camel/camel-stream-buffer.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8; fill-column: 160 -*- */
   2
   3 /* camel-stream-buffer.c : Buffer any other other stream
   4  *
   5  * Authors: Michael Zucchi <notzed@ximian.com>
   6  *
   7  * Copyright 1999-2003 Ximian, Inc. (www.ximian.com)
   8  *
   9  * This program is free software; you can redistribute it and/or
  10  * modify it under the terms of version 2 of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
  21  * USA
  22  */
  23
  24 #ifdef HAVE_CONFIG_H
  25 #include <config.h>
  26 #endif
  27
  28 #include <errno.h>
  29 #include <fcntl.h>
  30 #include <string.h>
  31 #include <sys/stat.h>
  32 #include <sys/types.h>
  33
  34 #include "camel-stream-buffer.h"
  35
  36 static CamelStreamClass *parent_class = NULL;
  37
  38 enum {
  39         BUF_USER = 1<<0,        /* user-supplied buffer, do not free */
  40 };
  41
  42 #define BUF_SIZE 1024
  43
  44 static ssize_t stream_read (CamelStream *stream, char *buffer, size_t n);
  45 static ssize_t stream_write (CamelStream *stream, const char *buffer, size_t n);
  46 static int stream_flush (CamelStream *stream);
  47 static int stream_close (CamelStream *stream);
  48 static gboolean stream_eos (CamelStream *stream);
  49
  50 static void init_vbuf(CamelStreamBuffer *sbf, CamelStream *s, CamelStreamBufferMode mode, char *buf, guint32 size);
  51 static void init(CamelStreamBuffer *sbuf, CamelStream *s, CamelStreamBufferMode mode);
  52
  53 static void
  54 camel_stream_buffer_class_init (CamelStreamBufferClass *camel_stream_buffer_class)
  55 {
  56         CamelStreamClass *camel_stream_class = CAMEL_STREAM_CLASS (camel_stream_buffer_class);
  57
  58         parent_class = CAMEL_STREAM_CLASS (camel_type_get_global_classfuncs (camel_stream_get_type ()));
  59
  60         /* virtual method definition */
  61         camel_stream_buffer_class->init = init;
  62         camel_stream_buffer_class->init_vbuf = init_vbuf;
  63
  64         /* virtual method overload */
  65         camel_stream_class->read = stream_read;
  66         camel_stream_class->write = stream_write;
  67         camel_stream_class->flush = stream_flush;
  68         camel_stream_class->close = stream_close;
  69         camel_stream_class->eos = stream_eos;
  70 }
  71
  72 static void
  73 camel_stream_buffer_init (gpointer object, gpointer klass)
  74 {
  75         CamelStreamBuffer *sbf = CAMEL_STREAM_BUFFER (object);
  76
  77         sbf->flags = 0;
  78         sbf->size = BUF_SIZE;
  79         sbf->buf = g_malloc(BUF_SIZE);
  80         sbf->ptr = sbf->buf;
  81         sbf->end = sbf->buf;
  82         sbf->mode = CAMEL_STREAM_BUFFER_READ | CAMEL_STREAM_BUFFER_BUFFER;
  83         sbf->stream = 0;
  84         sbf->linesize = 80;
  85         sbf->linebuf = g_malloc(sbf->linesize);
  86 }
  87
  88 static void
  89 camel_stream_buffer_finalize (CamelObject *object)
  90 {
  91         CamelStreamBuffer *sbf = CAMEL_STREAM_BUFFER (object);
  92
  93         if (!(sbf->flags & BUF_USER)) {
  94                 g_free(sbf->buf);
  95         }
  96         if (sbf->stream)
  97                 camel_object_unref (sbf->stream);
  98
  99         g_free(sbf->linebuf);
 100 }
 101
 102
 103 CamelType
 104 camel_stream_buffer_get_type (void)
 105 {
 106         static CamelType camel_stream_buffer_type = CAMEL_INVALID_TYPE;
 107
 108         if (camel_stream_buffer_type == CAMEL_INVALID_TYPE)     {
 109                 camel_stream_buffer_type = camel_type_register (camel_stream_get_type (), "CamelStreamBuffer",
 110                                                                 sizeof (CamelStreamBuffer),
 111                                                                 sizeof (CamelStreamBufferClass),
 112                                                                 (CamelObjectClassInitFunc) camel_stream_buffer_class_init,
 113                                                                 NULL,
 114                                                                 (CamelObjectInitFunc) camel_stream_buffer_init,
 115                                                                 (CamelObjectFinalizeFunc) camel_stream_buffer_finalize);
 116         }
 117
 118         return camel_stream_buffer_type;
 119 }
 120
 121
 122 static void
 123 set_vbuf(CamelStreamBuffer *sbf, char *buf, CamelStreamBufferMode mode, int size)
 124 {
 125         if (sbf->buf && !(sbf->flags & BUF_USER)) {
 126                 g_free(sbf->buf);
 127         }
 128         if (buf) {
 129                 sbf->buf = buf;
 130                 sbf->flags |= BUF_USER;
 131         } else {
 132                 sbf->buf = g_malloc(size);
 133                 sbf->flags &= ~BUF_USER;
 134         }
 135
 136         sbf->ptr = sbf->buf;
 137         sbf->end = sbf->buf;
 138         sbf->size = size;
 139         sbf->mode = mode;
 140 }
 141
 142 static void
 143 init_vbuf(CamelStreamBuffer *sbf, CamelStream *s, CamelStreamBufferMode mode, char *buf, guint32 size)
 144 {
 145         set_vbuf(sbf, buf, mode, size);
 146         if (sbf->stream)
 147                 camel_object_unref (sbf->stream);
 148         sbf->stream = s;
 149         camel_object_ref (sbf->stream);
 150 }
 151
 152 static void
 153 init(CamelStreamBuffer *sbuf, CamelStream *s, CamelStreamBufferMode mode)
 154 {
 155         init_vbuf(sbuf, s, mode, NULL, BUF_SIZE);
 156 }
 157
 158
 159 /**
 160  * camel_stream_buffer_new:
 161  * @stream: a #CamelStream object to buffer
 162  * @mode: Operational mode of buffered stream.
 163  *
 164  * Create a new buffered stream of another stream.  A default
 165  * buffer size (1024 bytes), automatically managed will be used
 166  * for buffering.
 167  *
 168  * See #camel_stream_buffer_new_with_vbuf for details on the
 169  * @mode parameter.
 170  *
 171  * Returns a newly created buffered stream.
 172  **/
 173 CamelStream *
 174 camel_stream_buffer_new (CamelStream *stream, CamelStreamBufferMode mode)
 175 {
 176         CamelStreamBuffer *sbf;
 177
 178         sbf = CAMEL_STREAM_BUFFER (camel_object_new (camel_stream_buffer_get_type ()));
 179         CAMEL_STREAM_BUFFER_CLASS (CAMEL_OBJECT_GET_CLASS(sbf))->init (sbf, stream, mode);
 180
 181         return CAMEL_STREAM (sbf);
 182 }
 183
 184 /**
 185  * camel_stream_buffer_new_with_vbuf:
 186  * @stream: An existing stream to buffer.
 187  * @mode: Mode to buffer in.
 188  * @buf: Memory to use for buffering.
 189  * @size: Size of buffer to use.
 190  *
 191  * Create a new stream which buffers another stream, @stream.
 192  *
 193  * The following values are available for @mode:
 194  *
 195  * #CAMEL_STREAM_BUFFER_BUFFER, Buffer the input/output in blocks.
 196  * #CAMEL_STREAM_BUFFER_NEWLINE, Buffer on newlines (for output).
 197  * #CAMEL_STREAM_BUFFER_NONE, Perform no buffering.
 198  *
 199  * Note that currently this is ignored and #CAMEL_STREAM_BUFFER_BUFFER
 200  * is always used.
 201  *
 202  * In addition, one of the following mode options should be or'd
 203  * together with the buffering mode:
 204  *
 205  * #CAMEL_STREAM_BUFFER_WRITE, Buffer in write mode.
 206  * #CAMEL_STREAM_BUFFER_READ, Buffer in read mode.
 207  *
 208  * Buffering can only be done in one direction for any
 209  * buffer instance.
 210  *
 211  * If @buf is non-NULL, then use the memory pointed to
 212  * (for upto @size bytes) as the buffer for all buffering
 213  * operations.  It is upto the application to free this buffer.
 214  * If @buf is NULL, then allocate and manage @size bytes
 215  * for all buffering.
 216  *
 217  * Return value: A new stream with buffering applied.
 218  **/
 219 CamelStream *
 220 camel_stream_buffer_new_with_vbuf (CamelStream *stream, CamelStreamBufferMode mode, char *buf, guint32 size)
 221 {
 222         CamelStreamBuffer *sbf;
 223         sbf = CAMEL_STREAM_BUFFER (camel_object_new (camel_stream_buffer_get_type ()));
 224         CAMEL_STREAM_BUFFER_CLASS (CAMEL_OBJECT_GET_CLASS(sbf))->init_vbuf (sbf, stream, mode, buf, size);
 225
 226         return CAMEL_STREAM (sbf);
 227 }
 228
 229 static ssize_t
 230 stream_read (CamelStream *stream, char *buffer, size_t n)
 231 {
 232         CamelStreamBuffer *sbf = CAMEL_STREAM_BUFFER (stream);
 233         ssize_t bytes_read = 1;
 234         ssize_t bytes_left;
 235         char *bptr = buffer;
 236
 237         g_return_val_if_fail( (sbf->mode & CAMEL_STREAM_BUFFER_MODE) == CAMEL_STREAM_BUFFER_READ, 0);
 238
 239         while (n && bytes_read > 0) {
 240                 bytes_left = sbf->end - sbf->ptr;
 241                 if (bytes_left < n) {
 242                         if (bytes_left > 0) {
 243                                 memcpy(bptr, sbf->ptr, bytes_left);
 244                                 n -= bytes_left;
 245                                 bptr += bytes_left;
 246                                 sbf->ptr += bytes_left;
 247                         }
 248                         /* if we are reading a lot, then read directly to the destination buffer */
 249                         if (n >= sbf->size/3) {
 250                                 bytes_read = camel_stream_read(sbf->stream, bptr, n);
 251                                 if (bytes_read>0) {
 252                                         n -= bytes_read;
 253                                         bptr += bytes_read;
 254                                 }
 255                         } else {
 256                                 bytes_read = camel_stream_read(sbf->stream, sbf->buf, sbf->size);
 257                                 if (bytes_read>0) {
 258                                         size_t bytes_used = bytes_read > n ? n : bytes_read;
 259                                         sbf->ptr = sbf->buf;
 260                                         sbf->end = sbf->buf+bytes_read;
 261                                         memcpy(bptr, sbf->ptr, bytes_used);
 262                                         sbf->ptr += bytes_used;
 263                                         bptr += bytes_used;
 264                                         n -= bytes_used;
 265                                 }
 266                         }
 267                 } else {
 268                         memcpy(bptr, sbf->ptr, n);
 269                         sbf->ptr += n;
 270                         bptr += n;
 271                         n = 0;
 272                 }
 273         }
 274
 275         return (ssize_t)(bptr - buffer);
 276 }
 277
 278 /* only returns the number passed in, or -1 on an error */
 279 static ssize_t
 280 stream_write_all(CamelStream *stream, const char *buffer, size_t n)
 281 {
 282         size_t left = n, w;
 283
 284         while (left > 0) {
 285                 w = camel_stream_write(stream, buffer, left);
 286                 if (w == -1)
 287                         return -1;
 288                 left -= w;
 289                 buffer += w;
 290         }
 291
 292         return n;
 293 }
 294
 295 static ssize_t
 296 stream_write (CamelStream *stream, const char *buffer, size_t n)
 297 {
 298         CamelStreamBuffer *sbf = CAMEL_STREAM_BUFFER (stream);
 299         ssize_t total = n;
 300         ssize_t left, todo;
 301
 302         g_return_val_if_fail( (sbf->mode & CAMEL_STREAM_BUFFER_MODE) == CAMEL_STREAM_BUFFER_WRITE, 0);
 303
 304         /* first, copy as much as we can */
 305         left = sbf->size - (sbf->ptr-sbf->buf);
 306         todo = MIN(left, n);
 307
 308         memcpy(sbf->ptr, buffer, todo);
 309         n -= todo;
 310         buffer += todo;
 311         sbf->ptr += todo;
 312
 313         /* if we've filled the buffer, write it out, reset buffer */
 314         if (left == todo) {
 315                 if (stream_write_all(sbf->stream, sbf->buf, sbf->size) == -1)
 316                         return -1;
 317
 318                 sbf->ptr = sbf->buf;
 319         }
 320
 321         /* if we still have more, write directly, or copy to buffer */
 322         if (n > 0) {
 323                 if (n >= sbf->size/3) {
 324                         if (stream_write_all(sbf->stream, buffer, n) == -1)
 325                                 return -1;
 326                 } else {
 327                         memcpy(sbf->ptr, buffer, n);
 328                         sbf->ptr += n;
 329                 }
 330         }
 331
 332         return total;
 333 }
 334
 335 static int
 336 stream_flush (CamelStream *stream)
 337 {
 338         CamelStreamBuffer *sbf = CAMEL_STREAM_BUFFER (stream);
 339
 340         if ((sbf->mode & CAMEL_STREAM_BUFFER_MODE) == CAMEL_STREAM_BUFFER_WRITE) {
 341                 size_t len = sbf->ptr - sbf->buf;
 342
 343                 if (camel_stream_write (sbf->stream, sbf->buf, len) == -1)
 344                         return -1;
 345
 346                 sbf->ptr = sbf->buf;
 347         } else {
 348                 /* nothing to do for read mode 'flush' */
 349         }
 350
 351         return camel_stream_flush(sbf->stream);
 352 }
 353
 354 static int
 355 stream_close (CamelStream *stream)
 356 {
 357         CamelStreamBuffer *sbf = CAMEL_STREAM_BUFFER (stream);
 358
 359         if (stream_flush(stream) == -1)
 360                 return -1;
 361         return camel_stream_close(sbf->stream);
 362 }
 363
 364 static gboolean
 365 stream_eos (CamelStream *stream)
 366 {
 367         CamelStreamBuffer *sbf = CAMEL_STREAM_BUFFER (stream);
 368
 369         return camel_stream_eos(sbf->stream) && sbf->ptr == sbf->end;
 370 }
 371
 372 /**
 373  * camel_stream_buffer_gets:
 374  * @sbf: a #CamelStreamBuffer object
 375  * @buf: Memory to write the string to.
 376  * @max: Maxmimum number of characters to store.
 377  *
 378  * Read a line of characters up to the next newline character or
 379  * @max-1 characters.
 380  *
 381  * If the newline character is encountered, then it will be
 382  * included in the buffer @buf.  The buffer will be #NUL terminated.
 383  *
 384  * Returns the number of characters read, or %0 for end of file,
 385  * and %-1 on error.
 386  **/
 387 int
 388 camel_stream_buffer_gets(CamelStreamBuffer *sbf, char *buf, unsigned int max)
 389 {
 390         register char *outptr, *inptr, *inend, c, *outend;
 391         int bytes_read;
 392
 393         outptr = buf;
 394         inptr = sbf->ptr;
 395         inend = sbf->end;
 396         outend = buf+max-1;     /* room for NUL */
 397
 398         do {
 399                 while (inptr<inend && outptr<outend) {
 400                         c = *inptr++;
 401                         *outptr++ = c;
 402                         if (c == '\n') {
 403                                 *outptr = 0;
 404                                 sbf->ptr = inptr;
 405                                 return outptr-buf;
 406                         }
 407                 }
 408                 if (outptr == outend)
 409                         break;
 410
 411                 bytes_read = camel_stream_read (sbf->stream, sbf->buf, sbf->size);
 412                 if (bytes_read == -1) {
 413                         if (buf == outptr)
 414                                 return -1;
 415                         else
 416                                 bytes_read = 0;
 417                 }
 418                 inptr = sbf->ptr = sbf->buf;
 419                 inend = sbf->end = sbf->buf + bytes_read;
 420         } while (bytes_read>0);
 421
 422         sbf->ptr = inptr;
 423         *outptr = 0;
 424
 425         return (int)(outptr - buf);
 426 }
 427
 428 /**
 429  * camel_stream_buffer_read_line: read a complete line from the stream
 430  * @sbf: a #CamelStreamBuffer object
 431  *
 432  * This function reads a complete newline-terminated line from the stream
 433  * and returns it in allocated memory. The trailing newline (and carriage
 434  * return if any) are not included in the returned string.
 435  *
 436  * Returns the line read, which the caller must free when done with,
 437  * or %NULL on eof. If an error occurs, @ex will be set.
 438  **/
 439 char *
 440 camel_stream_buffer_read_line (CamelStreamBuffer *sbf)
 441 {
 442         unsigned char *p;
 443         int nread;
 444
 445         p = sbf->linebuf;
 446
 447         while (1) {
 448                 nread = camel_stream_buffer_gets (sbf, p, sbf->linesize - (p - sbf->linebuf));
 449                 if (nread <=0) {
 450                         if (p > sbf->linebuf)
 451                                 break;
 452                         return NULL;
 453                 }
 454
 455                 p += nread;
 456                 if (p[-1] == '\n')
 457                         break;
 458
 459                 nread = p - sbf->linebuf;
 460                 sbf->linesize *= 2;
 461                 sbf->linebuf = g_realloc (sbf->linebuf, sbf->linesize);
 462                 p = sbf->linebuf + nread;
 463         }
 464
 465         p--;
 466         if (p > sbf->linebuf && p[-1] == '\r')
 467                 p--;
 468         p[0] = 0;
 469
 470         return g_strdup(sbf->linebuf);
 471 }