1 /* 2 * IPP utilities for CUPS. 3 * 4 * Copyright 2007-2017 by Apple Inc. 5 * Copyright 1997-2007 by Easy Software Products. 6 * 7 * These coded instructions, statements, and computer programs are the 8 * property of Apple Inc. and are protected by Federal copyright 9 * law. Distribution and use rights are outlined in the file "LICENSE.txt" 10 * which should have been included with this file. If this file is 11 * missing or damaged, see the license at "http://www.cups.org/". 12 * 13 * This file is subject to the Apple OS-Developed Software exception. 14 */ 15 16 /* 17 * Include necessary headers... 18 */ 19 20 #include "cups-private.h" 21 #include <fcntl.h> 22 #include <sys/stat.h> 23 #if defined(WIN32) || defined(__EMX__) 24 # include <io.h> 25 #else 26 # include <unistd.h> 27 #endif /* WIN32 || __EMX__ */ 28 #ifndef O_BINARY 29 # define O_BINARY 0 30 #endif /* O_BINARY */ 31 #ifndef MSG_DONTWAIT 32 # define MSG_DONTWAIT 0 33 #endif /* !MSG_DONTWAIT */ 34 35 36 /* 37 * 'cupsDoFileRequest()' - Do an IPP request with a file. 38 * 39 * This function sends the IPP request and attached file to the specified 40 * server, retrying and authenticating as necessary. The request is freed with 41 * @link ippDelete@. 42 */ 43 44 ipp_t * /* O - Response data */ 45 cupsDoFileRequest(http_t *http, /* I - Connection to server or @code CUPS_HTTP_DEFAULT@ */ 46 ipp_t *request, /* I - IPP request */ 47 const char *resource, /* I - HTTP resource for POST */ 48 const char *filename) /* I - File to send or @code NULL@ for none */ 49 { 50 ipp_t *response; /* IPP response data */ 51 int infile; /* Input file */ 52 53 54 DEBUG_printf(("cupsDoFileRequest(http=%p, request=%p(%s), resource=\"%s\", filename=\"%s\")", (void *)http, (void *)request, request ? ippOpString(request->request.op.operation_id) : "?", resource, filename)); 55 56 if (filename) 57 { 58 if ((infile = open(filename, O_RDONLY | O_BINARY)) < 0) 59 { 60 /* 61 * Can't get file information! 62 */ 63 64 _cupsSetError(errno == ENOENT ? IPP_STATUS_ERROR_NOT_FOUND : IPP_STATUS_ERROR_NOT_AUTHORIZED, 65 NULL, 0); 66 67 ippDelete(request); 68 69 return (NULL); 70 } 71 } 72 else 73 infile = -1; 74 75 response = cupsDoIORequest(http, request, resource, infile, -1); 76 77 if (infile >= 0) 78 close(infile); 79 80 return (response); 81 } 82 83 84 /* 85 * 'cupsDoIORequest()' - Do an IPP request with file descriptors. 86 * 87 * This function sends the IPP request with the optional input file "infile" to 88 * the specified server, retrying and authenticating as necessary. The request 89 * is freed with @link ippDelete@. 90 * 91 * If "infile" is a valid file descriptor, @code cupsDoIORequest@ copies 92 * all of the data from the file after the IPP request message. 93 * 94 * If "outfile" is a valid file descriptor, @code cupsDoIORequest@ copies 95 * all of the data after the IPP response message to the file. 96 * 97 * @since CUPS 1.3/macOS 10.5@ 98 */ 99 100 ipp_t * /* O - Response data */ 101 cupsDoIORequest(http_t *http, /* I - Connection to server or @code CUPS_HTTP_DEFAULT@ */ 102 ipp_t *request, /* I - IPP request */ 103 const char *resource, /* I - HTTP resource for POST */ 104 int infile, /* I - File to read from or -1 for none */ 105 int outfile) /* I - File to write to or -1 for none */ 106 { 107 ipp_t *response = NULL; /* IPP response data */ 108 size_t length = 0; /* Content-Length value */ 109 http_status_t status; /* Status of HTTP request */ 110 struct stat fileinfo; /* File information */ 111 ssize_t bytes; /* Number of bytes read/written */ 112 char buffer[32768]; /* Output buffer */ 113 114 115 DEBUG_printf(("cupsDoIORequest(http=%p, request=%p(%s), resource=\"%s\", infile=%d, outfile=%d)", (void *)http, (void *)request, request ? ippOpString(request->request.op.operation_id) : "?", resource, infile, outfile)); 116 117 /* 118 * Range check input... 119 */ 120 121 if (!request || !resource) 122 { 123 ippDelete(request); 124 125 _cupsSetError(IPP_STATUS_ERROR_INTERNAL, strerror(EINVAL), 0); 126 127 return (NULL); 128 } 129 130 /* 131 * Get the default connection as needed... 132 */ 133 134 if (!http && (http = _cupsConnect()) == NULL) 135 { 136 ippDelete(request); 137 138 return (NULL); 139 } 140 141 /* 142 * See if we have a file to send... 143 */ 144 145 if (infile >= 0) 146 { 147 if (fstat(infile, &fileinfo)) 148 { 149 /* 150 * Can't get file information! 151 */ 152 153 _cupsSetError(errno == EBADF ? IPP_STATUS_ERROR_NOT_FOUND : IPP_STATUS_ERROR_NOT_AUTHORIZED, NULL, 0); 154 ippDelete(request); 155 156 return (NULL); 157 } 158 159 #ifdef WIN32 160 if (fileinfo.st_mode & _S_IFDIR) 161 #else 162 if (S_ISDIR(fileinfo.st_mode)) 163 #endif /* WIN32 */ 164 { 165 /* 166 * Can't send a directory... 167 */ 168 169 _cupsSetError(IPP_STATUS_ERROR_NOT_POSSIBLE, strerror(EISDIR), 0); 170 ippDelete(request); 171 172 return (NULL); 173 } 174 175 #ifndef WIN32 176 if (!S_ISREG(fileinfo.st_mode)) 177 length = 0; /* Chunk when piping */ 178 else 179 #endif /* !WIN32 */ 180 length = ippLength(request) + (size_t)fileinfo.st_size; 181 } 182 else 183 length = ippLength(request); 184 185 DEBUG_printf(("2cupsDoIORequest: Request length=%ld, total length=%ld", (long)ippLength(request), (long)length)); 186 187 /* 188 * Clear any "Local" authentication data since it is probably stale... 189 */ 190 191 if (http->authstring && !strncmp(http->authstring, "Local ", 6)) 192 httpSetAuthString(http, NULL, NULL); 193 194 /* 195 * Loop until we can send the request without authorization problems. 196 */ 197 198 while (response == NULL) 199 { 200 DEBUG_puts("2cupsDoIORequest: setup..."); 201 202 /* 203 * Send the request... 204 */ 205 206 status = cupsSendRequest(http, request, resource, length); 207 208 DEBUG_printf(("2cupsDoIORequest: status=%d", status)); 209 210 if (status == HTTP_STATUS_CONTINUE && request->state == IPP_STATE_DATA && infile >= 0) 211 { 212 DEBUG_puts("2cupsDoIORequest: file write..."); 213 214 /* 215 * Send the file with the request... 216 */ 217 218 #ifndef WIN32 219 if (S_ISREG(fileinfo.st_mode)) 220 #endif /* WIN32 */ 221 lseek(infile, 0, SEEK_SET); 222 223 while ((bytes = read(infile, buffer, sizeof(buffer))) > 0) 224 { 225 if ((status = cupsWriteRequestData(http, buffer, (size_t)bytes)) 226 != HTTP_STATUS_CONTINUE) 227 break; 228 } 229 } 230 231 /* 232 * Get the server's response... 233 */ 234 235 if (status <= HTTP_STATUS_CONTINUE || status == HTTP_STATUS_OK) 236 { 237 response = cupsGetResponse(http, resource); 238 status = httpGetStatus(http); 239 } 240 241 DEBUG_printf(("2cupsDoIORequest: status=%d", status)); 242 243 if (status == HTTP_STATUS_ERROR || 244 (status >= HTTP_STATUS_BAD_REQUEST && status != HTTP_STATUS_UNAUTHORIZED && 245 status != HTTP_STATUS_UPGRADE_REQUIRED)) 246 { 247 _cupsSetHTTPError(status); 248 break; 249 } 250 251 if (response && outfile >= 0) 252 { 253 /* 254 * Write trailing data to file... 255 */ 256 257 while ((bytes = httpRead2(http, buffer, sizeof(buffer))) > 0) 258 if (write(outfile, buffer, (size_t)bytes) < bytes) 259 break; 260 } 261 262 if (http->state != HTTP_STATE_WAITING) 263 { 264 /* 265 * Flush any remaining data... 266 */ 267 268 httpFlush(http); 269 } 270 } 271 272 /* 273 * Delete the original request and return the response... 274 */ 275 276 ippDelete(request); 277 278 return (response); 279 } 280 281 282 /* 283 * 'cupsDoRequest()' - Do an IPP request. 284 * 285 * This function sends the IPP request to the specified server, retrying 286 * and authenticating as necessary. The request is freed with @link ippDelete@. 287 */ 288 289 ipp_t * /* O - Response data */ 290 cupsDoRequest(http_t *http, /* I - Connection to server or @code CUPS_HTTP_DEFAULT@ */ 291 ipp_t *request, /* I - IPP request */ 292 const char *resource) /* I - HTTP resource for POST */ 293 { 294 DEBUG_printf(("cupsDoRequest(http=%p, request=%p(%s), resource=\"%s\")", (void *)http, (void *)request, request ? ippOpString(request->request.op.operation_id) : "?", resource)); 295 296 return (cupsDoIORequest(http, request, resource, -1, -1)); 297 } 298 299 300 /* 301 * 'cupsGetResponse()' - Get a response to an IPP request. 302 * 303 * Use this function to get the response for an IPP request sent using 304 * @link cupsSendRequest@. For requests that return additional data, use 305 * @link cupsReadResponseData@ after getting a successful response, 306 * otherwise call @link httpFlush@ to complete the response processing. 307 * 308 * @since CUPS 1.4/macOS 10.6@ 309 */ 310 311 ipp_t * /* O - Response or @code NULL@ on HTTP error */ 312 cupsGetResponse(http_t *http, /* I - Connection to server or @code CUPS_HTTP_DEFAULT@ */ 313 const char *resource) /* I - HTTP resource for POST */ 314 { 315 http_status_t status; /* HTTP status */ 316 ipp_state_t state; /* IPP read state */ 317 ipp_t *response = NULL; /* IPP response */ 318 319 320 DEBUG_printf(("cupsGetResponse(http=%p, resource=\"%s\")", (void *)http, resource)); 321 DEBUG_printf(("1cupsGetResponse: http->state=%d", http ? http->state : HTTP_STATE_ERROR)); 322 323 /* 324 * Connect to the default server as needed... 325 */ 326 327 if (!http) 328 { 329 _cups_globals_t *cg = _cupsGlobals(); 330 /* Pointer to library globals */ 331 332 if ((http = cg->http) == NULL) 333 { 334 _cupsSetError(IPP_STATUS_ERROR_INTERNAL, _("No active connection."), 1); 335 DEBUG_puts("1cupsGetResponse: No active connection - returning NULL."); 336 return (NULL); 337 } 338 } 339 340 if (http->state != HTTP_STATE_POST_RECV && http->state != HTTP_STATE_POST_SEND) 341 { 342 _cupsSetError(IPP_STATUS_ERROR_INTERNAL, _("No request sent."), 1); 343 DEBUG_puts("1cupsGetResponse: Not in POST state - returning NULL."); 344 return (NULL); 345 } 346 347 /* 348 * Check for an unfinished chunked request... 349 */ 350 351 if (http->data_encoding == HTTP_ENCODING_CHUNKED) 352 { 353 /* 354 * Send a 0-length chunk to finish off the request... 355 */ 356 357 DEBUG_puts("2cupsGetResponse: Finishing chunked POST..."); 358 359 if (httpWrite2(http, "", 0) < 0) 360 return (NULL); 361 } 362 363 /* 364 * Wait for a response from the server... 365 */ 366 367 DEBUG_printf(("2cupsGetResponse: Update loop, http->status=%d...", 368 http->status)); 369 370 do 371 { 372 status = httpUpdate(http); 373 } 374 while (status == HTTP_STATUS_CONTINUE); 375 376 DEBUG_printf(("2cupsGetResponse: status=%d", status)); 377 378 if (status == HTTP_STATUS_OK) 379 { 380 /* 381 * Get the IPP response... 382 */ 383 384 response = ippNew(); 385 386 while ((state = ippRead(http, response)) != IPP_STATE_DATA) 387 if (state == IPP_STATE_ERROR) 388 break; 389 390 if (state == IPP_STATE_ERROR) 391 { 392 /* 393 * Flush remaining data and delete the response... 394 */ 395 396 DEBUG_puts("1cupsGetResponse: IPP read error!"); 397 398 httpFlush(http); 399 400 ippDelete(response); 401 response = NULL; 402 403 http->status = status = HTTP_STATUS_ERROR; 404 http->error = EINVAL; 405 } 406 } 407 else if (status != HTTP_STATUS_ERROR) 408 { 409 /* 410 * Flush any error message... 411 */ 412 413 httpFlush(http); 414 415 /* 416 * Then handle encryption and authentication... 417 */ 418 419 if (status == HTTP_STATUS_UNAUTHORIZED) 420 { 421 /* 422 * See if we can do authentication... 423 */ 424 425 DEBUG_puts("2cupsGetResponse: Need authorization..."); 426 427 if (!cupsDoAuthentication(http, "POST", resource)) 428 httpReconnect2(http, 30000, NULL); 429 else 430 http->status = status = HTTP_STATUS_CUPS_AUTHORIZATION_CANCELED; 431 } 432 433 #ifdef HAVE_SSL 434 else if (status == HTTP_STATUS_UPGRADE_REQUIRED) 435 { 436 /* 437 * Force a reconnect with encryption... 438 */ 439 440 DEBUG_puts("2cupsGetResponse: Need encryption..."); 441 442 if (!httpReconnect2(http, 30000, NULL)) 443 httpEncryption(http, HTTP_ENCRYPTION_REQUIRED); 444 } 445 #endif /* HAVE_SSL */ 446 } 447 448 if (response) 449 { 450 ipp_attribute_t *attr; /* status-message attribute */ 451 452 453 attr = ippFindAttribute(response, "status-message", IPP_TAG_TEXT); 454 455 DEBUG_printf(("1cupsGetResponse: status-code=%s, status-message=\"%s\"", 456 ippErrorString(response->request.status.status_code), 457 attr ? attr->values[0].string.text : "")); 458 459 _cupsSetError(response->request.status.status_code, 460 attr ? attr->values[0].string.text : 461 ippErrorString(response->request.status.status_code), 0); 462 } 463 464 return (response); 465 } 466 467 468 /* 469 * 'cupsLastError()' - Return the last IPP status code received on the current 470 * thread. 471 */ 472 473 ipp_status_t /* O - IPP status code from last request */ 474 cupsLastError(void) 475 { 476 return (_cupsGlobals()->last_error); 477 } 478 479 480 /* 481 * 'cupsLastErrorString()' - Return the last IPP status-message received on the 482 * current thread. 483 * 484 * @since CUPS 1.2/macOS 10.5@ 485 */ 486 487 const char * /* O - status-message text from last request */ 488 cupsLastErrorString(void) 489 { 490 return (_cupsGlobals()->last_status_message); 491 } 492 493 494 /* 495 * '_cupsNextDelay()' - Return the next retry delay value. 496 * 497 * This function currently returns the Fibonacci sequence 1 1 2 3 5 8. 498 * 499 * Pass 0 for the current delay value to initialize the sequence. 500 */ 501 502 int /* O - Next delay value */ 503 _cupsNextDelay(int current, /* I - Current delay value or 0 */ 504 int *previous) /* IO - Previous delay value */ 505 { 506 int next; /* Next delay value */ 507 508 509 if (current > 0) 510 { 511 next = (current + *previous) % 12; 512 *previous = next < current ? 0 : current; 513 } 514 else 515 { 516 next = 1; 517 *previous = 0; 518 } 519 520 return (next); 521 } 522 523 524 /* 525 * 'cupsReadResponseData()' - Read additional data after the IPP response. 526 * 527 * This function is used after @link cupsGetResponse@ to read the PPD or document 528 * files from @code CUPS_GET_PPD@ and @code CUPS_GET_DOCUMENT@ requests, 529 * respectively. 530 * 531 * @since CUPS 1.4/macOS 10.6@ 532 */ 533 534 ssize_t /* O - Bytes read, 0 on EOF, -1 on error */ 535 cupsReadResponseData( 536 http_t *http, /* I - Connection to server or @code CUPS_HTTP_DEFAULT@ */ 537 char *buffer, /* I - Buffer to use */ 538 size_t length) /* I - Number of bytes to read */ 539 { 540 /* 541 * Get the default connection as needed... 542 */ 543 544 DEBUG_printf(("cupsReadResponseData(http=%p, buffer=%p, length=" CUPS_LLFMT ")", (void *)http, (void *)buffer, CUPS_LLCAST length)); 545 546 if (!http) 547 { 548 _cups_globals_t *cg = _cupsGlobals(); 549 /* Pointer to library globals */ 550 551 if ((http = cg->http) == NULL) 552 { 553 _cupsSetError(IPP_STATUS_ERROR_INTERNAL, _("No active connection"), 1); 554 return (-1); 555 } 556 } 557 558 /* 559 * Then read from the HTTP connection... 560 */ 561 562 return (httpRead2(http, buffer, length)); 563 } 564 565 566 /* 567 * 'cupsSendRequest()' - Send an IPP request. 568 * 569 * Use @link cupsWriteRequestData@ to write any additional data (document, PPD 570 * file, etc.) for the request, @link cupsGetResponse@ to get the IPP response, 571 * and @link cupsReadResponseData@ to read any additional data following the 572 * response. Only one request can be sent/queued at a time per @code http_t@ 573 * connection. 574 * 575 * Returns the initial HTTP status code, which will be @code HTTP_STATUS_CONTINUE@ 576 * on a successful send of the request. 577 * 578 * Note: Unlike @link cupsDoFileRequest@, @link cupsDoIORequest@, and 579 * @link cupsDoRequest@, the request is NOT freed with @link ippDelete@. 580 * 581 * @since CUPS 1.4/macOS 10.6@ 582 */ 583 584 http_status_t /* O - Initial HTTP status */ 585 cupsSendRequest(http_t *http, /* I - Connection to server or @code CUPS_HTTP_DEFAULT@ */ 586 ipp_t *request, /* I - IPP request */ 587 const char *resource, /* I - Resource path */ 588 size_t length) /* I - Length of data to follow or @code CUPS_LENGTH_VARIABLE@ */ 589 { 590 http_status_t status; /* Status of HTTP request */ 591 int got_status; /* Did we get the status? */ 592 ipp_state_t state; /* State of IPP processing */ 593 http_status_t expect; /* Expect: header to use */ 594 char date[256]; /* Date: header value */ 595 596 597 DEBUG_printf(("cupsSendRequest(http=%p, request=%p(%s), resource=\"%s\", length=" CUPS_LLFMT ")", (void *)http, (void *)request, request ? ippOpString(request->request.op.operation_id) : "?", resource, CUPS_LLCAST length)); 598 599 /* 600 * Range check input... 601 */ 602 603 if (!request || !resource) 604 { 605 _cupsSetError(IPP_STATUS_ERROR_INTERNAL, strerror(EINVAL), 0); 606 607 return (HTTP_STATUS_ERROR); 608 } 609 610 /* 611 * Get the default connection as needed... 612 */ 613 614 if (!http && (http = _cupsConnect()) == NULL) 615 return (HTTP_STATUS_SERVICE_UNAVAILABLE); 616 617 /* 618 * If the prior request was not flushed out, do so now... 619 */ 620 621 if (http->state == HTTP_STATE_GET_SEND || 622 http->state == HTTP_STATE_POST_SEND) 623 { 624 DEBUG_puts("2cupsSendRequest: Flush prior response."); 625 httpFlush(http); 626 } 627 else if (http->state != HTTP_STATE_WAITING) 628 { 629 DEBUG_printf(("1cupsSendRequest: Unknown HTTP state (%d), " 630 "reconnecting.", http->state)); 631 if (httpReconnect2(http, 30000, NULL)) 632 return (HTTP_STATUS_ERROR); 633 } 634 635 #ifdef HAVE_SSL 636 /* 637 * See if we have an auth-info attribute and are communicating over 638 * a non-local link. If so, encrypt the link so that we can pass 639 * the authentication information securely... 640 */ 641 642 if (ippFindAttribute(request, "auth-info", IPP_TAG_TEXT) && 643 !httpAddrLocalhost(http->hostaddr) && !http->tls && 644 httpEncryption(http, HTTP_ENCRYPTION_REQUIRED)) 645 { 646 DEBUG_puts("1cupsSendRequest: Unable to encrypt connection."); 647 return (HTTP_STATUS_SERVICE_UNAVAILABLE); 648 } 649 #endif /* HAVE_SSL */ 650 651 /* 652 * Reconnect if the last response had a "Connection: close"... 653 */ 654 655 if (!_cups_strcasecmp(http->fields[HTTP_FIELD_CONNECTION], "close")) 656 { 657 DEBUG_puts("2cupsSendRequest: Connection: close"); 658 httpClearFields(http); 659 if (httpReconnect2(http, 30000, NULL)) 660 { 661 DEBUG_puts("1cupsSendRequest: Unable to reconnect."); 662 return (HTTP_STATUS_SERVICE_UNAVAILABLE); 663 } 664 } 665 666 /* 667 * Loop until we can send the request without authorization problems. 668 */ 669 670 expect = HTTP_STATUS_CONTINUE; 671 672 for (;;) 673 { 674 DEBUG_puts("2cupsSendRequest: Setup..."); 675 676 /* 677 * Setup the HTTP variables needed... 678 */ 679 680 httpClearFields(http); 681 httpSetExpect(http, expect); 682 httpSetField(http, HTTP_FIELD_CONTENT_TYPE, "application/ipp"); 683 httpSetField(http, HTTP_FIELD_DATE, httpGetDateString2(time(NULL), date, (int)sizeof(date))); 684 httpSetLength(http, length); 685 686 #ifdef HAVE_GSSAPI 687 if (http->authstring && !strncmp(http->authstring, "Negotiate", 9)) 688 { 689 /* 690 * Do not use cached Kerberos credentials since they will look like a 691 * "replay" attack... 692 */ 693 694 _cupsSetNegotiateAuthString(http, "POST", resource); 695 } 696 #endif /* HAVE_GSSAPI */ 697 698 httpSetField(http, HTTP_FIELD_AUTHORIZATION, http->authstring); 699 700 DEBUG_printf(("2cupsSendRequest: authstring=\"%s\"", http->authstring)); 701 702 /* 703 * Try the request... 704 */ 705 706 DEBUG_puts("2cupsSendRequest: Sending HTTP POST..."); 707 708 if (httpPost(http, resource)) 709 { 710 DEBUG_puts("2cupsSendRequest: POST failed, reconnecting."); 711 if (httpReconnect2(http, 30000, NULL)) 712 { 713 DEBUG_puts("1cupsSendRequest: Unable to reconnect."); 714 return (HTTP_STATUS_SERVICE_UNAVAILABLE); 715 } 716 else 717 continue; 718 } 719 720 /* 721 * Send the IPP data... 722 */ 723 724 DEBUG_puts("2cupsSendRequest: Writing IPP request..."); 725 726 request->state = IPP_STATE_IDLE; 727 status = HTTP_STATUS_CONTINUE; 728 got_status = 0; 729 730 while ((state = ippWrite(http, request)) != IPP_STATE_DATA) 731 { 732 if (httpCheck(http)) 733 { 734 got_status = 1; 735 736 _httpUpdate(http, &status); 737 if (status >= HTTP_STATUS_MULTIPLE_CHOICES) 738 break; 739 } 740 else if (state == IPP_STATE_ERROR) 741 break; 742 } 743 744 if (state == IPP_STATE_ERROR) 745 { 746 /* 747 * We weren't able to send the IPP request. But did we already get a HTTP 748 * error status? 749 */ 750 751 if (!got_status || status < HTTP_STATUS_MULTIPLE_CHOICES) 752 { 753 /* 754 * No, something else went wrong. 755 */ 756 757 DEBUG_puts("1cupsSendRequest: Unable to send IPP request."); 758 759 http->status = HTTP_STATUS_ERROR; 760 http->state = HTTP_STATE_WAITING; 761 762 return (HTTP_STATUS_ERROR); 763 } 764 } 765 766 /* 767 * Wait up to 1 second to get the 100-continue response as needed... 768 */ 769 770 if (!got_status) 771 { 772 if (expect == HTTP_STATUS_CONTINUE) 773 { 774 DEBUG_puts("2cupsSendRequest: Waiting for 100-continue..."); 775 776 if (httpWait(http, 1000)) 777 _httpUpdate(http, &status); 778 } 779 else if (httpCheck(http)) 780 _httpUpdate(http, &status); 781 } 782 783 DEBUG_printf(("2cupsSendRequest: status=%d", status)); 784 785 /* 786 * Process the current HTTP status... 787 */ 788 789 if (status >= HTTP_STATUS_MULTIPLE_CHOICES) 790 { 791 int temp_status; /* Temporary status */ 792 793 _cupsSetHTTPError(status); 794 795 do 796 { 797 temp_status = httpUpdate(http); 798 } 799 while (temp_status != HTTP_STATUS_ERROR && 800 http->state == HTTP_STATE_POST_RECV); 801 802 httpFlush(http); 803 } 804 805 switch (status) 806 { 807 case HTTP_STATUS_CONTINUE : 808 case HTTP_STATUS_OK : 809 case HTTP_STATUS_ERROR : 810 DEBUG_printf(("1cupsSendRequest: Returning %d.", status)); 811 return (status); 812 813 case HTTP_STATUS_UNAUTHORIZED : 814 if (cupsDoAuthentication(http, "POST", resource)) 815 { 816 DEBUG_puts("1cupsSendRequest: Returning HTTP_STATUS_CUPS_AUTHORIZATION_CANCELED."); 817 return (HTTP_STATUS_CUPS_AUTHORIZATION_CANCELED); 818 } 819 820 DEBUG_puts("2cupsSendRequest: Reconnecting after HTTP_STATUS_UNAUTHORIZED."); 821 822 if (httpReconnect2(http, 30000, NULL)) 823 { 824 DEBUG_puts("1cupsSendRequest: Unable to reconnect."); 825 return (HTTP_STATUS_SERVICE_UNAVAILABLE); 826 } 827 break; 828 829 #ifdef HAVE_SSL 830 case HTTP_STATUS_UPGRADE_REQUIRED : 831 /* 832 * Flush any error message, reconnect, and then upgrade with 833 * encryption... 834 */ 835 836 DEBUG_puts("2cupsSendRequest: Reconnecting after " 837 "HTTP_STATUS_UPGRADE_REQUIRED."); 838 839 if (httpReconnect2(http, 30000, NULL)) 840 { 841 DEBUG_puts("1cupsSendRequest: Unable to reconnect."); 842 return (HTTP_STATUS_SERVICE_UNAVAILABLE); 843 } 844 845 DEBUG_puts("2cupsSendRequest: Upgrading to TLS."); 846 if (httpEncryption(http, HTTP_ENCRYPTION_REQUIRED)) 847 { 848 DEBUG_puts("1cupsSendRequest: Unable to encrypt connection."); 849 return (HTTP_STATUS_SERVICE_UNAVAILABLE); 850 } 851 break; 852 #endif /* HAVE_SSL */ 853 854 case HTTP_STATUS_EXPECTATION_FAILED : 855 /* 856 * Don't try using the Expect: header the next time around... 857 */ 858 859 expect = (http_status_t)0; 860 861 DEBUG_puts("2cupsSendRequest: Reconnecting after " 862 "HTTP_EXPECTATION_FAILED."); 863 864 if (httpReconnect2(http, 30000, NULL)) 865 { 866 DEBUG_puts("1cupsSendRequest: Unable to reconnect."); 867 return (HTTP_STATUS_SERVICE_UNAVAILABLE); 868 } 869 break; 870 871 default : 872 /* 873 * Some other error... 874 */ 875 876 return (status); 877 } 878 } 879 } 880 881 882 /* 883 * 'cupsWriteRequestData()' - Write additional data after an IPP request. 884 * 885 * This function is used after @link cupsSendRequest@ to provide a PPD and 886 * after @link cupsStartDocument@ to provide a document file. 887 * 888 * @since CUPS 1.4/macOS 10.6@ 889 */ 890 891 http_status_t /* O - @code HTTP_STATUS_CONTINUE@ if OK or HTTP status on error */ 892 cupsWriteRequestData( 893 http_t *http, /* I - Connection to server or @code CUPS_HTTP_DEFAULT@ */ 894 const char *buffer, /* I - Bytes to write */ 895 size_t length) /* I - Number of bytes to write */ 896 { 897 int wused; /* Previous bytes in buffer */ 898 899 900 /* 901 * Get the default connection as needed... 902 */ 903 904 DEBUG_printf(("cupsWriteRequestData(http=%p, buffer=%p, length=" CUPS_LLFMT ")", (void *)http, (void *)buffer, CUPS_LLCAST length)); 905 906 if (!http) 907 { 908 _cups_globals_t *cg = _cupsGlobals(); 909 /* Pointer to library globals */ 910 911 if ((http = cg->http) == NULL) 912 { 913 _cupsSetError(IPP_STATUS_ERROR_INTERNAL, _("No active connection"), 1); 914 DEBUG_puts("1cupsWriteRequestData: Returning HTTP_STATUS_ERROR."); 915 return (HTTP_STATUS_ERROR); 916 } 917 } 918 919 /* 920 * Then write to the HTTP connection... 921 */ 922 923 wused = http->wused; 924 925 if (httpWrite2(http, buffer, length) < 0) 926 { 927 DEBUG_puts("1cupsWriteRequestData: Returning HTTP_STATUS_ERROR."); 928 _cupsSetError(IPP_STATUS_ERROR_INTERNAL, strerror(http->error), 0); 929 return (HTTP_STATUS_ERROR); 930 } 931 932 /* 933 * Finally, check if we have any pending data from the server... 934 */ 935 936 if (length >= HTTP_MAX_BUFFER || 937 http->wused < wused || 938 (wused > 0 && (size_t)http->wused == length)) 939 { 940 /* 941 * We've written something to the server, so check for response data... 942 */ 943 944 if (_httpWait(http, 0, 1)) 945 { 946 http_status_t status; /* Status from _httpUpdate */ 947 948 _httpUpdate(http, &status); 949 if (status >= HTTP_STATUS_MULTIPLE_CHOICES) 950 { 951 _cupsSetHTTPError(status); 952 953 do 954 { 955 status = httpUpdate(http); 956 } 957 while (status != HTTP_STATUS_ERROR && http->state == HTTP_STATE_POST_RECV); 958 959 httpFlush(http); 960 } 961 962 DEBUG_printf(("1cupsWriteRequestData: Returning %d.\n", status)); 963 return (status); 964 } 965 } 966 967 DEBUG_puts("1cupsWriteRequestData: Returning HTTP_STATUS_CONTINUE."); 968 return (HTTP_STATUS_CONTINUE); 969 } 970 971 972 /* 973 * '_cupsConnect()' - Get the default server connection... 974 */ 975 976 http_t * /* O - HTTP connection */ 977 _cupsConnect(void) 978 { 979 _cups_globals_t *cg = _cupsGlobals(); /* Pointer to library globals */ 980 981 982 /* 983 * See if we are connected to the same server... 984 */ 985 986 if (cg->http) 987 { 988 /* 989 * Compare the connection hostname, port, and encryption settings to 990 * the cached defaults; these were initialized the first time we 991 * connected... 992 */ 993 994 if (strcmp(cg->http->hostname, cg->server) || 995 #ifdef AF_LOCAL 996 (httpAddrFamily(cg->http->hostaddr) != AF_LOCAL && cg->ipp_port != httpAddrPort(cg->http->hostaddr)) || 997 #else 998 cg->ipp_port != httpAddrPort(cg->http->hostaddr) || 999 #endif /* AF_LOCAL */ 1000 (cg->http->encryption != cg->encryption && 1001 cg->http->encryption == HTTP_ENCRYPTION_NEVER)) 1002 { 1003 /* 1004 * Need to close the current connection because something has changed... 1005 */ 1006 1007 httpClose(cg->http); 1008 cg->http = NULL; 1009 } 1010 else 1011 { 1012 /* 1013 * Same server, see if the connection is still established... 1014 */ 1015 1016 char ch; /* Connection check byte */ 1017 ssize_t n; /* Number of bytes */ 1018 1019 #ifdef WIN32 1020 if ((n = recv(cg->http->fd, &ch, 1, MSG_PEEK)) == 0 || 1021 (n < 0 && WSAGetLastError() != WSAEWOULDBLOCK)) 1022 #else 1023 if ((n = recv(cg->http->fd, &ch, 1, MSG_PEEK | MSG_DONTWAIT)) == 0 || 1024 (n < 0 && errno != EWOULDBLOCK)) 1025 #endif /* WIN32 */ 1026 { 1027 /* 1028 * Nope, close the connection... 1029 */ 1030 1031 httpClose(cg->http); 1032 cg->http = NULL; 1033 } 1034 } 1035 } 1036 1037 /* 1038 * (Re)connect as needed... 1039 */ 1040 1041 if (!cg->http) 1042 { 1043 if ((cg->http = httpConnect2(cupsServer(), ippPort(), NULL, AF_UNSPEC, 1044 cupsEncryption(), 1, 30000, NULL)) == NULL) 1045 { 1046 if (errno) 1047 _cupsSetError(IPP_STATUS_ERROR_SERVICE_UNAVAILABLE, NULL, 0); 1048 else 1049 _cupsSetError(IPP_STATUS_ERROR_SERVICE_UNAVAILABLE, 1050 _("Unable to connect to host."), 1); 1051 } 1052 } 1053 1054 /* 1055 * Return the cached connection... 1056 */ 1057 1058 return (cg->http); 1059 } 1060 1061 1062 /* 1063 * '_cupsSetError()' - Set the last IPP status code and status-message. 1064 */ 1065 1066 void 1067 _cupsSetError(ipp_status_t status, /* I - IPP status code */ 1068 const char *message, /* I - status-message value */ 1069 int localize) /* I - Localize the message? */ 1070 { 1071 _cups_globals_t *cg; /* Global data */ 1072 1073 1074 if (!message && errno) 1075 { 1076 message = strerror(errno); 1077 localize = 0; 1078 } 1079 1080 cg = _cupsGlobals(); 1081 cg->last_error = status; 1082 1083 if (cg->last_status_message) 1084 { 1085 _cupsStrFree(cg->last_status_message); 1086 1087 cg->last_status_message = NULL; 1088 } 1089 1090 if (message) 1091 { 1092 if (localize) 1093 { 1094 /* 1095 * Get the message catalog... 1096 */ 1097 1098 if (!cg->lang_default) 1099 cg->lang_default = cupsLangDefault(); 1100 1101 cg->last_status_message = _cupsStrAlloc(_cupsLangString(cg->lang_default, 1102 message)); 1103 } 1104 else 1105 cg->last_status_message = _cupsStrAlloc(message); 1106 } 1107 1108 DEBUG_printf(("4_cupsSetError: last_error=%s, last_status_message=\"%s\"", 1109 ippErrorString(cg->last_error), cg->last_status_message)); 1110 } 1111 1112 1113 /* 1114 * '_cupsSetHTTPError()' - Set the last error using the HTTP status. 1115 */ 1116 1117 void 1118 _cupsSetHTTPError(http_status_t status) /* I - HTTP status code */ 1119 { 1120 switch (status) 1121 { 1122 case HTTP_STATUS_NOT_FOUND : 1123 _cupsSetError(IPP_STATUS_ERROR_NOT_FOUND, httpStatus(status), 0); 1124 break; 1125 1126 case HTTP_STATUS_UNAUTHORIZED : 1127 _cupsSetError(IPP_STATUS_ERROR_NOT_AUTHENTICATED, httpStatus(status), 0); 1128 break; 1129 1130 case HTTP_STATUS_CUPS_AUTHORIZATION_CANCELED : 1131 _cupsSetError(IPP_STATUS_ERROR_CUPS_AUTHENTICATION_CANCELED, httpStatus(status), 0); 1132 break; 1133 1134 case HTTP_STATUS_FORBIDDEN : 1135 _cupsSetError(IPP_STATUS_ERROR_FORBIDDEN, httpStatus(status), 0); 1136 break; 1137 1138 case HTTP_STATUS_BAD_REQUEST : 1139 _cupsSetError(IPP_STATUS_ERROR_BAD_REQUEST, httpStatus(status), 0); 1140 break; 1141 1142 case HTTP_STATUS_REQUEST_TOO_LARGE : 1143 _cupsSetError(IPP_STATUS_ERROR_REQUEST_VALUE, httpStatus(status), 0); 1144 break; 1145 1146 case HTTP_STATUS_NOT_IMPLEMENTED : 1147 _cupsSetError(IPP_STATUS_ERROR_OPERATION_NOT_SUPPORTED, httpStatus(status), 0); 1148 break; 1149 1150 case HTTP_STATUS_NOT_SUPPORTED : 1151 _cupsSetError(IPP_STATUS_ERROR_VERSION_NOT_SUPPORTED, httpStatus(status), 0); 1152 break; 1153 1154 case HTTP_STATUS_UPGRADE_REQUIRED : 1155 _cupsSetError(IPP_STATUS_ERROR_CUPS_UPGRADE_REQUIRED, httpStatus(status), 0); 1156 break; 1157 1158 case HTTP_STATUS_CUPS_PKI_ERROR : 1159 _cupsSetError(IPP_STATUS_ERROR_CUPS_PKI, httpStatus(status), 0); 1160 break; 1161 1162 case HTTP_STATUS_ERROR : 1163 _cupsSetError(IPP_STATUS_ERROR_INTERNAL, strerror(errno), 0); 1164 break; 1165 1166 default : 1167 DEBUG_printf(("4_cupsSetHTTPError: HTTP error %d mapped to " 1168 "IPP_STATUS_ERROR_SERVICE_UNAVAILABLE!", status)); 1169 _cupsSetError(IPP_STATUS_ERROR_SERVICE_UNAVAILABLE, httpStatus(status), 0); 1170 break; 1171 } 1172 } 1173
