Return to buffer.h CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / lib

Annotation of embedaddon/quagga/lib/buffer.h, revision 1.1.1.1

1.1       misho       1: /*
                      2:  * Buffering to 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: #ifndef _ZEBRA_BUFFER_H
                     24: #define _ZEBRA_BUFFER_H
                     25: 
                     26: 
                     27: /* Create a new buffer.  Memory will be allocated in chunks of the given
                     28:    size.  If the argument is 0, the library will supply a reasonable
                     29:    default size suitable for buffering socket I/O. */
                     30: extern struct buffer *buffer_new (size_t);
                     31: 
                     32: /* Free all data in the buffer. */
                     33: extern void buffer_reset (struct buffer *);
                     34: 
                     35: /* This function first calls buffer_reset to release all buffered data.
                     36:    Then it frees the struct buffer itself. */
                     37: extern void buffer_free (struct buffer *);
                     38: 
                     39: /* Add the given data to the end of the buffer. */
                     40: extern void buffer_put (struct buffer *, const void *, size_t);
                     41: /* Add a single character to the end of the buffer. */
                     42: extern void buffer_putc (struct buffer *, u_char);
                     43: /* Add a NUL-terminated string to the end of the buffer. */
                     44: extern void buffer_putstr (struct buffer *, const char *);
                     45: 
                     46: /* Combine all accumulated (and unflushed) data inside the buffer into a
                     47:    single NUL-terminated string allocated using XMALLOC(MTYPE_TMP).  Note
                     48:    that this function does not alter the state of the buffer, so the data
                     49:    is still inside waiting to be flushed. */
                     50: char *buffer_getstr (struct buffer *);
                     51: 
                     52: /* Returns 1 if there is no pending data in the buffer.  Otherwise returns 0. */
                     53: int buffer_empty (struct buffer *);
                     54: 
                     55: typedef enum
                     56:   {
                     57:     /* An I/O error occurred.  The buffer should be destroyed and the
                     58:        file descriptor should be closed. */
                     59:     BUFFER_ERROR = -1,
                     60: 
                     61:     /* The data was written successfully, and the buffer is now empty
                     62:        (there is no pending data waiting to be flushed). */
                     63:     BUFFER_EMPTY = 0,
                     64: 
                     65:     /* There is pending data in the buffer waiting to be flushed.  Please
                     66:        try flushing the buffer when select indicates that the file descriptor
                     67:        is writeable. */
                     68:     BUFFER_PENDING = 1
                     69:   } buffer_status_t;
                     70: 
                     71: /* Try to write this data to the file descriptor.  Any data that cannot
                     72:    be written immediately is added to the buffer queue. */
                     73: extern buffer_status_t buffer_write(struct buffer *, int fd,
                     74:                                    const void *, size_t);
                     75: 
                     76: /* This function attempts to flush some (but perhaps not all) of 
                     77:    the queued data to the given file descriptor. */
                     78: extern buffer_status_t buffer_flush_available(struct buffer *, int fd);
                     79: 
                     80: /* The following 2 functions (buffer_flush_all and buffer_flush_window)
                     81:    are for use in lib/vty.c only.  They should not be used elsewhere. */
                     82: 
                     83: /* Call buffer_flush_available repeatedly until either all data has been
                     84:    flushed, or an I/O error has been encountered, or the operation would
                     85:    block. */
                     86: extern buffer_status_t buffer_flush_all (struct buffer *, int fd);
                     87: 
                     88: /* Attempt to write enough data to the given fd to fill a window of the
                     89:    given width and height (and remove the data written from the buffer).
                     90: 
                     91:    If !no_more, then a message saying " --More-- " is appended. 
                     92:    If erase is true, then first overwrite the previous " --More-- " message
                     93:    with spaces.
                     94: 
                     95:    Any write error (including EAGAIN or EINTR) will cause this function
                     96:    to return -1 (because the logic for handling the erase and more features
                     97:    is too complicated to retry the write later).
                     98: */
                     99: extern buffer_status_t buffer_flush_window (struct buffer *, int fd, int width,
                    100:                                            int height, int erase, int no_more);
                    101: 
                    102: #endif /* _ZEBRA_BUFFER_H */