mach/devstream.c

   1 /* stdio on a Mach device port.
   2    Translates \n to \r\n on output, echos input.
   3
   4 Copyright (C) 1992, 1993, 1994 Free Software Foundation, Inc.
   5 This file is part of the GNU C Library.
   6
   7 The GNU C Library is free software; you can redistribute it and/or
   8 modify it under the terms of the GNU Library General Public License as
   9 published by the Free Software Foundation; either version 2 of the
  10 License, or (at your option) any later version.
  11
  12 The GNU C Library is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15 Library General Public License for more details.
  16
  17 You should have received a copy of the GNU Library General Public
  18 License along with the GNU C Library; see the file COPYING.LIB.  If
  19 not, write to the Free Software Foundation, Inc., 675 Mass Ave,
  20 Cambridge, MA 02139, USA.  */
  21
  22 #include <stdio.h>
  23 #include <mach.h>
  24 #include <device/device.h>
  25 #include <errno.h>
  26 #include <string.h>
  27
  28 static int
  29 input (FILE *f)
  30 {
  31   kern_return_t err;
  32   char *buffer;
  33   size_t to_read;
  34   mach_msg_type_number_t nread;
  35   char c;
  36
  37   if (f->__buffer == NULL)
  38     {
  39       buffer = &c;
  40       to_read = 1;
  41     }
  42   else
  43     {
  44       buffer = f->__buffer;
  45       to_read = f->__bufsize;
  46     }
  47
  48   f->__eof = 0;
  49
  50   nread = to_read;
  51   err = device_read_inband ((device_t) f->__cookie, 0, f->__target,
  52                             to_read, buffer, &nread);
  53
  54   if (err)
  55     {
  56       f->__error = 1;
  57       f->__bufp = f->__get_limit = f->__put_limit = f->__buffer;
  58       errno = err;
  59       return EOF;
  60     }
  61
  62   /* Echo it back.  */
  63   err = device_write_inband ((device_t) f->__cookie, 0, f->__target,
  64                              buffer, nread, (int *) &to_read);
  65
  66   if (f->__buffer == NULL)
  67     return (unsigned char) c;
  68
  69   f->__get_limit = f->__buffer + nread;
  70   f->__bufp = f->__buffer;
  71   f->__put_limit = f->__buffer + (f->__mode.__write ? f->__bufsize : 0);
  72   return (unsigned char) *f->__bufp++;
  73 }
  74
  75
  76 #if 0
  77 static void
  78 output (FILE *f, int c)
  79 {
  80   inline void write_some (const char *p, size_t to_write)
  81     {
  82       kern_return_t err;
  83       int wrote;
  84       while (to_write > 0)
  85         {
  86           if (err = device_write ((device_t) f->__cookie, 0,
  87                                   f->__target, (char *)p,
  88                                   to_write, &wrote))
  89             {
  90               errno = err;
  91               f->__error = 1;
  92               break;
  93             }
  94           p += wrote;
  95           to_write -= wrote;
  96           f->__target += wrote;
  97         }
  98     }
  99
 100   if (f->__buffer != NULL)
 101     {
 102       if (f->__put_limit == f->__buffer)
 103         {
 104           /* Prime the stream for writing.  */
 105           f->__put_limit = f->__buffer + f->__bufsize;
 106           f->__bufp = f->__buffer;
 107           if (c != EOF)
 108             {
 109               *f->__bufp++ = (unsigned char) c;
 110               c = EOF;
 111             }
 112         }
 113
 114
 115       /* Write out the buffer.  */
 116
 117       write_some (f->__buffer, f->__bufp - f->__buffer);
 118
 119       f->__bufp = f->__buffer;
 120     }
 121
 122   if (c != EOF && !ferror (f))
 123     {
 124       if (f->__linebuf && (unsigned char) c == '\n')
 125         {
 126           static const char nl = '\n';
 127           write_some (&nl, 1);
 128         }
 129       else
 130         *f->__bufp++ = (unsigned char) c;
 131     }
 132 }
 133 #endif
 134
 135
 136 static void
 137 output (FILE *f, int c)
 138 {
 139   void write_some (const char *p, size_t to_write)
 140     {
 141       kern_return_t err;
 142       int wrote;
 143       while (to_write > 0)
 144         {
 145           if (err = device_write_inband ((device_t) f->__cookie, 0,
 146                                          f->__target, p, to_write, &wrote))
 147             {
 148               errno = err;
 149               f->__error = 1;
 150               break;
 151             }
 152           p += wrote;
 153           to_write -= wrote;
 154           f->__target += wrote;
 155         }
 156     }
 157   void write_crlf (void)
 158     {
 159       static const char crlf[] = "\r\n";
 160       write_some (crlf, 2);
 161     }
 162
 163   if (f->__buffer == NULL)
 164     {
 165       /* The stream is unbuffered.  */
 166
 167       if (c == '\n')
 168         write_crlf ();
 169       else if (c != EOF)
 170         {
 171           char cc = (unsigned char) c;
 172           write_some (&cc, 1);
 173         }
 174
 175       return;
 176     }
 177
 178   if (f->__put_limit == f->__buffer)
 179     {
 180       /* Prime the stream for writing.  */
 181       f->__put_limit = f->__buffer + f->__bufsize;
 182       f->__bufp = f->__buffer;
 183       if (c != EOF)
 184         {
 185           *f->__bufp++ = (unsigned char) c;
 186           c = EOF;
 187         }
 188     }
 189
 190   {
 191     /* Search for newlines (LFs) in the buffer.  */
 192
 193     char *start = f->__buffer, *p = start;
 194
 195     while (!ferror (f) && (p = memchr (p, '\n', f->__bufp - start)))
 196       {
 197         /* Found one.  Replace it with a CR and write out through that CR.  */
 198
 199         *p = '\r';
 200         write_some (start, p + 1 - start);
 201
 202         /* Change it back to an LF; the next iteration will write it out
 203            first thing.  Start the next searching iteration one char later.  */
 204
 205         start = p;
 206         *p++ = '\n';
 207       }
 208
 209     /* Write the remainder of the buffer.  */
 210
 211     if (!ferror (f))
 212       write_some (start, f->__bufp - start);
 213   }
 214
 215   f->__bufp = f->__buffer;
 216
 217   if (c != EOF && !ferror (f))
 218     {
 219       if (f->__linebuf && (unsigned char) c == '\n')
 220         write_crlf ();
 221       else
 222         *f->__bufp++ = (unsigned char) c;
 223     }
 224 }
 225
 226 static int
 227 dealloc_ref (void *cookie)
 228 {
 229   if (mach_port_deallocate (mach_task_self (), (mach_port_t) cookie))
 230     {
 231       errno = EINVAL;
 232       return -1;
 233     }
 234   return 0;
 235 }
 236
 237
 238 FILE *
 239 mach_open_devstream (mach_port_t dev, const char *mode)
 240 {
 241   FILE *stream;
 242
 243   if (mach_port_mod_refs (mach_task_self (), dev, MACH_PORT_RIGHT_SEND, 1))
 244     {
 245       errno = EINVAL;
 246       return NULL;
 247     }
 248
 249   stream = fopencookie ((void *) dev, mode, __default_io_functions);
 250   if (stream == NULL)
 251     {
 252       mach_port_deallocate (mach_task_self (), dev);
 253       return NULL;
 254     }
 255
 256   stream->__room_funcs.__input = input;
 257   stream->__room_funcs.__output = output;
 258   stream->__io_funcs.__close = dealloc_ref;
 259   stream->__io_funcs.__seek = NULL; /* Cannot seek.  */
 260   stream->__io_funcs.__fileno = NULL; /* No corresponding POSIX.1 fd.  */
 261   stream->__seen = 1;
 262
 263   return stream;
 264 }