lib/buffer.c

   1 /*
   2  * Buffering of output and input.
   3  * Copyright (C) 1998 Kunihiro Ishiguro
   4  *
   5  * This file is part of GNU Zebra.
   6  *
   7  * GNU Zebra is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published
   9  * by the Free Software Foundation; either version 2, or (at your
  10  * option) any later version.
  11  *
  12  * GNU Zebra is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with GNU Zebra; see the file COPYING.  If not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  */
  22
  23 #include <zebra.h>
  24
  25 #include "memory.h"
  26 #include "buffer.h"
  27 #include "log.h"
  28 #include "network.h"
  29 #include <stddef.h>
  30
  31
  32
  33 /* Buffer master. */
  34 struct buffer
  35 {
  36   /* Data list. */
  37   struct buffer_data *head;
  38   struct buffer_data *tail;
  39
  40   /* Size of each buffer_data chunk. */
  41   size_t size;
  42 };
  43
  44 /* Data container. */
  45 struct buffer_data
  46 {
  47   struct buffer_data *next;
  48
  49   /* Location to add new data. */
  50   size_t cp;
  51
  52   /* Pointer to data not yet flushed. */
  53   size_t sp;
  54
  55   /* Actual data stream (variable length). */
  56   unsigned char data[];  /* real dimension is buffer->size */
  57 };
  58
  59 /* It should always be true that: 0 <= sp <= cp <= size */
  60
  61 /* Default buffer size (used if none specified).  It is rounded up to the
  62    next page boundery. */
  63 #define BUFFER_SIZE_DEFAULT             4096
  64
  65
  66 #define BUFFER_DATA_FREE(D) XFREE(MTYPE_BUFFER_DATA, (D))
  67
  68 /* Make new buffer. */
  69 struct buffer *
  70 buffer_new (size_t size)
  71 {
  72   struct buffer *b;
  73
  74   b = XCALLOC (MTYPE_BUFFER, sizeof (struct buffer));
  75
  76   if (size)
  77     b->size = size;
  78   else
  79     {
  80       static size_t default_size;
  81       if (!default_size)
  82         {
  83           long pgsz = sysconf(_SC_PAGESIZE);
  84           default_size = ((((BUFFER_SIZE_DEFAULT-1)/pgsz)+1)*pgsz);
  85         }
  86       b->size = default_size;
  87     }
  88
  89   return b;
  90 }
  91
  92 /* Free buffer. */
  93 void
  94 buffer_free (struct buffer *b)
  95 {
  96   buffer_reset(b);
  97   XFREE (MTYPE_BUFFER, b);
  98 }
  99
 100 /* Make string clone. */
 101 char *
 102 buffer_getstr (struct buffer *b)
 103 {
 104   size_t totlen = 0;
 105   struct buffer_data *data;
 106   char *s;
 107   char *p;
 108
 109   for (data = b->head; data; data = data->next)
 110     totlen += data->cp - data->sp;
 111   if (!(s = XMALLOC(MTYPE_TMP, totlen+1)))
 112     return NULL;
 113   p = s;
 114   for (data = b->head; data; data = data->next)
 115     {
 116       memcpy(p, data->data + data->sp, data->cp - data->sp);
 117       p += data->cp - data->sp;
 118     }
 119   *p = '\0';
 120   return s;
 121 }
 122
 123 /* Return 1 if buffer is empty. */
 124 int
 125 buffer_empty (struct buffer *b)
 126 {
 127   return (b->head == NULL);
 128 }
 129
 130 /* Clear and free all allocated data. */
 131 void
 132 buffer_reset (struct buffer *b)
 133 {
 134   struct buffer_data *data;
 135   struct buffer_data *next;
 136
 137   for (data = b->head; data; data = next)
 138     {
 139       next = data->next;
 140       BUFFER_DATA_FREE(data);
 141     }
 142   b->head = b->tail = NULL;
 143 }
 144
 145 /* Add buffer_data to the end of buffer. */
 146 static struct buffer_data *
 147 buffer_add (struct buffer *b)
 148 {
 149   struct buffer_data *d;
 150
 151   d = XMALLOC(MTYPE_BUFFER_DATA, offsetof(struct buffer_data, data[b->size]));
 152   d->cp = d->sp = 0;
 153   d->next = NULL;
 154
 155   if (b->tail)
 156     b->tail->next = d;
 157   else
 158     b->head = d;
 159   b->tail = d;
 160
 161   return d;
 162 }
 163
 164 /* Write data to buffer. */
 165 void
 166 buffer_put(struct buffer *b, const void *p, size_t size)
 167 {
 168   struct buffer_data *data = b->tail;
 169   const char *ptr = p;
 170
 171   /* We use even last one byte of data buffer. */
 172   while (size)
 173     {
 174       size_t chunk;
 175
 176       /* If there is no data buffer add it. */
 177       if (data == NULL || data->cp == b->size)
 178         data = buffer_add (b);
 179
 180       chunk = ((size <= (b->size - data->cp)) ? size : (b->size - data->cp));
 181       memcpy ((data->data + data->cp), ptr, chunk);
 182       size -= chunk;
 183       ptr += chunk;
 184       data->cp += chunk;
 185     }
 186 }
 187
 188 /* Insert character into the buffer. */
 189 void
 190 buffer_putc (struct buffer *b, u_char c)
 191 {
 192   buffer_put(b, &c, 1);
 193 }
 194
 195 /* Put string to the buffer. */
 196 void
 197 buffer_putstr (struct buffer *b, const char *c)
 198 {
 199   buffer_put(b, c, strlen(c));
 200 }
 201
 202 /* Keep flushing data to the fd until the buffer is empty or an error is
 203    encountered or the operation would block. */
 204 buffer_status_t
 205 buffer_flush_all (struct buffer *b, int fd)
 206 {
 207   buffer_status_t ret;
 208   struct buffer_data *head;
 209   size_t head_sp;
 210
 211   if (!b->head)
 212     return BUFFER_EMPTY;
 213   head_sp = (head = b->head)->sp;
 214   /* Flush all data. */
 215   while ((ret = buffer_flush_available(b, fd)) == BUFFER_PENDING)
 216     {
 217       if ((b->head == head) && (head_sp == head->sp) && (errno != EINTR))
 218         /* No data was flushed, so kernel buffer must be full. */
 219         return ret;
 220       head_sp = (head = b->head)->sp;
 221     }
 222
 223   return ret;
 224 }
 225
 226 /* Flush enough data to fill a terminal window of the given scene (used only
 227    by vty telnet interface). */
 228 buffer_status_t
 229 buffer_flush_window (struct buffer *b, int fd, int width, int height,
 230                      int erase_flag, int no_more_flag)
 231 {
 232   int nbytes;
 233   int iov_alloc;
 234   int iov_index;
 235   struct iovec *iov;
 236   struct iovec small_iov[3];
 237   char more[] = " --More-- ";
 238   char erase[] = { 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
 239                    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
 240                    0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08};
 241   struct buffer_data *data;
 242   int column;
 243
 244   if (!b->head)
 245     return BUFFER_EMPTY;
 246
 247   if (height < 1)
 248     {
 249       zlog_warn("%s called with non-positive window height %d, forcing to 1",
 250                 __func__, height);
 251       height = 1;
 252     }
 253   else if (height >= 2)
 254     height--;
 255   if (width < 1)
 256     {
 257       zlog_warn("%s called with non-positive window width %d, forcing to 1",
 258                 __func__, width);
 259       width = 1;
 260     }
 261
 262   /* For erase and more data add two to b's buffer_data count.*/
 263   if (b->head->next == NULL)
 264     {
 265       iov_alloc = sizeof(small_iov)/sizeof(small_iov[0]);
 266       iov = small_iov;
 267     }
 268   else
 269     {
 270       iov_alloc = ((height*(width+2))/b->size)+10;
 271       iov = XMALLOC(MTYPE_TMP, iov_alloc*sizeof(*iov));
 272     }
 273   iov_index = 0;
 274
 275   /* Previously print out is performed. */
 276   if (erase_flag)
 277     {
 278       iov[iov_index].iov_base = erase;
 279       iov[iov_index].iov_len = sizeof erase;
 280       iov_index++;
 281     }
 282
 283   /* Output data. */
 284   column = 1;  /* Column position of next character displayed. */
 285   for (data = b->head; data && (height > 0); data = data->next)
 286     {
 287       size_t cp;
 288
 289       cp = data->sp;
 290       while ((cp < data->cp) && (height > 0))
 291         {
 292           /* Calculate lines remaining and column position after displaying
 293              this character. */
 294           if (data->data[cp] == '\r')
 295             column = 1;
 296           else if ((data->data[cp] == '\n') || (column == width))
 297             {
 298               column = 1;
 299               height--;
 300             }
 301           else
 302             column++;
 303           cp++;
 304         }
 305       iov[iov_index].iov_base = (char *)(data->data + data->sp);
 306       iov[iov_index++].iov_len = cp-data->sp;
 307       data->sp = cp;
 308
 309       if (iov_index == iov_alloc)
 310         /* This should not ordinarily happen. */
 311         {
 312           iov_alloc *= 2;
 313           if (iov != small_iov)
 314             {
 315               zlog_warn("%s: growing iov array to %d; "
 316                         "width %d, height %d, size %lu",
 317                         __func__, iov_alloc, width, height, (u_long)b->size);
 318               iov = XREALLOC(MTYPE_TMP, iov, iov_alloc*sizeof(*iov));
 319             }
 320           else
 321             {
 322               /* This should absolutely never occur. */
 323               zlog_err("%s: corruption detected: iov_small overflowed; "
 324                        "head %p, tail %p, head->next %p",
 325                        __func__, b->head, b->tail, b->head->next);
 326               iov = XMALLOC(MTYPE_TMP, iov_alloc*sizeof(*iov));
 327               memcpy(iov, small_iov, sizeof(small_iov));
 328             }
 329         }
 330     }
 331
 332   /* In case of `more' display need. */
 333   if (b->tail && (b->tail->sp < b->tail->cp) && !no_more_flag)
 334     {
 335       iov[iov_index].iov_base = more;
 336       iov[iov_index].iov_len = sizeof more;
 337       iov_index++;
 338     }
 339
 340
 341 #ifdef IOV_MAX
 342   /* IOV_MAX are normally defined in <sys/uio.h> , Posix.1g.
 343      example: Solaris2.6 are defined IOV_MAX size at 16.     */
 344   {
 345     struct iovec *c_iov = iov;
 346     nbytes = 0; /* Make sure it's initialized. */
 347
 348     while (iov_index > 0)
 349       {
 350          int iov_size;
 351
 352          iov_size = ((iov_index > IOV_MAX) ? IOV_MAX : iov_index);
 353          if ((nbytes = writev(fd, c_iov, iov_size)) < 0)
 354            {
 355              zlog_warn("%s: writev to fd %d failed: %s",
 356                        __func__, fd, safe_strerror(errno));
 357              break;
 358            }
 359
 360          /* move pointer io-vector */
 361          c_iov += iov_size;
 362          iov_index -= iov_size;
 363       }
 364   }
 365 #else  /* IOV_MAX */
 366    if ((nbytes = writev (fd, iov, iov_index)) < 0)
 367      zlog_warn("%s: writev to fd %d failed: %s",
 368                __func__, fd, safe_strerror(errno));
 369 #endif /* IOV_MAX */
 370
 371   /* Free printed buffer data. */
 372   while (b->head && (b->head->sp == b->head->cp))
 373     {
 374       struct buffer_data *del;
 375       if (!(b->head = (del = b->head)->next))
 376         b->tail = NULL;
 377       BUFFER_DATA_FREE(del);
 378     }
 379
 380   if (iov != small_iov)
 381     XFREE (MTYPE_TMP, iov);
 382
 383   return (nbytes < 0) ? BUFFER_ERROR :
 384                         (b->head ? BUFFER_PENDING : BUFFER_EMPTY);
 385 }
 386
 387 /* This function (unlike other buffer_flush* functions above) is designed
 388 to work with non-blocking sockets.  It does not attempt to write out
 389 all of the queued data, just a "big" chunk.  It returns 0 if it was
 390 able to empty out the buffers completely, 1 if more flushing is
 391 required later, or -1 on a fatal write error. */
 392 buffer_status_t
 393 buffer_flush_available(struct buffer *b, int fd)
 394 {
 395
 396 /* These are just reasonable values to make sure a significant amount of
 397 data is written.  There's no need to go crazy and try to write it all
 398 in one shot. */
 399 #ifdef IOV_MAX
 400 #define MAX_CHUNKS ((IOV_MAX >= 16) ? 16 : IOV_MAX)
 401 #else
 402 #define MAX_CHUNKS 16
 403 #endif
 404 #define MAX_FLUSH 131072
 405
 406   struct buffer_data *d;
 407   size_t written;
 408   struct iovec iov[MAX_CHUNKS];
 409   size_t iovcnt = 0;
 410   size_t nbyte = 0;
 411
 412   for (d = b->head; d && (iovcnt < MAX_CHUNKS) && (nbyte < MAX_FLUSH);
 413        d = d->next, iovcnt++)
 414     {
 415       iov[iovcnt].iov_base = d->data+d->sp;
 416       nbyte += (iov[iovcnt].iov_len = d->cp-d->sp);
 417     }
 418
 419   if (!nbyte)
 420     /* No data to flush: should we issue a warning message? */
 421     return BUFFER_EMPTY;
 422
 423   /* only place where written should be sign compared */
 424   if ((ssize_t)(written = writev(fd,iov,iovcnt)) < 0)
 425     {
 426       if (ERRNO_IO_RETRY(errno))
 427         /* Calling code should try again later. */
 428         return BUFFER_PENDING;
 429       zlog_warn("%s: write error on fd %d: %s",
 430                 __func__, fd, safe_strerror(errno));
 431       return BUFFER_ERROR;
 432     }
 433
 434   /* Free printed buffer data. */
 435   while (written > 0)
 436     {
 437       struct buffer_data *d;
 438       if (!(d = b->head))
 439         {
 440           zlog_err("%s: corruption detected: buffer queue empty, "
 441                    "but written is %lu", __func__, (u_long)written);
 442           break;
 443         }
 444       if (written < d->cp-d->sp)
 445         {
 446           d->sp += written;
 447           return BUFFER_PENDING;
 448         }
 449
 450       written -= (d->cp-d->sp);
 451       if (!(b->head = d->next))
 452         b->tail = NULL;
 453       BUFFER_DATA_FREE(d);
 454     }
 455
 456   return b->head ? BUFFER_PENDING : BUFFER_EMPTY;
 457
 458 #undef MAX_CHUNKS
 459 #undef MAX_FLUSH
 460 }
 461
 462 buffer_status_t
 463 buffer_write(struct buffer *b, int fd, const void *p, size_t size)
 464 {
 465   ssize_t nbytes;
 466
 467 #if 0
 468   /* Should we attempt to drain any previously buffered data?  This could help
 469      reduce latency in pushing out the data if we are stuck in a long-running
 470      thread that is preventing the main select loop from calling the flush
 471      thread... */
 472   if (b->head && (buffer_flush_available(b, fd) == BUFFER_ERROR))
 473     return BUFFER_ERROR;
 474 #endif
 475   if (b->head)
 476     /* Buffer is not empty, so do not attempt to write the new data. */
 477     nbytes = 0;
 478   else if ((nbytes = write(fd, p, size)) < 0)
 479     {
 480       if (ERRNO_IO_RETRY(errno))
 481         nbytes = 0;
 482       else
 483         {
 484           zlog_warn("%s: write error on fd %d: %s",
 485                     __func__, fd, safe_strerror(errno));
 486           return BUFFER_ERROR;
 487         }
 488     }
 489   /* Add any remaining data to the buffer. */
 490   {
 491     size_t written = nbytes;
 492     if (written < size)
 493       buffer_put(b, ((const char *)p)+written, size-written);
 494   }
 495   return b->head ? BUFFER_PENDING : BUFFER_EMPTY;
 496 }