librb/src/linebuf.c

   1 /*
   2  *  ircd-ratbox: A slightly useful ircd.
   3  *  linebuf.c: Maintains linebuffers.
   4  *
   5  *  Copyright (C) 2001-2002 Adrian Chadd <adrian@creative.net.au>
   6  *  Copyright (C) 2002 Hybrid Development Team
   7  *  Copyright (C) 2002-2005 ircd-ratbox development team
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 2 of the License, or
  12  *  (at your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, write to the Free Software
  21  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
  22  *  USA
  23  *
  24  */
  25
  26 #include <librb_config.h>
  27 #include <rb_lib.h>
  28 #include <commio-int.h>
  29
  30 static rb_bh *rb_linebuf_heap;
  31
  32 static int bufline_count = 0;
  33
  34 /*
  35  * rb_linebuf_init
  36  *
  37  * Initialise the linebuf mechanism
  38  */
  39
  40 void
  41 rb_linebuf_init(size_t heap_size)
  42 {
  43         rb_linebuf_heap = rb_bh_create(sizeof(buf_line_t), heap_size, "librb_linebuf_heap");
  44 }
  45
  46 static buf_line_t *
  47 rb_linebuf_allocate(void)
  48 {
  49         buf_line_t *t;
  50         t = rb_bh_alloc(rb_linebuf_heap);
  51         return (t);
  52
  53 }
  54
  55 static void
  56 rb_linebuf_free(buf_line_t * p)
  57 {
  58         rb_bh_free(rb_linebuf_heap, p);
  59 }
  60
  61 /*
  62  * rb_linebuf_new_line
  63  *
  64  * Create a new line, and link it to the given linebuf.
  65  * It will be initially empty.
  66  */
  67 static buf_line_t *
  68 rb_linebuf_new_line(buf_head_t * bufhead)
  69 {
  70         buf_line_t *bufline;
  71
  72         bufline = rb_linebuf_allocate();
  73         if(bufline == NULL)
  74                 return NULL;
  75         ++bufline_count;
  76
  77         /* Stick it at the end of the buf list */
  78         rb_dlinkAddTailAlloc(bufline, &bufhead->list);
  79         bufline->refcount++;
  80
  81         /* And finally, update the allocated size */
  82         bufhead->alloclen++;
  83         bufhead->numlines++;
  84
  85         return bufline;
  86 }
  87
  88
  89 /*
  90  * rb_linebuf_done_line
  91  *
  92  * We've finished with the given line, so deallocate it
  93  */
  94 static void
  95 rb_linebuf_done_line(buf_head_t * bufhead, buf_line_t * bufline, rb_dlink_node *node)
  96 {
  97         /* Remove it from the linked list */
  98         rb_dlinkDestroy(node, &bufhead->list);
  99
 100         /* Update the allocated size */
 101         bufhead->alloclen--;
 102         bufhead->len -= bufline->len;
 103         lrb_assert(bufhead->len >= 0);
 104         bufhead->numlines--;
 105
 106         bufline->refcount--;
 107         lrb_assert(bufline->refcount >= 0);
 108
 109         if(bufline->refcount == 0)
 110         {
 111                 /* and finally, deallocate the buf */
 112                 --bufline_count;
 113                 lrb_assert(bufline_count >= 0);
 114                 rb_linebuf_free(bufline);
 115         }
 116 }
 117
 118
 119 /*
 120  * skip to end of line or the crlfs, return the number of bytes ..
 121  */
 122 static inline int
 123 rb_linebuf_skip_crlf(char *ch, int len)
 124 {
 125         int orig_len = len;
 126
 127         /* First, skip until the first non-CRLF */
 128         for(; len; len--, ch++)
 129         {
 130                 if(*ch == '\r')
 131                         break;
 132                 else if(*ch == '\n')
 133                         break;
 134         }
 135
 136         /* Then, skip until the last CRLF */
 137         for(; len; len--, ch++)
 138         {
 139                 if((*ch != '\r') && (*ch != '\n'))
 140                         break;
 141         }
 142         lrb_assert(orig_len > len);
 143         return (orig_len - len);
 144 }
 145
 146
 147
 148 /*
 149  * rb_linebuf_newbuf
 150  *
 151  * Initialise the new buffer
 152  */
 153 void
 154 rb_linebuf_newbuf(buf_head_t * bufhead)
 155 {
 156         /* not much to do right now :) */
 157         memset(bufhead, 0, sizeof(buf_head_t));
 158 }
 159
 160 /*
 161  * rb_linebuf_donebuf
 162  *
 163  * Flush all the lines associated with this buffer
 164  */
 165 void
 166 rb_linebuf_donebuf(buf_head_t * bufhead)
 167 {
 168         while(bufhead->list.head != NULL)
 169         {
 170                 rb_linebuf_done_line(bufhead, (buf_line_t *) bufhead->list.head->data,
 171                                      bufhead->list.head);
 172         }
 173 }
 174
 175 /*
 176  * rb_linebuf_copy_line
 177  *
 178  * Okay..this functions comments made absolutely no sense.
 179  *
 180  * Basically what we do is this.  Find the first chunk of text
 181  * and then scan for a CRLF.  If we didn't find it, but we didn't
 182  * overflow our buffer..we wait for some more data.
 183  * If we found a CRLF, we replace them with a \0 character.
 184  * If we overflowed, we copy the most our buffer can handle, terminate
 185  * it with a \0 and return.
 186  *
 187  * The return value is the amount of data we consumed.  This could
 188  * be different than the size of the linebuffer, as when we discard
 189  * the overflow, we don't want to process it again.
 190  *
 191  * This still sucks in my opinion, but it seems to work.
 192  *
 193  * -Aaron
 194  */
 195 static int
 196 rb_linebuf_copy_line(buf_head_t * bufhead, buf_line_t * bufline, char *data, int len)
 197 {
 198         int cpylen = 0;         /* how many bytes we've copied */
 199         char *ch = data;        /* Pointer to where we are in the read data */
 200         char *bufch = bufline->buf + bufline->len;
 201         int clen = 0;           /* how many bytes we've processed,
 202                                    and don't ever want to see again.. */
 203
 204         /* If its full or terminated, ignore it */
 205
 206         bufline->raw = 0;
 207         lrb_assert(bufline->len < BUF_DATA_SIZE);
 208         if(bufline->terminated == 1)
 209                 return 0;
 210
 211         clen = cpylen = rb_linebuf_skip_crlf(ch, len);
 212         if(clen == -1)
 213                 return -1;
 214
 215         /* This is the ~overflow case..This doesn't happen often.. */
 216         if(cpylen > (BUF_DATA_SIZE - bufline->len - 1))
 217         {
 218                 cpylen = BUF_DATA_SIZE - bufline->len - 1;
 219                 memcpy(bufch, ch, cpylen);
 220                 bufline->buf[BUF_DATA_SIZE - 1] = '\0';
 221                 bufch = bufline->buf + BUF_DATA_SIZE - 2;
 222                 while(cpylen && (*bufch == '\r' || *bufch == '\n'))
 223                 {
 224                         *bufch = '\0';
 225                         cpylen--;
 226                         bufch--;
 227                 }
 228                 bufline->terminated = 1;
 229                 bufline->len = BUF_DATA_SIZE - 1;
 230                 bufhead->len += BUF_DATA_SIZE - 1;
 231                 return clen;
 232         }
 233
 234         memcpy(bufch, ch, cpylen);
 235         bufch += cpylen;
 236         *bufch = '\0';
 237         bufch--;
 238
 239         if(*bufch != '\r' && *bufch != '\n')
 240         {
 241                 /* No linefeed, bail for the next time */
 242                 bufhead->len += cpylen;
 243                 bufline->len += cpylen;
 244                 bufline->terminated = 0;
 245                 return clen;
 246         }
 247
 248         /* Yank the CRLF off this, replace with a \0 */
 249         while(cpylen && (*bufch == '\r' || *bufch == '\n'))
 250         {
 251                 *bufch = '\0';
 252                 cpylen--;
 253                 bufch--;
 254         }
 255
 256         bufline->terminated = 1;
 257         bufhead->len += cpylen;
 258         bufline->len += cpylen;
 259         return clen;
 260 }
 261
 262 /*
 263  * rb_linebuf_copy_raw
 264  *
 265  * Copy as much data as possible directly into a linebuf,
 266  * splitting at \r\n, but without altering any data.
 267  *
 268  */
 269 static int
 270 rb_linebuf_copy_raw(buf_head_t * bufhead, buf_line_t * bufline, char *data, int len)
 271 {
 272         int cpylen = 0;         /* how many bytes we've copied */
 273         char *ch = data;        /* Pointer to where we are in the read data */
 274         char *bufch = bufline->buf + bufline->len;
 275         int clen = 0;           /* how many bytes we've processed,
 276                                    and don't ever want to see again.. */
 277
 278         /* If its full or terminated, ignore it */
 279
 280         bufline->raw = 1;
 281         lrb_assert(bufline->len < BUF_DATA_SIZE);
 282         if(bufline->terminated == 1)
 283                 return 0;
 284
 285         clen = cpylen = rb_linebuf_skip_crlf(ch, len);
 286         if(clen == -1)
 287                 return -1;
 288
 289         /* This is the overflow case..This doesn't happen often.. */
 290         if(cpylen > (BUF_DATA_SIZE - bufline->len - 1))
 291         {
 292                 clen = BUF_DATA_SIZE - bufline->len - 1;
 293                 memcpy(bufch, ch, clen);
 294                 bufline->buf[BUF_DATA_SIZE - 1] = '\0';
 295                 bufline->terminated = 1;
 296                 bufline->len = BUF_DATA_SIZE - 1;
 297                 bufhead->len += BUF_DATA_SIZE - 1;
 298                 return clen;
 299         }
 300
 301         memcpy(bufch, ch, cpylen);
 302         bufch += cpylen;
 303         *bufch = '\0';
 304         bufch--;
 305
 306         if(*bufch != '\r' && *bufch != '\n')
 307         {
 308                 /* No linefeed, bail for the next time */
 309                 bufhead->len += cpylen;
 310                 bufline->len += cpylen;
 311                 bufline->terminated = 0;
 312                 return clen;
 313         }
 314
 315         bufline->terminated = 1;
 316         bufhead->len += cpylen;
 317         bufline->len += cpylen;
 318         return clen;
 319 }
 320
 321
 322 /*
 323  * rb_linebuf_parse
 324  *
 325  * Take a given buffer and break out as many buffers as we can.
 326  * If we find a CRLF, we terminate that buffer and create a new one.
 327  * If we don't find a CRLF whilst parsing a buffer, we don't mark it
 328  * 'finished', so the next loop through we can continue appending ..
 329  *
 330  * A few notes here, which you'll need to understand before continuing.
 331  *
 332  * - right now I'm only dealing with single sized buffers. Later on,
 333  *   I might consider chaining buffers together to get longer "lines"
 334  *   but seriously, I don't see the advantage right now.
 335  *
 336  * - This *is* designed to turn into a reference-counter-protected setup
 337  *   to dodge copious copies.
 338  */
 339 int
 340 rb_linebuf_parse(buf_head_t * bufhead, char *data, int len, int raw)
 341 {
 342         buf_line_t *bufline;
 343         int cpylen;
 344         int linecnt = 0;
 345
 346         /* First, if we have a partial buffer, try to squeze data into it */
 347         if(bufhead->list.tail != NULL)
 348         {
 349                 /* Check we're doing the partial buffer thing */
 350                 bufline = bufhead->list.tail->data;
 351                 /* just try, the worst it could do is *reject* us .. */
 352                 if(!raw)
 353                         cpylen = rb_linebuf_copy_line(bufhead, bufline, data, len);
 354                 else
 355                         cpylen = rb_linebuf_copy_raw(bufhead, bufline, data, len);
 356
 357                 if(cpylen == -1)
 358                         return -1;
 359
 360                 linecnt++;
 361                 /* If we've copied the same as what we've got, quit now */
 362                 if(cpylen == len)
 363                         return linecnt; /* all the data done so soon? */
 364
 365                 /* Skip the data and update len .. */
 366                 len -= cpylen;
 367                 lrb_assert(len >= 0);
 368                 data += cpylen;
 369         }
 370
 371         /* Next, the loop */
 372         while(len > 0)
 373         {
 374                 /* We obviously need a new buffer, so .. */
 375                 bufline = rb_linebuf_new_line(bufhead);
 376
 377                 /* And parse */
 378                 if(!raw)
 379                         cpylen = rb_linebuf_copy_line(bufhead, bufline, data, len);
 380                 else
 381                         cpylen = rb_linebuf_copy_raw(bufhead, bufline, data, len);
 382
 383                 if(cpylen == -1)
 384                         return -1;
 385
 386                 len -= cpylen;
 387                 lrb_assert(len >= 0);
 388                 data += cpylen;
 389                 linecnt++;
 390         }
 391         return linecnt;
 392 }
 393
 394
 395 /*
 396  * rb_linebuf_get
 397  *
 398  * get the next buffer from our line. For the time being it will copy
 399  * data into the given buffer and free the underlying linebuf.
 400  */
 401 int
 402 rb_linebuf_get(buf_head_t * bufhead, char *buf, int buflen, int partial, int raw)
 403 {
 404         buf_line_t *bufline;
 405         int cpylen;
 406         char *start, *ch;
 407
 408         /* make sure we have a line */
 409         if(bufhead->list.head == NULL)
 410                 return 0;       /* Obviously not.. hrm. */
 411
 412         bufline = bufhead->list.head->data;
 413
 414         /* make sure that the buffer was actually *terminated */
 415         if(!(partial || bufline->terminated))
 416                 return 0;       /* Wait for more data! */
 417
 418         if(buflen < bufline->len)
 419                 cpylen = buflen - 1;
 420         else
 421                 cpylen = bufline->len;
 422
 423         /* Copy it */
 424         start = bufline->buf;
 425
 426         /* if we left extraneous '\r\n' characters in the string,
 427          * and we don't want to read the raw data, clean up the string.
 428          */
 429         if(bufline->raw && !raw)
 430         {
 431                 /* skip leading EOL characters */
 432                 while(cpylen && (*start == '\r' || *start == '\n'))
 433                 {
 434                         start++;
 435                         cpylen--;
 436                 }
 437                 /* skip trailing EOL characters */
 438                 ch = &start[cpylen - 1];
 439                 while(cpylen && (*ch == '\r' || *ch == '\n'))
 440                 {
 441                         ch--;
 442                         cpylen--;
 443                 }
 444         }
 445
 446         memcpy(buf, start, cpylen);
 447
 448         /* convert CR/LF to NULL */
 449         if(!raw)
 450                 buf[cpylen] = '\0';
 451
 452         lrb_assert(cpylen >= 0);
 453
 454         /* Deallocate the line */
 455         rb_linebuf_done_line(bufhead, bufline, bufhead->list.head);
 456
 457         /* return how much we copied */
 458         return cpylen;
 459 }
 460
 461 /*
 462  * rb_linebuf_attach
 463  *
 464  * attach the lines in a buf_head_t to another buf_head_t
 465  * without copying the data (using refcounts).
 466  */
 467 void
 468 rb_linebuf_attach(buf_head_t * bufhead, buf_head_t * new)
 469 {
 470         rb_dlink_node *ptr;
 471         buf_line_t *line;
 472
 473         RB_DLINK_FOREACH(ptr, new->list.head)
 474         {
 475                 line = ptr->data;
 476                 rb_dlinkAddTailAlloc(line, &bufhead->list);
 477
 478                 /* Update the allocated size */
 479                 bufhead->alloclen++;
 480                 bufhead->len += line->len;
 481                 bufhead->numlines++;
 482
 483                 line->refcount++;
 484         }
 485 }
 486
 487 /*
 488  * rb_linebuf_putmsg
 489  *
 490  * Similar to rb_linebuf_put, but designed for use by send.c.
 491  *
 492  * prefixfmt is used as a format for the varargs, and is inserted first.
 493  * Then format/va_args is appended to the buffer.
 494  */
 495 void
 496 rb_linebuf_putmsg(buf_head_t * bufhead, const char *format, va_list * va_args,
 497                   const char *prefixfmt, ...)
 498 {
 499         buf_line_t *bufline;
 500         int len = 0;
 501         va_list prefix_args;
 502
 503         /* make sure the previous line is terminated */
 504 #ifndef NDEBUG
 505         if(bufhead->list.tail)
 506         {
 507                 bufline = bufhead->list.tail->data;
 508                 lrb_assert(bufline->terminated);
 509         }
 510 #endif
 511         /* Create a new line */
 512         bufline = rb_linebuf_new_line(bufhead);
 513
 514         if(prefixfmt != NULL)
 515         {
 516                 va_start(prefix_args, prefixfmt);
 517                 len = vsnprintf(bufline->buf, BUF_DATA_SIZE, prefixfmt, prefix_args);
 518                 va_end(prefix_args);
 519         }
 520
 521         if(va_args != NULL)
 522         {
 523                 len += vsnprintf((bufline->buf + len), (BUF_DATA_SIZE - len), format, *va_args);
 524         }
 525
 526         bufline->terminated = 1;
 527
 528         /* Truncate the data if required */
 529         if(rb_unlikely(len > 510))
 530         {
 531                 len = 510;
 532                 bufline->buf[len++] = '\r';
 533                 bufline->buf[len++] = '\n';
 534         }
 535         else if(rb_unlikely(len == 0))
 536         {
 537                 bufline->buf[len++] = '\r';
 538                 bufline->buf[len++] = '\n';
 539                 bufline->buf[len] = '\0';
 540         }
 541         else
 542         {
 543                 /* Chop trailing CRLF's .. */
 544                 while((bufline->buf[len] == '\r') || (bufline->buf[len] == '\n')
 545                       || (bufline->buf[len] == '\0'))
 546                 {
 547                         len--;
 548                 }
 549
 550                 bufline->buf[++len] = '\r';
 551                 bufline->buf[++len] = '\n';
 552                 bufline->buf[++len] = '\0';
 553         }
 554
 555         bufline->len = len;
 556         bufhead->len += len;
 557 }
 558
 559 /*
 560  * rb_linebuf_putprefix
 561  *
 562  * Similar to rb_linebuf_put, but designed for use by send.c.
 563  *
 564  * prefix is inserted first, then format/va_args is appended to the buffer.
 565  */
 566 void
 567 rb_linebuf_putprefix(buf_head_t * bufhead, const char *format, va_list * va_args,
 568                   const char *prefix)
 569 {
 570         buf_line_t *bufline;
 571         int len = 0;
 572
 573         /* make sure the previous line is terminated */
 574 #ifndef NDEBUG
 575         if(bufhead->list.tail)
 576         {
 577                 bufline = bufhead->list.tail->data;
 578                 lrb_assert(bufline->terminated);
 579         }
 580 #endif
 581         /* Create a new line */
 582         bufline = rb_linebuf_new_line(bufhead);
 583
 584         if(prefix != NULL)
 585                 len = rb_strlcpy(bufline->buf, prefix, BUF_DATA_SIZE);
 586
 587         if(va_args != NULL)
 588         {
 589                 len += vsnprintf((bufline->buf + len), (BUF_DATA_SIZE - len), format, *va_args);
 590         }
 591
 592         bufline->terminated = 1;
 593
 594         /* Truncate the data if required */
 595         if(rb_unlikely(len > 510))
 596         {
 597                 len = 510;
 598                 bufline->buf[len++] = '\r';
 599                 bufline->buf[len++] = '\n';
 600         }
 601         else if(rb_unlikely(len == 0))
 602         {
 603                 bufline->buf[len++] = '\r';
 604                 bufline->buf[len++] = '\n';
 605                 bufline->buf[len] = '\0';
 606         }
 607         else
 608         {
 609                 /* Chop trailing CRLF's .. */
 610                 while((bufline->buf[len] == '\r') || (bufline->buf[len] == '\n')
 611                       || (bufline->buf[len] == '\0'))
 612                 {
 613                         len--;
 614                 }
 615
 616                 bufline->buf[++len] = '\r';
 617                 bufline->buf[++len] = '\n';
 618                 bufline->buf[++len] = '\0';
 619         }
 620
 621         bufline->len = len;
 622         bufhead->len += len;
 623 }
 624
 625 void
 626 rb_linebuf_putbuf(buf_head_t * bufhead, const char *buffer)
 627 {
 628         buf_line_t *bufline;
 629         int len = 0;
 630
 631         /* make sure the previous line is terminated */
 632 #ifndef NDEBUG
 633         if(bufhead->list.tail)
 634         {
 635                 bufline = bufhead->list.tail->data;
 636                 lrb_assert(bufline->terminated);
 637         }
 638 #endif
 639         /* Create a new line */
 640         bufline = rb_linebuf_new_line(bufhead);
 641
 642         if(rb_unlikely(buffer != NULL))
 643                 len = rb_strlcpy(bufline->buf, buffer, BUF_DATA_SIZE);
 644
 645         bufline->terminated = 1;
 646
 647         /* Truncate the data if required */
 648         if(rb_unlikely(len > 510))
 649         {
 650                 len = 510;
 651                 bufline->buf[len++] = '\r';
 652                 bufline->buf[len++] = '\n';
 653         }
 654         else if(rb_unlikely(len == 0))
 655         {
 656                 bufline->buf[len++] = '\r';
 657                 bufline->buf[len++] = '\n';
 658                 bufline->buf[len] = '\0';
 659         }
 660         else
 661         {
 662                 /* Chop trailing CRLF's .. */
 663                 while((bufline->buf[len] == '\r') || (bufline->buf[len] == '\n')
 664                       || (bufline->buf[len] == '\0'))
 665                 {
 666                         len--;
 667                 }
 668
 669                 bufline->buf[++len] = '\r';
 670                 bufline->buf[++len] = '\n';
 671                 bufline->buf[++len] = '\0';
 672         }
 673
 674         bufline->len = len;
 675         bufhead->len += len;
 676
 677
 678 }
 679
 680 void
 681 rb_linebuf_put(buf_head_t * bufhead, const char *format, ...)
 682 {
 683         buf_line_t *bufline;
 684         int len = 0;
 685         va_list args;
 686
 687         /* make sure the previous line is terminated */
 688 #ifndef NDEBUG
 689         if(bufhead->list.tail)
 690         {
 691                 bufline = bufhead->list.tail->data;
 692                 lrb_assert(bufline->terminated);
 693         }
 694 #endif
 695         /* Create a new line */
 696         bufline = rb_linebuf_new_line(bufhead);
 697
 698         if(rb_unlikely(format != NULL))
 699         {
 700                 va_start(args, format);
 701                 len = vsnprintf(bufline->buf, BUF_DATA_SIZE, format, args);
 702                 va_end(args);
 703         }
 704
 705         bufline->terminated = 1;
 706
 707         /* Truncate the data if required */
 708         if(rb_unlikely(len > 510))
 709         {
 710                 len = 510;
 711                 bufline->buf[len++] = '\r';
 712                 bufline->buf[len++] = '\n';
 713         }
 714         else if(rb_unlikely(len == 0))
 715         {
 716                 bufline->buf[len++] = '\r';
 717                 bufline->buf[len++] = '\n';
 718                 bufline->buf[len] = '\0';
 719         }
 720         else
 721         {
 722                 /* Chop trailing CRLF's .. */
 723                 while((bufline->buf[len] == '\r') || (bufline->buf[len] == '\n')
 724                       || (bufline->buf[len] == '\0'))
 725                 {
 726                         len--;
 727                 }
 728
 729                 bufline->buf[++len] = '\r';
 730                 bufline->buf[++len] = '\n';
 731                 bufline->buf[++len] = '\0';
 732         }
 733
 734         bufline->len = len;
 735         bufhead->len += len;
 736 }
 737
 738
 739
 740 /*
 741  * rb_linebuf_flush
 742  *
 743  * Flush data to the buffer. It tries to write as much data as possible
 744  * to the given socket. Any return values are passed straight through.
 745  * If there is no data in the socket, EWOULDBLOCK is set as an errno
 746  * rather than returning 0 (which would map to an EOF..)
 747  *
 748  * Notes: XXX We *should* have a clue here when a non-full buffer is arrived.
 749  *        and tag it so that we don't re-schedule another write until
 750  *        we have a CRLF.
 751  */
 752 int
 753 rb_linebuf_flush(rb_fde_t *F, buf_head_t * bufhead)
 754 {
 755         buf_line_t *bufline;
 756         int retval;
 757
 758 /*
 759  * autoconf checks for this..but really just want to use it if we have a
 760  * native version even if libircd provides a fake version...
 761  */
 762 #ifdef HAVE_WRITEV
 763         if(!rb_fd_ssl(F))
 764         {
 765                 rb_dlink_node *ptr;
 766                 int x = 0, y;
 767                 int xret;
 768                 static struct rb_iovec vec[RB_UIO_MAXIOV];
 769
 770                 memset(vec, 0, sizeof(vec));
 771                 /* Check we actually have a first buffer */
 772                 if(bufhead->list.head == NULL)
 773                 {
 774                         /* nope, so we return none .. */
 775                         errno = EWOULDBLOCK;
 776                         return -1;
 777                 }
 778
 779                 ptr = bufhead->list.head;
 780
 781                 bufline = ptr->data;
 782                 if(!bufline->terminated)
 783                 {
 784                         errno = EWOULDBLOCK;
 785                         return -1;
 786
 787                 }
 788
 789                 vec[x].iov_base = bufline->buf + bufhead->writeofs;
 790                 vec[x++].iov_len = bufline->len - bufhead->writeofs;
 791                 ptr = ptr->next;
 792
 793                 do
 794                 {
 795                         if(ptr == NULL)
 796                                 break;
 797
 798                         bufline = ptr->data;
 799                         if(!bufline->terminated)
 800                                 break;
 801
 802                         vec[x].iov_base = bufline->buf;
 803                         vec[x].iov_len = bufline->len;
 804                         ptr = ptr->next;
 805
 806                 }
 807                 while(++x < RB_UIO_MAXIOV);
 808
 809                 if(x == 0)
 810                 {
 811                         errno = EWOULDBLOCK;
 812                         return -1;
 813                 }
 814
 815                 xret = retval = rb_writev(F, vec, x);
 816                 if(retval <= 0)
 817                         return retval;
 818
 819                 ptr = bufhead->list.head;
 820
 821                 for(y = 0; y < x; y++)
 822                 {
 823                         bufline = ptr->data;
 824
 825                         if(xret >= bufline->len - bufhead->writeofs)
 826                         {
 827                                 xret -= bufline->len - bufhead->writeofs;
 828                                 ptr = ptr->next;
 829                                 rb_linebuf_done_line(bufhead, bufline, bufhead->list.head);
 830                                 bufhead->writeofs = 0;
 831                         }
 832                         else
 833                         {
 834                                 bufhead->writeofs += xret;
 835                                 break;
 836                         }
 837                 }
 838
 839                 return retval;
 840         }
 841 #endif
 842
 843         /* this is the non-writev case */
 844
 845         /* Check we actually have a first buffer */
 846         if(bufhead->list.head == NULL)
 847         {
 848                 /* nope, so we return none .. */
 849                 errno = EWOULDBLOCK;
 850                 return -1;
 851         }
 852
 853         bufline = bufhead->list.head->data;
 854
 855         /* And that its actually full .. */
 856         if(!bufline->terminated)
 857         {
 858                 errno = EWOULDBLOCK;
 859                 return -1;
 860         }
 861
 862         /* Now, try writing data */
 863         retval = rb_write(F, bufline->buf + bufhead->writeofs, bufline->len - bufhead->writeofs);
 864
 865         if(retval <= 0)
 866                 return retval;
 867
 868         /* we've got data, so update the write offset */
 869         bufhead->writeofs += retval;
 870
 871         /* if we've written everything *and* the CRLF, deallocate and update
 872            bufhead */
 873         if(bufhead->writeofs == bufline->len)
 874         {
 875                 bufhead->writeofs = 0;
 876                 lrb_assert(bufhead->len >= 0);
 877                 rb_linebuf_done_line(bufhead, bufline, bufhead->list.head);
 878         }
 879
 880         /* Return line length */
 881         return retval;
 882 }
 883
 884
 885
 886 /*
 887  * count linebufs for stats z
 888  */
 889
 890 void
 891 rb_count_rb_linebuf_memory(size_t *count, size_t *rb_linebuf_memory_used)
 892 {
 893         rb_bh_usage(rb_linebuf_heap, count, NULL, rb_linebuf_memory_used, NULL);
 894 }