text: /*
   * This file is part of the MicroPython project, http://micropython.org/
   *
   * The MIT License (MIT)
   *
   * SPDX-FileCopyrightText: Copyright (c) 2013, 2014 Damien P. George
   * Copyright (c) 2014 Paul Sokolovsky
   *
   * Permission is hereby granted, free of charge, to any person obtaining a copy
   * of this software and associated documentation files (the "Software"), to deal
   * in the Software without restriction, including without limitation the rights
   * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   * copies of the Software, and to permit persons to whom the Software is
   * furnished to do so, subject to the following conditions:
   *
   * The above copyright notice and this permission notice shall be included in
   * all copies or substantial portions of the Software.
   *
   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
   * THE SOFTWARE.
   */
  
  #include <string.h>
  #include <unistd.h>
  
  #include "py/objstr.h"
  #include "py/stream.h"
  #include "py/runtime.h"
  #include "supervisor/shared/translate.h"
  
  // This file defines generic Python stream read/write methods which
  // dispatch to the underlying stream interface of an object.
  
  // TODO: should be in mpconfig.h
  #define DEFAULT_BUFFER_SIZE 256
  
  STATIC mp_obj_t stream_readall(mp_obj_t self_in);
  
  #define STREAM_CONTENT_TYPE(stream) (((stream)->is_text) ? &mp_type_str : &mp_type_bytes)
  
  // Returns error condition in *errcode, if non-zero, return value is number of bytes written
  // before error condition occurred. If *errcode == 0, returns total bytes written (which will
  // be equal to input size).
  mp_uint_t mp_stream_rw(mp_obj_t stream, void *buf_, mp_uint_t size, int *errcode, byte flags) {
      byte *buf = buf_;
      typedef mp_uint_t (*io_func_t)(mp_obj_t obj, void *buf, mp_uint_t size, int *errcode);
      io_func_t io_func;
      const mp_stream_p_t *stream_p = mp_get_stream(stream);
      if (flags & MP_STREAM_RW_WRITE) {
          io_func = (io_func_t)stream_p->write;
      } else {
          io_func = stream_p->read;
      }
  
      *errcode = 0;
      mp_uint_t done = 0;
      while (size > 0) {
          mp_uint_t out_sz = io_func(stream, buf, size, errcode);
          // For read, out_sz == 0 means EOF. For write, it's unspecified
          // what it means, but we don't make any progress, so returning
          // is still the best option.
          if (out_sz == 0) {
              return done;
          }
          if (out_sz == MP_STREAM_ERROR) {
              // If we read something before getting EAGAIN, don't leak it
              if (mp_is_nonblocking_error(*errcode) && done != 0) {
                  *errcode = 0;
              }
              return done;
          }
          if (flags & MP_STREAM_RW_ONCE) {
              return out_sz;
          }
  
          buf += out_sz;
          size -= out_sz;
          done += out_sz;
      }
      return done;
  }
  
  const mp_stream_p_t *mp_get_stream_raise(mp_obj_t self_in, int flags) {
      const mp_stream_p_t *stream_p = mp_proto_get(MP_QSTR_protocol_stream, self_in);
      if (stream_p == NULL
          || ((flags & MP_STREAM_OP_READ) && stream_p->read == NULL)
          || ((flags & MP_STREAM_OP_WRITE) && stream_p->write == NULL)
          || ((flags & MP_STREAM_OP_IOCTL) && stream_p->ioctl == NULL)) {
          // CPython: io.UnsupportedOperation, OSError subclass
          mp_raise_msg(&mp_type_OSError, translate("stream operation not supported"));
      }
      return stream_p;
  }
  
  STATIC mp_obj_t stream_read_generic(size_t n_args, const mp_obj_t *args, byte flags) {
      // What to do if sz < -1?  Python docs don't specify this case.
      // CPython does a readall, let's do the same.
      mp_int_t sz;
      const mp_stream_p_t *stream_p = mp_get_stream(args[0]);
      if (stream_p->pyserial_read_compatibility) {
          // Pyserial defaults to sz=1 if not specified.
          if (n_args == 1) {
              sz = 1;
          } else {
              // Pyserial treats negative size as 0.
              sz = MAX(0, mp_obj_get_int(args[1]));
          }
      } else {
          if (n_args == 1 || args[1] == mp_const_none || (sz = mp_obj_get_int(args[1])) <= -1) {
              return stream_readall(args[0]);
          }
      }
  
      #if MICROPY_PY_BUILTINS_STR_UNICODE
      if (stream_p->is_text) {
          // We need to read sz number of unicode characters.  Because we don't have any
          // buffering, and because the stream API can only read bytes, we must read here
          // in units of bytes and must never over read.  If we want sz chars, then reading
          // sz bytes will never over-read, so we follow this approach, in a loop to keep
          // reading until we have exactly enough chars.  This will be 1 read for text
          // with ASCII-only chars, and about 2 reads for text with a couple of non-ASCII
          // chars.  For text with lots of non-ASCII chars, it'll be pretty inefficient
          // in time and memory.
  
          vstr_t vstr;
          vstr_init(&vstr, sz);
          mp_uint_t more_bytes = sz;
          mp_uint_t last_buf_offset = 0;
          while (more_bytes > 0) {
              char *p = vstr_add_len(&vstr, more_bytes);
              int error;
              mp_uint_t out_sz = mp_stream_read_exactly(args[0], p, more_bytes, &error);
              if (error != 0) {
                  vstr_cut_tail_bytes(&vstr, more_bytes);
                  if (mp_is_nonblocking_error(error)) {
                      // With non-blocking streams, we read as much as we can.
                      // If we read nothing, return None, just like read().
                      // Otherwise, return data read so far.
                      // TODO what if we have read only half a non-ASCII char?
                      if (vstr.len == 0) {
                          vstr_clear(&vstr);
                          return mp_const_none;
                      }
                      break;
                  }
                  mp_raise_OSError(error);
              }
  
              if (out_sz < more_bytes) {
                  // Finish reading.
                  // TODO what if we have read only half a non-ASCII char?
                  vstr_cut_tail_bytes(&vstr, more_bytes - out_sz);
                  if (out_sz == 0) {
                      break;
                  }
              }
  
              // count chars from bytes just read
              for (mp_uint_t off = last_buf_offset;;) {
                  byte b = vstr.buf[off];
                  int n;
                  if (!UTF8_IS_NONASCII(b)) {
                      // 1-byte ASCII char
                      n = 1;
                  } else if ((b & 0xe0) == 0xc0) {
                      // 2-byte char
                      n = 2;
                  } else if ((b & 0xf0) == 0xe0) {
                      // 3-byte char
                      n = 3;
                  } else if ((b & 0xf8) == 0xf0) {
                      // 4-byte char
                      n = 4;
                  } else {
                      // TODO
                      n = 5;
                  }
                  if (off + n <= vstr.len) {
                      // got a whole char in n bytes
                      off += n;
                      sz -= 1;
                      last_buf_offset = off;
                      if (off >= vstr.len) {
                          more_bytes = sz;
                          break;
                      }
                  } else {
                      // didn't get a whole char, so work out how many extra bytes are needed for
                      // this partial char, plus bytes for additional chars that we want
                      more_bytes = (off + n - vstr.len) + (sz - 1);
                      break;
                  }
              }
          }
  
          return mp_obj_new_str_from_vstr(&mp_type_str, &vstr);
      }
      #endif
  
      vstr_t vstr;
      vstr_init_len(&vstr, sz);
      int error;
      mp_uint_t out_sz = mp_stream_rw(args[0], vstr.buf, sz, &error, flags);
      if (error != 0) {
          vstr_clear(&vstr);
          if (mp_is_nonblocking_error(error)) {
              // https://docs.python.org/3.4/library/io.html#io.RawIOBase.read
              // "If the object is in non-blocking mode and no bytes are available,
              // None is returned."
              // This is actually very weird, as naive truth check will treat
              // this as EOF.
              return mp_const_none;
          }
          mp_raise_OSError(error);
      } else {
          vstr.len = out_sz;
          return mp_obj_new_str_from_vstr(STREAM_CONTENT_TYPE(stream_p), &vstr);
      }
  }
  
  STATIC mp_obj_t stream_read(size_t n_args, const mp_obj_t *args) {
      return stream_read_generic(n_args, args, MP_STREAM_RW_READ);
  }
  MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_stream_read_obj, 1, 2, stream_read);
  
  STATIC mp_obj_t stream_read1(size_t n_args, const mp_obj_t *args) {
      return stream_read_generic(n_args, args, MP_STREAM_RW_READ | MP_STREAM_RW_ONCE);
  }
  MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_stream_read1_obj, 1, 2, stream_read1);
  
  mp_obj_t mp_stream_write(mp_obj_t self_in, const void *buf, size_t len, byte flags) {
      int error;
      mp_uint_t out_sz = mp_stream_rw(self_in, (void *)buf, len, &error, flags);
      if (error != 0) {
          if (mp_is_nonblocking_error(error)) {
              // http://docs.python.org/3/library/io.html#io.RawIOBase.write
              // "None is returned if the raw stream is set not to block and
              // no single byte could be readily written to it."
              return mp_const_none;
          }
          mp_raise_OSError(error);
      } else {
          return MP_OBJ_NEW_SMALL_INT(out_sz);
      }
  }
  
  // This is used to adapt a stream object to an mp_print_t interface
  void mp_stream_write_adaptor(void *self, const char *buf, size_t len) {
      mp_stream_write(MP_OBJ_FROM_PTR(self), buf, len, MP_STREAM_RW_WRITE);
  }
  
  STATIC mp_obj_t stream_write_method(size_t n_args, const mp_obj_t *args) {
      mp_buffer_info_t bufinfo;
      mp_get_buffer_raise(args[1], &bufinfo, MP_BUFFER_READ);
      if (!mp_get_stream(args[0])->is_text && MP_OBJ_IS_STR(args[1])) {
          mp_raise_ValueError(translate("string not supported; use bytes or bytearray"));
      }
      size_t max_len = (size_t)-1;
      size_t off = 0;
      if (n_args == 3) {
          max_len = mp_obj_get_int_truncated(args[2]);
      } else if (n_args == 4) {
          off = mp_obj_get_int_truncated(args[2]);
          max_len = mp_obj_get_int_truncated(args[3]);
          if (off > bufinfo.len) {
              off = bufinfo.len;
          }
      }
      bufinfo.len -= off;
      return mp_stream_write(args[0], (byte *)bufinfo.buf + off, MIN(bufinfo.len, max_len), MP_STREAM_RW_WRITE);
  }
  MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_stream_write_obj, 2, 4, stream_write_method);
  
  STATIC mp_obj_t stream_write1_method(mp_obj_t self_in, mp_obj_t arg) {
      mp_buffer_info_t bufinfo;
      mp_get_buffer_raise(arg, &bufinfo, MP_BUFFER_READ);
      return mp_stream_write(self_in, bufinfo.buf, bufinfo.len, MP_STREAM_RW_WRITE | MP_STREAM_RW_ONCE);
  }
  MP_DEFINE_CONST_FUN_OBJ_2(mp_stream_write1_obj, stream_write1_method);
  
  STATIC mp_obj_t stream_readinto(size_t n_args, const mp_obj_t *args) {
      mp_buffer_info_t bufinfo;
      mp_get_buffer_raise(args[1], &bufinfo, MP_BUFFER_WRITE);
  
      // CPython extension: if 2nd arg is provided, that's max len to read,
      // instead of full buffer. Similar to
      // https://docs.python.org/3/library/socket.html#socket.socket.recv_into
      mp_uint_t len = bufinfo.len;
      if (n_args > 2) {
          if (mp_get_stream(args[0])->pyserial_readinto_compatibility) {
              mp_raise_ValueError(translate("length argument not allowed for this type"));
          }
          len = mp_obj_get_int(args[2]);
          if (len > bufinfo.len) {
              len = bufinfo.len;
          }
      }
  
      int error;
      mp_uint_t out_sz = mp_stream_read_exactly(args[0], bufinfo.buf, len, &error);
      if (error != 0) {
          if (mp_is_nonblocking_error(error)) {
              // pyserial readinto never returns None, just 0.
              return mp_get_stream(args[0])->pyserial_dont_return_none_compatibility
                  ? MP_OBJ_NEW_SMALL_INT(0)
                  : mp_const_none;
          }
          mp_raise_OSError(error);
      } else {
          return MP_OBJ_NEW_SMALL_INT(out_sz);
      }
  }
  MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_stream_readinto_obj, 2, 3, stream_readinto);
  
  STATIC mp_obj_t stream_readall(mp_obj_t self_in) {
      const mp_stream_p_t *stream_p = mp_get_stream(self_in);
  
      mp_uint_t total_size = 0;
      vstr_t vstr;
      vstr_init(&vstr, DEFAULT_BUFFER_SIZE);
      char *p = vstr.buf;
      mp_uint_t current_read = DEFAULT_BUFFER_SIZE;
      while (true) {
          int error;
          mp_uint_t out_sz = stream_p->read(self_in, p, current_read, &error);
          if (out_sz == MP_STREAM_ERROR) {
              if (mp_is_nonblocking_error(error)) {
                  // With non-blocking streams, we read as much as we can.
                  // If we read nothing, return None, just like read().
                  // Otherwise, return data read so far.
                  if (total_size == 0) {
                      // pyserial read() never returns None, just b''.
                      return stream_p->pyserial_dont_return_none_compatibility
                          ? mp_const_empty_bytes
                          : mp_const_none;
                  }
                  break;
              }
              mp_raise_OSError(error);
          }
          if (out_sz == 0) {
              break;
          }
          total_size += out_sz;
          if (out_sz < current_read) {
              current_read -= out_sz;
              p += out_sz;
          } else {
              p = vstr_extend(&vstr, DEFAULT_BUFFER_SIZE);
              current_read = DEFAULT_BUFFER_SIZE;
          }
          #ifdef RUN_BACKGROUND_TASKS
          RUN_BACKGROUND_TASKS;
          #endif
      }
  
      vstr.len = total_size;
      return mp_obj_new_str_from_vstr(STREAM_CONTENT_TYPE(stream_p), &vstr);
  }
  
  // Unbuffered, inefficient implementation of readline() for raw I/O files.
  STATIC mp_obj_t stream_unbuffered_readline(size_t n_args, const mp_obj_t *args) {
      const mp_stream_p_t *stream_p = mp_get_stream(args[0]);
  
      mp_int_t max_size = -1;
      if (n_args > 1) {
          max_size = MP_OBJ_SMALL_INT_VALUE(args[1]);
      }
  
      vstr_t vstr;
      if (max_size != -1) {
          vstr_init(&vstr, max_size);
      } else {
          vstr_init(&vstr, 16);
      }
  
      while (max_size == -1 || max_size-- != 0) {
          char *p = vstr_add_len(&vstr, 1);
          int error;
          mp_uint_t out_sz = stream_p->read(args[0], p, 1, &error);
          if (out_sz == MP_STREAM_ERROR) {
              if (mp_is_nonblocking_error(error)) {
                  if (vstr.len == 1) {
                      // We just incremented it, but otherwise we read nothing
                      // and immediately got EAGAIN. This case is not well
                      // specified in
                      // https://docs.python.org/3/library/io.html#io.IOBase.readline
                      // unlike similar case for read(). But we follow the latter's
                      // behavior - return None.
                      vstr_clear(&vstr);
                      return mp_const_none;
                  } else {
                      goto done;
                  }
              }
              mp_raise_OSError(error);
          }
          if (out_sz == 0) {
          done:
              // Back out previously added byte
              // Consider, what's better - read a char and get OutOfMemory (so read
              // char is lost), or allocate first as we do.
              vstr_cut_tail_bytes(&vstr, 1);
              break;
          }
          if (*p == '\n') {
              break;
          }
      }
  
      return mp_obj_new_str_from_vstr(STREAM_CONTENT_TYPE(stream_p), &vstr);
  }
  MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_stream_unbuffered_readline_obj, 1, 2, stream_unbuffered_readline);
  
  // TODO take an optional extra argument (what does it do exactly?)
  STATIC mp_obj_t stream_unbuffered_readlines(mp_obj_t self) {
      mp_obj_t lines = mp_obj_new_list(0, NULL);
      for (;;) {
          mp_obj_t line = stream_unbuffered_readline(1, &self);
          if (!mp_obj_is_true(line)) {
              break;
          }
          mp_obj_list_append(lines, line);
      }
      return lines;
  }
  MP_DEFINE_CONST_FUN_OBJ_1(mp_stream_unbuffered_readlines_obj, stream_unbuffered_readlines);
  
  mp_obj_t mp_stream_unbuffered_iter(mp_obj_t self) {
      mp_obj_t l_in = stream_unbuffered_readline(1, &self);
      if (mp_obj_is_true(l_in)) {
          return l_in;
      }
      return MP_OBJ_STOP_ITERATION;
  }
  
  mp_obj_t mp_stream_close(mp_obj_t stream) {
      const mp_stream_p_t *stream_p = mp_get_stream(stream);
      int error;
      mp_uint_t res = stream_p->ioctl(stream, MP_STREAM_CLOSE, 0, &error);
      if (res == MP_STREAM_ERROR) {
          mp_raise_OSError(error);
      }
      return mp_const_none;
  }
  MP_DEFINE_CONST_FUN_OBJ_1(mp_stream_close_obj, mp_stream_close);
  
  STATIC mp_obj_t stream_seek(size_t n_args, const mp_obj_t *args) {
      struct mp_stream_seek_t seek_s;
      // TODO: Could be uint64
      seek_s.offset = mp_obj_get_int(args[1]);
      seek_s.whence = SEEK_SET;
      if (n_args == 3) {
          seek_s.whence = mp_obj_get_int(args[2]);
      }
  
      // In POSIX, it's error to seek before end of stream, we enforce it here.
      if (seek_s.whence == SEEK_SET && seek_s.offset < 0) {
          mp_raise_OSError(MP_EINVAL);
      }
  
      const mp_stream_p_t *stream_p = mp_get_stream(args[0]);
      int error;
      mp_uint_t res = stream_p->ioctl(args[0], MP_STREAM_SEEK, (mp_uint_t)(uintptr_t)&seek_s, &error);
      if (res == MP_STREAM_ERROR) {
          mp_raise_OSError(error);
      }
  
      // TODO: Could be uint64
      return mp_obj_new_int_from_uint(seek_s.offset);
  }
  MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_stream_seek_obj, 2, 3, stream_seek);
  
  STATIC mp_obj_t stream_tell(mp_obj_t self) {
      mp_obj_t offset = MP_OBJ_NEW_SMALL_INT(0);
      mp_obj_t whence = MP_OBJ_NEW_SMALL_INT(SEEK_CUR);
      const mp_obj_t args[3] = {self, offset, whence};
      return stream_seek(3, args);
  }
  MP_DEFINE_CONST_FUN_OBJ_1(mp_stream_tell_obj, stream_tell);
  
  mp_obj_t mp_stream_flush(mp_obj_t self) {
      const mp_stream_p_t *stream_p = mp_get_stream(self);
      int error;
      if (stream_p->ioctl == NULL) {
          mp_raise_OSError(MP_EINVAL);
      }
      mp_uint_t res = stream_p->ioctl(self, MP_STREAM_FLUSH, 0, &error);
      if (res == MP_STREAM_ERROR) {
          mp_raise_OSError(error);
      }
      return mp_const_none;
  }
  MP_DEFINE_CONST_FUN_OBJ_1(mp_stream_flush_obj, mp_stream_flush);
  
  STATIC mp_obj_t stream_ioctl(size_t n_args, const mp_obj_t *args) {
      mp_buffer_info_t bufinfo;
      uintptr_t val = 0;
      if (n_args > 2) {
          if (mp_get_buffer(args[2], &bufinfo, MP_BUFFER_WRITE)) {
              val = (uintptr_t)bufinfo.buf;
          } else {
              val = mp_obj_get_int_truncated(args[2]);
          }
      }
  
      const mp_stream_p_t *stream_p = mp_get_stream(args[0]);
      int error;
      mp_uint_t res = stream_p->ioctl(args[0], mp_obj_get_int(args[1]), val, &error);
      if (res == MP_STREAM_ERROR) {
          mp_raise_OSError(error);
      }
  
      return mp_obj_new_int(res);
  }
  MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_stream_ioctl_obj, 2, 3, stream_ioctl);
  
  #if MICROPY_STREAMS_POSIX_API
  /*
   * POSIX-like functions
   *
   * These functions have POSIX-compatible signature (except for "void *stream"
   * first argument instead of "int fd"). They are useful to port existing
   * POSIX-compatible software to work with MicroPython streams.
   */
  
  // errno-like variable. If any of the functions below returned with error
  // status, this variable will contain error no.
  int mp_stream_errno;
  
  ssize_t mp_stream_posix_write(mp_obj_t stream, const void *buf, size_t len) {
      mp_obj_base_t *o = (mp_obj_base_t *)MP_OBJ_TO_PTR(stream);
      const mp_stream_p_t *stream_p = mp_get_stream(o);
      mp_uint_t out_sz = stream_p->write(stream, buf, len, &mp_stream_errno);
      if (out_sz == MP_STREAM_ERROR) {
          return -1;
      } else {
          return out_sz;
      }
  }
  
  ssize_t mp_stream_posix_read(mp_obj_t stream, void *buf, size_t len) {
      mp_obj_base_t *o = (mp_obj_base_t *)MP_OBJ_TO_PTR(stream);
      const mp_stream_p_t *stream_p = mp_get_stream(o);
      mp_uint_t out_sz = stream_p->read(stream, buf, len, &mp_stream_errno);
      if (out_sz == MP_STREAM_ERROR) {
          return -1;
      } else {
          return out_sz;
      }
  }
  
  off_t mp_stream_posix_lseek(mp_obj_t stream, off_t offset, int whence) {
      const mp_obj_base_t *o = (mp_obj_base_t *)MP_OBJ_TO_PTR(stream);
      const mp_stream_p_t *stream_p = mp_get_stream(o);
      struct mp_stream_seek_t seek_s;
      seek_s.offset = offset;
      seek_s.whence = whence;
      mp_uint_t res = stream_p->ioctl(MP_OBJ_FROM_PTR(stream), MP_STREAM_SEEK, (mp_uint_t)(uintptr_t)&seek_s, &mp_stream_errno);
      if (res == MP_STREAM_ERROR) {
          return -1;
      }
      return seek_s.offset;
  }
  
  int mp_stream_posix_fsync(mp_obj_t stream) {
      mp_obj_base_t *o = (mp_obj_base_t *)MP_OBJ_TO_PTR(stream);
      const mp_stream_p_t *stream_p = mp_get_stream(o);
      mp_uint_t res = stream_p->ioctl(stream, MP_STREAM_FLUSH, 0, &mp_stream_errno);
      if (res == MP_STREAM_ERROR) {
          return -1;
      }
      return res;
  }
  
  #endif
  