]> git.ipfire.org Git - thirdparty/cups.git/blob - cups/http-addr.c
a3a628c54a012db52042d1024ca391e0ea8719c7
[thirdparty/cups.git] / cups / http-addr.c
1 /*
2 * "$Id$"
3 *
4 * HTTP address routines for CUPS.
5 *
6 * Copyright 2007-2014 by Apple Inc.
7 * Copyright 1997-2006 by Easy Software Products, all rights reserved.
8 *
9 * These coded instructions, statements, and computer programs are the
10 * property of Apple Inc. and are protected by Federal copyright
11 * law. Distribution and use rights are outlined in the file "LICENSE.txt"
12 * which should have been included with this file. If this file is
13 * file is missing or damaged, see the license at "http://www.cups.org/".
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/OS X 10.5@
35 */
36
37 int /* O - 1 if "any", 0 otherwise */
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@
66 */
67
68 int /* O - 0 on success, -1 on failure */
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/OS X 10.5@
92 */
93
94 int /* O - 1 if equal, 0 if not */
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/OS X 10.5@
125 */
126
127 int /* O - Length in bytes */
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/OS X 10.9@
156 */
157
158 int /* O - Socket or -1 on error */
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/OS X 10.5@
282 */
283
284 int /* O - 1 if local host, 0 otherwise */
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/OS X 10.5@
314 */
315
316 char * /* O - Host name */
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)", addr, name,
327 namelen));
328
329 /*
330 * Range check input...
331 */
332
333 if (!addr || !name || namelen <= 2)
334 {
335 if (name && namelen >= 1)
336 *name = '\0';
337
338 return (NULL);
339 }
340
341 #ifdef AF_LOCAL
342 if (addr->addr.sa_family == AF_LOCAL)
343 {
344 strlcpy(name, addr->un.sun_path, namelen);
345 return (name);
346 }
347 #endif /* AF_LOCAL */
348
349 /*
350 * Optimize lookups for localhost/loopback addresses...
351 */
352
353 if (httpAddrLocalhost(addr))
354 {
355 strlcpy(name, "localhost", namelen);
356 return (name);
357 }
358
359 #ifdef HAVE_RES_INIT
360 /*
361 * STR #2920: Initialize resolver after failure in cups-polld
362 *
363 * If the previous lookup failed, re-initialize the resolver to prevent
364 * temporary network errors from persisting. This *should* be handled by
365 * the resolver libraries, but apparently the glibc folks do not agree.
366 *
367 * We set a flag at the end of this function if we encounter an error that
368 * requires reinitialization of the resolver functions. We then call
369 * res_init() if the flag is set on the next call here or in httpAddrLookup().
370 */
371
372 if (cg->need_res_init)
373 {
374 res_init();
375
376 cg->need_res_init = 0;
377 }
378 #endif /* HAVE_RES_INIT */
379
380 #ifdef HAVE_GETNAMEINFO
381 {
382 /*
383 * STR #2486: httpAddrLookup() fails when getnameinfo() returns EAI_AGAIN
384 *
385 * FWIW, I think this is really a bug in the implementation of
386 * getnameinfo(), but falling back on httpAddrString() is easy to
387 * do...
388 */
389
390 int error = getnameinfo(&addr->addr, (socklen_t)httpAddrLength(addr), name, (socklen_t)namelen, NULL, 0, 0);
391
392 if (error)
393 {
394 if (error == EAI_FAIL)
395 cg->need_res_init = 1;
396
397 return (httpAddrString(addr, name, namelen));
398 }
399 }
400 #else
401 {
402 struct hostent *host; /* Host from name service */
403
404
405 # ifdef AF_INET6
406 if (addr->addr.sa_family == AF_INET6)
407 host = gethostbyaddr((char *)&(addr->ipv6.sin6_addr),
408 sizeof(struct in_addr), AF_INET6);
409 else
410 # endif /* AF_INET6 */
411 host = gethostbyaddr((char *)&(addr->ipv4.sin_addr),
412 sizeof(struct in_addr), AF_INET);
413
414 if (host == NULL)
415 {
416 /*
417 * No hostname, so return the raw address...
418 */
419
420 if (h_errno == NO_RECOVERY)
421 cg->need_res_init = 1;
422
423 return (httpAddrString(addr, name, namelen));
424 }
425
426 strlcpy(name, host->h_name, namelen);
427 }
428 #endif /* HAVE_GETNAMEINFO */
429
430 DEBUG_printf(("1httpAddrLookup: returning \"%s\"...", name));
431
432 return (name);
433 }
434
435
436 /*
437 * 'httpAddrFamily()' - Get the address family of an address.
438 */
439
440 int /* O - Address family */
441 httpAddrFamily(http_addr_t *addr) /* I - Address */
442 {
443 if (addr)
444 return (addr->addr.sa_family);
445 else
446 return (0);
447 }
448
449
450 /*
451 * 'httpAddrPort()' - Get the port number associated with an address.
452 *
453 * @since CUPS 1.7/OS X 10.9@
454 */
455
456 int /* O - Port number */
457 httpAddrPort(http_addr_t *addr) /* I - Address */
458 {
459 if (!addr)
460 return (-1);
461 #ifdef AF_INET6
462 else if (addr->addr.sa_family == AF_INET6)
463 return (ntohs(addr->ipv6.sin6_port));
464 #endif /* AF_INET6 */
465 else if (addr->addr.sa_family == AF_INET)
466 return (ntohs(addr->ipv4.sin_port));
467 else
468 return (0);
469 }
470
471
472 /*
473 * '_httpAddrSetPort()' - Set the port number associated with an address.
474 */
475
476 void
477 _httpAddrSetPort(http_addr_t *addr, /* I - Address */
478 int port) /* I - Port */
479 {
480 if (!addr || port <= 0)
481 return;
482
483 #ifdef AF_INET6
484 if (addr->addr.sa_family == AF_INET6)
485 addr->ipv6.sin6_port = htons(port);
486 else
487 #endif /* AF_INET6 */
488 if (addr->addr.sa_family == AF_INET)
489 addr->ipv4.sin_port = htons(port);
490 }
491
492
493 /*
494 * 'httpAddrString()' - Convert an address to a numeric string.
495 *
496 * @since CUPS 1.2/OS X 10.5@
497 */
498
499 char * /* O - Numeric address string */
500 httpAddrString(const http_addr_t *addr, /* I - Address to convert */
501 char *s, /* I - String buffer */
502 int slen) /* I - Length of string */
503 {
504 DEBUG_printf(("httpAddrString(addr=%p, s=%p, slen=%d)", addr, s, slen));
505
506 /*
507 * Range check input...
508 */
509
510 if (!addr || !s || slen <= 2)
511 {
512 if (s && slen >= 1)
513 *s = '\0';
514
515 return (NULL);
516 }
517
518 #ifdef AF_LOCAL
519 if (addr->addr.sa_family == AF_LOCAL)
520 {
521 if (addr->un.sun_path[0] == '/')
522 strlcpy(s, addr->un.sun_path, slen);
523 else
524 strlcpy(s, "localhost", slen);
525 }
526 else
527 #endif /* AF_LOCAL */
528 if (addr->addr.sa_family == AF_INET)
529 {
530 unsigned temp; /* Temporary address */
531
532
533 temp = ntohl(addr->ipv4.sin_addr.s_addr);
534
535 snprintf(s, slen, "%d.%d.%d.%d", (temp >> 24) & 255,
536 (temp >> 16) & 255, (temp >> 8) & 255, temp & 255);
537 }
538 #ifdef AF_INET6
539 else if (addr->addr.sa_family == AF_INET6)
540 {
541 char *sptr, /* Pointer into string */
542 temps[64]; /* Temporary string for address */
543
544 # ifdef HAVE_GETNAMEINFO
545 if (getnameinfo(&addr->addr, (socklen_t)httpAddrLength(addr), temps, sizeof(temps), NULL, 0, NI_NUMERICHOST))
546 {
547 /*
548 * If we get an error back, then the address type is not supported
549 * and we should zero out the buffer...
550 */
551
552 s[0] = '\0';
553
554 return (NULL);
555 }
556 else if ((sptr = strchr(temps, '%')) != NULL)
557 {
558 /*
559 * Convert "%zone" to "+zone" to match URI form...
560 */
561
562 *sptr = '+';
563 }
564
565 # else
566 int i; /* Looping var */
567 unsigned temp; /* Current value */
568 const char *prefix; /* Prefix for address */
569
570
571 prefix = "";
572 for (sptr = temps, i = 0; i < 4 && addr->ipv6.sin6_addr.s6_addr32[i]; i ++)
573 {
574 temp = ntohl(addr->ipv6.sin6_addr.s6_addr32[i]);
575
576 snprintf(sptr, sizeof(temps) - (sptr - temps), "%s%x", prefix,
577 (temp >> 16) & 0xffff);
578 prefix = ":";
579 sptr += strlen(sptr);
580
581 temp &= 0xffff;
582
583 if (temp || i == 3 || addr->ipv6.sin6_addr.s6_addr32[i + 1])
584 {
585 snprintf(sptr, sizeof(temps) - (sptr - temps), "%s%x", prefix, temp);
586 sptr += strlen(sptr);
587 }
588 }
589
590 if (i < 4)
591 {
592 while (i < 4 && !addr->ipv6.sin6_addr.s6_addr32[i])
593 i ++;
594
595 if (i < 4)
596 {
597 snprintf(sptr, sizeof(temps) - (sptr - temps), "%s:", prefix);
598 prefix = ":";
599 sptr += strlen(sptr);
600
601 for (; i < 4; i ++)
602 {
603 temp = ntohl(addr->ipv6.sin6_addr.s6_addr32[i]);
604
605 if ((temp & 0xffff0000) ||
606 (i > 0 && addr->ipv6.sin6_addr.s6_addr32[i - 1]))
607 {
608 snprintf(sptr, sizeof(temps) - (sptr - temps), "%s%x", prefix,
609 (temp >> 16) & 0xffff);
610 sptr += strlen(sptr);
611 }
612
613 snprintf(sptr, sizeof(temps) - (sptr - temps), "%s%x", prefix,
614 temp & 0xffff);
615 sptr += strlen(sptr);
616 }
617 }
618 else if (sptr == s)
619 {
620 /*
621 * Empty address...
622 */
623
624 strlcpy(temps, "::", sizeof(temps));
625 }
626 else
627 {
628 /*
629 * Empty at end...
630 */
631
632 strlcpy(sptr, "::", sizeof(temps) - (sptr - temps));
633 }
634 }
635 # endif /* HAVE_GETNAMEINFO */
636
637 /*
638 * Add "[v1." and "]" around IPv6 address to convert to URI form.
639 */
640
641 snprintf(s, slen, "[v1.%s]", temps);
642 }
643 #endif /* AF_INET6 */
644 else
645 strlcpy(s, "UNKNOWN", slen);
646
647 DEBUG_printf(("1httpAddrString: returning \"%s\"...", s));
648
649 return (s);
650 }
651
652
653 /*
654 * 'httpGetAddress()' - Get the address of the connected peer of a connection.
655 *
656 * Returns @code NULL@ if the socket is currently unconnected.
657 *
658 * @since CUPS 2.0@
659 */
660
661 http_addr_t * /* O - Connected address or @code NULL@ */
662 httpGetAddress(http_t *http) /* I - HTTP connection */
663 {
664 if (http)
665 return (http->hostaddr);
666 else
667 return (NULL);
668 }
669
670
671 /*
672 * 'httpGetHostByName()' - Lookup a hostname or IPv4 address, and return
673 * address records for the specified name.
674 *
675 * @deprecated@
676 */
677
678 struct hostent * /* O - Host entry */
679 httpGetHostByName(const char *name) /* I - Hostname or IP address */
680 {
681 const char *nameptr; /* Pointer into name */
682 unsigned ip[4]; /* IP address components */
683 _cups_globals_t *cg = _cupsGlobals();
684 /* Pointer to library globals */
685
686
687 DEBUG_printf(("httpGetHostByName(name=\"%s\")", name));
688
689 /*
690 * Avoid lookup delays and configuration problems when connecting
691 * to the localhost address...
692 */
693
694 if (!strcmp(name, "localhost"))
695 name = "127.0.0.1";
696
697 /*
698 * This function is needed because some operating systems have a
699 * buggy implementation of gethostbyname() that does not support
700 * IP addresses. If the first character of the name string is a
701 * number, then sscanf() is used to extract the IP components.
702 * We then pack the components into an IPv4 address manually,
703 * since the inet_aton() function is deprecated. We use the
704 * htonl() macro to get the right byte order for the address.
705 *
706 * We also support domain sockets when supported by the underlying
707 * OS...
708 */
709
710 #ifdef AF_LOCAL
711 if (name[0] == '/')
712 {
713 /*
714 * A domain socket address, so make an AF_LOCAL entry and return it...
715 */
716
717 cg->hostent.h_name = (char *)name;
718 cg->hostent.h_aliases = NULL;
719 cg->hostent.h_addrtype = AF_LOCAL;
720 cg->hostent.h_length = (int)strlen(name) + 1;
721 cg->hostent.h_addr_list = cg->ip_ptrs;
722 cg->ip_ptrs[0] = (char *)name;
723 cg->ip_ptrs[1] = NULL;
724
725 DEBUG_puts("1httpGetHostByName: returning domain socket address...");
726
727 return (&cg->hostent);
728 }
729 #endif /* AF_LOCAL */
730
731 for (nameptr = name; isdigit(*nameptr & 255) || *nameptr == '.'; nameptr ++);
732
733 if (!*nameptr)
734 {
735 /*
736 * We have an IPv4 address; break it up and provide the host entry
737 * to the caller.
738 */
739
740 if (sscanf(name, "%u.%u.%u.%u", ip, ip + 1, ip + 2, ip + 3) != 4)
741 return (NULL); /* Must have 4 numbers */
742
743 if (ip[0] > 255 || ip[1] > 255 || ip[2] > 255 || ip[3] > 255)
744 return (NULL); /* Invalid byte ranges! */
745
746 cg->ip_addr = htonl((((((((unsigned)ip[0] << 8) | (unsigned)ip[1]) << 8) |
747 (unsigned)ip[2]) << 8) |
748 (unsigned)ip[3]));
749
750 /*
751 * Fill in the host entry and return it...
752 */
753
754 cg->hostent.h_name = (char *)name;
755 cg->hostent.h_aliases = NULL;
756 cg->hostent.h_addrtype = AF_INET;
757 cg->hostent.h_length = 4;
758 cg->hostent.h_addr_list = cg->ip_ptrs;
759 cg->ip_ptrs[0] = (char *)&(cg->ip_addr);
760 cg->ip_ptrs[1] = NULL;
761
762 DEBUG_puts("1httpGetHostByName: returning IPv4 address...");
763
764 return (&cg->hostent);
765 }
766 else
767 {
768 /*
769 * Use the gethostbyname() function to get the IPv4 address for
770 * the name...
771 */
772
773 DEBUG_puts("1httpGetHostByName: returning domain lookup address(es)...");
774
775 return (gethostbyname(name));
776 }
777 }
778
779
780 /*
781 * 'httpGetHostname()' - Get the FQDN for the connection or local system.
782 *
783 * When "http" points to a connected socket, return the hostname or
784 * address that was used in the call to httpConnect() or httpConnectEncrypt(),
785 * or the address of the client for the connection from httpAcceptConnection().
786 * Otherwise, return the FQDN for the local system using both gethostname()
787 * and gethostbyname() to get the local hostname with domain.
788 *
789 * @since CUPS 1.2/OS X 10.5@
790 */
791
792 const char * /* O - FQDN for connection or system */
793 httpGetHostname(http_t *http, /* I - HTTP connection or NULL */
794 char *s, /* I - String buffer for name */
795 int slen) /* I - Size of buffer */
796 {
797 if (http)
798 {
799 if (!s || slen <= 1)
800 {
801 if (http->hostname[0] == '/')
802 return ("localhost");
803 else
804 return (http->hostname);
805 }
806 else if (http->hostname[0] == '/')
807 strlcpy(s, "localhost", slen);
808 else
809 strlcpy(s, http->hostname, slen);
810 }
811 else
812 {
813 /*
814 * Get the hostname...
815 */
816
817 if (!s || slen <= 1)
818 return (NULL);
819
820 if (gethostname(s, (size_t)slen) < 0)
821 strlcpy(s, "localhost", slen);
822
823 if (!strchr(s, '.'))
824 {
825 #ifdef HAVE_SCDYNAMICSTORECOPYCOMPUTERNAME
826 /*
827 * The hostname is not a FQDN, so use the local hostname from the
828 * SystemConfiguration framework...
829 */
830
831 SCDynamicStoreRef sc = SCDynamicStoreCreate(kCFAllocatorDefault,
832 CFSTR("libcups"), NULL, NULL);
833 /* System configuration data */
834 CFStringRef local = sc ? SCDynamicStoreCopyLocalHostName(sc) : NULL;
835 /* Local host name */
836 char localStr[1024]; /* Local host name C string */
837
838 if (local && CFStringGetCString(local, localStr, sizeof(localStr),
839 kCFStringEncodingUTF8))
840 {
841 /*
842 * Append ".local." to the hostname we get...
843 */
844
845 snprintf(s, slen, "%s.local.", localStr);
846 }
847
848 if (local)
849 CFRelease(local);
850 if (sc)
851 CFRelease(sc);
852
853 #else
854 /*
855 * The hostname is not a FQDN, so look it up...
856 */
857
858 struct hostent *host; /* Host entry to get FQDN */
859
860 if ((host = gethostbyname(s)) != NULL && host->h_name)
861 {
862 /*
863 * Use the resolved hostname...
864 */
865
866 strlcpy(s, host->h_name, slen);
867 }
868 #endif /* HAVE_SCDYNAMICSTORECOPYCOMPUTERNAME */
869 }
870 }
871
872 /*
873 * Return the hostname with as much domain info as we have...
874 */
875
876 return (s);
877 }
878
879
880 /*
881 * 'httpResolveHostname()' - Resolve the hostname of the HTTP connection
882 * address.
883 *
884 * @since CUPS 2.0@
885 */
886
887 const char * /* O - Resolved hostname or @code NULL@ */
888 httpResolveHostname(http_t *http, /* I - HTTP connection */
889 char *buffer, /* I - Hostname buffer */
890 size_t bufsize) /* I - Size of buffer */
891 {
892 if (!http)
893 return (NULL);
894
895 if (isdigit(http->hostname[0] & 255) || http->hostname[0] == '[')
896 {
897 char temp[1024]; /* Temporary string */
898
899 if (httpAddrLookup(http->hostaddr, temp, sizeof(temp)))
900 strlcpy(http->hostname, temp, sizeof(http->hostname));
901 else
902 return (NULL);
903 }
904
905 if (buffer)
906 {
907 if (http->hostname[0] == '/')
908 strlcpy(buffer, "localhost", bufsize);
909 else
910 strlcpy(buffer, http->hostname, bufsize);
911
912 return (buffer);
913 }
914 else if (http->hostname[0] == '/')
915 return ("localhost");
916 else
917 return (http->hostname);
918 }
919
920
921 /*
922 * End of "$Id$".
923 */