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

source code of glibc/hurd/hurdmsg.c