io.c

来自「俄罗斯高人Mamaich的Pocket gcc编译器（运行在PocketPC上）」· C语言 代码 · 共 737 行 · 第 1/2 页

#include <stdlib.h>
#include <stddef.h>
#include <stdio.h>
#include <sys/stat.h>
#include <string.h>
#include <fcntl.h>
#include <reent.h>
#include <errno.h>

#include <sys/ioctl.h>
#include <sys/sysconf.h>
#include <sys/wcebase.h>
#include <sys/wceerror.h>
#include <sys/wcefile.h>
#include <sys/wcenetwork.h>
#include <sys/wcethread.h>
#include <sys/wcetrace.h>
#include <sys/io.h>
#include <sys/fifo.h>

static int fdsinitialized = 0;
static CRITICAL_SECTION critsect;

_fdent_t _fdtab[MAXFDS];

/* Prototypes from local.h that probably shouldn't be here.. */
extern int __sclose(void *);
extern _READ_WRITE_RETURN_TYPE __sread(void *, char *, int);
extern _READ_WRITE_RETURN_TYPE __swrite(void *, char const *, int);
extern fpos_t __sseek(void *, fpos_t, int);

/* Public devops for devices we support */
extern _DEVOPS _fifo_devops;

void
_initfds()
{
  HANDLE a, b, c;
  int i;

  if (fdsinitialized)
    return;
  fdsinitialized = 1;

  InitializeCriticalSection(&critsect);

  EnterCriticalSection(&critsect);
  for (i = 0; i < MAXFDS; i++)
    _fdtab[i].fd = -1;
  LeaveCriticalSection(&critsect);
}

void
_cleanupstdio()
{
//	fclose(stderr);
//	fclose(stdout);
//	fclose(stdin);
}

void
_initstdio()
{
  _initstdfd(stdin,  0, (HANDLE)_fileno(_getstdfilex(0)), __SRD);
  _initstdfd(stdout, 1, (HANDLE)_fileno(_getstdfilex(1)), __SWR);
  _initstdfd(stderr, 2, (HANDLE)_fileno(_getstdfilex(2)), __SWR);
  atexit(_cleanupstdio);
}

int
_getnewfd()
{
  int i;

  EnterCriticalSection(&critsect);
  for (i = 0; i < MAXFDS; i++) {
    if (_fdtab[i].fd == -1)	{
   	  _fdtab[i].flags = 0;
      LeaveCriticalSection(&critsect);
   	  return i;
   	}
  }
  LeaveCriticalSection(&critsect);

  WCETRACE(WCE_IO, "Out of file descriptors!");

  return(-1);
}

void
_setfd(int fd, int type, HANDLE hnd, int flags)
{
  _fdtab[fd].fd = fd;
  _fdtab[fd].type = type;
  _fdtab[fd].hnd = hnd;
  _fdtab[fd].flags = flags;
}

int
_assignfd(int type, HANDLE hnd, int flags)
{
  int fd;

  WCETRACE(WCE_IO, "_assignfd(%x)", hnd);

  if ((fd = _getnewfd()) >= 0)
    _setfd(fd, type, hnd, flags);

  WCETRACE(WCE_IO, "_assignfd returns %d", fd);
  return(fd);
}

void
_initstdfd(FILE *fp, int fd, HANDLE hnd, int flags)
{

  if (fd < 0 || fd > 2 || fp == NULL)
    return;

  _setfd(fd, IO_FILE_TYPE_CONSOLE, hnd, 0);

  WCETRACE(WCE_IO, "_initstdfd: fd %d hnd %x", fd, hnd);

  fp->_file = fd;
  fp->_flags = flags;
  fp->_cookie = (_PTR) fp;
  fp->_read = __sread;
  fp->_write = __swrite;
  fp->_seek = __sseek;
  fp->_close = __sclose;

#ifdef __SCLE
  if (__stextmode(fp->_file))
    fp->_flags |= __SCLE;
#endif
}

void
_initstdfifofd(FILE *fp, int fd, int flags)
{

  if (fd < 0 || fd > 2 || fp == NULL)
    return;

  _fdtab[fd].type = IO_FILE_TYPE_FIFO;
  _fdtab[fd].hnd = NULL;
  _fdtab[fd].flags = 0;

  WCETRACE(WCE_IO, "_initstdfifofd: fd %d fifofd %d", fd, _fdtab[fd].fd);

  fp->_file = fd;
  fp->_flags = flags;
  fp->_cookie = (_PTR) fp;
  fp->_read = __sread;
  fp->_write = __swrite;
  fp->_seek = __sseek;
  fp->_close = __sclose;

#ifdef __SCLE
  if (__stextmode(fp->_file))
    fp->_flags |= __SCLE;
#endif
}

void
_initecho(int stdinfd, int stdoutfd)
{
  _FIFOIOCXT fcxt = NULL;

  WCETRACE(WCE_IO, "_initecho: stdinfd %d stdoutfd %d", stdinfd, stdoutfd);

  if (stdinfd < 0 || stdoutfd < 0) {
    WCETRACE(WCE_IO, "_initecho: ERROR invalid fds (%d,%d) giving up", stdinfd, stdoutfd);
  }

  fcxt = (_FIFOIOCXT) _fdtab[stdinfd].cxt;
  WCETRACE(WCE_IO, "_initecho: fcxt %p", fcxt);
  fflush(stdout);

  if (fcxt == NULL) {
    WCETRACE(WCE_IO, "_initecho: ERROR fcxt is NULL");
    return;
  }

  if (_fdtab[stdoutfd].cxt == NULL) {
    WCETRACE(WCE_IO, "_initecho: ERROR stdout cxt is NULL");
    return;
  }

  fcxt->echofd = stdoutfd;
  fcxt->echocxt = _fdtab[stdoutfd].cxt;
}

void *
_getiocxt(int fd)
{
  if (fd < 0 || fd > MAXFDS - 1)
    return(NULL);
  return(_fdtab[fd].cxt);
}

void
_ioatexit(void)
{
  int i;

  WCETRACE(WCE_IO, "_ioatexit: STARTED");
  for (i = 0; i < MAXFDS; i++) {
    if (_fdtab[i].fd != -1)	{
      if (_fdtab[i].type == IO_FILE_TYPE_FIFO) {
        _close_r(NULL, i);
   	  }
    }
  }
}
  
int
_open_r(struct _reent *reent, const char *path, int flags, int mode)
{
  wchar_t wpath[MAX_PATH];
  char pathbuf[MAX_PATH];
  HANDLE hnd = NULL;
  DWORD fileaccess;
  DWORD fileshare; 
  DWORD filecreate;
  DWORD fileattrib;
  void *cxt;
  int fd;

  WCETRACE(WCE_IO, "open(%s, %x, %o)", path, flags, mode);

  _initfds();

  /* Not a FIFO */
  if (strncmp("fifo", path, 4) != 0) {
    if (strlen(path) >= MAX_PATH) {
      WCETRACE(WCE_IO, "open fails, invalid path\n");
      return(-1);
    }

    fixpath(path, pathbuf);
    mbstowcs(wpath, pathbuf, strlen(pathbuf) + 1);

    fileshare = FILE_SHARE_READ|FILE_SHARE_WRITE;
    fileattrib = FILE_ATTRIBUTE_NORMAL;

    switch (flags & (O_RDONLY | O_WRONLY | O_RDWR)) {
    case O_RDONLY:              /* read access */
      fileaccess = GENERIC_READ;
      break;
    case O_WRONLY:              /* write access */
      fileaccess = GENERIC_WRITE;
      break;
    case O_RDWR:                /* read and write access */
      fileaccess = GENERIC_READ | GENERIC_WRITE;
      break;
    default:                    /* error, bad flags */
      errno = EINVAL;
      return -1;
    }

    switch (flags & (O_CREAT | O_EXCL | O_TRUNC)) {
    case 0:
    case O_EXCL:                /* ignore EXCL w/o CREAT */
      filecreate = OPEN_EXISTING;
      break;
    case O_CREAT:
      filecreate = OPEN_ALWAYS;
      break;
    case O_CREAT | O_EXCL:
    case O_CREAT | O_TRUNC | O_EXCL:
      filecreate = CREATE_NEW;
      break;

    case O_TRUNC:
    case O_TRUNC | O_EXCL:      /* ignore EXCL w/o CREAT */
      filecreate = TRUNCATE_EXISTING;
      break;
    case O_CREAT | O_TRUNC:
      filecreate = CREATE_ALWAYS;
      break;
    default:
      /* this can't happen ... all cases are covered */
      errno = EINVAL;
      return(-1);
    }

    if ((hnd = CreateFileW(wpath, fileaccess, fileshare, NULL, filecreate,
                           fileattrib, NULL)) == INVALID_HANDLE_VALUE) {
      errno = _winerr2errno(GetLastError());
      WCETRACE(WCE_IO, "CreateFile(%s): errno=%d oserr=%d\n", pathbuf, errno, GetLastError());
      return(-1);
    }

    fd = _assignfd(IO_FILE_TYPE_FILE, hnd, 0);

    if (fd < 0) {
      errno = ENMFILE;
      return(-1);
    }
    _fdtab[fd].devops = NULL;
    _fdtab[fd].cxt = NULL;

    if (flags & O_APPEND) {
      SetFilePointer(hnd, 0, NULL, FILE_END);
    }
  } else {
    fd = _assignfd(IO_FILE_TYPE_FIFO, NULL, 0);
 
    if (fd < 0) {
      errno = ENMFILE;
      return(-1);
    }

    _fdtab[fd].devops = _fifo_devops;
    _fdtab[fd].cxt = cxt = _fifo_alloc();
    if ((_fdtab[fd].fd = _fdtab[fd].devops->open_r(reent, path, flags, mode, cxt)) == -1) {
      WCETRACE(WCE_IO, "FIFO open fails, errno %d", errno);
      _fdtab[fd].fd = -1;
      return(-1);
    }
  }

  WCETRACE(WCE_IO, "open returns %d fd %d cxt %p (hnd %x)", fd, _fdtab[fd].fd, cxt, hnd);
  return fd;
}

int
_close_r(struct _reent *reent, int fd)
{
  WCETRACE(WCE_IO, "close(%d)", fd);
  WCETRACE(WCE_IO, "close: fd %d type %d flags %x hnd %p cxt %p", _fdtab[fd].fd,
           _fdtab[fd].type, _fdtab[fd].flags, _fdtab[fd].hnd, _fdtab[fd].cxt);

  EnterCriticalSection(&critsect);
  FDCHECK(fd);

  if (_fdtab[fd].devops == NULL) {
    if (_fdtab[fd].type == IO_FILE_TYPE_FILE) {
      CloseHandle(_fdtab[fd].hnd);
    } else if (_fdtab[fd].type == IO_FILE_TYPE_SOCKET) {
      closesocket((SOCKET) _fdtab[fd].hnd);
    } else if(_fdtab[fd].type == IO_FILE_TYPE_NULL) {
    }
  } else {
    _fdtab[fd].devops->close_r(reent, _fdtab[fd].fd, _fdtab[fd].cxt);
    if (_fdtab[fd].cxt != NULL) {
      free(_fdtab[fd].cxt);
      _fdtab[fd].cxt = NULL;
    }
  }

  _fdtab[fd].fd = -1;
  LeaveCriticalSection(&critsect);

  return(0);
}

_ssize_t
_read_r(struct _reent *reent, int fd, void *buf, size_t count)
{
  int nread;
  int error;

  WCETRACE(WCE_IO, "read(fd = %d, count = %d, hnd %x)", fd, count, _fdtab[fd].hnd);

  FDCHECK(fd);

  if (_fdtab[fd].devops == NULL) {