1: /* Copyright (C) 1994,95,97,2000,01,02 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, write to the Free
   16:    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   17:    02111-1307 USA.  */
   18: 
   19: #include <hurd.h>
   20: #include <stdio.h>
   21: #include <fcntl.h>
   22: #include <string.h>
   23: 
   24: /* Read up to N chars into BUF from COOKIE.
   25:    Return how many chars were read, 0 for EOF or -1 for error.  */
   26: static ssize_t
   27: readio (void *cookie, char *buf, size_t n)
   28: {
   29:   mach_msg_type_number_t nread;
   30:   error_t err;
   31:   char *bufp = buf;
   32: 
   33:   nread = n;
   34:   if (err = __io_read ((io_t) cookie, &bufp, &nread, -1, n))
   35:     return __hurd_fail (err);
   36: 
   37:   if (bufp != buf)
   38:     {
   39:       memcpy (buf, bufp, nread);
   40:       __vm_deallocate (__mach_task_self (),
   41:                        (vm_address_t) bufp, (vm_size_t) nread);
   42:     }
   43: 
   44:   return nread;
   45: }
   46: 
   47: /* Write up to N chars from BUF to COOKIE.
   48:    Return how many chars were written or -1 for error.  */
   49: static ssize_t
   50: writeio (void *cookie, const char *buf, size_t n)
   51: {
   52:   mach_msg_type_number_t wrote;
   53:   error_t err;
   54: 
   55:   if (err = __io_write ((io_t) cookie, buf, n, -1, &wrote))
   56:     return __hurd_fail (err);
   57: 
   58:   return wrote;
   59: }
   60: 
   61: /* Move COOKIE's file position *POS bytes, according to WHENCE.
   62:    The current file position is stored in *POS.
   63:    Returns zero if successful, nonzero if not.  */
   64: static int
   65: seekio (void *cookie,
   66: #ifdef USE_IN_LIBIO
   67:         _IO_off64_t *pos,
   68: #else
   69:         fpos_t *pos,
   70: #endif
   71:         int whence)
   72: {
   73:   error_t err = __io_seek ((file_t) cookie, *pos, whence, pos);
   74:   return err ? __hurd_fail (err) : 0;
   75: }
   76: 
   77: /* Close the file associated with COOKIE.
   78:    Return 0 for success or -1 for failure.  */
   79: static int
   80: closeio (void *cookie)
   81: {
   82:   error_t error = __mach_port_deallocate (__mach_task_self (),
   83:                                           (mach_port_t) cookie);
   84:   if (error)
   85:     return __hurd_fail (error);
   86:   return 0;
   87: }
   88: 
   89: #ifdef USE_IN_LIBIO
   90: #include "../libio/libioP.h"
   91: #define fopencookie _IO_fopencookie
   92: #else
   93: #define cookie_io_functions_t __io_functions
   94: #endif
   95: static const cookie_io_functions_t funcsio =
   96: { readio, writeio, seekio, closeio };
   97: ^L
   98: 
   99: /* Open a stream on PORT.  MODE is as for fopen.  */
  100: 
  101: FILE *
  102: __fopenport (mach_port_t port, const char *mode)
  103: {
  104:   int pflags;
  105:   int needflags;
  106:   error_t err;
  107: 
  108:   const char *m = mode;
  109: 
  110:   switch (*m++)
  111:     {
  112:     case 'r':
  113:       needflags = O_READ;
  114:       break;
  115:     case 'w':
  116:       needflags = O_WRITE;
  117:       break;
  118:     case 'a':
  119:       needflags = O_WRITE|O_APPEND;
  120:       break;
  121:     default:
  122:       return NULL;
  123:   }
  124:   if (m[0] == '+' || (m[0] == 'b' && m[1] == '+'))
  125:     needflags |= O_RDWR;
  126: 
  127:   /* Verify the PORT is valid allows the access MODE specifies.  */
  128: 
  129:   if (err = __io_get_openmodes (port, &pflags))
  130:     return __hurd_fail (err), NULL;
  131: 
  132:   /* Check the access mode.  */
  133:   if ((pflags & needflags) != needflags)
  134:     {
  135:       errno = EBADF;
  136:       return NULL;
  137:     }
  138: 
  139:   return fopencookie ((void *) port, mode, funcsio);
  140: }
  141: weak_alias (__fopenport, fopenport)