]> git.ipfire.org Git - thirdparty/cups.git/blob - cups/http.c
projects / thirdparty / cups.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Silence yet another bogus compiler warning.
[thirdparty/cups.git] / cups / http.c
1 /*
2 * "$Id$"
3 *
4 * HTTP routines for CUPS.
5 *
6 * Copyright 2007-2014 by Apple Inc.
7 * Copyright 1997-2007 by Easy Software Products, all rights reserved.
8 *
9 * This file contains Kerberos support code, copyright 2006 by
10 * Jelmer Vernooij.
11 *
12 * These coded instructions, statements, and computer programs are the
13 * property of Apple Inc. and are protected by Federal copyright
14 * law. Distribution and use rights are outlined in the file "LICENSE.txt"
15 * which should have been included with this file. If this file is
16 * file is missing or damaged, see the license at "http://www.cups.org/".
17 *
18 * This file is subject to the Apple OS-Developed Software exception.
19 */
20
21 /*
22 * Include necessary headers...
23 */
24
25 #include "cups-private.h"
26 #include <fcntl.h>
27 #include <math.h>
28 #ifdef WIN32
29 # include <tchar.h>
30 #else
31 # include <signal.h>
32 # include <sys/time.h>
33 # include <sys/resource.h>
34 #endif /* WIN32 */
35 #ifdef HAVE_POLL
36 # include <poll.h>
37 #endif /* HAVE_POLL */
38
39
40 /*
41 * Local functions...
42 */
43
44 #ifdef HAVE_LIBZ
45 static void http_content_coding_finish(http_t *http);
46 static void http_content_coding_start(http_t *http,
47 const char *value);
48 #endif /* HAVE_LIBZ */
49 static http_t *http_create(const char *host, int port,
50 http_addrlist_t *addrlist, int family,
51 http_encryption_t encryption,
52 int blocking, _http_mode_t mode);
53 #ifdef DEBUG
54 static void http_debug_hex(const char *prefix, const char *buffer,
55 int bytes);
56 #endif /* DEBUG */
57 static ssize_t http_read(http_t *http, char *buffer, size_t length);
58 static ssize_t http_read_buffered(http_t *http, char *buffer, size_t length);
59 static ssize_t http_read_chunk(http_t *http, char *buffer, size_t length);
60 static int http_send(http_t *http, http_state_t request,
61 const char *uri);
62 static ssize_t http_write(http_t *http, const char *buffer,
63 size_t length);
64 static ssize_t http_write_chunk(http_t *http, const char *buffer,
65 size_t length);
66 static off_t http_set_length(http_t *http);
67 static void http_set_timeout(int fd, double timeout);
68 static void http_set_wait(http_t *http);
69
70 #ifdef HAVE_SSL
71 static int http_tls_upgrade(http_t *http);
72 #endif /* HAVE_SSL */
73
74
75 /*
76 * Local globals...
77 */
78
79 static const char * const http_fields[] =
80 {
81 "Accept-Language",
82 "Accept-Ranges",
83 "Authorization",
84 "Connection",
85 "Content-Encoding",
86 "Content-Language",
87 "Content-Length",
88 "Content-Location",
89 "Content-MD5",
90 "Content-Range",
91 "Content-Type",
92 "Content-Version",
93 "Date",
94 "Host",
95 "If-Modified-Since",
96 "If-Unmodified-since",
97 "Keep-Alive",
98 "Last-Modified",
99 "Link",
100 "Location",
101 "Range",
102 "Referer",
103 "Retry-After",
104 "Transfer-Encoding",
105 "Upgrade",
106 "User-Agent",
107 "WWW-Authenticate",
108 "Accept-Encoding",
109 "Allow",
110 "Server"
111 };
112
113
114 /*
115 * 'httpAcceptConnection()' - Accept a new HTTP client connection from the
116 * specified listening socket.
117 *
118 * @since CUPS 1.7/OS X 10.9@
119 */
120
121 http_t * /* O - HTTP connection or @code NULL@ */
122 httpAcceptConnection(int fd, /* I - Listen socket file descriptor */
123 int blocking) /* I - 1 if the connection should be
124 blocking, 0 otherwise */
125 {
126 http_t *http; /* HTTP connection */
127 http_addrlist_t addrlist; /* Dummy address list */
128 socklen_t addrlen; /* Length of address */
129 int val; /* Socket option value */
130
131
132 /*
133 * Range check input...
134 */
135
136 if (fd < 0)
137 return (NULL);
138
139 /*
140 * Create the client connection...
141 */
142
143 memset(&addrlist, 0, sizeof(addrlist));
144
145 if ((http = http_create(NULL, 0, &addrlist, AF_UNSPEC,
146 HTTP_ENCRYPTION_IF_REQUESTED, blocking,
147 _HTTP_MODE_SERVER)) == NULL)
148 return (NULL);
149
150 /*
151 * Accept the client and get the remote address...
152 */
153
154 addrlen = sizeof(http_addr_t);
155
156 if ((http->fd = accept(fd, (struct sockaddr *)&(http->addrlist->addr),
157 &addrlen)) < 0)
158 {
159 _cupsSetHTTPError(HTTP_STATUS_ERROR);
160 httpClose(http);
161
162 return (NULL);
163 }
164
165 http->hostaddr = &(http->addrlist->addr);
166
167 if (httpAddrLocalhost(http->hostaddr))
168 strlcpy(http->hostname, "localhost", sizeof(http->hostname));
169 else
170 httpAddrString(http->hostaddr, http->hostname, sizeof(http->hostname));
171
172 #ifdef SO_NOSIGPIPE
173 /*
174 * Disable SIGPIPE for this socket.
175 */
176
177 val = 1;
178 setsockopt(http->fd, SOL_SOCKET, SO_NOSIGPIPE, CUPS_SOCAST &val, sizeof(val));
179 #endif /* SO_NOSIGPIPE */
180
181 /*
182 * Using TCP_NODELAY improves responsiveness, especially on systems
183 * with a slow loopback interface. Since we write large buffers
184 * when sending print files and requests, there shouldn't be any
185 * performance penalty for this...
186 */
187
188 val = 1;
189 setsockopt(http->fd, IPPROTO_TCP, TCP_NODELAY, CUPS_SOCAST &val, sizeof(val));
190
191 #ifdef FD_CLOEXEC
192 /*
193 * Close this socket when starting another process...
194 */
195
196 fcntl(http->fd, F_SETFD, FD_CLOEXEC);
197 #endif /* FD_CLOEXEC */
198
199 return (http);
200 }
201
202
203 /*
204 * 'httpAddCredential()' - Allocates and adds a single credential to an array.
205 *
206 * Use @code cupsArrayNew(NULL, NULL)@ to create a credentials array.
207 *
208 * @since CUPS 1.5/OS X 10.7@
209 */
210
211 int /* O - 0 on success, -1 on error */
212 httpAddCredential(
213 cups_array_t *credentials, /* I - Credentials array */
214 const void *data, /* I - PEM-encoded X.509 data */
215 size_t datalen) /* I - Length of data */
216 {
217 http_credential_t *credential; /* Credential data */
218
219
220 if ((credential = malloc(sizeof(http_credential_t))) != NULL)
221 {
222 credential->datalen = datalen;
223
224 if ((credential->data = malloc(datalen)) != NULL)
225 {
226 memcpy(credential->data, data, datalen);
227 cupsArrayAdd(credentials, credential);
228 return (0);
229 }
230
231 free(credential);
232 }
233
234 return (-1);
235 }
236
237
238 /*
239 * 'httpBlocking()' - Set blocking/non-blocking behavior on a connection.
240 */
241
242 void
243 httpBlocking(http_t *http, /* I - HTTP connection */
244 int b) /* I - 1 = blocking, 0 = non-blocking */
245 {
246 if (http)
247 {
248 http->blocking = b;
249 http_set_wait(http);
250 }
251 }
252
253
254 /*
255 * 'httpCheck()' - Check to see if there is a pending response from the server.
256 */
257
258 int /* O - 0 = no data, 1 = data available */
259 httpCheck(http_t *http) /* I - HTTP connection */
260 {
261 return (httpWait(http, 0));
262 }
263
264
265 /*
266 * 'httpClearCookie()' - Clear the cookie value(s).
267 *
268 * @since CUPS 1.1.19/OS X 10.3@
269 */
270
271 void
272 httpClearCookie(http_t *http) /* I - HTTP connection */
273 {
274 if (!http)
275 return;
276
277 if (http->cookie)
278 {
279 free(http->cookie);
280 http->cookie = NULL;
281 }
282 }
283
284
285 /*
286 * 'httpClearFields()' - Clear HTTP request fields.
287 */
288
289 void
290 httpClearFields(http_t *http) /* I - HTTP connection */
291 {
292 DEBUG_printf(("httpClearFields(http=%p)", http));
293
294 if (http)
295 {
296 memset(http->fields, 0, sizeof(http->fields));
297
298 if (http->mode == _HTTP_MODE_CLIENT)
299 {
300 if (http->hostname[0] == '/')
301 httpSetField(http, HTTP_FIELD_HOST, "localhost");
302 else
303 httpSetField(http, HTTP_FIELD_HOST, http->hostname);
304 }
305
306 if (http->field_authorization)
307 {
308 free(http->field_authorization);
309 http->field_authorization = NULL;
310 }
311
312 if (http->accept_encoding)
313 {
314 _cupsStrFree(http->accept_encoding);
315 http->accept_encoding = NULL;
316 }
317
318 if (http->allow)
319 {
320 _cupsStrFree(http->allow);
321 http->allow = NULL;
322 }
323
324 if (http->server)
325 {
326 _cupsStrFree(http->server);
327 http->server = NULL;
328 }
329
330 http->expect = (http_status_t)0;
331 }
332 }
333
334
335 /*
336 * 'httpClose()' - Close an HTTP connection.
337 */
338
339 void
340 httpClose(http_t *http) /* I - HTTP connection */
341 {
342 #ifdef HAVE_GSSAPI
343 OM_uint32 minor_status; /* Minor status code */
344 #endif /* HAVE_GSSAPI */
345
346
347 DEBUG_printf(("httpClose(http=%p)", http));
348
349 /*
350 * Range check input...
351 */
352
353 if (!http)
354 return;
355
356 /*
357 * Close any open connection...
358 */
359
360 _httpDisconnect(http);
361
362 /*
363 * Free memory used...
364 */
365
366 httpAddrFreeList(http->addrlist);
367
368 if (http->cookie)
369 free(http->cookie);
370
371 #ifdef HAVE_GSSAPI
372 if (http->gssctx != GSS_C_NO_CONTEXT)
373 gss_delete_sec_context(&minor_status, &http->gssctx, GSS_C_NO_BUFFER);
374
375 if (http->gssname != GSS_C_NO_NAME)
376 gss_release_name(&minor_status, &http->gssname);
377 #endif /* HAVE_GSSAPI */
378
379 #ifdef HAVE_AUTHORIZATION_H
380 if (http->auth_ref)
381 AuthorizationFree(http->auth_ref, kAuthorizationFlagDefaults);
382 #endif /* HAVE_AUTHORIZATION_H */
383
384 httpClearFields(http);
385
386 if (http->authstring && http->authstring != http->_authstring)
387 free(http->authstring);
388
389 free(http);
390 }
391
392
393 /*
394 * 'httpCompareCredentials()' - Compare two sets of X.509 credentials.
395 *
396 * @since CUPS 2.0/OS 10.10@
397 */
398
399 int /* O - 1 if they match, 0 if they do not */
400 httpCompareCredentials(
401 cups_array_t *cred1, /* I - First set of X.509 credentials */
402 cups_array_t *cred2) /* I - Second set of X.509 credentials */
403 {
404 http_credential_t *temp1, *temp2; /* Temporary credentials */
405
406
407 for (temp1 = (http_credential_t *)cupsArrayFirst(cred1), temp2 = (http_credential_t *)cupsArrayFirst(cred2); temp1 && temp2; temp1 = (http_credential_t *)cupsArrayNext(cred1), temp2 = (http_credential_t *)cupsArrayNext(cred2))
408 if (temp1->datalen != temp2->datalen)
409 return (0);
410 else if (memcmp(temp1->data, temp2->data, temp1->datalen))
411 return (0);
412
413 return (temp1 == temp2);
414 }
415
416
417 /*
418 * 'httpConnect()' - Connect to a HTTP server.
419 *
420 * This function is deprecated - use @link httpConnect2@ instead.
421 *
422 * @deprecated@
423 */
424
425 http_t * /* O - New HTTP connection */
426 httpConnect(const char *host, /* I - Host to connect to */
427 int port) /* I - Port number */
428 {
429 return (httpConnect2(host, port, NULL, AF_UNSPEC,
430 HTTP_ENCRYPTION_IF_REQUESTED, 1, 30000, NULL));
431 }
432
433
434 /*
435 * 'httpConnect2()' - Connect to a HTTP server.
436 *
437 * @since CUPS 1.7/OS X 10.9@
438 */
439
440 http_t * /* O - New HTTP connection */
441 httpConnect2(
442 const char *host, /* I - Host to connect to */
443 int port, /* I - Port number */
444 http_addrlist_t *addrlist, /* I - List of addresses or NULL to lookup */
445 int family, /* I - Address family to use or @code AF_UNSPEC@ for any */
446 http_encryption_t encryption, /* I - Type of encryption to use */
447 int blocking, /* I - 1 for blocking connection, 0 for non-blocking */
448 int msec, /* I - Connection timeout in milliseconds, 0 means don't connect */
449 int *cancel) /* I - Pointer to "cancel" variable */
450 {
451 http_t *http; /* New HTTP connection */
452
453
454 DEBUG_printf(("httpConnect2(host=\"%s\", port=%d, addrlist=%p, family=%d, "
455 "encryption=%d, blocking=%d, msec=%d, cancel=%p)", host, port,
456 addrlist, family, encryption, blocking, msec, cancel));
457
458 /*
459 * Create the HTTP structure...
460 */
461
462 if ((http = http_create(host, port, addrlist, family, encryption, blocking,
463 _HTTP_MODE_CLIENT)) == NULL)
464 return (NULL);
465
466 /*
467 * Optionally connect to the remote system...
468 */
469
470 if (msec == 0 || !httpReconnect2(http, msec, cancel))
471 return (http);
472
473 /*
474 * Could not connect to any known address - bail out!
475 */
476
477 httpClose(http);
478
479 return (NULL);
480 }
481
482
483 /*
484 * 'httpConnectEncrypt()' - Connect to a HTTP server using encryption.
485 *
486 * This function is now deprecated. Please use the @link httpConnect2@ function
487 * instead.
488 *
489 * @deprecated@
490 */
491
492 http_t * /* O - New HTTP connection */
493 httpConnectEncrypt(
494 const char *host, /* I - Host to connect to */
495 int port, /* I - Port number */
496 http_encryption_t encryption) /* I - Type of encryption to use */
497 {
498 DEBUG_printf(("httpConnectEncrypt(host=\"%s\", port=%d, encryption=%d)",
499 host, port, encryption));
500
501 return (httpConnect2(host, port, NULL, AF_UNSPEC, encryption, 1, 30000,
502 NULL));
503 }
504
505
506 /*
507 * 'httpDelete()' - Send a DELETE request to the server.
508 */
509
510 int /* O - Status of call (0 = success) */
511 httpDelete(http_t *http, /* I - HTTP connection */
512 const char *uri) /* I - URI to delete */
513 {
514 return (http_send(http, HTTP_STATE_DELETE, uri));
515 }
516
517
518 /*
519 * '_httpDisconnect()' - Disconnect a HTTP connection.
520 */
521
522 void
523 _httpDisconnect(http_t *http) /* I - HTTP connection */
524 {
525 #ifdef HAVE_SSL
526 if (http->tls)
527 _httpTLSStop(http);
528 #endif /* HAVE_SSL */
529
530 httpAddrClose(NULL, http->fd);
531
532 http->fd = -1;
533 }
534
535
536 /*
537 * 'httpEncryption()' - Set the required encryption on the link.
538 */
539
540 int /* O - -1 on error, 0 on success */
541 httpEncryption(http_t *http, /* I - HTTP connection */
542 http_encryption_t e) /* I - New encryption preference */
543 {
544 DEBUG_printf(("httpEncryption(http=%p, e=%d)", http, e));
545
546 #ifdef HAVE_SSL
547 if (!http)
548 return (0);
549
550 if (http->mode == _HTTP_MODE_CLIENT)
551 {
552 http->encryption = e;
553
554 if ((http->encryption == HTTP_ENCRYPTION_ALWAYS && !http->tls) ||
555 (http->encryption == HTTP_ENCRYPTION_NEVER && http->tls))
556 return (httpReconnect2(http, 30000, NULL));
557 else if (http->encryption == HTTP_ENCRYPTION_REQUIRED && !http->tls)
558 return (http_tls_upgrade(http));
559 else
560 return (0);
561 }
562 else
563 {
564 if (e == HTTP_ENCRYPTION_NEVER && http->tls)
565 return (-1);
566
567 http->encryption = e;
568 if (e != HTTP_ENCRYPTION_IF_REQUESTED && !http->tls)
569 return (_httpTLSStart(http));
570 else
571 return (0);
572 }
573 #else
574 if (e == HTTP_ENCRYPTION_ALWAYS || e == HTTP_ENCRYPTION_REQUIRED)
575 return (-1);
576 else
577 return (0);
578 #endif /* HAVE_SSL */
579 }
580
581
582 /*
583 * 'httpError()' - Get the last error on a connection.
584 */
585
586 int /* O - Error code (errno) value */
587 httpError(http_t *http) /* I - HTTP connection */
588 {
589 if (http)
590 return (http->error);
591 else
592 return (EINVAL);
593 }
594
595
596 /*
597 * 'httpFieldValue()' - Return the HTTP field enumeration value for a field
598 * name.
599 */
600
601 http_field_t /* O - Field index */
602 httpFieldValue(const char *name) /* I - String name */
603 {
604 int i; /* Looping var */
605
606
607 for (i = 0; i < HTTP_FIELD_MAX; i ++)
608 if (!_cups_strcasecmp(name, http_fields[i]))
609 return ((http_field_t)i);
610
611 return (HTTP_FIELD_UNKNOWN);
612 }
613
614
615 /*
616 * 'httpFlush()' - Flush data from a HTTP connection.
617 */
618
619 void
620 httpFlush(http_t *http) /* I - HTTP connection */
621 {
622 char buffer[8192]; /* Junk buffer */
623 int blocking; /* To block or not to block */
624 http_state_t oldstate; /* Old state */
625
626
627 DEBUG_printf(("httpFlush(http=%p), state=%s", http,
628 httpStateString(http->state)));
629
630 /*
631 * Nothing to do if we are in the "waiting" state...
632 */
633
634 if (http->state == HTTP_STATE_WAITING)
635 return;
636
637 /*
638 * Temporarily set non-blocking mode so we don't get stuck in httpRead()...
639 */
640
641 blocking = http->blocking;
642 http->blocking = 0;
643
644 /*
645 * Read any data we can...
646 */
647
648 oldstate = http->state;
649 while (httpRead2(http, buffer, sizeof(buffer)) > 0);
650
651 /*
652 * Restore blocking and reset the connection if we didn't get all of
653 * the remaining data...
654 */
655
656 http->blocking = blocking;
657
658 if (http->state == oldstate && http->state != HTTP_STATE_WAITING &&
659 http->fd >= 0)
660 {
661 /*
662 * Didn't get the data back, so close the current connection.
663 */
664
665 #ifdef HAVE_LIBZ
666 if (http->coding)
667 http_content_coding_finish(http);
668 #endif /* HAVE_LIBZ */
669
670 DEBUG_puts("1httpFlush: Setting state to HTTP_STATE_WAITING and closing.");
671
672 http->state = HTTP_STATE_WAITING;
673
674 #ifdef HAVE_SSL
675 if (http->tls)
676 _httpTLSStop(http);
677 #endif /* HAVE_SSL */
678
679 httpAddrClose(NULL, http->fd);
680
681 http->fd = -1;
682 }
683 }
684
685
686 /*
687 * 'httpFlushWrite()' - Flush data in write buffer.
688 *
689 * @since CUPS 1.2/OS X 10.5@
690 */
691
692 int /* O - Bytes written or -1 on error */
693 httpFlushWrite(http_t *http) /* I - HTTP connection */
694 {
695 ssize_t bytes; /* Bytes written */
696
697
698 DEBUG_printf(("httpFlushWrite(http=%p) data_encoding=%d", http,
699 http ? http->data_encoding : 100));
700
701 if (!http || !http->wused)
702 {
703 DEBUG_puts(http ? "1httpFlushWrite: Write buffer is empty." :
704 "1httpFlushWrite: No connection.");
705 return (0);
706 }
707
708 if (http->data_encoding == HTTP_ENCODING_CHUNKED)
709 bytes = http_write_chunk(http, http->wbuffer, (size_t)http->wused);
710 else
711 bytes = http_write(http, http->wbuffer, (size_t)http->wused);
712
713 http->wused = 0;
714
715 DEBUG_printf(("1httpFlushWrite: Returning %d, errno=%d.", (int)bytes, errno));
716
717 return ((int)bytes);
718 }
719
720
721 /*
722 * 'httpFreeCredentials()' - Free an array of credentials.
723 */
724
725 void
726 httpFreeCredentials(
727 cups_array_t *credentials) /* I - Array of credentials */
728 {
729 http_credential_t *credential; /* Credential */
730
731
732 for (credential = (http_credential_t *)cupsArrayFirst(credentials);
733 credential;
734 credential = (http_credential_t *)cupsArrayNext(credentials))
735 {
736 cupsArrayRemove(credentials, credential);
737 free((void *)credential->data);
738 free(credential);
739 }
740
741 cupsArrayDelete(credentials);
742 }
743
744
745 /*
746 * 'httpGet()' - Send a GET request to the server.
747 */
748
749 int /* O - Status of call (0 = success) */
750 httpGet(http_t *http, /* I - HTTP connection */
751 const char *uri) /* I - URI to get */
752 {
753 return (http_send(http, HTTP_STATE_GET, uri));
754 }
755
756
757 /*
758 * 'httpGetActivity()' - Get the most recent activity for a connection.
759 *
760 * The return value is the UNIX time of the last read or write.
761 *
762 * @since CUPS 2.0/OS 10.10@
763 */
764
765 time_t /* O - Time of last read or write */
766 httpGetActivity(http_t *http) /* I - HTTP connection */
767 {
768 return (http ? http->activity : 0);
769 }
770
771
772 /*
773 * 'httpGetAuthString()' - Get the current authorization string.
774 *
775 * The authorization string is set by cupsDoAuthentication() and
776 * httpSetAuthString(). Use httpGetAuthString() to retrieve the
777 * string to use with httpSetField() for the HTTP_FIELD_AUTHORIZATION
778 * value.
779 *
780 * @since CUPS 1.3/OS X 10.5@
781 */
782
783 char * /* O - Authorization string */
784 httpGetAuthString(http_t *http) /* I - HTTP connection */
785 {
786 if (http)
787 return (http->authstring);
788 else
789 return (NULL);
790 }
791
792
793 /*
794 * 'httpGetBlocking()' - Get the blocking/non-block state of a connection.
795 *
796 * @since CUPS 1.2/OS X 10.5@
797 */
798
799 int /* O - 1 if blocking, 0 if non-blocking */
800 httpGetBlocking(http_t *http) /* I - HTTP connection */
801 {
802 return (http ? http->blocking : 0);
803 }
804
805
806 /*
807 * 'httpGetContentEncoding()' - Get a common content encoding, if any, between
808 * the client and server.
809 *
810 * This function uses the value of the Accepts-Encoding HTTP header and must be
811 * called after receiving a response from the server or a request from the
812 * client. The value returned can be use in subsequent requests (for clients)
813 * or in the response (for servers) in order to compress the content stream.
814 *
815 * @since CUPS 1.7/OS X 10.9@
816 */
817
818 const char * /* O - Content-Coding value or
819 @code NULL@ for the identity
820 coding. */
821 httpGetContentEncoding(http_t *http) /* I - HTTP connection */
822 {
823 #ifdef HAVE_LIBZ
824 if (http && http->accept_encoding)
825 {
826 int i; /* Looping var */
827 char temp[HTTP_MAX_VALUE], /* Copy of Accepts-Encoding value */
828 *start, /* Start of coding value */
829 *end; /* End of coding value */
830 double qvalue; /* "qvalue" for coding */
831 struct lconv *loc = localeconv(); /* Locale data */
832 static const char * const codings[] =
833 { /* Supported content codings */
834 "deflate",
835 "gzip",
836 "x-deflate",
837 "x-gzip"
838 };
839
840 strlcpy(temp, http->accept_encoding, sizeof(temp));
841
842 for (start = temp; *start; start = end)
843 {
844 /*
845 * Find the end of the coding name...
846 */
847
848 qvalue = 1.0;
849 end = start;
850 while (*end && *end != ';' && *end != ',' && !isspace(*end & 255))
851 end ++;
852
853 if (*end == ';')
854 {
855 /*
856 * Grab the qvalue as needed...
857 */
858
859 if (!strncmp(end, ";q=", 3))
860 qvalue = _cupsStrScand(end + 3, NULL, loc);
861
862 /*
863 * Skip past all attributes...
864 */
865
866 *end++ = '\0';
867 while (*end && *end != ',' && !isspace(*end & 255))
868 end ++;
869 }
870 else if (*end)
871 *end++ = '\0';
872
873 while (*end && isspace(*end & 255))
874 end ++;
875
876 /*
877 * Check value if it matches something we support...
878 */
879
880 if (qvalue <= 0.0)
881 continue;
882
883 for (i = 0; i < (int)(sizeof(codings) / sizeof(codings[0])); i ++)
884 if (!strcmp(start, codings[i]))
885 return (codings[i]);
886 }
887 }
888 #endif /* HAVE_LIBZ */
889
890 return (NULL);
891 }
892
893
894 /*
895 * 'httpGetCookie()' - Get any cookie data from the response.
896 *
897 * @since CUPS 1.1.19/OS X 10.3@
898 */
899
900 const char * /* O - Cookie data or NULL */
901 httpGetCookie(http_t *http) /* I - HTTP connecion */
902 {
903 return (http ? http->cookie : NULL);
904 }
905
906
907 /*
908 * 'httpGetEncryption()' - Get the current encryption mode of a connection.
909 *
910 * This function returns the encryption mode for the connection. Use the
911 * @link httpIsEncrypted@ function to determine whether a TLS session has
912 * been established.
913 *
914 * @since CUPS 2.0/OS 10.10@
915 */
916
917 http_encryption_t /* O - Current encryption mode */
918 httpGetEncryption(http_t *http) /* I - HTTP connection */
919 {
920 return (http ? http->encryption : HTTP_ENCRYPTION_IF_REQUESTED);
921 }
922
923
924 /*
925 * 'httpGetExpect()' - Get the value of the Expect header, if any.
926 *
927 * Returns @code HTTP_STATUS_NONE@ if there is no Expect header, otherwise
928 * returns the expected HTTP status code, typically @code HTTP_STATUS_CONTINUE@.
929 *
930 * @since CUPS 1.7/OS X 10.9@
931 */
932
933 http_status_t /* O - Expect: status, if any */
934 httpGetExpect(http_t *http) /* I - HTTP connection */
935 {
936 if (!http)
937 return (HTTP_STATUS_ERROR);
938 else
939 return (http->expect);
940 }
941
942
943 /*
944 * 'httpGetFd()' - Get the file descriptor associated with a connection.
945 *
946 * @since CUPS 1.2/OS X 10.5@
947 */
948
949 int /* O - File descriptor or -1 if none */
950 httpGetFd(http_t *http) /* I - HTTP connection */
951 {
952 return (http ? http->fd : -1);
953 }
954
955
956 /*
957 * 'httpGetField()' - Get a field value from a request/response.
958 */
959
960 const char * /* O - Field value */
961 httpGetField(http_t *http, /* I - HTTP connection */
962 http_field_t field) /* I - Field to get */
963 {
964 if (!http || field <= HTTP_FIELD_UNKNOWN || field >= HTTP_FIELD_MAX)
965 return (NULL);
966
967 switch (field)
968 {
969 case HTTP_FIELD_ACCEPT_ENCODING :
970 return (http->accept_encoding);
971
972 case HTTP_FIELD_ALLOW :
973 return (http->allow);
974
975 case HTTP_FIELD_SERVER :
976 return (http->server);
977
978 case HTTP_FIELD_AUTHORIZATION :
979 if (http->field_authorization)
980 {
981 /*
982 * Special case for WWW-Authenticate: as its contents can be
983 * longer than HTTP_MAX_VALUE...
984 */
985
986 return (http->field_authorization);
987 }
988
989 default :
990 return (http->fields[field]);
991 }
992 }
993
994
995 /*
996 * 'httpGetKeepAlive()' - Get the current Keep-Alive state of the connection.
997 *
998 * @since CUPS 2.0/OS 10.10@
999 */
1000
1001 http_keepalive_t /* O - Keep-Alive state */
1002 httpGetKeepAlive(http_t *http) /* I - HTTP connection */
1003 {
1004 return (http ? http->keep_alive : HTTP_KEEPALIVE_OFF);
1005 }
1006
1007
1008 /*
1009 * 'httpGetLength()' - Get the amount of data remaining from the
1010 * content-length or transfer-encoding fields.
1011 *
1012 * This function is deprecated and will not return lengths larger than
1013 * 2^31 - 1; use httpGetLength2() instead.
1014 *
1015 * @deprecated@
1016 */
1017
1018 int /* O - Content length */
1019 httpGetLength(http_t *http) /* I - HTTP connection */
1020 {
1021 /*
1022 * Get the read content length and return the 32-bit value.
1023 */
1024
1025 if (http)
1026 {
1027 httpGetLength2(http);
1028
1029 return (http->_data_remaining);
1030 }
1031 else
1032 return (-1);
1033 }
1034
1035
1036 /*
1037 * 'httpGetLength2()' - Get the amount of data remaining from the
1038 * content-length or transfer-encoding fields.
1039 *
1040 * This function returns the complete content length, even for
1041 * content larger than 2^31 - 1.
1042 *
1043 * @since CUPS 1.2/OS X 10.5@
1044 */
1045
1046 off_t /* O - Content length */
1047 httpGetLength2(http_t *http) /* I - HTTP connection */
1048 {
1049 off_t remaining; /* Remaining length */
1050
1051
1052 DEBUG_printf(("2httpGetLength2(http=%p), state=%s", http,
1053 httpStateString(http->state)));
1054
1055 if (!http)
1056 return (-1);
1057
1058 if (!_cups_strcasecmp(http->fields[HTTP_FIELD_TRANSFER_ENCODING], "chunked"))
1059 {
1060 DEBUG_puts("4httpGetLength2: chunked request!");
1061 remaining = 0;
1062 }
1063 else
1064 {
1065 /*
1066 * The following is a hack for HTTP servers that don't send a
1067 * Content-Length or Transfer-Encoding field...
1068 *
1069 * If there is no Content-Length then the connection must close
1070 * after the transfer is complete...
1071 */
1072
1073 if (!http->fields[HTTP_FIELD_CONTENT_LENGTH][0])
1074 {
1075 /*
1076 * Default content length is 0 for errors and certain types of operations,
1077 * and 2^31-1 for other successful requests...
1078 */
1079
1080 if (http->status >= HTTP_STATUS_MULTIPLE_CHOICES ||
1081 http->state == HTTP_STATE_OPTIONS ||
1082 (http->state == HTTP_STATE_GET && http->mode == _HTTP_MODE_SERVER) ||
1083 http->state == HTTP_STATE_HEAD ||
1084 (http->state == HTTP_STATE_PUT && http->mode == _HTTP_MODE_CLIENT) ||
1085 http->state == HTTP_STATE_DELETE ||
1086 http->state == HTTP_STATE_TRACE ||
1087 http->state == HTTP_STATE_CONNECT)
1088 remaining = 0;
1089 else
1090 remaining = 2147483647;
1091 }
1092 else if ((remaining = strtoll(http->fields[HTTP_FIELD_CONTENT_LENGTH],
1093 NULL, 10)) < 0)
1094 remaining = -1;
1095
1096 DEBUG_printf(("4httpGetLength2: content_length=" CUPS_LLFMT,
1097 CUPS_LLCAST remaining));
1098 }
1099
1100 return (remaining);
1101 }
1102
1103
1104 /*
1105 * 'httpGetPending()' - Get the number of bytes that are buffered for writing.
1106 *
1107 * @since CUPS 2.0/OS 10.10@
1108 */
1109
1110 size_t /* O - Number of bytes buffered */
1111 httpGetPending(http_t *http) /* I - HTTP connection */
1112 {
1113 return (http ? (size_t)http->wused : 0);
1114 }
1115
1116
1117 /*
1118 * 'httpGetReady()' - Get the number of bytes that can be read without blocking.
1119 *
1120 * @since CUPS 2.0/OS 10.10@
1121 */
1122
1123 size_t /* O - Number of bytes available */
1124 httpGetReady(http_t *http) /* I - HTTP connection */
1125 {
1126 if (!http)
1127 return (0);
1128 else if (http->used > 0)
1129 return ((size_t)http->used);
1130 #ifdef HAVE_SSL
1131 else if (http->tls)
1132 return (_httpTLSPending(http));
1133 #endif /* HAVE_SSL */
1134
1135 return (0);
1136 }
1137
1138
1139 /*
1140 * 'httpGetRemaining()' - Get the number of remaining bytes in the message
1141 * body or current chunk.
1142 *
1143 * The @link httpIsChunked@ function can be used to determine whether the
1144 * message body is chunked or fixed-length.
1145 *
1146 * @since CUPS 2.0/OS 10.10@
1147 */
1148
1149 size_t /* O - Remaining bytes */
1150 httpGetRemaining(http_t *http) /* I - HTTP connection */
1151 {
1152 return (http ? (size_t)http->data_remaining : 0);
1153 }
1154
1155
1156 /*
1157 * 'httpGets()' - Get a line of text from a HTTP connection.
1158 */
1159
1160 char * /* O - Line or NULL */
1161 httpGets(char *line, /* I - Line to read into */
1162 int length, /* I - Max length of buffer */
1163 http_t *http) /* I - HTTP connection */
1164 {
1165 char *lineptr, /* Pointer into line */
1166 *lineend, /* End of line */
1167 *bufptr, /* Pointer into input buffer */
1168 *bufend; /* Pointer to end of buffer */
1169 ssize_t bytes; /* Number of bytes read */
1170 int eol; /* End-of-line? */
1171
1172
1173 DEBUG_printf(("2httpGets(line=%p, length=%d, http=%p)", line, length, http));
1174
1175 if (!http || !line || length <= 1)
1176 return (NULL);
1177
1178 /*
1179 * Read a line from the buffer...
1180 */
1181
1182 http->error = 0;
1183 lineptr = line;
1184 lineend = line + length - 1;
1185 eol = 0;
1186
1187 while (lineptr < lineend)
1188 {
1189 /*
1190 * Pre-load the buffer as needed...
1191 */
1192
1193 #ifdef WIN32
1194 WSASetLastError(0);
1195 #else
1196 errno = 0;
1197 #endif /* WIN32 */
1198
1199 while (http->used == 0)
1200 {
1201 /*
1202 * No newline; see if there is more data to be read...
1203 */
1204
1205 while (!_httpWait(http, http->wait_value, 1))
1206 {
1207 if (http->timeout_cb && (*http->timeout_cb)(http, http->timeout_data))
1208 continue;
1209
1210 DEBUG_puts("3httpGets: Timed out!");
1211 #ifdef WIN32
1212 http->error = WSAETIMEDOUT;
1213 #else
1214 http->error = ETIMEDOUT;
1215 #endif /* WIN32 */
1216 return (NULL);
1217 }
1218
1219 bytes = http_read(http, http->buffer + http->used, (size_t)(HTTP_MAX_BUFFER - http->used));
1220
1221 DEBUG_printf(("4httpGets: read " CUPS_LLFMT " bytes.", CUPS_LLCAST bytes));
1222
1223 if (bytes < 0)
1224 {
1225 /*
1226 * Nope, can't get a line this time...
1227 */
1228
1229 #ifdef WIN32
1230 DEBUG_printf(("3httpGets: recv() error %d!", WSAGetLastError()));
1231
1232 if (WSAGetLastError() == WSAEINTR)
1233 continue;
1234 else if (WSAGetLastError() == WSAEWOULDBLOCK)
1235 {
1236 if (http->timeout_cb && (*http->timeout_cb)(http, http->timeout_data))
1237 continue;
1238
1239 http->error = WSAGetLastError();
1240 }
1241 else if (WSAGetLastError() != http->error)
1242 {
1243 http->error = WSAGetLastError();
1244 continue;
1245 }
1246
1247 #else
1248 DEBUG_printf(("3httpGets: recv() error %d!", errno));
1249
1250 if (errno == EINTR)
1251 continue;
1252 else if (errno == EWOULDBLOCK || errno == EAGAIN)
1253 {
1254 if (http->timeout_cb && (*http->timeout_cb)(http, http->timeout_data))
1255 continue;
1256 else if (!http->timeout_cb && errno == EAGAIN)
1257 continue;
1258
1259 http->error = errno;
1260 }
1261 else if (errno != http->error)
1262 {
1263 http->error = errno;
1264 continue;
1265 }
1266 #endif /* WIN32 */
1267
1268 return (NULL);
1269 }
1270 else if (bytes == 0)
1271 {
1272 http->error = EPIPE;
1273
1274 return (NULL);
1275 }
1276
1277 /*
1278 * Yup, update the amount used...
1279 */
1280
1281 http->used += (int)bytes;
1282 }
1283
1284 /*
1285 * Now copy as much of the current line as possible...
1286 */
1287
1288 for (bufptr = http->buffer, bufend = http->buffer + http->used;
1289 lineptr < lineend && bufptr < bufend;)
1290 {
1291 if (*bufptr == 0x0a)
1292 {
1293 eol = 1;
1294 bufptr ++;
1295 break;
1296 }
1297 else if (*bufptr == 0x0d)
1298 bufptr ++;
1299 else
1300 *lineptr++ = *bufptr++;
1301 }
1302
1303 http->used -= (int)(bufptr - http->buffer);
1304 if (http->used > 0)
1305 memmove(http->buffer, bufptr, (size_t)http->used);
1306
1307 if (eol)
1308 {
1309 /*
1310 * End of line...
1311 */
1312
1313 http->activity = time(NULL);
1314
1315 *lineptr = '\0';
1316
1317 DEBUG_printf(("3httpGets: Returning \"%s\"", line));
1318
1319 return (line);
1320 }
1321 }
1322
1323 DEBUG_puts("3httpGets: No new line available!");
1324
1325 return (NULL);
1326 }
1327
1328
1329 /*
1330 * 'httpGetState()' - Get the current state of the HTTP request.
1331 */
1332
1333 http_state_t /* O - HTTP state */
1334 httpGetState(http_t *http) /* I - HTTP connection */
1335 {
1336 return (http ? http->state : HTTP_STATE_ERROR);
1337 }
1338
1339
1340 /*
1341 * 'httpGetStatus()' - Get the status of the last HTTP request.
1342 *
1343 * @since CUPS 1.2/OS X 10.5@
1344 */
1345
1346 http_status_t /* O - HTTP status */
1347 httpGetStatus(http_t *http) /* I - HTTP connection */
1348 {
1349 return (http ? http->status : HTTP_STATUS_ERROR);
1350 }
1351
1352
1353 /*
1354 * 'httpGetSubField()' - Get a sub-field value.
1355 *
1356 * @deprecated@
1357 */
1358
1359 char * /* O - Value or NULL */
1360 httpGetSubField(http_t *http, /* I - HTTP connection */
1361 http_field_t field, /* I - Field index */
1362 const char *name, /* I - Name of sub-field */
1363 char *value) /* O - Value string */
1364 {
1365 return (httpGetSubField2(http, field, name, value, HTTP_MAX_VALUE));
1366 }
1367
1368
1369 /*
1370 * 'httpGetSubField2()' - Get a sub-field value.
1371 *
1372 * @since CUPS 1.2/OS X 10.5@
1373 */
1374
1375 char * /* O - Value or NULL */
1376 httpGetSubField2(http_t *http, /* I - HTTP connection */
1377 http_field_t field, /* I - Field index */
1378 const char *name, /* I - Name of sub-field */
1379 char *value, /* O - Value string */
1380 int valuelen) /* I - Size of value buffer */
1381 {
1382 const char *fptr; /* Pointer into field */
1383 char temp[HTTP_MAX_VALUE], /* Temporary buffer for name */
1384 *ptr, /* Pointer into string buffer */
1385 *end; /* End of value buffer */
1386
1387 DEBUG_printf(("2httpGetSubField2(http=%p, field=%d, name=\"%s\", value=%p, "
1388 "valuelen=%d)", http, field, name, value, valuelen));
1389
1390 if (!http || !name || !value || valuelen < 2 ||
1391 field <= HTTP_FIELD_UNKNOWN || field >= HTTP_FIELD_MAX)
1392 return (NULL);
1393
1394 end = value + valuelen - 1;
1395
1396 for (fptr = http->fields[field]; *fptr;)
1397 {
1398 /*
1399 * Skip leading whitespace...
1400 */
1401
1402 while (_cups_isspace(*fptr))
1403 fptr ++;
1404
1405 if (*fptr == ',')
1406 {
1407 fptr ++;
1408 continue;
1409 }
1410
1411 /*
1412 * Get the sub-field name...
1413 */
1414
1415 for (ptr = temp;
1416 *fptr && *fptr != '=' && !_cups_isspace(*fptr) &&
1417 ptr < (temp + sizeof(temp) - 1);
1418 *ptr++ = *fptr++);
1419
1420 *ptr = '\0';
1421
1422 DEBUG_printf(("4httpGetSubField2: name=\"%s\"", temp));
1423
1424 /*
1425 * Skip trailing chars up to the '='...
1426 */
1427
1428 while (_cups_isspace(*fptr))
1429 fptr ++;
1430
1431 if (!*fptr)
1432 break;
1433
1434 if (*fptr != '=')
1435 continue;
1436
1437 /*
1438 * Skip = and leading whitespace...
1439 */
1440
1441 fptr ++;
1442
1443 while (_cups_isspace(*fptr))
1444 fptr ++;
1445
1446 if (*fptr == '\"')
1447 {
1448 /*
1449 * Read quoted string...
1450 */
1451
1452 for (ptr = value, fptr ++;
1453 *fptr && *fptr != '\"' && ptr < end;
1454 *ptr++ = *fptr++);
1455
1456 *ptr = '\0';
1457
1458 while (*fptr && *fptr != '\"')
1459 fptr ++;
1460
1461 if (*fptr)
1462 fptr ++;
1463 }
1464 else
1465 {
1466 /*
1467 * Read unquoted string...
1468 */
1469
1470 for (ptr = value;
1471 *fptr && !_cups_isspace(*fptr) && *fptr != ',' && ptr < end;
1472 *ptr++ = *fptr++);
1473
1474 *ptr = '\0';
1475
1476 while (*fptr && !_cups_isspace(*fptr) && *fptr != ',')
1477 fptr ++;
1478 }
1479
1480 DEBUG_printf(("4httpGetSubField2: value=\"%s\"", value));
1481
1482 /*
1483 * See if this is the one...
1484 */
1485
1486 if (!strcmp(name, temp))
1487 {
1488 DEBUG_printf(("3httpGetSubField2: Returning \"%s\"", value));
1489 return (value);
1490 }
1491 }
1492
1493 value[0] = '\0';
1494
1495 DEBUG_puts("3httpGetSubField2: Returning NULL");
1496
1497 return (NULL);
1498 }
1499
1500
1501 /*
1502 * 'httpGetVersion()' - Get the HTTP version at the other end.
1503 */
1504
1505 http_version_t /* O - Version number */
1506 httpGetVersion(http_t *http) /* I - HTTP connection */
1507 {
1508 return (http ? http->version : HTTP_VERSION_1_0);
1509 }
1510
1511
1512 /*
1513 * 'httpHead()' - Send a HEAD request to the server.
1514 */
1515
1516 int /* O - Status of call (0 = success) */
1517 httpHead(http_t *http, /* I - HTTP connection */
1518 const char *uri) /* I - URI for head */
1519 {
1520 DEBUG_printf(("httpHead(http=%p, uri=\"%s\")", http, uri));
1521 return (http_send(http, HTTP_STATE_HEAD, uri));
1522 }
1523
1524
1525 /*
1526 * 'httpInitialize()' - Initialize the HTTP interface library and set the
1527 * default HTTP proxy (if any).
1528 */
1529
1530 void
1531 httpInitialize(void)
1532 {
1533 static int initialized = 0; /* Have we been called before? */
1534 #ifdef WIN32
1535 WSADATA winsockdata; /* WinSock data */
1536 #endif /* WIN32 */
1537
1538
1539 _cupsGlobalLock();
1540 if (initialized)
1541 {
1542 _cupsGlobalUnlock();
1543 return;
1544 }
1545
1546 #ifdef WIN32
1547 WSAStartup(MAKEWORD(2,2), &winsockdata);
1548
1549 #elif !defined(SO_NOSIGPIPE)
1550 /*
1551 * Ignore SIGPIPE signals...
1552 */
1553
1554 # ifdef HAVE_SIGSET
1555 sigset(SIGPIPE, SIG_IGN);
1556
1557 # elif defined(HAVE_SIGACTION)
1558 struct sigaction action; /* POSIX sigaction data */
1559
1560
1561 memset(&action, 0, sizeof(action));
1562 action.sa_handler = SIG_IGN;
1563 sigaction(SIGPIPE, &action, NULL);
1564
1565 # else
1566 signal(SIGPIPE, SIG_IGN);
1567 # endif /* !SO_NOSIGPIPE */
1568 #endif /* WIN32 */
1569
1570 # ifdef HAVE_SSL
1571 _httpTLSInitialize();
1572 # endif /* HAVE_SSL */
1573
1574 initialized = 1;
1575 _cupsGlobalUnlock();
1576 }
1577
1578
1579 /*
1580 * 'httpIsChunked()' - Report whether a message body is chunked.
1581 *
1582 * This function returns non-zero if the message body is composed of
1583 * variable-length chunks.
1584 *
1585 * @since CUPS 2.0/OS 10.10@
1586 */
1587
1588 int /* O - 1 if chunked, 0 if not */
1589 httpIsChunked(http_t *http) /* I - HTTP connection */
1590 {
1591 return (http ? http->data_encoding == HTTP_ENCODING_CHUNKED : 0);
1592 }
1593
1594
1595 /*
1596 * 'httpIsEncrypted()' - Report whether a connection is encrypted.
1597 *
1598 * This function returns non-zero if the connection is currently encrypted.
1599 *
1600 * @since CUPS 2.0/OS 10.10@
1601 */
1602
1603 int /* O - 1 if encrypted, 0 if not */
1604 httpIsEncrypted(http_t *http) /* I - HTTP connection */
1605 {
1606 return (http ? http->tls != NULL : 0);
1607 }
1608
1609
1610 /*
1611 * 'httpOptions()' - Send an OPTIONS request to the server.
1612 */
1613
1614 int /* O - Status of call (0 = success) */
1615 httpOptions(http_t *http, /* I - HTTP connection */
1616 const char *uri) /* I - URI for options */
1617 {
1618 return (http_send(http, HTTP_STATE_OPTIONS, uri));
1619 }
1620
1621
1622 /*
1623 * 'httpPeek()' - Peek at data from a HTTP connection.
1624 *
1625 * This function copies available data from the given HTTP connection, reading
1626 * a buffer as needed. The data is still available for reading using
1627 * @link httpRead@ or @link httpRead2@.
1628 *
1629 * For non-blocking connections the usual timeouts apply.
1630 *
1631 * @since CUPS 1.7/OS X 10.9@
1632 */
1633
1634 ssize_t /* O - Number of bytes copied */
1635 httpPeek(http_t *http, /* I - HTTP connection */
1636 char *buffer, /* I - Buffer for data */
1637 size_t length) /* I - Maximum number of bytes */
1638 {
1639 ssize_t bytes; /* Bytes read */
1640 char len[32]; /* Length string */
1641
1642
1643 DEBUG_printf(("httpPeek(http=%p, buffer=%p, length=" CUPS_LLFMT ")",
1644 http, buffer, CUPS_LLCAST length));
1645
1646 if (http == NULL || buffer == NULL)
1647 return (-1);
1648
1649 http->activity = time(NULL);
1650 http->error = 0;
1651
1652 if (length <= 0)
1653 return (0);
1654
1655 if (http->data_encoding == HTTP_ENCODING_CHUNKED &&
1656 http->data_remaining <= 0)
1657 {
1658 DEBUG_puts("2httpPeek: Getting chunk length...");
1659
1660 if (httpGets(len, sizeof(len), http) == NULL)
1661 {
1662 DEBUG_puts("1httpPeek: Could not get length!");
1663 return (0);
1664 }
1665
1666 if (!len[0])
1667 {
1668 DEBUG_puts("1httpPeek: Blank chunk length, trying again...");
1669 if (!httpGets(len, sizeof(len), http))
1670 {
1671 DEBUG_puts("1httpPeek: Could not get chunk length.");
1672 return (0);
1673 }
1674 }
1675
1676 http->data_remaining = strtoll(len, NULL, 16);
1677
1678 if (http->data_remaining < 0)
1679 {
1680 DEBUG_puts("1httpPeek: Negative chunk length!");
1681 return (0);
1682 }
1683 }
1684
1685 DEBUG_printf(("2httpPeek: data_remaining=" CUPS_LLFMT,
1686 CUPS_LLCAST http->data_remaining));
1687
1688 if (http->data_remaining <= 0 && http->data_encoding != HTTP_ENCODING_FIELDS)
1689 {
1690 /*
1691 * A zero-length chunk ends a transfer; unless we are reading POST
1692 * data, go idle...
1693 */
1694
1695 #ifdef HAVE_LIBZ
1696 if (http->coding >= _HTTP_CODING_GUNZIP)
1697 http_content_coding_finish(http);
1698 #endif /* HAVE_LIBZ */
1699
1700 if (http->data_encoding == HTTP_ENCODING_CHUNKED)
1701 httpGets(len, sizeof(len), http);
1702
1703 if (http->state == HTTP_STATE_POST_RECV)
1704 http->state ++;
1705 else
1706 http->state = HTTP_STATE_STATUS;
1707
1708 DEBUG_printf(("1httpPeek: 0-length chunk, set state to %s.",
1709 httpStateString(http->state)));
1710
1711 /*
1712 * Prevent future reads for this request...
1713 */
1714
1715 http->data_encoding = HTTP_ENCODING_FIELDS;
1716
1717 return (0);
1718 }
1719 else if (length > (size_t)http->data_remaining)
1720 length = (size_t)http->data_remaining;
1721
1722 #ifdef HAVE_LIBZ
1723 if (http->used == 0 &&
1724 (http->coding == _HTTP_CODING_IDENTITY ||
1725 (http->coding >= _HTTP_CODING_GUNZIP && http->stream.avail_in == 0)))
1726 #else
1727 if (http->used == 0)
1728 #endif /* HAVE_LIBZ */
1729 {
1730 /*
1731 * Buffer small reads for better performance...
1732 */
1733
1734 ssize_t buflen; /* Length of read for buffer */
1735
1736 if (!http->blocking)
1737 {
1738 while (!httpWait(http, http->wait_value))
1739 {
1740 if (http->timeout_cb && (*http->timeout_cb)(http, http->timeout_data))
1741 continue;
1742
1743 return (0);
1744 }
1745 }
1746
1747 if ((size_t)http->data_remaining > sizeof(http->buffer))
1748 buflen = sizeof(http->buffer);
1749 else
1750 buflen = (ssize_t)http->data_remaining;
1751
1752 DEBUG_printf(("2httpPeek: Reading %d bytes into buffer.", (int)buflen));
1753 bytes = http_read(http, http->buffer, (size_t)buflen);
1754
1755 DEBUG_printf(("2httpPeek: Read " CUPS_LLFMT " bytes into buffer.",
1756 CUPS_LLCAST bytes));
1757 if (bytes > 0)
1758 {
1759 #ifdef DEBUG
1760 http_debug_hex("httpPeek", http->buffer, (int)bytes);
1761 #endif /* DEBUG */
1762
1763 http->used = (int)bytes;
1764 }
1765 }
1766
1767 #ifdef HAVE_LIBZ
1768 if (http->coding >= _HTTP_CODING_GUNZIP)
1769 {
1770 # ifdef HAVE_INFLATECOPY
1771 int zerr; /* Decompressor error */
1772 z_stream stream; /* Copy of decompressor stream */
1773
1774 if (http->used > 0 && http->stream.avail_in < HTTP_MAX_BUFFER)
1775 {
1776 size_t buflen = buflen = HTTP_MAX_BUFFER - http->stream.avail_in;
1777 /* Number of bytes to copy */
1778
1779 if (http->stream.avail_in > 0 &&
1780 http->stream.next_in > http->sbuffer)
1781 memmove(http->sbuffer, http->stream.next_in, http->stream.avail_in);
1782
1783 http->stream.next_in = http->sbuffer;
1784
1785 if (buflen > (size_t)http->data_remaining)
1786 buflen = (size_t)http->data_remaining;
1787
1788 if (buflen > (size_t)http->used)
1789 buflen = (size_t)http->used;
1790
1791 DEBUG_printf(("1httpPeek: Copying %d more bytes of data into "
1792 "decompression buffer.", (int)buflen));
1793
1794 memcpy(http->sbuffer + http->stream.avail_in, http->buffer, buflen);
1795 http->stream.avail_in += buflen;
1796 http->used -= (int)buflen;
1797 http->data_remaining -= (off_t)buflen;
1798
1799 if (http->used > 0)
1800 memmove(http->buffer, http->buffer + buflen, (size_t)http->used);
1801 }
1802
1803 DEBUG_printf(("2httpPeek: length=%d, avail_in=%d", (int)length,
1804 (int)http->stream.avail_in));
1805
1806 if (inflateCopy(&stream, &(http->stream)) != Z_OK)
1807 {
1808 DEBUG_puts("2httpPeek: Unable to copy decompressor stream.");
1809 http->error = ENOMEM;
1810 return (-1);
1811 }
1812
1813 stream.next_out = (Bytef *)buffer;
1814 stream.avail_out = (uInt)length;
1815
1816 zerr = inflate(&stream, Z_SYNC_FLUSH);
1817 inflateEnd(&stream);
1818
1819 if (zerr < Z_OK)
1820 {
1821 DEBUG_printf(("2httpPeek: zerr=%d", zerr));
1822 #ifdef DEBUG
1823 http_debug_hex("2httpPeek", (char *)http->sbuffer, (int)http->stream.avail_in);
1824 #endif /* DEBUG */
1825
1826 http->error = EIO;
1827 return (-1);
1828 }
1829
1830 bytes = (ssize_t)(length - http->stream.avail_out);
1831
1832 # else
1833 DEBUG_puts("2httpPeek: No inflateCopy on this platform, httpPeek does not "
1834 "work with compressed streams.");
1835 return (-1);
1836 # endif /* HAVE_INFLATECOPY */
1837 }
1838 else
1839 #endif /* HAVE_LIBZ */
1840 if (http->used > 0)
1841 {
1842 if (length > (size_t)http->used)
1843 length = (size_t)http->used;
1844
1845 bytes = (ssize_t)length;
1846
1847 DEBUG_printf(("2httpPeek: grabbing %d bytes from input buffer...",
1848 (int)bytes));
1849
1850 memcpy(buffer, http->buffer, length);
1851 }
1852 else
1853 bytes = 0;
1854
1855 if (bytes < 0)
1856 {
1857 #ifdef WIN32
1858 if (WSAGetLastError() == WSAEINTR || WSAGetLastError() == WSAEWOULDBLOCK)
1859 bytes = 0;
1860 else
1861 http->error = WSAGetLastError();
1862 #else
1863 if (errno == EINTR || errno == EAGAIN)
1864 bytes = 0;
1865 else
1866 http->error = errno;
1867 #endif /* WIN32 */
1868 }
1869 else if (bytes == 0)
1870 {
1871 http->error = EPIPE;
1872 return (0);
1873 }
1874
1875 return (bytes);
1876 }
1877
1878
1879 /*
1880 * 'httpPost()' - Send a POST request to the server.
1881 */
1882
1883 int /* O - Status of call (0 = success) */
1884 httpPost(http_t *http, /* I - HTTP connection */
1885 const char *uri) /* I - URI for post */
1886 {
1887 return (http_send(http, HTTP_STATE_POST, uri));
1888 }
1889
1890
1891 /*
1892 * 'httpPrintf()' - Print a formatted string to a HTTP connection.
1893 *
1894 * @private@
1895 */
1896
1897 int /* O - Number of bytes written */
1898 httpPrintf(http_t *http, /* I - HTTP connection */
1899 const char *format, /* I - printf-style format string */
1900 ...) /* I - Additional args as needed */
1901 {
1902 ssize_t bytes; /* Number of bytes to write */
1903 char buf[16384]; /* Buffer for formatted string */
1904 va_list ap; /* Variable argument pointer */
1905
1906
1907 DEBUG_printf(("2httpPrintf(http=%p, format=\"%s\", ...)", http, format));
1908
1909 va_start(ap, format);
1910 bytes = vsnprintf(buf, sizeof(buf), format, ap);
1911 va_end(ap);
1912
1913 DEBUG_printf(("3httpPrintf: (" CUPS_LLFMT " bytes) %s", CUPS_LLCAST bytes, buf));
1914
1915 if (http->data_encoding == HTTP_ENCODING_FIELDS)
1916 return ((int)httpWrite2(http, buf, (size_t)bytes));
1917 else
1918 {
1919 if (http->wused)
1920 {
1921 DEBUG_puts("4httpPrintf: flushing existing data...");
1922
1923 if (httpFlushWrite(http) < 0)
1924 return (-1);
1925 }
1926
1927 return ((int)http_write(http, buf, (size_t)bytes));
1928 }
1929 }
1930
1931
1932 /*
1933 * 'httpPut()' - Send a PUT request to the server.
1934 */
1935
1936 int /* O - Status of call (0 = success) */
1937 httpPut(http_t *http, /* I - HTTP connection */
1938 const char *uri) /* I - URI to put */
1939 {
1940 DEBUG_printf(("httpPut(http=%p, uri=\"%s\")", http, uri));
1941 return (http_send(http, HTTP_STATE_PUT, uri));
1942 }
1943
1944
1945 /*
1946 * 'httpRead()' - Read data from a HTTP connection.
1947 *
1948 * This function is deprecated. Use the httpRead2() function which can
1949 * read more than 2GB of data.
1950 *
1951 * @deprecated@
1952 */
1953
1954 int /* O - Number of bytes read */
1955 httpRead(http_t *http, /* I - HTTP connection */
1956 char *buffer, /* I - Buffer for data */
1957 int length) /* I - Maximum number of bytes */
1958 {
1959 return ((int)httpRead2(http, buffer, (size_t)length));
1960 }
1961
1962
1963 /*
1964 * 'httpRead2()' - Read data from a HTTP connection.
1965 *
1966 * @since CUPS 1.2/OS X 10.5@
1967 */
1968
1969 ssize_t /* O - Number of bytes read */
1970 httpRead2(http_t *http, /* I - HTTP connection */
1971 char *buffer, /* I - Buffer for data */
1972 size_t length) /* I - Maximum number of bytes */
1973 {
1974 ssize_t bytes; /* Bytes read */
1975
1976
1977 #ifdef HAVE_LIBZ
1978 DEBUG_printf(("httpRead2(http=%p, buffer=%p, length=" CUPS_LLFMT
1979 ") coding=%d data_encoding=%d data_remaining=" CUPS_LLFMT,
1980 http, buffer, CUPS_LLCAST length,
1981 http->coding,
1982 http->data_encoding, CUPS_LLCAST http->data_remaining));
1983 #else
1984 DEBUG_printf(("httpRead2(http=%p, buffer=%p, length=" CUPS_LLFMT
1985 ") data_encoding=%d data_remaining=" CUPS_LLFMT,
1986 http, buffer, CUPS_LLCAST length,
1987 http->data_encoding, CUPS_LLCAST http->data_remaining));
1988 #endif /* HAVE_LIBZ */
1989
1990 if (http == NULL || buffer == NULL)
1991 return (-1);
1992
1993 http->activity = time(NULL);
1994 http->error = 0;
1995
1996 if (length <= 0)
1997 return (0);
1998
1999 #ifdef HAVE_LIBZ
2000 if (http->coding >= _HTTP_CODING_GUNZIP)
2001 {
2002 do
2003 {
2004 if (http->stream.avail_in > 0)
2005 {
2006 int zerr; /* Decompressor error */
2007
2008 DEBUG_printf(("2httpRead2: avail_in=%d, avail_out=%d",
2009 (int)http->stream.avail_in, (int)length));
2010
2011 http->stream.next_out = (Bytef *)buffer;
2012 http->stream.avail_out = (uInt)length;
2013
2014 if ((zerr = inflate(&(http->stream), Z_SYNC_FLUSH)) < Z_OK)
2015 {
2016 DEBUG_printf(("2httpRead2: zerr=%d", zerr));
2017 #ifdef DEBUG
2018 http_debug_hex("2httpRead2", (char *)http->sbuffer, (int)http->stream.avail_in);
2019 #endif /* DEBUG */
2020
2021 http->error = EIO;
2022 return (-1);
2023 }
2024
2025 bytes = (ssize_t)(length - http->stream.avail_out);
2026
2027 DEBUG_printf(("2httpRead2: avail_in=%d, avail_out=%d, bytes=%d",
2028 http->stream.avail_in, http->stream.avail_out,
2029 (int)bytes));
2030 }
2031 else
2032 bytes = 0;
2033
2034 if (bytes == 0)
2035 {
2036 ssize_t buflen = HTTP_MAX_BUFFER - (ssize_t)http->stream.avail_in;
2037 /* Additional bytes for buffer */
2038
2039 if (buflen > 0)
2040 {
2041 if (http->stream.avail_in > 0 &&
2042 http->stream.next_in > http->sbuffer)
2043 memmove(http->sbuffer, http->stream.next_in, http->stream.avail_in);
2044
2045 http->stream.next_in = http->sbuffer;
2046
2047 DEBUG_printf(("1httpRead2: Reading up to %d more bytes of data into "
2048 "decompression buffer.", (int)buflen));
2049
2050 if (http->data_remaining > 0)
2051 {
2052 if (buflen > http->data_remaining)
2053 buflen = (ssize_t)http->data_remaining;
2054
2055 bytes = http_read_buffered(http, (char *)http->sbuffer + http->stream.avail_in, (size_t)buflen);
2056 }
2057 else if (http->data_encoding == HTTP_ENCODING_CHUNKED)
2058 bytes = http_read_chunk(http, (char *)http->sbuffer + http->stream.avail_in, (size_t)buflen);
2059 else
2060 bytes = 0;
2061
2062 if (bytes < 0)
2063 return (bytes);
2064 else if (bytes == 0)
2065 break;
2066
2067 DEBUG_printf(("1httpRead2: Adding " CUPS_LLFMT " bytes to "
2068 "decompression buffer.", CUPS_LLCAST bytes));
2069
2070 http->data_remaining -= bytes;
2071 http->stream.avail_in += (uInt)bytes;
2072
2073 if (http->data_remaining <= 0 &&
2074 http->data_encoding == HTTP_ENCODING_CHUNKED)
2075 {
2076 /*
2077 * Read the trailing blank line now...
2078 */
2079
2080 char len[32]; /* Length string */
2081
2082 httpGets(len, sizeof(len), http);
2083 }
2084
2085 bytes = 0;
2086 }
2087 else
2088 return (0);
2089 }
2090 }
2091 while (bytes == 0);
2092 }
2093 else
2094 #endif /* HAVE_LIBZ */
2095 if (http->data_remaining == 0 && http->data_encoding == HTTP_ENCODING_CHUNKED)
2096 {
2097 if ((bytes = http_read_chunk(http, buffer, length)) > 0)
2098 {
2099 http->data_remaining -= bytes;
2100
2101 if (http->data_remaining <= 0)
2102 {
2103 /*
2104 * Read the trailing blank line now...
2105 */
2106
2107 char len[32]; /* Length string */
2108
2109 httpGets(len, sizeof(len), http);
2110 }
2111 }
2112 }
2113 else if (http->data_remaining <= 0)
2114 {
2115 /*
2116 * No more data to read...
2117 */
2118
2119 return (0);
2120 }
2121 else
2122 {
2123 DEBUG_printf(("1httpRead2: Reading up to %d bytes into buffer.",
2124 (int)length));
2125
2126 if (length > (size_t)http->data_remaining)
2127 length = (size_t)http->data_remaining;
2128
2129 if ((bytes = http_read_buffered(http, buffer, length)) > 0)
2130 {
2131 http->data_remaining -= bytes;
2132
2133 if (http->data_remaining <= 0 &&
2134 http->data_encoding == HTTP_ENCODING_CHUNKED)
2135 {
2136 /*
2137 * Read the trailing blank line now...
2138 */
2139
2140 char len[32]; /* Length string */
2141
2142 httpGets(len, sizeof(len), http);
2143 }
2144 }
2145 }
2146
2147 if (
2148 #ifdef HAVE_LIBZ
2149 (http->coding == _HTTP_CODING_IDENTITY ||
2150 (http->coding >= _HTTP_CODING_GUNZIP && http->stream.avail_in == 0)) &&
2151 #endif /* HAVE_LIBZ */
2152 ((http->data_remaining <= 0 &&
2153 http->data_encoding == HTTP_ENCODING_LENGTH) ||
2154 (http->data_encoding == HTTP_ENCODING_CHUNKED && bytes == 0)))
2155 {
2156 #ifdef HAVE_LIBZ
2157 if (http->coding >= _HTTP_CODING_GUNZIP)
2158 http_content_coding_finish(http);
2159 #endif /* HAVE_LIBZ */
2160
2161 if (http->state == HTTP_STATE_POST_RECV)
2162 http->state ++;
2163 else if (http->state == HTTP_STATE_GET_SEND ||
2164 http->state == HTTP_STATE_POST_SEND)
2165 http->state = HTTP_STATE_WAITING;
2166 else
2167 http->state = HTTP_STATE_STATUS;
2168
2169 DEBUG_printf(("1httpRead2: End of content, set state to %s.",
2170 httpStateString(http->state)));
2171 }
2172
2173 return (bytes);
2174 }
2175
2176
2177 /*
2178 * 'httpReadRequest()' - Read a HTTP request from a connection.
2179 *
2180 * @since CUPS 1.7/OS X 10.9@
2181 */
2182
2183 http_state_t /* O - New state of connection */
2184 httpReadRequest(http_t *http, /* I - HTTP connection */
2185 char *uri, /* I - URI buffer */
2186 size_t urilen) /* I - Size of URI buffer */
2187 {
2188 char line[4096], /* HTTP request line */
2189 *req_method, /* HTTP request method */
2190 *req_uri, /* HTTP request URI */
2191 *req_version; /* HTTP request version number string */
2192
2193
2194 /*
2195 * Range check input...
2196 */
2197
2198 DEBUG_printf(("httpReadRequest(http=%p, uri=%p, urilen=" CUPS_LLFMT ")",
2199 http, uri, CUPS_LLCAST urilen));
2200
2201 if (uri)
2202 *uri = '\0';
2203
2204 if (!http || !uri || urilen < 1)
2205 {
2206 DEBUG_puts("1httpReadRequest: Bad arguments, returning HTTP_STATE_ERROR.");
2207 return (HTTP_STATE_ERROR);
2208 }
2209 else if (http->state != HTTP_STATE_WAITING)
2210 {
2211 DEBUG_printf(("1httpReadRequest: Bad state %s, returning HTTP_STATE_ERROR.",
2212 httpStateString(http->state)));
2213 return (HTTP_STATE_ERROR);
2214 }
2215
2216 /*
2217 * Reset state...
2218 */
2219
2220 httpClearFields(http);
2221
2222 http->activity = time(NULL);
2223 http->data_encoding = HTTP_ENCODING_FIELDS;
2224 http->data_remaining = 0;
2225 http->keep_alive = HTTP_KEEPALIVE_OFF;
2226 http->status = HTTP_STATUS_OK;
2227 http->version = HTTP_VERSION_1_1;
2228
2229 /*
2230 * Read a line from the socket...
2231 */
2232
2233 if (!httpGets(line, sizeof(line), http))
2234 {
2235 DEBUG_puts("1httpReadRequest: Unable to read, returning HTTP_STATE_ERROR");
2236 return (HTTP_STATE_ERROR);
2237 }
2238
2239 if (!line[0])
2240 {
2241 DEBUG_puts("1httpReadRequest: Blank line, returning HTTP_STATE_WAITING");
2242 return (HTTP_STATE_WAITING);
2243 }
2244
2245 DEBUG_printf(("1httpReadRequest: %s", line));
2246
2247 /*
2248 * Parse it...
2249 */
2250
2251 req_method = line;
2252 req_uri = line;
2253
2254 while (*req_uri && !isspace(*req_uri & 255))
2255 req_uri ++;
2256
2257 if (!*req_uri)
2258 {
2259 DEBUG_puts("1httpReadRequest: No request URI.");
2260 _cupsSetError(IPP_STATUS_ERROR_INTERNAL, _("No request URI."), 1);
2261 return (HTTP_STATE_ERROR);
2262 }
2263
2264 *req_uri++ = '\0';
2265
2266 while (*req_uri && isspace(*req_uri & 255))
2267 req_uri ++;
2268
2269 req_version = req_uri;
2270
2271 while (*req_version && !isspace(*req_version & 255))
2272 req_version ++;
2273
2274 if (!*req_version)
2275 {
2276 DEBUG_puts("1httpReadRequest: No request protocol version.");
2277 _cupsSetError(IPP_STATUS_ERROR_INTERNAL, _("No request protocol version."), 1);
2278 return (HTTP_STATE_ERROR);
2279 }
2280
2281 *req_version++ = '\0';
2282
2283 while (*req_version && isspace(*req_version & 255))
2284 req_version ++;
2285
2286 /*
2287 * Validate...
2288 */
2289
2290 if (!strcmp(req_method, "OPTIONS"))
2291 http->state = HTTP_STATE_OPTIONS;
2292 else if (!strcmp(req_method, "GET"))
2293 http->state = HTTP_STATE_GET;
2294 else if (!strcmp(req_method, "HEAD"))
2295 http->state = HTTP_STATE_HEAD;
2296 else if (!strcmp(req_method, "POST"))
2297 http->state = HTTP_STATE_POST;
2298 else if (!strcmp(req_method, "PUT"))
2299 http->state = HTTP_STATE_PUT;
2300 else if (!strcmp(req_method, "DELETE"))
2301 http->state = HTTP_STATE_DELETE;
2302 else if (!strcmp(req_method, "TRACE"))
2303 http->state = HTTP_STATE_TRACE;
2304 else if (!strcmp(req_method, "CONNECT"))
2305 http->state = HTTP_STATE_CONNECT;
2306 else
2307 {
2308 DEBUG_printf(("1httpReadRequest: Unknown method \"%s\".", req_method));
2309 _cupsSetError(IPP_STATUS_ERROR_INTERNAL, _("Unknown request method."), 1);
2310 return (HTTP_STATE_UNKNOWN_METHOD);
2311 }
2312
2313 DEBUG_printf(("1httpReadRequest: Set state to %s.",
2314 httpStateString(http->state)));
2315
2316 if (!strcmp(req_version, "HTTP/1.0"))
2317 {
2318 http->version = HTTP_VERSION_1_0;
2319 http->keep_alive = HTTP_KEEPALIVE_OFF;
2320 }
2321 else if (!strcmp(req_version, "HTTP/1.1"))
2322 {
2323 http->version = HTTP_VERSION_1_1;
2324 http->keep_alive = HTTP_KEEPALIVE_ON;
2325 }
2326 else
2327 {
2328 DEBUG_printf(("1httpReadRequest: Unknown version \"%s\".", req_version));
2329 _cupsSetError(IPP_STATUS_ERROR_INTERNAL, _("Unknown request version."), 1);
2330 return (HTTP_STATE_UNKNOWN_VERSION);
2331 }
2332
2333 DEBUG_printf(("1httpReadRequest: URI is \"%s\".", req_uri));
2334 strlcpy(uri, req_uri, urilen);
2335
2336 return (http->state);
2337 }
2338
2339
2340 /*
2341 * 'httpReconnect()' - Reconnect to a HTTP server.
2342 *
2343 * This function is deprecated. Please use the @link httpReconnect2@ function
2344 * instead.
2345 *
2346 * @deprecated@
2347 */
2348
2349 int /* O - 0 on success, non-zero on failure */
2350 httpReconnect(http_t *http) /* I - HTTP connection */
2351 {
2352 DEBUG_printf(("httpReconnect(http=%p)", http));
2353
2354 return (httpReconnect2(http, 30000, NULL));
2355 }
2356
2357
2358 /*
2359 * 'httpReconnect2()' - Reconnect to a HTTP server with timeout and optional
2360 * cancel.
2361 */
2362
2363 int /* O - 0 on success, non-zero on failure */
2364 httpReconnect2(http_t *http, /* I - HTTP connection */
2365 int msec, /* I - Timeout in milliseconds */
2366 int *cancel) /* I - Pointer to "cancel" variable */
2367 {
2368 http_addrlist_t *addr; /* Connected address */
2369 #ifdef DEBUG
2370 http_addrlist_t *current; /* Current address */
2371 char temp[256]; /* Temporary address string */
2372 #endif /* DEBUG */
2373
2374
2375 DEBUG_printf(("httpReconnect2(http=%p, msec=%d, cancel=%p)", http, msec,
2376 cancel));
2377
2378 if (!http)
2379 {
2380 _cupsSetError(IPP_STATUS_ERROR_INTERNAL, strerror(EINVAL), 0);
2381 return (-1);
2382 }
2383
2384 #ifdef HAVE_SSL
2385 if (http->tls)
2386 {
2387 DEBUG_puts("2httpReconnect2: Shutting down SSL/TLS...");
2388 _httpTLSStop(http);
2389 }
2390 #endif /* HAVE_SSL */
2391
2392 /*
2393 * Close any previously open socket...
2394 */
2395
2396 if (http->fd >= 0)
2397 {
2398 DEBUG_printf(("2httpReconnect2: Closing socket %d...", http->fd));
2399
2400 httpAddrClose(NULL, http->fd);
2401
2402 http->fd = -1;
2403 }
2404
2405 /*
2406 * Reset all state (except fields, which may be reused)...
2407 */
2408
2409 http->state = HTTP_STATE_WAITING;
2410 http->version = HTTP_VERSION_1_1;
2411 http->keep_alive = HTTP_KEEPALIVE_OFF;
2412 memset(&http->_hostaddr, 0, sizeof(http->_hostaddr));
2413 http->data_encoding = HTTP_ENCODING_FIELDS;
2414 http->_data_remaining = 0;
2415 http->used = 0;
2416 http->data_remaining = 0;
2417 http->hostaddr = NULL;
2418 http->wused = 0;
2419
2420 /*
2421 * Connect to the server...
2422 */
2423
2424 #ifdef DEBUG
2425 for (current = http->addrlist; current; current = current->next)
2426 DEBUG_printf(("2httpReconnect2: Address %s:%d",
2427 httpAddrString(&(current->addr), temp, sizeof(temp)),
2428 httpAddrPort(&(current->addr))));
2429 #endif /* DEBUG */
2430
2431 if ((addr = httpAddrConnect2(http->addrlist, &(http->fd), msec,
2432 cancel)) == NULL)
2433 {
2434 /*
2435 * Unable to connect...
2436 */
2437
2438 #ifdef WIN32
2439 http->error = WSAGetLastError();
2440 #else
2441 http->error = errno;
2442 #endif /* WIN32 */
2443 http->status = HTTP_STATUS_ERROR;
2444
2445 DEBUG_printf(("1httpReconnect2: httpAddrConnect failed: %s",
2446 strerror(http->error)));
2447
2448 return (-1);
2449 }
2450
2451 DEBUG_printf(("2httpReconnect2: New socket=%d", http->fd));
2452
2453 if (http->timeout_value > 0)
2454 http_set_timeout(http->fd, http->timeout_value);
2455
2456 http->hostaddr = &(addr->addr);
2457 http->error = 0;
2458
2459 #ifdef HAVE_SSL
2460 if (http->encryption == HTTP_ENCRYPTION_ALWAYS)
2461 {
2462 /*
2463 * Always do encryption via SSL.
2464 */
2465
2466 if (_httpTLSStart(http) != 0)
2467 {
2468 httpAddrClose(NULL, http->fd);
2469
2470 return (-1);
2471 }
2472 }
2473 else if (http->encryption == HTTP_ENCRYPTION_REQUIRED && !http->tls_upgrade)
2474 return (http_tls_upgrade(http));
2475 #endif /* HAVE_SSL */
2476
2477 DEBUG_printf(("1httpReconnect2: Connected to %s:%d...",
2478 httpAddrString(http->hostaddr, temp, sizeof(temp)),
2479 httpAddrPort(http->hostaddr)));
2480
2481 return (0);
2482 }
2483
2484
2485 /*
2486 * 'httpSetAuthString()' - Set the current authorization string.
2487 *
2488 * This function just stores a copy of the current authorization string in
2489 * the HTTP connection object. You must still call httpSetField() to set
2490 * HTTP_FIELD_AUTHORIZATION prior to issuing a HTTP request using httpGet(),
2491 * httpHead(), httpOptions(), httpPost, or httpPut().
2492 *
2493 * @since CUPS 1.3/OS X 10.5@
2494 */
2495
2496 void
2497 httpSetAuthString(http_t *http, /* I - HTTP connection */
2498 const char *scheme, /* I - Auth scheme (NULL to clear it) */
2499 const char *data) /* I - Auth data (NULL for none) */
2500 {
2501 /*
2502 * Range check input...
2503 */
2504
2505 if (!http)
2506 return;
2507
2508 if (http->authstring && http->authstring != http->_authstring)
2509 free(http->authstring);
2510
2511 http->authstring = http->_authstring;
2512
2513 if (scheme)
2514 {
2515 /*
2516 * Set the current authorization string...
2517 */
2518
2519 size_t len = strlen(scheme) + (data ? strlen(data) + 1 : 0) + 1;
2520 char *temp;
2521
2522 if (len > sizeof(http->_authstring))
2523 {
2524 if ((temp = malloc(len)) == NULL)
2525 len = sizeof(http->_authstring);
2526 else
2527 http->authstring = temp;
2528 }
2529
2530 if (data)
2531 snprintf(http->authstring, len, "%s %s", scheme, data);
2532 else
2533 strlcpy(http->authstring, scheme, len);
2534 }
2535 else
2536 {
2537 /*
2538 * Clear the current authorization string...
2539 */
2540
2541 http->_authstring[0] = '\0';
2542 }
2543 }
2544
2545
2546 /*
2547 * 'httpSetCredentials()' - Set the credentials associated with an encrypted
2548 * connection.
2549 *
2550 * @since CUPS 1.5/OS X 10.7@
2551 */
2552
2553 int /* O - Status of call (0 = success) */
2554 httpSetCredentials(http_t *http, /* I - HTTP connection */
2555 cups_array_t *credentials) /* I - Array of credentials */
2556 {
2557 if (!http || cupsArrayCount(credentials) < 1)
2558 return (-1);
2559
2560 #ifdef HAVE_SSL
2561 _httpFreeCredentials(http->tls_credentials);
2562
2563 http->tls_credentials = _httpCreateCredentials(credentials);
2564 #endif /* HAVE_SSL */
2565
2566 return (http->tls_credentials ? 0 : -1);
2567 }
2568
2569
2570 /*
2571 * 'httpSetCookie()' - Set the cookie value(s).
2572 *
2573 * @since CUPS 1.1.19/OS X 10.3@
2574 */
2575
2576 void
2577 httpSetCookie(http_t *http, /* I - Connection */
2578 const char *cookie) /* I - Cookie string */
2579 {
2580 if (!http)
2581 return;
2582
2583 if (http->cookie)
2584 free(http->cookie);
2585
2586 if (cookie)
2587 http->cookie = strdup(cookie);
2588 else
2589 http->cookie = NULL;
2590 }
2591
2592
2593 /*
2594 * 'httpSetDefaultField()' - Set the default value of an HTTP header.
2595 *
2596 * Currently only @code HTTP_FIELD_ACCEPT_ENCODING@, @code HTTP_FIELD_SERVER@,
2597 * and @code HTTP_FIELD_USER_AGENT@ can be set.
2598 *
2599 * @since CUPS 1.7/OS X 10.9@
2600 */
2601
2602 void
2603 httpSetDefaultField(http_t *http, /* I - HTTP connection */
2604 http_field_t field, /* I - Field index */
2605 const char *value)/* I - Value */
2606 {
2607 DEBUG_printf(("httpSetDefaultField(http=%p, field=%d(%s), value=\"%s\")",
2608 http, field, http_fields[field], value));
2609
2610 if (!http)
2611 return;
2612
2613 switch (field)
2614 {
2615 case HTTP_FIELD_ACCEPT_ENCODING :
2616 if (http->default_accept_encoding)
2617 _cupsStrFree(http->default_accept_encoding);
2618
2619 http->default_accept_encoding = value ? _cupsStrAlloc(value) : NULL;
2620 break;
2621
2622 case HTTP_FIELD_SERVER :
2623 if (http->default_server)
2624 _cupsStrFree(http->default_server);
2625
2626 http->default_server = value ? _cupsStrAlloc(value) : NULL;
2627 break;
2628
2629 case HTTP_FIELD_USER_AGENT :
2630 if (http->default_user_agent)
2631 _cupsStrFree(http->default_user_agent);
2632
2633 http->default_user_agent = value ? _cupsStrAlloc(value) : NULL;
2634 break;
2635
2636 default :
2637 DEBUG_puts("1httpSetDefaultField: Ignored.");
2638 break;
2639 }
2640 }
2641
2642
2643 /*
2644 * 'httpSetExpect()' - Set the Expect: header in a request.
2645 *
2646 * Currently only @code HTTP_STATUS_CONTINUE@ is supported for the "expect"
2647 * argument.
2648 *
2649 * @since CUPS 1.2/OS X 10.5@
2650 */
2651
2652 void
2653 httpSetExpect(http_t *http, /* I - HTTP connection */
2654 http_status_t expect) /* I - HTTP status to expect
2655 (@code HTTP_STATUS_CONTINUE@) */
2656 {
2657 DEBUG_printf(("httpSetExpect(http=%p, expect=%d)", http, expect));
2658
2659 if (http)
2660 http->expect = expect;
2661 }
2662
2663
2664 /*
2665 * 'httpSetField()' - Set the value of an HTTP header.
2666 */
2667
2668 void
2669 httpSetField(http_t *http, /* I - HTTP connection */
2670 http_field_t field, /* I - Field index */
2671 const char *value) /* I - Value */
2672 {
2673 DEBUG_printf(("httpSetField(http=%p, field=%d(%s), value=\"%s\")", http,
2674 field, http_fields[field], value));
2675
2676 if (http == NULL ||
2677 field < HTTP_FIELD_ACCEPT_LANGUAGE ||
2678 field >= HTTP_FIELD_MAX ||
2679 value == NULL)
2680 return;
2681
2682 switch (field)
2683 {
2684 case HTTP_FIELD_ACCEPT_ENCODING :
2685 if (http->accept_encoding)
2686 _cupsStrFree(http->accept_encoding);
2687
2688 http->accept_encoding = _cupsStrAlloc(value);
2689 break;
2690
2691 case HTTP_FIELD_ALLOW :
2692 if (http->allow)
2693 _cupsStrFree(http->allow);
2694
2695 http->allow = _cupsStrAlloc(value);
2696 break;
2697
2698 case HTTP_FIELD_SERVER :
2699 if (http->server)
2700 _cupsStrFree(http->server);
2701
2702 http->server = _cupsStrAlloc(value);
2703 break;
2704
2705 case HTTP_FIELD_WWW_AUTHENTICATE :
2706 /* CUPS STR #4503 - don't override WWW-Authenticate for unknown auth schemes */
2707 if (http->fields[HTTP_FIELD_WWW_AUTHENTICATE][0] &&
2708 _cups_strncasecmp(value, "Basic ", 6) &&
2709 _cups_strncasecmp(value, "Digest ", 7) &&
2710 _cups_strncasecmp(value, "Negotiate ", 10))
2711 {
2712 DEBUG_printf(("1httpSetField: Ignoring unknown auth scheme in \"%s\".", value));
2713 return;
2714 }
2715
2716 /* Fall through to copy */
2717
2718 default :
2719 strlcpy(http->fields[field], value, HTTP_MAX_VALUE);
2720 break;
2721 }
2722
2723 if (field == HTTP_FIELD_AUTHORIZATION)
2724 {
2725 /*
2726 * Special case for Authorization: as its contents can be
2727 * longer than HTTP_MAX_VALUE
2728 */
2729
2730 if (http->field_authorization)
2731 free(http->field_authorization);
2732
2733 http->field_authorization = strdup(value);
2734 }
2735 else if (field == HTTP_FIELD_HOST)
2736 {
2737 /*
2738 * Special-case for Host: as we don't want a trailing "." on the hostname and
2739 * need to bracket IPv6 numeric addresses.
2740 */
2741
2742 char *ptr = strchr(value, ':');
2743
2744 if (value[0] != '[' && ptr && strchr(ptr + 1, ':'))
2745 {
2746 /*
2747 * Bracket IPv6 numeric addresses...
2748 *
2749 * This is slightly inefficient (basically copying twice), but is an edge
2750 * case and not worth optimizing...
2751 */
2752
2753 snprintf(http->fields[HTTP_FIELD_HOST],
2754 sizeof(http->fields[HTTP_FIELD_HOST]), "[%s]", value);
2755 }
2756 else
2757 {
2758 /*
2759 * Check for a trailing dot on the hostname...
2760 */
2761
2762 ptr = http->fields[HTTP_FIELD_HOST];
2763
2764 if (*ptr)
2765 {
2766 ptr += strlen(ptr) - 1;
2767
2768 if (*ptr == '.')
2769 *ptr = '\0';
2770 }
2771 }
2772 }
2773 #ifdef HAVE_LIBZ
2774 else if (field == HTTP_FIELD_CONTENT_ENCODING &&
2775 http->data_encoding != HTTP_ENCODING_FIELDS)
2776 {
2777 DEBUG_puts("1httpSetField: Calling http_content_coding_start.");
2778 http_content_coding_start(http, value);
2779 }
2780 #endif /* HAVE_LIBZ */
2781 }
2782
2783
2784 /*
2785 * 'httpSetKeepAlive()' - Set the current Keep-Alive state of a connection.
2786 *
2787 * @since CUPS 2.0/OS 10.10@
2788 */
2789
2790 void
2791 httpSetKeepAlive(
2792 http_t *http, /* I - HTTP connection */
2793 http_keepalive_t keep_alive) /* I - New Keep-Alive value */
2794 {
2795 if (http)
2796 http->keep_alive = keep_alive;
2797 }
2798
2799
2800 /*
2801 * 'httpSetLength()' - Set the content-length and content-encoding.
2802 *
2803 * @since CUPS 1.2/OS X 10.5@
2804 */
2805
2806 void
2807 httpSetLength(http_t *http, /* I - HTTP connection */
2808 size_t length) /* I - Length (0 for chunked) */
2809 {
2810 DEBUG_printf(("httpSetLength(http=%p, length=" CUPS_LLFMT ")", http,
2811 CUPS_LLCAST length));
2812
2813 if (!http)
2814 return;
2815
2816 if (!length)
2817 {
2818 strlcpy(http->fields[HTTP_FIELD_TRANSFER_ENCODING], "chunked",
2819 HTTP_MAX_VALUE);
2820 http->fields[HTTP_FIELD_CONTENT_LENGTH][0] = '\0';
2821 }
2822 else
2823 {
2824 http->fields[HTTP_FIELD_TRANSFER_ENCODING][0] = '\0';
2825 snprintf(http->fields[HTTP_FIELD_CONTENT_LENGTH], HTTP_MAX_VALUE,
2826 CUPS_LLFMT, CUPS_LLCAST length);
2827 }
2828 }
2829
2830
2831 /*
2832 * 'httpSetTimeout()' - Set read/write timeouts and an optional callback.
2833 *
2834 * The optional timeout callback receives both the HTTP connection and a user
2835 * data pointer and must return 1 to continue or 0 to error (time) out.
2836 *
2837 * @since CUPS 1.5/OS X 10.7@
2838 */
2839
2840 void
2841 httpSetTimeout(
2842 http_t *http, /* I - HTTP connection */
2843 double timeout, /* I - Number of seconds for timeout,
2844 must be greater than 0 */
2845 http_timeout_cb_t cb, /* I - Callback function or NULL */
2846 void *user_data) /* I - User data pointer */
2847 {
2848 if (!http || timeout <= 0.0)
2849 return;
2850
2851 http->timeout_cb = cb;
2852 http->timeout_data = user_data;
2853 http->timeout_value = timeout;
2854
2855 if (http->fd >= 0)
2856 http_set_timeout(http->fd, timeout);
2857
2858 http_set_wait(http);
2859 }
2860
2861
2862 /*
2863 * 'httpShutdown()' - Shutdown one side of an HTTP connection.
2864 *
2865 * @since CUPS 2.0/OS 10.10@
2866 */
2867
2868 void
2869 httpShutdown(http_t *http) /* I - HTTP connection */
2870 {
2871 if (!http || http->fd < 0)
2872 return;
2873
2874 #ifdef HAVE_SSL
2875 if (http->tls)
2876 _httpTLSStop(http);
2877 #endif /* HAVE_SSL */
2878
2879 #ifdef WIN32
2880 shutdown(http->fd, SD_RECEIVE); /* Microsoft-ism... */
2881 #else
2882 shutdown(http->fd, SHUT_RD);
2883 #endif /* WIN32 */
2884 }
2885
2886
2887 /*
2888 * 'httpTrace()' - Send an TRACE request to the server.
2889 */
2890
2891 int /* O - Status of call (0 = success) */
2892 httpTrace(http_t *http, /* I - HTTP connection */
2893 const char *uri) /* I - URI for trace */
2894 {
2895 return (http_send(http, HTTP_STATE_TRACE, uri));
2896 }
2897
2898
2899 /*
2900 * '_httpUpdate()' - Update the current HTTP status for incoming data.
2901 *
2902 * Note: Unlike httpUpdate(), this function does not flush pending write data
2903 * and only retrieves a single status line from the HTTP connection.
2904 */
2905
2906 int /* O - 1 to continue, 0 to stop */
2907 _httpUpdate(http_t *http, /* I - HTTP connection */
2908 http_status_t *status) /* O - Current HTTP status */
2909 {
2910 char line[32768], /* Line from connection... */
2911 *value; /* Pointer to value on line */
2912 http_field_t field; /* Field index */
2913 int major, minor; /* HTTP version numbers */
2914
2915
2916 DEBUG_printf(("_httpUpdate(http=%p, status=%p), state=%s", http, status,
2917 httpStateString(http->state)));
2918
2919 /*
2920 * Grab a single line from the connection...
2921 */
2922
2923 if (!httpGets(line, sizeof(line), http))
2924 {
2925 *status = HTTP_STATUS_ERROR;
2926 return (0);
2927 }
2928
2929 DEBUG_printf(("2_httpUpdate: Got \"%s\"", line));
2930
2931 if (line[0] == '\0')
2932 {
2933 /*
2934 * Blank line means the start of the data section (if any). Return
2935 * the result code, too...
2936 *
2937 * If we get status 100 (HTTP_STATUS_CONTINUE), then we *don't* change
2938 * states. Instead, we just return HTTP_STATUS_CONTINUE to the caller and
2939 * keep on tryin'...
2940 */
2941
2942 if (http->status == HTTP_STATUS_CONTINUE)
2943 {
2944 *status = http->status;
2945 return (0);
2946 }
2947
2948 if (http->status < HTTP_STATUS_BAD_REQUEST)
2949 http->digest_tries = 0;
2950
2951 #ifdef HAVE_SSL
2952 if (http->status == HTTP_STATUS_SWITCHING_PROTOCOLS && !http->tls)
2953 {
2954 if (_httpTLSStart(http) != 0)
2955 {
2956 httpAddrClose(NULL, http->fd);
2957
2958 *status = http->status = HTTP_STATUS_ERROR;
2959 return (0);
2960 }
2961
2962 *status = HTTP_STATUS_CONTINUE;
2963 return (0);
2964 }
2965 #endif /* HAVE_SSL */
2966
2967 if (http_set_length(http) < 0)
2968 {
2969 DEBUG_puts("1_httpUpdate: Bad Content-Length.");
2970 http->error = EINVAL;
2971 http->status = *status = HTTP_STATUS_ERROR;
2972 return (0);
2973 }
2974
2975 switch (http->state)
2976 {
2977 case HTTP_STATE_GET :
2978 case HTTP_STATE_POST :
2979 case HTTP_STATE_POST_RECV :
2980 case HTTP_STATE_PUT :
2981 http->state ++;
2982
2983 DEBUG_printf(("1_httpUpdate: Set state to %s.",
2984 httpStateString(http->state)));
2985
2986 case HTTP_STATE_POST_SEND :
2987 case HTTP_STATE_HEAD :
2988 break;
2989
2990 default :
2991 http->state = HTTP_STATE_WAITING;
2992
2993 DEBUG_puts("1_httpUpdate: Reset state to HTTP_STATE_WAITING.");
2994 break;
2995 }
2996
2997 #ifdef HAVE_LIBZ
2998 DEBUG_puts("1_httpUpdate: Calling http_content_coding_start.");
2999 http_content_coding_start(http,
3000 httpGetField(http, HTTP_FIELD_CONTENT_ENCODING));
3001 #endif /* HAVE_LIBZ */
3002
3003 *status = http->status;
3004 return (0);
3005 }
3006 else if (!strncmp(line, "HTTP/", 5))
3007 {
3008 /*
3009 * Got the beginning of a response...
3010 */
3011
3012 int intstatus; /* Status value as an integer */
3013
3014 if (sscanf(line, "HTTP/%d.%d%d", &major, &minor, &intstatus) != 3)
3015 {
3016 *status = http->status = HTTP_STATUS_ERROR;
3017 return (0);
3018 }
3019
3020 httpClearFields(http);
3021
3022 http->version = (http_version_t)(major * 100 + minor);
3023 *status = http->status = (http_status_t)intstatus;
3024 }
3025 else if ((value = strchr(line, ':')) != NULL)
3026 {
3027 /*
3028 * Got a value...
3029 */
3030
3031 *value++ = '\0';
3032 while (_cups_isspace(*value))
3033 value ++;
3034
3035 DEBUG_printf(("1_httpUpdate: Header %s: %s", line, value));
3036
3037 /*
3038 * Be tolerants of servers that send unknown attribute fields...
3039 */
3040
3041 if (!_cups_strcasecmp(line, "expect"))
3042 {
3043 /*
3044 * "Expect: 100-continue" or similar...
3045 */
3046
3047 http->expect = (http_status_t)atoi(value);
3048 }
3049 else if (!_cups_strcasecmp(line, "cookie"))
3050 {
3051 /*
3052 * "Cookie: name=value[; name=value ...]" - replaces previous cookies...
3053 */
3054
3055 httpSetCookie(http, value);
3056 }
3057 else if ((field = httpFieldValue(line)) != HTTP_FIELD_UNKNOWN)
3058 httpSetField(http, field, value);
3059 #ifdef DEBUG
3060 else
3061 DEBUG_printf(("1_httpUpdate: unknown field %s seen!", line));
3062 #endif /* DEBUG */
3063 }
3064 else
3065 {
3066 DEBUG_printf(("1_httpUpdate: Bad response line \"%s\"!", line));
3067 http->error = EINVAL;
3068 http->status = *status = HTTP_STATUS_ERROR;
3069 return (0);
3070 }
3071
3072 return (1);
3073 }
3074
3075
3076 /*
3077 * 'httpUpdate()' - Update the current HTTP state for incoming data.
3078 */
3079
3080 http_status_t /* O - HTTP status */
3081 httpUpdate(http_t *http) /* I - HTTP connection */
3082 {
3083 http_status_t status; /* Request status */
3084
3085
3086 DEBUG_printf(("httpUpdate(http=%p), state=%s", http,
3087 httpStateString(http->state)));
3088
3089 /*
3090 * Flush pending data, if any...
3091 */
3092
3093 if (http->wused)
3094 {
3095 DEBUG_puts("2httpUpdate: flushing buffer...");
3096
3097 if (httpFlushWrite(http) < 0)
3098 return (HTTP_STATUS_ERROR);
3099 }
3100
3101 /*
3102 * If we haven't issued any commands, then there is nothing to "update"...
3103 */
3104
3105 if (http->state == HTTP_STATE_WAITING)
3106 return (HTTP_STATUS_CONTINUE);
3107
3108 /*
3109 * Grab all of the lines we can from the connection...
3110 */
3111
3112 while (_httpUpdate(http, &status));
3113
3114 /*
3115 * See if there was an error...
3116 */
3117
3118 if (http->error == EPIPE && http->status > HTTP_STATUS_CONTINUE)
3119 {
3120 DEBUG_printf(("1httpUpdate: Returning status %d...", http->status));
3121 return (http->status);
3122 }
3123
3124 if (http->error)
3125 {
3126 DEBUG_printf(("1httpUpdate: socket error %d - %s", http->error,
3127 strerror(http->error)));
3128 http->status = HTTP_STATUS_ERROR;
3129 return (HTTP_STATUS_ERROR);
3130 }
3131
3132 /*
3133 * Return the current status...
3134 */
3135
3136 return (status);
3137 }
3138
3139
3140 /*
3141 * '_httpWait()' - Wait for data available on a connection (no flush).
3142 */
3143
3144 int /* O - 1 if data is available, 0 otherwise */
3145 _httpWait(http_t *http, /* I - HTTP connection */
3146 int msec, /* I - Milliseconds to wait */
3147 int usessl) /* I - Use SSL context? */
3148 {
3149 #ifdef HAVE_POLL
3150 struct pollfd pfd; /* Polled file descriptor */
3151 #else
3152 fd_set input_set; /* select() input set */
3153 struct timeval timeout; /* Timeout */
3154 #endif /* HAVE_POLL */
3155 int nfds; /* Result from select()/poll() */
3156
3157
3158 DEBUG_printf(("4_httpWait(http=%p, msec=%d, usessl=%d)", http, msec, usessl));
3159
3160 if (http->fd < 0)
3161 {
3162 DEBUG_printf(("5_httpWait: Returning 0 since fd=%d", http->fd));
3163 return (0);
3164 }
3165
3166 /*
3167 * Check the SSL/TLS buffers for data first...
3168 */
3169
3170 #ifdef HAVE_SSL
3171 if (http->tls && _httpTLSPending(http))
3172 {
3173 DEBUG_puts("5_httpWait: Return 1 since there is pending TLS data.");
3174 return (1);
3175 }
3176 #endif /* HAVE_SSL */
3177
3178 /*
3179 * Then try doing a select() or poll() to poll the socket...
3180 */
3181
3182 #ifdef HAVE_POLL
3183 pfd.fd = http->fd;
3184 pfd.events = POLLIN;
3185
3186 do
3187 {
3188 nfds = poll(&pfd, 1, msec);
3189 }
3190 while (nfds < 0 && (errno == EINTR || errno == EAGAIN));
3191
3192 #else
3193 do
3194 {
3195 FD_ZERO(&input_set);
3196 FD_SET(http->fd, &input_set);
3197
3198 DEBUG_printf(("6_httpWait: msec=%d, http->fd=%d", msec, http->fd));
3199
3200 if (msec >= 0)
3201 {
3202 timeout.tv_sec = msec / 1000;
3203 timeout.tv_usec = (msec % 1000) * 1000;
3204
3205 nfds = select(http->fd + 1, &input_set, NULL, NULL, &timeout);
3206 }
3207 else
3208 nfds = select(http->fd + 1, &input_set, NULL, NULL, NULL);
3209
3210 DEBUG_printf(("6_httpWait: select() returned %d...", nfds));
3211 }
3212 # ifdef WIN32
3213 while (nfds < 0 && (WSAGetLastError() == WSAEINTR ||
3214 WSAGetLastError() == WSAEWOULDBLOCK));
3215 # else
3216 while (nfds < 0 && (errno == EINTR || errno == EAGAIN));
3217 # endif /* WIN32 */
3218 #endif /* HAVE_POLL */
3219
3220 DEBUG_printf(("5_httpWait: returning with nfds=%d, errno=%d...", nfds,
3221 errno));
3222
3223 return (nfds > 0);
3224 }
3225
3226
3227 /*
3228 * 'httpWait()' - Wait for data available on a connection.
3229 *
3230 * @since CUPS 1.1.19/OS X 10.3@
3231 */
3232
3233 int /* O - 1 if data is available, 0 otherwise */
3234 httpWait(http_t *http, /* I - HTTP connection */
3235 int msec) /* I - Milliseconds to wait */
3236 {
3237 /*
3238 * First see if there is data in the buffer...
3239 */
3240
3241 DEBUG_printf(("2httpWait(http=%p, msec=%d)", http, msec));
3242
3243 if (http == NULL)
3244 return (0);
3245
3246 if (http->used)
3247 {
3248 DEBUG_puts("3httpWait: Returning 1 since there is buffered data ready.");
3249 return (1);
3250 }
3251
3252 #ifdef HAVE_LIBZ
3253 if (http->coding >= _HTTP_CODING_GUNZIP && http->stream.avail_in > 0)
3254 {
3255 DEBUG_puts("3httpWait: Returning 1 since there is buffered data ready.");
3256 return (1);
3257 }
3258 #endif /* HAVE_LIBZ */
3259
3260 /*
3261 * Flush pending data, if any...
3262 */
3263
3264 if (http->wused)
3265 {
3266 DEBUG_puts("3httpWait: Flushing write buffer.");
3267
3268 if (httpFlushWrite(http) < 0)
3269 return (0);
3270 }
3271
3272 /*
3273 * If not, check the SSL/TLS buffers and do a select() on the connection...
3274 */
3275
3276 return (_httpWait(http, msec, 1));
3277 }
3278
3279
3280 /*
3281 * 'httpWrite()' - Write data to a HTTP connection.
3282 *
3283 * This function is deprecated. Use the httpWrite2() function which can
3284 * write more than 2GB of data.
3285 *
3286 * @deprecated@
3287 */
3288
3289 int /* O - Number of bytes written */
3290 httpWrite(http_t *http, /* I - HTTP connection */
3291 const char *buffer, /* I - Buffer for data */
3292 int length) /* I - Number of bytes to write */
3293 {
3294 return ((int)httpWrite2(http, buffer, (size_t)length));
3295 }
3296
3297
3298 /*
3299 * 'httpWrite2()' - Write data to a HTTP connection.
3300 *
3301 * @since CUPS 1.2/OS X 10.5@
3302 */
3303
3304 ssize_t /* O - Number of bytes written */
3305 httpWrite2(http_t *http, /* I - HTTP connection */
3306 const char *buffer, /* I - Buffer for data */
3307 size_t length) /* I - Number of bytes to write */
3308 {
3309 ssize_t bytes; /* Bytes written */
3310
3311
3312 DEBUG_printf(("httpWrite2(http=%p, buffer=%p, length=" CUPS_LLFMT ")", http,
3313 buffer, CUPS_LLCAST length));
3314
3315 /*
3316 * Range check input...
3317 */
3318
3319 if (!http || !buffer)
3320 {
3321 DEBUG_puts("1httpWrite2: Returning -1 due to bad input.");
3322 return (-1);
3323 }
3324
3325 /*
3326 * Mark activity on the connection...
3327 */
3328
3329 http->activity = time(NULL);
3330
3331 /*
3332 * Buffer small writes for better performance...
3333 */
3334
3335 #ifdef HAVE_LIBZ
3336 if (http->coding == _HTTP_CODING_GZIP || http->coding == _HTTP_CODING_DEFLATE)
3337 {
3338 DEBUG_printf(("1httpWrite2: http->coding=%d", http->coding));
3339
3340 if (length == 0)
3341 {
3342 http_content_coding_finish(http);
3343 bytes = 0;
3344 }
3345 else
3346 {
3347 size_t slen; /* Bytes to write */
3348 ssize_t sret; /* Bytes written */
3349
3350 http->stream.next_in = (Bytef *)buffer;
3351 http->stream.avail_in = (uInt)length;
3352
3353 while (deflate(&(http->stream), Z_NO_FLUSH) == Z_OK)
3354 {
3355 DEBUG_printf(("1httpWrite2: avail_out=%d", http->stream.avail_out));
3356
3357 if (http->stream.avail_out > 0)
3358 continue;
3359
3360 slen = _HTTP_MAX_SBUFFER - http->stream.avail_out;
3361
3362 DEBUG_printf(("1httpWrite2: Writing intermediate chunk, len=%d", (int)slen));
3363
3364 if (slen > 0 && http->data_encoding == HTTP_ENCODING_CHUNKED)
3365 sret = http_write_chunk(http, (char *)http->sbuffer, slen);
3366 else if (slen > 0)
3367 sret = http_write(http, (char *)http->sbuffer, slen);
3368 else
3369 sret = 0;
3370
3371 if (sret < 0)
3372 {
3373 DEBUG_puts("1httpWrite2: Unable to write, returning -1.");
3374 return (-1);
3375 }
3376
3377 http->stream.next_out = (Bytef *)http->sbuffer;
3378 http->stream.avail_out = (uInt)_HTTP_MAX_SBUFFER;
3379 }
3380
3381 bytes = (ssize_t)length;
3382 }
3383 }
3384 else
3385 #endif /* HAVE_LIBZ */
3386 if (length > 0)
3387 {
3388 if (http->wused && (length + (size_t)http->wused) > sizeof(http->wbuffer))
3389 {
3390 DEBUG_printf(("2httpWrite2: Flushing buffer (wused=%d, length="
3391 CUPS_LLFMT ")", http->wused, CUPS_LLCAST length));
3392
3393 httpFlushWrite(http);
3394 }
3395
3396 if ((length + (size_t)http->wused) <= sizeof(http->wbuffer) && length < sizeof(http->wbuffer))
3397 {
3398 /*
3399 * Write to buffer...
3400 */
3401
3402 DEBUG_printf(("2httpWrite2: Copying " CUPS_LLFMT " bytes to wbuffer...",
3403 CUPS_LLCAST length));
3404
3405 memcpy(http->wbuffer + http->wused, buffer, length);
3406 http->wused += (int)length;
3407 bytes = (ssize_t)length;
3408 }
3409 else
3410 {
3411 /*
3412 * Otherwise write the data directly...
3413 */
3414
3415 DEBUG_printf(("2httpWrite2: Writing " CUPS_LLFMT " bytes to socket...",
3416 CUPS_LLCAST length));
3417
3418 if (http->data_encoding == HTTP_ENCODING_CHUNKED)
3419 bytes = (ssize_t)http_write_chunk(http, buffer, length);
3420 else
3421 bytes = (ssize_t)http_write(http, buffer, length);
3422
3423 DEBUG_printf(("2httpWrite2: Wrote " CUPS_LLFMT " bytes...",
3424 CUPS_LLCAST bytes));
3425 }
3426
3427 if (http->data_encoding == HTTP_ENCODING_LENGTH)
3428 http->data_remaining -= bytes;
3429 }
3430 else
3431 bytes = 0;
3432
3433 /*
3434 * Handle end-of-request processing...
3435 */
3436
3437 if ((http->data_encoding == HTTP_ENCODING_CHUNKED && length == 0) ||
3438 (http->data_encoding == HTTP_ENCODING_LENGTH && http->data_remaining == 0))
3439 {
3440 /*
3441 * Finished with the transfer; unless we are sending POST or PUT
3442 * data, go idle...
3443 */
3444
3445 #ifdef HAVE_LIBZ
3446 if (http->coding == _HTTP_CODING_GZIP || http->coding == _HTTP_CODING_DEFLATE)
3447 http_content_coding_finish(http);
3448 #endif /* HAVE_LIBZ */
3449
3450 if (http->wused)
3451 {
3452 if (httpFlushWrite(http) < 0)
3453 return (-1);
3454 }
3455
3456 if (http->data_encoding == HTTP_ENCODING_CHUNKED)
3457 {
3458 /*
3459 * Send a 0-length chunk at the end of the request...
3460 */
3461
3462 http_write(http, "0\r\n\r\n", 5);
3463
3464 /*
3465 * Reset the data state...
3466 */
3467
3468 http->data_encoding = HTTP_ENCODING_FIELDS;
3469 http->data_remaining = 0;
3470 }
3471
3472 if (http->state == HTTP_STATE_POST_RECV)
3473 http->state ++;
3474 else if (http->state == HTTP_STATE_POST_SEND ||
3475 http->state == HTTP_STATE_GET_SEND)
3476 http->state = HTTP_STATE_WAITING;
3477 else
3478 http->state = HTTP_STATE_STATUS;
3479
3480 DEBUG_printf(("2httpWrite2: Changed state to %s.",
3481 httpStateString(http->state)));
3482 }
3483
3484 DEBUG_printf(("1httpWrite2: Returning " CUPS_LLFMT ".", CUPS_LLCAST bytes));
3485
3486 return (bytes);
3487 }
3488
3489
3490 /*
3491 * 'httpWriteResponse()' - Write a HTTP response to a client connection.
3492 *
3493 * @since CUPS 1.7/OS X 10.9@
3494 */
3495
3496 int /* O - 0 on success, -1 on error */
3497 httpWriteResponse(http_t *http, /* I - HTTP connection */
3498 http_status_t status) /* I - Status code */
3499 {
3500 http_encoding_t old_encoding; /* Old data_encoding value */
3501 off_t old_remaining; /* Old data_remaining value */
3502
3503
3504 /*
3505 * Range check input...
3506 */
3507
3508 DEBUG_printf(("httpWriteResponse(http=%p, status=%d)", http, status));
3509
3510 if (!http || status < HTTP_STATUS_CONTINUE)
3511 {
3512 DEBUG_puts("1httpWriteResponse: Bad input.");
3513 return (-1);
3514 }
3515
3516 /*
3517 * Set the various standard fields if they aren't already...
3518 */
3519
3520 if (!http->fields[HTTP_FIELD_DATE][0])
3521 httpSetField(http, HTTP_FIELD_DATE, httpGetDateString(time(NULL)));
3522
3523 if (status >= HTTP_STATUS_BAD_REQUEST && http->keep_alive)
3524 {
3525 http->keep_alive = HTTP_KEEPALIVE_OFF;
3526 httpSetField(http, HTTP_FIELD_KEEP_ALIVE, "");
3527 }
3528
3529 if (http->version == HTTP_VERSION_1_1)
3530 {
3531 if (!http->fields[HTTP_FIELD_CONNECTION][0])
3532 {
3533 if (http->keep_alive)
3534 httpSetField(http, HTTP_FIELD_CONNECTION, "Keep-Alive");
3535 else
3536 httpSetField(http, HTTP_FIELD_CONNECTION, "close");
3537 }
3538
3539 if (http->keep_alive && !http->fields[HTTP_FIELD_KEEP_ALIVE][0])
3540 httpSetField(http, HTTP_FIELD_KEEP_ALIVE, "timeout=10");
3541 }
3542
3543 #ifdef HAVE_SSL
3544 if (status == HTTP_STATUS_UPGRADE_REQUIRED ||
3545 status == HTTP_STATUS_SWITCHING_PROTOCOLS)
3546 {
3547 if (!http->fields[HTTP_FIELD_CONNECTION][0])
3548 httpSetField(http, HTTP_FIELD_CONNECTION, "Upgrade");
3549
3550 if (!http->fields[HTTP_FIELD_UPGRADE][0])
3551 httpSetField(http, HTTP_FIELD_UPGRADE, "TLS/1.2,TLS/1.1,TLS/1.0");
3552
3553 if (!http->fields[HTTP_FIELD_CONTENT_LENGTH][0])
3554 httpSetField(http, HTTP_FIELD_CONTENT_LENGTH, "0");
3555 }
3556 #endif /* HAVE_SSL */
3557
3558 if (!http->server)
3559 httpSetField(http, HTTP_FIELD_SERVER,
3560 http->default_server ? http->default_server : CUPS_MINIMAL);
3561
3562 /*
3563 * Set the Accept-Encoding field if it isn't already...
3564 */
3565
3566 if (!http->accept_encoding)
3567 httpSetField(http, HTTP_FIELD_ACCEPT_ENCODING,
3568 http->default_accept_encoding ? http->default_accept_encoding :
3569 #ifdef HAVE_LIBZ
3570 "gzip, deflate, identity");
3571 #else
3572 "identity");
3573 #endif /* HAVE_LIBZ */
3574
3575 /*
3576 * Send the response header...
3577 */
3578
3579 old_encoding = http->data_encoding;
3580 old_remaining = http->data_remaining;
3581 http->data_encoding = HTTP_ENCODING_FIELDS;
3582
3583 if (httpPrintf(http, "HTTP/%d.%d %d %s\r\n", http->version / 100,
3584 http->version % 100, (int)status, httpStatus(status)) < 0)
3585 {
3586 http->status = HTTP_STATUS_ERROR;
3587 return (-1);
3588 }
3589
3590 if (status != HTTP_STATUS_CONTINUE)
3591 {
3592 /*
3593 * 100 Continue doesn't have the rest of the response headers...
3594 */
3595
3596 int i; /* Looping var */
3597 const char *value; /* Field value */
3598
3599 for (i = 0; i < HTTP_FIELD_MAX; i ++)
3600 {
3601 if ((value = httpGetField(http, i)) != NULL && *value)
3602 {
3603 if (httpPrintf(http, "%s: %s\r\n", http_fields[i], value) < 1)
3604 {
3605 http->status = HTTP_STATUS_ERROR;
3606 return (-1);
3607 }
3608 }
3609 }
3610
3611 if (http->cookie)
3612 {
3613 if (strchr(http->cookie, ';'))
3614 {
3615 if (httpPrintf(http, "Set-Cookie: %s\r\n", http->cookie) < 1)
3616 {
3617 http->status = HTTP_STATUS_ERROR;
3618 return (-1);
3619 }
3620 }
3621 else if (httpPrintf(http, "Set-Cookie: %s; path=/; httponly;%s\r\n", http->cookie, http->tls ? " secure;" : "") < 1)
3622 {
3623 http->status = HTTP_STATUS_ERROR;
3624 return (-1);
3625 }
3626 }
3627
3628 /*
3629 * "Click-jacking" defense (STR #4492)...
3630 */
3631
3632 if (httpPrintf(http, "X-Frame-Options: DENY\r\n"
3633 "Content-Security-Policy: frame-ancestors 'none'\r\n") < 1)
3634 {
3635 http->status = HTTP_STATUS_ERROR;
3636 return (-1);
3637 }
3638 }
3639
3640 if (httpWrite2(http, "\r\n", 2) < 2)
3641 {
3642 http->status = HTTP_STATUS_ERROR;
3643 return (-1);
3644 }
3645
3646 if (httpFlushWrite(http) < 0)
3647 {
3648 http->status = HTTP_STATUS_ERROR;
3649 return (-1);
3650 }
3651
3652 if (status == HTTP_STATUS_CONTINUE ||
3653 status == HTTP_STATUS_SWITCHING_PROTOCOLS)
3654 {
3655 /*
3656 * Restore the old data_encoding and data_length values...
3657 */
3658
3659 http->data_encoding = old_encoding;
3660 http->data_remaining = old_remaining;
3661
3662 if (old_remaining <= INT_MAX)
3663 http->_data_remaining = (int)old_remaining;
3664 else
3665 http->_data_remaining = INT_MAX;
3666 }
3667 else if (http->state == HTTP_STATE_OPTIONS ||
3668 http->state == HTTP_STATE_HEAD ||
3669 http->state == HTTP_STATE_PUT ||
3670 http->state == HTTP_STATE_TRACE ||
3671 http->state == HTTP_STATE_CONNECT ||
3672 http->state == HTTP_STATE_STATUS)
3673 {
3674 DEBUG_printf(("1httpWriteResponse: Resetting state to HTTP_STATE_WAITING, "
3675 "was %s.", httpStateString(http->state)));
3676 http->state = HTTP_STATE_WAITING;
3677 }
3678 else
3679 {
3680 /*
3681 * Force data_encoding and data_length to be set according to the response
3682 * headers...
3683 */
3684
3685 http_set_length(http);
3686
3687 if (http->data_encoding == HTTP_ENCODING_LENGTH && http->data_remaining == 0)
3688 {
3689 DEBUG_printf(("1httpWriteResponse: Resetting state to HTTP_STATE_WAITING, "
3690 "was %s.", httpStateString(http->state)));
3691 http->state = HTTP_STATE_WAITING;
3692 return (0);
3693 }
3694
3695 #ifdef HAVE_LIBZ
3696 /*
3697 * Then start any content encoding...
3698 */
3699
3700 DEBUG_puts("1httpWriteResponse: Calling http_content_coding_start.");
3701 http_content_coding_start(http,
3702 httpGetField(http, HTTP_FIELD_CONTENT_ENCODING));
3703 #endif /* HAVE_LIBZ */
3704
3705 }
3706
3707 return (0);
3708 }
3709
3710
3711 #ifdef HAVE_LIBZ
3712 /*
3713 * 'http_content_coding_finish()' - Finish doing any content encoding.
3714 */
3715
3716 static void
3717 http_content_coding_finish(
3718 http_t *http) /* I - HTTP connection */
3719 {
3720 int zerr; /* Compression status */
3721 Byte dummy[1]; /* Dummy read buffer */
3722 size_t bytes; /* Number of bytes to write */
3723
3724
3725 DEBUG_printf(("http_content_coding_finish(http=%p)", http));
3726 DEBUG_printf(("1http_content_coding_finishing: http->coding=%d", http->coding));
3727
3728 switch (http->coding)
3729 {
3730 case _HTTP_CODING_DEFLATE :
3731 case _HTTP_CODING_GZIP :
3732 http->stream.next_in = dummy;
3733 http->stream.avail_in = 0;
3734
3735 do
3736 {
3737 zerr = deflate(&(http->stream), Z_FINISH);
3738 bytes = _HTTP_MAX_SBUFFER - http->stream.avail_out;
3739
3740 if (bytes > 0)
3741 {
3742 DEBUG_printf(("1http_content_coding_finish: Writing trailing chunk, len=%d", (int)bytes));
3743
3744 if (http->data_encoding == HTTP_ENCODING_CHUNKED)
3745 http_write_chunk(http, (char *)http->sbuffer, bytes);
3746 else
3747 http_write(http, (char *)http->sbuffer, bytes);
3748 }
3749
3750 http->stream.next_out = (Bytef *)http->sbuffer;
3751 http->stream.avail_out = (uInt)_HTTP_MAX_SBUFFER;
3752 }
3753 while (zerr == Z_OK);
3754
3755 deflateEnd(&(http->stream));
3756
3757 free(http->sbuffer);
3758 http->sbuffer = NULL;
3759
3760 if (http->wused)
3761 httpFlushWrite(http);
3762 break;
3763
3764 case _HTTP_CODING_INFLATE :
3765 case _HTTP_CODING_GUNZIP :
3766 inflateEnd(&(http->stream));
3767 free(http->sbuffer);
3768 http->sbuffer = NULL;
3769 break;
3770
3771 default :
3772 break;
3773 }
3774
3775 http->coding = _HTTP_CODING_IDENTITY;
3776 }
3777
3778
3779 /*
3780 * 'http_content_coding_start()' - Start doing content encoding.
3781 */
3782
3783 static void
3784 http_content_coding_start(
3785 http_t *http, /* I - HTTP connection */
3786 const char *value) /* I - Value of Content-Encoding */
3787 {
3788 int zerr; /* Error/status */
3789 _http_coding_t coding; /* Content coding value */
3790
3791
3792 DEBUG_printf(("http_content_coding_start(http=%p, value=\"%s\")", http,
3793 value));
3794
3795 if (http->coding != _HTTP_CODING_IDENTITY)
3796 {
3797 DEBUG_printf(("1http_content_coding_start: http->coding already %d.",
3798 http->coding));
3799 return;
3800 }
3801 else if (!strcmp(value, "x-gzip") || !strcmp(value, "gzip"))
3802 {
3803 if (http->state == HTTP_STATE_GET_SEND ||
3804 http->state == HTTP_STATE_POST_SEND)
3805 coding = http->mode == _HTTP_MODE_SERVER ? _HTTP_CODING_GZIP :
3806 _HTTP_CODING_GUNZIP;
3807 else if (http->state == HTTP_STATE_POST_RECV ||
3808 http->state == HTTP_STATE_PUT_RECV)
3809 coding = http->mode == _HTTP_MODE_CLIENT ? _HTTP_CODING_GZIP :
3810 _HTTP_CODING_GUNZIP;
3811 else
3812 {
3813 DEBUG_puts("1http_content_coding_start: Not doing content coding.");
3814 return;
3815 }
3816 }
3817 else if (!strcmp(value, "x-deflate") || !strcmp(value, "deflate"))
3818 {
3819 if (http->state == HTTP_STATE_GET_SEND ||
3820 http->state == HTTP_STATE_POST_SEND)
3821 coding = http->mode == _HTTP_MODE_SERVER ? _HTTP_CODING_DEFLATE :
3822 _HTTP_CODING_INFLATE;
3823 else if (http->state == HTTP_STATE_POST_RECV ||
3824 http->state == HTTP_STATE_PUT_RECV)
3825 coding = http->mode == _HTTP_MODE_CLIENT ? _HTTP_CODING_DEFLATE :
3826 _HTTP_CODING_INFLATE;
3827 else
3828 {
3829 DEBUG_puts("1http_content_coding_start: Not doing content coding.");
3830 return;
3831 }
3832 }
3833 else
3834 {
3835 DEBUG_puts("1http_content_coding_start: Not doing content coding.");
3836 return;
3837 }
3838
3839 memset(&(http->stream), 0, sizeof(http->stream));
3840
3841 switch (coding)
3842 {
3843 case _HTTP_CODING_DEFLATE :
3844 case _HTTP_CODING_GZIP :
3845 if (http->wused)
3846 httpFlushWrite(http);
3847
3848 if ((http->sbuffer = malloc(_HTTP_MAX_SBUFFER)) == NULL)
3849 {
3850 http->status = HTTP_STATUS_ERROR;
3851 http->error = errno;
3852 return;
3853 }
3854
3855 /*
3856 * Window size for compression is 11 bits - optimal based on PWG Raster
3857 * sample files on pwg.org. -11 is raw deflate, 27 is gzip, per ZLIB
3858 * documentation.
3859 */
3860
3861 if ((zerr = deflateInit2(&(http->stream), Z_DEFAULT_COMPRESSION,
3862 Z_DEFLATED,
3863 coding == _HTTP_CODING_DEFLATE ? -11 : 27, 7,
3864 Z_DEFAULT_STRATEGY)) < Z_OK)
3865 {
3866 http->status = HTTP_STATUS_ERROR;
3867 http->error = zerr == Z_MEM_ERROR ? ENOMEM : EINVAL;
3868 return;
3869 }
3870
3871 http->stream.next_out = (Bytef *)http->sbuffer;
3872 http->stream.avail_out = (uInt)_HTTP_MAX_SBUFFER;
3873 break;
3874
3875 case _HTTP_CODING_INFLATE :
3876 case _HTTP_CODING_GUNZIP :
3877 if ((http->sbuffer = malloc(_HTTP_MAX_SBUFFER)) == NULL)
3878 {
3879 http->status = HTTP_STATUS_ERROR;
3880 http->error = errno;
3881 return;
3882 }
3883
3884 /*
3885 * Window size for decompression is up to 15 bits (maximum supported).
3886 * -15 is raw inflate, 31 is gunzip, per ZLIB documentation.
3887 */
3888
3889 if ((zerr = inflateInit2(&(http->stream),
3890 coding == _HTTP_CODING_INFLATE ? -15 : 31))
3891 < Z_OK)
3892 {
3893 free(http->sbuffer);
3894 http->sbuffer = NULL;
3895 http->status = HTTP_STATUS_ERROR;
3896 http->error = zerr == Z_MEM_ERROR ? ENOMEM : EINVAL;
3897 return;
3898 }
3899
3900 http->stream.avail_in = 0;
3901 http->stream.next_in = http->sbuffer;
3902 break;
3903
3904 default :
3905 break;
3906 }
3907
3908 http->coding = coding;
3909
3910 DEBUG_printf(("1http_content_coding_start: http->coding now %d.",
3911 http->coding));
3912 }
3913 #endif /* HAVE_LIBZ */
3914
3915
3916 /*
3917 * 'http_create()' - Create an unconnected HTTP connection.
3918 */
3919
3920 static http_t * /* O - HTTP connection */
3921 http_create(
3922 const char *host, /* I - Hostname */
3923 int port, /* I - Port number */
3924 http_addrlist_t *addrlist, /* I - Address list or NULL */
3925 int family, /* I - Address family or AF_UNSPEC */
3926 http_encryption_t encryption, /* I - Encryption to use */
3927 int blocking, /* I - 1 for blocking mode */
3928 _http_mode_t mode) /* I - _HTTP_MODE_CLIENT or _SERVER */
3929 {
3930 http_t *http; /* New HTTP connection */
3931 char service[255]; /* Service name */
3932 http_addrlist_t *myaddrlist = NULL; /* My address list */
3933
3934
3935 DEBUG_printf(("4http_create(host=\"%s\", port=%d, addrlist=%p, family=%d, "
3936 "encryption=%d, blocking=%d, mode=%d)", host, port, addrlist,
3937 family, encryption, blocking, mode));
3938
3939 if (!host && mode == _HTTP_MODE_CLIENT)
3940 return (NULL);
3941
3942 httpInitialize();
3943
3944 /*
3945 * Lookup the host...
3946 */
3947
3948 if (addrlist)
3949 {
3950 myaddrlist = httpAddrCopyList(addrlist);
3951 }
3952 else
3953 {
3954 snprintf(service, sizeof(service), "%d", port);
3955
3956 myaddrlist = httpAddrGetList(host, family, service);
3957 }
3958
3959 if (!myaddrlist)
3960 return (NULL);
3961
3962 /*
3963 * Allocate memory for the structure...
3964 */
3965
3966 if ((http = calloc(sizeof(http_t), 1)) == NULL)
3967 {
3968 _cupsSetError(IPP_STATUS_ERROR_INTERNAL, strerror(errno), 0);
3969 httpAddrFreeList(addrlist);
3970 return (NULL);
3971 }
3972
3973 /*
3974 * Initialize the HTTP data...
3975 */
3976
3977 http->mode = mode;
3978 http->activity = time(NULL);
3979 http->addrlist = myaddrlist;
3980 http->blocking = blocking;
3981 http->fd = -1;
3982 #ifdef HAVE_GSSAPI
3983 http->gssctx = GSS_C_NO_CONTEXT;
3984 http->gssname = GSS_C_NO_NAME;
3985 #endif /* HAVE_GSSAPI */
3986 http->status = HTTP_STATUS_CONTINUE;
3987 http->version = HTTP_VERSION_1_1;
3988
3989 if (host)
3990 strlcpy(http->hostname, host, sizeof(http->hostname));
3991
3992 if (port == 443) /* Always use encryption for https */
3993 http->encryption = HTTP_ENCRYPTION_ALWAYS;
3994 else
3995 http->encryption = encryption;
3996
3997 http_set_wait(http);
3998
3999 /*
4000 * Return the new structure...
4001 */
4002
4003 return (http);
4004 }
4005
4006
4007 #ifdef DEBUG
4008 /*
4009 * 'http_debug_hex()' - Do a hex dump of a buffer.
4010 */
4011
4012 static void
4013 http_debug_hex(const char *prefix, /* I - Prefix for line */
4014 const char *buffer, /* I - Buffer to dump */
4015 int bytes) /* I - Bytes to dump */
4016 {
4017 int i, j, /* Looping vars */
4018 ch; /* Current character */
4019 char line[255], /* Line buffer */
4020 *start, /* Start of line after prefix */
4021 *ptr; /* Pointer into line */
4022
4023
4024 if (_cups_debug_fd < 0 || _cups_debug_level < 6)
4025 return;
4026
4027 DEBUG_printf(("6%s: %d bytes:", prefix, bytes));
4028
4029 snprintf(line, sizeof(line), "6%s: ", prefix);
4030 start = line + strlen(line);
4031
4032 for (i = 0; i < bytes; i += 16)
4033 {
4034 for (j = 0, ptr = start; j < 16 && (i + j) < bytes; j ++, ptr += 2)
4035 snprintf(ptr, 3, "%02X", buffer[i + j] & 255);
4036
4037 while (j < 16)
4038 {
4039 memcpy(ptr, " ", 3);
4040 ptr += 2;
4041 j ++;
4042 }
4043
4044 memcpy(ptr, " ", 3);
4045 ptr += 2;
4046
4047 for (j = 0; j < 16 && (i + j) < bytes; j ++)
4048 {
4049 ch = buffer[i + j] & 255;
4050
4051 if (ch < ' ' || ch >= 127)
4052 ch = '.';
4053
4054 *ptr++ = (char)ch;
4055 }
4056
4057 *ptr = '\0';
4058 DEBUG_puts(line);
4059 }
4060 }
4061 #endif /* DEBUG */
4062
4063
4064 /*
4065 * 'http_read()' - Read a buffer from a HTTP connection.
4066 *
4067 * This function does the low-level read from the socket, retrying and timing
4068 * out as needed.
4069 */
4070
4071 static ssize_t /* O - Number of bytes read or -1 on error */
4072 http_read(http_t *http, /* I - HTTP connection */
4073 char *buffer, /* I - Buffer */
4074 size_t length) /* I - Maximum bytes to read */
4075 {
4076 ssize_t bytes; /* Bytes read */
4077
4078
4079 DEBUG_printf(("http_read(http=%p, buffer=%p, length=" CUPS_LLFMT ")", http,
4080 buffer, CUPS_LLCAST length));
4081
4082 if (!http->blocking)
4083 {
4084 while (!httpWait(http, http->wait_value))
4085 {
4086 if (http->timeout_cb && (*http->timeout_cb)(http, http->timeout_data))
4087 continue;
4088
4089 DEBUG_puts("2http_read: Timeout.");
4090 return (0);
4091 }
4092 }
4093
4094 DEBUG_printf(("2http_read: Reading %d bytes into buffer.", (int)length));
4095
4096 do
4097 {
4098 #ifdef HAVE_SSL
4099 if (http->tls)
4100 bytes = _httpTLSRead(http, buffer, (int)length);
4101 else
4102 #endif /* HAVE_SSL */
4103 bytes = recv(http->fd, buffer, length, 0);
4104
4105 if (bytes < 0)
4106 {
4107 #ifdef WIN32
4108 if (WSAGetLastError() != WSAEINTR)
4109 {
4110 http->error = WSAGetLastError();
4111 return (-1);
4112 }
4113 else if (WSAGetLastError() == WSAEWOULDBLOCK)
4114 {
4115 if (!http->timeout_cb ||
4116 !(*http->timeout_cb)(http, http->timeout_data))
4117 {
4118 http->error = WSAEWOULDBLOCK;
4119 return (-1);
4120 }
4121 }
4122 #else
4123 DEBUG_printf(("2http_read: %s", strerror(errno)));
4124
4125 if (errno == EWOULDBLOCK || errno == EAGAIN)
4126 {
4127 if (http->timeout_cb && !(*http->timeout_cb)(http, http->timeout_data))
4128 {
4129 http->error = errno;
4130 return (-1);
4131 }
4132 else if (!http->timeout_cb && errno != EAGAIN)
4133 {
4134 http->error = errno;
4135 return (-1);
4136 }
4137 }
4138 else if (errno != EINTR)
4139 {
4140 http->error = errno;
4141 return (-1);
4142 }
4143 #endif /* WIN32 */
4144 }
4145 }
4146 while (bytes < 0);
4147
4148 DEBUG_printf(("2http_read: Read " CUPS_LLFMT " bytes into buffer.",
4149 CUPS_LLCAST bytes));
4150 #ifdef DEBUG
4151 if (bytes > 0)
4152 http_debug_hex("http_read", buffer, (int)bytes);
4153 #endif /* DEBUG */
4154
4155 if (bytes < 0)
4156 {
4157 #ifdef WIN32
4158 if (WSAGetLastError() == WSAEINTR)
4159 bytes = 0;
4160 else
4161 http->error = WSAGetLastError();
4162 #else
4163 if (errno == EINTR || (errno == EAGAIN && !http->timeout_cb))
4164 bytes = 0;
4165 else
4166 http->error = errno;
4167 #endif /* WIN32 */
4168 }
4169 else if (bytes == 0)
4170 {
4171 http->error = EPIPE;
4172 return (0);
4173 }
4174
4175 return (bytes);
4176 }
4177
4178
4179 /*
4180 * 'http_read_buffered()' - Do a buffered read from a HTTP connection.
4181 *
4182 * This function reads data from the HTTP buffer or from the socket, as needed.
4183 */
4184
4185 static ssize_t /* O - Number of bytes read or -1 on error */
4186 http_read_buffered(http_t *http, /* I - HTTP connection */
4187 char *buffer, /* I - Buffer */
4188 size_t length) /* I - Maximum bytes to read */
4189 {
4190 ssize_t bytes; /* Bytes read */
4191
4192
4193 DEBUG_printf(("http_read_buffered(http=%p, buffer=%p, length=" CUPS_LLFMT
4194 ") used=%d",
4195 http, buffer, CUPS_LLCAST length, http->used));
4196
4197 if (http->used > 0)
4198 {
4199 if (length > (size_t)http->used)
4200 bytes = (ssize_t)http->used;
4201 else
4202 bytes = (ssize_t)length;
4203
4204 DEBUG_printf(("2http_read: Grabbing %d bytes from input buffer.",
4205 (int)bytes));
4206
4207 memcpy(buffer, http->buffer, (size_t)bytes);
4208 http->used -= (int)bytes;
4209
4210 if (http->used > 0)
4211 memmove(http->buffer, http->buffer + bytes, (size_t)http->used);
4212 }
4213 else
4214 bytes = http_read(http, buffer, length);
4215
4216 return (bytes);
4217 }
4218
4219
4220 /*
4221 * 'http_read_chunk()' - Read a chunk from a HTTP connection.
4222 *
4223 * This function reads and validates the chunk length, then does a buffered read
4224 * returning the number of bytes placed in the buffer.
4225 */
4226
4227 static ssize_t /* O - Number of bytes read or -1 on error */
4228 http_read_chunk(http_t *http, /* I - HTTP connection */
4229 char *buffer, /* I - Buffer */
4230 size_t length) /* I - Maximum bytes to read */
4231 {
4232 DEBUG_printf(("http_read_chunk(http=%p, buffer=%p, length=" CUPS_LLFMT ")",
4233 http, buffer, CUPS_LLCAST length));
4234
4235 if (http->data_remaining <= 0)
4236 {
4237 char len[32]; /* Length string */
4238
4239 if (!httpGets(len, sizeof(len), http))
4240 {
4241 DEBUG_puts("1http_read_chunk: Could not get chunk length.");
4242 return (0);
4243 }
4244
4245 if (!len[0])
4246 {
4247 DEBUG_puts("1http_read_chunk: Blank chunk length, trying again...");
4248 if (!httpGets(len, sizeof(len), http))
4249 {
4250 DEBUG_puts("1http_read_chunk: Could not get chunk length.");
4251 return (0);
4252 }
4253 }
4254
4255 http->data_remaining = strtoll(len, NULL, 16);
4256
4257 if (http->data_remaining < 0)
4258 {
4259 DEBUG_printf(("1http_read_chunk: Negative chunk length \"%s\" ("
4260 CUPS_LLFMT ")", len, CUPS_LLCAST http->data_remaining));
4261 return (0);
4262 }
4263
4264 DEBUG_printf(("2http_read_chunk: Got chunk length \"%s\" (" CUPS_LLFMT ")",
4265 len, CUPS_LLCAST http->data_remaining));
4266
4267 if (http->data_remaining == 0)
4268 {
4269 /*
4270 * 0-length chunk, grab trailing blank line...
4271 */
4272
4273 httpGets(len, sizeof(len), http);
4274 }
4275 }
4276
4277 DEBUG_printf(("2http_read_chunk: data_remaining=" CUPS_LLFMT,
4278 CUPS_LLCAST http->data_remaining));
4279
4280 if (http->data_remaining <= 0)
4281 return (0);
4282 else if (length > (size_t)http->data_remaining)
4283 length = (size_t)http->data_remaining;
4284
4285 return (http_read_buffered(http, buffer, length));
4286 }
4287
4288
4289 /*
4290 * 'http_send()' - Send a request with all fields and the trailing blank line.
4291 */
4292
4293 static int /* O - 0 on success, non-zero on error */
4294 http_send(http_t *http, /* I - HTTP connection */
4295 http_state_t request, /* I - Request code */
4296 const char *uri) /* I - URI */
4297 {
4298 int i; /* Looping var */
4299 char buf[1024]; /* Encoded URI buffer */
4300 const char *value; /* Field value */
4301 static const char * const codes[] = /* Request code strings */
4302 {
4303 NULL,
4304 "OPTIONS",
4305 "GET",
4306 NULL,
4307 "HEAD",
4308 "POST",
4309 NULL,
4310 NULL,
4311 "PUT",
4312 NULL,
4313 "DELETE",
4314 "TRACE",
4315 "CLOSE",
4316 NULL,
4317 NULL
4318 };
4319
4320
4321 DEBUG_printf(("4http_send(http=%p, request=HTTP_%s, uri=\"%s\")",
4322 http, codes[request], uri));
4323
4324 if (http == NULL || uri == NULL)
4325 return (-1);
4326
4327 /*
4328 * Set the User-Agent field if it isn't already...
4329 */
4330
4331 if (!http->fields[HTTP_FIELD_USER_AGENT][0])
4332 {
4333 if (http->default_user_agent)
4334 httpSetField(http, HTTP_FIELD_USER_AGENT, http->default_user_agent);
4335 else
4336 httpSetField(http, HTTP_FIELD_USER_AGENT, cupsUserAgent());
4337 }
4338
4339 /*
4340 * Set the Accept-Encoding field if it isn't already...
4341 */
4342
4343 if (!http->accept_encoding && http->default_accept_encoding)
4344 httpSetField(http, HTTP_FIELD_ACCEPT_ENCODING,
4345 http->default_accept_encoding);
4346
4347 /*
4348 * Encode the URI as needed...
4349 */
4350
4351 _httpEncodeURI(buf, uri, sizeof(buf));
4352
4353 /*
4354 * See if we had an error the last time around; if so, reconnect...
4355 */
4356
4357 if (http->fd < 0 || http->status == HTTP_STATUS_ERROR ||
4358 http->status >= HTTP_STATUS_BAD_REQUEST)
4359 {
4360 DEBUG_printf(("5http_send: Reconnecting, fd=%d, status=%d, tls_upgrade=%d",
4361 http->fd, http->status, http->tls_upgrade));
4362
4363 if (httpReconnect2(http, 30000, NULL))
4364 return (-1);
4365 }
4366
4367 /*
4368 * Flush any written data that is pending...
4369 */
4370
4371 if (http->wused)
4372 {
4373 if (httpFlushWrite(http) < 0)
4374 if (httpReconnect2(http, 30000, NULL))
4375 return (-1);
4376 }
4377
4378 /*
4379 * Send the request header...
4380 */
4381
4382 http->state = request;
4383 http->data_encoding = HTTP_ENCODING_FIELDS;
4384
4385 if (request == HTTP_STATE_POST || request == HTTP_STATE_PUT)
4386 http->state ++;
4387
4388 http->status = HTTP_STATUS_CONTINUE;
4389
4390 #ifdef HAVE_SSL
4391 if (http->encryption == HTTP_ENCRYPTION_REQUIRED && !http->tls)
4392 {
4393 httpSetField(http, HTTP_FIELD_CONNECTION, "Upgrade");
4394 httpSetField(http, HTTP_FIELD_UPGRADE, "TLS/1.2,TLS/1.1,TLS/1.0");
4395 }
4396 #endif /* HAVE_SSL */
4397
4398 if (httpPrintf(http, "%s %s HTTP/1.1\r\n", codes[request], buf) < 1)
4399 {
4400 http->status = HTTP_STATUS_ERROR;
4401 return (-1);
4402 }
4403
4404 for (i = 0; i < HTTP_FIELD_MAX; i ++)
4405 if ((value = httpGetField(http, i)) != NULL && *value)
4406 {
4407 DEBUG_printf(("5http_send: %s: %s", http_fields[i], value));
4408
4409 if (i == HTTP_FIELD_HOST)
4410 {
4411 if (httpPrintf(http, "Host: %s:%d\r\n", value,
4412 httpAddrPort(http->hostaddr)) < 1)
4413 {
4414 http->status = HTTP_STATUS_ERROR;
4415 return (-1);
4416 }
4417 }
4418 else if (httpPrintf(http, "%s: %s\r\n", http_fields[i], value) < 1)
4419 {
4420 http->status = HTTP_STATUS_ERROR;
4421 return (-1);
4422 }
4423 }
4424
4425 if (http->cookie)
4426 if (httpPrintf(http, "Cookie: $Version=0; %s\r\n", http->cookie) < 1)
4427 {
4428 http->status = HTTP_STATUS_ERROR;
4429 return (-1);
4430 }
4431
4432 DEBUG_printf(("5http_send: expect=%d, mode=%d, state=%d", http->expect,
4433 http->mode, http->state));
4434
4435 if (http->expect == HTTP_STATUS_CONTINUE && http->mode == _HTTP_MODE_CLIENT &&
4436 (http->state == HTTP_STATE_POST_RECV ||
4437 http->state == HTTP_STATE_PUT_RECV))
4438 if (httpPrintf(http, "Expect: 100-continue\r\n") < 1)
4439 {
4440 http->status = HTTP_STATUS_ERROR;
4441 return (-1);
4442 }
4443
4444 if (httpPrintf(http, "\r\n") < 1)
4445 {
4446 http->status = HTTP_STATUS_ERROR;
4447 return (-1);
4448 }
4449
4450 if (httpFlushWrite(http) < 0)
4451 return (-1);
4452
4453 http_set_length(http);
4454 httpClearFields(http);
4455
4456 /*
4457 * The Kerberos and AuthRef authentication strings can only be used once...
4458 */
4459
4460 if (http->field_authorization && http->authstring &&
4461 (!strncmp(http->authstring, "Negotiate", 9) ||
4462 !strncmp(http->authstring, "AuthRef", 7)))
4463 {
4464 http->_authstring[0] = '\0';
4465
4466 if (http->authstring != http->_authstring)
4467 free(http->authstring);
4468
4469 http->authstring = http->_authstring;
4470 }
4471
4472 return (0);
4473 }
4474
4475
4476 /*
4477 * 'http_set_length()' - Set the data_encoding and data_remaining values.
4478 */
4479
4480 static off_t /* O - Remainder or -1 on error */
4481 http_set_length(http_t *http) /* I - Connection */
4482 {
4483 off_t remaining; /* Remainder */
4484
4485
4486 DEBUG_printf(("http_set_length(http=%p) mode=%d state=%s", http, http->mode,
4487 httpStateString(http->state)));
4488
4489 if ((remaining = httpGetLength2(http)) >= 0)
4490 {
4491 if (http->mode == _HTTP_MODE_SERVER &&
4492 http->state != HTTP_STATE_GET_SEND &&
4493 http->state != HTTP_STATE_PUT &&
4494 http->state != HTTP_STATE_POST &&
4495 http->state != HTTP_STATE_POST_SEND)
4496 {
4497 DEBUG_puts("1http_set_length: Not setting data_encoding/remaining.");
4498 return (remaining);
4499 }
4500
4501 if (!_cups_strcasecmp(http->fields[HTTP_FIELD_TRANSFER_ENCODING],
4502 "chunked"))
4503 {
4504 DEBUG_puts("1http_set_length: Setting data_encoding to "
4505 "HTTP_ENCODING_CHUNKED.");
4506 http->data_encoding = HTTP_ENCODING_CHUNKED;
4507 }
4508 else
4509 {
4510 DEBUG_puts("1http_set_length: Setting data_encoding to "
4511 "HTTP_ENCODING_LENGTH.");
4512 http->data_encoding = HTTP_ENCODING_LENGTH;
4513 }
4514
4515 DEBUG_printf(("1http_set_length: Setting data_remaining to " CUPS_LLFMT ".",
4516 CUPS_LLCAST remaining));
4517 http->data_remaining = remaining;
4518
4519 if (remaining <= INT_MAX)
4520 http->_data_remaining = (int)remaining;
4521 else
4522 http->_data_remaining = INT_MAX;
4523 }
4524
4525 return (remaining);
4526 }
4527
4528 /*
4529 * 'http_set_timeout()' - Set the socket timeout values.
4530 */
4531
4532 static void
4533 http_set_timeout(int fd, /* I - File descriptor */
4534 double timeout) /* I - Timeout in seconds */
4535 {
4536 #ifdef WIN32
4537 DWORD tv = (DWORD)(timeout * 1000);
4538 /* Timeout in milliseconds */
4539
4540 setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, CUPS_SOCAST &tv, sizeof(tv));
4541 setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, CUPS_SOCAST &tv, sizeof(tv));
4542
4543 #else
4544 struct timeval tv; /* Timeout in secs and usecs */
4545
4546 tv.tv_sec = (int)timeout;
4547 tv.tv_usec = (int)(1000000 * fmod(timeout, 1.0));
4548
4549 setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, CUPS_SOCAST &tv, sizeof(tv));
4550 setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, CUPS_SOCAST &tv, sizeof(tv));
4551 #endif /* WIN32 */
4552 }
4553
4554
4555 /*
4556 * 'http_set_wait()' - Set the default wait value for reads.
4557 */
4558
4559 static void
4560 http_set_wait(http_t *http) /* I - HTTP connection */
4561 {
4562 if (http->blocking)
4563 {
4564 http->wait_value = (int)(http->timeout_value * 1000);
4565
4566 if (http->wait_value <= 0)
4567 http->wait_value = 60000;
4568 }
4569 else
4570 http->wait_value = 10000;
4571 }
4572
4573
4574 #ifdef HAVE_SSL
4575 /*
4576 * 'http_tls_upgrade()' - Force upgrade to TLS encryption.
4577 */
4578
4579 static int /* O - Status of connection */
4580 http_tls_upgrade(http_t *http) /* I - HTTP connection */
4581 {
4582 int ret; /* Return value */
4583 http_t myhttp; /* Local copy of HTTP data */
4584
4585
4586 DEBUG_printf(("7http_tls_upgrade(%p)", http));
4587
4588 /*
4589 * Flush the connection to make sure any previous "Upgrade" message
4590 * has been read.
4591 */
4592
4593 httpFlush(http);
4594
4595 /*
4596 * Copy the HTTP data to a local variable so we can do the OPTIONS
4597 * request without interfering with the existing request data...
4598 */
4599
4600 memcpy(&myhttp, http, sizeof(myhttp));
4601
4602 /*
4603 * Send an OPTIONS request to the server, requiring SSL or TLS
4604 * encryption on the link...
4605 */
4606
4607 http->tls_upgrade = 1;
4608 http->field_authorization = NULL; /* Don't free the auth string */
4609
4610 httpClearFields(http);
4611 httpSetField(http, HTTP_FIELD_CONNECTION, "upgrade");
4612 httpSetField(http, HTTP_FIELD_UPGRADE, "TLS/1.2,TLS/1.1,TLS/1.0");
4613
4614 if ((ret = httpOptions(http, "*")) == 0)
4615 {
4616 /*
4617 * Wait for the secure connection...
4618 */
4619
4620 while (httpUpdate(http) == HTTP_STATUS_CONTINUE);
4621 }
4622
4623 /*
4624 * Restore the HTTP request data...
4625 */
4626
4627 memcpy(http->fields, myhttp.fields, sizeof(http->fields));
4628 http->data_encoding = myhttp.data_encoding;
4629 http->data_remaining = myhttp.data_remaining;
4630 http->_data_remaining = myhttp._data_remaining;
4631 http->expect = myhttp.expect;
4632 http->field_authorization = myhttp.field_authorization;
4633 http->digest_tries = myhttp.digest_tries;
4634 http->tls_upgrade = 0;
4635
4636 /*
4637 * See if we actually went secure...
4638 */
4639
4640 if (!http->tls)
4641 {
4642 /*
4643 * Server does not support HTTP upgrade...
4644 */
4645
4646 DEBUG_puts("8http_tls_upgrade: Server does not support HTTP upgrade!");
4647
4648 _cupsSetError(IPP_STATUS_ERROR_CUPS_PKI, _("Encryption is not supported."), 1);
4649 httpAddrClose(NULL, http->fd);
4650
4651 http->fd = -1;
4652
4653 return (-1);
4654 }
4655 else
4656 return (ret);
4657 }
4658 #endif /* HAVE_SSL */
4659
4660
4661 /*
4662 * 'http_write()' - Write a buffer to a HTTP connection.
4663 */
4664
4665 static ssize_t /* O - Number of bytes written */
4666 http_write(http_t *http, /* I - HTTP connection */
4667 const char *buffer, /* I - Buffer for data */
4668 size_t length) /* I - Number of bytes to write */
4669 {
4670 ssize_t tbytes, /* Total bytes sent */
4671 bytes; /* Bytes sent */
4672
4673
4674 DEBUG_printf(("2http_write(http=%p, buffer=%p, length=" CUPS_LLFMT ")", http,
4675 buffer, CUPS_LLCAST length));
4676 http->error = 0;
4677 tbytes = 0;
4678
4679 while (length > 0)
4680 {
4681 DEBUG_printf(("3http_write: About to write %d bytes.", (int)length));
4682
4683 if (http->timeout_cb)
4684 {
4685 #ifdef HAVE_POLL
4686 struct pollfd pfd; /* Polled file descriptor */
4687 #else
4688 fd_set output_set; /* Output ready for write? */
4689 struct timeval timeout; /* Timeout value */
4690 #endif /* HAVE_POLL */
4691 int nfds; /* Result from select()/poll() */
4692
4693 do
4694 {
4695 #ifdef HAVE_POLL
4696 pfd.fd = http->fd;
4697 pfd.events = POLLOUT;
4698
4699 while ((nfds = poll(&pfd, 1, http->wait_value)) < 0 &&
4700 (errno == EINTR || errno == EAGAIN))
4701 /* do nothing */;
4702
4703 #else
4704 do
4705 {
4706 FD_ZERO(&output_set);
4707 FD_SET(http->fd, &output_set);
4708
4709 timeout.tv_sec = http->wait_value / 1000;
4710 timeout.tv_usec = 1000 * (http->wait_value % 1000);
4711
4712 nfds = select(http->fd + 1, NULL, &output_set, NULL, &timeout);
4713 }
4714 # ifdef WIN32
4715 while (nfds < 0 && (WSAGetLastError() == WSAEINTR ||
4716 WSAGetLastError() == WSAEWOULDBLOCK));
4717 # else
4718 while (nfds < 0 && (errno == EINTR || errno == EAGAIN));
4719 # endif /* WIN32 */
4720 #endif /* HAVE_POLL */
4721
4722 if (nfds < 0)
4723 {
4724 http->error = errno;
4725 return (-1);
4726 }
4727 else if (nfds == 0 && !(*http->timeout_cb)(http, http->timeout_data))
4728 {
4729 #ifdef WIN32
4730 http->error = WSAEWOULDBLOCK;
4731 #else
4732 http->error = EWOULDBLOCK;
4733 #endif /* WIN32 */
4734 return (-1);
4735 }
4736 }
4737 while (nfds <= 0);
4738 }
4739
4740 #ifdef HAVE_SSL
4741 if (http->tls)
4742 bytes = _httpTLSWrite(http, buffer, (int)length);
4743 else
4744 #endif /* HAVE_SSL */
4745 bytes = send(http->fd, buffer, length, 0);
4746
4747 DEBUG_printf(("3http_write: Write of " CUPS_LLFMT " bytes returned "
4748 CUPS_LLFMT ".", CUPS_LLCAST length, CUPS_LLCAST bytes));
4749
4750 if (bytes < 0)
4751 {
4752 #ifdef WIN32
4753 if (WSAGetLastError() == WSAEINTR)
4754 continue;
4755 else if (WSAGetLastError() == WSAEWOULDBLOCK)
4756 {
4757 if (http->timeout_cb && (*http->timeout_cb)(http, http->timeout_data))
4758 continue;
4759
4760 http->error = WSAGetLastError();
4761 }
4762 else if (WSAGetLastError() != http->error &&
4763 WSAGetLastError() != WSAECONNRESET)
4764 {
4765 http->error = WSAGetLastError();
4766 continue;
4767 }
4768
4769 #else
4770 if (errno == EINTR)
4771 continue;
4772 else if (errno == EWOULDBLOCK || errno == EAGAIN)
4773 {
4774 if (http->timeout_cb && (*http->timeout_cb)(http, http->timeout_data))
4775 continue;
4776 else if (!http->timeout_cb && errno == EAGAIN)
4777 continue;
4778
4779 http->error = errno;
4780 }
4781 else if (errno != http->error && errno != ECONNRESET)
4782 {
4783 http->error = errno;
4784 continue;
4785 }
4786 #endif /* WIN32 */
4787
4788 DEBUG_printf(("3http_write: error writing data (%s).",
4789 strerror(http->error)));
4790
4791 return (-1);
4792 }
4793
4794 buffer += bytes;
4795 tbytes += bytes;
4796 length -= (size_t)bytes;
4797 }
4798
4799 #ifdef DEBUG
4800 http_debug_hex("http_write", buffer - tbytes, (int)tbytes);
4801 #endif /* DEBUG */
4802
4803 DEBUG_printf(("3http_write: Returning " CUPS_LLFMT ".", CUPS_LLCAST tbytes));
4804
4805 return (tbytes);
4806 }
4807
4808
4809 /*
4810 * 'http_write_chunk()' - Write a chunked buffer.
4811 */
4812
4813 static ssize_t /* O - Number bytes written */
4814 http_write_chunk(http_t *http, /* I - HTTP connection */
4815 const char *buffer, /* I - Buffer to write */
4816 size_t length) /* I - Length of buffer */
4817 {
4818 char header[16]; /* Chunk header */
4819 ssize_t bytes; /* Bytes written */
4820
4821
4822 DEBUG_printf(("7http_write_chunk(http=%p, buffer=%p, length=" CUPS_LLFMT ")",
4823 http, buffer, CUPS_LLCAST length));
4824
4825 /*
4826 * Write the chunk header, data, and trailer.
4827 */
4828
4829 snprintf(header, sizeof(header), "%x\r\n", (unsigned)length);
4830 if (http_write(http, header, strlen(header)) < 0)
4831 {
4832 DEBUG_puts("8http_write_chunk: http_write of length failed.");
4833 return (-1);
4834 }
4835
4836 if ((bytes = http_write(http, buffer, length)) < 0)
4837 {
4838 DEBUG_puts("8http_write_chunk: http_write of buffer failed.");
4839 return (-1);
4840 }
4841
4842 if (http_write(http, "\r\n", 2) < 0)
4843 {
4844 DEBUG_puts("8http_write_chunk: http_write of CR LF failed.");
4845 return (-1);
4846 }
4847
4848 return (bytes);
4849 }
4850
4851
4852 /*
4853 * End of "$Id$".
4854 */
Unnamed repository; edit this file 'description' to name the repository.