]> 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
Fix build errors on Fedora.
[thirdparty/cups.git] / cups / http-support.c
1 /*
2 * "$Id$"
3 *
4 * HTTP support routines for CUPS.
5 *
6 * Copyright 2007-2014 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, "mailto") || !strcmp(scheme, "tel"))
196 {
197 /*
198 * 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 mailto: and tel: all 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++ |= 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 (*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 * 'httpStateString()' - Return the string describing a HTTP state value.
1302 *
1303 * @since CUPS 2.0@
1304 */
1305
1306 const char * /* O - State string */
1307 httpStateString(http_state_t state) /* I - HTTP state value */
1308 {
1309 if (state < HTTP_STATE_ERROR || state > HTTP_STATE_UNKNOWN_VERSION)
1310 return ("HTTP_STATE_???");
1311 else
1312 return (http_states[state - HTTP_STATE_ERROR]);
1313 }
1314
1315
1316 /*
1317 * '_httpStatus()' - Return the localized string describing a HTTP status code.
1318 *
1319 * The returned string is localized using the passed message catalog.
1320 */
1321
1322 const char * /* O - Localized status string */
1323 _httpStatus(cups_lang_t *lang, /* I - Language */
1324 http_status_t status) /* I - HTTP status code */
1325 {
1326 const char *s; /* Status string */
1327
1328
1329 switch (status)
1330 {
1331 case HTTP_STATUS_ERROR :
1332 s = strerror(errno);
1333 break;
1334 case HTTP_STATUS_CONTINUE :
1335 s = _("Continue");
1336 break;
1337 case HTTP_STATUS_SWITCHING_PROTOCOLS :
1338 s = _("Switching Protocols");
1339 break;
1340 case HTTP_STATUS_OK :
1341 s = _("OK");
1342 break;
1343 case HTTP_STATUS_CREATED :
1344 s = _("Created");
1345 break;
1346 case HTTP_STATUS_ACCEPTED :
1347 s = _("Accepted");
1348 break;
1349 case HTTP_STATUS_NO_CONTENT :
1350 s = _("No Content");
1351 break;
1352 case HTTP_STATUS_MOVED_PERMANENTLY :
1353 s = _("Moved Permanently");
1354 break;
1355 case HTTP_STATUS_SEE_OTHER :
1356 s = _("See Other");
1357 break;
1358 case HTTP_STATUS_NOT_MODIFIED :
1359 s = _("Not Modified");
1360 break;
1361 case HTTP_STATUS_BAD_REQUEST :
1362 s = _("Bad Request");
1363 break;
1364 case HTTP_STATUS_UNAUTHORIZED :
1365 case HTTP_STATUS_CUPS_AUTHORIZATION_CANCELED :
1366 s = _("Unauthorized");
1367 break;
1368 case HTTP_STATUS_FORBIDDEN :
1369 s = _("Forbidden");
1370 break;
1371 case HTTP_STATUS_NOT_FOUND :
1372 s = _("Not Found");
1373 break;
1374 case HTTP_STATUS_REQUEST_TOO_LARGE :
1375 s = _("Request Entity Too Large");
1376 break;
1377 case HTTP_STATUS_URI_TOO_LONG :
1378 s = _("URI Too Long");
1379 break;
1380 case HTTP_STATUS_UPGRADE_REQUIRED :
1381 s = _("Upgrade Required");
1382 break;
1383 case HTTP_STATUS_NOT_IMPLEMENTED :
1384 s = _("Not Implemented");
1385 break;
1386 case HTTP_STATUS_NOT_SUPPORTED :
1387 s = _("Not Supported");
1388 break;
1389 case HTTP_STATUS_EXPECTATION_FAILED :
1390 s = _("Expectation Failed");
1391 break;
1392 case HTTP_STATUS_SERVICE_UNAVAILABLE :
1393 s = _("Service Unavailable");
1394 break;
1395 case HTTP_STATUS_SERVER_ERROR :
1396 s = _("Internal Server Error");
1397 break;
1398 case HTTP_STATUS_CUPS_PKI_ERROR :
1399 s = _("SSL/TLS Negotiation Error");
1400 break;
1401 case HTTP_STATUS_CUPS_WEBIF_DISABLED :
1402 s = _("Web Interface is Disabled");
1403 break;
1404
1405 default :
1406 s = _("Unknown");
1407 break;
1408 }
1409
1410 return (_cupsLangString(lang, s));
1411 }
1412
1413
1414 /*
1415 * 'httpStatus()' - Return a short string describing a HTTP status code.
1416 *
1417 * The returned string is localized to the current POSIX locale and is based
1418 * on the status strings defined in RFC 2616.
1419 */
1420
1421 const char * /* O - Localized status string */
1422 httpStatus(http_status_t status) /* I - HTTP status code */
1423 {
1424 _cups_globals_t *cg = _cupsGlobals(); /* Global data */
1425
1426
1427 if (!cg->lang_default)
1428 cg->lang_default = cupsLangDefault();
1429
1430 return (_httpStatus(cg->lang_default, status));
1431 }
1432
1433 /*
1434 * 'httpURIStatusString()' - Return a string describing a URI status code.
1435 *
1436 * @since CUPS 2.0@
1437 */
1438
1439 const char * /* O - Localized status string */
1440 httpURIStatusString(
1441 http_uri_status_t status) /* I - URI status code */
1442 {
1443 const char *s; /* Status string */
1444 _cups_globals_t *cg = _cupsGlobals(); /* Global data */
1445
1446
1447 if (!cg->lang_default)
1448 cg->lang_default = cupsLangDefault();
1449
1450 switch (status)
1451 {
1452 case HTTP_URI_STATUS_OVERFLOW :
1453 s = _("URI too large");
1454 break;
1455 case HTTP_URI_STATUS_BAD_ARGUMENTS :
1456 s = _("Bad arguments to function");
1457 break;
1458 case HTTP_URI_STATUS_BAD_RESOURCE :
1459 s = _("Bad resource in URI");
1460 break;
1461 case HTTP_URI_STATUS_BAD_PORT :
1462 s = _("Bad port number in URI");
1463 break;
1464 case HTTP_URI_STATUS_BAD_HOSTNAME :
1465 s = _("Bad hostname/address in URI");
1466 break;
1467 case HTTP_URI_STATUS_BAD_USERNAME :
1468 s = _("Bad username in URI");
1469 break;
1470 case HTTP_URI_STATUS_BAD_SCHEME :
1471 s = _("Bad scheme in URI");
1472 break;
1473 case HTTP_URI_STATUS_BAD_URI :
1474 s = _("Bad/empty URI");
1475 break;
1476 case HTTP_URI_STATUS_OK :
1477 s = _("OK");
1478 break;
1479 case HTTP_URI_STATUS_MISSING_SCHEME :
1480 s = _("Missing scheme in URI");
1481 break;
1482 case HTTP_URI_STATUS_UNKNOWN_SCHEME :
1483 s = _("Unknown scheme in URI");
1484 break;
1485 case HTTP_URI_STATUS_MISSING_RESOURCE :
1486 s = _("Missing resource in URI");
1487 break;
1488
1489 default:
1490 s = _("Unknown");
1491 break;
1492 }
1493
1494 return (_cupsLangString(cg->lang_default, s));
1495 }
1496
1497
1498 #ifndef HAVE_HSTRERROR
1499 /*
1500 * '_cups_hstrerror()' - hstrerror() emulation function for Solaris and others.
1501 */
1502
1503 const char * /* O - Error string */
1504 _cups_hstrerror(int error) /* I - Error number */
1505 {
1506 static const char * const errors[] = /* Error strings */
1507 {
1508 "OK",
1509 "Host not found.",
1510 "Try again.",
1511 "Unrecoverable lookup error.",
1512 "No data associated with name."
1513 };
1514
1515
1516 if (error < 0 || error > 4)
1517 return ("Unknown hostname lookup error.");
1518 else
1519 return (errors[error]);
1520 }
1521 #endif /* !HAVE_HSTRERROR */
1522
1523
1524 /*
1525 * '_httpDecodeURI()' - Percent-decode a HTTP request URI.
1526 */
1527
1528 char * /* O - Decoded URI or NULL on error */
1529 _httpDecodeURI(char *dst, /* I - Destination buffer */
1530 const char *src, /* I - Source URI */
1531 size_t dstsize) /* I - Size of destination buffer */
1532 {
1533 if (http_copy_decode(dst, src, (int)dstsize, NULL, 1))
1534 return (dst);
1535 else
1536 return (NULL);
1537 }
1538
1539
1540 /*
1541 * '_httpEncodeURI()' - Percent-encode a HTTP request URI.
1542 */
1543
1544 char * /* O - Encoded URI */
1545 _httpEncodeURI(char *dst, /* I - Destination buffer */
1546 const char *src, /* I - Source URI */
1547 size_t dstsize) /* I - Size of destination buffer */
1548 {
1549 http_copy_encode(dst, src, dst + dstsize - 1, NULL, NULL, 1);
1550 return (dst);
1551 }
1552
1553
1554 /*
1555 * '_httpResolveURI()' - Resolve a DNS-SD URI.
1556 */
1557
1558 const char * /* O - Resolved URI */
1559 _httpResolveURI(
1560 const char *uri, /* I - DNS-SD URI */
1561 char *resolved_uri, /* I - Buffer for resolved URI */
1562 size_t resolved_size, /* I - Size of URI buffer */
1563 int options, /* I - Resolve options */
1564 int (*cb)(void *context), /* I - Continue callback function */
1565 void *context) /* I - Context pointer for callback */
1566 {
1567 char scheme[32], /* URI components... */
1568 userpass[256],
1569 hostname[1024],
1570 resource[1024];
1571 int port;
1572 #ifdef DEBUG
1573 http_uri_status_t status; /* URI decode status */
1574 #endif /* DEBUG */
1575
1576
1577 DEBUG_printf(("4_httpResolveURI(uri=\"%s\", resolved_uri=%p, "
1578 "resolved_size=" CUPS_LLFMT ")", uri, resolved_uri,
1579 CUPS_LLCAST resolved_size));
1580
1581 /*
1582 * Get the device URI...
1583 */
1584
1585 #ifdef DEBUG
1586 if ((status = httpSeparateURI(HTTP_URI_CODING_ALL, uri, scheme,
1587 sizeof(scheme), userpass, sizeof(userpass),
1588 hostname, sizeof(hostname), &port, resource,
1589 sizeof(resource))) < HTTP_URI_STATUS_OK)
1590 #else
1591 if (httpSeparateURI(HTTP_URI_CODING_ALL, uri, scheme,
1592 sizeof(scheme), userpass, sizeof(userpass),
1593 hostname, sizeof(hostname), &port, resource,
1594 sizeof(resource)) < HTTP_URI_STATUS_OK)
1595 #endif /* DEBUG */
1596 {
1597 if (options & _HTTP_RESOLVE_STDERR)
1598 _cupsLangPrintFilter(stderr, "ERROR", _("Bad device-uri \"%s\"."), uri);
1599
1600 DEBUG_printf(("6_httpResolveURI: httpSeparateURI returned %d!", status));
1601 DEBUG_puts("5_httpResolveURI: Returning NULL");
1602 return (NULL);
1603 }
1604
1605 /*
1606 * Resolve it as needed...
1607 */
1608
1609 if (strstr(hostname, "._tcp"))
1610 {
1611 #if defined(HAVE_DNSSD) || defined(HAVE_AVAHI)
1612 char *regtype, /* Pointer to type in hostname */
1613 *domain, /* Pointer to domain in hostname */
1614 *uuid, /* Pointer to UUID in URI */
1615 *uuidend; /* Pointer to end of UUID in URI */
1616 _http_uribuf_t uribuf; /* URI buffer */
1617 int offline = 0; /* offline-report state set? */
1618 # ifdef HAVE_DNSSD
1619 # ifdef WIN32
1620 # pragma comment(lib, "dnssd.lib")
1621 # endif /* WIN32 */
1622 DNSServiceRef ref, /* DNS-SD master service reference */
1623 domainref = NULL,/* DNS-SD service reference for domain */
1624 localref; /* DNS-SD service reference for .local */
1625 int domainsent = 0; /* Send the domain resolve? */
1626 # ifdef HAVE_POLL
1627 struct pollfd polldata; /* Polling data */
1628 # else /* select() */
1629 fd_set input_set; /* Input set for select() */
1630 struct timeval stimeout; /* Timeout value for select() */
1631 # endif /* HAVE_POLL */
1632 # elif defined(HAVE_AVAHI)
1633 AvahiClient *client; /* Client information */
1634 int error; /* Status */
1635 # endif /* HAVE_DNSSD */
1636
1637 if (options & _HTTP_RESOLVE_STDERR)
1638 fprintf(stderr, "DEBUG: Resolving \"%s\"...\n", hostname);
1639
1640 /*
1641 * Separate the hostname into service name, registration type, and domain...
1642 */
1643
1644 for (regtype = strstr(hostname, "._tcp") - 2;
1645 regtype > hostname;
1646 regtype --)
1647 if (regtype[0] == '.' && regtype[1] == '_')
1648 {
1649 /*
1650 * Found ._servicetype in front of ._tcp...
1651 */
1652
1653 *regtype++ = '\0';
1654 break;
1655 }
1656
1657 if (regtype <= hostname)
1658 {
1659 DEBUG_puts("5_httpResolveURI: Bad hostname, returning NULL");
1660 return (NULL);
1661 }
1662
1663 for (domain = strchr(regtype, '.');
1664 domain;
1665 domain = strchr(domain + 1, '.'))
1666 if (domain[1] != '_')
1667 break;
1668
1669 if (domain)
1670 *domain++ = '\0';
1671
1672 if ((uuid = strstr(resource, "?uuid=")) != NULL)
1673 {
1674 *uuid = '\0';
1675 uuid += 6;
1676 if ((uuidend = strchr(uuid, '&')) != NULL)
1677 *uuidend = '\0';
1678 }
1679
1680 resolved_uri[0] = '\0';
1681
1682 uribuf.buffer = resolved_uri;
1683 uribuf.bufsize = resolved_size;
1684 uribuf.options = options;
1685 uribuf.resource = resource;
1686 uribuf.uuid = uuid;
1687
1688 DEBUG_printf(("6_httpResolveURI: Resolving hostname=\"%s\", regtype=\"%s\", "
1689 "domain=\"%s\"\n", hostname, regtype, domain));
1690 if (options & _HTTP_RESOLVE_STDERR)
1691 {
1692 fputs("STATE: +connecting-to-device\n", stderr);
1693 fprintf(stderr, "DEBUG: Resolving \"%s\", regtype=\"%s\", "
1694 "domain=\"local.\"...\n", hostname, regtype);
1695 }
1696
1697 uri = NULL;
1698
1699 # ifdef HAVE_DNSSD
1700 if (DNSServiceCreateConnection(&ref) == kDNSServiceErr_NoError)
1701 {
1702 uint32_t myinterface = kDNSServiceInterfaceIndexAny;
1703 /* Lookup on any interface */
1704
1705 if (!strcmp(scheme, "ippusb"))
1706 myinterface = kDNSServiceInterfaceIndexLocalOnly;
1707
1708 localref = ref;
1709 if (DNSServiceResolve(&localref,
1710 kDNSServiceFlagsShareConnection, myinterface,
1711 hostname, regtype, "local.", http_resolve_cb,
1712 &uribuf) == kDNSServiceErr_NoError)
1713 {
1714 int fds; /* Number of ready descriptors */
1715 time_t timeout, /* Poll timeout */
1716 start_time = time(NULL),/* Start time */
1717 end_time = start_time + 90;
1718 /* End time */
1719
1720 while (time(NULL) < end_time)
1721 {
1722 if (options & _HTTP_RESOLVE_STDERR)
1723 _cupsLangPrintFilter(stderr, "INFO", _("Looking for printer."));
1724
1725 if (cb && !(*cb)(context))
1726 {
1727 DEBUG_puts("5_httpResolveURI: callback returned 0 (stop)");
1728 break;
1729 }
1730
1731 /*
1732 * Wakeup every 2 seconds to emit a "looking for printer" message...
1733 */
1734
1735 if ((timeout = end_time - time(NULL)) > 2)
1736 timeout = 2;
1737
1738 # ifdef HAVE_POLL
1739 polldata.fd = DNSServiceRefSockFD(ref);
1740 polldata.events = POLLIN;
1741
1742 fds = poll(&polldata, 1, (int)(1000 * timeout));
1743
1744 # else /* select() */
1745 FD_ZERO(&input_set);
1746 FD_SET(DNSServiceRefSockFD(ref), &input_set);
1747
1748 # ifdef WIN32
1749 stimeout.tv_sec = (long)timeout;
1750 # else
1751 stimeout.tv_sec = timeout;
1752 # endif /* WIN32 */
1753 stimeout.tv_usec = 0;
1754
1755 fds = select(DNSServiceRefSockFD(ref)+1, &input_set, NULL, NULL,
1756 &stimeout);
1757 # endif /* HAVE_POLL */
1758
1759 if (fds < 0)
1760 {
1761 if (errno != EINTR && errno != EAGAIN)
1762 {
1763 DEBUG_printf(("5_httpResolveURI: poll error: %s", strerror(errno)));
1764 break;
1765 }
1766 }
1767 else if (fds == 0)
1768 {
1769 /*
1770 * Wait 2 seconds for a response to the local resolve; if nothing
1771 * comes in, do an additional domain resolution...
1772 */
1773
1774 if (domainsent == 0 && domain && _cups_strcasecmp(domain, "local."))
1775 {
1776 if (options & _HTTP_RESOLVE_STDERR)
1777 fprintf(stderr,
1778 "DEBUG: Resolving \"%s\", regtype=\"%s\", "
1779 "domain=\"%s\"...\n", hostname, regtype,
1780 domain ? domain : "");
1781
1782 domainref = ref;
1783 if (DNSServiceResolve(&domainref,
1784 kDNSServiceFlagsShareConnection,
1785 myinterface, hostname, regtype, domain,
1786 http_resolve_cb,
1787 &uribuf) == kDNSServiceErr_NoError)
1788 domainsent = 1;
1789 }
1790
1791 /*
1792 * If it hasn't resolved within 5 seconds set the offline-report
1793 * printer-state-reason...
1794 */
1795
1796 if ((options & _HTTP_RESOLVE_STDERR) && offline == 0 &&
1797 time(NULL) > (start_time + 5))
1798 {
1799 fputs("STATE: +offline-report\n", stderr);
1800 offline = 1;
1801 }
1802 }
1803 else
1804 {
1805 if (DNSServiceProcessResult(ref) == kDNSServiceErr_NoError &&
1806 resolved_uri[0])
1807 {
1808 uri = resolved_uri;
1809 break;
1810 }
1811 }
1812 }
1813
1814 if (domainsent)
1815 DNSServiceRefDeallocate(domainref);
1816
1817 DNSServiceRefDeallocate(localref);
1818 }
1819
1820 DNSServiceRefDeallocate(ref);
1821 }
1822 # else /* HAVE_AVAHI */
1823 if ((uribuf.poll = avahi_simple_poll_new()) != NULL)
1824 {
1825 avahi_simple_poll_set_func(uribuf.poll, http_poll_cb, NULL);
1826
1827 if ((client = avahi_client_new(avahi_simple_poll_get(uribuf.poll),
1828 0, http_client_cb,
1829 &uribuf, &error)) != NULL)
1830 {
1831 if (avahi_service_resolver_new(client, AVAHI_IF_UNSPEC,
1832 AVAHI_PROTO_UNSPEC, hostname,
1833 regtype, "local.", AVAHI_PROTO_UNSPEC, 0,
1834 http_resolve_cb, &uribuf) != NULL)
1835 {
1836 time_t start_time = time(NULL),
1837 /* Start time */
1838 end_time = start_time + 90;
1839 /* End time */
1840 int pstatus; /* Poll status */
1841
1842 pstatus = avahi_simple_poll_iterate(uribuf.poll, 2000);
1843
1844 if (pstatus == 0 && !resolved_uri[0] && domain &&
1845 _cups_strcasecmp(domain, "local."))
1846 {
1847 /*
1848 * Resolve for .local hasn't returned anything, try the listed
1849 * domain...
1850 */
1851
1852 avahi_service_resolver_new(client, AVAHI_IF_UNSPEC,
1853 AVAHI_PROTO_UNSPEC, hostname,
1854 regtype, domain, AVAHI_PROTO_UNSPEC, 0,
1855 http_resolve_cb, &uribuf);
1856 }
1857
1858 while (!pstatus && !resolved_uri[0] && time(NULL) < end_time)
1859 {
1860 if ((pstatus = avahi_simple_poll_iterate(uribuf.poll, 2000)) != 0)
1861 break;
1862
1863 /*
1864 * If it hasn't resolved within 5 seconds set the offline-report
1865 * printer-state-reason...
1866 */
1867
1868 if ((options & _HTTP_RESOLVE_STDERR) && offline == 0 &&
1869 time(NULL) > (start_time + 5))
1870 {
1871 fputs("STATE: +offline-report\n", stderr);
1872 offline = 1;
1873 }
1874 }
1875
1876 /*
1877 * Collect the result (if we got one).
1878 */
1879
1880 if (resolved_uri[0])
1881 uri = resolved_uri;
1882 }
1883
1884 avahi_client_free(client);
1885 }
1886
1887 avahi_simple_poll_free(uribuf.poll);
1888 }
1889 # endif /* HAVE_DNSSD */
1890
1891 if (options & _HTTP_RESOLVE_STDERR)
1892 {
1893 if (uri)
1894 {
1895 fprintf(stderr, "DEBUG: Resolved as \"%s\"...\n", uri);
1896 fputs("STATE: -connecting-to-device,offline-report\n", stderr);
1897 }
1898 else
1899 {
1900 fputs("DEBUG: Unable to resolve URI\n", stderr);
1901 fputs("STATE: -connecting-to-device\n", stderr);
1902 }
1903 }
1904
1905 #else /* HAVE_DNSSD || HAVE_AVAHI */
1906 /*
1907 * No DNS-SD support...
1908 */
1909
1910 uri = NULL;
1911 #endif /* HAVE_DNSSD || HAVE_AVAHI */
1912
1913 if ((options & _HTTP_RESOLVE_STDERR) && !uri)
1914 _cupsLangPrintFilter(stderr, "INFO", _("Unable to find printer."));
1915 }
1916 else
1917 {
1918 /*
1919 * Nothing more to do...
1920 */
1921
1922 strlcpy(resolved_uri, uri, resolved_size);
1923 uri = resolved_uri;
1924 }
1925
1926 DEBUG_printf(("5_httpResolveURI: Returning \"%s\"", uri));
1927
1928 return (uri);
1929 }
1930
1931
1932 #ifdef HAVE_AVAHI
1933 /*
1934 * 'http_client_cb()' - Client callback for resolving URI.
1935 */
1936
1937 static void
1938 http_client_cb(
1939 AvahiClient *client, /* I - Client information */
1940 AvahiClientState state, /* I - Current state */
1941 void *context) /* I - Pointer to URI buffer */
1942 {
1943 DEBUG_printf(("7http_client_cb(client=%p, state=%d, context=%p)", client,
1944 state, context));
1945
1946 /*
1947 * If the connection drops, quit.
1948 */
1949
1950 if (state == AVAHI_CLIENT_FAILURE)
1951 {
1952 _http_uribuf_t *uribuf = (_http_uribuf_t *)context;
1953 /* URI buffer */
1954
1955 avahi_simple_poll_quit(uribuf->poll);
1956 }
1957 }
1958 #endif /* HAVE_AVAHI */
1959
1960
1961 /*
1962 * 'http_copy_decode()' - Copy and decode a URI.
1963 */
1964
1965 static const char * /* O - New source pointer or NULL on error */
1966 http_copy_decode(char *dst, /* O - Destination buffer */
1967 const char *src, /* I - Source pointer */
1968 int dstsize, /* I - Destination size */
1969 const char *term, /* I - Terminating characters */
1970 int decode) /* I - Decode %-encoded values */
1971 {
1972 char *ptr, /* Pointer into buffer */
1973 *end; /* End of buffer */
1974 int quoted; /* Quoted character */
1975
1976
1977 /*
1978 * Copy the src to the destination until we hit a terminating character
1979 * or the end of the string.
1980 */
1981
1982 for (ptr = dst, end = dst + dstsize - 1;
1983 *src && (!term || !strchr(term, *src));
1984 src ++)
1985 if (ptr < end)
1986 {
1987 if (*src == '%' && decode)
1988 {
1989 if (isxdigit(src[1] & 255) && isxdigit(src[2] & 255))
1990 {
1991 /*
1992 * Grab a hex-encoded character...
1993 */
1994
1995 src ++;
1996 if (isalpha(*src))
1997 quoted = (tolower(*src) - 'a' + 10) << 4;
1998 else
1999 quoted = (*src - '0') << 4;
2000
2001 src ++;
2002 if (isalpha(*src))
2003 quoted |= tolower(*src) - 'a' + 10;
2004 else
2005 quoted |= *src - '0';
2006
2007 *ptr++ = (char)quoted;
2008 }
2009 else
2010 {
2011 /*
2012 * Bad hex-encoded character...
2013 */
2014
2015 *ptr = '\0';
2016 return (NULL);
2017 }
2018 }
2019 else if ((*src & 255) <= 0x20 || (*src & 255) >= 0x7f)
2020 {
2021 *ptr = '\0';
2022 return (NULL);
2023 }
2024 else
2025 *ptr++ = *src;
2026 }
2027
2028 *ptr = '\0';
2029
2030 return (src);
2031 }
2032
2033
2034 /*
2035 * 'http_copy_encode()' - Copy and encode a URI.
2036 */
2037
2038 static char * /* O - End of current URI */
2039 http_copy_encode(char *dst, /* O - Destination buffer */
2040 const char *src, /* I - Source pointer */
2041 char *dstend, /* I - End of destination buffer */
2042 const char *reserved, /* I - Extra reserved characters */
2043 const char *term, /* I - Terminating characters */
2044 int encode) /* I - %-encode reserved chars? */
2045 {
2046 static const char hex[] = "0123456789ABCDEF";
2047
2048
2049 while (*src && dst < dstend)
2050 {
2051 if (term && *src == *term)
2052 return (dst);
2053
2054 if (encode && (*src == '%' || *src <= ' ' || *src & 128 ||
2055 (reserved && strchr(reserved, *src))))
2056 {
2057 /*
2058 * Hex encode reserved characters...
2059 */
2060
2061 if ((dst + 2) >= dstend)
2062 break;
2063
2064 *dst++ = '%';
2065 *dst++ = hex[(*src >> 4) & 15];
2066 *dst++ = hex[*src & 15];
2067
2068 src ++;
2069 }
2070 else
2071 *dst++ = *src++;
2072 }
2073
2074 *dst = '\0';
2075
2076 if (*src)
2077 return (NULL);
2078 else
2079 return (dst);
2080 }
2081
2082
2083 #ifdef HAVE_DNSSD
2084 /*
2085 * 'http_resolve_cb()' - Build a device URI for the given service name.
2086 */
2087
2088 static void DNSSD_API
2089 http_resolve_cb(
2090 DNSServiceRef sdRef, /* I - Service reference */
2091 DNSServiceFlags flags, /* I - Results flags */
2092 uint32_t interfaceIndex, /* I - Interface number */
2093 DNSServiceErrorType errorCode, /* I - Error, if any */
2094 const char *fullName, /* I - Full service name */
2095 const char *hostTarget, /* I - Hostname */
2096 uint16_t port, /* I - Port number */
2097 uint16_t txtLen, /* I - Length of TXT record */
2098 const unsigned char *txtRecord, /* I - TXT record data */
2099 void *context) /* I - Pointer to URI buffer */
2100 {
2101 _http_uribuf_t *uribuf = (_http_uribuf_t *)context;
2102 /* URI buffer */
2103 const char *scheme, /* URI scheme */
2104 *hostptr, /* Pointer into hostTarget */
2105 *reskey, /* "rp" or "rfo" */
2106 *resdefault; /* Default path */
2107 char resource[257], /* Remote path */
2108 fqdn[256]; /* FQDN of the .local name */
2109 const void *value; /* Value from TXT record */
2110 uint8_t valueLen; /* Length of value */
2111
2112
2113 DEBUG_printf(("7http_resolve_cb(sdRef=%p, flags=%x, interfaceIndex=%u, "
2114 "errorCode=%d, fullName=\"%s\", hostTarget=\"%s\", port=%u, "
2115 "txtLen=%u, txtRecord=%p, context=%p)", sdRef, flags,
2116 interfaceIndex, errorCode, fullName, hostTarget, port, txtLen,
2117 txtRecord, context));
2118
2119 /*
2120 * If we have a UUID, compare it...
2121 */
2122
2123 if (uribuf->uuid &&
2124 (value = TXTRecordGetValuePtr(txtLen, txtRecord, "UUID",
2125 &valueLen)) != NULL)
2126 {
2127 char uuid[256]; /* UUID value */
2128
2129 memcpy(uuid, value, valueLen);
2130 uuid[valueLen] = '\0';
2131
2132 if (_cups_strcasecmp(uuid, uribuf->uuid))
2133 {
2134 if (uribuf->options & _HTTP_RESOLVE_STDERR)
2135 fprintf(stderr, "DEBUG: Found UUID %s, looking for %s.", uuid,
2136 uribuf->uuid);
2137
2138 DEBUG_printf(("7http_resolve_cb: Found UUID %s, looking for %s.", uuid,
2139 uribuf->uuid));
2140 return;
2141 }
2142 }
2143
2144 /*
2145 * Figure out the scheme from the full name...
2146 */
2147
2148 if (strstr(fullName, "._ipps") || strstr(fullName, "._ipp-tls"))
2149 scheme = "ipps";
2150 else if (strstr(fullName, "._ipp") || strstr(fullName, "._fax-ipp"))
2151 scheme = "ipp";
2152 else if (strstr(fullName, "._http."))
2153 scheme = "http";
2154 else if (strstr(fullName, "._https."))
2155 scheme = "https";
2156 else if (strstr(fullName, "._printer."))
2157 scheme = "lpd";
2158 else if (strstr(fullName, "._pdl-datastream."))
2159 scheme = "socket";
2160 else
2161 scheme = "riousbprint";
2162
2163 /*
2164 * Extract the "remote printer" key from the TXT record...
2165 */
2166
2167 if ((uribuf->options & _HTTP_RESOLVE_FAXOUT) &&
2168 (!strcmp(scheme, "ipp") || !strcmp(scheme, "ipps")) &&
2169 !TXTRecordGetValuePtr(txtLen, txtRecord, "printer-type", &valueLen))
2170 {
2171 reskey = "rfo";
2172 resdefault = "/ipp/faxout";
2173 }
2174 else
2175 {
2176 reskey = "rp";
2177 resdefault = "/";
2178 }
2179
2180 if ((value = TXTRecordGetValuePtr(txtLen, txtRecord, reskey,
2181 &valueLen)) != NULL)
2182 {
2183 if (((char *)value)[0] == '/')
2184 {
2185 /*
2186 * Value (incorrectly) has a leading slash already...
2187 */
2188
2189 memcpy(resource, value, valueLen);
2190 resource[valueLen] = '\0';
2191 }
2192 else
2193 {
2194 /*
2195 * Convert to resource by concatenating with a leading "/"...
2196 */
2197
2198 resource[0] = '/';
2199 memcpy(resource + 1, value, valueLen);
2200 resource[valueLen + 1] = '\0';
2201 }
2202 }
2203 else
2204 {
2205 /*
2206 * Use the default value...
2207 */
2208
2209 strlcpy(resource, resdefault, sizeof(resource));
2210 }
2211
2212 /*
2213 * Lookup the FQDN if needed...
2214 */
2215
2216 if ((uribuf->options & _HTTP_RESOLVE_FQDN) &&
2217 (hostptr = hostTarget + strlen(hostTarget) - 7) > hostTarget &&
2218 !_cups_strcasecmp(hostptr, ".local."))
2219 {
2220 /*
2221 * OK, we got a .local name but the caller needs a real domain. Start by
2222 * getting the IP address of the .local name and then do reverse-lookups...
2223 */
2224
2225 http_addrlist_t *addrlist, /* List of addresses */
2226 *addr; /* Current address */
2227
2228 DEBUG_printf(("8http_resolve_cb: Looking up \"%s\".", hostTarget));
2229
2230 snprintf(fqdn, sizeof(fqdn), "%d", ntohs(port));
2231 if ((addrlist = httpAddrGetList(hostTarget, AF_UNSPEC, fqdn)) != NULL)
2232 {
2233 for (addr = addrlist; addr; addr = addr->next)
2234 {
2235 int error = getnameinfo(&(addr->addr.addr), (socklen_t)httpAddrLength(&(addr->addr)), fqdn, sizeof(fqdn), NULL, 0, NI_NAMEREQD);
2236
2237 if (!error)
2238 {
2239 DEBUG_printf(("8http_resolve_cb: Found \"%s\".", fqdn));
2240
2241 if ((hostptr = fqdn + strlen(fqdn) - 6) <= fqdn ||
2242 _cups_strcasecmp(hostptr, ".local"))
2243 {
2244 hostTarget = fqdn;
2245 break;
2246 }
2247 }
2248 #ifdef DEBUG
2249 else
2250 DEBUG_printf(("8http_resolve_cb: \"%s\" did not resolve: %d",
2251 httpAddrString(&(addr->addr), fqdn, sizeof(fqdn)),
2252 error));
2253 #endif /* DEBUG */
2254 }
2255
2256 httpAddrFreeList(addrlist);
2257 }
2258 }
2259
2260 /*
2261 * Assemble the final device URI...
2262 */
2263
2264 if ((!strcmp(scheme, "ipp") || !strcmp(scheme, "ipps")) &&
2265 !strcmp(uribuf->resource, "/cups"))
2266 httpAssembleURIf(HTTP_URI_CODING_ALL, uribuf->buffer, (int)uribuf->bufsize, scheme, NULL, hostTarget, ntohs(port), "%s?snmp=false", resource);
2267 else
2268 httpAssembleURI(HTTP_URI_CODING_ALL, uribuf->buffer, (int)uribuf->bufsize, scheme, NULL, hostTarget, ntohs(port), resource);
2269
2270 DEBUG_printf(("8http_resolve_cb: Resolved URI is \"%s\"...", uribuf->buffer));
2271 }
2272
2273 #elif defined(HAVE_AVAHI)
2274 /*
2275 * 'http_poll_cb()' - Wait for input on the specified file descriptors.
2276 *
2277 * Note: This function is needed because avahi_simple_poll_iterate is broken
2278 * and always uses a timeout of 0 (!) milliseconds.
2279 * (Avahi Ticket #364)
2280 */
2281
2282 static int /* O - Number of file descriptors matching */
2283 http_poll_cb(
2284 struct pollfd *pollfds, /* I - File descriptors */
2285 unsigned int num_pollfds, /* I - Number of file descriptors */
2286 int timeout, /* I - Timeout in milliseconds (used) */
2287 void *context) /* I - User data (unused) */
2288 {
2289 (void)timeout;
2290 (void)context;
2291
2292 return (poll(pollfds, num_pollfds, 2000));
2293 }
2294
2295
2296 /*
2297 * 'http_resolve_cb()' - Build a device URI for the given service name.
2298 */
2299
2300 static void
2301 http_resolve_cb(
2302 AvahiServiceResolver *resolver, /* I - Resolver (unused) */
2303 AvahiIfIndex interface, /* I - Interface index (unused) */
2304 AvahiProtocol protocol, /* I - Network protocol (unused) */
2305 AvahiResolverEvent event, /* I - Event (found, etc.) */
2306 const char *name, /* I - Service name */
2307 const char *type, /* I - Registration type */
2308 const char *domain, /* I - Domain (unused) */
2309 const char *hostTarget, /* I - Hostname */
2310 const AvahiAddress *address, /* I - Address (unused) */
2311 uint16_t port, /* I - Port number */
2312 AvahiStringList *txt, /* I - TXT record */
2313 AvahiLookupResultFlags flags, /* I - Lookup flags (unused) */
2314 void *context) /* I - Pointer to URI buffer */
2315 {
2316 _http_uribuf_t *uribuf = (_http_uribuf_t *)context;
2317 /* URI buffer */
2318 const char *scheme, /* URI scheme */
2319 *hostptr, /* Pointer into hostTarget */
2320 *reskey, /* "rp" or "rfo" */
2321 *resdefault; /* Default path */
2322 char resource[257], /* Remote path */
2323 fqdn[256]; /* FQDN of the .local name */
2324 AvahiStringList *pair; /* Current TXT record key/value pair */
2325 char *value; /* Value for "rp" key */
2326 size_t valueLen = 0; /* Length of "rp" key */
2327
2328
2329 DEBUG_printf(("7http_resolve_cb(resolver=%p, "
2330 "interface=%d, protocol=%d, event=%d, name=\"%s\", "
2331 "type=\"%s\", domain=\"%s\", hostTarget=\"%s\", address=%p, "
2332 "port=%d, txt=%p, flags=%d, context=%p)",
2333 resolver, interface, protocol, event, name, type, domain,
2334 hostTarget, address, port, txt, flags, context));
2335
2336 if (event != AVAHI_RESOLVER_FOUND)
2337 {
2338 avahi_service_resolver_free(resolver);
2339 avahi_simple_poll_quit(uribuf->poll);
2340 return;
2341 }
2342
2343 /*
2344 * If we have a UUID, compare it...
2345 */
2346
2347 if (uribuf->uuid && (pair = avahi_string_list_find(txt, "UUID")) != NULL)
2348 {
2349 char uuid[256]; /* UUID value */
2350
2351 avahi_string_list_get_pair(pair, NULL, &value, &valueLen);
2352
2353 memcpy(uuid, value, valueLen);
2354 uuid[valueLen] = '\0';
2355
2356 if (_cups_strcasecmp(uuid, uribuf->uuid))
2357 {
2358 if (uribuf->options & _HTTP_RESOLVE_STDERR)
2359 fprintf(stderr, "DEBUG: Found UUID %s, looking for %s.", uuid,
2360 uribuf->uuid);
2361
2362 DEBUG_printf(("7http_resolve_cb: Found UUID %s, looking for %s.", uuid,
2363 uribuf->uuid));
2364 return;
2365 }
2366 }
2367
2368 /*
2369 * Figure out the scheme from the full name...
2370 */
2371
2372 if (strstr(type, "_ipp."))
2373 scheme = "ipp";
2374 else if (strstr(type, "_printer."))
2375 scheme = "lpd";
2376 else if (strstr(type, "_pdl-datastream."))
2377 scheme = "socket";
2378 else
2379 scheme = "riousbprint";
2380
2381 if (!strncmp(type, "_ipps.", 6) || !strncmp(type, "_ipp-tls.", 9))
2382 scheme = "ipps";
2383 else if (!strncmp(type, "_ipp.", 5) || !strncmp(type, "_fax-ipp.", 9))
2384 scheme = "ipp";
2385 else if (!strncmp(type, "_http.", 6))
2386 scheme = "http";
2387 else if (!strncmp(type, "_https.", 7))
2388 scheme = "https";
2389 else if (!strncmp(type, "_printer.", 9))
2390 scheme = "lpd";
2391 else if (!strncmp(type, "_pdl-datastream.", 16))
2392 scheme = "socket";
2393 else
2394 {
2395 avahi_service_resolver_free(resolver);
2396 avahi_simple_poll_quit(uribuf->poll);
2397 return;
2398 }
2399
2400 /*
2401 * Extract the remote resource key from the TXT record...
2402 */
2403
2404 if ((uribuf->options & _HTTP_RESOLVE_FAXOUT) &&
2405 (!strcmp(scheme, "ipp") || !strcmp(scheme, "ipps")) &&
2406 !avahi_string_list_find(txt, "printer-type"))
2407 {
2408 reskey = "rfo";
2409 resdefault = "/ipp/faxout";
2410 }
2411 else
2412 {
2413 reskey = "rp";
2414 resdefault = "/";
2415 }
2416
2417 if ((pair = avahi_string_list_find(txt, reskey)) != NULL)
2418 {
2419 avahi_string_list_get_pair(pair, NULL, &value, &valueLen);
2420
2421 if (value[0] == '/')
2422 {
2423 /*
2424 * Value (incorrectly) has a leading slash already...
2425 */
2426
2427 memcpy(resource, value, valueLen);
2428 resource[valueLen] = '\0';
2429 }
2430 else
2431 {
2432 /*
2433 * Convert to resource by concatenating with a leading "/"...
2434 */
2435
2436 resource[0] = '/';
2437 memcpy(resource + 1, value, valueLen);
2438 resource[valueLen + 1] = '\0';
2439 }
2440 }
2441 else
2442 {
2443 /*
2444 * Use the default value...
2445 */
2446
2447 strlcpy(resource, resdefault, sizeof(resource));
2448 }
2449
2450 /*
2451 * Lookup the FQDN if needed...
2452 */
2453
2454 if ((uribuf->options & _HTTP_RESOLVE_FQDN) &&
2455 (hostptr = hostTarget + strlen(hostTarget) - 6) > hostTarget &&
2456 !_cups_strcasecmp(hostptr, ".local"))
2457 {
2458 /*
2459 * OK, we got a .local name but the caller needs a real domain. Start by
2460 * getting the IP address of the .local name and then do reverse-lookups...
2461 */
2462
2463 http_addrlist_t *addrlist, /* List of addresses */
2464 *addr; /* Current address */
2465
2466 DEBUG_printf(("8http_resolve_cb: Looking up \"%s\".", hostTarget));
2467
2468 snprintf(fqdn, sizeof(fqdn), "%d", ntohs(port));
2469 if ((addrlist = httpAddrGetList(hostTarget, AF_UNSPEC, fqdn)) != NULL)
2470 {
2471 for (addr = addrlist; addr; addr = addr->next)
2472 {
2473 int error = getnameinfo(&(addr->addr.addr), (socklen_t)httpAddrLength(&(addr->addr)), fqdn, sizeof(fqdn), NULL, 0, NI_NAMEREQD);
2474
2475 if (!error)
2476 {
2477 DEBUG_printf(("8http_resolve_cb: Found \"%s\".", fqdn));
2478
2479 if ((hostptr = fqdn + strlen(fqdn) - 6) <= fqdn ||
2480 _cups_strcasecmp(hostptr, ".local"))
2481 {
2482 hostTarget = fqdn;
2483 break;
2484 }
2485 }
2486 #ifdef DEBUG
2487 else
2488 DEBUG_printf(("8http_resolve_cb: \"%s\" did not resolve: %d",
2489 httpAddrString(&(addr->addr), fqdn, sizeof(fqdn)),
2490 error));
2491 #endif /* DEBUG */
2492 }
2493
2494 httpAddrFreeList(addrlist);
2495 }
2496 }
2497
2498 /*
2499 * Assemble the final device URI using the resolved hostname...
2500 */
2501
2502 httpAssembleURI(HTTP_URI_CODING_ALL, uribuf->buffer, uribuf->bufsize, scheme,
2503 NULL, hostTarget, port, resource);
2504 DEBUG_printf(("8http_resolve_cb: Resolved URI is \"%s\".", uribuf->buffer));
2505
2506 avahi_simple_poll_quit(uribuf->poll);
2507 }
2508 #endif /* HAVE_DNSSD */
2509
2510
2511 /*
2512 * End of "$Id$".
2513 */
Unnamed repository; edit this file 'description' to name the repository.