diff options
Diffstat (limited to 'openpcd/opcd_test/zebvty/buffer.c')
-rw-r--r-- | openpcd/opcd_test/zebvty/buffer.c | 460 |
1 files changed, 0 insertions, 460 deletions
diff --git a/openpcd/opcd_test/zebvty/buffer.c b/openpcd/opcd_test/zebvty/buffer.c deleted file mode 100644 index 0610ebb..0000000 --- a/openpcd/opcd_test/zebvty/buffer.c +++ /dev/null @@ -1,460 +0,0 @@ -/* - * Buffering of output and input. - * Copyright (C) 1998 Kunihiro Ishiguro - * - * This file is part of GNU Zebra. - * - * GNU Zebra is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published - * by the Free Software Foundation; either version 2, or (at your - * option) any later version. - * - * GNU Zebra is distributed in the hope that it will be useful, but - * WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with GNU Zebra; see the file COPYING. If not, write to the - * Free Software Foundation, Inc., 59 Temple Place - Suite 330, - * Boston, MA 02111-1307, USA. - */ - -#include <stdio.h> -#include <stdlib.h> -#include <unistd.h> -#include <string.h> -#include <errno.h> -#include <stddef.h> -#include <sys/uio.h> - -#include "buffer.h" -#include "vty.h" - -/* Buffer master. */ -struct buffer { - /* Data list. */ - struct buffer_data *head; - struct buffer_data *tail; - - /* Size of each buffer_data chunk. */ - size_t size; -}; - -/* Data container. */ -struct buffer_data { - struct buffer_data *next; - - /* Location to add new data. */ - size_t cp; - - /* Pointer to data not yet flushed. */ - size_t sp; - - /* Actual data stream (variable length). */ - unsigned char data[0]; /* real dimension is buffer->size */ -}; - -/* It should always be true that: 0 <= sp <= cp <= size */ - -/* Default buffer size (used if none specified). It is rounded up to the - next page boundery. */ -#define BUFFER_SIZE_DEFAULT 4096 - -#define BUFFER_DATA_FREE(D) free((D)) - -/* Make new buffer. */ -struct buffer *buffer_new(size_t size) -{ - struct buffer *b; - - b = calloc(1, sizeof(struct buffer)); - - if (size) - b->size = size; - else { - static size_t default_size; - if (!default_size) { - long pgsz = sysconf(_SC_PAGESIZE); - default_size = - ((((BUFFER_SIZE_DEFAULT - 1) / pgsz) + 1) * pgsz); - } - b->size = default_size; - } - - return b; -} - -/* Free buffer. */ -void buffer_free(struct buffer *b) -{ - buffer_reset(b); - free(b); -} - -/* Make string clone. */ -char *buffer_getstr(struct buffer *b) -{ - size_t totlen = 0; - struct buffer_data *data; - char *s; - char *p; - - for (data = b->head; data; data = data->next) - totlen += data->cp - data->sp; - if (!(s = malloc(totlen + 1))) - return NULL; - p = s; - for (data = b->head; data; data = data->next) { - memcpy(p, data->data + data->sp, data->cp - data->sp); - p += data->cp - data->sp; - } - *p = '\0'; - return s; -} - -/* Return 1 if buffer is empty. */ -int buffer_empty(struct buffer *b) -{ - return (b->head == NULL); -} - -/* Clear and free all allocated data. */ -void buffer_reset(struct buffer *b) -{ - struct buffer_data *data; - struct buffer_data *next; - - for (data = b->head; data; data = next) { - next = data->next; - BUFFER_DATA_FREE(data); - } - b->head = b->tail = NULL; -} - -/* Add buffer_data to the end of buffer. */ -static struct buffer_data *buffer_add(struct buffer *b) -{ - struct buffer_data *d; - - d = malloc(offsetof(struct buffer_data, data[b->size])); - if (!d) - return NULL; - d->cp = d->sp = 0; - d->next = NULL; - - if (b->tail) - b->tail->next = d; - else - b->head = d; - b->tail = d; - - return d; -} - -/* Write data to buffer. */ -void buffer_put(struct buffer *b, const void *p, size_t size) -{ - struct buffer_data *data = b->tail; - const char *ptr = p; - - /* We use even last one byte of data buffer. */ - while (size) { - size_t chunk; - - /* If there is no data buffer add it. */ - if (data == NULL || data->cp == b->size) - data = buffer_add(b); - - chunk = - ((size <= - (b->size - data->cp)) ? size : (b->size - data->cp)); - memcpy((data->data + data->cp), ptr, chunk); - size -= chunk; - ptr += chunk; - data->cp += chunk; - } -} - -/* Insert character into the buffer. */ -void buffer_putc(struct buffer *b, u_char c) -{ - buffer_put(b, &c, 1); -} - -/* Put string to the buffer. */ -void buffer_putstr(struct buffer *b, const char *c) -{ - buffer_put(b, c, strlen(c)); -} - -/* Keep flushing data to the fd until the buffer is empty or an error is - encountered or the operation would block. */ -buffer_status_t buffer_flush_all(struct buffer *b, int fd) -{ - buffer_status_t ret; - struct buffer_data *head; - size_t head_sp; - - if (!b->head) - return BUFFER_EMPTY; - head_sp = (head = b->head)->sp; - /* Flush all data. */ - while ((ret = buffer_flush_available(b, fd)) == BUFFER_PENDING) { - if ((b->head == head) && (head_sp == head->sp) - && (errno != EINTR)) - /* No data was flushed, so kernel buffer must be full. */ - return ret; - head_sp = (head = b->head)->sp; - } - - return ret; -} - -#if 0 -/* Flush enough data to fill a terminal window of the given scene (used only - by vty telnet interface). */ -buffer_status_t -buffer_flush_window(struct buffer * b, int fd, int width, int height, - int erase_flag, int no_more_flag) -{ - int nbytes; - int iov_alloc; - int iov_index; - struct iovec *iov; - struct iovec small_iov[3]; - char more[] = " --More-- "; - char erase[] = - { 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, - ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', - 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08 - }; - struct buffer_data *data; - int column; - - if (!b->head) - return BUFFER_EMPTY; - - if (height < 1) { - zlog_warn - ("%s called with non-positive window height %d, forcing to 1", - __func__, height); - height = 1; - } else if (height >= 2) - height--; - if (width < 1) { - zlog_warn - ("%s called with non-positive window width %d, forcing to 1", - __func__, width); - width = 1; - } - - /* For erase and more data add two to b's buffer_data count. */ - if (b->head->next == NULL) { - iov_alloc = sizeof(small_iov) / sizeof(small_iov[0]); - iov = small_iov; - } else { - iov_alloc = ((height * (width + 2)) / b->size) + 10; - iov = XMALLOC(MTYPE_TMP, iov_alloc * sizeof(*iov)); - } - iov_index = 0; - - /* Previously print out is performed. */ - if (erase_flag) { - iov[iov_index].iov_base = erase; - iov[iov_index].iov_len = sizeof erase; - iov_index++; - } - - /* Output data. */ - column = 1; /* Column position of next character displayed. */ - for (data = b->head; data && (height > 0); data = data->next) { - size_t cp; - - cp = data->sp; - while ((cp < data->cp) && (height > 0)) { - /* Calculate lines remaining and column position after displaying - this character. */ - if (data->data[cp] == '\r') - column = 1; - else if ((data->data[cp] == '\n') || (column == width)) { - column = 1; - height--; - } else - column++; - cp++; - } - iov[iov_index].iov_base = (char *)(data->data + data->sp); - iov[iov_index++].iov_len = cp - data->sp; - data->sp = cp; - - if (iov_index == iov_alloc) - /* This should not ordinarily happen. */ - { - iov_alloc *= 2; - if (iov != small_iov) { - zlog_warn("%s: growing iov array to %d; " - "width %d, height %d, size %lu", - __func__, iov_alloc, width, height, - (u_long) b->size); - iov = - XREALLOC(MTYPE_TMP, iov, - iov_alloc * sizeof(*iov)); - } else { - /* This should absolutely never occur. */ - zlog_err - ("%s: corruption detected: iov_small overflowed; " - "head %p, tail %p, head->next %p", - __func__, b->head, b->tail, b->head->next); - iov = - XMALLOC(MTYPE_TMP, - iov_alloc * sizeof(*iov)); - memcpy(iov, small_iov, sizeof(small_iov)); - } - } - } - - /* In case of `more' display need. */ - if (b->tail && (b->tail->sp < b->tail->cp) && !no_more_flag) { - iov[iov_index].iov_base = more; - iov[iov_index].iov_len = sizeof more; - iov_index++; - } -#ifdef IOV_MAX - /* IOV_MAX are normally defined in <sys/uio.h> , Posix.1g. - example: Solaris2.6 are defined IOV_MAX size at 16. */ - { - struct iovec *c_iov = iov; - nbytes = 0; /* Make sure it's initialized. */ - - while (iov_index > 0) { - int iov_size; - - iov_size = - ((iov_index > IOV_MAX) ? IOV_MAX : iov_index); - if ((nbytes = writev(fd, c_iov, iov_size)) < 0) { - zlog_warn("%s: writev to fd %d failed: %s", - __func__, fd, safe_strerror(errno)); - break; - } - - /* move pointer io-vector */ - c_iov += iov_size; - iov_index -= iov_size; - } - } -#else /* IOV_MAX */ - if ((nbytes = writev(fd, iov, iov_index)) < 0) - zlog_warn("%s: writev to fd %d failed: %s", - __func__, fd, safe_strerror(errno)); -#endif /* IOV_MAX */ - - /* Free printed buffer data. */ - while (b->head && (b->head->sp == b->head->cp)) { - struct buffer_data *del; - if (!(b->head = (del = b->head)->next)) - b->tail = NULL; - BUFFER_DATA_FREE(del); - } - - if (iov != small_iov) - XFREE(MTYPE_TMP, iov); - - return (nbytes < 0) ? BUFFER_ERROR : - (b->head ? BUFFER_PENDING : BUFFER_EMPTY); -} -#endif - -/* This function (unlike other buffer_flush* functions above) is designed -to work with non-blocking sockets. It does not attempt to write out -all of the queued data, just a "big" chunk. It returns 0 if it was -able to empty out the buffers completely, 1 if more flushing is -required later, or -1 on a fatal write error. */ -buffer_status_t buffer_flush_available(struct buffer * b, int fd) -{ - -/* These are just reasonable values to make sure a significant amount of -data is written. There's no need to go crazy and try to write it all -in one shot. */ -#ifdef IOV_MAX -#define MAX_CHUNKS ((IOV_MAX >= 16) ? 16 : IOV_MAX) -#else -#define MAX_CHUNKS 16 -#endif -#define MAX_FLUSH 131072 - - struct buffer_data *d; - size_t written; - struct iovec iov[MAX_CHUNKS]; - size_t iovcnt = 0; - size_t nbyte = 0; - - for (d = b->head; d && (iovcnt < MAX_CHUNKS) && (nbyte < MAX_FLUSH); - d = d->next, iovcnt++) { - iov[iovcnt].iov_base = d->data + d->sp; - nbyte += (iov[iovcnt].iov_len = d->cp - d->sp); - } - - if (!nbyte) - /* No data to flush: should we issue a warning message? */ - return BUFFER_EMPTY; - - /* only place where written should be sign compared */ - if ((ssize_t) (written = writev(fd, iov, iovcnt)) < 0) { - if (ERRNO_IO_RETRY(errno)) - /* Calling code should try again later. */ - return BUFFER_PENDING; - return BUFFER_ERROR; - } - - /* Free printed buffer data. */ - while (written > 0) { - struct buffer_data *d; - if (!(d = b->head)) - break; - if (written < d->cp - d->sp) { - d->sp += written; - return BUFFER_PENDING; - } - - written -= (d->cp - d->sp); - if (!(b->head = d->next)) - b->tail = NULL; - BUFFER_DATA_FREE(d); - } - - return b->head ? BUFFER_PENDING : BUFFER_EMPTY; - -#undef MAX_CHUNKS -#undef MAX_FLUSH -} - -buffer_status_t -buffer_write(struct buffer * b, int fd, const void *p, size_t size) -{ - ssize_t nbytes; - -#if 0 - /* Should we attempt to drain any previously buffered data? This could help reduce latency in pushing out the data if we are stuck in a long-running thread that is preventing the main select loop from calling the flush thread... */ - - if (b->head && (buffer_flush_available(b, fd) == BUFFER_ERROR)) - return BUFFER_ERROR; -#endif - if (b->head) - /* Buffer is not empty, so do not attempt to write the new data. */ - nbytes = 0; - else if ((nbytes = write(fd, p, size)) < 0) { - if (ERRNO_IO_RETRY(errno)) - nbytes = 0; - else - return BUFFER_ERROR; - } - /* Add any remaining data to the buffer. */ - { - size_t written = nbytes; - if (written < size) - buffer_put(b, ((const char *)p) + written, - size - written); - } - return b->head ? BUFFER_PENDING : BUFFER_EMPTY; -} |