]> git.ipfire.org Git - thirdparty/cups.git/blob - cups/http-support.c
projects / thirdparty / cups.git / blob
? search:


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