libio/iofopncook.c

   1 /* Copyright (C) 1993, 1995, 1997, 1999 Free Software Foundation, Inc.
   2    This file is part of the GNU IO Library.
   3
   4    This library is free software; you can redistribute it and/or
   5    modify it under the terms of the GNU General Public License as
   6    published by the Free Software Foundation; either version 2, or (at
   7    your option) any later version.
   8
   9    This library is distributed in the hope that it will be useful, but
  10    WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12    General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this library; see the file COPYING.  If not, write to
  16    the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
  17    MA 02111-1307, USA.
  18
  19    As a special exception, if you link this library with files
  20    compiled with a GNU compiler to produce an executable, this does
  21    not cause the resulting executable to be covered by the GNU General
  22    Public License.  This exception does not however invalidate any
  23    other reasons why the executable file might be covered by the GNU
  24    General Public License.  */
  25
  26 #include <libioP.h>
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29
  30
  31 /* Prototyped for local functions.  */
  32 static _IO_ssize_t _IO_cookie_read __P ((register _IO_FILE* fp, void* buf,
  33                                          _IO_ssize_t size));
  34 static _IO_ssize_t _IO_cookie_write __P ((register _IO_FILE* fp,
  35                                           const void* buf, _IO_ssize_t size));
  36 static _IO_off64_t _IO_cookie_seek __P ((_IO_FILE *fp, _IO_off64_t offset,
  37                                          int dir));
  38 static int _IO_cookie_close __P ((_IO_FILE* fp));
  39
  40
  41 static _IO_ssize_t
  42 _IO_cookie_read (fp, buf, size)
  43      _IO_FILE *fp;
  44      void *buf;
  45      _IO_ssize_t size;
  46 {
  47   struct _IO_cookie_file *cfile = (struct _IO_cookie_file *) fp;
  48
  49   if (cfile->__io_functions.read == NULL)
  50     return -1;
  51
  52   return cfile->__io_functions.read (cfile->__cookie, buf, size);
  53 }
  54
  55 static _IO_ssize_t
  56 _IO_cookie_write (fp, buf, size)
  57      _IO_FILE *fp;
  58      const void *buf;
  59      _IO_ssize_t size;
  60 {
  61   struct _IO_cookie_file *cfile = (struct _IO_cookie_file *) fp;
  62
  63   if (cfile->__io_functions.write == NULL)
  64     return -1;
  65
  66   return cfile->__io_functions.write (cfile->__cookie, buf, size);
  67 }
  68
  69 static _IO_off64_t
  70 _IO_cookie_seek (fp, offset, dir)
  71      _IO_FILE *fp;
  72      _IO_off64_t offset;
  73      int dir;
  74 {
  75   struct _IO_cookie_file *cfile = (struct _IO_cookie_file *) fp;
  76
  77   if (cfile->__io_functions.seek == NULL)
  78     return _IO_pos_BAD;
  79
  80   return cfile->__io_functions.seek (cfile->__cookie, offset, dir);
  81 }
  82
  83 static int
  84 _IO_cookie_close (fp)
  85      _IO_FILE *fp;
  86 {
  87   struct _IO_cookie_file *cfile = (struct _IO_cookie_file *) fp;
  88
  89   if (cfile->__io_functions.close == NULL)
  90     return 0;
  91
  92   return cfile->__io_functions.close (cfile->__cookie);
  93 }
  94
  95
  96 static struct _IO_jump_t _IO_cookie_jumps = {
  97   JUMP_INIT_DUMMY,
  98   JUMP_INIT(finish, _IO_file_finish),
  99   JUMP_INIT(overflow, _IO_file_overflow),
 100   JUMP_INIT(underflow, _IO_file_underflow),
 101   JUMP_INIT(uflow, _IO_default_uflow),
 102   JUMP_INIT(pbackfail, _IO_default_pbackfail),
 103   JUMP_INIT(xsputn, _IO_file_xsputn),
 104   JUMP_INIT(xsgetn, _IO_default_xsgetn),
 105   JUMP_INIT(seekoff, _IO_file_seekoff),
 106   JUMP_INIT(seekpos, _IO_default_seekpos),
 107   JUMP_INIT(setbuf, _IO_file_setbuf),
 108   JUMP_INIT(sync, _IO_file_sync),
 109   JUMP_INIT(doallocate, _IO_file_doallocate),
 110   JUMP_INIT(read, _IO_cookie_read),
 111   JUMP_INIT(write, _IO_cookie_write),
 112   JUMP_INIT(seek, _IO_cookie_seek),
 113   JUMP_INIT(close, _IO_cookie_close),
 114   JUMP_INIT(stat, _IO_default_stat),
 115   JUMP_INIT(showmanyc, _IO_default_showmanyc),
 116   JUMP_INIT(imbue, _IO_default_imbue),
 117 };
 118
 119
 120 _IO_FILE *
 121 fopencookie (cookie, mode, io_functions)
 122      void *cookie;
 123      const char *mode;
 124      _IO_cookie_io_functions_t io_functions;
 125 {
 126   int read_write;
 127   struct locked_FILE
 128   {
 129     struct _IO_cookie_file cfile;
 130 #ifdef _IO_MTSAFE_IO
 131     _IO_lock_t lock;
 132 #endif
 133   } *new_f;
 134
 135   switch (*mode++)
 136     {
 137     case 'r':
 138       read_write = _IO_NO_WRITES;
 139       break;
 140     case 'w':
 141       read_write = _IO_NO_READS;
 142       break;
 143     case 'a':
 144       read_write = _IO_NO_READS|_IO_IS_APPENDING;
 145       break;
 146     default:
 147       return NULL;
 148   }
 149   if (mode[0] == '+' || (mode[0] == 'b' && mode[1] == '+'))
 150     read_write &= _IO_IS_APPENDING;
 151
 152   new_f = (struct locked_FILE *) malloc (sizeof (struct locked_FILE));
 153   if (new_f == NULL)
 154     return NULL;
 155 #ifdef _IO_MTSAFE_IO
 156   new_f->cfile.__file._lock = &new_f->lock;
 157 #endif
 158
 159   _IO_init (&new_f->cfile.__file, 0);
 160   _IO_JUMPS (&new_f->cfile.__file) = &_IO_cookie_jumps;
 161   new_f->cfile.__cookie = cookie;
 162   new_f->cfile.__io_functions = io_functions;
 163
 164   _IO_file_init(&new_f->cfile.__file);
 165
 166   new_f->cfile.__file._IO_file_flags =
 167     _IO_mask_flags (&new_f->cfile.__file, read_write,
 168                     _IO_NO_READS+_IO_NO_WRITES+_IO_IS_APPENDING);
 169
 170   /* We use a negative number different from -1 for _fileno to mark that
 171      this special stream is not associated with a real file, but still has
 172      to be treated as such.  */
 173   new_f->cfile.__file._fileno = -2;
 174
 175   return &new_f->cfile.__file;
 176 }