hurd/hurdmsg.c

   1 /* Copyright (C) 1992, 1994, 1995, 1996 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 Library General Public License as
   6 published by the Free Software Foundation; either version 2 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 Library General Public License for more details.
  13
  14 You should have received a copy of the GNU Library General Public
  15 License along with the GNU C Library; see the file COPYING.LIB.  If
  16 not, write to the Free Software Foundation, Inc., 675 Mass Ave,
  17 Cambridge, MA 02139, USA.  */
  18
  19 #include <hurd.h>
  20 #include <hurd/msg_server.h>
  21 #include <hurd/fd.h>
  22 #include <unistd.h>
  23 #include <limits.h>
  24 #include <string.h>
  25 #include <argz.h>
  26
  27
  28 #define AUTHCHECK \
  29   if (auth != mach_task_self () && ! __USEPORT (AUTH, port == auth)) \
  30     return EPERM
  31
  32
  33 /* Snarfing and frobbing the init ports.  */
  34
  35 kern_return_t
  36   _S_msg_get_init_port (mach_port_t msgport, mach_port_t auth, int which,
  37                         mach_port_t *result, mach_msg_type_name_t *result_type)
  38 {
  39   AUTHCHECK;
  40   *result_type = MACH_MSG_TYPE_MOVE_SEND;
  41   /* This function adds a new user reference for the *RESULT it gives back.
  42      Our reply message uses a move-send right that consumes this reference.  */
  43   return _hurd_ports_get (which, result);
  44 }
  45
  46 kern_return_t
  47 _S_msg_set_init_port (mach_port_t msgport, mach_port_t auth,
  48                       int which, mach_port_t port)
  49 {
  50   error_t err;
  51
  52   AUTHCHECK;
  53
  54   err = _hurd_ports_set (which, port);
  55   if (err == 0)
  56     __mach_port_deallocate (__mach_task_self (), port);
  57
  58   return 0;
  59 }
  60
  61 kern_return_t
  62 _S_msg_get_init_ports (mach_port_t msgport, mach_port_t auth,
  63                        mach_port_t **ports,
  64                        mach_msg_type_name_t *ports_type,
  65                        mach_msg_type_number_t *nports)
  66 {
  67   mach_msg_type_number_t i;
  68   error_t err;
  69
  70   AUTHCHECK;
  71
  72   if (err = __vm_allocate (__mach_task_self (), (vm_address_t *) ports,
  73                            _hurd_nports * sizeof (mach_port_t), 1))
  74     return err;
  75   *nports = _hurd_nports;
  76
  77   for (i = 0; i < _hurd_nports; ++i)
  78     /* This function adds a new user ref for the *RESULT it gives back.
  79        Our reply message uses move-send rights that consumes this ref.  */
  80     if (err = _hurd_ports_get (i, &(*ports)[i]))
  81       {
  82         /* Died part way through.  Deallocate the ports already fetched.  */
  83         while (i-- > 0)
  84           __mach_port_deallocate (__mach_task_self (), (*ports)[i]);
  85         __vm_deallocate (__mach_task_self (),
  86                          (vm_address_t) *ports,
  87                          *nports * sizeof (mach_port_t));
  88         return err;
  89       }
  90
  91   *ports_type = MACH_MSG_TYPE_MOVE_SEND;
  92   return 0;
  93 }
  94
  95 kern_return_t
  96 _S_msg_set_init_ports (mach_port_t msgport, mach_port_t auth,
  97                        mach_port_t *ports, mach_msg_type_number_t nports)
  98 {
  99   mach_msg_type_number_t i;
 100   error_t err;
 101
 102   AUTHCHECK;
 103
 104   for (i = 0; i < _hurd_nports; ++i)
 105     {
 106       if (err = _hurd_ports_set (i, ports[i]))
 107         return err;
 108       else
 109         __mach_port_deallocate (__mach_task_self (), ports[i]);
 110     }
 111
 112   return 0;
 113 }
 114 \f
 115 /* Snarfing and frobbing the init ints.  */
 116
 117 static kern_return_t
 118 get_int (int which, int *value)
 119 {
 120   switch (which)
 121     {
 122     case INIT_UMASK:
 123       *value = _hurd_umask;
 124       return 0;
 125     case INIT_SIGMASK:
 126       {
 127         struct hurd_sigstate *ss = _hurd_thread_sigstate (_hurd_sigthread);
 128         __spin_lock (&ss->lock);
 129         *value = ss->blocked;
 130         __spin_unlock (&ss->lock);
 131         return 0;
 132       }
 133     case INIT_SIGPENDING:
 134       {
 135         struct hurd_sigstate *ss = _hurd_thread_sigstate (_hurd_sigthread);
 136         __spin_lock (&ss->lock);
 137         *value = ss->pending;
 138         __spin_unlock (&ss->lock);
 139         return 0;
 140       }
 141     case INIT_SIGIGN:
 142       {
 143         struct hurd_sigstate *ss = _hurd_thread_sigstate (_hurd_sigthread);
 144         sigset_t ign;
 145         int sig;
 146         __spin_lock (&ss->lock);
 147         __sigemptyset (&ign);
 148         for (sig = 1; sig < NSIG; ++sig)
 149           if (ss->actions[sig].sa_handler == SIG_IGN)
 150             __sigaddset (&ign, sig);
 151         __spin_unlock (&ss->lock);
 152         *value = ign;
 153         return 0;
 154       }
 155     default:
 156       return EINVAL;
 157     }
 158 }
 159
 160 kern_return_t
 161 _S_msg_get_init_int (mach_port_t msgport, mach_port_t auth,
 162                      int which, int *value)
 163 {
 164   AUTHCHECK;
 165
 166   return get_int (which, value);
 167 }
 168
 169 kern_return_t
 170 _S_msg_get_init_ints (mach_port_t msgport, mach_port_t auth,
 171                       int **values, mach_msg_type_number_t *nvalues)
 172 {
 173   error_t err;
 174   mach_msg_type_number_t i;
 175
 176   AUTHCHECK;
 177
 178   if (err = __vm_allocate (__mach_task_self (), (vm_address_t *) values,
 179                            INIT_INT_MAX * sizeof (int), 1))
 180     return err;
 181   *nvalues = INIT_INT_MAX;
 182
 183   for (i = 0; i < INIT_INT_MAX; ++i)
 184     switch (err = get_int (i, &(*values)[i]))
 185       {
 186       case 0:                   /* Success.  */
 187         break;
 188       case EINVAL:              /* Unknown index.  */
 189         (*values)[i] = 0;
 190         break;
 191       default:                  /* Lossage.  */
 192         __vm_deallocate (__mach_task_self (),
 193                          (vm_address_t) *values, INIT_INT_MAX * sizeof (int));
 194         return err;
 195       }
 196
 197   return 0;
 198 }
 199
 200
 201 static kern_return_t
 202 set_int (int which, int value)
 203 {
 204   switch (which)
 205     {
 206     case INIT_UMASK:
 207       _hurd_umask = value;
 208       return 0;
 209
 210       /* These are pretty odd things to do.  But you asked for it.  */
 211     case INIT_SIGMASK:
 212       {
 213         struct hurd_sigstate *ss = _hurd_thread_sigstate (_hurd_sigthread);
 214         __spin_lock (&ss->lock);
 215         ss->blocked = value;
 216         __spin_unlock (&ss->lock);
 217         return 0;
 218       }
 219     case INIT_SIGPENDING:
 220       {
 221         struct hurd_sigstate *ss = _hurd_thread_sigstate (_hurd_sigthread);
 222         __spin_lock (&ss->lock);
 223         ss->pending = value;
 224         __spin_unlock (&ss->lock);
 225         return 0;
 226       }
 227     case INIT_SIGIGN:
 228       {
 229         struct hurd_sigstate *ss = _hurd_thread_sigstate (_hurd_sigthread);
 230         int sig;
 231         const sigset_t ign = value;
 232         __spin_lock (&ss->lock);
 233         for (sig = 1; sig < NSIG; ++sig)
 234           {
 235             if (__sigismember (&ign, sig))
 236               ss->actions[sig].sa_handler = SIG_IGN;
 237             else if (ss->actions[sig].sa_handler == SIG_IGN)
 238               ss->actions[sig].sa_handler = SIG_DFL;
 239           }
 240         __spin_unlock (&ss->lock);
 241         return 0;
 242       }
 243     default:
 244       return EINVAL;
 245     }
 246 }
 247
 248 kern_return_t
 249 _S_msg_set_init_int (mach_port_t msgport, mach_port_t auth,
 250                      int which, int value)
 251 {
 252   AUTHCHECK;
 253
 254   return set_int (which, value);
 255 }
 256
 257 kern_return_t
 258 _S_msg_set_init_ints (mach_port_t msgport, mach_port_t auth,
 259                       int *values, mach_msg_type_number_t nvalues)
 260 {
 261   error_t err;
 262   mach_msg_type_number_t i;
 263
 264   AUTHCHECK;
 265
 266   for (i = 0; i < INIT_INT_MAX; ++i)
 267     switch (err = set_int (i, values[i]))
 268       {
 269       case 0:                   /* Success.  */
 270         break;
 271       case EINVAL:              /* Unknown index.  */
 272         break;
 273       default:                  /* Lossage.  */
 274         return err;
 275       }
 276
 277   return 0;
 278 }
 279 \f
 280
 281 kern_return_t
 282 _S_msg_get_fd (mach_port_t msgport, mach_port_t auth, int which,
 283                mach_port_t *result, mach_msg_type_name_t *result_type)
 284 {
 285   AUTHCHECK;
 286
 287   /* This creates a new user reference for the send right.
 288      Our reply message will move that reference to the caller.  */
 289   *result = __getdport (which);
 290   if (*result == MACH_PORT_NULL)
 291     return errno;
 292   *result_type = MACH_MSG_TYPE_MOVE_SEND;
 293
 294   return 0;
 295 }
 296
 297 kern_return_t
 298 _S_msg_set_fd (mach_port_t msgport, mach_port_t auth,
 299                int which, mach_port_t port)
 300 {
 301   AUTHCHECK;
 302
 303   /* We consume the reference if successful.  */
 304   return HURD_FD_USE (which, (_hurd_port2fd (descriptor, port, 0), 0));
 305 }
 306 \f
 307 /* Snarfing and frobbing environment variables.  */
 308
 309 kern_return_t
 310 _S_msg_get_env_variable (mach_port_t msgport,
 311                          char *variable,
 312                          char **data, mach_msg_type_number_t *datalen)
 313 {
 314   const char *value = getenv (variable);
 315
 316   if (value == NULL)
 317     return ENOENT;
 318
 319   /* XXX this pointer might become invalid */
 320   *data = value;
 321   *datalen = strlen (value);
 322   return 0;
 323 }
 324
 325
 326 kern_return_t
 327 _S_msg_set_env_variable (mach_port_t msgport, mach_port_t auth,
 328                          char *variable,
 329                          char *value,
 330                          int replace)
 331 {
 332   AUTHCHECK;
 333
 334   if (setenv (variable, value, replace)) /* XXX name space */
 335     return errno;
 336   return 0;
 337 }
 338
 339 kern_return_t
 340 _S_msg_get_environment (mach_port_t msgport,
 341                         char **data, mach_msg_type_number_t *datalen)
 342 {
 343   /* Pack the environment into an array with nulls separating elements.  */
 344   if (__environ != NULL)
 345     {
 346       char *ap, **p;
 347       size_t envlen = 0;
 348
 349       for (p = __environ; *p != NULL; ++p)
 350         envlen += strlen (*p) + 1;
 351
 352       if (envlen > *datalen)
 353         {
 354           if (__vm_allocate (__mach_task_self (),
 355                              (vm_address_t *) data, envlen, 1))
 356             return ENOMEM;
 357         }
 358
 359       ap = *data;
 360       for (p = __environ; *p != NULL; ++p)
 361         ap = __memccpy (ap, *p, '\0', ULONG_MAX);
 362
 363       *datalen = envlen;
 364     }
 365   else
 366     *datalen = 0;
 367
 368   return 0;
 369 }
 370
 371 kern_return_t
 372 _S_msg_set_environment (mach_port_t msgport, mach_port_t auth,
 373                         char *data, mach_msg_type_number_t datalen)
 374 {
 375   int _hurd_split_args (char *, mach_msg_type_number_t, char **);
 376   int envc;
 377   char **envp;
 378
 379   AUTHCHECK;
 380
 381   envc = __argz_count (data, datalen);
 382   envp = malloc ((envc + 1) * sizeof (char *));
 383   if (envp == NULL)
 384     return errno;
 385   __argz_extract (data, datalen, envp);
 386   __environ = envp;             /* XXX cooperate with loadenv et al */
 387   return 0;
 388 }
 389 \f
 390
 391 /* XXX */
 392
 393 kern_return_t
 394 _S_msg_get_dtable (mach_port_t process,
 395                    mach_port_t refport,
 396                    portarray_t *dtable,
 397                    mach_msg_type_name_t *dtablePoly,
 398                    mach_msg_type_number_t *dtableCnt)
 399 { return EOPNOTSUPP; }
 400
 401 kern_return_t
 402 _S_msg_set_dtable (mach_port_t process,
 403                    mach_port_t refport,
 404                    portarray_t dtable,
 405                    mach_msg_type_number_t dtableCnt)
 406 { return EOPNOTSUPP; }