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 httpAddrConnect@ and the
62 * listen address for sockets created with @link httpAddrListen@. This will
63 * ensure 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 * Returns @code NULL@ if the socket is currently unconnected.
652 *
653 * @since CUPS 2.0/OS 10.10@
654 */
655
656 http_addr_t * /* O - Connected address or @code NULL@ */
httpGetAddress(http_t * http)657 httpGetAddress(http_t *http) /* I - HTTP connection */
658 {
659 if (http)
660 return (http->hostaddr);
661 else
662 return (NULL);
663 }
664
665
666 /*
667 * 'httpGetHostByName()' - Lookup a hostname or IPv4 address, and return
668 * address records for the specified name.
669 *
670 * @deprecated@
671 */
672
673 struct hostent * /* O - Host entry */
httpGetHostByName(const char * name)674 httpGetHostByName(const char *name) /* I - Hostname or IP address */
675 {
676 const char *nameptr; /* Pointer into name */
677 unsigned ip[4]; /* IP address components */
678 _cups_globals_t *cg = _cupsGlobals();
679 /* Pointer to library globals */
680
681
682 DEBUG_printf(("httpGetHostByName(name=\"%s\")", name));
683
684 /*
685 * Avoid lookup delays and configuration problems when connecting
686 * to the localhost address...
687 */
688
689 if (!strcmp(name, "localhost"))
690 name = "127.0.0.1";
691
692 /*
693 * This function is needed because some operating systems have a
694 * buggy implementation of gethostbyname() that does not support
695 * IP addresses. If the first character of the name string is a
696 * number, then sscanf() is used to extract the IP components.
697 * We then pack the components into an IPv4 address manually,
698 * since the inet_aton() function is deprecated. We use the
699 * htonl() macro to get the right byte order for the address.
700 *
701 * We also support domain sockets when supported by the underlying
702 * OS...
703 */
704
705 #ifdef AF_LOCAL
706 if (name[0] == '/')
707 {
708 /*
709 * A domain socket address, so make an AF_LOCAL entry and return it...
710 */
711
712 cg->hostent.h_name = (char *)name;
713 cg->hostent.h_aliases = NULL;
714 cg->hostent.h_addrtype = AF_LOCAL;
715 cg->hostent.h_length = (int)strlen(name) + 1;
716 cg->hostent.h_addr_list = cg->ip_ptrs;
717 cg->ip_ptrs[0] = (char *)name;
718 cg->ip_ptrs[1] = NULL;
719
720 DEBUG_puts("1httpGetHostByName: returning domain socket address...");
721
722 return (&cg->hostent);
723 }
724 #endif /* AF_LOCAL */
725
726 for (nameptr = name; isdigit(*nameptr & 255) || *nameptr == '.'; nameptr ++);
727
728 if (!*nameptr)
729 {
730 /*
731 * We have an IPv4 address; break it up and provide the host entry
732 * to the caller.
733 */
734
735 if (sscanf(name, "%u.%u.%u.%u", ip, ip + 1, ip + 2, ip + 3) != 4)
736 return (NULL); /* Must have 4 numbers */
737
738 if (ip[0] > 255 || ip[1] > 255 || ip[2] > 255 || ip[3] > 255)
739 return (NULL); /* Invalid byte ranges! */
740
741 cg->ip_addr = htonl((((((((unsigned)ip[0] << 8) | (unsigned)ip[1]) << 8) |
742 (unsigned)ip[2]) << 8) |
743 (unsigned)ip[3]));
744
745 /*
746 * Fill in the host entry and return it...
747 */
748
749 cg->hostent.h_name = (char *)name;
750 cg->hostent.h_aliases = NULL;
751 cg->hostent.h_addrtype = AF_INET;
752 cg->hostent.h_length = 4;
753 cg->hostent.h_addr_list = cg->ip_ptrs;
754 cg->ip_ptrs[0] = (char *)&(cg->ip_addr);
755 cg->ip_ptrs[1] = NULL;
756
757 DEBUG_puts("1httpGetHostByName: returning IPv4 address...");
758
759 return (&cg->hostent);
760 }
761 else
762 {
763 /*
764 * Use the gethostbyname() function to get the IPv4 address for
765 * the name...
766 */
767
768 DEBUG_puts("1httpGetHostByName: returning domain lookup address(es)...");
769
770 return (gethostbyname(name));
771 }
772 }
773
774
775 /*
776 * 'httpGetHostname()' - Get the FQDN for the connection or local system.
777 *
778 * When "http" points to a connected socket, return the hostname or
779 * address that was used in the call to httpConnect() or httpConnectEncrypt(),
780 * or the address of the client for the connection from httpAcceptConnection().
781 * Otherwise, return the FQDN for the local system using both gethostname()
782 * and gethostbyname() to get the local hostname with domain.
783 *
784 * @since CUPS 1.2/macOS 10.5@
785 */
786
787 const char * /* O - FQDN for connection or system */
httpGetHostname(http_t * http,char * s,int slen)788 httpGetHostname(http_t *http, /* I - HTTP connection or NULL */
789 char *s, /* I - String buffer for name */
790 int slen) /* I - Size of buffer */
791 {
792 if (http)
793 {
794 if (!s || slen <= 1)
795 {
796 if (http->hostname[0] == '/')
797 return ("localhost");
798 else
799 return (http->hostname);
800 }
801 else if (http->hostname[0] == '/')
802 strlcpy(s, "localhost", (size_t)slen);
803 else
804 strlcpy(s, http->hostname, (size_t)slen);
805 }
806 else
807 {
808 /*
809 * Get the hostname...
810 */
811
812 if (!s || slen <= 1)
813 return (NULL);
814
815 if (gethostname(s, (size_t)slen) < 0)
816 strlcpy(s, "localhost", (size_t)slen);
817
818 if (!strchr(s, '.'))
819 {
820 #ifdef HAVE_SCDYNAMICSTORECOPYCOMPUTERNAME
821 /*
822 * The hostname is not a FQDN, so use the local hostname from the
823 * SystemConfiguration framework...
824 */
825
826 SCDynamicStoreRef sc = SCDynamicStoreCreate(kCFAllocatorDefault,
827 CFSTR("libcups"), NULL, NULL);
828 /* System configuration data */
829 CFStringRef local = sc ? SCDynamicStoreCopyLocalHostName(sc) : NULL;
830 /* Local host name */
831 char localStr[1024]; /* Local host name C string */
832
833 if (local && CFStringGetCString(local, localStr, sizeof(localStr),
834 kCFStringEncodingUTF8))
835 {
836 /*
837 * Append ".local." to the hostname we get...
838 */
839
840 snprintf(s, (size_t)slen, "%s.local.", localStr);
841 }
842
843 if (local)
844 CFRelease(local);
845 if (sc)
846 CFRelease(sc);
847
848 #else
849 /*
850 * The hostname is not a FQDN, so look it up...
851 */
852
853 struct hostent *host; /* Host entry to get FQDN */
854
855 if ((host = gethostbyname(s)) != NULL && host->h_name)
856 {
857 /*
858 * Use the resolved hostname...
859 */
860
861 strlcpy(s, host->h_name, (size_t)slen);
862 }
863 #endif /* HAVE_SCDYNAMICSTORECOPYCOMPUTERNAME */
864 }
865
866 /*
867 * Make sure .local hostnames end with a period...
868 */
869
870 if (strlen(s) > 6 && !strcmp(s + strlen(s) - 6, ".local"))
871 strlcat(s, ".", (size_t)slen);
872 }
873
874 /*
875 * Convert the hostname to lowercase as needed...
876 */
877
878 if (s[0] != '/')
879 {
880 char *ptr; /* Pointer into string */
881
882 for (ptr = s; *ptr; ptr ++)
883 *ptr = (char)_cups_tolower((int)*ptr);
884 }
885
886 /*
887 * Return the hostname with as much domain info as we have...
888 */
889
890 return (s);
891 }
892
893
894 /*
895 * 'httpResolveHostname()' - Resolve the hostname of the HTTP connection
896 * address.
897 *
898 * @since CUPS 2.0/OS 10.10@
899 */
900
901 const char * /* O - Resolved hostname or @code NULL@ */
httpResolveHostname(http_t * http,char * buffer,size_t bufsize)902 httpResolveHostname(http_t *http, /* I - HTTP connection */
903 char *buffer, /* I - Hostname buffer */
904 size_t bufsize) /* I - Size of buffer */
905 {
906 if (!http)
907 return (NULL);
908
909 if (isdigit(http->hostname[0] & 255) || http->hostname[0] == '[')
910 {
911 char temp[1024]; /* Temporary string */
912
913 if (httpAddrLookup(http->hostaddr, temp, sizeof(temp)))
914 strlcpy(http->hostname, temp, sizeof(http->hostname));
915 else
916 return (NULL);
917 }
918
919 if (buffer)
920 {
921 if (http->hostname[0] == '/')
922 strlcpy(buffer, "localhost", bufsize);
923 else
924 strlcpy(buffer, http->hostname, bufsize);
925
926 return (buffer);
927 }
928 else if (http->hostname[0] == '/')
929 return ("localhost");
930 else
931 return (http->hostname);
932 }
933