nuttx/libs/libc/stdio/lib_libfread_unlocked.c

/****************************************************************************
 * libs/libc/stdio/lib_libfread_unlocked.c
 *
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.  The
 * ASF licenses this file to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance with the
 * License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
 * License for the specific language governing permissions and limitations
 * under the License.
 *
 ****************************************************************************/

/****************************************************************************
 * Included Files
 ****************************************************************************/

#include <nuttx/config.h>

#include <sys/types.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include <assert.h>
#include <errno.h>

#include <nuttx/fs/fs.h>

#include "libc.h"

/****************************************************************************
 * Public Functions
 ****************************************************************************/

/****************************************************************************
 * Name: lib_fread_unlocked
 ****************************************************************************/

ssize_t lib_fread_unlocked(FAR void *ptr, size_t count, FAR FILE *stream)
{
  FAR char *dest = ptr;
  ssize_t bytes_read;
  size_t remaining = count;
#ifndef CONFIG_STDIO_DISABLE_BUFFERING
  size_t gulp_size;
  int ret;
#endif
  int fd;

  /* Make sure that reading from this stream is allowed */

  if (!stream)
    {
      _NX_SETERRNO(EBADF);
      return ERROR;
    }
  else if ((stream->fs_oflags & O_RDOK) == 0)
    {
      stream->fs_flags |= __FS_FLAG_ERROR;
      _NX_SETERRNO(EBADF);
      return ERROR;
    }
  else
    {
      fd = (int)(intptr_t)stream->fs_cookie;
#if CONFIG_NUNGET_CHARS > 0
      /* First, re-read any previously ungotten characters */

      while (stream->fs_nungotten > 0 && remaining > 0)
        {
          /* Decrement the count of ungotten bytes to get an index */

          stream->fs_nungotten--;

          /* Return the last ungotten byte */

          *dest++ = stream->fs_ungotten[stream->fs_nungotten];

          /* That's one less byte that we have to read */

          remaining--;
        }
#endif

#ifndef CONFIG_STDIO_DISABLE_BUFFERING
      /* Is there an I/O buffer? */

      if (stream->fs_bufstart != NULL)
        {
          /* If the buffer is currently being used for write access, then
           * flush all of the buffered write data.  We do not support
           * concurrent buffered read/write access.
           */

          ret = lib_wrflush_unlocked(stream);
          if (ret < 0)
            {
              if (count - remaining > 0)
                {
                  goto shortread;
                }
              else
                {
                  _NX_SETERRNO(ret);
                  goto errout_with_errno;
                }
            }

          /* Now get any other needed chars from the buffer or the file. */

          while (remaining > 0)
            {
              /* Is there readable data in the buffer? */

              gulp_size = stream->fs_bufread - stream->fs_bufpos;

              /* Avoid empty buffers or read requests greater than the size
               *  buffer remaining
               */

              if (gulp_size > 0)
                {
                  if (gulp_size > remaining)
                    {
                      /* Clip the gulp size to the requested byte count */

                      gulp_size = remaining;
                    }

                  memcpy(dest, stream->fs_bufpos, gulp_size);

                  remaining -= gulp_size;
                  stream->fs_bufpos += gulp_size;
                  dest += gulp_size;
                }

              /* The buffer is empty OR we have already supplied the number
               * of bytes requested in the read.  Check if we need to read
               * more from the file.
               */

              if (remaining > 0)
                {
                  size_t buffer_available;

                  /* We need to read more data into the buffer from the
                   * file
                   */

                  /* Mark the buffer empty */

                  stream->fs_bufpos = stream->fs_bufread =
                                      stream->fs_bufstart;

                  /* How much space is available in the buffer? */

                  buffer_available = stream->fs_bufend - stream->fs_bufread;

                  /* Will the number of bytes that we need to read fit into
                   * the buffer space that is available? If the read size is
                   * larger than the buffer, then read some of the data
                   * directly into the user's buffer.
                   */

                  if (remaining > buffer_available)
                    {
                      if (stream->fs_iofunc.read != NULL)
                        {
                          bytes_read = stream->fs_iofunc.read(
                                                          stream->fs_cookie,
                                                          dest, remaining);
                        }
                      else
                        {
                          bytes_read = _NX_READ(fd, dest, remaining);
                        }

                      if (bytes_read < 0)
                        {
                          if (count - remaining > 0)
                            {
                              goto shortread;
                            }
                          else
                            {
                              /* An error occurred on the read. */

                              _NX_SETERRNO(bytes_read);
                              goto errout_with_errno;
                            }
                        }
                      else if (bytes_read == 0)
                        {
                          /* We are at the end of the file.  But we may
                           * already have buffered data.  In that case,
                           * we will report the EOF indication later.
                           */

                          goto shortread;
                        }
                      else
                        {
                          /* Some (perhaps all) bytes were read. Adjust the
                           * dest pointer and remaining bytes to be read.
                           */

                          DEBUGASSERT(bytes_read <= remaining);
                          dest      += bytes_read;
                          remaining -= bytes_read;
                        }
                    }
                  else
                    {
                      /* The number of bytes required to satisfy the read
                       * is less than or equal to the size of the buffer
                       * space that we have left. Read as much as we can
                       * into the buffer.
                       */

                      if (stream->fs_iofunc.read != NULL)
                        {
                          bytes_read = stream->fs_iofunc.read(
                                              stream->fs_cookie,
                                              stream->fs_bufread,
                                              buffer_available);
                        }
                      else
                        {
                          bytes_read = _NX_READ(fd, stream->fs_bufread,
                                                buffer_available);
                        }

                      if (bytes_read < 0)
                        {
                          if (count - remaining > 0)
                            {
                              goto shortread;
                            }
                          else
                            {
                              /* An error occurred on the read.  The error
                               * code is in the 'errno' variable.
                               */

                              _NX_SETERRNO(bytes_read);
                              goto errout_with_errno;
                            }
                        }
                      else if (bytes_read == 0)
                        {
                          /* We are at the end of the file.  But we may
                           * already have buffered data.  In that case,
                           * we will report the EOF indication later.
                           */

                          goto shortread;
                        }
                      else
                        {
                          /* Some (perhaps all) bytes were read */

                          stream->fs_bufread += bytes_read;
                        }
                    }
                }
            }
        }
      else
#endif
        {
          /* Now get any other needed chars from the file. */

          while (remaining > 0)
            {
              if (stream->fs_iofunc.read != NULL)
                {
                  bytes_read = stream->fs_iofunc.read(stream->fs_cookie,
                                                      dest,
                                                      remaining);
                }
              else
                {
                  bytes_read = _NX_READ(fd, dest, remaining);
                }

              if (bytes_read < 0)
                {
                  if (count - remaining > 0)
                    {
                      break;
                    }
                  else
                    {
                      /* An error occurred on the read.  The error code is
                       * in the 'errno' variable.
                       */

                      _NX_SETERRNO(bytes_read);
                      goto errout_with_errno;
                    }
                }
              else if (bytes_read == 0)
                {
                  /* We are at the end of the file.  But we may already
                   * have buffered data.  In that case, we will report
                   * the EOF indication later.
                   */

                  break;
                }
              else
                {
                  DEBUGASSERT(bytes_read <= remaining);
                  dest      += bytes_read;
                  remaining -= bytes_read;
                }
            }
        }

#ifndef CONFIG_STDIO_DISABLE_BUFFERING
      /* Here after a successful (but perhaps short) read.  A short read can
       * only occur is read() returns 0 (end-of-file).
       */

shortread:
#endif

      /* Set or clear the EOF indicator.  If we get here because of a
       * short read and the total number of bytes read is zero, then
       * we must be at the end-of-file.
       */

      if (remaining == 0)
        {
          stream->fs_flags &= ~__FS_FLAG_EOF;
        }
      else
        {
          stream->fs_flags |= __FS_FLAG_EOF;
        }

      return count - remaining;
    }

  /* Error exits */

errout_with_errno:
  stream->fs_flags |= __FS_FLAG_ERROR;
  return ERROR;
}