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