]> 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 builds.
[thirdparty/cups.git] / cups / http-support.c
1 /*
2 * "$Id$"
3 *
4 * HTTP support routines for CUPS.
5 *
6 * Copyright 2007-2013 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, 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 (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, 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 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 = *in - 'A';
612 else if (*in >= 'a' && *in <= 'z')
613 base64 = *in - 'a' + 26;
614 else if (*in >= '0' && *in <= '9')
615 base64 = *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 = base64 << 2;
634 pos ++;
635 break;
636 case 1 :
637 if (outptr < outend)
638 *outptr++ |= (base64 >> 4) & 3;
639 if (outptr < outend)
640 *outptr = (base64 << 4) & 255;
641 pos ++;
642 break;
643 case 2 :
644 if (outptr < outend)
645 *outptr++ |= (base64 >> 2) & 15;
646 if (outptr < outend)
647 *outptr = (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, slen, "%s, %02d %s %d %02d:%02d:%02d GMT",
813 http_days[tdate->tm_wday], tdate->tm_mday,
814 http_months[tdate->tm_mon], tdate->tm_year + 1900,
815 tdate->tm_hour, tdate->tm_min, tdate->tm_sec);
816 else
817 s[0] = '\0';
818
819 return (s);
820 }
821
822
823 /*
824 * 'httpGetDateTime()' - Get a time value from a formatted date/time string.
825 */
826
827 time_t /* O - UNIX time */
828 httpGetDateTime(const char *s) /* I - Date/time string */
829 {
830 int i; /* Looping var */
831 char mon[16]; /* Abbreviated month name */
832 int day, year; /* Day of month and year */
833 int hour, min, sec; /* Time */
834 int days; /* Number of days since 1970 */
835 static const int normal_days[] = /* Days to a month, normal years */
836 { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 };
837 static const int leap_days[] = /* Days to a month, leap years */
838 { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 };
839
840
841 DEBUG_printf(("2httpGetDateTime(s=\"%s\")", s));
842
843 /*
844 * Extract the date and time from the formatted string...
845 */
846
847 if (sscanf(s, "%*s%d%15s%d%d:%d:%d", &day, mon, &year, &hour, &min, &sec) < 6)
848 return (0);
849
850 DEBUG_printf(("4httpGetDateTime: day=%d, mon=\"%s\", year=%d, hour=%d, "
851 "min=%d, sec=%d", day, mon, year, hour, min, sec));
852
853 /*
854 * Convert the month name to a number from 0 to 11.
855 */
856
857 for (i = 0; i < 12; i ++)
858 if (!_cups_strcasecmp(mon, http_months[i]))
859 break;
860
861 if (i >= 12)
862 return (0);
863
864 DEBUG_printf(("4httpGetDateTime: i=%d", i));
865
866 /*
867 * Now convert the date and time to a UNIX time value in seconds since
868 * 1970. We can't use mktime() since the timezone may not be UTC but
869 * the date/time string *is* UTC.
870 */
871
872 if ((year & 3) == 0 && ((year % 100) != 0 || (year % 400) == 0))
873 days = leap_days[i] + day - 1;
874 else
875 days = normal_days[i] + day - 1;
876
877 DEBUG_printf(("4httpGetDateTime: days=%d", days));
878
879 days += (year - 1970) * 365 + /* 365 days per year (normally) */
880 ((year - 1) / 4 - 492) - /* + leap days */
881 ((year - 1) / 100 - 19) + /* - 100 year days */
882 ((year - 1) / 400 - 4); /* + 400 year days */
883
884 DEBUG_printf(("4httpGetDateTime: days=%d\n", days));
885
886 return (days * 86400 + hour * 3600 + min * 60 + sec);
887 }
888
889
890 /*
891 * 'httpSeparate()' - Separate a Universal Resource Identifier into its
892 * components.
893 *
894 * This function is deprecated; use the httpSeparateURI() function instead.
895 *
896 * @deprecated@
897 */
898
899 void
900 httpSeparate(const char *uri, /* I - Universal Resource Identifier */
901 char *scheme, /* O - Scheme [32] (http, https, etc.) */
902 char *username, /* O - Username [1024] */
903 char *host, /* O - Hostname [1024] */
904 int *port, /* O - Port number to use */
905 char *resource) /* O - Resource/filename [1024] */
906 {
907 httpSeparateURI(HTTP_URI_CODING_ALL, uri, scheme, 32, username,
908 HTTP_MAX_URI, host, HTTP_MAX_URI, port, resource,
909 HTTP_MAX_URI);
910 }
911
912
913 /*
914 * 'httpSeparate2()' - Separate a Universal Resource Identifier into its
915 * components.
916 *
917 * This function is deprecated; use the httpSeparateURI() function instead.
918 *
919 * @since CUPS 1.1.21/OS X 10.4@
920 * @deprecated@
921 */
922
923 void
924 httpSeparate2(const char *uri, /* I - Universal Resource Identifier */
925 char *scheme, /* O - Scheme (http, https, etc.) */
926 int schemelen, /* I - Size of scheme buffer */
927 char *username, /* O - Username */
928 int usernamelen, /* I - Size of username buffer */
929 char *host, /* O - Hostname */
930 int hostlen, /* I - Size of hostname buffer */
931 int *port, /* O - Port number to use */
932 char *resource, /* O - Resource/filename */
933 int resourcelen) /* I - Size of resource buffer */
934 {
935 httpSeparateURI(HTTP_URI_CODING_ALL, uri, scheme, schemelen, username,
936 usernamelen, host, hostlen, port, resource, resourcelen);
937 }
938
939
940 /*
941 * 'httpSeparateURI()' - Separate a Universal Resource Identifier into its
942 * components.
943 *
944 * @since CUPS 1.2/OS X 10.5@
945 */
946
947 http_uri_status_t /* O - Result of separation */
948 httpSeparateURI(
949 http_uri_coding_t decoding, /* I - Decoding flags */
950 const char *uri, /* I - Universal Resource Identifier */
951 char *scheme, /* O - Scheme (http, https, etc.) */
952 int schemelen, /* I - Size of scheme buffer */
953 char *username, /* O - Username */
954 int usernamelen, /* I - Size of username buffer */
955 char *host, /* O - Hostname */
956 int hostlen, /* I - Size of hostname buffer */
957 int *port, /* O - Port number to use */
958 char *resource, /* O - Resource/filename */
959 int resourcelen) /* I - Size of resource buffer */
960 {
961 char *ptr, /* Pointer into string... */
962 *end; /* End of string */
963 const char *sep; /* Separator character */
964 http_uri_status_t status; /* Result of separation */
965
966
967 /*
968 * Initialize everything to blank...
969 */
970
971 if (scheme && schemelen > 0)
972 *scheme = '\0';
973
974 if (username && usernamelen > 0)
975 *username = '\0';
976
977 if (host && hostlen > 0)
978 *host = '\0';
979
980 if (port)
981 *port = 0;
982
983 if (resource && resourcelen > 0)
984 *resource = '\0';
985
986 /*
987 * Range check input...
988 */
989
990 if (!uri || !port || !scheme || schemelen <= 0 || !username ||
991 usernamelen <= 0 || !host || hostlen <= 0 || !resource ||
992 resourcelen <= 0)
993 return (HTTP_URI_STATUS_BAD_ARGUMENTS);
994
995 if (!*uri)
996 return (HTTP_URI_STATUS_BAD_URI);
997
998 /*
999 * Grab the scheme portion of the URI...
1000 */
1001
1002 status = HTTP_URI_STATUS_OK;
1003
1004 if (!strncmp(uri, "//", 2))
1005 {
1006 /*
1007 * Workaround for HP IPP client bug...
1008 */
1009
1010 strlcpy(scheme, "ipp", schemelen);
1011 status = HTTP_URI_STATUS_MISSING_SCHEME;
1012 }
1013 else if (*uri == '/')
1014 {
1015 /*
1016 * Filename...
1017 */
1018
1019 strlcpy(scheme, "file", schemelen);
1020 status = HTTP_URI_STATUS_MISSING_SCHEME;
1021 }
1022 else
1023 {
1024 /*
1025 * Standard URI with scheme...
1026 */
1027
1028 for (ptr = scheme, end = scheme + schemelen - 1;
1029 *uri && *uri != ':' && ptr < end;)
1030 if (strchr("ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1031 "abcdefghijklmnopqrstuvwxyz"
1032 "0123456789-+.", *uri) != NULL)
1033 *ptr++ = *uri++;
1034 else
1035 break;
1036
1037 *ptr = '\0';
1038
1039 if (*uri != ':')
1040 {
1041 *scheme = '\0';
1042 return (HTTP_URI_STATUS_BAD_SCHEME);
1043 }
1044
1045 uri ++;
1046 }
1047
1048 /*
1049 * Set the default port number...
1050 */
1051
1052 if (!strcmp(scheme, "http"))
1053 *port = 80;
1054 else if (!strcmp(scheme, "https"))
1055 *port = 443;
1056 else if (!strcmp(scheme, "ipp") || !strcmp(scheme, "ipps"))
1057 *port = 631;
1058 else if (!_cups_strcasecmp(scheme, "lpd"))
1059 *port = 515;
1060 else if (!strcmp(scheme, "socket")) /* Not yet registered with IANA... */
1061 *port = 9100;
1062 else if (strcmp(scheme, "file") && strcmp(scheme, "mailto") && strcmp(scheme, "tel"))
1063 status = HTTP_URI_STATUS_UNKNOWN_SCHEME;
1064
1065 /*
1066 * Now see if we have a hostname...
1067 */
1068
1069 if (!strncmp(uri, "//", 2))
1070 {
1071 /*
1072 * Yes, extract it...
1073 */
1074
1075 uri += 2;
1076
1077 /*
1078 * Grab the username, if any...
1079 */
1080
1081 if ((sep = strpbrk(uri, "@/")) != NULL && *sep == '@')
1082 {
1083 /*
1084 * Get a username:password combo...
1085 */
1086
1087 uri = http_copy_decode(username, uri, usernamelen, "@",
1088 decoding & HTTP_URI_CODING_USERNAME);
1089
1090 if (!uri)
1091 {
1092 *username = '\0';
1093 return (HTTP_URI_STATUS_BAD_USERNAME);
1094 }
1095
1096 uri ++;
1097 }
1098
1099 /*
1100 * Then the hostname/IP address...
1101 */
1102
1103 if (*uri == '[')
1104 {
1105 /*
1106 * Grab IPv6 address...
1107 */
1108
1109 uri ++;
1110 if (*uri == 'v')
1111 {
1112 /*
1113 * Skip IPvFuture ("vXXXX.") prefix...
1114 */
1115
1116 uri ++;
1117
1118 while (isxdigit(*uri & 255))
1119 uri ++;
1120
1121 if (*uri != '.')
1122 {
1123 *host = '\0';
1124 return (HTTP_URI_STATUS_BAD_HOSTNAME);
1125 }
1126
1127 uri ++;
1128 }
1129
1130 uri = http_copy_decode(host, uri, hostlen, "]",
1131 decoding & HTTP_URI_CODING_HOSTNAME);
1132
1133 if (!uri)
1134 {
1135 *host = '\0';
1136 return (HTTP_URI_STATUS_BAD_HOSTNAME);
1137 }
1138
1139 /*
1140 * Validate value...
1141 */
1142
1143 if (*uri != ']')
1144 {
1145 *host = '\0';
1146 return (HTTP_URI_STATUS_BAD_HOSTNAME);
1147 }
1148
1149 uri ++;
1150
1151 for (ptr = host; *ptr; ptr ++)
1152 if (*ptr == '+')
1153 {
1154 /*
1155 * Convert zone separator to % and stop here...
1156 */
1157
1158 *ptr = '%';
1159 break;
1160 }
1161 else if (*ptr == '%')
1162 {
1163 /*
1164 * Stop at zone separator (RFC 6874)
1165 */
1166
1167 break;
1168 }
1169 else if (*ptr != ':' && *ptr != '.' && !isxdigit(*ptr & 255))
1170 {
1171 *host = '\0';
1172 return (HTTP_URI_STATUS_BAD_HOSTNAME);
1173 }
1174 }
1175 else
1176 {
1177 /*
1178 * Validate the hostname or IPv4 address first...
1179 */
1180
1181 for (ptr = (char *)uri; *ptr; ptr ++)
1182 if (strchr(":?/", *ptr))
1183 break;
1184 else if (!strchr("abcdefghijklmnopqrstuvwxyz" /* unreserved */
1185 "ABCDEFGHIJKLMNOPQRSTUVWXYZ" /* unreserved */
1186 "0123456789" /* unreserved */
1187 "-._~" /* unreserved */
1188 "%" /* pct-encoded */
1189 "!$&'()*+,;=" /* sub-delims */
1190 "\\", *ptr)) /* SMB domain */
1191 {
1192 *host = '\0';
1193 return (HTTP_URI_STATUS_BAD_HOSTNAME);
1194 }
1195
1196 /*
1197 * Then copy the hostname or IPv4 address to the buffer...
1198 */
1199
1200 uri = http_copy_decode(host, uri, hostlen, ":?/",
1201 decoding & HTTP_URI_CODING_HOSTNAME);
1202
1203 if (!uri)
1204 {
1205 *host = '\0';
1206 return (HTTP_URI_STATUS_BAD_HOSTNAME);
1207 }
1208 }
1209
1210 /*
1211 * Validate hostname for file scheme - only empty and localhost are
1212 * acceptable.
1213 */
1214
1215 if (!strcmp(scheme, "file") && strcmp(host, "localhost") && host[0])
1216 {
1217 *host = '\0';
1218 return (HTTP_URI_STATUS_BAD_HOSTNAME);
1219 }
1220
1221 /*
1222 * See if we have a port number...
1223 */
1224
1225 if (*uri == ':')
1226 {
1227 /*
1228 * Yes, collect the port number...
1229 */
1230
1231 if (!isdigit(uri[1] & 255))
1232 {
1233 *port = 0;
1234 return (HTTP_URI_STATUS_BAD_PORT);
1235 }
1236
1237 *port = strtol(uri + 1, (char **)&uri, 10);
1238
1239 if (*uri != '/' && *uri)
1240 {
1241 *port = 0;
1242 return (HTTP_URI_STATUS_BAD_PORT);
1243 }
1244 }
1245 }
1246
1247 /*
1248 * The remaining portion is the resource string...
1249 */
1250
1251 if (*uri == '?' || !*uri)
1252 {
1253 /*
1254 * Hostname but no path...
1255 */
1256
1257 status = HTTP_URI_STATUS_MISSING_RESOURCE;
1258 *resource = '/';
1259
1260 /*
1261 * Copy any query string...
1262 */
1263
1264 if (*uri == '?')
1265 uri = http_copy_decode(resource + 1, uri, resourcelen - 1, NULL,
1266 decoding & HTTP_URI_CODING_QUERY);
1267 else
1268 resource[1] = '\0';
1269 }
1270 else
1271 {
1272 uri = http_copy_decode(resource, uri, resourcelen, "?",
1273 decoding & HTTP_URI_CODING_RESOURCE);
1274
1275 if (uri && *uri == '?')
1276 {
1277 /*
1278 * Concatenate any query string...
1279 */
1280
1281 char *resptr = resource + strlen(resource);
1282
1283 uri = http_copy_decode(resptr, uri,
1284 resourcelen - (int)(resptr - resource), NULL,
1285 decoding & HTTP_URI_CODING_QUERY);
1286 }
1287 }
1288
1289 if (!uri)
1290 {
1291 *resource = '\0';
1292 return (HTTP_URI_STATUS_BAD_RESOURCE);
1293 }
1294
1295 /*
1296 * Return the URI separation status...
1297 */
1298
1299 return (status);
1300 }
1301
1302
1303 /*
1304 * 'httpStateString()' - Return the string describing a HTTP state value.
1305 *
1306 * @since CUPS 2.0@
1307 */
1308
1309 const char * /* O - State string */
1310 httpStateString(http_state_t state) /* I - HTTP state value */
1311 {
1312 if (state < HTTP_STATE_ERROR || state > HTTP_STATE_UNKNOWN_VERSION)
1313 return ("HTTP_STATE_???");
1314 else
1315 return (http_states[state - HTTP_STATE_ERROR]);
1316 }
1317
1318
1319 /*
1320 * '_httpStatus()' - Return the localized string describing a HTTP status code.
1321 *
1322 * The returned string is localized using the passed message catalog.
1323 */
1324
1325 const char * /* O - Localized status string */
1326 _httpStatus(cups_lang_t *lang, /* I - Language */
1327 http_status_t status) /* I - HTTP status code */
1328 {
1329 const char *s; /* Status string */
1330
1331
1332 switch (status)
1333 {
1334 case HTTP_STATUS_ERROR :
1335 s = strerror(errno);
1336 break;
1337 case HTTP_STATUS_CONTINUE :
1338 s = _("Continue");
1339 break;
1340 case HTTP_STATUS_SWITCHING_PROTOCOLS :
1341 s = _("Switching Protocols");
1342 break;
1343 case HTTP_STATUS_OK :
1344 s = _("OK");
1345 break;
1346 case HTTP_STATUS_CREATED :
1347 s = _("Created");
1348 break;
1349 case HTTP_STATUS_ACCEPTED :
1350 s = _("Accepted");
1351 break;
1352 case HTTP_STATUS_NO_CONTENT :
1353 s = _("No Content");
1354 break;
1355 case HTTP_STATUS_MOVED_PERMANENTLY :
1356 s = _("Moved Permanently");
1357 break;
1358 case HTTP_STATUS_SEE_OTHER :
1359 s = _("See Other");
1360 break;
1361 case HTTP_STATUS_NOT_MODIFIED :
1362 s = _("Not Modified");
1363 break;
1364 case HTTP_STATUS_BAD_REQUEST :
1365 s = _("Bad Request");
1366 break;
1367 case HTTP_STATUS_UNAUTHORIZED :
1368 case HTTP_STATUS_CUPS_AUTHORIZATION_CANCELED :
1369 s = _("Unauthorized");
1370 break;
1371 case HTTP_STATUS_FORBIDDEN :
1372 s = _("Forbidden");
1373 break;
1374 case HTTP_STATUS_NOT_FOUND :
1375 s = _("Not Found");
1376 break;
1377 case HTTP_STATUS_REQUEST_TOO_LARGE :
1378 s = _("Request Entity Too Large");
1379 break;
1380 case HTTP_STATUS_URI_TOO_LONG :
1381 s = _("URI Too Long");
1382 break;
1383 case HTTP_STATUS_UPGRADE_REQUIRED :
1384 s = _("Upgrade Required");
1385 break;
1386 case HTTP_STATUS_NOT_IMPLEMENTED :
1387 s = _("Not Implemented");
1388 break;
1389 case HTTP_STATUS_NOT_SUPPORTED :
1390 s = _("Not Supported");
1391 break;
1392 case HTTP_STATUS_EXPECTATION_FAILED :
1393 s = _("Expectation Failed");
1394 break;
1395 case HTTP_STATUS_SERVICE_UNAVAILABLE :
1396 s = _("Service Unavailable");
1397 break;
1398 case HTTP_STATUS_SERVER_ERROR :
1399 s = _("Internal Server Error");
1400 break;
1401 case HTTP_STATUS_CUPS_PKI_ERROR :
1402 s = _("SSL/TLS Negotiation Error");
1403 break;
1404 case HTTP_STATUS_CUPS_WEBIF_DISABLED :
1405 s = _("Web Interface is Disabled");
1406 break;
1407
1408 default :
1409 s = _("Unknown");
1410 break;
1411 }
1412
1413 return (_cupsLangString(lang, s));
1414 }
1415
1416
1417 /*
1418 * 'httpStatus()' - Return a short string describing a HTTP status code.
1419 *
1420 * The returned string is localized to the current POSIX locale and is based
1421 * on the status strings defined in RFC 2616.
1422 */
1423
1424 const char * /* O - Localized status string */
1425 httpStatus(http_status_t status) /* I - HTTP status code */
1426 {
1427 _cups_globals_t *cg = _cupsGlobals(); /* Global data */
1428
1429
1430 if (!cg->lang_default)
1431 cg->lang_default = cupsLangDefault();
1432
1433 return (_httpStatus(cg->lang_default, status));
1434 }
1435
1436
1437 #ifndef HAVE_HSTRERROR
1438 /*
1439 * '_cups_hstrerror()' - hstrerror() emulation function for Solaris and others.
1440 */
1441
1442 const char * /* O - Error string */
1443 _cups_hstrerror(int error) /* I - Error number */
1444 {
1445 static const char * const errors[] = /* Error strings */
1446 {
1447 "OK",
1448 "Host not found.",
1449 "Try again.",
1450 "Unrecoverable lookup error.",
1451 "No data associated with name."
1452 };
1453
1454
1455 if (error < 0 || error > 4)
1456 return ("Unknown hostname lookup error.");
1457 else
1458 return (errors[error]);
1459 }
1460 #endif /* !HAVE_HSTRERROR */
1461
1462
1463 /*
1464 * '_httpDecodeURI()' - Percent-decode a HTTP request URI.
1465 */
1466
1467 char * /* O - Decoded URI or NULL on error */
1468 _httpDecodeURI(char *dst, /* I - Destination buffer */
1469 const char *src, /* I - Source URI */
1470 size_t dstsize) /* I - Size of destination buffer */
1471 {
1472 if (http_copy_decode(dst, src, (int)dstsize, NULL, 1))
1473 return (dst);
1474 else
1475 return (NULL);
1476 }
1477
1478
1479 /*
1480 * '_httpEncodeURI()' - Percent-encode a HTTP request URI.
1481 */
1482
1483 char * /* O - Encoded URI */
1484 _httpEncodeURI(char *dst, /* I - Destination buffer */
1485 const char *src, /* I - Source URI */
1486 size_t dstsize) /* I - Size of destination buffer */
1487 {
1488 http_copy_encode(dst, src, dst + dstsize - 1, NULL, NULL, 1);
1489 return (dst);
1490 }
1491
1492
1493 /*
1494 * '_httpResolveURI()' - Resolve a DNS-SD URI.
1495 */
1496
1497 const char * /* O - Resolved URI */
1498 _httpResolveURI(
1499 const char *uri, /* I - DNS-SD URI */
1500 char *resolved_uri, /* I - Buffer for resolved URI */
1501 size_t resolved_size, /* I - Size of URI buffer */
1502 int options, /* I - Resolve options */
1503 int (*cb)(void *context), /* I - Continue callback function */
1504 void *context) /* I - Context pointer for callback */
1505 {
1506 char scheme[32], /* URI components... */
1507 userpass[256],
1508 hostname[1024],
1509 resource[1024];
1510 int port;
1511 #ifdef DEBUG
1512 http_uri_status_t status; /* URI decode status */
1513 #endif /* DEBUG */
1514
1515
1516 DEBUG_printf(("4_httpResolveURI(uri=\"%s\", resolved_uri=%p, "
1517 "resolved_size=" CUPS_LLFMT ")", uri, resolved_uri,
1518 CUPS_LLCAST resolved_size));
1519
1520 /*
1521 * Get the device URI...
1522 */
1523
1524 #ifdef DEBUG
1525 if ((status = httpSeparateURI(HTTP_URI_CODING_ALL, uri, scheme,
1526 sizeof(scheme), userpass, sizeof(userpass),
1527 hostname, sizeof(hostname), &port, resource,
1528 sizeof(resource))) < HTTP_URI_STATUS_OK)
1529 #else
1530 if (httpSeparateURI(HTTP_URI_CODING_ALL, uri, scheme,
1531 sizeof(scheme), userpass, sizeof(userpass),
1532 hostname, sizeof(hostname), &port, resource,
1533 sizeof(resource)) < HTTP_URI_STATUS_OK)
1534 #endif /* DEBUG */
1535 {
1536 if (options & _HTTP_RESOLVE_STDERR)
1537 _cupsLangPrintFilter(stderr, "ERROR", _("Bad device-uri \"%s\"."), uri);
1538
1539 DEBUG_printf(("6_httpResolveURI: httpSeparateURI returned %d!", status));
1540 DEBUG_puts("5_httpResolveURI: Returning NULL");
1541 return (NULL);
1542 }
1543
1544 /*
1545 * Resolve it as needed...
1546 */
1547
1548 if (strstr(hostname, "._tcp"))
1549 {
1550 #if defined(HAVE_DNSSD) || defined(HAVE_AVAHI)
1551 char *regtype, /* Pointer to type in hostname */
1552 *domain, /* Pointer to domain in hostname */
1553 *uuid, /* Pointer to UUID in URI */
1554 *uuidend; /* Pointer to end of UUID in URI */
1555 _http_uribuf_t uribuf; /* URI buffer */
1556 int offline = 0; /* offline-report state set? */
1557 # ifdef HAVE_DNSSD
1558 # ifdef WIN32
1559 # pragma comment(lib, "dnssd.lib")
1560 # endif /* WIN32 */
1561 DNSServiceRef ref, /* DNS-SD master service reference */
1562 domainref, /* DNS-SD service reference for domain */
1563 localref; /* DNS-SD service reference for .local */
1564 int domainsent = 0; /* Send the domain resolve? */
1565 # ifdef HAVE_POLL
1566 struct pollfd polldata; /* Polling data */
1567 # else /* select() */
1568 fd_set input_set; /* Input set for select() */
1569 struct timeval stimeout; /* Timeout value for select() */
1570 # endif /* HAVE_POLL */
1571 # elif defined(HAVE_AVAHI)
1572 AvahiClient *client; /* Client information */
1573 int error; /* Status */
1574 # endif /* HAVE_DNSSD */
1575
1576 if (options & _HTTP_RESOLVE_STDERR)
1577 fprintf(stderr, "DEBUG: Resolving \"%s\"...\n", hostname);
1578
1579 /*
1580 * Separate the hostname into service name, registration type, and domain...
1581 */
1582
1583 for (regtype = strstr(hostname, "._tcp") - 2;
1584 regtype > hostname;
1585 regtype --)
1586 if (regtype[0] == '.' && regtype[1] == '_')
1587 {
1588 /*
1589 * Found ._servicetype in front of ._tcp...
1590 */
1591
1592 *regtype++ = '\0';
1593 break;
1594 }
1595
1596 if (regtype <= hostname)
1597 {
1598 DEBUG_puts("5_httpResolveURI: Bad hostname, returning NULL");
1599 return (NULL);
1600 }
1601
1602 for (domain = strchr(regtype, '.');
1603 domain;
1604 domain = strchr(domain + 1, '.'))
1605 if (domain[1] != '_')
1606 break;
1607
1608 if (domain)
1609 *domain++ = '\0';
1610
1611 if ((uuid = strstr(resource, "?uuid=")) != NULL)
1612 {
1613 *uuid = '\0';
1614 uuid += 6;
1615 if ((uuidend = strchr(uuid, '&')) != NULL)
1616 *uuidend = '\0';
1617 }
1618
1619 resolved_uri[0] = '\0';
1620
1621 uribuf.buffer = resolved_uri;
1622 uribuf.bufsize = resolved_size;
1623 uribuf.options = options;
1624 uribuf.resource = resource;
1625 uribuf.uuid = uuid;
1626
1627 DEBUG_printf(("6_httpResolveURI: Resolving hostname=\"%s\", regtype=\"%s\", "
1628 "domain=\"%s\"\n", hostname, regtype, domain));
1629 if (options & _HTTP_RESOLVE_STDERR)
1630 {
1631 fputs("STATE: +connecting-to-device\n", stderr);
1632 fprintf(stderr, "DEBUG: Resolving \"%s\", regtype=\"%s\", "
1633 "domain=\"local.\"...\n", hostname, regtype);
1634 }
1635
1636 uri = NULL;
1637
1638 # ifdef HAVE_DNSSD
1639 if (DNSServiceCreateConnection(&ref) == kDNSServiceErr_NoError)
1640 {
1641 int myinterface = kDNSServiceInterfaceIndexAny;
1642 /* Lookup on any interface */
1643
1644 if (!strcmp(scheme, "ippusb"))
1645 myinterface = kDNSServiceInterfaceIndexLocalOnly;
1646
1647 localref = ref;
1648 if (DNSServiceResolve(&localref,
1649 kDNSServiceFlagsShareConnection, myinterface,
1650 hostname, regtype, "local.", http_resolve_cb,
1651 &uribuf) == kDNSServiceErr_NoError)
1652 {
1653 int fds; /* Number of ready descriptors */
1654 time_t timeout, /* Poll timeout */
1655 start_time = time(NULL),/* Start time */
1656 end_time = start_time + 90;
1657 /* End time */
1658
1659 while (time(NULL) < end_time)
1660 {
1661 if (options & _HTTP_RESOLVE_STDERR)
1662 _cupsLangPrintFilter(stderr, "INFO", _("Looking for printer."));
1663
1664 if (cb && !(*cb)(context))
1665 {
1666 DEBUG_puts("5_httpResolveURI: callback returned 0 (stop)");
1667 break;
1668 }
1669
1670 /*
1671 * Wakeup every 2 seconds to emit a "looking for printer" message...
1672 */
1673
1674 if ((timeout = end_time - time(NULL)) > 2)
1675 timeout = 2;
1676
1677 # ifdef HAVE_POLL
1678 polldata.fd = DNSServiceRefSockFD(ref);
1679 polldata.events = POLLIN;
1680
1681 fds = poll(&polldata, 1, 1000 * timeout);
1682
1683 # else /* select() */
1684 FD_ZERO(&input_set);
1685 FD_SET(DNSServiceRefSockFD(ref), &input_set);
1686
1687 # ifdef WIN32
1688 stimeout.tv_sec = (long)timeout;
1689 # else
1690 stimeout.tv_sec = timeout;
1691 # endif /* WIN32 */
1692 stimeout.tv_usec = 0;
1693
1694 fds = select(DNSServiceRefSockFD(ref)+1, &input_set, NULL, NULL,
1695 &stimeout);
1696 # endif /* HAVE_POLL */
1697
1698 if (fds < 0)
1699 {
1700 if (errno != EINTR && errno != EAGAIN)
1701 {
1702 DEBUG_printf(("5_httpResolveURI: poll error: %s", strerror(errno)));
1703 break;
1704 }
1705 }
1706 else if (fds == 0)
1707 {
1708 /*
1709 * Wait 2 seconds for a response to the local resolve; if nothing
1710 * comes in, do an additional domain resolution...
1711 */
1712
1713 if (domainsent == 0 && domain && _cups_strcasecmp(domain, "local."))
1714 {
1715 if (options & _HTTP_RESOLVE_STDERR)
1716 fprintf(stderr,
1717 "DEBUG: Resolving \"%s\", regtype=\"%s\", "
1718 "domain=\"%s\"...\n", hostname, regtype,
1719 domain ? domain : "");
1720
1721 domainref = ref;
1722 if (DNSServiceResolve(&domainref,
1723 kDNSServiceFlagsShareConnection,
1724 myinterface, hostname, regtype, domain,
1725 http_resolve_cb,
1726 &uribuf) == kDNSServiceErr_NoError)
1727 domainsent = 1;
1728 }
1729
1730 /*
1731 * If it hasn't resolved within 5 seconds set the offline-report
1732 * printer-state-reason...
1733 */
1734
1735 if ((options & _HTTP_RESOLVE_STDERR) && offline == 0 &&
1736 time(NULL) > (start_time + 5))
1737 {
1738 fputs("STATE: +offline-report\n", stderr);
1739 offline = 1;
1740 }
1741 }
1742 else
1743 {
1744 if (DNSServiceProcessResult(ref) == kDNSServiceErr_NoError &&
1745 resolved_uri[0])
1746 {
1747 uri = resolved_uri;
1748 break;
1749 }
1750 }
1751 }
1752
1753 if (domainsent)
1754 DNSServiceRefDeallocate(domainref);
1755
1756 DNSServiceRefDeallocate(localref);
1757 }
1758
1759 DNSServiceRefDeallocate(ref);
1760 }
1761 # else /* HAVE_AVAHI */
1762 if ((uribuf.poll = avahi_simple_poll_new()) != NULL)
1763 {
1764 avahi_simple_poll_set_func(uribuf.poll, http_poll_cb, NULL);
1765
1766 if ((client = avahi_client_new(avahi_simple_poll_get(uribuf.poll),
1767 0, http_client_cb,
1768 &uribuf, &error)) != NULL)
1769 {
1770 if (avahi_service_resolver_new(client, AVAHI_IF_UNSPEC,
1771 AVAHI_PROTO_UNSPEC, hostname,
1772 regtype, "local.", AVAHI_PROTO_UNSPEC, 0,
1773 http_resolve_cb, &uribuf) != NULL)
1774 {
1775 time_t start_time = time(NULL),
1776 /* Start time */
1777 end_time = start_time + 90;
1778 /* End time */
1779 int pstatus; /* Poll status */
1780
1781 pstatus = avahi_simple_poll_iterate(uribuf.poll, 2000);
1782
1783 if (pstatus == 0 && !resolved_uri[0] && domain &&
1784 _cups_strcasecmp(domain, "local."))
1785 {
1786 /*
1787 * Resolve for .local hasn't returned anything, try the listed
1788 * domain...
1789 */
1790
1791 avahi_service_resolver_new(client, AVAHI_IF_UNSPEC,
1792 AVAHI_PROTO_UNSPEC, hostname,
1793 regtype, domain, AVAHI_PROTO_UNSPEC, 0,
1794 http_resolve_cb, &uribuf);
1795 }
1796
1797 while (!pstatus && !resolved_uri[0] && time(NULL) < end_time)
1798 {
1799 if ((pstatus = avahi_simple_poll_iterate(uribuf.poll, 2000)) != 0)
1800 break;
1801
1802 /*
1803 * If it hasn't resolved within 5 seconds set the offline-report
1804 * printer-state-reason...
1805 */
1806
1807 if ((options & _HTTP_RESOLVE_STDERR) && offline == 0 &&
1808 time(NULL) > (start_time + 5))
1809 {
1810 fputs("STATE: +offline-report\n", stderr);
1811 offline = 1;
1812 }
1813 }
1814
1815 /*
1816 * Collect the result (if we got one).
1817 */
1818
1819 if (resolved_uri[0])
1820 uri = resolved_uri;
1821 }
1822
1823 avahi_client_free(client);
1824 }
1825
1826 avahi_simple_poll_free(uribuf.poll);
1827 }
1828 # endif /* HAVE_DNSSD */
1829
1830 if (options & _HTTP_RESOLVE_STDERR)
1831 {
1832 if (uri)
1833 {
1834 fprintf(stderr, "DEBUG: Resolved as \"%s\"...\n", uri);
1835 fputs("STATE: -connecting-to-device,offline-report\n", stderr);
1836 }
1837 else
1838 {
1839 fputs("DEBUG: Unable to resolve URI\n", stderr);
1840 fputs("STATE: -connecting-to-device\n", stderr);
1841 }
1842 }
1843
1844 #else /* HAVE_DNSSD || HAVE_AVAHI */
1845 /*
1846 * No DNS-SD support...
1847 */
1848
1849 uri = NULL;
1850 #endif /* HAVE_DNSSD || HAVE_AVAHI */
1851
1852 if ((options & _HTTP_RESOLVE_STDERR) && !uri)
1853 _cupsLangPrintFilter(stderr, "INFO", _("Unable to find printer."));
1854 }
1855 else
1856 {
1857 /*
1858 * Nothing more to do...
1859 */
1860
1861 strlcpy(resolved_uri, uri, resolved_size);
1862 uri = resolved_uri;
1863 }
1864
1865 DEBUG_printf(("5_httpResolveURI: Returning \"%s\"", uri));
1866
1867 return (uri);
1868 }
1869
1870
1871 #ifdef HAVE_AVAHI
1872 /*
1873 * 'http_client_cb()' - Client callback for resolving URI.
1874 */
1875
1876 static void
1877 http_client_cb(
1878 AvahiClient *client, /* I - Client information */
1879 AvahiClientState state, /* I - Current state */
1880 void *context) /* I - Pointer to URI buffer */
1881 {
1882 DEBUG_printf(("7http_client_cb(client=%p, state=%d, context=%p)", client,
1883 state, context));
1884
1885 /*
1886 * If the connection drops, quit.
1887 */
1888
1889 if (state == AVAHI_CLIENT_FAILURE)
1890 {
1891 _http_uribuf_t *uribuf = (_http_uribuf_t *)context;
1892 /* URI buffer */
1893
1894 avahi_simple_poll_quit(uribuf->poll);
1895 }
1896 }
1897 #endif /* HAVE_AVAHI */
1898
1899
1900 /*
1901 * 'http_copy_decode()' - Copy and decode a URI.
1902 */
1903
1904 static const char * /* O - New source pointer or NULL on error */
1905 http_copy_decode(char *dst, /* O - Destination buffer */
1906 const char *src, /* I - Source pointer */
1907 int dstsize, /* I - Destination size */
1908 const char *term, /* I - Terminating characters */
1909 int decode) /* I - Decode %-encoded values */
1910 {
1911 char *ptr, /* Pointer into buffer */
1912 *end; /* End of buffer */
1913 int quoted; /* Quoted character */
1914
1915
1916 /*
1917 * Copy the src to the destination until we hit a terminating character
1918 * or the end of the string.
1919 */
1920
1921 for (ptr = dst, end = dst + dstsize - 1;
1922 *src && (!term || !strchr(term, *src));
1923 src ++)
1924 if (ptr < end)
1925 {
1926 if (*src == '%' && decode)
1927 {
1928 if (isxdigit(src[1] & 255) && isxdigit(src[2] & 255))
1929 {
1930 /*
1931 * Grab a hex-encoded character...
1932 */
1933
1934 src ++;
1935 if (isalpha(*src))
1936 quoted = (tolower(*src) - 'a' + 10) << 4;
1937 else
1938 quoted = (*src - '0') << 4;
1939
1940 src ++;
1941 if (isalpha(*src))
1942 quoted |= tolower(*src) - 'a' + 10;
1943 else
1944 quoted |= *src - '0';
1945
1946 *ptr++ = quoted;
1947 }
1948 else
1949 {
1950 /*
1951 * Bad hex-encoded character...
1952 */
1953
1954 *ptr = '\0';
1955 return (NULL);
1956 }
1957 }
1958 else if ((*src & 255) <= 0x20 || (*src & 255) >= 0x7f)
1959 {
1960 *ptr = '\0';
1961 return (NULL);
1962 }
1963 else
1964 *ptr++ = *src;
1965 }
1966
1967 *ptr = '\0';
1968
1969 return (src);
1970 }
1971
1972
1973 /*
1974 * 'http_copy_encode()' - Copy and encode a URI.
1975 */
1976
1977 static char * /* O - End of current URI */
1978 http_copy_encode(char *dst, /* O - Destination buffer */
1979 const char *src, /* I - Source pointer */
1980 char *dstend, /* I - End of destination buffer */
1981 const char *reserved, /* I - Extra reserved characters */
1982 const char *term, /* I - Terminating characters */
1983 int encode) /* I - %-encode reserved chars? */
1984 {
1985 static const char hex[] = "0123456789ABCDEF";
1986
1987
1988 while (*src && dst < dstend)
1989 {
1990 if (term && *src == *term)
1991 return (dst);
1992
1993 if (encode && (*src == '%' || *src <= ' ' || *src & 128 ||
1994 (reserved && strchr(reserved, *src))))
1995 {
1996 /*
1997 * Hex encode reserved characters...
1998 */
1999
2000 if ((dst + 2) >= dstend)
2001 break;
2002
2003 *dst++ = '%';
2004 *dst++ = hex[(*src >> 4) & 15];
2005 *dst++ = hex[*src & 15];
2006
2007 src ++;
2008 }
2009 else
2010 *dst++ = *src++;
2011 }
2012
2013 *dst = '\0';
2014
2015 if (*src)
2016 return (NULL);
2017 else
2018 return (dst);
2019 }
2020
2021
2022 #ifdef HAVE_DNSSD
2023 /*
2024 * 'http_resolve_cb()' - Build a device URI for the given service name.
2025 */
2026
2027 static void DNSSD_API
2028 http_resolve_cb(
2029 DNSServiceRef sdRef, /* I - Service reference */
2030 DNSServiceFlags flags, /* I - Results flags */
2031 uint32_t interfaceIndex, /* I - Interface number */
2032 DNSServiceErrorType errorCode, /* I - Error, if any */
2033 const char *fullName, /* I - Full service name */
2034 const char *hostTarget, /* I - Hostname */
2035 uint16_t port, /* I - Port number */
2036 uint16_t txtLen, /* I - Length of TXT record */
2037 const unsigned char *txtRecord, /* I - TXT record data */
2038 void *context) /* I - Pointer to URI buffer */
2039 {
2040 _http_uribuf_t *uribuf = (_http_uribuf_t *)context;
2041 /* URI buffer */
2042 const char *scheme, /* URI scheme */
2043 *hostptr, /* Pointer into hostTarget */
2044 *reskey, /* "rp" or "rfo" */
2045 *resdefault; /* Default path */
2046 char resource[257], /* Remote path */
2047 fqdn[256]; /* FQDN of the .local name */
2048 const void *value; /* Value from TXT record */
2049 uint8_t valueLen; /* Length of value */
2050
2051
2052 DEBUG_printf(("7http_resolve_cb(sdRef=%p, flags=%x, interfaceIndex=%u, "
2053 "errorCode=%d, fullName=\"%s\", hostTarget=\"%s\", port=%u, "
2054 "txtLen=%u, txtRecord=%p, context=%p)", sdRef, flags,
2055 interfaceIndex, errorCode, fullName, hostTarget, port, txtLen,
2056 txtRecord, context));
2057
2058 /*
2059 * If we have a UUID, compare it...
2060 */
2061
2062 if (uribuf->uuid &&
2063 (value = TXTRecordGetValuePtr(txtLen, txtRecord, "UUID",
2064 &valueLen)) != NULL)
2065 {
2066 char uuid[256]; /* UUID value */
2067
2068 memcpy(uuid, value, valueLen);
2069 uuid[valueLen] = '\0';
2070
2071 if (_cups_strcasecmp(uuid, uribuf->uuid))
2072 {
2073 if (uribuf->options & _HTTP_RESOLVE_STDERR)
2074 fprintf(stderr, "DEBUG: Found UUID %s, looking for %s.", uuid,
2075 uribuf->uuid);
2076
2077 DEBUG_printf(("7http_resolve_cb: Found UUID %s, looking for %s.", uuid,
2078 uribuf->uuid));
2079 return;
2080 }
2081 }
2082
2083 /*
2084 * Figure out the scheme from the full name...
2085 */
2086
2087 if (strstr(fullName, "._ipps") || strstr(fullName, "._ipp-tls"))
2088 scheme = "ipps";
2089 else if (strstr(fullName, "._ipp") || strstr(fullName, "._fax-ipp"))
2090 scheme = "ipp";
2091 else if (strstr(fullName, "._http."))
2092 scheme = "http";
2093 else if (strstr(fullName, "._https."))
2094 scheme = "https";
2095 else if (strstr(fullName, "._printer."))
2096 scheme = "lpd";
2097 else if (strstr(fullName, "._pdl-datastream."))
2098 scheme = "socket";
2099 else
2100 scheme = "riousbprint";
2101
2102 /*
2103 * Extract the "remote printer" key from the TXT record...
2104 */
2105
2106 if ((uribuf->options & _HTTP_RESOLVE_FAXOUT) &&
2107 (!strcmp(scheme, "ipp") || !strcmp(scheme, "ipps")) &&
2108 !TXTRecordGetValuePtr(txtLen, txtRecord, "printer-type", &valueLen))
2109 {
2110 reskey = "rfo";
2111 resdefault = "/ipp/faxout";
2112 }
2113 else
2114 {
2115 reskey = "rp";
2116 resdefault = "/";
2117 }
2118
2119 if ((value = TXTRecordGetValuePtr(txtLen, txtRecord, reskey,
2120 &valueLen)) != NULL)
2121 {
2122 if (((char *)value)[0] == '/')
2123 {
2124 /*
2125 * Value (incorrectly) has a leading slash already...
2126 */
2127
2128 memcpy(resource, value, valueLen);
2129 resource[valueLen] = '\0';
2130 }
2131 else
2132 {
2133 /*
2134 * Convert to resource by concatenating with a leading "/"...
2135 */
2136
2137 resource[0] = '/';
2138 memcpy(resource + 1, value, valueLen);
2139 resource[valueLen + 1] = '\0';
2140 }
2141 }
2142 else
2143 {
2144 /*
2145 * Use the default value...
2146 */
2147
2148 strlcpy(resource, resdefault, sizeof(resource));
2149 }
2150
2151 /*
2152 * Lookup the FQDN if needed...
2153 */
2154
2155 if ((uribuf->options & _HTTP_RESOLVE_FQDN) &&
2156 (hostptr = hostTarget + strlen(hostTarget) - 7) > hostTarget &&
2157 !_cups_strcasecmp(hostptr, ".local."))
2158 {
2159 /*
2160 * OK, we got a .local name but the caller needs a real domain. Start by
2161 * getting the IP address of the .local name and then do reverse-lookups...
2162 */
2163
2164 http_addrlist_t *addrlist, /* List of addresses */
2165 *addr; /* Current address */
2166
2167 DEBUG_printf(("8http_resolve_cb: Looking up \"%s\".", hostTarget));
2168
2169 snprintf(fqdn, sizeof(fqdn), "%d", ntohs(port));
2170 if ((addrlist = httpAddrGetList(hostTarget, AF_UNSPEC, fqdn)) != NULL)
2171 {
2172 for (addr = addrlist; addr; addr = addr->next)
2173 {
2174 int error = getnameinfo(&(addr->addr.addr),
2175 httpAddrLength(&(addr->addr)),
2176 fqdn, sizeof(fqdn), NULL, 0, NI_NAMEREQD);
2177
2178 if (!error)
2179 {
2180 DEBUG_printf(("8http_resolve_cb: Found \"%s\".", fqdn));
2181
2182 if ((hostptr = fqdn + strlen(fqdn) - 6) <= fqdn ||
2183 _cups_strcasecmp(hostptr, ".local"))
2184 {
2185 hostTarget = fqdn;
2186 break;
2187 }
2188 }
2189 #ifdef DEBUG
2190 else
2191 DEBUG_printf(("8http_resolve_cb: \"%s\" did not resolve: %d",
2192 httpAddrString(&(addr->addr), fqdn, sizeof(fqdn)),
2193 error));
2194 #endif /* DEBUG */
2195 }
2196
2197 httpAddrFreeList(addrlist);
2198 }
2199 }
2200
2201 /*
2202 * Assemble the final device URI...
2203 */
2204
2205 if ((!strcmp(scheme, "ipp") || !strcmp(scheme, "ipps")) &&
2206 !strcmp(uribuf->resource, "/cups"))
2207 httpAssembleURIf(HTTP_URI_CODING_ALL, uribuf->buffer, uribuf->bufsize,
2208 scheme, NULL, hostTarget, ntohs(port), "%s?snmp=false",
2209 resource);
2210 else
2211 httpAssembleURI(HTTP_URI_CODING_ALL, uribuf->buffer, uribuf->bufsize,
2212 scheme, NULL, hostTarget, ntohs(port), resource);
2213
2214 DEBUG_printf(("8http_resolve_cb: Resolved URI is \"%s\"...", uribuf->buffer));
2215 }
2216
2217 #elif defined(HAVE_AVAHI)
2218 /*
2219 * 'http_poll_cb()' - Wait for input on the specified file descriptors.
2220 *
2221 * Note: This function is needed because avahi_simple_poll_iterate is broken
2222 * and always uses a timeout of 0 (!) milliseconds.
2223 * (Avahi Ticket #364)
2224 */
2225
2226 static int /* O - Number of file descriptors matching */
2227 http_poll_cb(
2228 struct pollfd *pollfds, /* I - File descriptors */
2229 unsigned int num_pollfds, /* I - Number of file descriptors */
2230 int timeout, /* I - Timeout in milliseconds (used) */
2231 void *context) /* I - User data (unused) */
2232 {
2233 (void)timeout;
2234 (void)context;
2235
2236 return (poll(pollfds, num_pollfds, 2000));
2237 }
2238
2239
2240 /*
2241 * 'http_resolve_cb()' - Build a device URI for the given service name.
2242 */
2243
2244 static void
2245 http_resolve_cb(
2246 AvahiServiceResolver *resolver, /* I - Resolver (unused) */
2247 AvahiIfIndex interface, /* I - Interface index (unused) */
2248 AvahiProtocol protocol, /* I - Network protocol (unused) */
2249 AvahiResolverEvent event, /* I - Event (found, etc.) */
2250 const char *name, /* I - Service name */
2251 const char *type, /* I - Registration type */
2252 const char *domain, /* I - Domain (unused) */
2253 const char *hostTarget, /* I - Hostname */
2254 const AvahiAddress *address, /* I - Address (unused) */
2255 uint16_t port, /* I - Port number */
2256 AvahiStringList *txt, /* I - TXT record */
2257 AvahiLookupResultFlags flags, /* I - Lookup flags (unused) */
2258 void *context) /* I - Pointer to URI buffer */
2259 {
2260 _http_uribuf_t *uribuf = (_http_uribuf_t *)context;
2261 /* URI buffer */
2262 const char *scheme, /* URI scheme */
2263 *hostptr, /* Pointer into hostTarget */
2264 *reskey, /* "rp" or "rfo" */
2265 *resdefault; /* Default path */
2266 char resource[257], /* Remote path */
2267 fqdn[256]; /* FQDN of the .local name */
2268 AvahiStringList *pair; /* Current TXT record key/value pair */
2269 char *value; /* Value for "rp" key */
2270 size_t valueLen = 0; /* Length of "rp" key */
2271
2272
2273 DEBUG_printf(("7http_resolve_cb(resolver=%p, "
2274 "interface=%d, protocol=%d, event=%d, name=\"%s\", "
2275 "type=\"%s\", domain=\"%s\", hostTarget=\"%s\", address=%p, "
2276 "port=%d, txt=%p, flags=%d, context=%p)",
2277 resolver, interface, protocol, event, name, type, domain,
2278 hostTarget, address, port, txt, flags, context));
2279
2280 if (event != AVAHI_RESOLVER_FOUND)
2281 {
2282 avahi_service_resolver_free(resolver);
2283 avahi_simple_poll_quit(uribuf->poll);
2284 return;
2285 }
2286
2287 /*
2288 * If we have a UUID, compare it...
2289 */
2290
2291 if (uribuf->uuid && (pair = avahi_string_list_find(txt, "UUID")) != NULL)
2292 {
2293 char uuid[256]; /* UUID value */
2294
2295 avahi_string_list_get_pair(pair, NULL, &value, &valueLen);
2296
2297 memcpy(uuid, value, valueLen);
2298 uuid[valueLen] = '\0';
2299
2300 if (_cups_strcasecmp(uuid, uribuf->uuid))
2301 {
2302 if (uribuf->options & _HTTP_RESOLVE_STDERR)
2303 fprintf(stderr, "DEBUG: Found UUID %s, looking for %s.", uuid,
2304 uribuf->uuid);
2305
2306 DEBUG_printf(("7http_resolve_cb: Found UUID %s, looking for %s.", uuid,
2307 uribuf->uuid));
2308 return;
2309 }
2310 }
2311
2312 /*
2313 * Figure out the scheme from the full name...
2314 */
2315
2316 if (strstr(type, "_ipp."))
2317 scheme = "ipp";
2318 else if (strstr(type, "_printer."))
2319 scheme = "lpd";
2320 else if (strstr(type, "_pdl-datastream."))
2321 scheme = "socket";
2322 else
2323 scheme = "riousbprint";
2324
2325 if (!strncmp(type, "_ipps.", 6) || !strncmp(type, "_ipp-tls.", 9))
2326 scheme = "ipps";
2327 else if (!strncmp(type, "_ipp.", 5) || !strncmp(type, "_fax-ipp.", 9))
2328 scheme = "ipp";
2329 else if (!strncmp(type, "_http.", 6))
2330 scheme = "http";
2331 else if (!strncmp(type, "_https.", 7))
2332 scheme = "https";
2333 else if (!strncmp(type, "_printer.", 9))
2334 scheme = "lpd";
2335 else if (!strncmp(type, "_pdl-datastream.", 16))
2336 scheme = "socket";
2337 else
2338 {
2339 avahi_service_resolver_free(resolver);
2340 avahi_simple_poll_quit(uribuf->poll);
2341 return;
2342 }
2343
2344 /*
2345 * Extract the remote resource key from the TXT record...
2346 */
2347
2348 if ((uribuf->options & _HTTP_RESOLVE_FAXOUT) &&
2349 (!strcmp(scheme, "ipp") || !strcmp(scheme, "ipps")) &&
2350 !avahi_string_list_find(txt, "printer-type"))
2351 {
2352 reskey = "rfo";
2353 resdefault = "/ipp/faxout";
2354 }
2355 else
2356 {
2357 reskey = "rp";
2358 resdefault = "/";
2359 }
2360
2361 if ((pair = avahi_string_list_find(txt, reskey)) != NULL)
2362 {
2363 avahi_string_list_get_pair(pair, NULL, &value, &valueLen);
2364
2365 if (value[0] == '/')
2366 {
2367 /*
2368 * Value (incorrectly) has a leading slash already...
2369 */
2370
2371 memcpy(resource, value, valueLen);
2372 resource[valueLen] = '\0';
2373 }
2374 else
2375 {
2376 /*
2377 * Convert to resource by concatenating with a leading "/"...
2378 */
2379
2380 resource[0] = '/';
2381 memcpy(resource + 1, value, valueLen);
2382 resource[valueLen + 1] = '\0';
2383 }
2384 }
2385 else
2386 {
2387 /*
2388 * Use the default value...
2389 */
2390
2391 strlcpy(resource, resdefault, sizeof(resource));
2392 }
2393
2394 /*
2395 * Lookup the FQDN if needed...
2396 */
2397
2398 if ((uribuf->options & _HTTP_RESOLVE_FQDN) &&
2399 (hostptr = hostTarget + strlen(hostTarget) - 6) > hostTarget &&
2400 !_cups_strcasecmp(hostptr, ".local"))
2401 {
2402 /*
2403 * OK, we got a .local name but the caller needs a real domain. Start by
2404 * getting the IP address of the .local name and then do reverse-lookups...
2405 */
2406
2407 http_addrlist_t *addrlist, /* List of addresses */
2408 *addr; /* Current address */
2409
2410 DEBUG_printf(("8http_resolve_cb: Looking up \"%s\".", hostTarget));
2411
2412 snprintf(fqdn, sizeof(fqdn), "%d", ntohs(port));
2413 if ((addrlist = httpAddrGetList(hostTarget, AF_UNSPEC, fqdn)) != NULL)
2414 {
2415 for (addr = addrlist; addr; addr = addr->next)
2416 {
2417 int error = getnameinfo(&(addr->addr.addr),
2418 httpAddrLength(&(addr->addr)),
2419 fqdn, sizeof(fqdn), NULL, 0, NI_NAMEREQD);
2420
2421 if (!error)
2422 {
2423 DEBUG_printf(("8http_resolve_cb: Found \"%s\".", fqdn));
2424
2425 if ((hostptr = fqdn + strlen(fqdn) - 6) <= fqdn ||
2426 _cups_strcasecmp(hostptr, ".local"))
2427 {
2428 hostTarget = fqdn;
2429 break;
2430 }
2431 }
2432 #ifdef DEBUG
2433 else
2434 DEBUG_printf(("8http_resolve_cb: \"%s\" did not resolve: %d",
2435 httpAddrString(&(addr->addr), fqdn, sizeof(fqdn)),
2436 error));
2437 #endif /* DEBUG */
2438 }
2439
2440 httpAddrFreeList(addrlist);
2441 }
2442 }
2443
2444 /*
2445 * Assemble the final device URI using the resolved hostname...
2446 */
2447
2448 httpAssembleURI(HTTP_URI_CODING_ALL, uribuf->buffer, uribuf->bufsize, scheme,
2449 NULL, hostTarget, port, resource);
2450 DEBUG_printf(("8http_resolve_cb: Resolved URI is \"%s\".", uribuf->buffer));
2451
2452 avahi_simple_poll_quit(uribuf->poll);
2453 }
2454 #endif /* HAVE_DNSSD */
2455
2456
2457 /*
2458 * End of "$Id$".
2459 */
Unnamed repository; edit this file 'description' to name the repository.