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 <= LINEBUF_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 > (LINEBUF_SIZE - bufline->len))
 217         {
 218                 cpylen = LINEBUF_SIZE - bufline->len;
 219                 memcpy(bufch, ch, cpylen);
 220                 bufline->buf[LINEBUF_SIZE] = '\0';
 221                 bufch = bufline->buf + LINEBUF_SIZE - 1;
 222                 while(cpylen && (*bufch == '\r' || *bufch == '\n'))
 223                 {
 224                         *bufch = '\0';
 225                         cpylen--;
 226                         bufch--;
 227                 }
 228                 bufline->terminated = 1;
 229                 bufline->len = LINEBUF_SIZE;
 230                 bufhead->len += LINEBUF_SIZE;
 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 <= LINEBUF_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 > (LINEBUF_SIZE - bufline->len))
 291         {
 292                 clen = LINEBUF_SIZE - bufline->len;
 293                 memcpy(bufch, ch, clen);
 294                 bufline->buf[LINEBUF_SIZE] = '\0';
 295                 bufline->terminated = 1;
 296                 bufline->len = LINEBUF_SIZE;
 297                 bufhead->len += LINEBUF_SIZE;
 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_put
 489  *
 490  * linked list of strings are appended in order.
 491  */
 492 void
 493 rb_linebuf_put(buf_head_t *bufhead, const rb_strf_t *strings)
 494 {
 495         buf_line_t *bufline;
 496         size_t len = 0;
 497         int ret;
 498
 499         /* make sure the previous line is terminated */
 500         if (bufhead->list.tail) {
 501                 bufline = bufhead->list.tail->data;
 502                 lrb_assert(bufline->terminated);
 503         }
 504
 505         /* create a new line */
 506         bufline = rb_linebuf_new_line(bufhead);
 507
 508         ret = rb_fsnprint(bufline->buf, LINEBUF_SIZE + 1, strings);
 509         if (ret > 0)
 510                 len += ret;
 511
 512         if (len > LINEBUF_SIZE)
 513                 len = LINEBUF_SIZE;
 514
 515         /* add trailing CRLF */
 516         bufline->buf[len++] = '\r';
 517         bufline->buf[len++] = '\n';
 518         bufline->buf[len] = '\0';
 519
 520         bufline->terminated = 1;
 521
 522         bufline->len = len;
 523         bufhead->len += len;
 524 }
 525
 526 /*
 527  * rb_linebuf_flush
 528  *
 529  * Flush data to the buffer. It tries to write as much data as possible
 530  * to the given socket. Any return values are passed straight through.
 531  * If there is no data in the socket, EWOULDBLOCK is set as an errno
 532  * rather than returning 0 (which would map to an EOF..)
 533  *
 534  * Notes: XXX We *should* have a clue here when a non-full buffer is arrived.
 535  *        and tag it so that we don't re-schedule another write until
 536  *        we have a CRLF.
 537  */
 538 int
 539 rb_linebuf_flush(rb_fde_t *F, buf_head_t * bufhead)
 540 {
 541         buf_line_t *bufline;
 542         int retval;
 543
 544 /*
 545  * autoconf checks for this..but really just want to use it if we have a
 546  * native version even if libircd provides a fake version...
 547  */
 548 #ifdef HAVE_WRITEV
 549         if(!rb_fd_ssl(F))
 550         {
 551                 rb_dlink_node *ptr;
 552                 int x = 0, y;
 553                 int xret;
 554                 static struct rb_iovec vec[RB_UIO_MAXIOV];
 555
 556                 memset(vec, 0, sizeof(vec));
 557                 /* Check we actually have a first buffer */
 558                 if(bufhead->list.head == NULL)
 559                 {
 560                         /* nope, so we return none .. */
 561                         errno = EWOULDBLOCK;
 562                         return -1;
 563                 }
 564
 565                 ptr = bufhead->list.head;
 566
 567                 bufline = ptr->data;
 568                 if(!bufline->terminated)
 569                 {
 570                         errno = EWOULDBLOCK;
 571                         return -1;
 572
 573                 }
 574
 575                 vec[x].iov_base = bufline->buf + bufhead->writeofs;
 576                 vec[x++].iov_len = bufline->len - bufhead->writeofs;
 577                 ptr = ptr->next;
 578
 579                 do
 580                 {
 581                         if(ptr == NULL)
 582                                 break;
 583
 584                         bufline = ptr->data;
 585                         if(!bufline->terminated)
 586                                 break;
 587
 588                         vec[x].iov_base = bufline->buf;
 589                         vec[x].iov_len = bufline->len;
 590                         ptr = ptr->next;
 591
 592                 }
 593                 while(++x < RB_UIO_MAXIOV);
 594
 595                 if(x == 0)
 596                 {
 597                         errno = EWOULDBLOCK;
 598                         return -1;
 599                 }
 600
 601                 xret = retval = rb_writev(F, vec, x);
 602                 if(retval <= 0)
 603                         return retval;
 604
 605                 ptr = bufhead->list.head;
 606
 607                 for(y = 0; y < x; y++)
 608                 {
 609                         bufline = ptr->data;
 610
 611                         if(xret >= bufline->len - bufhead->writeofs)
 612                         {
 613                                 xret -= bufline->len - bufhead->writeofs;
 614                                 ptr = ptr->next;
 615                                 rb_linebuf_done_line(bufhead, bufline, bufhead->list.head);
 616                                 bufhead->writeofs = 0;
 617                         }
 618                         else
 619                         {
 620                                 bufhead->writeofs += xret;
 621                                 break;
 622                         }
 623                 }
 624
 625                 return retval;
 626         }
 627 #endif
 628
 629         /* this is the non-writev case */
 630
 631         /* Check we actually have a first buffer */
 632         if(bufhead->list.head == NULL)
 633         {
 634                 /* nope, so we return none .. */
 635                 errno = EWOULDBLOCK;
 636                 return -1;
 637         }
 638
 639         bufline = bufhead->list.head->data;
 640
 641         /* And that its actually full .. */
 642         if(!bufline->terminated)
 643         {
 644                 errno = EWOULDBLOCK;
 645                 return -1;
 646         }
 647
 648         /* Now, try writing data */
 649         retval = rb_write(F, bufline->buf + bufhead->writeofs, bufline->len - bufhead->writeofs);
 650
 651         if(retval <= 0)
 652                 return retval;
 653
 654         /* we've got data, so update the write offset */
 655         bufhead->writeofs += retval;
 656
 657         /* if we've written everything *and* the CRLF, deallocate and update
 658            bufhead */
 659         if(bufhead->writeofs == bufline->len)
 660         {
 661                 bufhead->writeofs = 0;
 662                 lrb_assert(bufhead->len >= 0);
 663                 rb_linebuf_done_line(bufhead, bufline, bufhead->list.head);
 664         }
 665
 666         /* Return line length */
 667         return retval;
 668 }
 669
 670
 671
 672 /*
 673  * count linebufs for stats z
 674  */
 675
 676 void
 677 rb_count_rb_linebuf_memory(size_t *count, size_t *rb_linebuf_memory_used)
 678 {
 679         rb_bh_usage(rb_linebuf_heap, count, NULL, rb_linebuf_memory_used, NULL);
 680 }