libio/strops.c

   1 /* Copyright (C) 1993-2023 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3
   4    The GNU C Library is free software; you can redistribute it and/or
   5    modify it under the terms of the GNU Lesser General Public
   6    License as published by the Free Software Foundation; either
   7    version 2.1 of the License, or (at your option) any later version.
   8
   9    The GNU C Library is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12    Lesser General Public License for more details.
  13
  14    You should have received a copy of the GNU Lesser General Public
  15    License along with the GNU C Library; if not, see
  16    <https://www.gnu.org/licenses/>.
  17
  18    As a special exception, if you link the code in this file with
  19    files compiled with a GNU compiler to produce an executable,
  20    that does not cause the resulting executable to be covered by
  21    the GNU Lesser General Public License.  This exception does not
  22    however invalidate any other reasons why the executable file
  23    might be covered by the GNU Lesser General Public License.
  24    This exception applies to code released by its copyright holders
  25    in files containing the exception.  */
  26
  27 #include <assert.h>
  28 #include "strfile.h"
  29 #include "libioP.h"
  30 #include <string.h>
  31 #include <stdio_ext.h>
  32
  33 void
  34 _IO_str_init_static_internal (_IO_strfile *sf, char *ptr, size_t size,
  35                               char *pstart)
  36 {
  37   FILE *fp = &sf->_sbf._f;
  38   char *end;
  39
  40   if (size == 0)
  41     end = strchr (ptr, '\0');
  42   else if ((size_t) ptr + size > (size_t) ptr)
  43     end = ptr + size;
  44   else
  45     end = (char *) -1;
  46   _IO_setb (fp, ptr, end, 0);
  47
  48   fp->_IO_write_base = ptr;
  49   fp->_IO_read_base = ptr;
  50   fp->_IO_read_ptr = ptr;
  51   if (pstart)
  52     {
  53       fp->_IO_write_ptr = pstart;
  54       fp->_IO_write_end = end;
  55       fp->_IO_read_end = pstart;
  56     }
  57   else
  58     {
  59       fp->_IO_write_ptr = ptr;
  60       fp->_IO_write_end = ptr;
  61       fp->_IO_read_end = end;
  62     }
  63   /* A null _allocate_buffer function flags the strfile as being static. */
  64   sf->_s._allocate_buffer_unused = (_IO_alloc_type) 0;
  65 }
  66
  67 void
  68 _IO_str_init_static (_IO_strfile *sf, char *ptr, int size, char *pstart)
  69 {
  70   return _IO_str_init_static_internal (sf, ptr, size < 0 ? -1 : size, pstart);
  71 }
  72
  73 void
  74 _IO_str_init_readonly (_IO_strfile *sf, const char *ptr, int size)
  75 {
  76   _IO_str_init_static_internal (sf, (char *) ptr, size < 0 ? -1 : size, NULL);
  77   sf->_sbf._f._flags |= _IO_NO_WRITES;
  78 }
  79
  80 int
  81 _IO_str_overflow (FILE *fp, int c)
  82 {
  83   int flush_only = c == EOF;
  84   size_t pos;
  85   if (fp->_flags & _IO_NO_WRITES)
  86       return flush_only ? 0 : EOF;
  87   if ((fp->_flags & _IO_TIED_PUT_GET) && !(fp->_flags & _IO_CURRENTLY_PUTTING))
  88     {
  89       fp->_flags |= _IO_CURRENTLY_PUTTING;
  90       fp->_IO_write_ptr = fp->_IO_read_ptr;
  91       fp->_IO_read_ptr = fp->_IO_read_end;
  92     }
  93   pos = fp->_IO_write_ptr - fp->_IO_write_base;
  94   if (pos >= (size_t) (_IO_blen (fp) + flush_only))
  95     {
  96       if (fp->_flags & _IO_USER_BUF) /* not allowed to enlarge */
  97         return EOF;
  98       else
  99         {
 100           char *new_buf;
 101           char *old_buf = fp->_IO_buf_base;
 102           size_t old_blen = _IO_blen (fp);
 103           size_t new_size = 2 * old_blen + 100;
 104           if (new_size < old_blen)
 105             return EOF;
 106           new_buf = malloc (new_size);
 107           if (new_buf == NULL)
 108             {
 109               /*          __ferror(fp) = 1; */
 110               return EOF;
 111             }
 112           if (old_buf)
 113             {
 114               memcpy (new_buf, old_buf, old_blen);
 115               free (old_buf);
 116               /* Make sure _IO_setb won't try to delete _IO_buf_base. */
 117               fp->_IO_buf_base = NULL;
 118             }
 119           memset (new_buf + old_blen, '\0', new_size - old_blen);
 120
 121           _IO_setb (fp, new_buf, new_buf + new_size, 1);
 122           fp->_IO_read_base = new_buf + (fp->_IO_read_base - old_buf);
 123           fp->_IO_read_ptr = new_buf + (fp->_IO_read_ptr - old_buf);
 124           fp->_IO_read_end = new_buf + (fp->_IO_read_end - old_buf);
 125           fp->_IO_write_ptr = new_buf + (fp->_IO_write_ptr - old_buf);
 126
 127           fp->_IO_write_base = new_buf;
 128           fp->_IO_write_end = fp->_IO_buf_end;
 129         }
 130     }
 131
 132   if (!flush_only)
 133     *fp->_IO_write_ptr++ = (unsigned char) c;
 134   if (fp->_IO_write_ptr > fp->_IO_read_end)
 135     fp->_IO_read_end = fp->_IO_write_ptr;
 136   if (flush_only)
 137     return 0;
 138   else
 139     return c;
 140 }
 141 libc_hidden_def (_IO_str_overflow)
 142
 143 int
 144 _IO_str_underflow (FILE *fp)
 145 {
 146   if (fp->_IO_write_ptr > fp->_IO_read_end)
 147     fp->_IO_read_end = fp->_IO_write_ptr;
 148   if ((fp->_flags & _IO_TIED_PUT_GET) && (fp->_flags & _IO_CURRENTLY_PUTTING))
 149     {
 150       fp->_flags &= ~_IO_CURRENTLY_PUTTING;
 151       fp->_IO_read_ptr = fp->_IO_write_ptr;
 152       fp->_IO_write_ptr = fp->_IO_write_end;
 153     }
 154   if (fp->_IO_read_ptr < fp->_IO_read_end)
 155     return *((unsigned char *) fp->_IO_read_ptr);
 156   else
 157     return EOF;
 158 }
 159 libc_hidden_def (_IO_str_underflow)
 160
 161 /* The size of the valid part of the buffer.  */
 162
 163 ssize_t
 164 _IO_str_count (FILE *fp)
 165 {
 166   return ((fp->_IO_write_ptr > fp->_IO_read_end
 167            ? fp->_IO_write_ptr : fp->_IO_read_end)
 168           - fp->_IO_read_base);
 169 }
 170
 171
 172 static int
 173 enlarge_userbuf (FILE *fp, off64_t offset, int reading)
 174 {
 175   if ((ssize_t) offset <= _IO_blen (fp))
 176     return 0;
 177
 178   ssize_t oldend = fp->_IO_write_end - fp->_IO_write_base;
 179
 180   /* Try to enlarge the buffer.  */
 181   if (fp->_flags & _IO_USER_BUF)
 182     /* User-provided buffer.  */
 183     return 1;
 184
 185   size_t newsize = offset + 100;
 186   char *oldbuf = fp->_IO_buf_base;
 187   char *newbuf = malloc (newsize);
 188   if (newbuf == NULL)
 189     return 1;
 190
 191   if (oldbuf != NULL)
 192     {
 193       memcpy (newbuf, oldbuf, _IO_blen (fp));
 194       free (oldbuf);
 195       /* Make sure _IO_setb won't try to delete
 196          _IO_buf_base. */
 197       fp->_IO_buf_base = NULL;
 198     }
 199
 200   _IO_setb (fp, newbuf, newbuf + newsize, 1);
 201
 202   if (reading)
 203     {
 204       fp->_IO_write_base = newbuf + (fp->_IO_write_base - oldbuf);
 205       fp->_IO_write_ptr = newbuf + (fp->_IO_write_ptr - oldbuf);
 206       fp->_IO_write_end = newbuf + (fp->_IO_write_end - oldbuf);
 207       fp->_IO_read_ptr = newbuf + (fp->_IO_read_ptr - oldbuf);
 208
 209       fp->_IO_read_base = newbuf;
 210       fp->_IO_read_end = fp->_IO_buf_end;
 211     }
 212   else
 213     {
 214       fp->_IO_read_base = newbuf + (fp->_IO_read_base - oldbuf);
 215       fp->_IO_read_ptr = newbuf + (fp->_IO_read_ptr - oldbuf);
 216       fp->_IO_read_end = newbuf + (fp->_IO_read_end - oldbuf);
 217       fp->_IO_write_ptr = newbuf + (fp->_IO_write_ptr - oldbuf);
 218
 219       fp->_IO_write_base = newbuf;
 220       fp->_IO_write_end = fp->_IO_buf_end;
 221     }
 222
 223   /* Clear the area between the last write position and th
 224      new position.  */
 225   assert (offset >= oldend);
 226   if (reading)
 227     memset (fp->_IO_read_base + oldend, '\0', offset - oldend);
 228   else
 229     memset (fp->_IO_write_base + oldend, '\0', offset - oldend);
 230
 231   return 0;
 232 }
 233
 234 static void
 235 _IO_str_switch_to_get_mode (FILE *fp)
 236 {
 237   if (_IO_in_backup (fp))
 238     fp->_IO_read_base = fp->_IO_backup_base;
 239   else
 240     {
 241       fp->_IO_read_base = fp->_IO_buf_base;
 242       if (fp->_IO_write_ptr > fp->_IO_read_end)
 243         fp->_IO_read_end = fp->_IO_write_ptr;
 244     }
 245   fp->_IO_read_ptr = fp->_IO_read_end = fp->_IO_write_ptr;
 246
 247   fp->_flags &= ~_IO_CURRENTLY_PUTTING;
 248 }
 249
 250 off64_t
 251 _IO_str_seekoff (FILE *fp, off64_t offset, int dir, int mode)
 252 {
 253   off64_t new_pos;
 254
 255   if (mode == 0 && (fp->_flags & _IO_TIED_PUT_GET))
 256     mode = (fp->_flags & _IO_CURRENTLY_PUTTING ? _IOS_OUTPUT : _IOS_INPUT);
 257
 258   bool was_writing = (fp->_IO_write_ptr > fp->_IO_write_base
 259                      || _IO_in_put_mode (fp));
 260   if (was_writing)
 261     _IO_str_switch_to_get_mode (fp);
 262
 263   if (mode == 0)
 264     {
 265       new_pos = fp->_IO_read_ptr - fp->_IO_read_base;
 266     }
 267   else
 268     {
 269       ssize_t cur_size = _IO_str_count(fp);
 270       new_pos = EOF;
 271
 272       /* Move the get pointer, if requested. */
 273       if (mode & _IOS_INPUT)
 274         {
 275           ssize_t base;
 276           switch (dir)
 277             {
 278             case _IO_seek_set:
 279               base = 0;
 280               break;
 281             case _IO_seek_cur:
 282               base = fp->_IO_read_ptr - fp->_IO_read_base;
 283               break;
 284             default: /* case _IO_seek_end: */
 285               base = cur_size;
 286               break;
 287             }
 288           ssize_t maxval = SSIZE_MAX - base;
 289           if (offset < -base || offset > maxval)
 290             {
 291               __set_errno (EINVAL);
 292               return EOF;
 293             }
 294           base += offset;
 295           if (base > cur_size
 296               && enlarge_userbuf (fp, base, 1) != 0)
 297             return EOF;
 298           fp->_IO_read_ptr = fp->_IO_read_base + base;
 299           fp->_IO_read_end = fp->_IO_read_base + cur_size;
 300           new_pos = base;
 301         }
 302
 303       /* Move the put pointer, if requested. */
 304       if (mode & _IOS_OUTPUT)
 305         {
 306           ssize_t base;
 307           switch (dir)
 308             {
 309             case _IO_seek_set:
 310               base = 0;
 311               break;
 312             case _IO_seek_cur:
 313               base = fp->_IO_write_ptr - fp->_IO_write_base;
 314               break;
 315             default: /* case _IO_seek_end: */
 316               base = cur_size;
 317               break;
 318             }
 319           ssize_t maxval = SSIZE_MAX - base;
 320           if (offset < -base || offset > maxval)
 321             {
 322               __set_errno (EINVAL);
 323               return EOF;
 324             }
 325           base += offset;
 326           if (base > cur_size
 327               && enlarge_userbuf (fp, base, 0) != 0)
 328             return EOF;
 329           fp->_IO_write_ptr = fp->_IO_write_base + base;
 330           new_pos = base;
 331         }
 332     }
 333   return new_pos;
 334 }
 335 libc_hidden_def (_IO_str_seekoff)
 336
 337 int
 338 _IO_str_pbackfail (FILE *fp, int c)
 339 {
 340   if ((fp->_flags & _IO_NO_WRITES) && c != EOF)
 341     return EOF;
 342   return _IO_default_pbackfail (fp, c);
 343 }
 344 libc_hidden_def (_IO_str_pbackfail)
 345
 346 void
 347 _IO_str_finish (FILE *fp, int dummy)
 348 {
 349   if (fp->_IO_buf_base && !(fp->_flags & _IO_USER_BUF))
 350     free (fp->_IO_buf_base);
 351   fp->_IO_buf_base = NULL;
 352
 353   _IO_default_finish (fp, 0);
 354 }