1 /*
2 * HTTP address routines for CUPS.
3 *
4 * Copyright 2007-2014 by Apple Inc.
5 * Copyright 1997-2006 by Easy Software Products, all rights reserved.
6 *
7 * These coded instructions, statements, and computer programs are the
8 * property of Apple Inc. and are protected by Federal copyright
9 * law. Distribution and use rights are outlined in the file "LICENSE.txt"
10 * which should have been included with this file. If this file is
11 * missing or damaged, see the license at "http://www.cups.org/".
12 *
13 * This file is subject to the Apple OS-Developed Software exception.
14 */
15
16 /*
17 * Include necessary headers...
18 */
19
20 #include "cups-private.h"
21 #include <sys/stat.h>
22 #ifdef HAVE_RESOLV_H
23 # include <resolv.h>
24 #endif /* HAVE_RESOLV_H */
25 #ifdef __APPLE__
26 # include <CoreFoundation/CoreFoundation.h>
27 # include <SystemConfiguration/SystemConfiguration.h>
28 #endif /* __APPLE__ */
29
30
31 /*
32 * 'httpAddrAny()' - Check for the "any" address.
33 *
34 * @since CUPS 1.2/macOS 10.5@
35 */
36
37 int /* O - 1 if "any", 0 otherwise */
httpAddrAny(const http_addr_t * addr)38 httpAddrAny(const http_addr_t *addr) /* I - Address to check */
39 {
40 if (!addr)
41 return (0);
42
43 #ifdef AF_INET6
44 if (addr->addr.sa_family == AF_INET6 &&
45 IN6_IS_ADDR_UNSPECIFIED(&(addr->ipv6.sin6_addr)))
46 return (1);
47 #endif /* AF_INET6 */
48
49 if (addr->addr.sa_family == AF_INET &&
50 ntohl(addr->ipv4.sin_addr.s_addr) == 0x00000000)
51 return (1);
52
53 return (0);
54 }
55
56
57 /*
58 * 'httpAddrClose()' - Close a socket created by @link httpAddrConnect@ or
59 * @link httpAddrListen@.
60 *
61 * Pass @code NULL@ for sockets created with @link httpAddrConnect2@ and the
62 * listen address for sockets created with @link httpAddrListen@. This function
63 * ensures that domain sockets are removed when closed.
64 *
65 * @since CUPS 2.0/OS 10.10@
66 */
67
68 int /* O - 0 on success, -1 on failure */
httpAddrClose(http_addr_t * addr,int fd)69 httpAddrClose(http_addr_t *addr, /* I - Listen address or @code NULL@ */
70 int fd) /* I - Socket file descriptor */
71 {
72 #ifdef WIN32
73 if (closesocket(fd))
74 #else
75 if (close(fd))
76 #endif /* WIN32 */
77 return (-1);
78
79 #ifdef AF_LOCAL
80 if (addr && addr->addr.sa_family == AF_LOCAL)
81 return (unlink(addr->un.sun_path));
82 #endif /* AF_LOCAL */
83
84 return (0);
85 }
86
87
88 /*
89 * 'httpAddrEqual()' - Compare two addresses.
90 *
91 * @since CUPS 1.2/macOS 10.5@
92 */
93
94 int /* O - 1 if equal, 0 if not */
httpAddrEqual(const http_addr_t * addr1,const http_addr_t * addr2)95 httpAddrEqual(const http_addr_t *addr1, /* I - First address */
96 const http_addr_t *addr2) /* I - Second address */
97 {
98 if (!addr1 && !addr2)
99 return (1);
100
101 if (!addr1 || !addr2)
102 return (0);
103
104 if (addr1->addr.sa_family != addr2->addr.sa_family)
105 return (0);
106
107 #ifdef AF_LOCAL
108 if (addr1->addr.sa_family == AF_LOCAL)
109 return (!strcmp(addr1->un.sun_path, addr2->un.sun_path));
110 #endif /* AF_LOCAL */
111
112 #ifdef AF_INET6
113 if (addr1->addr.sa_family == AF_INET6)
114 return (!memcmp(&(addr1->ipv6.sin6_addr), &(addr2->ipv6.sin6_addr), 16));
115 #endif /* AF_INET6 */
116
117 return (addr1->ipv4.sin_addr.s_addr == addr2->ipv4.sin_addr.s_addr);
118 }
119
120
121 /*
122 * 'httpAddrLength()' - Return the length of the address in bytes.
123 *
124 * @since CUPS 1.2/macOS 10.5@
125 */
126
127 int /* O - Length in bytes */
httpAddrLength(const http_addr_t * addr)128 httpAddrLength(const http_addr_t *addr) /* I - Address */
129 {
130 if (!addr)
131 return (0);
132
133 #ifdef AF_INET6
134 if (addr->addr.sa_family == AF_INET6)
135 return (sizeof(addr->ipv6));
136 else
137 #endif /* AF_INET6 */
138 #ifdef AF_LOCAL
139 if (addr->addr.sa_family == AF_LOCAL)
140 return ((int)(offsetof(struct sockaddr_un, sun_path) + strlen(addr->un.sun_path) + 1));
141 else
142 #endif /* AF_LOCAL */
143 if (addr->addr.sa_family == AF_INET)
144 return (sizeof(addr->ipv4));
145 else
146 return (0);
147
148 }
149
150
151 /*
152 * 'httpAddrListen()' - Create a listening socket bound to the specified
153 * address and port.
154 *
155 * @since CUPS 1.7/macOS 10.9@
156 */
157
158 int /* O - Socket or -1 on error */
httpAddrListen(http_addr_t * addr,int port)159 httpAddrListen(http_addr_t *addr, /* I - Address to bind to */
160 int port) /* I - Port number to bind to */
161 {
162 int fd = -1, /* Socket */
163 val, /* Socket value */
164 status; /* Bind status */
165
166
167 /*
168 * Range check input...
169 */
170
171 if (!addr || port < 0)
172 return (-1);
173
174 /*
175 * Create the socket and set options...
176 */
177
178 if ((fd = socket(addr->addr.sa_family, SOCK_STREAM, 0)) < 0)
179 {
180 _cupsSetHTTPError(HTTP_STATUS_ERROR);
181 return (-1);
182 }
183
184 val = 1;
185 setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, CUPS_SOCAST &val, sizeof(val));
186
187 #ifdef IPV6_V6ONLY
188 if (addr->addr.sa_family == AF_INET6)
189 setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, CUPS_SOCAST &val, sizeof(val));
190 #endif /* IPV6_V6ONLY */
191
192 /*
193 * Bind the socket...
194 */
195
196 #ifdef AF_LOCAL
197 if (addr->addr.sa_family == AF_LOCAL)
198 {
199 mode_t mask; /* Umask setting */
200
201 /*
202 * Remove any existing domain socket file...
203 */
204
205 unlink(addr->un.sun_path);
206
207 /*
208 * Save the current umask and set it to 0 so that all users can access
209 * the domain socket...
210 */
211
212 mask = umask(0);
213
214 /*
215 * Bind the domain socket...
216 */
217
218 status = bind(fd, (struct sockaddr *)addr, (socklen_t)httpAddrLength(addr));
219
220 /*
221 * Restore the umask and fix permissions...
222 */
223
224 umask(mask);
225 chmod(addr->un.sun_path, 0140777);
226 }
227 else
228 #endif /* AF_LOCAL */
229 {
230 _httpAddrSetPort(addr, port);
231
232 status = bind(fd, (struct sockaddr *)addr, (socklen_t)httpAddrLength(addr));
233 }
234
235 if (status)
236 {
237 _cupsSetHTTPError(HTTP_STATUS_ERROR);
238
239 close(fd);
240
241 return (-1);
242 }
243
244 /*
245 * Listen...
246 */
247
248 if (listen(fd, 5))
249 {
250 _cupsSetHTTPError(HTTP_STATUS_ERROR);
251
252 close(fd);
253
254 return (-1);
255 }
256
257 /*
258 * Close on exec...
259 */
260
261 #ifndef WIN32
262 fcntl(fd, F_SETFD, fcntl(fd, F_GETFD) | FD_CLOEXEC);
263 #endif /* !WIN32 */
264
265 #ifdef SO_NOSIGPIPE
266 /*
267 * Disable SIGPIPE for this socket.
268 */
269
270 val = 1;
271 setsockopt(fd, SOL_SOCKET, SO_NOSIGPIPE, CUPS_SOCAST &val, sizeof(val));
272 #endif /* SO_NOSIGPIPE */
273
274 return (fd);
275 }
276
277
278 /*
279 * 'httpAddrLocalhost()' - Check for the local loopback address.
280 *
281 * @since CUPS 1.2/macOS 10.5@
282 */
283
284 int /* O - 1 if local host, 0 otherwise */
httpAddrLocalhost(const http_addr_t * addr)285 httpAddrLocalhost(
286 const http_addr_t *addr) /* I - Address to check */
287 {
288 if (!addr)
289 return (1);
290
291 #ifdef AF_INET6
292 if (addr->addr.sa_family == AF_INET6 &&
293 IN6_IS_ADDR_LOOPBACK(&(addr->ipv6.sin6_addr)))
294 return (1);
295 #endif /* AF_INET6 */
296
297 #ifdef AF_LOCAL
298 if (addr->addr.sa_family == AF_LOCAL)
299 return (1);
300 #endif /* AF_LOCAL */
301
302 if (addr->addr.sa_family == AF_INET &&
303 (ntohl(addr->ipv4.sin_addr.s_addr) & 0xff000000) == 0x7f000000)
304 return (1);
305
306 return (0);
307 }
308
309
310 /*
311 * 'httpAddrLookup()' - Lookup the hostname associated with the address.
312 *
313 * @since CUPS 1.2/macOS 10.5@
314 */
315
316 char * /* O - Host name */
httpAddrLookup(const http_addr_t * addr,char * name,int namelen)317 httpAddrLookup(
318 const http_addr_t *addr, /* I - Address to lookup */
319 char *name, /* I - Host name buffer */
320 int namelen) /* I - Size of name buffer */
321 {
322 _cups_globals_t *cg = _cupsGlobals();
323 /* Global data */
324
325
326 DEBUG_printf(("httpAddrLookup(addr=%p, name=%p, namelen=%d)", (void *)addr, (void *)name, namelen));
327
328 /*
329 * Range check input...
330 */
331
332 if (!addr || !name || namelen <= 2)
333 {
334 if (name && namelen >= 1)
335 *name = '\0';
336
337 return (NULL);
338 }
339
340 #ifdef AF_LOCAL
341 if (addr->addr.sa_family == AF_LOCAL)
342 {
343 strlcpy(name, addr->un.sun_path, (size_t)namelen);
344 return (name);
345 }
346 #endif /* AF_LOCAL */
347
348 /*
349 * Optimize lookups for localhost/loopback addresses...
350 */
351
352 if (httpAddrLocalhost(addr))
353 {
354 strlcpy(name, "localhost", (size_t)namelen);
355 return (name);
356 }
357
358 #ifdef HAVE_RES_INIT
359 /*
360 * STR #2920: Initialize resolver after failure in cups-polld
361 *
362 * If the previous lookup failed, re-initialize the resolver to prevent
363 * temporary network errors from persisting. This *should* be handled by
364 * the resolver libraries, but apparently the glibc folks do not agree.
365 *
366 * We set a flag at the end of this function if we encounter an error that
367 * requires reinitialization of the resolver functions. We then call
368 * res_init() if the flag is set on the next call here or in httpAddrLookup().
369 */
370
371 if (cg->need_res_init)
372 {
373 res_init();
374
375 cg->need_res_init = 0;
376 }
377 #endif /* HAVE_RES_INIT */
378
379 #ifdef HAVE_GETNAMEINFO
380 {
381 /*
382 * STR #2486: httpAddrLookup() fails when getnameinfo() returns EAI_AGAIN
383 *
384 * FWIW, I think this is really a bug in the implementation of
385 * getnameinfo(), but falling back on httpAddrString() is easy to
386 * do...
387 */
388
389 int error = getnameinfo(&addr->addr, (socklen_t)httpAddrLength(addr), name, (socklen_t)namelen, NULL, 0, 0);
390
391 if (error)
392 {
393 if (error == EAI_FAIL)
394 cg->need_res_init = 1;
395
396 return (httpAddrString(addr, name, namelen));
397 }
398 }
399 #else
400 {
401 struct hostent *host; /* Host from name service */
402
403
404 # ifdef AF_INET6
405 if (addr->addr.sa_family == AF_INET6)
406 host = gethostbyaddr((char *)&(addr->ipv6.sin6_addr),
407 sizeof(struct in_addr), AF_INET6);
408 else
409 # endif /* AF_INET6 */
410 host = gethostbyaddr((char *)&(addr->ipv4.sin_addr),
411 sizeof(struct in_addr), AF_INET);
412
413 if (host == NULL)
414 {
415 /*
416 * No hostname, so return the raw address...
417 */
418
419 if (h_errno == NO_RECOVERY)
420 cg->need_res_init = 1;
421
422 return (httpAddrString(addr, name, namelen));
423 }
424
425 strlcpy(name, host->h_name, (size_t)namelen);
426 }
427 #endif /* HAVE_GETNAMEINFO */
428
429 DEBUG_printf(("1httpAddrLookup: returning \"%s\"...", name));
430
431 return (name);
432 }
433
434
435 /*
436 * 'httpAddrFamily()' - Get the address family of an address.
437 */
438
439 int /* O - Address family */
httpAddrFamily(http_addr_t * addr)440 httpAddrFamily(http_addr_t *addr) /* I - Address */
441 {
442 if (addr)
443 return (addr->addr.sa_family);
444 else
445 return (0);
446 }
447
448
449 /*
450 * 'httpAddrPort()' - Get the port number associated with an address.
451 *
452 * @since CUPS 1.7/macOS 10.9@
453 */
454
455 int /* O - Port number */
httpAddrPort(http_addr_t * addr)456 httpAddrPort(http_addr_t *addr) /* I - Address */
457 {
458 if (!addr)
459 return (-1);
460 #ifdef AF_INET6
461 else if (addr->addr.sa_family == AF_INET6)
462 return (ntohs(addr->ipv6.sin6_port));
463 #endif /* AF_INET6 */
464 else if (addr->addr.sa_family == AF_INET)
465 return (ntohs(addr->ipv4.sin_port));
466 else
467 return (0);
468 }
469
470
471 /*
472 * '_httpAddrSetPort()' - Set the port number associated with an address.
473 */
474
475 void
_httpAddrSetPort(http_addr_t * addr,int port)476 _httpAddrSetPort(http_addr_t *addr, /* I - Address */
477 int port) /* I - Port */
478 {
479 if (!addr || port <= 0)
480 return;
481
482 #ifdef AF_INET6
483 if (addr->addr.sa_family == AF_INET6)
484 addr->ipv6.sin6_port = htons(port);
485 else
486 #endif /* AF_INET6 */
487 if (addr->addr.sa_family == AF_INET)
488 addr->ipv4.sin_port = htons(port);
489 }
490
491
492 /*
493 * 'httpAddrString()' - Convert an address to a numeric string.
494 *
495 * @since CUPS 1.2/macOS 10.5@
496 */
497
498 char * /* O - Numeric address string */
httpAddrString(const http_addr_t * addr,char * s,int slen)499 httpAddrString(const http_addr_t *addr, /* I - Address to convert */
500 char *s, /* I - String buffer */
501 int slen) /* I - Length of string */
502 {
503 DEBUG_printf(("httpAddrString(addr=%p, s=%p, slen=%d)", (void *)addr, (void *)s, slen));
504
505 /*
506 * Range check input...
507 */
508
509 if (!addr || !s || slen <= 2)
510 {
511 if (s && slen >= 1)
512 *s = '\0';
513
514 return (NULL);
515 }
516
517 #ifdef AF_LOCAL
518 if (addr->addr.sa_family == AF_LOCAL)
519 {
520 if (addr->un.sun_path[0] == '/')
521 strlcpy(s, addr->un.sun_path, (size_t)slen);
522 else
523 strlcpy(s, "localhost", (size_t)slen);
524 }
525 else
526 #endif /* AF_LOCAL */
527 if (addr->addr.sa_family == AF_INET)
528 {
529 unsigned temp; /* Temporary address */
530
531 temp = ntohl(addr->ipv4.sin_addr.s_addr);
532
533 snprintf(s, (size_t)slen, "%d.%d.%d.%d", (temp >> 24) & 255,
534 (temp >> 16) & 255, (temp >> 8) & 255, temp & 255);
535 }
536 #ifdef AF_INET6
537 else if (addr->addr.sa_family == AF_INET6)
538 {
539 char *sptr, /* Pointer into string */
540 temps[64]; /* Temporary string for address */
541
542 # ifdef HAVE_GETNAMEINFO
543 if (getnameinfo(&addr->addr, (socklen_t)httpAddrLength(addr), temps, sizeof(temps), NULL, 0, NI_NUMERICHOST))
544 {
545 /*
546 * If we get an error back, then the address type is not supported
547 * and we should zero out the buffer...
548 */
549
550 s[0] = '\0';
551
552 return (NULL);
553 }
554 else if ((sptr = strchr(temps, '%')) != NULL)
555 {
556 /*
557 * Convert "%zone" to "+zone" to match URI form...
558 */
559
560 *sptr = '+';
561 }
562
563 # else
564 int i; /* Looping var */
565 unsigned temp; /* Current value */
566 const char *prefix; /* Prefix for address */
567
568
569 prefix = "";
570 for (sptr = temps, i = 0; i < 4 && addr->ipv6.sin6_addr.s6_addr32[i]; i ++)
571 {
572 temp = ntohl(addr->ipv6.sin6_addr.s6_addr32[i]);
573
574 snprintf(sptr, sizeof(temps) - (size_t)(sptr - temps), "%s%x", prefix, (temp >> 16) & 0xffff);
575 prefix = ":";
576 sptr += strlen(sptr);
577
578 temp &= 0xffff;
579
580 if (temp || i == 3 || addr->ipv6.sin6_addr.s6_addr32[i + 1])
581 {
582 snprintf(sptr, sizeof(temps) - (size_t)(sptr - temps), "%s%x", prefix, temp);
583 sptr += strlen(sptr);
584 }
585 }
586
587 if (i < 4)
588 {
589 while (i < 4 && !addr->ipv6.sin6_addr.s6_addr32[i])
590 i ++;
591
592 if (i < 4)
593 {
594 snprintf(sptr, sizeof(temps) - (size_t)(sptr - temps), "%s:", prefix);
595 prefix = ":";
596 sptr += strlen(sptr);
597
598 for (; i < 4; i ++)
599 {
600 temp = ntohl(addr->ipv6.sin6_addr.s6_addr32[i]);
601
602 if ((temp & 0xffff0000) ||
603 (i > 0 && addr->ipv6.sin6_addr.s6_addr32[i - 1]))
604 {
605 snprintf(sptr, sizeof(temps) - (size_t)(sptr - temps), "%s%x", prefix, (temp >> 16) & 0xffff);
606 sptr += strlen(sptr);
607 }
608
609 snprintf(sptr, sizeof(temps) - (size_t)(sptr - temps), "%s%x", prefix, temp & 0xffff);
610 sptr += strlen(sptr);
611 }
612 }
613 else if (sptr == s)
614 {
615 /*
616 * Empty address...
617 */
618
619 strlcpy(temps, "::", sizeof(temps));
620 }
621 else
622 {
623 /*
624 * Empty at end...
625 */
626
627 strlcpy(sptr, "::", sizeof(temps) - (size_t)(sptr - temps));
628 }
629 }
630 # endif /* HAVE_GETNAMEINFO */
631
632 /*
633 * Add "[v1." and "]" around IPv6 address to convert to URI form.
634 */
635
636 snprintf(s, (size_t)slen, "[v1.%s]", temps);
637 }
638 #endif /* AF_INET6 */
639 else
640 strlcpy(s, "UNKNOWN", (size_t)slen);
641
642 DEBUG_printf(("1httpAddrString: returning \"%s\"...", s));
643
644 return (s);
645 }
646
647
648 /*
649 * 'httpGetAddress()' - Get the address of the connected peer of a connection.
650 *
651 * For connections created with @link httpConnect2@, the address is for the
652 * server. For connections created with @link httpAccept@, the address is for
653 * the client.
654 *
655 * Returns @code NULL@ if the socket is currently unconnected.
656 *
657 * @since CUPS 2.0/OS 10.10@
658 */
659
660 http_addr_t * /* O - Connected address or @code NULL@ */
httpGetAddress(http_t * http)661 httpGetAddress(http_t *http) /* I - HTTP connection */
662 {
663 if (http)
664 return (http->hostaddr);
665 else
666 return (NULL);
667 }
668
669
670 /*
671 * 'httpGetHostByName()' - Lookup a hostname or IPv4 address, and return
672 * address records for the specified name.
673 *
674 * @deprecated@ @exclude all@
675 */
676
677 struct hostent * /* O - Host entry */
httpGetHostByName(const char * name)678 httpGetHostByName(const char *name) /* I - Hostname or IP address */
679 {
680 const char *nameptr; /* Pointer into name */
681 unsigned ip[4]; /* IP address components */
682 _cups_globals_t *cg = _cupsGlobals();
683 /* Pointer to library globals */
684
685
686 DEBUG_printf(("httpGetHostByName(name=\"%s\")", name));
687
688 /*
689 * Avoid lookup delays and configuration problems when connecting
690 * to the localhost address...
691 */
692
693 if (!strcmp(name, "localhost"))
694 name = "127.0.0.1";
695
696 /*
697 * This function is needed because some operating systems have a
698 * buggy implementation of gethostbyname() that does not support
699 * IP addresses. If the first character of the name string is a
700 * number, then sscanf() is used to extract the IP components.
701 * We then pack the components into an IPv4 address manually,
702 * since the inet_aton() function is deprecated. We use the
703 * htonl() macro to get the right byte order for the address.
704 *
705 * We also support domain sockets when supported by the underlying
706 * OS...
707 */
708
709 #ifdef AF_LOCAL
710 if (name[0] == '/')
711 {
712 /*
713 * A domain socket address, so make an AF_LOCAL entry and return it...
714 */
715
716 cg->hostent.h_name = (char *)name;
717 cg->hostent.h_aliases = NULL;
718 cg->hostent.h_addrtype = AF_LOCAL;
719 cg->hostent.h_length = (int)strlen(name) + 1;
720 cg->hostent.h_addr_list = cg->ip_ptrs;
721 cg->ip_ptrs[0] = (char *)name;
722 cg->ip_ptrs[1] = NULL;
723
724 DEBUG_puts("1httpGetHostByName: returning domain socket address...");
725
726 return (&cg->hostent);
727 }
728 #endif /* AF_LOCAL */
729
730 for (nameptr = name; isdigit(*nameptr & 255) || *nameptr == '.'; nameptr ++);
731
732 if (!*nameptr)
733 {
734 /*
735 * We have an IPv4 address; break it up and provide the host entry
736 * to the caller.
737 */
738
739 if (sscanf(name, "%u.%u.%u.%u", ip, ip + 1, ip + 2, ip + 3) != 4)
740 return (NULL); /* Must have 4 numbers */
741
742 if (ip[0] > 255 || ip[1] > 255 || ip[2] > 255 || ip[3] > 255)
743 return (NULL); /* Invalid byte ranges! */
744
745 cg->ip_addr = htonl((((((((unsigned)ip[0] << 8) | (unsigned)ip[1]) << 8) |
746 (unsigned)ip[2]) << 8) |
747 (unsigned)ip[3]));
748
749 /*
750 * Fill in the host entry and return it...
751 */
752
753 cg->hostent.h_name = (char *)name;
754 cg->hostent.h_aliases = NULL;
755 cg->hostent.h_addrtype = AF_INET;
756 cg->hostent.h_length = 4;
757 cg->hostent.h_addr_list = cg->ip_ptrs;
758 cg->ip_ptrs[0] = (char *)&(cg->ip_addr);
759 cg->ip_ptrs[1] = NULL;
760
761 DEBUG_puts("1httpGetHostByName: returning IPv4 address...");
762
763 return (&cg->hostent);
764 }
765 else
766 {
767 /*
768 * Use the gethostbyname() function to get the IPv4 address for
769 * the name...
770 */
771
772 DEBUG_puts("1httpGetHostByName: returning domain lookup address(es)...");
773
774 return (gethostbyname(name));
775 }
776 }
777
778
779 /*
780 * 'httpGetHostname()' - Get the FQDN for the connection or local system.
781 *
782 * When "http" points to a connected socket, return the hostname or
783 * address that was used in the call to httpConnect() or httpConnectEncrypt(),
784 * or the address of the client for the connection from httpAcceptConnection().
785 * Otherwise, return the FQDN for the local system using both gethostname()
786 * and gethostbyname() to get the local hostname with domain.
787 *
788 * @since CUPS 1.2/macOS 10.5@
789 */
790
791 const char * /* O - FQDN for connection or system */
httpGetHostname(http_t * http,char * s,int slen)792 httpGetHostname(http_t *http, /* I - HTTP connection or NULL */
793 char *s, /* I - String buffer for name */
794 int slen) /* I - Size of buffer */
795 {
796 if (http)
797 {
798 if (!s || slen <= 1)
799 {
800 if (http->hostname[0] == '/')
801 return ("localhost");
802 else
803 return (http->hostname);
804 }
805 else if (http->hostname[0] == '/')
806 strlcpy(s, "localhost", (size_t)slen);
807 else
808 strlcpy(s, http->hostname, (size_t)slen);
809 }
810 else
811 {
812 /*
813 * Get the hostname...
814 */
815
816 if (!s || slen <= 1)
817 return (NULL);
818
819 if (gethostname(s, (size_t)slen) < 0)
820 strlcpy(s, "localhost", (size_t)slen);
821
822 if (!strchr(s, '.'))
823 {
824 #ifdef HAVE_SCDYNAMICSTORECOPYCOMPUTERNAME
825 /*
826 * The hostname is not a FQDN, so use the local hostname from the
827 * SystemConfiguration framework...
828 */
829
830 SCDynamicStoreRef sc = SCDynamicStoreCreate(kCFAllocatorDefault,
831 CFSTR("libcups"), NULL, NULL);
832 /* System configuration data */
833 CFStringRef local = sc ? SCDynamicStoreCopyLocalHostName(sc) : NULL;
834 /* Local host name */
835 char localStr[1024]; /* Local host name C string */
836
837 if (local && CFStringGetCString(local, localStr, sizeof(localStr),
838 kCFStringEncodingUTF8))
839 {
840 /*
841 * Append ".local." to the hostname we get...
842 */
843
844 snprintf(s, (size_t)slen, "%s.local.", localStr);
845 }
846
847 if (local)
848 CFRelease(local);
849 if (sc)
850 CFRelease(sc);
851
852 #else
853 /*
854 * The hostname is not a FQDN, so look it up...
855 */
856
857 struct hostent *host; /* Host entry to get FQDN */
858
859 if ((host = gethostbyname(s)) != NULL && host->h_name)
860 {
861 /*
862 * Use the resolved hostname...
863 */
864
865 strlcpy(s, host->h_name, (size_t)slen);
866 }
867 #endif /* HAVE_SCDYNAMICSTORECOPYCOMPUTERNAME */
868 }
869
870 /*
871 * Make sure .local hostnames end with a period...
872 */
873
874 if (strlen(s) > 6 && !strcmp(s + strlen(s) - 6, ".local"))
875 strlcat(s, ".", (size_t)slen);
876 }
877
878 /*
879 * Convert the hostname to lowercase as needed...
880 */
881
882 if (s[0] != '/')
883 {
884 char *ptr; /* Pointer into string */
885
886 for (ptr = s; *ptr; ptr ++)
887 *ptr = (char)_cups_tolower((int)*ptr);
888 }
889
890 /*
891 * Return the hostname with as much domain info as we have...
892 */
893
894 return (s);
895 }
896
897
898 /*
899 * 'httpResolveHostname()' - Resolve the hostname of the HTTP connection
900 * address.
901 *
902 * @since CUPS 2.0/OS 10.10@
903 */
904
905 const char * /* O - Resolved hostname or @code NULL@ */
httpResolveHostname(http_t * http,char * buffer,size_t bufsize)906 httpResolveHostname(http_t *http, /* I - HTTP connection */
907 char *buffer, /* I - Hostname buffer */
908 size_t bufsize) /* I - Size of buffer */
909 {
910 if (!http)
911 return (NULL);
912
913 if (isdigit(http->hostname[0] & 255) || http->hostname[0] == '[')
914 {
915 char temp[1024]; /* Temporary string */
916
917 if (httpAddrLookup(http->hostaddr, temp, sizeof(temp)))
918 strlcpy(http->hostname, temp, sizeof(http->hostname));
919 else
920 return (NULL);
921 }
922
923 if (buffer)
924 {
925 if (http->hostname[0] == '/')
926 strlcpy(buffer, "localhost", bufsize);
927 else
928 strlcpy(buffer, http->hostname, bufsize);
929
930 return (buffer);
931 }
932 else if (http->hostname[0] == '/')
933 return ("localhost");
934 else
935 return (http->hostname);
936 }
937