libio/iofopncook.c

   1 /* Copyright (C) 1993,95,97,99,2000 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 #include <shlib-compat.h>
  30
  31 /* Prototyped for local functions.  */
  32 static _IO_ssize_t _IO_cookie_read (register _IO_FILE* fp, void* buf,
  33                                     _IO_ssize_t size);
  34 static _IO_ssize_t _IO_cookie_write (register _IO_FILE* fp,
  35                                      const void* buf, _IO_ssize_t size);
  36 static _IO_off64_t _IO_cookie_seek (_IO_FILE *fp, _IO_off64_t offset, int dir);
  37 static int _IO_cookie_close (_IO_FILE* fp);
  38 _IO_FILE * _IO_fopencookie (void *cookie, const char *mode,
  39                             _IO_cookie_io_functions_t io_functions);
  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   return ((cfile->__io_functions.seek == NULL
  78            || (cfile->__io_functions.seek (cfile->__cookie, &offset, dir)
  79                == (_IO_off64_t) -1))
  80           ? _IO_pos_BAD : offset);
  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 void
 121 _IO_cookie_init (struct _IO_cookie_file *cfile, int read_write,
 122                  void *cookie, _IO_cookie_io_functions_t io_functions)
 123 {
 124   _IO_init (&cfile->__file, 0);
 125   _IO_JUMPS (&cfile->__file) = &_IO_cookie_jumps;
 126
 127   cfile->__cookie = cookie;
 128   cfile->__io_functions = io_functions;
 129
 130   _IO_file_init(&cfile->__file);
 131
 132   cfile->__file._IO_file_flags =
 133     _IO_mask_flags (&cfile->__file, read_write,
 134                     _IO_NO_READS+_IO_NO_WRITES+_IO_IS_APPENDING);
 135
 136   /* We use a negative number different from -1 for _fileno to mark that
 137      this special stream is not associated with a real file, but still has
 138      to be treated as such.  */
 139   cfile->__file._fileno = -2;
 140 }
 141
 142
 143 _IO_FILE *
 144 _IO_fopencookie (cookie, mode, io_functions)
 145      void *cookie;
 146      const char *mode;
 147      _IO_cookie_io_functions_t io_functions;
 148 {
 149   int read_write;
 150   struct locked_FILE
 151   {
 152     struct _IO_cookie_file cfile;
 153 #ifdef _IO_MTSAFE_IO
 154     _IO_lock_t lock;
 155 #endif
 156   } *new_f;
 157
 158   switch (*mode++)
 159     {
 160     case 'r':
 161       read_write = _IO_NO_WRITES;
 162       break;
 163     case 'w':
 164       read_write = _IO_NO_READS;
 165       break;
 166     case 'a':
 167       read_write = _IO_NO_READS|_IO_IS_APPENDING;
 168       break;
 169     default:
 170       return NULL;
 171   }
 172   if (mode[0] == '+' || (mode[0] == 'b' && mode[1] == '+'))
 173     read_write &= _IO_IS_APPENDING;
 174
 175   new_f = (struct locked_FILE *) malloc (sizeof (struct locked_FILE));
 176   if (new_f == NULL)
 177     return NULL;
 178 #ifdef _IO_MTSAFE_IO
 179   new_f->cfile.__file._lock = &new_f->lock;
 180 #endif
 181
 182   _IO_cookie_init (&new_f->cfile, read_write, cookie, io_functions);
 183
 184   return &new_f->cfile.__file;
 185 }
 186
 187 versioned_symbol (libc, _IO_fopencookie, fopencookie, GLIBC_2_2);
 188
 189 #if SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_2)
 190
 191 static _IO_off64_t _IO_old_cookie_seek (_IO_FILE *fp, _IO_off64_t offset,
 192                                         int dir);
 193 _IO_FILE * _IO_old_fopencookie (void *cookie, const char *mode,
 194                                 _IO_cookie_io_functions_t io_functions);
 195
 196 static _IO_off64_t
 197 _IO_old_cookie_seek (fp, offset, dir)
 198      _IO_FILE *fp;
 199      _IO_off64_t offset;
 200      int dir;
 201 {
 202   struct _IO_cookie_file *cfile = (struct _IO_cookie_file *) fp;
 203   int (*seek) (_IO_FILE *, _IO_off_t, int);
 204   int ret;
 205
 206   seek = (int (*)(_IO_FILE *, _IO_off_t, int)) cfile->__io_functions.seek;
 207   if (seek == NULL)
 208     return _IO_pos_BAD;
 209
 210   ret = seek (cfile->__cookie, offset, dir);
 211
 212   return (ret == -1) ? _IO_pos_BAD : ret;
 213 }
 214
 215 static struct _IO_jump_t _IO_old_cookie_jumps = {
 216   JUMP_INIT_DUMMY,
 217   JUMP_INIT(finish, _IO_file_finish),
 218   JUMP_INIT(overflow, _IO_file_overflow),
 219   JUMP_INIT(underflow, _IO_file_underflow),
 220   JUMP_INIT(uflow, _IO_default_uflow),
 221   JUMP_INIT(pbackfail, _IO_default_pbackfail),
 222   JUMP_INIT(xsputn, _IO_file_xsputn),
 223   JUMP_INIT(xsgetn, _IO_default_xsgetn),
 224   JUMP_INIT(seekoff, _IO_file_seekoff),
 225   JUMP_INIT(seekpos, _IO_default_seekpos),
 226   JUMP_INIT(setbuf, _IO_file_setbuf),
 227   JUMP_INIT(sync, _IO_file_sync),
 228   JUMP_INIT(doallocate, _IO_file_doallocate),
 229   JUMP_INIT(read, _IO_cookie_read),
 230   JUMP_INIT(write, _IO_cookie_write),
 231   JUMP_INIT(seek, _IO_old_cookie_seek),
 232   JUMP_INIT(close, _IO_cookie_close),
 233   JUMP_INIT(stat, _IO_default_stat),
 234   JUMP_INIT(showmanyc, _IO_default_showmanyc),
 235   JUMP_INIT(imbue, _IO_default_imbue),
 236 };
 237
 238 _IO_FILE *
 239 _IO_old_fopencookie (cookie, mode, io_functions)
 240      void *cookie;
 241      const char *mode;
 242      _IO_cookie_io_functions_t io_functions;
 243 {
 244   _IO_FILE *ret;
 245
 246   ret = _IO_fopencookie (cookie, mode, io_functions);
 247   if (ret != NULL)
 248     _IO_JUMPS (ret) = &_IO_old_cookie_jumps;
 249
 250   return ret;
 251 }
 252
 253 compat_symbol (libc, _IO_old_fopencookie, fopencookie, GLIBC_2_0);
 254
 255 #endif