sysdeps/mach/hurd/sendmsg.c

   1 /* Copyright (C) 2001,2002,2004 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 License as
   6    published by the Free Software Foundation; either version 2.1 of the
   7    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; see the file COPYING.LIB.  If not,
  16    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17    Boston, MA 02111-1307, USA.  */
  18
  19 #include <errno.h>
  20 #include <string.h>
  21 #include <sys/socket.h>
  22 #include <sys/un.h>
  23
  24 #include <hurd.h>
  25 #include <hurd/fd.h>
  26 #include <hurd/ifsock.h>
  27 #include <hurd/socket.h>
  28
  29 /* Send a message described MESSAGE on socket FD.
  30    Returns the number of bytes sent, or -1 for errors.  */
  31 ssize_t
  32 __libc_sendmsg (int fd, const struct msghdr *message, int flags)
  33 {
  34   error_t err = 0;
  35   struct sockaddr_un *addr = message->msg_name;
  36   socklen_t addr_len = message->msg_namelen;
  37   addr_port_t aport = MACH_PORT_NULL;
  38   union
  39   {
  40     char *ptr;
  41     vm_address_t addr;
  42   } data = { .ptr = NULL };
  43   char data_buf[2048];
  44   mach_msg_type_number_t len;
  45   mach_msg_type_number_t amount;
  46   int dealloc = 0;
  47   int i;
  48
  49   /* Find the total number of bytes to be written.  */
  50   len = 0;
  51   for (i = 0; i < message->msg_iovlen; i++)
  52     {
  53       if (message->msg_iov[i].iov_len > 0)
  54         {
  55           /* As an optimization, if we only have a single non-empty
  56              iovec, we set DATA and LEN from it.  */
  57           if (len == 0)
  58             data.ptr = message->msg_iov[i].iov_base;
  59           else
  60             data.ptr = NULL;
  61
  62           len += message->msg_iov[i].iov_len;
  63         }
  64     }
  65
  66   if (data.ptr == NULL)
  67     {
  68       size_t to_copy;
  69       char *buf;
  70
  71       /* Allocate a temporary buffer to hold the data.  For small
  72          amounts of data, we allocate a buffer on the stack.  Larger
  73          amounts of data are stored in a page-aligned buffer.  The
  74          limit of 2048 bytes is inspired by the MiG stubs.  */
  75       if (len > 2048)
  76         {
  77           err = __vm_allocate (__mach_task_self (), &data.addr, len, 1);
  78           if (err)
  79             {
  80               __set_errno (err);
  81               return -1;
  82             }
  83           dealloc = 1;
  84         }
  85       else
  86         data.ptr = data_buf;
  87
  88       /* Copy the data into DATA.  */
  89       to_copy = len;
  90       buf = data.ptr;
  91       for (i = 0; i < len; i++)
  92         {
  93 #define min(a, b)       ((a) > (b) ? (b) : (a))
  94           size_t copy = min (message->msg_iov[i].iov_len, to_copy);
  95
  96           buf = __mempcpy (buf, message->msg_iov[i].iov_base, copy);
  97
  98           to_copy -= copy;
  99           if (to_copy == 0)
 100             break;
 101         }
 102     }
 103
 104   if (addr)
 105     {
 106       if (addr->sun_family == AF_LOCAL)
 107         {
 108           /* For the local domain, we must look up the name as a file
 109              and talk to it with the ifsock protocol.  */
 110           file_t file = __file_name_lookup (addr->sun_path, 0, 0);
 111           if (file == MACH_PORT_NULL)
 112             return -1;
 113           err = __ifsock_getsockaddr (file, &aport);
 114           __mach_port_deallocate (__mach_task_self (), file);
 115           if (err == MIG_BAD_ID || err == EOPNOTSUPP)
 116             /* The file did not grok the ifsock protocol.  */
 117             err = ENOTSOCK;
 118           if (err)
 119             return __hurd_fail (err);
 120         }
 121       else
 122         err = EIEIO;
 123     }
 124
 125   err = HURD_DPORT_USE (fd,
 126                         ({
 127                           if (err)
 128                             err = __socket_create_address (port,
 129                                                            addr->sun_family,
 130                                                            (char *) addr,
 131                                                            addr_len,
 132                                                            &aport);
 133                           if (! err)
 134                             {
 135                               /* Send the data.  */
 136                               err = __socket_send (port, aport,
 137                                                    flags, data.ptr, len,
 138                                                    NULL,
 139                                                    MACH_MSG_TYPE_COPY_SEND, 0,
 140                                                    message->msg_control,
 141                                                    message->msg_controllen,
 142                                                    &amount);
 143                               __mach_port_deallocate (__mach_task_self (),
 144                                                       aport);
 145                             }
 146                           err;
 147                         }));
 148
 149   if (dealloc)
 150     __vm_deallocate (__mach_task_self (), data.addr, len);
 151
 152   return err ? __hurd_sockfail (fd, flags, err) : amount;
 153 }
 154
 155 weak_alias (__libc_sendmsg, sendmsg)
 156 weak_alias (__libc_sendmsg, __sendmsg)