hurd/hurdmsg.c

   1 /* Copyright (C) 1992, 1994, 1995, 1996, 1997 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 not,
  16    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17    Boston, MA 02111-1307, 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       case INIT_TRACEMASK:
 244         _hurdsig_traced = value;
 245         return 0;
 246       }
 247     default:
 248       return EINVAL;
 249     }
 250 }
 251
 252 kern_return_t
 253 _S_msg_set_init_int (mach_port_t msgport, mach_port_t auth,
 254                      int which, int value)
 255 {
 256   AUTHCHECK;
 257
 258   return set_int (which, value);
 259 }
 260
 261 kern_return_t
 262 _S_msg_set_init_ints (mach_port_t msgport, mach_port_t auth,
 263                       int *values, mach_msg_type_number_t nvalues)
 264 {
 265   error_t err;
 266   mach_msg_type_number_t i;
 267
 268   AUTHCHECK;
 269
 270   for (i = 0; i < INIT_INT_MAX; ++i)
 271     switch (err = set_int (i, values[i]))
 272       {
 273       case 0:                   /* Success.  */
 274         break;
 275       case EINVAL:              /* Unknown index.  */
 276         break;
 277       default:                  /* Lossage.  */
 278         return err;
 279       }
 280
 281   return 0;
 282 }
 283 \f
 284
 285 kern_return_t
 286 _S_msg_get_fd (mach_port_t msgport, mach_port_t auth, int which,
 287                mach_port_t *result, mach_msg_type_name_t *result_type)
 288 {
 289   AUTHCHECK;
 290
 291   /* This creates a new user reference for the send right.
 292      Our reply message will move that reference to the caller.  */
 293   *result = __getdport (which);
 294   if (*result == MACH_PORT_NULL)
 295     return errno;
 296   *result_type = MACH_MSG_TYPE_MOVE_SEND;
 297
 298   return 0;
 299 }
 300
 301 kern_return_t
 302 _S_msg_set_fd (mach_port_t msgport, mach_port_t auth,
 303                int which, mach_port_t port)
 304 {
 305   AUTHCHECK;
 306
 307   /* We consume the reference if successful.  */
 308   return HURD_FD_USE (which, (_hurd_port2fd (descriptor, port, 0), 0));
 309 }
 310 \f
 311 /* Snarfing and frobbing environment variables.  */
 312
 313 kern_return_t
 314 _S_msg_get_env_variable (mach_port_t msgport,
 315                          char *variable,
 316                          char **data, mach_msg_type_number_t *datalen)
 317 {
 318   const char *value = getenv (variable);
 319
 320   if (value == NULL)
 321     return ENOENT;
 322
 323   /* XXX this pointer might become invalid */
 324   *data = value;
 325   *datalen = strlen (value);
 326   return 0;
 327 }
 328
 329
 330 kern_return_t
 331 _S_msg_set_env_variable (mach_port_t msgport, mach_port_t auth,
 332                          char *variable,
 333                          char *value,
 334                          int replace)
 335 {
 336   AUTHCHECK;
 337
 338   if (setenv (variable, value, replace)) /* XXX name space */
 339     return errno;
 340   return 0;
 341 }
 342
 343 kern_return_t
 344 _S_msg_get_environment (mach_port_t msgport,
 345                         char **data, mach_msg_type_number_t *datalen)
 346 {
 347   /* Pack the environment into an array with nulls separating elements.  */
 348   if (__environ != NULL)
 349     {
 350       char *ap, **p;
 351       size_t envlen = 0;
 352
 353       for (p = __environ; *p != NULL; ++p)
 354         envlen += strlen (*p) + 1;
 355
 356       if (envlen > *datalen)
 357         {
 358           if (__vm_allocate (__mach_task_self (),
 359                              (vm_address_t *) data, envlen, 1))
 360             return ENOMEM;
 361         }
 362
 363       ap = *data;
 364       for (p = __environ; *p != NULL; ++p)
 365         ap = __memccpy (ap, *p, '\0', ULONG_MAX);
 366
 367       *datalen = envlen;
 368     }
 369   else
 370     *datalen = 0;
 371
 372   return 0;
 373 }
 374
 375 kern_return_t
 376 _S_msg_set_environment (mach_port_t msgport, mach_port_t auth,
 377                         char *data, mach_msg_type_number_t datalen)
 378 {
 379   int _hurd_split_args (char *, mach_msg_type_number_t, char **);
 380   int envc;
 381   char **envp;
 382
 383   AUTHCHECK;
 384
 385   envc = __argz_count (data, datalen);
 386   envp = malloc ((envc + 1) * sizeof (char *));
 387   if (envp == NULL)
 388     return errno;
 389   __argz_extract (data, datalen, envp);
 390   __environ = envp;             /* XXX cooperate with loadenv et al */
 391   return 0;
 392 }
 393 \f
 394
 395 /* XXX */
 396
 397 kern_return_t
 398 _S_msg_get_dtable (mach_port_t process,
 399                    mach_port_t refport,
 400                    portarray_t *dtable,
 401                    mach_msg_type_name_t *dtablePoly,
 402                    mach_msg_type_number_t *dtableCnt)
 403 { return EOPNOTSUPP; }
 404
 405 kern_return_t
 406 _S_msg_set_dtable (mach_port_t process,
 407                    mach_port_t refport,
 408                    portarray_t dtable,
 409                    mach_msg_type_number_t dtableCnt)
 410 { return EOPNOTSUPP; }