Source Jam - openssh-4.3p2

00063 {
00064         void *p;
00065         p = buffer_append_space(buffer, len);
00066         memcpy(p, data, len);
00067 }

00077 {
00078         u_int newlen;
00079         void *p;
00080 
00081         if (len > BUFFER_MAX_CHUNK)
00082                 fatal("buffer_append_space: len %u not supported", len);
00083 
00084         /* If the buffer is empty, start using it from the beginning. */
00085         if (buffer->offset == buffer->end) {
00086                 buffer->offset = 0;
00087                 buffer->end = 0;
00088         }
00089 restart:
00090         /* If there is enough space to store all data, store it now. */
00091         if (buffer->end + len < buffer->alloc) {
00092                 p = buffer->buf + buffer->end;
00093                 buffer->end += len;
00094                 return p;
00095         }
00096         /*
00097          * If the buffer is quite empty, but all data is at the end, move the
00098          * data to the beginning and retry.
00099          */
00100         if (buffer->offset > MIN(buffer->alloc, BUFFER_MAX_CHUNK)) {
00101                 memmove(buffer->buf, buffer->buf + buffer->offset,
00102                         buffer->end - buffer->offset);
00103                 buffer->end -= buffer->offset;
00104                 buffer->offset = 0;
00105                 goto restart;
00106         }
00107         /* Increase the size of the buffer and retry. */
00108 
00109         newlen = buffer->alloc + len + 32768;
00110         if (newlen > BUFFER_MAX_LEN)
00111                 fatal("buffer_append_space: alloc %u not supported",
00112                     newlen);
00113         buffer->buf = xrealloc(buffer->buf, newlen);
00114         buffer->alloc = newlen;
00115         goto restart;
00116         /* NOTREACHED */
00117 }

00054 {
00055         buffer->offset = 0;
00056         buffer->end = 0;
00057 }

00164 {
00165         if (buffer_consume_ret(buffer, bytes) == -1)
00166                 fatal("buffer_consume: buffer error");
00167 }

00182 {
00183         if (buffer_consume_end_ret(buffer, bytes) == -1)
00184                 fatal("buffer_consume_end: trying to get more bytes than in buffer");
00185 }

00173 {
00174         if (bytes > buffer->end - buffer->offset)
00175                 return (-1);
00176         buffer->end -= bytes;
00177         return (0);
00178 }

00153 {
00154         if (bytes > buffer->end - buffer->offset) {
00155                 error("buffer_consume_ret: trying to get more bytes than in buffer");
00156                 return (-1);
00157         }
00158         buffer->offset += bytes;
00159         return (0);
00160 }

00199 {
00200         u_int i;
00201         u_char *ucp = buffer->buf;
00202 
00203         for (i = buffer->offset; i < buffer->end; i++) {
00204                 fprintf(stderr, "%02x", ucp[i]);
00205                 if ((i-buffer->offset)%16==15)
00206                         fprintf(stderr, "\r\n");
00207                 else if ((i-buffer->offset)%2==1)
00208                         fprintf(stderr, " ");
00209         }
00210         fprintf(stderr, "\r\n");
00211 }

00039 {
00040         if (buffer->alloc > 0) {
00041                 memset(buffer->buf, 0, buffer->alloc);
00042                 buffer->alloc = 0;
00043                 xfree(buffer->buf);
00044         }
00045 }

00144 {
00145         if (buffer_get_ret(buffer, buf, len) == -1)
00146                 fatal("buffer_get: buffer error");
00147 }

00131 {
00132         if (len > buffer->end - buffer->offset) {
00133                 error("buffer_get_ret: trying to get more bytes %d than in buffer %d",
00134                     len, buffer->end - buffer->offset);
00135                 return (-1);
00136         }
00137         memcpy(buf, buffer->buf + buffer->offset, len);
00138         buffer->offset += len;
00139         return (0);
00140 }

00025 {
00026         const u_int len = 4096;
00027 
00028         buffer->alloc = 0;
00029         buffer->buf = xmalloc(len);
00030         buffer->alloc = len;
00031         buffer->offset = 0;
00032         buffer->end = 0;
00033 }

00123 {
00124         return buffer->end - buffer->offset;
00125 }

00191 {
00192         return buffer->buf + buffer->offset;
00193 }


Classes
struct	Buffer
Defines
#define	BUFFER_MAX_CHUNK 0x100000
#define	BUFFER_MAX_LEN 0xa00000
Functions
void	buffer_init (Buffer *)
void	buffer_clear (Buffer *)
void	buffer_free (Buffer *)
u_int	buffer_len (Buffer *)
void *	buffer_ptr (Buffer *)
void	buffer_append (Buffer , const void , u_int)
void *	buffer_append_space (Buffer *, u_int)
void	buffer_get (Buffer , void , u_int)
void	buffer_consume (Buffer *, u_int)
void	buffer_consume_end (Buffer *, u_int)
void	buffer_dump (Buffer *)
int	buffer_get_ret (Buffer , void , u_int)
int	buffer_consume_ret (Buffer *, u_int)
int	buffer_consume_end_ret (Buffer *, u_int)

buffer.h File Reference

Classes

Defines

Functions

Define Documentation

Function Documentation