service_runtime/gio_mem.c

   1 /*
   2  * Copyright 2008, Google Inc.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are
   7  * met:
   8  *
   9  *     * Redistributions of source code must retain the above copyright
  10  * notice, this list of conditions and the following disclaimer.
  11  *     * Redistributions in binary form must reproduce the above
  12  * copyright notice, this list of conditions and the following disclaimer
  13  * in the documentation and/or other materials provided with the
  14  * distribution.
  15  *     * Neither the name of Google Inc. nor the names of its
  16  * contributors may be used to endorse or promote products derived from
  17  * this software without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  20  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  22  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  23  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  24  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  25  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  29  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 /*
  33  * NaCl Generic I/O interface implementation: memory buffer-based I/O.
  34  */
  35 #include "native_client/include/portability.h"
  36
  37 #include <string.h>
  38 #include <errno.h>
  39
  40 #include "native_client/service_runtime/gio.h"
  41
  42 /*
  43  * Memory file is just read/write from/to an in-memory buffer.  Once
  44  * the buffer is consumed, there is no refilling/flushing.
  45  */
  46
  47 struct GioVtbl const    kGioMemoryFileVtbl = {
  48   GioMemoryFileRead,
  49   GioMemoryFileWrite,
  50   GioMemoryFileSeek,
  51   GioMemoryFileFlush,
  52   GioMemoryFileClose,
  53   GioMemoryFileDtor,
  54 };
  55
  56 int GioMemoryFileCtor(struct GioMemoryFile  *self,
  57                       char                  *buffer,
  58                       size_t                len)
  59 {
  60   self->buffer = buffer;
  61   self->len = len;
  62   self->curpos = 0;
  63
  64   self->base.vtbl = &kGioMemoryFileVtbl;
  65   return 1;
  66 }
  67
  68 int GioMemoryFileRead(struct Gio  *vself,
  69                       void        *buf,
  70                       size_t      count)
  71 {
  72   struct GioMemoryFile    *self = (struct GioMemoryFile *) vself;
  73   size_t                  remain;
  74   size_t                  newpos;
  75
  76   /* is size_t signed? */
  77   if (count < 0) {
  78     errno = EINVAL;
  79     return -1;
  80   }
  81
  82   /* 0 <= self->curpos && self->curpos <= self->len */
  83   remain = self->len - self->curpos;
  84   /* 0 <= remain <= self->len */
  85   if (count > remain) {
  86     count = remain;
  87   }
  88   /* 0 <= count && count <= remain */
  89   if (0 == count) {
  90     return 0;
  91   }
  92   newpos = self->curpos + count;
  93   /* self->curpos <= newpos && newpos <= self->len */
  94
  95   memcpy(buf, self->buffer + self->curpos, count);
  96   self->curpos = newpos;
  97   return count;
  98 }
  99
 100 int GioMemoryFileWrite(struct Gio *vself,
 101                        void       *buf,
 102                        size_t     count)
 103 {
 104   struct GioMemoryFile  *self = (struct GioMemoryFile *) vself;
 105   size_t                remain;
 106   size_t                newpos;
 107
 108   /* is size_t signed? */
 109   if (count < 0) {
 110     errno = EINVAL;
 111     return -1;
 112   }
 113
 114   /* 0 <= self->curpos && self->curpos <= self->len */
 115   remain = self->len - self->curpos;
 116   /* 0 <= remain <= self->len */
 117   if (count > remain) {
 118     count = remain;
 119   }
 120   /* 0 <= count && count <= remain */
 121   if (0 == count) {
 122     return 0;
 123   }
 124   newpos = self->curpos + count;
 125   /* self->curpos <= newpos && newpos <= self->len */
 126
 127   memcpy(self->buffer + self->curpos, buf, count);
 128   self->curpos = newpos;
 129   /* we never extend a memory file */
 130   return count;
 131 }
 132
 133 off_t GioMemoryFileSeek(struct Gio  *vself,
 134                         off_t       offset,
 135                         int         whence)
 136 {
 137   struct GioMemoryFile  *self = (struct GioMemoryFile *) vself;
 138   size_t                new_pos;
 139
 140   switch (whence) {
 141     case SEEK_SET:
 142       new_pos = offset;
 143       break;
 144     case SEEK_CUR:
 145       new_pos = self->curpos + offset;
 146       break;
 147     case SEEK_END:
 148       new_pos = self->len + offset;
 149       break;
 150     default:
 151       errno = EINVAL;
 152       return -1;
 153   }
 154   if (new_pos < 0 || new_pos > self->len) {
 155     errno = EINVAL;
 156     return -1;
 157   }
 158   self->curpos = new_pos;
 159   return new_pos;
 160 }
 161
 162 int GioMemoryFileClose(struct Gio *vself)
 163 {
 164   return 0;
 165 }
 166
 167 int GioMemoryFileFlush(struct Gio   *vself)
 168 {
 169   return 0;
 170 }
 171
 172 void  GioMemoryFileDtor(struct Gio    *vself)
 173 {
 174   return;
 175 }