]> git.ipfire.org Git - thirdparty/cups.git/blob - cups/http-support.c
projects / thirdparty / cups.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Range check port numbers in URIs (<rdar://problem/23144461>)
[thirdparty/cups.git] / cups / http-support.c
1 /*
2 * "$Id$"
3 *
4 * HTTP support routines for CUPS.
5 *
6 * Copyright 2007-2015 by Apple Inc.
7 * Copyright 1997-2007 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 * This file is subject to the Apple OS-Developed Software exception.
16 */
17
18 /*
19 * Include necessary headers...
20 */
21
22 #include "cups-private.h"
23 #ifdef HAVE_DNSSD
24 # include <dns_sd.h>
25 # ifdef WIN32
26 # include <io.h>
27 # elif defined(HAVE_POLL)
28 # include <poll.h>
29 # else
30 # include <sys/select.h>
31 # endif /* WIN32 */
32 #elif defined(HAVE_AVAHI)
33 # include <avahi-client/client.h>
34 # include <avahi-client/lookup.h>
35 # include <avahi-common/simple-watch.h>
36 #endif /* HAVE_DNSSD */
37
38
39 /*
40 * Local types...
41 */
42
43 typedef struct _http_uribuf_s /* URI buffer */
44 {
45 #ifdef HAVE_AVAHI
46 AvahiSimplePoll *poll; /* Poll state */
47 #endif /* HAVE_AVAHI */
48 char *buffer; /* Pointer to buffer */
49 size_t bufsize; /* Size of buffer */
50 int options; /* Options passed to _httpResolveURI */
51 const char *resource; /* Resource from URI */
52 const char *uuid; /* UUID from URI */
53 } _http_uribuf_t;
54
55
56 /*
57 * Local globals...
58 */
59
60 static const char * const http_days[7] =/* Days of the week */
61 {
62 "Sun",
63 "Mon",
64 "Tue",
65 "Wed",
66 "Thu",
67 "Fri",
68 "Sat"
69 };
70 static const char * const http_months[12] =
71 { /* Months of the year */
72 "Jan",
73 "Feb",
74 "Mar",
75 "Apr",
76 "May",
77 "Jun",
78 "Jul",
79 "Aug",
80 "Sep",
81 "Oct",
82 "Nov",
83 "Dec"
84 };
85 static const char * const http_states[] =
86 { /* HTTP state strings */
87 "HTTP_STATE_ERROR",
88 "HTTP_STATE_WAITING",
89 "HTTP_STATE_OPTIONS",
90 "HTTP_STATE_GET",
91 "HTTP_STATE_GET_SEND",
92 "HTTP_STATE_HEAD",
93 "HTTP_STATE_POST",
94 "HTTP_STATE_POST_RECV",
95 "HTTP_STATE_POST_SEND",
96 "HTTP_STATE_PUT",
97 "HTTP_STATE_PUT_RECV",
98 "HTTP_STATE_DELETE",
99 "HTTP_STATE_TRACE",
100 "HTTP_STATE_CONNECT",
101 "HTTP_STATE_STATUS",
102 "HTTP_STATE_UNKNOWN_METHOD",
103 "HTTP_STATE_UNKNOWN_VERSION"
104 };
105
106
107 /*
108 * Local functions...
109 */
110
111 static const char *http_copy_decode(char *dst, const char *src,
112 int dstsize, const char *term,
113 int decode);
114 static char *http_copy_encode(char *dst, const char *src,
115 char *dstend, const char *reserved,
116 const char *term, int encode);
117 #ifdef HAVE_DNSSD
118 static void DNSSD_API http_resolve_cb(DNSServiceRef sdRef,
119 DNSServiceFlags flags,
120 uint32_t interfaceIndex,
121 DNSServiceErrorType errorCode,
122 const char *fullName,
123 const char *hostTarget,
124 uint16_t port, uint16_t txtLen,
125 const unsigned char *txtRecord,
126 void *context);
127 #endif /* HAVE_DNSSD */
128
129 #ifdef HAVE_AVAHI
130 static void http_client_cb(AvahiClient *client,
131 AvahiClientState state, void *simple_poll);
132 static int http_poll_cb(struct pollfd *pollfds, unsigned int num_pollfds,
133 int timeout, void *context);
134 static void http_resolve_cb(AvahiServiceResolver *resolver,
135 AvahiIfIndex interface,
136 AvahiProtocol protocol,
137 AvahiResolverEvent event,
138 const char *name, const char *type,
139 const char *domain, const char *host_name,
140 const AvahiAddress *address, uint16_t port,
141 AvahiStringList *txt,
142 AvahiLookupResultFlags flags, void *context);
143 #endif /* HAVE_AVAHI */
144
145
146 /*
147 * 'httpAssembleURI()' - Assemble a uniform resource identifier from its
148 * components.
149 *
150 * This function escapes reserved characters in the URI depending on the
151 * value of the "encoding" argument. You should use this function in
152 * place of traditional string functions whenever you need to create a
153 * URI string.
154 *
155 * @since CUPS 1.2/OS X 10.5@
156 */
157
158 http_uri_status_t /* O - URI status */
159 httpAssembleURI(
160 http_uri_coding_t encoding, /* I - Encoding flags */
161 char *uri, /* I - URI buffer */
162 int urilen, /* I - Size of URI buffer */
163 const char *scheme, /* I - Scheme name */
164 const char *username, /* I - Username */
165 const char *host, /* I - Hostname or address */
166 int port, /* I - Port number */
167 const char *resource) /* I - Resource */
168 {
169 char *ptr, /* Pointer into URI buffer */
170 *end; /* End of URI buffer */
171
172
173 /*
174 * Range check input...
175 */
176
177 if (!uri || urilen < 1 || !scheme || port < 0)
178 {
179 if (uri)
180 *uri = '\0';
181
182 return (HTTP_URI_STATUS_BAD_ARGUMENTS);
183 }
184
185 /*
186 * Assemble the URI starting with the scheme...
187 */
188
189 end = uri + urilen - 1;
190 ptr = http_copy_encode(uri, scheme, end, NULL, NULL, 0);
191
192 if (!ptr)
193 goto assemble_overflow;
194
195 if (!strcmp(scheme, "geo") || !strcmp(scheme, "mailto") || !strcmp(scheme, "tel"))
196 {
197 /*
198 * geo:, mailto:, and tel: only have :, no //...
199 */
200
201 if (ptr < end)
202 *ptr++ = ':';
203 else
204 goto assemble_overflow;
205 }
206 else
207 {
208 /*
209 * Schemes other than geo:, mailto:, and tel: typically have //...
210 */
211
212 if ((ptr + 2) < end)
213 {
214 *ptr++ = ':';
215 *ptr++ = '/';
216 *ptr++ = '/';
217 }
218 else
219 goto assemble_overflow;
220 }
221
222 /*
223 * Next the username and hostname, if any...
224 */
225
226 if (host)
227 {
228 const char *hostptr; /* Pointer into hostname */
229 int have_ipv6; /* Do we have an IPv6 address? */
230
231 if (username && *username)
232 {
233 /*
234 * Add username@ first...
235 */
236
237 ptr = http_copy_encode(ptr, username, end, "/?#[]@", NULL,
238 encoding & HTTP_URI_CODING_USERNAME);
239
240 if (!ptr)
241 goto assemble_overflow;
242
243 if (ptr < end)
244 *ptr++ = '@';
245 else
246 goto assemble_overflow;
247 }
248
249 /*
250 * Then add the hostname. Since IPv6 is a particular pain to deal
251 * with, we have several special cases to deal with. If we get
252 * an IPv6 address with brackets around it, assume it is already in
253 * URI format. Since DNS-SD service names can sometimes look like
254 * raw IPv6 addresses, we specifically look for "._tcp" in the name,
255 * too...
256 */
257
258 for (hostptr = host,
259 have_ipv6 = strchr(host, ':') && !strstr(host, "._tcp");
260 *hostptr && have_ipv6;
261 hostptr ++)
262 if (*hostptr != ':' && !isxdigit(*hostptr & 255))
263 {
264 have_ipv6 = *hostptr == '%';
265 break;
266 }
267
268 if (have_ipv6)
269 {
270 /*
271 * We have a raw IPv6 address...
272 */
273
274 if (strchr(host, '%') && !(encoding & HTTP_URI_CODING_RFC6874))
275 {
276 /*
277 * We have a link-local address, add "[v1." prefix...
278 */
279
280 if ((ptr + 4) < end)
281 {
282 *ptr++ = '[';
283 *ptr++ = 'v';
284 *ptr++ = '1';
285 *ptr++ = '.';
286 }
287 else
288 goto assemble_overflow;
289 }
290 else
291 {
292 /*
293 * We have a normal (or RFC 6874 link-local) address, add "[" prefix...
294 */
295
296 if (ptr < end)
297 *ptr++ = '[';
298 else
299 goto assemble_overflow;
300 }
301
302 /*
303 * Copy the rest of the IPv6 address, and terminate with "]".
304 */
305
306 while (ptr < end && *host)
307 {
308 if (*host == '%')
309 {
310 /*
311 * Convert/encode zone separator
312 */
313
314 if (encoding & HTTP_URI_CODING_RFC6874)
315 {
316 if (ptr >= (end - 2))
317 goto assemble_overflow;
318
319 *ptr++ = '%';
320 *ptr++ = '2';
321 *ptr++ = '5';
322 }
323 else
324 *ptr++ = '+';
325
326 host ++;
327 }
328 else
329 *ptr++ = *host++;
330 }
331
332 if (*host)
333 goto assemble_overflow;
334
335 if (ptr < end)
336 *ptr++ = ']';
337 else
338 goto assemble_overflow;
339 }
340 else
341 {
342 /*
343 * Otherwise, just copy the host string (the extra chars are not in the
344 * "reg-name" ABNF rule; anything <= SP or >= DEL plus % gets automatically
345 * percent-encoded.
346 */
347
348 ptr = http_copy_encode(ptr, host, end, "\"#/:<>?@[\\]^`{|}", NULL,
349 encoding & HTTP_URI_CODING_HOSTNAME);
350
351 if (!ptr)
352 goto assemble_overflow;
353 }
354
355 /*
356 * Finish things off with the port number...
357 */
358
359 if (port > 0)
360 {
361 snprintf(ptr, (size_t)(end - ptr + 1), ":%d", port);
362 ptr += strlen(ptr);
363
364 if (ptr >= end)
365 goto assemble_overflow;
366 }
367 }
368
369 /*
370 * Last but not least, add the resource string...
371 */
372
373 if (resource)
374 {
375 char *query; /* Pointer to query string */
376
377
378 /*
379 * Copy the resource string up to the query string if present...
380 */
381
382 query = strchr(resource, '?');
383 ptr = http_copy_encode(ptr, resource, end, NULL, "?",
384 encoding & HTTP_URI_CODING_RESOURCE);
385 if (!ptr)
386 goto assemble_overflow;
387
388 if (query)
389 {
390 /*
391 * Copy query string without encoding...
392 */
393
394 ptr = http_copy_encode(ptr, query, end, NULL, NULL,
395 encoding & HTTP_URI_CODING_QUERY);
396 if (!ptr)
397 goto assemble_overflow;
398 }
399 }
400 else if (ptr < end)
401 *ptr++ = '/';
402 else
403 goto assemble_overflow;
404
405 /*
406 * Nul-terminate the URI buffer and return with no errors...
407 */
408
409 *ptr = '\0';
410
411 return (HTTP_URI_STATUS_OK);
412
413 /*
414 * Clear the URI string and return an overflow error; I don't usually
415 * like goto's, but in this case it makes sense...
416 */
417
418 assemble_overflow:
419
420 *uri = '\0';
421 return (HTTP_URI_STATUS_OVERFLOW);
422 }
423
424
425 /*
426 * 'httpAssembleURIf()' - Assemble a uniform resource identifier from its
427 * components with a formatted resource.
428 *
429 * This function creates a formatted version of the resource string
430 * argument "resourcef" and escapes reserved characters in the URI
431 * depending on the value of the "encoding" argument. You should use
432 * this function in place of traditional string functions whenever
433 * you need to create a URI string.
434 *
435 * @since CUPS 1.2/OS X 10.5@
436 */
437
438 http_uri_status_t /* O - URI status */
439 httpAssembleURIf(
440 http_uri_coding_t encoding, /* I - Encoding flags */
441 char *uri, /* I - URI buffer */
442 int urilen, /* I - Size of URI buffer */
443 const char *scheme, /* I - Scheme name */
444 const char *username, /* I - Username */
445 const char *host, /* I - Hostname or address */
446 int port, /* I - Port number */
447 const char *resourcef, /* I - Printf-style resource */
448 ...) /* I - Additional arguments as needed */
449 {
450 va_list ap; /* Pointer to additional arguments */
451 char resource[1024]; /* Formatted resource string */
452 int bytes; /* Bytes in formatted string */
453
454
455 /*
456 * Range check input...
457 */
458
459 if (!uri || urilen < 1 || !scheme || port < 0 || !resourcef)
460 {
461 if (uri)
462 *uri = '\0';
463
464 return (HTTP_URI_STATUS_BAD_ARGUMENTS);
465 }
466
467 /*
468 * Format the resource string and assemble the URI...
469 */
470
471 va_start(ap, resourcef);
472 bytes = vsnprintf(resource, sizeof(resource), resourcef, ap);
473 va_end(ap);
474
475 if ((size_t)bytes >= sizeof(resource))
476 {
477 *uri = '\0';
478 return (HTTP_URI_STATUS_OVERFLOW);
479 }
480 else
481 return (httpAssembleURI(encoding, uri, urilen, scheme, username, host,
482 port, resource));
483 }
484
485
486 /*
487 * 'httpAssembleUUID()' - Assemble a name-based UUID URN conforming to RFC 4122.
488 *
489 * This function creates a unique 128-bit identifying number using the server
490 * name, port number, random data, and optionally an object name and/or object
491 * number. The result is formatted as a UUID URN as defined in RFC 4122.
492 *
493 * The buffer needs to be at least 46 bytes in size.
494 *
495 * @since CUPS 1.7/OS X 10.9@
496 */
497
498 char * /* I - UUID string */
499 httpAssembleUUID(const char *server, /* I - Server name */
500 int port, /* I - Port number */
501 const char *name, /* I - Object name or NULL */
502 int number, /* I - Object number or 0 */
503 char *buffer, /* I - String buffer */
504 size_t bufsize) /* I - Size of buffer */
505 {
506 char data[1024]; /* Source string for MD5 */
507 _cups_md5_state_t md5state; /* MD5 state */
508 unsigned char md5sum[16]; /* MD5 digest/sum */
509
510
511 /*
512 * Build a version 3 UUID conforming to RFC 4122.
513 *
514 * Start with the MD5 sum of the server, port, object name and
515 * number, and some random data on the end.
516 */
517
518 snprintf(data, sizeof(data), "%s:%d:%s:%d:%04x:%04x", server,
519 port, name ? name : server, number,
520 (unsigned)CUPS_RAND() & 0xffff, (unsigned)CUPS_RAND() & 0xffff);
521
522 _cupsMD5Init(&md5state);
523 _cupsMD5Append(&md5state, (unsigned char *)data, (int)strlen(data));
524 _cupsMD5Finish(&md5state, md5sum);
525
526 /*
527 * Generate the UUID from the MD5...
528 */
529
530 snprintf(buffer, bufsize,
531 "urn:uuid:%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-"
532 "%02x%02x%02x%02x%02x%02x",
533 md5sum[0], md5sum[1], md5sum[2], md5sum[3], md5sum[4], md5sum[5],
534 (md5sum[6] & 15) | 0x30, md5sum[7], (md5sum[8] & 0x3f) | 0x40,
535 md5sum[9], md5sum[10], md5sum[11], md5sum[12], md5sum[13],
536 md5sum[14], md5sum[15]);
537
538 return (buffer);
539 }
540
541
542 /*
543 * 'httpDecode64()' - Base64-decode a string.
544 *
545 * This function is deprecated. Use the httpDecode64_2() function instead
546 * which provides buffer length arguments.
547 *
548 * @deprecated@
549 */
550
551 char * /* O - Decoded string */
552 httpDecode64(char *out, /* I - String to write to */
553 const char *in) /* I - String to read from */
554 {
555 int outlen; /* Output buffer length */
556
557
558 /*
559 * Use the old maximum buffer size for binary compatibility...
560 */
561
562 outlen = 512;
563
564 return (httpDecode64_2(out, &outlen, in));
565 }
566
567
568 /*
569 * 'httpDecode64_2()' - Base64-decode a string.
570 *
571 * @since CUPS 1.1.21/OS X 10.4@
572 */
573
574 char * /* O - Decoded string */
575 httpDecode64_2(char *out, /* I - String to write to */
576 int *outlen, /* IO - Size of output string */
577 const char *in) /* I - String to read from */
578 {
579 int pos; /* Bit position */
580 unsigned base64; /* Value of this character */
581 char *outptr, /* Output pointer */
582 *outend; /* End of output buffer */
583
584
585 /*
586 * Range check input...
587 */
588
589 if (!out || !outlen || *outlen < 1 || !in)
590 return (NULL);
591
592 if (!*in)
593 {
594 *out = '\0';
595 *outlen = 0;
596
597 return (out);
598 }
599
600 /*
601 * Convert from base-64 to bytes...
602 */
603
604 for (outptr = out, outend = out + *outlen - 1, pos = 0; *in != '\0'; in ++)
605 {
606 /*
607 * Decode this character into a number from 0 to 63...
608 */
609
610 if (*in >= 'A' && *in <= 'Z')
611 base64 = (unsigned)(*in - 'A');
612 else if (*in >= 'a' && *in <= 'z')
613 base64 = (unsigned)(*in - 'a' + 26);
614 else if (*in >= '0' && *in <= '9')
615 base64 = (unsigned)(*in - '0' + 52);
616 else if (*in == '+')
617 base64 = 62;
618 else if (*in == '/')
619 base64 = 63;
620 else if (*in == '=')
621 break;
622 else
623 continue;
624
625 /*
626 * Store the result in the appropriate chars...
627 */
628
629 switch (pos)
630 {
631 case 0 :
632 if (outptr < outend)
633 *outptr = (char)(base64 << 2);
634 pos ++;
635 break;
636 case 1 :
637 if (outptr < outend)
638 *outptr++ |= (char)((base64 >> 4) & 3);
639 if (outptr < outend)
640 *outptr = (char)((base64 << 4) & 255);
641 pos ++;
642 break;
643 case 2 :
644 if (outptr < outend)
645 *outptr++ |= (char)((base64 >> 2) & 15);
646 if (outptr < outend)
647 *outptr = (char)((base64 << 6) & 255);
648 pos ++;
649 break;
650 case 3 :
651 if (outptr < outend)
652 *outptr++ |= (char)base64;
653 pos = 0;
654 break;
655 }
656 }
657
658 *outptr = '\0';
659
660 /*
661 * Return the decoded string and size...
662 */
663
664 *outlen = (int)(outptr - out);
665
666 return (out);
667 }
668
669
670 /*
671 * 'httpEncode64()' - Base64-encode a string.
672 *
673 * This function is deprecated. Use the httpEncode64_2() function instead
674 * which provides buffer length arguments.
675 *
676 * @deprecated@
677 */
678
679 char * /* O - Encoded string */
680 httpEncode64(char *out, /* I - String to write to */
681 const char *in) /* I - String to read from */
682 {
683 return (httpEncode64_2(out, 512, in, (int)strlen(in)));
684 }
685
686
687 /*
688 * 'httpEncode64_2()' - Base64-encode a string.
689 *
690 * @since CUPS 1.1.21/OS X 10.4@
691 */
692
693 char * /* O - Encoded string */
694 httpEncode64_2(char *out, /* I - String to write to */
695 int outlen, /* I - Size of output string */
696 const char *in, /* I - String to read from */
697 int inlen) /* I - Size of input string */
698 {
699 char *outptr, /* Output pointer */
700 *outend; /* End of output buffer */
701 static const char base64[] = /* Base64 characters... */
702 {
703 "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
704 "abcdefghijklmnopqrstuvwxyz"
705 "0123456789"
706 "+/"
707 };
708
709
710 /*
711 * Range check input...
712 */
713
714 if (!out || outlen < 1 || !in)
715 return (NULL);
716
717 /*
718 * Convert bytes to base-64...
719 */
720
721 for (outptr = out, outend = out + outlen - 1; inlen > 0; in ++, inlen --)
722 {
723 /*
724 * Encode the up to 3 characters as 4 Base64 numbers...
725 */
726
727 if (outptr < outend)
728 *outptr ++ = base64[(in[0] & 255) >> 2];
729
730 if (outptr < outend)
731 {
732 if (inlen > 1)
733 *outptr ++ = base64[(((in[0] & 255) << 4) | ((in[1] & 255) >> 4)) & 63];
734 else
735 *outptr ++ = base64[((in[0] & 255) << 4) & 63];
736 }
737
738 in ++;
739 inlen --;
740 if (inlen <= 0)
741 {
742 if (outptr < outend)
743 *outptr ++ = '=';
744 if (outptr < outend)
745 *outptr ++ = '=';
746 break;
747 }
748
749 if (outptr < outend)
750 {
751 if (inlen > 1)
752 *outptr ++ = base64[(((in[0] & 255) << 2) | ((in[1] & 255) >> 6)) & 63];
753 else
754 *outptr ++ = base64[((in[0] & 255) << 2) & 63];
755 }
756
757 in ++;
758 inlen --;
759 if (inlen <= 0)
760 {
761 if (outptr < outend)
762 *outptr ++ = '=';
763 break;
764 }
765
766 if (outptr < outend)
767 *outptr ++ = base64[in[0] & 63];
768 }
769
770 *outptr = '\0';
771
772 /*
773 * Return the encoded string...
774 */
775
776 return (out);
777 }
778
779
780 /*
781 * 'httpGetDateString()' - Get a formatted date/time string from a time value.
782 *
783 * @deprecated@
784 */
785
786 const char * /* O - Date/time string */
787 httpGetDateString(time_t t) /* I - UNIX time */
788 {
789 _cups_globals_t *cg = _cupsGlobals(); /* Pointer to library globals */
790
791
792 return (httpGetDateString2(t, cg->http_date, sizeof(cg->http_date)));
793 }
794
795
796 /*
797 * 'httpGetDateString2()' - Get a formatted date/time string from a time value.
798 *
799 * @since CUPS 1.2/OS X 10.5@
800 */
801
802 const char * /* O - Date/time string */
803 httpGetDateString2(time_t t, /* I - UNIX time */
804 char *s, /* I - String buffer */
805 int slen) /* I - Size of string buffer */
806 {
807 struct tm *tdate; /* UNIX date/time data */
808
809
810 tdate = gmtime(&t);
811 if (tdate)
812 snprintf(s, (size_t)slen, "%s, %02d %s %d %02d:%02d:%02d GMT", http_days[tdate->tm_wday], tdate->tm_mday, http_months[tdate->tm_mon], tdate->tm_year + 1900, tdate->tm_hour, tdate->tm_min, tdate->tm_sec);
813 else
814 s[0] = '\0';
815
816 return (s);
817 }
818
819
820 /*
821 * 'httpGetDateTime()' - Get a time value from a formatted date/time string.
822 */
823
824 time_t /* O - UNIX time */
825 httpGetDateTime(const char *s) /* I - Date/time string */
826 {
827 int i; /* Looping var */
828 char mon[16]; /* Abbreviated month name */
829 int day, year; /* Day of month and year */
830 int hour, min, sec; /* Time */
831 int days; /* Number of days since 1970 */
832 static const int normal_days[] = /* Days to a month, normal years */
833 { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 };
834 static const int leap_days[] = /* Days to a month, leap years */
835 { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 };
836
837
838 DEBUG_printf(("2httpGetDateTime(s=\"%s\")", s));
839
840 /*
841 * Extract the date and time from the formatted string...
842 */
843
844 if (sscanf(s, "%*s%d%15s%d%d:%d:%d", &day, mon, &year, &hour, &min, &sec) < 6)
845 return (0);
846
847 DEBUG_printf(("4httpGetDateTime: day=%d, mon=\"%s\", year=%d, hour=%d, "
848 "min=%d, sec=%d", day, mon, year, hour, min, sec));
849
850 /*
851 * Convert the month name to a number from 0 to 11.
852 */
853
854 for (i = 0; i < 12; i ++)
855 if (!_cups_strcasecmp(mon, http_months[i]))
856 break;
857
858 if (i >= 12)
859 return (0);
860
861 DEBUG_printf(("4httpGetDateTime: i=%d", i));
862
863 /*
864 * Now convert the date and time to a UNIX time value in seconds since
865 * 1970. We can't use mktime() since the timezone may not be UTC but
866 * the date/time string *is* UTC.
867 */
868
869 if ((year & 3) == 0 && ((year % 100) != 0 || (year % 400) == 0))
870 days = leap_days[i] + day - 1;
871 else
872 days = normal_days[i] + day - 1;
873
874 DEBUG_printf(("4httpGetDateTime: days=%d", days));
875
876 days += (year - 1970) * 365 + /* 365 days per year (normally) */
877 ((year - 1) / 4 - 492) - /* + leap days */
878 ((year - 1) / 100 - 19) + /* - 100 year days */
879 ((year - 1) / 400 - 4); /* + 400 year days */
880
881 DEBUG_printf(("4httpGetDateTime: days=%d\n", days));
882
883 return (days * 86400 + hour * 3600 + min * 60 + sec);
884 }
885
886
887 /*
888 * 'httpSeparate()' - Separate a Universal Resource Identifier into its
889 * components.
890 *
891 * This function is deprecated; use the httpSeparateURI() function instead.
892 *
893 * @deprecated@
894 */
895
896 void
897 httpSeparate(const char *uri, /* I - Universal Resource Identifier */
898 char *scheme, /* O - Scheme [32] (http, https, etc.) */
899 char *username, /* O - Username [1024] */
900 char *host, /* O - Hostname [1024] */
901 int *port, /* O - Port number to use */
902 char *resource) /* O - Resource/filename [1024] */
903 {
904 httpSeparateURI(HTTP_URI_CODING_ALL, uri, scheme, 32, username,
905 HTTP_MAX_URI, host, HTTP_MAX_URI, port, resource,
906 HTTP_MAX_URI);
907 }
908
909
910 /*
911 * 'httpSeparate2()' - Separate a Universal Resource Identifier into its
912 * components.
913 *
914 * This function is deprecated; use the httpSeparateURI() function instead.
915 *
916 * @since CUPS 1.1.21/OS X 10.4@
917 * @deprecated@
918 */
919
920 void
921 httpSeparate2(const char *uri, /* I - Universal Resource Identifier */
922 char *scheme, /* O - Scheme (http, https, etc.) */
923 int schemelen, /* I - Size of scheme buffer */
924 char *username, /* O - Username */
925 int usernamelen, /* I - Size of username buffer */
926 char *host, /* O - Hostname */
927 int hostlen, /* I - Size of hostname buffer */
928 int *port, /* O - Port number to use */
929 char *resource, /* O - Resource/filename */
930 int resourcelen) /* I - Size of resource buffer */
931 {
932 httpSeparateURI(HTTP_URI_CODING_ALL, uri, scheme, schemelen, username,
933 usernamelen, host, hostlen, port, resource, resourcelen);
934 }
935
936
937 /*
938 * 'httpSeparateURI()' - Separate a Universal Resource Identifier into its
939 * components.
940 *
941 * @since CUPS 1.2/OS X 10.5@
942 */
943
944 http_uri_status_t /* O - Result of separation */
945 httpSeparateURI(
946 http_uri_coding_t decoding, /* I - Decoding flags */
947 const char *uri, /* I - Universal Resource Identifier */
948 char *scheme, /* O - Scheme (http, https, etc.) */
949 int schemelen, /* I - Size of scheme buffer */
950 char *username, /* O - Username */
951 int usernamelen, /* I - Size of username buffer */
952 char *host, /* O - Hostname */
953 int hostlen, /* I - Size of hostname buffer */
954 int *port, /* O - Port number to use */
955 char *resource, /* O - Resource/filename */
956 int resourcelen) /* I - Size of resource buffer */
957 {
958 char *ptr, /* Pointer into string... */
959 *end; /* End of string */
960 const char *sep; /* Separator character */
961 http_uri_status_t status; /* Result of separation */
962
963
964 /*
965 * Initialize everything to blank...
966 */
967
968 if (scheme && schemelen > 0)
969 *scheme = '\0';
970
971 if (username && usernamelen > 0)
972 *username = '\0';
973
974 if (host && hostlen > 0)
975 *host = '\0';
976
977 if (port)
978 *port = 0;
979
980 if (resource && resourcelen > 0)
981 *resource = '\0';
982
983 /*
984 * Range check input...
985 */
986
987 if (!uri || !port || !scheme || schemelen <= 0 || !username ||
988 usernamelen <= 0 || !host || hostlen <= 0 || !resource ||
989 resourcelen <= 0)
990 return (HTTP_URI_STATUS_BAD_ARGUMENTS);
991
992 if (!*uri)
993 return (HTTP_URI_STATUS_BAD_URI);
994
995 /*
996 * Grab the scheme portion of the URI...
997 */
998
999 status = HTTP_URI_STATUS_OK;
1000
1001 if (!strncmp(uri, "//", 2))
1002 {
1003 /*
1004 * Workaround for HP IPP client bug...
1005 */
1006
1007 strlcpy(scheme, "ipp", (size_t)schemelen);
1008 status = HTTP_URI_STATUS_MISSING_SCHEME;
1009 }
1010 else if (*uri == '/')
1011 {
1012 /*
1013 * Filename...
1014 */
1015
1016 strlcpy(scheme, "file", (size_t)schemelen);
1017 status = HTTP_URI_STATUS_MISSING_SCHEME;
1018 }
1019 else
1020 {
1021 /*
1022 * Standard URI with scheme...
1023 */
1024
1025 for (ptr = scheme, end = scheme + schemelen - 1;
1026 *uri && *uri != ':' && ptr < end;)
1027 if (strchr("ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1028 "abcdefghijklmnopqrstuvwxyz"
1029 "0123456789-+.", *uri) != NULL)
1030 *ptr++ = *uri++;
1031 else
1032 break;
1033
1034 *ptr = '\0';
1035
1036 if (*uri != ':')
1037 {
1038 *scheme = '\0';
1039 return (HTTP_URI_STATUS_BAD_SCHEME);
1040 }
1041
1042 uri ++;
1043 }
1044
1045 /*
1046 * Set the default port number...
1047 */
1048
1049 if (!strcmp(scheme, "http"))
1050 *port = 80;
1051 else if (!strcmp(scheme, "https"))
1052 *port = 443;
1053 else if (!strcmp(scheme, "ipp") || !strcmp(scheme, "ipps"))
1054 *port = 631;
1055 else if (!_cups_strcasecmp(scheme, "lpd"))
1056 *port = 515;
1057 else if (!strcmp(scheme, "socket")) /* Not yet registered with IANA... */
1058 *port = 9100;
1059 else if (strcmp(scheme, "file") && strcmp(scheme, "mailto") && strcmp(scheme, "tel"))
1060 status = HTTP_URI_STATUS_UNKNOWN_SCHEME;
1061
1062 /*
1063 * Now see if we have a hostname...
1064 */
1065
1066 if (!strncmp(uri, "//", 2))
1067 {
1068 /*
1069 * Yes, extract it...
1070 */
1071
1072 uri += 2;
1073
1074 /*
1075 * Grab the username, if any...
1076 */
1077
1078 if ((sep = strpbrk(uri, "@/")) != NULL && *sep == '@')
1079 {
1080 /*
1081 * Get a username:password combo...
1082 */
1083
1084 uri = http_copy_decode(username, uri, usernamelen, "@",
1085 decoding & HTTP_URI_CODING_USERNAME);
1086
1087 if (!uri)
1088 {
1089 *username = '\0';
1090 return (HTTP_URI_STATUS_BAD_USERNAME);
1091 }
1092
1093 uri ++;
1094 }
1095
1096 /*
1097 * Then the hostname/IP address...
1098 */
1099
1100 if (*uri == '[')
1101 {
1102 /*
1103 * Grab IPv6 address...
1104 */
1105
1106 uri ++;
1107 if (*uri == 'v')
1108 {
1109 /*
1110 * Skip IPvFuture ("vXXXX.") prefix...
1111 */
1112
1113 uri ++;
1114
1115 while (isxdigit(*uri & 255))
1116 uri ++;
1117
1118 if (*uri != '.')
1119 {
1120 *host = '\0';
1121 return (HTTP_URI_STATUS_BAD_HOSTNAME);
1122 }
1123
1124 uri ++;
1125 }
1126
1127 uri = http_copy_decode(host, uri, hostlen, "]",
1128 decoding & HTTP_URI_CODING_HOSTNAME);
1129
1130 if (!uri)
1131 {
1132 *host = '\0';
1133 return (HTTP_URI_STATUS_BAD_HOSTNAME);
1134 }
1135
1136 /*
1137 * Validate value...
1138 */
1139
1140 if (*uri != ']')
1141 {
1142 *host = '\0';
1143 return (HTTP_URI_STATUS_BAD_HOSTNAME);
1144 }
1145
1146 uri ++;
1147
1148 for (ptr = host; *ptr; ptr ++)
1149 if (*ptr == '+')
1150 {
1151 /*
1152 * Convert zone separator to % and stop here...
1153 */
1154
1155 *ptr = '%';
1156 break;
1157 }
1158 else if (*ptr == '%')
1159 {
1160 /*
1161 * Stop at zone separator (RFC 6874)
1162 */
1163
1164 break;
1165 }
1166 else if (*ptr != ':' && *ptr != '.' && !isxdigit(*ptr & 255))
1167 {
1168 *host = '\0';
1169 return (HTTP_URI_STATUS_BAD_HOSTNAME);
1170 }
1171 }
1172 else
1173 {
1174 /*
1175 * Validate the hostname or IPv4 address first...
1176 */
1177
1178 for (ptr = (char *)uri; *ptr; ptr ++)
1179 if (strchr(":?/", *ptr))
1180 break;
1181 else if (!strchr("abcdefghijklmnopqrstuvwxyz" /* unreserved */
1182 "ABCDEFGHIJKLMNOPQRSTUVWXYZ" /* unreserved */
1183 "0123456789" /* unreserved */
1184 "-._~" /* unreserved */
1185 "%" /* pct-encoded */
1186 "!$&'()*+,;=" /* sub-delims */
1187 "\\", *ptr)) /* SMB domain */
1188 {
1189 *host = '\0';
1190 return (HTTP_URI_STATUS_BAD_HOSTNAME);
1191 }
1192
1193 /*
1194 * Then copy the hostname or IPv4 address to the buffer...
1195 */
1196
1197 uri = http_copy_decode(host, uri, hostlen, ":?/",
1198 decoding & HTTP_URI_CODING_HOSTNAME);
1199
1200 if (!uri)
1201 {
1202 *host = '\0';
1203 return (HTTP_URI_STATUS_BAD_HOSTNAME);
1204 }
1205 }
1206
1207 /*
1208 * Validate hostname for file scheme - only empty and localhost are
1209 * acceptable.
1210 */
1211
1212 if (!strcmp(scheme, "file") && strcmp(host, "localhost") && host[0])
1213 {
1214 *host = '\0';
1215 return (HTTP_URI_STATUS_BAD_HOSTNAME);
1216 }
1217
1218 /*
1219 * See if we have a port number...
1220 */
1221
1222 if (*uri == ':')
1223 {
1224 /*
1225 * Yes, collect the port number...
1226 */
1227
1228 if (!isdigit(uri[1] & 255))
1229 {
1230 *port = 0;
1231 return (HTTP_URI_STATUS_BAD_PORT);
1232 }
1233
1234 *port = (int)strtol(uri + 1, (char **)&uri, 10);
1235
1236 if (*port <= 0 || *port > 65535)
1237 {
1238 *port = 0;
1239 return (HTTP_URI_STATUS_BAD_PORT);
1240 }
1241
1242 if (*uri != '/' && *uri)
1243 {
1244 *port = 0;
1245 return (HTTP_URI_STATUS_BAD_PORT);
1246 }
1247 }
1248 }
1249
1250 /*
1251 * The remaining portion is the resource string...
1252 */
1253
1254 if (*uri == '?' || !*uri)
1255 {
1256 /*
1257 * Hostname but no path...
1258 */
1259
1260 status = HTTP_URI_STATUS_MISSING_RESOURCE;
1261 *resource = '/';
1262
1263 /*
1264 * Copy any query string...
1265 */
1266
1267 if (*uri == '?')
1268 uri = http_copy_decode(resource + 1, uri, resourcelen - 1, NULL,
1269 decoding & HTTP_URI_CODING_QUERY);
1270 else
1271 resource[1] = '\0';
1272 }
1273 else
1274 {
1275 uri = http_copy_decode(resource, uri, resourcelen, "?",
1276 decoding & HTTP_URI_CODING_RESOURCE);
1277
1278 if (uri && *uri == '?')
1279 {
1280 /*
1281 * Concatenate any query string...
1282 */
1283
1284 char *resptr = resource + strlen(resource);
1285
1286 uri = http_copy_decode(resptr, uri,
1287 resourcelen - (int)(resptr - resource), NULL,
1288 decoding & HTTP_URI_CODING_QUERY);
1289 }
1290 }
1291
1292 if (!uri)
1293 {
1294 *resource = '\0';
1295 return (HTTP_URI_STATUS_BAD_RESOURCE);
1296 }
1297
1298 /*
1299 * Return the URI separation status...
1300 */
1301
1302 return (status);
1303 }
1304
1305
1306 /*
1307 * 'httpStateString()' - Return the string describing a HTTP state value.
1308 *
1309 * @since CUPS 2.0/OS 10.10@
1310 */
1311
1312 const char * /* O - State string */
1313 httpStateString(http_state_t state) /* I - HTTP state value */
1314 {
1315 if (state < HTTP_STATE_ERROR || state > HTTP_STATE_UNKNOWN_VERSION)
1316 return ("HTTP_STATE_???");
1317 else
1318 return (http_states[state - HTTP_STATE_ERROR]);
1319 }
1320
1321
1322 /*
1323 * '_httpStatus()' - Return the localized string describing a HTTP status code.
1324 *
1325 * The returned string is localized using the passed message catalog.
1326 */
1327
1328 const char * /* O - Localized status string */
1329 _httpStatus(cups_lang_t *lang, /* I - Language */
1330 http_status_t status) /* I - HTTP status code */
1331 {
1332 const char *s; /* Status string */
1333
1334
1335 switch (status)
1336 {
1337 case HTTP_STATUS_ERROR :
1338 s = strerror(errno);
1339 break;
1340 case HTTP_STATUS_CONTINUE :
1341 s = _("Continue");
1342 break;
1343 case HTTP_STATUS_SWITCHING_PROTOCOLS :
1344 s = _("Switching Protocols");
1345 break;
1346 case HTTP_STATUS_OK :
1347 s = _("OK");
1348 break;
1349 case HTTP_STATUS_CREATED :
1350 s = _("Created");
1351 break;
1352 case HTTP_STATUS_ACCEPTED :
1353 s = _("Accepted");
1354 break;
1355 case HTTP_STATUS_NO_CONTENT :
1356 s = _("No Content");
1357 break;
1358 case HTTP_STATUS_MOVED_PERMANENTLY :
1359 s = _("Moved Permanently");
1360 break;
1361 case HTTP_STATUS_SEE_OTHER :
1362 s = _("See Other");
1363 break;
1364 case HTTP_STATUS_NOT_MODIFIED :
1365 s = _("Not Modified");
1366 break;
1367 case HTTP_STATUS_BAD_REQUEST :
1368 s = _("Bad Request");
1369 break;
1370 case HTTP_STATUS_UNAUTHORIZED :
1371 case HTTP_STATUS_CUPS_AUTHORIZATION_CANCELED :
1372 s = _("Unauthorized");
1373 break;
1374 case HTTP_STATUS_FORBIDDEN :
1375 s = _("Forbidden");
1376 break;
1377 case HTTP_STATUS_NOT_FOUND :
1378 s = _("Not Found");
1379 break;
1380 case HTTP_STATUS_REQUEST_TOO_LARGE :
1381 s = _("Request Entity Too Large");
1382 break;
1383 case HTTP_STATUS_URI_TOO_LONG :
1384 s = _("URI Too Long");
1385 break;
1386 case HTTP_STATUS_UPGRADE_REQUIRED :
1387 s = _("Upgrade Required");
1388 break;
1389 case HTTP_STATUS_NOT_IMPLEMENTED :
1390 s = _("Not Implemented");
1391 break;
1392 case HTTP_STATUS_NOT_SUPPORTED :
1393 s = _("Not Supported");
1394 break;
1395 case HTTP_STATUS_EXPECTATION_FAILED :
1396 s = _("Expectation Failed");
1397 break;
1398 case HTTP_STATUS_SERVICE_UNAVAILABLE :
1399 s = _("Service Unavailable");
1400 break;
1401 case HTTP_STATUS_SERVER_ERROR :
1402 s = _("Internal Server Error");
1403 break;
1404 case HTTP_STATUS_CUPS_PKI_ERROR :
1405 s = _("SSL/TLS Negotiation Error");
1406 break;
1407 case HTTP_STATUS_CUPS_WEBIF_DISABLED :
1408 s = _("Web Interface is Disabled");
1409 break;
1410
1411 default :
1412 s = _("Unknown");
1413 break;
1414 }
1415
1416 return (_cupsLangString(lang, s));
1417 }
1418
1419
1420 /*
1421 * 'httpStatus()' - Return a short string describing a HTTP status code.
1422 *
1423 * The returned string is localized to the current POSIX locale and is based
1424 * on the status strings defined in RFC 2616.
1425 */
1426
1427 const char * /* O - Localized status string */
1428 httpStatus(http_status_t status) /* I - HTTP status code */
1429 {
1430 _cups_globals_t *cg = _cupsGlobals(); /* Global data */
1431
1432
1433 if (!cg->lang_default)
1434 cg->lang_default = cupsLangDefault();
1435
1436 return (_httpStatus(cg->lang_default, status));
1437 }
1438
1439 /*
1440 * 'httpURIStatusString()' - Return a string describing a URI status code.
1441 *
1442 * @since CUPS 2.0/OS 10.10@
1443 */
1444
1445 const char * /* O - Localized status string */
1446 httpURIStatusString(
1447 http_uri_status_t status) /* I - URI status code */
1448 {
1449 const char *s; /* Status string */
1450 _cups_globals_t *cg = _cupsGlobals(); /* Global data */
1451
1452
1453 if (!cg->lang_default)
1454 cg->lang_default = cupsLangDefault();
1455
1456 switch (status)
1457 {
1458 case HTTP_URI_STATUS_OVERFLOW :
1459 s = _("URI too large");
1460 break;
1461 case HTTP_URI_STATUS_BAD_ARGUMENTS :
1462 s = _("Bad arguments to function");
1463 break;
1464 case HTTP_URI_STATUS_BAD_RESOURCE :
1465 s = _("Bad resource in URI");
1466 break;
1467 case HTTP_URI_STATUS_BAD_PORT :
1468 s = _("Bad port number in URI");
1469 break;
1470 case HTTP_URI_STATUS_BAD_HOSTNAME :
1471 s = _("Bad hostname/address in URI");
1472 break;
1473 case HTTP_URI_STATUS_BAD_USERNAME :
1474 s = _("Bad username in URI");
1475 break;
1476 case HTTP_URI_STATUS_BAD_SCHEME :
1477 s = _("Bad scheme in URI");
1478 break;
1479 case HTTP_URI_STATUS_BAD_URI :
1480 s = _("Bad/empty URI");
1481 break;
1482 case HTTP_URI_STATUS_OK :
1483 s = _("OK");
1484 break;
1485 case HTTP_URI_STATUS_MISSING_SCHEME :
1486 s = _("Missing scheme in URI");
1487 break;
1488 case HTTP_URI_STATUS_UNKNOWN_SCHEME :
1489 s = _("Unknown scheme in URI");
1490 break;
1491 case HTTP_URI_STATUS_MISSING_RESOURCE :
1492 s = _("Missing resource in URI");
1493 break;
1494
1495 default:
1496 s = _("Unknown");
1497 break;
1498 }
1499
1500 return (_cupsLangString(cg->lang_default, s));
1501 }
1502
1503
1504 #ifndef HAVE_HSTRERROR
1505 /*
1506 * '_cups_hstrerror()' - hstrerror() emulation function for Solaris and others.
1507 */
1508
1509 const char * /* O - Error string */
1510 _cups_hstrerror(int error) /* I - Error number */
1511 {
1512 static const char * const errors[] = /* Error strings */
1513 {
1514 "OK",
1515 "Host not found.",
1516 "Try again.",
1517 "Unrecoverable lookup error.",
1518 "No data associated with name."
1519 };
1520
1521
1522 if (error < 0 || error > 4)
1523 return ("Unknown hostname lookup error.");
1524 else
1525 return (errors[error]);
1526 }
1527 #endif /* !HAVE_HSTRERROR */
1528
1529
1530 /*
1531 * '_httpDecodeURI()' - Percent-decode a HTTP request URI.
1532 */
1533
1534 char * /* O - Decoded URI or NULL on error */
1535 _httpDecodeURI(char *dst, /* I - Destination buffer */
1536 const char *src, /* I - Source URI */
1537 size_t dstsize) /* I - Size of destination buffer */
1538 {
1539 if (http_copy_decode(dst, src, (int)dstsize, NULL, 1))
1540 return (dst);
1541 else
1542 return (NULL);
1543 }
1544
1545
1546 /*
1547 * '_httpEncodeURI()' - Percent-encode a HTTP request URI.
1548 */
1549
1550 char * /* O - Encoded URI */
1551 _httpEncodeURI(char *dst, /* I - Destination buffer */
1552 const char *src, /* I - Source URI */
1553 size_t dstsize) /* I - Size of destination buffer */
1554 {
1555 http_copy_encode(dst, src, dst + dstsize - 1, NULL, NULL, 1);
1556 return (dst);
1557 }
1558
1559
1560 /*
1561 * '_httpResolveURI()' - Resolve a DNS-SD URI.
1562 */
1563
1564 const char * /* O - Resolved URI */
1565 _httpResolveURI(
1566 const char *uri, /* I - DNS-SD URI */
1567 char *resolved_uri, /* I - Buffer for resolved URI */
1568 size_t resolved_size, /* I - Size of URI buffer */
1569 int options, /* I - Resolve options */
1570 int (*cb)(void *context), /* I - Continue callback function */
1571 void *context) /* I - Context pointer for callback */
1572 {
1573 char scheme[32], /* URI components... */
1574 userpass[256],
1575 hostname[1024],
1576 resource[1024];
1577 int port;
1578 #ifdef DEBUG
1579 http_uri_status_t status; /* URI decode status */
1580 #endif /* DEBUG */
1581
1582
1583 DEBUG_printf(("4_httpResolveURI(uri=\"%s\", resolved_uri=%p, "
1584 "resolved_size=" CUPS_LLFMT ")", uri, resolved_uri,
1585 CUPS_LLCAST resolved_size));
1586
1587 /*
1588 * Get the device URI...
1589 */
1590
1591 #ifdef DEBUG
1592 if ((status = httpSeparateURI(HTTP_URI_CODING_ALL, uri, scheme,
1593 sizeof(scheme), userpass, sizeof(userpass),
1594 hostname, sizeof(hostname), &port, resource,
1595 sizeof(resource))) < HTTP_URI_STATUS_OK)
1596 #else
1597 if (httpSeparateURI(HTTP_URI_CODING_ALL, uri, scheme,
1598 sizeof(scheme), userpass, sizeof(userpass),
1599 hostname, sizeof(hostname), &port, resource,
1600 sizeof(resource)) < HTTP_URI_STATUS_OK)
1601 #endif /* DEBUG */
1602 {
1603 if (options & _HTTP_RESOLVE_STDERR)
1604 _cupsLangPrintFilter(stderr, "ERROR", _("Bad device-uri \"%s\"."), uri);
1605
1606 DEBUG_printf(("6_httpResolveURI: httpSeparateURI returned %d!", status));
1607 DEBUG_puts("5_httpResolveURI: Returning NULL");
1608 return (NULL);
1609 }
1610
1611 /*
1612 * Resolve it as needed...
1613 */
1614
1615 if (strstr(hostname, "._tcp"))
1616 {
1617 #if defined(HAVE_DNSSD) || defined(HAVE_AVAHI)
1618 char *regtype, /* Pointer to type in hostname */
1619 *domain, /* Pointer to domain in hostname */
1620 *uuid, /* Pointer to UUID in URI */
1621 *uuidend; /* Pointer to end of UUID in URI */
1622 _http_uribuf_t uribuf; /* URI buffer */
1623 int offline = 0; /* offline-report state set? */
1624 # ifdef HAVE_DNSSD
1625 # ifdef WIN32
1626 # pragma comment(lib, "dnssd.lib")
1627 # endif /* WIN32 */
1628 DNSServiceRef ref, /* DNS-SD master service reference */
1629 domainref = NULL,/* DNS-SD service reference for domain */
1630 ippref = NULL, /* DNS-SD service reference for network IPP */
1631 ippsref = NULL, /* DNS-SD service reference for network IPPS */
1632 localref; /* DNS-SD service reference for .local */
1633 int extrasent = 0; /* Send the domain/IPP/IPPS resolves? */
1634 # ifdef HAVE_POLL
1635 struct pollfd polldata; /* Polling data */
1636 # else /* select() */
1637 fd_set input_set; /* Input set for select() */
1638 struct timeval stimeout; /* Timeout value for select() */
1639 # endif /* HAVE_POLL */
1640 # elif defined(HAVE_AVAHI)
1641 AvahiClient *client; /* Client information */
1642 int error; /* Status */
1643 # endif /* HAVE_DNSSD */
1644
1645 if (options & _HTTP_RESOLVE_STDERR)
1646 fprintf(stderr, "DEBUG: Resolving \"%s\"...\n", hostname);
1647
1648 /*
1649 * Separate the hostname into service name, registration type, and domain...
1650 */
1651
1652 for (regtype = strstr(hostname, "._tcp") - 2;
1653 regtype > hostname;
1654 regtype --)
1655 if (regtype[0] == '.' && regtype[1] == '_')
1656 {
1657 /*
1658 * Found ._servicetype in front of ._tcp...
1659 */
1660
1661 *regtype++ = '\0';
1662 break;
1663 }
1664
1665 if (regtype <= hostname)
1666 {
1667 DEBUG_puts("5_httpResolveURI: Bad hostname, returning NULL");
1668 return (NULL);
1669 }
1670
1671 for (domain = strchr(regtype, '.');
1672 domain;
1673 domain = strchr(domain + 1, '.'))
1674 if (domain[1] != '_')
1675 break;
1676
1677 if (domain)
1678 *domain++ = '\0';
1679
1680 if ((uuid = strstr(resource, "?uuid=")) != NULL)
1681 {
1682 *uuid = '\0';
1683 uuid += 6;
1684 if ((uuidend = strchr(uuid, '&')) != NULL)
1685 *uuidend = '\0';
1686 }
1687
1688 resolved_uri[0] = '\0';
1689
1690 uribuf.buffer = resolved_uri;
1691 uribuf.bufsize = resolved_size;
1692 uribuf.options = options;
1693 uribuf.resource = resource;
1694 uribuf.uuid = uuid;
1695
1696 DEBUG_printf(("6_httpResolveURI: Resolving hostname=\"%s\", regtype=\"%s\", "
1697 "domain=\"%s\"\n", hostname, regtype, domain));
1698 if (options & _HTTP_RESOLVE_STDERR)
1699 {
1700 fputs("STATE: +connecting-to-device\n", stderr);
1701 fprintf(stderr, "DEBUG: Resolving \"%s\", regtype=\"%s\", "
1702 "domain=\"local.\"...\n", hostname, regtype);
1703 }
1704
1705 uri = NULL;
1706
1707 # ifdef HAVE_DNSSD
1708 if (DNSServiceCreateConnection(&ref) == kDNSServiceErr_NoError)
1709 {
1710 uint32_t myinterface = kDNSServiceInterfaceIndexAny;
1711 /* Lookup on any interface */
1712
1713 if (!strcmp(scheme, "ippusb"))
1714 myinterface = kDNSServiceInterfaceIndexLocalOnly;
1715
1716 localref = ref;
1717 if (DNSServiceResolve(&localref,
1718 kDNSServiceFlagsShareConnection, myinterface,
1719 hostname, regtype, "local.", http_resolve_cb,
1720 &uribuf) == kDNSServiceErr_NoError)
1721 {
1722 int fds; /* Number of ready descriptors */
1723 time_t timeout, /* Poll timeout */
1724 start_time = time(NULL),/* Start time */
1725 end_time = start_time + 90;
1726 /* End time */
1727
1728 while (time(NULL) < end_time)
1729 {
1730 if (options & _HTTP_RESOLVE_STDERR)
1731 _cupsLangPrintFilter(stderr, "INFO", _("Looking for printer..."));
1732
1733 if (cb && !(*cb)(context))
1734 {
1735 DEBUG_puts("5_httpResolveURI: callback returned 0 (stop)");
1736 break;
1737 }
1738
1739 /*
1740 * Wakeup every 2 seconds to emit a "looking for printer" message...
1741 */
1742
1743 if ((timeout = end_time - time(NULL)) > 2)
1744 timeout = 2;
1745
1746 # ifdef HAVE_POLL
1747 polldata.fd = DNSServiceRefSockFD(ref);
1748 polldata.events = POLLIN;
1749
1750 fds = poll(&polldata, 1, (int)(1000 * timeout));
1751
1752 # else /* select() */
1753 FD_ZERO(&input_set);
1754 FD_SET(DNSServiceRefSockFD(ref), &input_set);
1755
1756 # ifdef WIN32
1757 stimeout.tv_sec = (long)timeout;
1758 # else
1759 stimeout.tv_sec = timeout;
1760 # endif /* WIN32 */
1761 stimeout.tv_usec = 0;
1762
1763 fds = select(DNSServiceRefSockFD(ref)+1, &input_set, NULL, NULL,
1764 &stimeout);
1765 # endif /* HAVE_POLL */
1766
1767 if (fds < 0)
1768 {
1769 if (errno != EINTR && errno != EAGAIN)
1770 {
1771 DEBUG_printf(("5_httpResolveURI: poll error: %s", strerror(errno)));
1772 break;
1773 }
1774 }
1775 else if (fds == 0)
1776 {
1777 /*
1778 * Wait 2 seconds for a response to the local resolve; if nothing
1779 * comes in, do an additional domain resolution...
1780 */
1781
1782 if (extrasent == 0 && domain && _cups_strcasecmp(domain, "local."))
1783 {
1784 if (options & _HTTP_RESOLVE_STDERR)
1785 fprintf(stderr,
1786 "DEBUG: Resolving \"%s\", regtype=\"%s\", "
1787 "domain=\"%s\"...\n", hostname, regtype,
1788 domain ? domain : "");
1789
1790 domainref = ref;
1791 if (DNSServiceResolve(&domainref,
1792 kDNSServiceFlagsShareConnection,
1793 myinterface, hostname, regtype, domain,
1794 http_resolve_cb,
1795 &uribuf) == kDNSServiceErr_NoError)
1796 extrasent = 1;
1797 }
1798 else if (extrasent == 0 && !strcmp(scheme, "ippusb"))
1799 {
1800 if (options & _HTTP_RESOLVE_STDERR)
1801 fprintf(stderr, "DEBUG: Resolving \"%s\", regtype=\"_ipps._tcp\", domain=\"local.\"...\n", hostname);
1802
1803 ippsref = ref;
1804 if (DNSServiceResolve(&ippsref,
1805 kDNSServiceFlagsShareConnection,
1806 kDNSServiceInterfaceIndexAny, hostname,
1807 "_ipps._tcp", domain, http_resolve_cb,
1808 &uribuf) == kDNSServiceErr_NoError)
1809 extrasent = 1;
1810 }
1811 else if (extrasent == 1 && !strcmp(scheme, "ippusb"))
1812 {
1813 if (options & _HTTP_RESOLVE_STDERR)
1814 fprintf(stderr, "DEBUG: Resolving \"%s\", regtype=\"_ipp._tcp\", domain=\"local.\"...\n", hostname);
1815
1816 ippref = ref;
1817 if (DNSServiceResolve(&ippref,
1818 kDNSServiceFlagsShareConnection,
1819 kDNSServiceInterfaceIndexAny, hostname,
1820 "_ipp._tcp", domain, http_resolve_cb,
1821 &uribuf) == kDNSServiceErr_NoError)
1822 extrasent = 2;
1823 }
1824
1825 /*
1826 * If it hasn't resolved within 5 seconds set the offline-report
1827 * printer-state-reason...
1828 */
1829
1830 if ((options & _HTTP_RESOLVE_STDERR) && offline == 0 &&
1831 time(NULL) > (start_time + 5))
1832 {
1833 fputs("STATE: +offline-report\n", stderr);
1834 offline = 1;
1835 }
1836 }
1837 else
1838 {
1839 if (DNSServiceProcessResult(ref) == kDNSServiceErr_NoError &&
1840 resolved_uri[0])
1841 {
1842 uri = resolved_uri;
1843 break;
1844 }
1845 }
1846 }
1847
1848 if (extrasent)
1849 {
1850 if (domainref)
1851 DNSServiceRefDeallocate(domainref);
1852 if (ippref)
1853 DNSServiceRefDeallocate(ippref);
1854 if (ippsref)
1855 DNSServiceRefDeallocate(ippsref);
1856 }
1857
1858 DNSServiceRefDeallocate(localref);
1859 }
1860
1861 DNSServiceRefDeallocate(ref);
1862 }
1863 # else /* HAVE_AVAHI */
1864 if ((uribuf.poll = avahi_simple_poll_new()) != NULL)
1865 {
1866 avahi_simple_poll_set_func(uribuf.poll, http_poll_cb, NULL);
1867
1868 if ((client = avahi_client_new(avahi_simple_poll_get(uribuf.poll),
1869 0, http_client_cb,
1870 &uribuf, &error)) != NULL)
1871 {
1872 if (avahi_service_resolver_new(client, AVAHI_IF_UNSPEC,
1873 AVAHI_PROTO_UNSPEC, hostname,
1874 regtype, "local.", AVAHI_PROTO_UNSPEC, 0,
1875 http_resolve_cb, &uribuf) != NULL)
1876 {
1877 time_t start_time = time(NULL),
1878 /* Start time */
1879 end_time = start_time + 90;
1880 /* End time */
1881 int pstatus; /* Poll status */
1882
1883 pstatus = avahi_simple_poll_iterate(uribuf.poll, 2000);
1884
1885 if (pstatus == 0 && !resolved_uri[0] && domain &&
1886 _cups_strcasecmp(domain, "local."))
1887 {
1888 /*
1889 * Resolve for .local hasn't returned anything, try the listed
1890 * domain...
1891 */
1892
1893 avahi_service_resolver_new(client, AVAHI_IF_UNSPEC,
1894 AVAHI_PROTO_UNSPEC, hostname,
1895 regtype, domain, AVAHI_PROTO_UNSPEC, 0,
1896 http_resolve_cb, &uribuf);
1897 }
1898
1899 while (!pstatus && !resolved_uri[0] && time(NULL) < end_time)
1900 {
1901 if ((pstatus = avahi_simple_poll_iterate(uribuf.poll, 2000)) != 0)
1902 break;
1903
1904 /*
1905 * If it hasn't resolved within 5 seconds set the offline-report
1906 * printer-state-reason...
1907 */
1908
1909 if ((options & _HTTP_RESOLVE_STDERR) && offline == 0 &&
1910 time(NULL) > (start_time + 5))
1911 {
1912 fputs("STATE: +offline-report\n", stderr);
1913 offline = 1;
1914 }
1915 }
1916
1917 /*
1918 * Collect the result (if we got one).
1919 */
1920
1921 if (resolved_uri[0])
1922 uri = resolved_uri;
1923 }
1924
1925 avahi_client_free(client);
1926 }
1927
1928 avahi_simple_poll_free(uribuf.poll);
1929 }
1930 # endif /* HAVE_DNSSD */
1931
1932 if (options & _HTTP_RESOLVE_STDERR)
1933 {
1934 if (uri)
1935 {
1936 fprintf(stderr, "DEBUG: Resolved as \"%s\"...\n", uri);
1937 fputs("STATE: -connecting-to-device,offline-report\n", stderr);
1938 }
1939 else
1940 {
1941 fputs("DEBUG: Unable to resolve URI\n", stderr);
1942 fputs("STATE: -connecting-to-device\n", stderr);
1943 }
1944 }
1945
1946 #else /* HAVE_DNSSD || HAVE_AVAHI */
1947 /*
1948 * No DNS-SD support...
1949 */
1950
1951 uri = NULL;
1952 #endif /* HAVE_DNSSD || HAVE_AVAHI */
1953
1954 if ((options & _HTTP_RESOLVE_STDERR) && !uri)
1955 _cupsLangPrintFilter(stderr, "INFO", _("Unable to find printer."));
1956 }
1957 else
1958 {
1959 /*
1960 * Nothing more to do...
1961 */
1962
1963 strlcpy(resolved_uri, uri, resolved_size);
1964 uri = resolved_uri;
1965 }
1966
1967 DEBUG_printf(("5_httpResolveURI: Returning \"%s\"", uri));
1968
1969 return (uri);
1970 }
1971
1972
1973 #ifdef HAVE_AVAHI
1974 /*
1975 * 'http_client_cb()' - Client callback for resolving URI.
1976 */
1977
1978 static void
1979 http_client_cb(
1980 AvahiClient *client, /* I - Client information */
1981 AvahiClientState state, /* I - Current state */
1982 void *context) /* I - Pointer to URI buffer */
1983 {
1984 DEBUG_printf(("7http_client_cb(client=%p, state=%d, context=%p)", client,
1985 state, context));
1986
1987 /*
1988 * If the connection drops, quit.
1989 */
1990
1991 if (state == AVAHI_CLIENT_FAILURE)
1992 {
1993 _http_uribuf_t *uribuf = (_http_uribuf_t *)context;
1994 /* URI buffer */
1995
1996 avahi_simple_poll_quit(uribuf->poll);
1997 }
1998 }
1999 #endif /* HAVE_AVAHI */
2000
2001
2002 /*
2003 * 'http_copy_decode()' - Copy and decode a URI.
2004 */
2005
2006 static const char * /* O - New source pointer or NULL on error */
2007 http_copy_decode(char *dst, /* O - Destination buffer */
2008 const char *src, /* I - Source pointer */
2009 int dstsize, /* I - Destination size */
2010 const char *term, /* I - Terminating characters */
2011 int decode) /* I - Decode %-encoded values */
2012 {
2013 char *ptr, /* Pointer into buffer */
2014 *end; /* End of buffer */
2015 int quoted; /* Quoted character */
2016
2017
2018 /*
2019 * Copy the src to the destination until we hit a terminating character
2020 * or the end of the string.
2021 */
2022
2023 for (ptr = dst, end = dst + dstsize - 1;
2024 *src && (!term || !strchr(term, *src));
2025 src ++)
2026 if (ptr < end)
2027 {
2028 if (*src == '%' && decode)
2029 {
2030 if (isxdigit(src[1] & 255) && isxdigit(src[2] & 255))
2031 {
2032 /*
2033 * Grab a hex-encoded character...
2034 */
2035
2036 src ++;
2037 if (isalpha(*src))
2038 quoted = (tolower(*src) - 'a' + 10) << 4;
2039 else
2040 quoted = (*src - '0') << 4;
2041
2042 src ++;
2043 if (isalpha(*src))
2044 quoted |= tolower(*src) - 'a' + 10;
2045 else
2046 quoted |= *src - '0';
2047
2048 *ptr++ = (char)quoted;
2049 }
2050 else
2051 {
2052 /*
2053 * Bad hex-encoded character...
2054 */
2055
2056 *ptr = '\0';
2057 return (NULL);
2058 }
2059 }
2060 else if ((*src & 255) <= 0x20 || (*src & 255) >= 0x7f)
2061 {
2062 *ptr = '\0';
2063 return (NULL);
2064 }
2065 else
2066 *ptr++ = *src;
2067 }
2068
2069 *ptr = '\0';
2070
2071 return (src);
2072 }
2073
2074
2075 /*
2076 * 'http_copy_encode()' - Copy and encode a URI.
2077 */
2078
2079 static char * /* O - End of current URI */
2080 http_copy_encode(char *dst, /* O - Destination buffer */
2081 const char *src, /* I - Source pointer */
2082 char *dstend, /* I - End of destination buffer */
2083 const char *reserved, /* I - Extra reserved characters */
2084 const char *term, /* I - Terminating characters */
2085 int encode) /* I - %-encode reserved chars? */
2086 {
2087 static const char hex[] = "0123456789ABCDEF";
2088
2089
2090 while (*src && dst < dstend)
2091 {
2092 if (term && *src == *term)
2093 return (dst);
2094
2095 if (encode && (*src == '%' || *src <= ' ' || *src & 128 ||
2096 (reserved && strchr(reserved, *src))))
2097 {
2098 /*
2099 * Hex encode reserved characters...
2100 */
2101
2102 if ((dst + 2) >= dstend)
2103 break;
2104
2105 *dst++ = '%';
2106 *dst++ = hex[(*src >> 4) & 15];
2107 *dst++ = hex[*src & 15];
2108
2109 src ++;
2110 }
2111 else
2112 *dst++ = *src++;
2113 }
2114
2115 *dst = '\0';
2116
2117 if (*src)
2118 return (NULL);
2119 else
2120 return (dst);
2121 }
2122
2123
2124 #ifdef HAVE_DNSSD
2125 /*
2126 * 'http_resolve_cb()' - Build a device URI for the given service name.
2127 */
2128
2129 static void DNSSD_API
2130 http_resolve_cb(
2131 DNSServiceRef sdRef, /* I - Service reference */
2132 DNSServiceFlags flags, /* I - Results flags */
2133 uint32_t interfaceIndex, /* I - Interface number */
2134 DNSServiceErrorType errorCode, /* I - Error, if any */
2135 const char *fullName, /* I - Full service name */
2136 const char *hostTarget, /* I - Hostname */
2137 uint16_t port, /* I - Port number */
2138 uint16_t txtLen, /* I - Length of TXT record */
2139 const unsigned char *txtRecord, /* I - TXT record data */
2140 void *context) /* I - Pointer to URI buffer */
2141 {
2142 _http_uribuf_t *uribuf = (_http_uribuf_t *)context;
2143 /* URI buffer */
2144 const char *scheme, /* URI scheme */
2145 *hostptr, /* Pointer into hostTarget */
2146 *reskey, /* "rp" or "rfo" */
2147 *resdefault; /* Default path */
2148 char resource[257], /* Remote path */
2149 fqdn[256]; /* FQDN of the .local name */
2150 const void *value; /* Value from TXT record */
2151 uint8_t valueLen; /* Length of value */
2152
2153
2154 DEBUG_printf(("7http_resolve_cb(sdRef=%p, flags=%x, interfaceIndex=%u, "
2155 "errorCode=%d, fullName=\"%s\", hostTarget=\"%s\", port=%u, "
2156 "txtLen=%u, txtRecord=%p, context=%p)", sdRef, flags,
2157 interfaceIndex, errorCode, fullName, hostTarget, port, txtLen,
2158 txtRecord, context));
2159
2160 /*
2161 * If we have a UUID, compare it...
2162 */
2163
2164 if (uribuf->uuid &&
2165 (value = TXTRecordGetValuePtr(txtLen, txtRecord, "UUID",
2166 &valueLen)) != NULL)
2167 {
2168 char uuid[256]; /* UUID value */
2169
2170 memcpy(uuid, value, valueLen);
2171 uuid[valueLen] = '\0';
2172
2173 if (_cups_strcasecmp(uuid, uribuf->uuid))
2174 {
2175 if (uribuf->options & _HTTP_RESOLVE_STDERR)
2176 fprintf(stderr, "DEBUG: Found UUID %s, looking for %s.", uuid,
2177 uribuf->uuid);
2178
2179 DEBUG_printf(("7http_resolve_cb: Found UUID %s, looking for %s.", uuid,
2180 uribuf->uuid));
2181 return;
2182 }
2183 }
2184
2185 /*
2186 * Figure out the scheme from the full name...
2187 */
2188
2189 if (strstr(fullName, "._ipps") || strstr(fullName, "._ipp-tls"))
2190 scheme = "ipps";
2191 else if (strstr(fullName, "._ipp") || strstr(fullName, "._fax-ipp"))
2192 scheme = "ipp";
2193 else if (strstr(fullName, "._http."))
2194 scheme = "http";
2195 else if (strstr(fullName, "._https."))
2196 scheme = "https";
2197 else if (strstr(fullName, "._printer."))
2198 scheme = "lpd";
2199 else if (strstr(fullName, "._pdl-datastream."))
2200 scheme = "socket";
2201 else
2202 scheme = "riousbprint";
2203
2204 /*
2205 * Extract the "remote printer" key from the TXT record...
2206 */
2207
2208 if ((uribuf->options & _HTTP_RESOLVE_FAXOUT) &&
2209 (!strcmp(scheme, "ipp") || !strcmp(scheme, "ipps")) &&
2210 !TXTRecordGetValuePtr(txtLen, txtRecord, "printer-type", &valueLen))
2211 {
2212 reskey = "rfo";
2213 resdefault = "/ipp/faxout";
2214 }
2215 else
2216 {
2217 reskey = "rp";
2218 resdefault = "/";
2219 }
2220
2221 if ((value = TXTRecordGetValuePtr(txtLen, txtRecord, reskey,
2222 &valueLen)) != NULL)
2223 {
2224 if (((char *)value)[0] == '/')
2225 {
2226 /*
2227 * Value (incorrectly) has a leading slash already...
2228 */
2229
2230 memcpy(resource, value, valueLen);
2231 resource[valueLen] = '\0';
2232 }
2233 else
2234 {
2235 /*
2236 * Convert to resource by concatenating with a leading "/"...
2237 */
2238
2239 resource[0] = '/';
2240 memcpy(resource + 1, value, valueLen);
2241 resource[valueLen + 1] = '\0';
2242 }
2243 }
2244 else
2245 {
2246 /*
2247 * Use the default value...
2248 */
2249
2250 strlcpy(resource, resdefault, sizeof(resource));
2251 }
2252
2253 /*
2254 * Lookup the FQDN if needed...
2255 */
2256
2257 if ((uribuf->options & _HTTP_RESOLVE_FQDN) &&
2258 (hostptr = hostTarget + strlen(hostTarget) - 7) > hostTarget &&
2259 !_cups_strcasecmp(hostptr, ".local."))
2260 {
2261 /*
2262 * OK, we got a .local name but the caller needs a real domain. Start by
2263 * getting the IP address of the .local name and then do reverse-lookups...
2264 */
2265
2266 http_addrlist_t *addrlist, /* List of addresses */
2267 *addr; /* Current address */
2268
2269 DEBUG_printf(("8http_resolve_cb: Looking up \"%s\".", hostTarget));
2270
2271 snprintf(fqdn, sizeof(fqdn), "%d", ntohs(port));
2272 if ((addrlist = httpAddrGetList(hostTarget, AF_UNSPEC, fqdn)) != NULL)
2273 {
2274 for (addr = addrlist; addr; addr = addr->next)
2275 {
2276 int error = getnameinfo(&(addr->addr.addr), (socklen_t)httpAddrLength(&(addr->addr)), fqdn, sizeof(fqdn), NULL, 0, NI_NAMEREQD);
2277
2278 if (!error)
2279 {
2280 DEBUG_printf(("8http_resolve_cb: Found \"%s\".", fqdn));
2281
2282 if ((hostptr = fqdn + strlen(fqdn) - 6) <= fqdn ||
2283 _cups_strcasecmp(hostptr, ".local"))
2284 {
2285 hostTarget = fqdn;
2286 break;
2287 }
2288 }
2289 #ifdef DEBUG
2290 else
2291 DEBUG_printf(("8http_resolve_cb: \"%s\" did not resolve: %d",
2292 httpAddrString(&(addr->addr), fqdn, sizeof(fqdn)),
2293 error));
2294 #endif /* DEBUG */
2295 }
2296
2297 httpAddrFreeList(addrlist);
2298 }
2299 }
2300
2301 /*
2302 * Assemble the final device URI...
2303 */
2304
2305 if ((!strcmp(scheme, "ipp") || !strcmp(scheme, "ipps")) &&
2306 !strcmp(uribuf->resource, "/cups"))
2307 httpAssembleURIf(HTTP_URI_CODING_ALL, uribuf->buffer, (int)uribuf->bufsize, scheme, NULL, hostTarget, ntohs(port), "%s?snmp=false", resource);
2308 else
2309 httpAssembleURI(HTTP_URI_CODING_ALL, uribuf->buffer, (int)uribuf->bufsize, scheme, NULL, hostTarget, ntohs(port), resource);
2310
2311 DEBUG_printf(("8http_resolve_cb: Resolved URI is \"%s\"...", uribuf->buffer));
2312 }
2313
2314 #elif defined(HAVE_AVAHI)
2315 /*
2316 * 'http_poll_cb()' - Wait for input on the specified file descriptors.
2317 *
2318 * Note: This function is needed because avahi_simple_poll_iterate is broken
2319 * and always uses a timeout of 0 (!) milliseconds.
2320 * (Avahi Ticket #364)
2321 */
2322
2323 static int /* O - Number of file descriptors matching */
2324 http_poll_cb(
2325 struct pollfd *pollfds, /* I - File descriptors */
2326 unsigned int num_pollfds, /* I - Number of file descriptors */
2327 int timeout, /* I - Timeout in milliseconds (used) */
2328 void *context) /* I - User data (unused) */
2329 {
2330 (void)timeout;
2331 (void)context;
2332
2333 return (poll(pollfds, num_pollfds, 2000));
2334 }
2335
2336
2337 /*
2338 * 'http_resolve_cb()' - Build a device URI for the given service name.
2339 */
2340
2341 static void
2342 http_resolve_cb(
2343 AvahiServiceResolver *resolver, /* I - Resolver (unused) */
2344 AvahiIfIndex interface, /* I - Interface index (unused) */
2345 AvahiProtocol protocol, /* I - Network protocol (unused) */
2346 AvahiResolverEvent event, /* I - Event (found, etc.) */
2347 const char *name, /* I - Service name */
2348 const char *type, /* I - Registration type */
2349 const char *domain, /* I - Domain (unused) */
2350 const char *hostTarget, /* I - Hostname */
2351 const AvahiAddress *address, /* I - Address (unused) */
2352 uint16_t port, /* I - Port number */
2353 AvahiStringList *txt, /* I - TXT record */
2354 AvahiLookupResultFlags flags, /* I - Lookup flags (unused) */
2355 void *context) /* I - Pointer to URI buffer */
2356 {
2357 _http_uribuf_t *uribuf = (_http_uribuf_t *)context;
2358 /* URI buffer */
2359 const char *scheme, /* URI scheme */
2360 *hostptr, /* Pointer into hostTarget */
2361 *reskey, /* "rp" or "rfo" */
2362 *resdefault; /* Default path */
2363 char resource[257], /* Remote path */
2364 fqdn[256]; /* FQDN of the .local name */
2365 AvahiStringList *pair; /* Current TXT record key/value pair */
2366 char *value; /* Value for "rp" key */
2367 size_t valueLen = 0; /* Length of "rp" key */
2368
2369
2370 DEBUG_printf(("7http_resolve_cb(resolver=%p, "
2371 "interface=%d, protocol=%d, event=%d, name=\"%s\", "
2372 "type=\"%s\", domain=\"%s\", hostTarget=\"%s\", address=%p, "
2373 "port=%d, txt=%p, flags=%d, context=%p)",
2374 resolver, interface, protocol, event, name, type, domain,
2375 hostTarget, address, port, txt, flags, context));
2376
2377 if (event != AVAHI_RESOLVER_FOUND)
2378 {
2379 avahi_service_resolver_free(resolver);
2380 avahi_simple_poll_quit(uribuf->poll);
2381 return;
2382 }
2383
2384 /*
2385 * If we have a UUID, compare it...
2386 */
2387
2388 if (uribuf->uuid && (pair = avahi_string_list_find(txt, "UUID")) != NULL)
2389 {
2390 char uuid[256]; /* UUID value */
2391
2392 avahi_string_list_get_pair(pair, NULL, &value, &valueLen);
2393
2394 memcpy(uuid, value, valueLen);
2395 uuid[valueLen] = '\0';
2396
2397 if (_cups_strcasecmp(uuid, uribuf->uuid))
2398 {
2399 if (uribuf->options & _HTTP_RESOLVE_STDERR)
2400 fprintf(stderr, "DEBUG: Found UUID %s, looking for %s.", uuid,
2401 uribuf->uuid);
2402
2403 DEBUG_printf(("7http_resolve_cb: Found UUID %s, looking for %s.", uuid,
2404 uribuf->uuid));
2405 return;
2406 }
2407 }
2408
2409 /*
2410 * Figure out the scheme from the full name...
2411 */
2412
2413 if (strstr(type, "_ipp."))
2414 scheme = "ipp";
2415 else if (strstr(type, "_printer."))
2416 scheme = "lpd";
2417 else if (strstr(type, "_pdl-datastream."))
2418 scheme = "socket";
2419 else
2420 scheme = "riousbprint";
2421
2422 if (!strncmp(type, "_ipps.", 6) || !strncmp(type, "_ipp-tls.", 9))
2423 scheme = "ipps";
2424 else if (!strncmp(type, "_ipp.", 5) || !strncmp(type, "_fax-ipp.", 9))
2425 scheme = "ipp";
2426 else if (!strncmp(type, "_http.", 6))
2427 scheme = "http";
2428 else if (!strncmp(type, "_https.", 7))
2429 scheme = "https";
2430 else if (!strncmp(type, "_printer.", 9))
2431 scheme = "lpd";
2432 else if (!strncmp(type, "_pdl-datastream.", 16))
2433 scheme = "socket";
2434 else
2435 {
2436 avahi_service_resolver_free(resolver);
2437 avahi_simple_poll_quit(uribuf->poll);
2438 return;
2439 }
2440
2441 /*
2442 * Extract the remote resource key from the TXT record...
2443 */
2444
2445 if ((uribuf->options & _HTTP_RESOLVE_FAXOUT) &&
2446 (!strcmp(scheme, "ipp") || !strcmp(scheme, "ipps")) &&
2447 !avahi_string_list_find(txt, "printer-type"))
2448 {
2449 reskey = "rfo";
2450 resdefault = "/ipp/faxout";
2451 }
2452 else
2453 {
2454 reskey = "rp";
2455 resdefault = "/";
2456 }
2457
2458 if ((pair = avahi_string_list_find(txt, reskey)) != NULL)
2459 {
2460 avahi_string_list_get_pair(pair, NULL, &value, &valueLen);
2461
2462 if (value[0] == '/')
2463 {
2464 /*
2465 * Value (incorrectly) has a leading slash already...
2466 */
2467
2468 memcpy(resource, value, valueLen);
2469 resource[valueLen] = '\0';
2470 }
2471 else
2472 {
2473 /*
2474 * Convert to resource by concatenating with a leading "/"...
2475 */
2476
2477 resource[0] = '/';
2478 memcpy(resource + 1, value, valueLen);
2479 resource[valueLen + 1] = '\0';
2480 }
2481 }
2482 else
2483 {
2484 /*
2485 * Use the default value...
2486 */
2487
2488 strlcpy(resource, resdefault, sizeof(resource));
2489 }
2490
2491 /*
2492 * Lookup the FQDN if needed...
2493 */
2494
2495 if ((uribuf->options & _HTTP_RESOLVE_FQDN) &&
2496 (hostptr = hostTarget + strlen(hostTarget) - 6) > hostTarget &&
2497 !_cups_strcasecmp(hostptr, ".local"))
2498 {
2499 /*
2500 * OK, we got a .local name but the caller needs a real domain. Start by
2501 * getting the IP address of the .local name and then do reverse-lookups...
2502 */
2503
2504 http_addrlist_t *addrlist, /* List of addresses */
2505 *addr; /* Current address */
2506
2507 DEBUG_printf(("8http_resolve_cb: Looking up \"%s\".", hostTarget));
2508
2509 snprintf(fqdn, sizeof(fqdn), "%d", ntohs(port));
2510 if ((addrlist = httpAddrGetList(hostTarget, AF_UNSPEC, fqdn)) != NULL)
2511 {
2512 for (addr = addrlist; addr; addr = addr->next)
2513 {
2514 int error = getnameinfo(&(addr->addr.addr), (socklen_t)httpAddrLength(&(addr->addr)), fqdn, sizeof(fqdn), NULL, 0, NI_NAMEREQD);
2515
2516 if (!error)
2517 {
2518 DEBUG_printf(("8http_resolve_cb: Found \"%s\".", fqdn));
2519
2520 if ((hostptr = fqdn + strlen(fqdn) - 6) <= fqdn ||
2521 _cups_strcasecmp(hostptr, ".local"))
2522 {
2523 hostTarget = fqdn;
2524 break;
2525 }
2526 }
2527 #ifdef DEBUG
2528 else
2529 DEBUG_printf(("8http_resolve_cb: \"%s\" did not resolve: %d",
2530 httpAddrString(&(addr->addr), fqdn, sizeof(fqdn)),
2531 error));
2532 #endif /* DEBUG */
2533 }
2534
2535 httpAddrFreeList(addrlist);
2536 }
2537 }
2538
2539 /*
2540 * Assemble the final device URI using the resolved hostname...
2541 */
2542
2543 httpAssembleURI(HTTP_URI_CODING_ALL, uribuf->buffer, uribuf->bufsize, scheme,
2544 NULL, hostTarget, port, resource);
2545 DEBUG_printf(("8http_resolve_cb: Resolved URI is \"%s\".", uribuf->buffer));
2546
2547 avahi_simple_poll_quit(uribuf->poll);
2548 }
2549 #endif /* HAVE_DNSSD */
2550
2551
2552 /*
2553 * End of "$Id$".
2554 */
Unnamed repository; edit this file 'description' to name the repository.