1 /* 2 * Copyright (C) 1996-2005 The Free Software Foundation, Inc. 3 * 4 * This program is free software; you can redistribute it and/or modify 5 * it under the terms of the GNU General Public License as published by 6 * the Free Software Foundation; either version 2, or (at your option) 7 * any later version. 8 * 9 * This program is distributed in the hope that it will be useful, 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 * GNU General Public License for more details. 13 */ 14 15 /* Code for the buffer data structure. */ 16 17 #include "cvs.h" 18 #include "buffer.h" 19 #include "pagealign_alloc.h" 20 21 #if defined (SERVER_SUPPORT) || defined (CLIENT_SUPPORT) 22 23 # include <sys/socket.h> 24 25 /* OS/2 doesn't have EIO. FIXME: this whole notion of turning 26 a different error into EIO strikes me as pretty dubious. */ 27 # if !defined( EIO ) 28 # define EIO EBADPOS 29 # endif 30 31 /* Local functions. */ 32 static void buf_default_memory_error (struct buffer *); 33 static struct buffer_data *get_buffer_data (void); 34 35 36 37 /* Initialize a buffer structure. */ 38 struct buffer * 39 buf_initialize (type_buf_input input, 40 type_buf_output output, 41 type_buf_flush flush, 42 type_buf_block block, 43 type_buf_get_fd get_fd, 44 type_buf_shutdown shutdown, 45 type_buf_memory_error memory_error, 46 void *closure) 47 { 48 struct buffer *buf; 49 50 buf = xmalloc (sizeof (struct buffer)); 51 buf->data = NULL; 52 buf->last = NULL; 53 buf->nonblocking = false; 54 buf->input = input; 55 buf->output = output; 56 buf->flush = flush; 57 buf->block = block; 58 buf->get_fd = get_fd; 59 buf->shutdown = shutdown; 60 buf->memory_error = memory_error ? memory_error : buf_default_memory_error; 61 buf->closure = closure; 62 return buf; 63 } 64 65 66 67 /* Free a buffer structure. */ 68 void 69 buf_free (struct buffer *buf) 70 { 71 if (buf->closure != NULL) 72 { 73 free (buf->closure); 74 buf->closure = NULL; 75 } 76 buf_free_data (buf); 77 free (buf); 78 } 79 80 81 82 /* Initialize a buffer structure which is not to be used for I/O. */ 83 struct buffer * 84 buf_nonio_initialize( void (*memory) (struct buffer *) ) 85 { 86 return buf_initialize (NULL, NULL, NULL, NULL, NULL, NULL, memory, NULL); 87 } 88 89 90 91 /* Default memory error handler. */ 92 static void 93 buf_default_memory_error (struct buffer *buf) 94 { 95 error (1, 0, "out of memory"); 96 } 97 98 99 100 /* Allocate more buffer_data structures. */ 101 /* Get a new buffer_data structure. */ 102 static struct buffer_data * 103 get_buffer_data (void) 104 { 105 struct buffer_data *ret; 106 107 ret = xmalloc (sizeof (struct buffer_data)); 108 ret->text = pagealign_xalloc (BUFFER_DATA_SIZE); 109 110 return ret; 111 } 112 113 114 115 /* See whether a buffer and its file descriptor is empty. */ 116 int 117 buf_empty (buf) 118 struct buffer *buf; 119 { 120 /* Try and read any data on the file descriptor first. 121 * We already know the descriptor is non-blocking. 122 */ 123 buf_input_data (buf, NULL); 124 return buf_empty_p (buf); 125 } 126 127 128 129 /* See whether a buffer is empty. */ 130 int 131 buf_empty_p (struct buffer *buf) 132 { 133 struct buffer_data *data; 134 135 for (data = buf->data; data != NULL; data = data->next) 136 if (data->size > 0) 137 return 0; 138 return 1; 139 } 140 141 142 143 # if defined (SERVER_FLOWCONTROL) || defined (PROXY_SUPPORT) 144 /* 145 * Count how much data is stored in the buffer.. 146 * Note that each buffer is a xmalloc'ed chunk BUFFER_DATA_SIZE. 147 */ 148 int 149 buf_count_mem (struct buffer *buf) 150 { 151 struct buffer_data *data; 152 int mem = 0; 153 154 for (data = buf->data; data != NULL; data = data->next) 155 mem += BUFFER_DATA_SIZE; 156 157 return mem; 158 } 159 # endif /* SERVER_FLOWCONTROL || PROXY_SUPPORT */ 160 161 162 163 /* Add data DATA of length LEN to BUF. */ 164 void 165 buf_output (struct buffer *buf, const char *data, size_t len) 166 { 167 if (buf->data != NULL 168 && (((buf->last->text + BUFFER_DATA_SIZE) 169 - (buf->last->bufp + buf->last->size)) 170 >= len)) 171 { 172 memcpy (buf->last->bufp + buf->last->size, data, len); 173 buf->last->size += len; 174 return; 175 } 176 177 while (1) 178 { 179 struct buffer_data *newdata; 180 181 newdata = get_buffer_data (); 182 if (newdata == NULL) 183 { 184 (*buf->memory_error) (buf); 185 return; 186 } 187 188 if (buf->data == NULL) 189 buf->data = newdata; 190 else 191 buf->last->next = newdata; 192 newdata->next = NULL; 193 buf->last = newdata; 194 195 newdata->bufp = newdata->text; 196 197 if (len <= BUFFER_DATA_SIZE) 198 { 199 newdata->size = len; 200 memcpy (newdata->text, data, len); 201 return; 202 } 203 204 newdata->size = BUFFER_DATA_SIZE; 205 memcpy (newdata->text, data, BUFFER_DATA_SIZE); 206 207 data += BUFFER_DATA_SIZE; 208 len -= BUFFER_DATA_SIZE; 209 } 210 211 /*NOTREACHED*/ 212 } 213 214 215 216 /* Add a '\0' terminated string to BUF. */ 217 void 218 buf_output0 (struct buffer *buf, const char *string) 219 { 220 buf_output (buf, string, strlen (string)); 221 } 222 223 224 225 /* Add a single character to BUF. */ 226 void 227 buf_append_char (struct buffer *buf, int ch) 228 { 229 if (buf->data != NULL 230 && (buf->last->text + BUFFER_DATA_SIZE 231 != buf->last->bufp + buf->last->size)) 232 { 233 *(buf->last->bufp + buf->last->size) = ch; 234 ++buf->last->size; 235 } 236 else 237 { 238 char b; 239 240 b = ch; 241 buf_output (buf, &b, 1); 242 } 243 } 244 245 246 247 /* Free struct buffer_data's from the list starting with FIRST and ending at 248 * LAST, inclusive. 249 */ 250 static inline void 251 buf_free_datas (struct buffer_data *first, struct buffer_data *last) 252 { 253 struct buffer_data *b, *n, *p; 254 b = first; 255 do 256 { 257 p = b; 258 n = b->next; 259 pagealign_free (b->text); 260 free (b); 261 b = n; 262 } while (p != last); 263 } 264 265 266 267 /* 268 * Send all the output we've been saving up. Returns 0 for success or 269 * errno code. If the buffer has been set to be nonblocking, this 270 * will just write until the write would block. 271 */ 272 int 273 buf_send_output (struct buffer *buf) 274 { 275 assert (buf->output != NULL); 276 277 while (buf->data != NULL) 278 { 279 struct buffer_data *data; 280 281 data = buf->data; 282 283 if (data->size > 0) 284 { 285 int status; 286 size_t nbytes; 287 288 status = (*buf->output) (buf->closure, data->bufp, data->size, 289 &nbytes); 290 if (status != 0) 291 { 292 /* Some sort of error. Discard the data, and return. */ 293 buf_free_data (buf); 294 return status; 295 } 296 297 if (nbytes != data->size) 298 { 299 /* Not all the data was written out. This is only 300 permitted in nonblocking mode. Adjust the buffer, 301 and return. */ 302 303 assert (buf->nonblocking); 304 305 data->size -= nbytes; 306 data->bufp += nbytes; 307 308 return 0; 309 } 310 } 311 312 buf->data = data->next; 313 buf_free_datas (data, data); 314 } 315 316 buf->last = NULL; 317 318 return 0; 319 } 320 321 322 323 /* 324 * Flush any data queued up in the buffer. If BLOCK is nonzero, then 325 * if the buffer is in nonblocking mode, put it into blocking mode for 326 * the duration of the flush. This returns 0 on success, or an error 327 * code. 328 */ 329 int 330 buf_flush (struct buffer *buf, bool block) 331 { 332 int nonblocking; 333 int status; 334 335 assert (buf->flush != NULL); 336 337 nonblocking = buf->nonblocking; 338 if (nonblocking && block) 339 { 340 status = set_block (buf); 341 if (status != 0) 342 return status; 343 } 344 345 status = buf_send_output (buf); 346 if (status == 0) 347 status = (*buf->flush) (buf->closure); 348 349 if (nonblocking && block) 350 { 351 int blockstat; 352 353 blockstat = set_nonblock (buf); 354 if (status == 0) 355 status = blockstat; 356 } 357 358 return status; 359 } 360 361 362 363 /* 364 * Set buffer BUF to nonblocking I/O. Returns 0 for success or errno 365 * code. 366 */ 367 int 368 set_nonblock (struct buffer *buf) 369 { 370 int status; 371 372 if (buf->nonblocking) 373 return 0; 374 assert (buf->block != NULL); 375 status = (*buf->block) (buf->closure, 0); 376 if (status != 0) 377 return status; 378 buf->nonblocking = true; 379 return 0; 380 } 381 382 383 384 /* 385 * Set buffer BUF to blocking I/O. Returns 0 for success or errno 386 * code. 387 */ 388 int 389 set_block (struct buffer *buf) 390 { 391 int status; 392 393 if (! buf->nonblocking) 394 return 0; 395 assert (buf->block != NULL); 396 status = (*buf->block) (buf->closure, 1); 397 if (status != 0) 398 return status; 399 buf->nonblocking = false; 400 return 0; 401 } 402 403 404 405 /* 406 * Send a character count and some output. Returns errno code or 0 for 407 * success. 408 * 409 * Sending the count in binary is OK since this is only used on a pipe 410 * within the same system. 411 */ 412 int 413 buf_send_counted (struct buffer *buf) 414 { 415 int size; 416 struct buffer_data *data; 417 418 size = 0; 419 for (data = buf->data; data != NULL; data = data->next) 420 size += data->size; 421 422 data = get_buffer_data (); 423 if (data == NULL) 424 { 425 (*buf->memory_error) (buf); 426 return ENOMEM; 427 } 428 429 data->next = buf->data; 430 buf->data = data; 431 if (buf->last == NULL) 432 buf->last = data; 433 434 data->bufp = data->text; 435 data->size = sizeof (int); 436 437 *((int *) data->text) = size; 438 439 return buf_send_output (buf); 440 } 441 442 443 444 /* 445 * Send a special count. COUNT should be negative. It will be 446 * handled specially by buf_copy_counted. This function returns 0 or 447 * an errno code. 448 * 449 * Sending the count in binary is OK since this is only used on a pipe 450 * within the same system. 451 */ 452 int 453 buf_send_special_count (struct buffer *buf, int count) 454 { 455 struct buffer_data *data; 456 457 data = get_buffer_data (); 458 if (data == NULL) 459 { 460 (*buf->memory_error) (buf); 461 return ENOMEM; 462 } 463 464 data->next = buf->data; 465 buf->data = data; 466 if (buf->last == NULL) 467 buf->last = data; 468 469 data->bufp = data->text; 470 data->size = sizeof (int); 471 472 *((int *) data->text) = count; 473 474 return buf_send_output (buf); 475 } 476 477 478 479 /* Append a list of buffer_data structures to an buffer. */ 480 void 481 buf_append_data (struct buffer *buf, struct buffer_data *data, 482 struct buffer_data *last) 483 { 484 if (data != NULL) 485 { 486 if (buf->data == NULL) 487 buf->data = data; 488 else 489 buf->last->next = data; 490 buf->last = last; 491 } 492 } 493 494 495 496 # ifdef PROXY_SUPPORT 497 /* Copy data structures and append them to a buffer. 498 * 499 * ERRORS 500 * Failure to allocate memory here is fatal. 501 */ 502 void 503 buf_copy_data (struct buffer *buf, struct buffer_data *data, 504 struct buffer_data *last) 505 { 506 struct buffer_data *first, *new, *cur, *prev; 507 508 assert (buf); 509 assert (data); 510 511 prev = first = NULL; 512 cur = data; 513 while (1) 514 { 515 new = get_buffer_data (); 516 if (!new) error (1, errno, "Failed to allocate buffer data."); 517 518 if (!first) first = new; 519 memcpy (new->text, cur->bufp, cur->size); 520 new->bufp = new->text; 521 new->size = cur->size; 522 new->next = NULL; 523 if (prev) prev->next = new; 524 if (cur == last) break; 525 prev = new; 526 cur = cur->next; 527 } 528 529 buf_append_data (buf, first, new); 530 } 531 # endif /* PROXY_SUPPORT */ 532 533 534 535 /* Dispose of any remaining data in the buffer. */ 536 void 537 buf_free_data (struct buffer *buffer) 538 { 539 if (buf_empty_p (buffer)) return; 540 buf_free_datas (buffer->data, buffer->last); 541 buffer->data = buffer->last = NULL; 542 } 543 544 545 546 /* Append the data in one buffer to another. This removes the data 547 * from the source buffer. 548 */ 549 void 550 buf_append_buffer (struct buffer *to, struct buffer *from) 551 { 552 struct buffer_data *n; 553 554 /* Copy the data pointer to the new buf. */ 555 buf_append_data (to, from->data, from->last); 556 557 n = from->data; 558 while (n) 559 { 560 if (n == from->last) break; 561 n = n->next; 562 } 563 564 /* Remove from the original location. */ 565 from->data = NULL; 566 from->last = NULL; 567 } 568 569 570 571 /* 572 * Copy the contents of file F into buffer_data structures. We can't 573 * copy directly into an buffer, because we want to handle failure and 574 * success differently. Returns 0 on success, or -2 if out of 575 * memory, or a status code on error. Since the caller happens to 576 * know the size of the file, it is passed in as SIZE. On success, 577 * this function sets *RETP and *LASTP, which may be passed to 578 * buf_append_data. 579 */ 580 int 581 buf_read_file (FILE *f, long int size, struct buffer_data **retp, 582 struct buffer_data **lastp) 583 { 584 int status; 585 586 *retp = NULL; 587 *lastp = NULL; 588 589 while (size > 0) 590 { 591 struct buffer_data *data; 592 int get; 593 594 data = get_buffer_data (); 595 if (data == NULL) 596 { 597 status = -2; 598 goto error_return; 599 } 600 601 if (*retp == NULL) 602 *retp = data; 603 else 604 (*lastp)->next = data; 605 data->next = NULL; 606 *lastp = data; 607 608 data->bufp = data->text; 609 data->size = 0; 610 611 if (size > BUFFER_DATA_SIZE) 612 get = BUFFER_DATA_SIZE; 613 else 614 get = size; 615 616 errno = EIO; 617 if (fread (data->text, get, 1, f) != 1) 618 { 619 status = errno; 620 goto error_return; 621 } 622 623 data->size += get; 624 size -= get; 625 } 626 627 return 0; 628 629 error_return: 630 if (*retp != NULL) 631 buf_free_datas (*retp, (*lastp)->next); 632 return status; 633 } 634 635 636 637 /* 638 * Copy the contents of file F into buffer_data structures. We can't 639 * copy directly into an buffer, because we want to handle failure and 640 * success differently. Returns 0 on success, or -2 if out of 641 * memory, or a status code on error. On success, this function sets 642 * *RETP and *LASTP, which may be passed to buf_append_data. 643 */ 644 int 645 buf_read_file_to_eof (FILE *f, struct buffer_data **retp, 646 struct buffer_data **lastp) 647 { 648 int status; 649 650 *retp = NULL; 651 *lastp = NULL; 652 653 while (!feof (f)) 654 { 655 struct buffer_data *data; 656 int get, nread; 657 658 data = get_buffer_data (); 659 if (data == NULL) 660 { 661 status = -2; 662 goto error_return; 663 } 664 665 if (*retp == NULL) 666 *retp = data; 667 else 668 (*lastp)->next = data; 669 data->next = NULL; 670 *lastp = data; 671 672 data->bufp = data->text; 673 data->size = 0; 674 675 get = BUFFER_DATA_SIZE; 676 677 errno = EIO; 678 nread = fread (data->text, 1, get, f); 679 if (nread == 0 && !feof (f)) 680 { 681 status = errno; 682 goto error_return; 683 } 684 685 data->size = nread; 686 } 687 688 return 0; 689 690 error_return: 691 if (*retp != NULL) 692 buf_free_datas (*retp, (*lastp)->next); 693 return status; 694 } 695 696 697 698 /* Return the number of bytes in a chain of buffer_data structures. */ 699 int 700 buf_chain_length (struct buffer_data *buf) 701 { 702 int size = 0; 703 while (buf) 704 { 705 size += buf->size; 706 buf = buf->next; 707 } 708 return size; 709 } 710 711 712 713 /* Return the number of bytes in a buffer. */ 714 int 715 buf_length (struct buffer *buf) 716 { 717 return buf_chain_length (buf->data); 718 } 719 720 721 722 /* 723 * Read an arbitrary amount of data into an input buffer. The buffer 724 * will be in nonblocking mode, and we just grab what we can. Return 725 * 0 on success, or -1 on end of file, or -2 if out of memory, or an 726 * error code. If COUNTP is not NULL, *COUNTP is set to the number of 727 * bytes read. 728 */ 729 int 730 buf_input_data (struct buffer *buf, size_t *countp) 731 { 732 assert (buf->input != NULL); 733 734 if (countp != NULL) 735 *countp = 0; 736 737 while (1) 738 { 739 int status; 740 size_t get, nbytes; 741 742 if (buf->data == NULL 743 || (buf->last->bufp + buf->last->size 744 == buf->last->text + BUFFER_DATA_SIZE)) 745 { 746 struct buffer_data *data; 747 748 data = get_buffer_data (); 749 if (data == NULL) 750 { 751 (*buf->memory_error) (buf); 752 return -2; 753 } 754 755 if (buf->data == NULL) 756 buf->data = data; 757 else 758 buf->last->next = data; 759 data->next = NULL; 760 buf->last = data; 761 762 data->bufp = data->text; 763 data->size = 0; 764 } 765 766 get = ((buf->last->text + BUFFER_DATA_SIZE) 767 - (buf->last->bufp + buf->last->size)); 768 769 status = (*buf->input) (buf->closure, 770 buf->last->bufp + buf->last->size, 771 0, get, &nbytes); 772 if (status != 0) 773 return status; 774 775 buf->last->size += nbytes; 776 if (countp != NULL) 777 *countp += nbytes; 778 779 if (nbytes < get) 780 { 781 /* If we did not fill the buffer, then presumably we read 782 all the available data. */ 783 return 0; 784 } 785 } 786 787 /*NOTREACHED*/ 788 } 789 790 791 792 /* 793 * Read a line (characters up to a \012) from an input buffer. (We 794 * use \012 rather than \n for the benefit of non Unix clients for 795 * which \n means something else). This returns 0 on success, or -1 796 * on end of file, or -2 if out of memory, or an error code. If it 797 * succeeds, it sets *LINE to an allocated buffer holding the contents 798 * of the line. The trailing \012 is not included in the buffer. If 799 * LENP is not NULL, then *LENP is set to the number of bytes read; 800 * strlen may not work, because there may be embedded null bytes. 801 */ 802 int 803 buf_read_line (struct buffer *buf, char **line, size_t *lenp) 804 { 805 return buf_read_short_line (buf, line, lenp, SIZE_MAX); 806 } 807 808 809 810 /* Like buf_read_line, but return -2 if no newline is found in MAX characters. 811 */ 812 int 813 buf_read_short_line (struct buffer *buf, char **line, size_t *lenp, 814 size_t max) 815 { 816 assert (buf->input != NULL); 817 818 *line = NULL; 819 820 while (1) 821 { 822 size_t len, finallen, predicted_len; 823 struct buffer_data *data; 824 char *nl; 825 826 /* See if there is a newline in BUF. */ 827 len = 0; 828 for (data = buf->data; data != NULL; data = data->next) 829 { 830 nl = memchr (data->bufp, '\012', data->size); 831 if (nl != NULL) 832 { 833 finallen = nl - data->bufp; 834 if (xsum (len, finallen) >= max) return -2; 835 len += finallen; 836 break; 837 } 838 else if (xsum (len, data->size) >= max) return -2; 839 len += data->size; 840 } 841 842 /* If we found a newline, copy the line into a memory buffer, 843 and remove it from BUF. */ 844 if (data != NULL) 845 { 846 char *p; 847 struct buffer_data *nldata; 848 849 p = xmalloc (len + 1); 850 if (p == NULL) 851 return -2; 852 *line = p; 853 854 nldata = data; 855 data = buf->data; 856 while (data != nldata) 857 { 858 struct buffer_data *next; 859 860 memcpy (p, data->bufp, data->size); 861 p += data->size; 862 next = data->next; 863 buf_free_datas (data, data); 864 data = next; 865 } 866 867 memcpy (p, data->bufp, finallen); 868 p[finallen] = '\0'; 869 870 data->size -= finallen + 1; 871 data->bufp = nl + 1; 872 buf->data = data; 873 874 if (lenp != NULL) 875 *lenp = len; 876 877 return 0; 878 } 879 880 /* Read more data until we get a newline or MAX characters. */ 881 predicted_len = 0; 882 while (1) 883 { 884 int status; 885 size_t size, nbytes; 886 char *mem; 887 888 if (buf->data == NULL 889 || (buf->last->bufp + buf->last->size 890 == buf->last->text + BUFFER_DATA_SIZE)) 891 { 892 data = get_buffer_data (); 893 if (data == NULL) 894 { 895 (*buf->memory_error) (buf); 896 return -2; 897 } 898 899 if (buf->data == NULL) 900 buf->data = data; 901 else 902 buf->last->next = data; 903 data->next = NULL; 904 buf->last = data; 905 906 data->bufp = data->text; 907 data->size = 0; 908 } 909 910 mem = buf->last->bufp + buf->last->size; 911 size = (buf->last->text + BUFFER_DATA_SIZE) - mem; 912 913 /* We need to read at least 1 byte. We can handle up to 914 SIZE bytes. This will only be efficient if the 915 underlying communication stream does its own buffering, 916 or is clever about getting more than 1 byte at a time. */ 917 status = (*buf->input) (buf->closure, mem, 1, size, &nbytes); 918 if (status != 0) 919 return status; 920 921 predicted_len += nbytes; 922 buf->last->size += nbytes; 923 924 /* Optimize slightly to avoid an unnecessary call to memchr. */ 925 if (nbytes == 1) 926 { 927 if (*mem == '\012') 928 break; 929 } 930 else 931 { 932 if (memchr (mem, '\012', nbytes) != NULL) 933 break; 934 } 935 if (xsum (len, predicted_len) >= max) return -2; 936 } 937 } 938 } 939 940 941 942 /* 943 * Extract data from the input buffer BUF. This will read up to WANT 944 * bytes from the buffer. It will set *RETDATA to point at the bytes, 945 * and set *GOT to the number of bytes to be found there. Any buffer 946 * call which uses BUF may change the contents of the buffer at *DATA, 947 * so the data should be fully processed before any further calls are 948 * made. This returns 0 on success, or -1 on end of file, or -2 if 949 * out of memory, or an error code. 950 */ 951 int 952 buf_read_data (struct buffer *buf, size_t want, char **retdata, size_t *got) 953 { 954 assert (buf->input != NULL); 955 956 while (buf->data != NULL && buf->data->size == 0) 957 { 958 struct buffer_data *next; 959 960 next = buf->data->next; 961 buf_free_datas (buf->data, buf->data); 962 buf->data = next; 963 if (next == NULL) 964 buf->last = NULL; 965 } 966 967 if (buf->data == NULL) 968 { 969 struct buffer_data *data; 970 int status; 971 size_t get, nbytes; 972 973 data = get_buffer_data (); 974 if (data == NULL) 975 { 976 (*buf->memory_error) (buf); 977 return -2; 978 } 979 980 buf->data = data; 981 buf->last = data; 982 data->next = NULL; 983 data->bufp = data->text; 984 data->size = 0; 985 986 if (want < BUFFER_DATA_SIZE) 987 get = want; 988 else 989 get = BUFFER_DATA_SIZE; 990 status = (*buf->input) (buf->closure, data->bufp, get, 991 BUFFER_DATA_SIZE, &nbytes); 992 if (status != 0) 993 return status; 994 995 data->size = nbytes; 996 } 997 998 *retdata = buf->data->bufp; 999 if (want < buf->data->size) 1000 { 1001 *got = want; 1002 buf->data->size -= want; 1003 buf->data->bufp += want; 1004 } 1005 else 1006 { 1007 *got = buf->data->size; 1008 buf->data->size = 0; 1009 } 1010 1011 return 0; 1012 } 1013 1014 1015 1016 /* 1017 * Copy lines from an input buffer to an output buffer. 1018 * This copies all complete lines (characters up to a 1019 * newline) from INBUF to OUTBUF. Each line in OUTBUF is preceded by the 1020 * character COMMAND and a space. 1021 */ 1022 void 1023 buf_copy_lines (struct buffer *outbuf, struct buffer *inbuf, int command) 1024 { 1025 while (1) 1026 { 1027 struct buffer_data *data; 1028 struct buffer_data *nldata; 1029 char *nl; 1030 int len; 1031 1032 /* See if there is a newline in INBUF. */ 1033 nldata = NULL; 1034 nl = NULL; 1035 for (data = inbuf->data; data != NULL; data = data->next) 1036 { 1037 nl = memchr (data->bufp, '\n', data->size); 1038 if (nl != NULL) 1039 { 1040 nldata = data; 1041 break; 1042 } 1043 } 1044 1045 if (nldata == NULL) 1046 { 1047 /* There are no more lines in INBUF. */ 1048 return; 1049 } 1050 1051 /* Put in the command. */ 1052 buf_append_char (outbuf, command); 1053 buf_append_char (outbuf, ' '); 1054 1055 if (inbuf->data != nldata) 1056 { 1057 /* 1058 * Simply move over all the buffers up to the one containing 1059 * the newline. 1060 */ 1061 for (data = inbuf->data; data->next != nldata; data = data->next); 1062 data->next = NULL; 1063 buf_append_data (outbuf, inbuf->data, data); 1064 inbuf->data = nldata; 1065 } 1066 1067 /* 1068 * If the newline is at the very end of the buffer, just move 1069 * the buffer onto OUTBUF. Otherwise we must copy the data. 1070 */ 1071 len = nl + 1 - nldata->bufp; 1072 if (len == nldata->size) 1073 { 1074 inbuf->data = nldata->next; 1075 if (inbuf->data == NULL) 1076 inbuf->last = NULL; 1077 1078 nldata->next = NULL; 1079 buf_append_data (outbuf, nldata, nldata); 1080 } 1081 else 1082 { 1083 buf_output (outbuf, nldata->bufp, len); 1084 nldata->bufp += len; 1085 nldata->size -= len; 1086 } 1087 } 1088 } 1089 1090 1091 1092 /* 1093 * Copy counted data from one buffer to another. The count is an 1094 * integer, host size, host byte order (it is only used across a 1095 * pipe). If there is enough data, it should be moved over. If there 1096 * is not enough data, it should remain on the original buffer. A 1097 * negative count is a special case. if one is seen, *SPECIAL is set 1098 * to the (negative) count value and no additional data is gathered 1099 * from the buffer; normally *SPECIAL is set to 0. This function 1100 * returns the number of bytes it needs to see in order to actually 1101 * copy something over. 1102 */ 1103 int 1104 buf_copy_counted (struct buffer *outbuf, struct buffer *inbuf, int *special) 1105 { 1106 *special = 0; 1107 1108 while (1) 1109 { 1110 struct buffer_data *data; 1111 int need; 1112 union 1113 { 1114 char intbuf[sizeof (int)]; 1115 int i; 1116 } u; 1117 char *intp; 1118 int count; 1119 struct buffer_data *start; 1120 int startoff; 1121 struct buffer_data *stop; 1122 int stopwant; 1123 1124 /* See if we have enough bytes to figure out the count. */ 1125 need = sizeof (int); 1126 intp = u.intbuf; 1127 for (data = inbuf->data; data != NULL; data = data->next) 1128 { 1129 if (data->size >= need) 1130 { 1131 memcpy (intp, data->bufp, need); 1132 break; 1133 } 1134 memcpy (intp, data->bufp, data->size); 1135 intp += data->size; 1136 need -= data->size; 1137 } 1138 if (data == NULL) 1139 { 1140 /* We don't have enough bytes to form an integer. */ 1141 return need; 1142 } 1143 1144 count = u.i; 1145 start = data; 1146 startoff = need; 1147 1148 if (count < 0) 1149 { 1150 /* A negative COUNT is a special case meaning that we 1151 don't need any further information. */ 1152 stop = start; 1153 stopwant = 0; 1154 } 1155 else 1156 { 1157 /* 1158 * We have an integer in COUNT. We have gotten all the 1159 * data from INBUF in all buffers before START, and we 1160 * have gotten STARTOFF bytes from START. See if we have 1161 * enough bytes remaining in INBUF. 1162 */ 1163 need = count - (start->size - startoff); 1164 if (need <= 0) 1165 { 1166 stop = start; 1167 stopwant = count; 1168 } 1169 else 1170 { 1171 for (data = start->next; data != NULL; data = data->next) 1172 { 1173 if (need <= data->size) 1174 break; 1175 need -= data->size; 1176 } 1177 if (data == NULL) 1178 { 1179 /* We don't have enough bytes. */ 1180 return need; 1181 } 1182 stop = data; 1183 stopwant = need; 1184 } 1185 } 1186 1187 /* 1188 * We have enough bytes. Free any buffers in INBUF before 1189 * START, and remove STARTOFF bytes from START, so that we can 1190 * forget about STARTOFF. 1191 */ 1192 start->bufp += startoff; 1193 start->size -= startoff; 1194 1195 if (start->size == 0) 1196 start = start->next; 1197 1198 if (stop->size == stopwant) 1199 { 1200 stop = stop->next; 1201 stopwant = 0; 1202 } 1203 1204 while (inbuf->data != start) 1205 { 1206 data = inbuf->data; 1207 inbuf->data = data->next; 1208 buf_free_datas (data, data); 1209 } 1210 1211 /* If COUNT is negative, set *SPECIAL and get out now. */ 1212 if (count < 0) 1213 { 1214 *special = count; 1215 return 0; 1216 } 1217 1218 /* 1219 * We want to copy over the bytes from START through STOP. We 1220 * only want STOPWANT bytes from STOP. 1221 */ 1222 1223 if (start != stop) 1224 { 1225 /* Attach the buffers from START through STOP to OUTBUF. */ 1226 for (data = start; data->next != stop; data = data->next); 1227 inbuf->data = stop; 1228 data->next = NULL; 1229 buf_append_data (outbuf, start, data); 1230 } 1231 1232 if (stopwant > 0) 1233 { 1234 buf_output (outbuf, stop->bufp, stopwant); 1235 stop->bufp += stopwant; 1236 stop->size -= stopwant; 1237 } 1238 } 1239 1240 /*NOTREACHED*/ 1241 } 1242 1243 1244 1245 int 1246 buf_get_fd (struct buffer *buf) 1247 { 1248 if (buf->get_fd) 1249 return (*buf->get_fd) (buf->closure); 1250 return -1; 1251 } 1252 1253 1254 1255 /* Shut down a buffer. This returns 0 on success, or an errno code. */ 1256 int 1257 buf_shutdown (struct buffer *buf) 1258 { 1259 if (buf->shutdown) return (*buf->shutdown) (buf); 1260 return 0; 1261 } 1262 1263 1264 1265 /* Certain types of communication input and output data in packets, 1266 where each packet is translated in some fashion. The packetizing 1267 buffer type supports that, given a buffer which handles lower level 1268 I/O and a routine to translate the data in a packet. 1269 1270 This code uses two bytes for the size of a packet, so packets are 1271 restricted to 65536 bytes in total. 1272 1273 The translation functions should just translate; they may not 1274 significantly increase or decrease the amount of data. The actual 1275 size of the initial data is part of the translated data. The 1276 output translation routine may add up to PACKET_SLOP additional 1277 bytes, and the input translation routine should shrink the data 1278 correspondingly. */ 1279 1280 # define PACKET_SLOP (100) 1281 1282 /* This structure is the closure field of a packetizing buffer. */ 1283 1284 struct packetizing_buffer 1285 { 1286 /* The underlying buffer. */ 1287 struct buffer *buf; 1288 /* The input translation function. Exactly one of inpfn and outfn 1289 will be NULL. The input translation function should 1290 untranslate the data in INPUT, storing the result in OUTPUT. 1291 SIZE is the amount of data in INPUT, and is also the size of 1292 OUTPUT. This should return 0 on success, or an errno code. */ 1293 int (*inpfn) (void *fnclosure, const char *input, char *output, 1294 size_t size); 1295 /* The output translation function. This should translate the 1296 data in INPUT, storing the result in OUTPUT. The first two 1297 bytes in INPUT will be the size of the data, and so will SIZE. 1298 This should set *TRANSLATED to the amount of translated data in 1299 OUTPUT. OUTPUT is large enough to hold SIZE + PACKET_SLOP 1300 bytes. This should return 0 on success, or an errno code. */ 1301 int (*outfn) (void *fnclosure, const char *input, char *output, 1302 size_t size, size_t *translated); 1303 /* A closure for the translation function. */ 1304 void *fnclosure; 1305 /* For an input buffer, we may have to buffer up data here. */ 1306 /* This is non-zero if the buffered data has been translated. 1307 Otherwise, the buffered data has not been translated, and starts 1308 with the two byte packet size. */ 1309 bool translated; 1310 /* The amount of buffered data. */ 1311 size_t holdsize; 1312 /* The buffer allocated to hold the data. */ 1313 char *holdbuf; 1314 /* The size of holdbuf. */ 1315 size_t holdbufsize; 1316 /* If translated is set, we need another data pointer to track 1317 where we are in holdbuf. If translated is clear, then this 1318 pointer is not used. */ 1319 char *holddata; 1320 }; 1321 1322 1323 1324 static int packetizing_buffer_input (void *, char *, size_t, size_t, size_t *); 1325 static int packetizing_buffer_output (void *, const char *, size_t, size_t *); 1326 static int packetizing_buffer_flush (void *); 1327 static int packetizing_buffer_block (void *, bool); 1328 static int packetizing_buffer_get_fd (void *); 1329 static int packetizing_buffer_shutdown (struct buffer *); 1330 1331 1332 1333 /* Create a packetizing buffer. */ 1334 struct buffer * 1335 packetizing_buffer_initialize (struct buffer *buf, 1336 int (*inpfn) (void *, const char *, char *, 1337 size_t), 1338 int (*outfn) (void *, const char *, char *, 1339 size_t, size_t *), 1340 void *fnclosure, 1341 void (*memory) (struct buffer *)) 1342 { 1343 struct packetizing_buffer *pb; 1344 1345 pb = xmalloc (sizeof *pb); 1346 memset (pb, 0, sizeof *pb); 1347 1348 pb->buf = buf; 1349 pb->inpfn = inpfn; 1350 pb->outfn = outfn; 1351 pb->fnclosure = fnclosure; 1352 1353 if (inpfn != NULL) 1354 { 1355 /* Add PACKET_SLOP to handle larger translated packets, and 1356 add 2 for the count. This buffer is increased if 1357 necessary. */ 1358 pb->holdbufsize = BUFFER_DATA_SIZE + PACKET_SLOP + 2; 1359 pb->holdbuf = xmalloc (pb->holdbufsize); 1360 } 1361 1362 return buf_initialize (inpfn != NULL ? packetizing_buffer_input : NULL, 1363 inpfn != NULL ? NULL : packetizing_buffer_output, 1364 inpfn != NULL ? NULL : packetizing_buffer_flush, 1365 packetizing_buffer_block, 1366 packetizing_buffer_get_fd, 1367 packetizing_buffer_shutdown, 1368 memory, 1369 pb); 1370 } 1371 1372 1373 1374 /* Input data from a packetizing buffer. */ 1375 static int 1376 packetizing_buffer_input (void *closure, char *data, size_t need, size_t size, 1377 size_t *got) 1378 { 1379 struct packetizing_buffer *pb = closure; 1380 1381 *got = 0; 1382 1383 if (pb->holdsize > 0 && pb->translated) 1384 { 1385 size_t copy; 1386 1387 copy = pb->holdsize; 1388 1389 if (copy > size) 1390 { 1391 memcpy (data, pb->holddata, size); 1392 pb->holdsize -= size; 1393 pb->holddata += size; 1394 *got = size; 1395 return 0; 1396 } 1397 1398 memcpy (data, pb->holddata, copy); 1399 pb->holdsize = 0; 1400 pb->translated = false; 1401 1402 data += copy; 1403 need -= copy; 1404 size -= copy; 1405 *got = copy; 1406 } 1407 1408 while (need > 0 || *got == 0) 1409 { 1410 int status; 1411 size_t get, nread, count, tcount; 1412 char *bytes; 1413 static char *stackoutbuf = NULL; 1414 char *inbuf, *outbuf; 1415 1416 if (!stackoutbuf) 1417 stackoutbuf = xmalloc (BUFFER_DATA_SIZE + PACKET_SLOP); 1418 1419 /* If we don't already have the two byte count, get it. */ 1420 if (pb->holdsize < 2) 1421 { 1422 get = 2 - pb->holdsize; 1423 status = buf_read_data (pb->buf, get, &bytes, &nread); 1424 if (status != 0) 1425 { 1426 /* buf_read_data can return -2, but a buffer input 1427 function is only supposed to return -1, 0, or an 1428 error code. */ 1429 if (status == -2) 1430 status = ENOMEM; 1431 return status; 1432 } 1433 1434 if (nread == 0) 1435 { 1436 /* The buffer is in nonblocking mode, and we didn't 1437 manage to read anything. */ 1438 return 0; 1439 } 1440 1441 if (get == 1) 1442 pb->holdbuf[1] = bytes[0]; 1443 else 1444 { 1445 pb->holdbuf[0] = bytes[0]; 1446 if (nread < 2) 1447 { 1448 /* We only got one byte, but we needed two. Stash 1449 the byte we got, and try again. */ 1450 pb->holdsize = 1; 1451 continue; 1452 } 1453 pb->holdbuf[1] = bytes[1]; 1454 } 1455 pb->holdsize = 2; 1456 } 1457 1458 /* Read the packet. */ 1459 1460 count = (((pb->holdbuf[0] & 0xff) << 8) 1461 + (pb->holdbuf[1] & 0xff)); 1462 1463 if (count + 2 > pb->holdbufsize) 1464 { 1465 char *n; 1466 1467 /* We didn't allocate enough space in the initialize 1468 function. */ 1469 1470 n = xrealloc (pb->holdbuf, count + 2); 1471 if (n == NULL) 1472 { 1473 (*pb->buf->memory_error) (pb->buf); 1474 return ENOMEM; 1475 } 1476 pb->holdbuf = n; 1477 pb->holdbufsize = count + 2; 1478 } 1479 1480 get = count - (pb->holdsize - 2); 1481 1482 status = buf_read_data (pb->buf, get, &bytes, &nread); 1483 if (status != 0) 1484 { 1485 /* buf_read_data can return -2, but a buffer input 1486 function is only supposed to return -1, 0, or an error 1487 code. */ 1488 if (status == -2) 1489 status = ENOMEM; 1490 return status; 1491 } 1492 1493 if (nread == 0) 1494 { 1495 /* We did not get any data. Presumably the buffer is in 1496 nonblocking mode. */ 1497 return 0; 1498 } 1499 1500 if (nread < get) 1501 { 1502 /* We did not get all the data we need to fill the packet. 1503 buf_read_data does not promise to return all the bytes 1504 requested, so we must try again. */ 1505 memcpy (pb->holdbuf + pb->holdsize, bytes, nread); 1506 pb->holdsize += nread; 1507 continue; 1508 } 1509 1510 /* We have a complete untranslated packet of COUNT bytes. */ 1511 1512 if (pb->holdsize == 2) 1513 { 1514 /* We just read the entire packet (the 2 bytes in 1515 PB->HOLDBUF are the size). Save a memcpy by 1516 translating directly from BYTES. */ 1517 inbuf = bytes; 1518 } 1519 else 1520 { 1521 /* We already had a partial packet in PB->HOLDBUF. We 1522 need to copy the new data over to make the input 1523 contiguous. */ 1524 memcpy (pb->holdbuf + pb->holdsize, bytes, nread); 1525 inbuf = pb->holdbuf + 2; 1526 } 1527 1528 if (count <= BUFFER_DATA_SIZE + PACKET_SLOP) 1529 outbuf = stackoutbuf; 1530 else 1531 { 1532 outbuf = xmalloc (count); 1533 if (outbuf == NULL) 1534 { 1535 (*pb->buf->memory_error) (pb->buf); 1536 return ENOMEM; 1537 } 1538 } 1539 1540 status = (*pb->inpfn) (pb->fnclosure, inbuf, outbuf, count); 1541 if (status != 0) 1542 return status; 1543 1544 /* The first two bytes in the translated buffer are the real 1545 length of the translated data. */ 1546 tcount = ((outbuf[0] & 0xff) << 8) + (outbuf[1] & 0xff); 1547 1548 if (tcount > count) 1549 error (1, 0, "Input translation failure"); 1550 1551 if (tcount > size) 1552 { 1553 /* We have more data than the caller has provided space 1554 for. We need to save some of it for the next call. */ 1555 1556 memcpy (data, outbuf + 2, size); 1557 *got += size; 1558 1559 pb->holdsize = tcount - size; 1560 memcpy (pb->holdbuf, outbuf + 2 + size, tcount - size); 1561 pb->holddata = pb->holdbuf; 1562 pb->translated = true; 1563 1564 if (outbuf != stackoutbuf) 1565 free (outbuf); 1566 1567 return 0; 1568 } 1569 1570 memcpy (data, outbuf + 2, tcount); 1571 1572 if (outbuf != stackoutbuf) 1573 free (outbuf); 1574 1575 pb->holdsize = 0; 1576 1577 data += tcount; 1578 need -= tcount; 1579 size -= tcount; 1580 *got += tcount; 1581 } 1582 1583 return 0; 1584 } 1585 1586 1587 1588 /* Output data to a packetizing buffer. */ 1589 static int 1590 packetizing_buffer_output (void *closure, const char *data, size_t have, 1591 size_t *wrote) 1592 { 1593 struct packetizing_buffer *pb = closure; 1594 static char *inbuf = NULL; /* These two buffers are static so that they 1595 * depend on the size of BUFFER_DATA_SIZE yet 1596 * still only be allocated once per run. 1597 */ 1598 static char *stack_outbuf = NULL; 1599 struct buffer_data *outdata = NULL; /* Initialize to silence -Wall. Dumb. 1600 */ 1601 char *outbuf; 1602 size_t size, translated; 1603 int status; 1604 1605 /* It would be easy to xmalloc a buffer, but I don't think this 1606 case can ever arise. */ 1607 assert (have <= BUFFER_DATA_SIZE); 1608 1609 if (!inbuf) 1610 { 1611 inbuf = xmalloc (BUFFER_DATA_SIZE + 2); 1612 stack_outbuf = xmalloc (BUFFER_DATA_SIZE + PACKET_SLOP + 4); 1613 } 1614 1615 inbuf[0] = (have >> 8) & 0xff; 1616 inbuf[1] = have & 0xff; 1617 memcpy (inbuf + 2, data, have); 1618 1619 size = have + 2; 1620 1621 /* The output function is permitted to add up to PACKET_SLOP 1622 bytes, and we need 2 bytes for the size of the translated data. 1623 If we can guarantee that the result will fit in a buffer_data, 1624 we translate directly into one to avoid a memcpy in buf_output. */ 1625 if (size + PACKET_SLOP + 2 > BUFFER_DATA_SIZE) 1626 outbuf = stack_outbuf; 1627 else 1628 { 1629 outdata = get_buffer_data (); 1630 if (outdata == NULL) 1631 { 1632 (*pb->buf->memory_error) (pb->buf); 1633 return ENOMEM; 1634 } 1635 1636 outdata->next = NULL; 1637 outdata->bufp = outdata->text; 1638 1639 outbuf = outdata->text; 1640 } 1641 1642 status = (*pb->outfn) (pb->fnclosure, inbuf, outbuf + 2, size, 1643 &translated); 1644 if (status != 0) 1645 return status; 1646 1647 /* The output function is permitted to add up to PACKET_SLOP 1648 bytes. */ 1649 assert (translated <= size + PACKET_SLOP); 1650 1651 outbuf[0] = (translated >> 8) & 0xff; 1652 outbuf[1] = translated & 0xff; 1653 1654 if (outbuf == stack_outbuf) 1655 buf_output (pb->buf, outbuf, translated + 2); 1656 else 1657 { 1658 outdata->size = translated + 2; 1659 buf_append_data (pb->buf, outdata, outdata); 1660 } 1661 1662 *wrote = have; 1663 1664 /* We will only be here because buf_send_output was called on the 1665 packetizing buffer. That means that we should now call 1666 buf_send_output on the underlying buffer. */ 1667 return buf_send_output (pb->buf); 1668 } 1669 1670 1671 1672 /* Flush data to a packetizing buffer. */ 1673 static int 1674 packetizing_buffer_flush (void *closure) 1675 { 1676 struct packetizing_buffer *pb = closure; 1677 1678 /* Flush the underlying buffer. Note that if the original call to 1679 buf_flush passed 1 for the BLOCK argument, then the buffer will 1680 already have been set into blocking mode, so we should always 1681 pass 0 here. */ 1682 return buf_flush (pb->buf, 0); 1683 } 1684 1685 1686 1687 /* The block routine for a packetizing buffer. */ 1688 static int 1689 packetizing_buffer_block (void *closure, bool block) 1690 { 1691 struct packetizing_buffer *pb = closure; 1692 1693 if (block) 1694 return set_block (pb->buf); 1695 else 1696 return set_nonblock (pb->buf); 1697 } 1698 1699 1700 1701 /* Return the file descriptor underlying any child buffers. */ 1702 static int 1703 packetizing_buffer_get_fd (void *closure) 1704 { 1705 struct packetizing_buffer *cb = closure; 1706 return buf_get_fd (cb->buf); 1707 } 1708 1709 1710 1711 /* Shut down a packetizing buffer. */ 1712 static int 1713 packetizing_buffer_shutdown (struct buffer *buf) 1714 { 1715 struct packetizing_buffer *pb = buf->closure; 1716 1717 return buf_shutdown (pb->buf); 1718 } 1719 1720 1721 1722 /* All server communication goes through buffer structures. Most of 1723 the buffers are built on top of a file descriptor. This structure 1724 is used as the closure field in a buffer. */ 1725 1726 struct fd_buffer 1727 { 1728 /* The file descriptor. */ 1729 int fd; 1730 /* Nonzero if the file descriptor is in blocking mode. */ 1731 int blocking; 1732 /* The child process id when fd is a pipe. */ 1733 pid_t child_pid; 1734 /* The connection info, when fd is a pipe to a server. */ 1735 cvsroot_t *root; 1736 }; 1737 1738 static int fd_buffer_input (void *, char *, size_t, size_t, size_t *); 1739 static int fd_buffer_output (void *, const char *, size_t, size_t *); 1740 static int fd_buffer_flush (void *); 1741 static int fd_buffer_block (void *, bool); 1742 static int fd_buffer_get_fd (void *); 1743 static int fd_buffer_shutdown (struct buffer *); 1744 1745 /* Initialize a buffer built on a file descriptor. FD is the file 1746 descriptor. INPUT is nonzero if this is for input, zero if this is 1747 for output. MEMORY is the function to call when a memory error 1748 occurs. */ 1749 1750 struct buffer * 1751 fd_buffer_initialize (int fd, pid_t child_pid, cvsroot_t *root, bool input, 1752 void (*memory) (struct buffer *)) 1753 { 1754 struct fd_buffer *n; 1755 1756 n = xmalloc (sizeof *n); 1757 n->fd = fd; 1758 n->child_pid = child_pid; 1759 n->root = root; 1760 fd_buffer_block (n, true); 1761 return buf_initialize (input ? fd_buffer_input : NULL, 1762 input ? NULL : fd_buffer_output, 1763 input ? NULL : fd_buffer_flush, 1764 fd_buffer_block, fd_buffer_get_fd, 1765 fd_buffer_shutdown, 1766 memory, 1767 n); 1768 } 1769 1770 1771 1772 /* The buffer input function for a buffer built on a file descriptor. 1773 * 1774 * In non-blocking mode, this function will read as many bytes as it can in a 1775 * single try, up to SIZE bytes, and return. 1776 * 1777 * In blocking mode with NEED > 0, this function will read as many bytes as it 1778 * can but will not return until it has read at least NEED bytes. 1779 * 1780 * In blocking mode with NEED == 0, this function will block until it can read 1781 * either at least one byte or EOF, then read as many bytes as are available 1782 * and return. At the very least, compress_buffer_shutdown depends on this 1783 * behavior to read EOF and can loop indefinitely without it. 1784 * 1785 * ASSUMPTIONS 1786 * NEED <= SIZE. 1787 * 1788 * INPUTS 1789 * closure Our FD_BUFFER struct. 1790 * data The start of our input buffer. 1791 * need How many bytes our caller needs. 1792 * size How many bytes are available in DATA. 1793 * got Where to store the number of bytes read. 1794 * 1795 * OUTPUTS 1796 * data Filled with bytes read. 1797 * *got Number of bytes actually read into DATA. 1798 * 1799 * RETURNS 1800 * errno On error. 1801 * -1 On EOF. 1802 * 0 Otherwise. 1803 * 1804 * ERRORS 1805 * This function can return an error if fd_buffer_block(), or the system 1806 * read() or select() calls do. 1807 */ 1808 static int 1809 fd_buffer_input (void *closure, char *data, size_t need, size_t size, 1810 size_t *got) 1811 { 1812 struct fd_buffer *fb = closure; 1813 int nbytes; 1814 1815 assert (need <= size); 1816 1817 *got = 0; 1818 1819 if (fb->blocking) 1820 { 1821 int status; 1822 fd_set readfds; 1823 1824 /* Set non-block. */ 1825 status = fd_buffer_block (fb, false); 1826 if (status != 0) return status; 1827 1828 FD_ZERO (&readfds); 1829 FD_SET (fb->fd, &readfds); 1830 do 1831 { 1832 int numfds; 1833 1834 do { 1835 /* This used to select on exceptions too, but as far 1836 as I know there was never any reason to do that and 1837 SCO doesn't let you select on exceptions on pipes. */ 1838 numfds = fd_select (fb->fd + 1, &readfds, NULL, NULL, NULL); 1839 if (numfds < 0 && errno != EINTR) 1840 { 1841 status = errno; 1842 goto block_done; 1843 } 1844 } while (numfds < 0); 1845 1846 nbytes = read (fb->fd, data + *got, size - *got); 1847 1848 if (nbytes == 0) 1849 { 1850 /* End of file. This assumes that we are using POSIX or BSD 1851 style nonblocking I/O. On System V we will get a zero 1852 return if there is no data, even when not at EOF. */ 1853 if (*got) 1854 { 1855 /* We already read some data, so return no error, counting 1856 * on the fact that we will read EOF again next time. 1857 */ 1858 status = 0; 1859 break; 1860 } 1861 else 1862 { 1863 /* Return EOF. */ 1864 status = -1; 1865 break; 1866 } 1867 } 1868 1869 if (nbytes < 0) 1870 { 1871 /* Some error occurred. */ 1872 if (!blocking_error (errno)) 1873 { 1874 status = errno; 1875 break; 1876 } 1877 /* else Everything's fine, we just didn't get any data. */ 1878 } 1879 1880 *got += nbytes; 1881 } while (*got < need); 1882 1883 block_done: 1884 if (status == 0 || status == -1) 1885 { 1886 int newstatus; 1887 1888 /* OK or EOF - Reset block. */ 1889 newstatus = fd_buffer_block (fb, true); 1890 if (newstatus) status = newstatus; 1891 } 1892 return status; 1893 } 1894 1895 /* The above will always return. Handle non-blocking read. */ 1896 nbytes = read (fb->fd, data, size); 1897 1898 if (nbytes > 0) 1899 { 1900 *got = nbytes; 1901 return 0; 1902 } 1903 1904 if (nbytes == 0) 1905 /* End of file. This assumes that we are using POSIX or BSD 1906 style nonblocking I/O. On System V we will get a zero 1907 return if there is no data, even when not at EOF. */ 1908 return -1; 1909 1910 /* Some error occurred. */ 1911 if (blocking_error (errno)) 1912 /* Everything's fine, we just didn't get any data. */ 1913 return 0; 1914 1915 return errno; 1916 } 1917 1918 1919 1920 /* The buffer output function for a buffer built on a file descriptor. */ 1921 1922 static int 1923 fd_buffer_output (void *closure, const char *data, size_t have, size_t *wrote) 1924 { 1925 struct fd_buffer *fd = closure; 1926 1927 *wrote = 0; 1928 1929 while (have > 0) 1930 { 1931 int nbytes; 1932 1933 nbytes = write (fd->fd, data, have); 1934 1935 if (nbytes <= 0) 1936 { 1937 if (! fd->blocking 1938 && (nbytes == 0 || blocking_error (errno))) 1939 { 1940 /* A nonblocking write failed to write any data. Just 1941 return. */ 1942 return 0; 1943 } 1944 1945 /* Some sort of error occurred. */ 1946 1947 if (nbytes == 0) 1948 return EIO; 1949 1950 return errno; 1951 } 1952 1953 *wrote += nbytes; 1954 data += nbytes; 1955 have -= nbytes; 1956 } 1957 1958 return 0; 1959 } 1960 1961 1962 1963 /* The buffer flush function for a buffer built on a file descriptor. */ 1964 static int 1965 fd_buffer_flush (void *closure) 1966 { 1967 /* We don't need to do anything here. Our fd doesn't have its own buffer 1968 * and syncing won't do anything but slow us down. 1969 * 1970 * struct fd_buffer *fb = closure; 1971 * 1972 * if (fsync (fb->fd) < 0 && errno != EROFS && errno != EINVAL) 1973 * return errno; 1974 */ 1975 return 0; 1976 } 1977 1978 1979 1980 static struct stat devnull; 1981 static int devnull_set = -1; 1982 1983 /* The buffer block function for a buffer built on a file descriptor. */ 1984 static int 1985 fd_buffer_block (void *closure, bool block) 1986 { 1987 struct fd_buffer *fb = closure; 1988 # if defined (F_GETFL) && defined (O_NONBLOCK) && defined (F_SETFL) 1989 int flags; 1990 1991 flags = fcntl (fb->fd, F_GETFL, 0); 1992 if (flags < 0) 1993 return errno; 1994 1995 if (block) 1996 flags &= ~O_NONBLOCK; 1997 else 1998 flags |= O_NONBLOCK; 1999 2000 if (fcntl (fb->fd, F_SETFL, flags) < 0) 2001 { 2002 /* 2003 * BSD returns ENODEV when we try to set block/nonblock on /dev/null. 2004 * BSDI returns ENOTTY when we try to set block/nonblock on /dev/null. 2005 */ 2006 struct stat sb; 2007 int save_errno = errno; 2008 bool isdevnull = false; 2009 2010 if (devnull_set == -1) 2011 devnull_set = stat ("/dev/null", &devnull); 2012 2013 if (devnull_set >= 0) 2014 /* Equivalent to /dev/null ? */ 2015 isdevnull = (fstat (fb->fd, &sb) >= 0 2016 && sb.st_dev == devnull.st_dev 2017 && sb.st_ino == devnull.st_ino 2018 && sb.st_mode == devnull.st_mode 2019 && sb.st_uid == devnull.st_uid 2020 && sb.st_gid == devnull.st_gid 2021 && sb.st_size == devnull.st_size 2022 && sb.st_blocks == devnull.st_blocks 2023 && sb.st_blksize == devnull.st_blksize); 2024 if (isdevnull) 2025 errno = 0; 2026 else 2027 { 2028 errno = save_errno; 2029 return errno; 2030 } 2031 } 2032 # endif /* F_GETFL && O_NONBLOCK && F_SETFL */ 2033 2034 fb->blocking = block; 2035 2036 return 0; 2037 } 2038 2039 2040 2041 static int 2042 fd_buffer_get_fd (void *closure) 2043 { 2044 struct fd_buffer *fb = closure; 2045 return fb->fd; 2046 } 2047 2048 2049 2050 /* The buffer shutdown function for a buffer built on a file descriptor. 2051 * 2052 * This function disposes of memory allocated for this buffer. 2053 */ 2054 static int 2055 fd_buffer_shutdown (struct buffer *buf) 2056 { 2057 struct fd_buffer *fb = buf->closure; 2058 struct stat s; 2059 bool closefd, statted; 2060 2061 /* Must be an open pipe, socket, or file. What could go wrong? */ 2062 if (fstat (fb->fd, &s) == -1) statted = false; 2063 else statted = true; 2064 /* Don't bother to try closing the FD if we couldn't stat it. This 2065 * probably won't work. 2066 * 2067 * (buf_shutdown() on some of the server/child communication pipes is 2068 * getting EBADF on both the fstat and the close. I'm not sure why - 2069 * perhaps they were alredy closed somehow? 2070 */ 2071 closefd = statted; 2072 2073 /* Flush the buffer if possible. */ 2074 if (buf->flush) 2075 { 2076 buf_flush (buf, 1); 2077 buf->flush = NULL; 2078 } 2079 2080 if (buf->input) 2081 { 2082 /* There used to be a check here for unread data in the buffer of 2083 * the pipe, but it was deemed unnecessary and possibly dangerous. In 2084 * some sense it could be second-guessing the caller who requested it 2085 * closed, as well. 2086 */ 2087 2088 /* FIXME: 2089 * 2090 * This mess of #ifdefs is hard to read. There must be some relation between 2091 * the macros being checked which at least deserves comments - if 2092 * SHUTDOWN_SERVER, NO_SOCKET_TO_FD, & START_RSH_WITH_POPEN_RW were completely 2093 * independant, then the next few lines could easily refuse to compile. 2094 * 2095 * The note below about START_RSH_WITH_POPEN_RW never being set when 2096 * SHUTDOWN_SERVER is defined means that this code would always break on 2097 * systems with SHUTDOWN_SERVER defined and thus the comment must now be 2098 * incorrect or the code was broken since the comment was written. 2099 */ 2100 # ifdef SHUTDOWN_SERVER 2101 if (fb->root && fb->root->method != server_method) 2102 # endif 2103 # ifndef NO_SOCKET_TO_FD 2104 { 2105 /* shutdown() sockets */ 2106 if (statted && S_ISSOCK (s.st_mode)) 2107 shutdown (fb->fd, 0); 2108 } 2109 # endif /* NO_SOCKET_TO_FD */ 2110 # ifdef START_RSH_WITH_POPEN_RW 2111 /* Can't be set with SHUTDOWN_SERVER defined */ 2112 /* FIXME: This is now certainly broken since pclose is defined by ANSI 2113 * C to accept a FILE * argument. The switch will need to happen at a 2114 * higher abstraction level to switch between initializing stdio & fd 2115 * buffers on systems that need this (or maybe an fd buffer that keeps 2116 * track of the FILE * could be used - I think flushing the stream 2117 * before beginning exclusive access via the FD is OK. 2118 */ 2119 else if (fb->root && pclose (fb->fd) == EOF) 2120 { 2121 error (1, errno, "closing connection to %s", 2122 fb->root->hostname); 2123 closefd = false; 2124 } 2125 # endif /* START_RSH_WITH_POPEN_RW */ 2126 2127 buf->input = NULL; 2128 } 2129 else if (buf->output) 2130 { 2131 # ifdef SHUTDOWN_SERVER 2132 /* FIXME: Should have a SHUTDOWN_SERVER_INPUT & 2133 * SHUTDOWN_SERVER_OUTPUT 2134 */ 2135 if (fb->root && fb->root->method == server_method) 2136 SHUTDOWN_SERVER (fb->fd); 2137 else 2138 # endif 2139 # ifndef NO_SOCKET_TO_FD 2140 /* shutdown() sockets */ 2141 if (statted && S_ISSOCK (s.st_mode)) 2142 shutdown (fb->fd, 1); 2143 # else 2144 { 2145 /* I'm not sure I like this empty block, but the alternative 2146 * is another nested NO_SOCKET_TO_FD switch as above. 2147 */ 2148 } 2149 # endif /* NO_SOCKET_TO_FD */ 2150 2151 buf->output = NULL; 2152 } 2153 2154 if (statted && closefd && close (fb->fd) == -1) 2155 { 2156 if (server_active) 2157 { 2158 /* Syslog this? */ 2159 } 2160 # ifdef CLIENT_SUPPORT 2161 else if (fb->root) 2162 error (1, errno, "closing down connection to %s", 2163 fb->root->hostname); 2164 /* EXITS */ 2165 # endif /* CLIENT_SUPPORT */ 2166 2167 error (0, errno, "closing down buffer"); 2168 } 2169 2170 /* If we were talking to a process, make sure it exited */ 2171 if (fb->child_pid) 2172 { 2173 int w; 2174 2175 do 2176 w = waitpid (fb->child_pid, NULL, 0); 2177 while (w == -1 && errno == EINTR); 2178 if (w == -1) 2179 error (1, errno, "waiting for process %d", fb->child_pid); 2180 } 2181 2182 free (buf->closure); 2183 buf->closure = NULL; 2184 2185 return 0; 2186 } 2187 #endif /* defined (SERVER_SUPPORT) || defined (CLIENT_SUPPORT) */ 2188