mach/devstream.c

   1 /* stdio on a Mach device port.
   2    Translates \n to \r\n on output, echos and translates \r to \n on input.
   3    Copyright (C) 1992-2023 Free Software Foundation, Inc.
   4    This file is part of the GNU C Library.
   5
   6    The GNU C Library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Lesser General Public
   8    License as published by the Free Software Foundation; either
   9    version 2.1 of the License, or (at your option) any later version.
  10
  11    The GNU C Library is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with the GNU C Library; if not, see
  18    <https://www.gnu.org/licenses/>.  */
  19
  20 #include <stdio.h>
  21 #include <mach.h>
  22 #include <device/device.h>
  23 #include <errno.h>
  24 #include <string.h>
  25 #include <libioP.h>
  26
  27
  28 static ssize_t
  29 devstream_write (void *cookie, const char *buffer, size_t n)
  30 {
  31   const device_t dev = (device_t) (uintptr_t) cookie;
  32
  33   int write_some (const char *p, size_t to_write)
  34     {
  35       kern_return_t err;
  36       int wrote;
  37       int thiswrite;
  38
  39       while (to_write > 0)
  40         {
  41           thiswrite = to_write;
  42           if (thiswrite > IO_INBAND_MAX)
  43             thiswrite = IO_INBAND_MAX;
  44
  45           if (err = device_write_inband (dev, 0, 0, p, thiswrite, &wrote))
  46             {
  47               errno = err;
  48               return 0;
  49             }
  50           p += wrote;
  51           to_write -= wrote;
  52         }
  53       return 1;
  54     }
  55   int write_crlf (void)
  56     {
  57       static const char crlf[] = "\r\n";
  58       return write_some (crlf, 2);
  59     }
  60
  61   /* Search for newlines (LFs) in the buffer.  */
  62
  63   const char *start = buffer, *p;
  64   while ((p = memchr (start, '\n', n)) != NULL)
  65     {
  66       /* Found one.  Write out through the preceding character,
  67          and then write a CR/LF pair.  */
  68
  69       if ((p > start && !write_some (start, p - start))
  70           || !write_crlf ())
  71         return (start - buffer) ?: -1;
  72
  73       n -= p + 1 - start;
  74       start = p + 1;
  75     }
  76
  77   /* Write the remainder of the buffer.  */
  78   if (write_some (start, n))
  79     start += n;
  80   return (start - buffer) ?: -1;
  81 }
  82
  83 static ssize_t
  84 devstream_read (void *cookie, char *buffer, size_t to_read)
  85 {
  86   const device_t dev = (device_t) (uintptr_t) cookie;
  87
  88   kern_return_t err;
  89   mach_msg_type_number_t nread = to_read;
  90
  91   err = device_read_inband (dev, 0, 0, to_read, buffer, &nread);
  92   if (err)
  93     {
  94       errno = err;
  95       return -1;
  96     }
  97
  98   /* Translate CR to LF.  */
  99   {
 100     char *p;
 101     for (p = memchr (buffer, '\r', nread); p;
 102          p = memchr (p + 1, '\r', (buffer + nread) - (p + 1)))
 103       *p = '\n';
 104   }
 105
 106   /* Echo back what we read.  */
 107   (void) devstream_write (cookie, buffer, nread);
 108
 109   return nread;
 110 }
 111
 112 static int
 113 dealloc_ref (void *cookie)
 114 {
 115   const device_t dev = (device_t) (uintptr_t) cookie;
 116   if (__mach_port_deallocate (mach_task_self (), dev))
 117     {
 118       errno = EINVAL;
 119       return -1;
 120     }
 121   return 0;
 122 }
 123
 124 FILE *
 125 mach_open_devstream (mach_port_t dev, const char *mode)
 126 {
 127   FILE *stream;
 128
 129   if (mach_port_mod_refs (mach_task_self (), dev, MACH_PORT_RIGHT_SEND, 1))
 130     {
 131       errno = EINVAL;
 132       return NULL;
 133     }
 134
 135   stream = _IO_fopencookie ((void *) (uintptr_t) dev, mode,
 136                             (cookie_io_functions_t) { write: devstream_write,
 137                                                       read: devstream_read,
 138                                                       close: dealloc_ref });
 139   if (stream == NULL)
 140     {
 141       __mach_port_deallocate (mach_task_self (), dev);
 142       return NULL;
 143     }
 144
 145   return stream;
 146 }