]> git.saurik.com Git - apple/launchd.git/blob - launchd/src/launchctl.c
projects / apple / launchd.git / blob
? search:


f6911d57cf01b59725cc02cd3007c4cf3f2b0399
[apple/launchd.git] / launchd / src / launchctl.c
1 /*
2 * Copyright (c) 2005 Apple Computer, Inc. All rights reserved.
3 *
4 * @APPLE_LICENSE_HEADER_START@
5 *
6 * This file contains Original Code and/or Modifications of Original Code
7 * as defined in and that are subject to the Apple Public Source License
8 * Version 2.0 (the 'License'). You may not use this file except in
9 * compliance with the License. Please obtain a copy of the License at
10 * http://www.opensource.apple.com/apsl/ and read it before using this
11 * file.
12 *
13 * The Original Code and all software distributed under the License are
14 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
15 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
16 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
18 * Please see the License for the specific language governing rights and
19 * limitations under the License.
20 *
21 * @APPLE_LICENSE_HEADER_END@
22 */
23 #include <CoreFoundation/CoreFoundation.h>
24 #include <sys/types.h>
25 #include <sys/time.h>
26 #include <sys/stat.h>
27 #include <sys/socket.h>
28 #include <sys/un.h>
29 #include <sys/fcntl.h>
30 #include <sys/event.h>
31 #include <sys/resource.h>
32 #include <sys/param.h>
33 #include <netinet/in.h>
34 #include <unistd.h>
35 #include <dirent.h>
36 #include <libgen.h>
37 #include <pwd.h>
38 #include <stdio.h>
39 #include <stdlib.h>
40 #include <pwd.h>
41 #include <grp.h>
42 #include <netdb.h>
43 #include <syslog.h>
44 #include <readline/readline.h>
45 #include <readline/history.h>
46 #include <dns_sd.h>
47
48 #include "launch.h"
49 #include "launch_priv.h"
50
51 #define LAUNCH_SECDIR "/tmp/launch-XXXXXX"
52
53 static bool launch_data_array_append(launch_data_t a, launch_data_t o);
54 static void distill_config_file(launch_data_t);
55 static void sock_dict_cb(launch_data_t what, const char *key, void *context);
56 static void sock_dict_edit_entry(launch_data_t tmp, const char *key, launch_data_t fdarray, launch_data_t thejob);
57 static launch_data_t CF2launch_data(CFTypeRef);
58 static launch_data_t read_plist_file(const char *file, bool editondisk, bool load);
59 static CFPropertyListRef CreateMyPropertyListFromFile(const char *);
60 static void WriteMyPropertyListToFile(CFPropertyListRef, const char *);
61 static void readpath(const char *, launch_data_t, launch_data_t, bool editondisk, bool load);
62 static int _fd(int);
63 static int demux_cmd(int argc, char *const argv[]);
64 static launch_data_t do_rendezvous_magic(const struct addrinfo *res, const char *serv);
65 static void submit_job_pass(launch_data_t jobs);
66
67 static int load_and_unload_cmd(int argc, char *const argv[]);
68 //static int reload_cmd(int argc, char *const argv[]);
69 static int start_and_stop_cmd(int argc, char *const argv[]);
70 static int list_cmd(int argc, char *const argv[]);
71
72 static int setenv_cmd(int argc, char *const argv[]);
73 static int unsetenv_cmd(int argc, char *const argv[]);
74 static int getenv_and_export_cmd(int argc, char *const argv[]);
75
76 static int limit_cmd(int argc, char *const argv[]);
77 static int stdio_cmd(int argc, char *const argv[]);
78 static int fyi_cmd(int argc, char *const argv[]);
79 static int logupdate_cmd(int argc, char *const argv[]);
80 static int umask_cmd(int argc, char *const argv[]);
81 static int getrusage_cmd(int argc, char *const argv[]);
82
83 static int help_cmd(int argc, char *const argv[]);
84
85 static const struct {
86 const char *name;
87 int (*func)(int argc, char *const argv[]);
88 const char *desc;
89 } cmds[] = {
90 { "load", load_and_unload_cmd, "Load configuration files and/or directories" },
91 { "unload", load_and_unload_cmd, "Unload configuration files and/or directories" },
92 // { "reload", reload_cmd, "Reload configuration files and/or directories" },
93 { "start", start_and_stop_cmd, "Start specified jobs" },
94 { "stop", start_and_stop_cmd, "Stop specified jobs" },
95 { "list", list_cmd, "List jobs and information about jobs" },
96 { "setenv", setenv_cmd, "Set an environmental variable in launchd" },
97 { "unsetenv", unsetenv_cmd, "Unset an environmental variable in launchd" },
98 { "getenv", getenv_and_export_cmd, "Get an environmental variable from launchd" },
99 { "export", getenv_and_export_cmd, "Export shell settings from launchd" },
100 { "limit", limit_cmd, "View and adjust launchd resource limits" },
101 { "stdout", stdio_cmd, "Redirect launchd's standard out to the given path" },
102 { "stderr", stdio_cmd, "Redirect launchd's standard error to the given path" },
103 { "shutdown", fyi_cmd, "Prepare for system shutdown" },
104 { "reloadttys", fyi_cmd, "Reload /etc/ttys" },
105 { "getrusage", getrusage_cmd, "Get resource usage statistics from launchd" },
106 { "log", logupdate_cmd, "Adjust the logging level or mask of launchd" },
107 { "umask", umask_cmd, "Change launchd's umask" },
108 { "help", help_cmd, "This help output" },
109 };
110
111 int main(int argc, char *const argv[])
112 {
113 bool istty = isatty(STDIN_FILENO);
114 char *l;
115
116 if (argc > 1)
117 exit(demux_cmd(argc - 1, argv + 1));
118
119 if (NULL == readline) {
120 fprintf(stderr, "missing library: readline\n");
121 exit(EXIT_FAILURE);
122 }
123
124 while ((l = readline(istty ? "launchd% " : NULL))) {
125 char *inputstring = l, *argv2[100], **ap = argv2;
126 int i = 0;
127
128 while ((*ap = strsep(&inputstring, " \t"))) {
129 if (**ap != '\0') {
130 ap++;
131 i++;
132 }
133 }
134
135 if (i > 0)
136 demux_cmd(i, argv2);
137
138 free(l);
139 }
140
141 if (istty)
142 fputc('\n', stdout);
143
144 exit(EXIT_SUCCESS);
145 }
146
147 static int demux_cmd(int argc, char *const argv[])
148 {
149 size_t i;
150
151 optind = 1;
152 optreset = 1;
153
154 for (i = 0; i < (sizeof cmds / sizeof cmds[0]); i++) {
155 if (!strcmp(cmds[i].name, argv[0]))
156 return cmds[i].func(argc, argv);
157 }
158
159 fprintf(stderr, "%s: unknown subcommand \"%s\"\n", getprogname(), argv[0]);
160 return 1;
161 }
162
163 static int unsetenv_cmd(int argc, char *const argv[])
164 {
165 launch_data_t resp, tmp, msg;
166
167 if (argc != 2) {
168 fprintf(stderr, "%s usage: unsetenv <key>\n", getprogname());
169 return 1;
170 }
171
172 msg = launch_data_alloc(LAUNCH_DATA_DICTIONARY);
173
174 tmp = launch_data_new_string(argv[1]);
175 launch_data_dict_insert(msg, tmp, LAUNCH_KEY_UNSETUSERENVIRONMENT);
176
177 resp = launch_msg(msg);
178
179 launch_data_free(msg);
180
181 if (resp) {
182 launch_data_free(resp);
183 } else {
184 fprintf(stderr, "launch_msg(\"%s\"): %s\n", LAUNCH_KEY_UNSETUSERENVIRONMENT, strerror(errno));
185 }
186
187 return 0;
188 }
189
190 static int setenv_cmd(int argc, char *const argv[])
191 {
192 launch_data_t resp, tmp, tmpv, msg;
193
194 if (argc != 3) {
195 fprintf(stderr, "%s usage: setenv <key> <value>\n", getprogname());
196 return 1;
197 }
198
199 msg = launch_data_alloc(LAUNCH_DATA_DICTIONARY);
200 tmp = launch_data_alloc(LAUNCH_DATA_DICTIONARY);
201
202 tmpv = launch_data_new_string(argv[2]);
203 launch_data_dict_insert(tmp, tmpv, argv[1]);
204 launch_data_dict_insert(msg, tmp, LAUNCH_KEY_SETUSERENVIRONMENT);
205
206 resp = launch_msg(msg);
207 launch_data_free(msg);
208
209 if (resp) {
210 launch_data_free(resp);
211 } else {
212 fprintf(stderr, "launch_msg(\"%s\"): %s\n", LAUNCH_KEY_SETUSERENVIRONMENT, strerror(errno));
213 }
214
215 return 0;
216 }
217
218 static int getenv_and_export_cmd(int argc, char *const argv[] __attribute__((unused)))
219 {
220 launch_data_t resp, msg;
221 bool is_csh = false;
222 const char *k;
223 void print_launchd_env(launch_data_t obj, const char *key, void *context __attribute__((unused))) {
224 if (is_csh)
225 fprintf(stdout, "setenv %s %s;\n", key, launch_data_get_string(obj));
226 else
227 fprintf(stdout, "%s=%s; export %s;\n", key, launch_data_get_string(obj), key);
228 }
229 void print_key_value(launch_data_t obj, const char *key, void *context __attribute__((unused))) {
230 if (!strcmp(key, k))
231 fprintf(stdout, "%s\n", launch_data_get_string(obj));
232 }
233
234 if (!strcmp(argv[0], "export")) {
235 char *s = getenv("SHELL");
236 if (s)
237 is_csh = strstr(s, "csh") ? true : false;
238 } else if (argc != 2) {
239 fprintf(stderr, "%s usage: getenv <key>\n", getprogname());
240 return 1;
241 }
242
243 k = argv[1];
244
245 msg = launch_data_new_string(LAUNCH_KEY_GETUSERENVIRONMENT);
246
247 resp = launch_msg(msg);
248 launch_data_free(msg);
249
250 if (resp) {
251 launch_data_dict_iterate(resp, (!strcmp(argv[0], "export")) ? print_launchd_env : print_key_value, NULL);
252 launch_data_free(resp);
253 } else {
254 fprintf(stderr, "launch_msg(\"" LAUNCH_KEY_GETUSERENVIRONMENT "\"): %s\n", strerror(errno));
255 }
256 return 0;
257 }
258
259 static void unloadjob(launch_data_t job)
260 {
261 launch_data_t resp, tmp, tmps, msg;
262 int e;
263
264 msg = launch_data_alloc(LAUNCH_DATA_DICTIONARY);
265 tmp = launch_data_alloc(LAUNCH_DATA_STRING);
266 tmps = launch_data_dict_lookup(job, LAUNCH_JOBKEY_LABEL);
267
268 if (!tmps) {
269 fprintf(stderr, "%s: Error: Missing Key: %s\n", getprogname(), LAUNCH_JOBKEY_LABEL);
270 return;
271 }
272
273 launch_data_set_string(tmp, launch_data_get_string(tmps));
274 launch_data_dict_insert(msg, tmp, LAUNCH_KEY_REMOVEJOB);
275 resp = launch_msg(msg);
276 launch_data_free(msg);
277 if (!resp) {
278 fprintf(stderr, "%s: Error: launch_msg(): %s\n", getprogname(), strerror(errno));
279 return;
280 }
281 if (LAUNCH_DATA_ERRNO == launch_data_get_type(resp)) {
282 if ((e = launch_data_get_errno(resp)))
283 fprintf(stderr, "%s\n", strerror(e));
284 }
285 launch_data_free(resp);
286 }
287
288 static launch_data_t read_plist_file(const char *file, bool editondisk, bool load)
289 {
290 CFPropertyListRef plist = CreateMyPropertyListFromFile(file);
291 launch_data_t r = NULL;
292
293 if (NULL == plist) {
294 fprintf(stderr, "%s: no plist was returned for: %s\n", getprogname(), file);
295 return NULL;
296 }
297
298 if (editondisk) {
299 if (load)
300 CFDictionaryRemoveValue((CFMutableDictionaryRef)plist, CFSTR(LAUNCH_JOBKEY_DISABLED));
301 else
302 CFDictionarySetValue((CFMutableDictionaryRef)plist, CFSTR(LAUNCH_JOBKEY_DISABLED), kCFBooleanTrue);
303 WriteMyPropertyListToFile(plist, file);
304 }
305
306 r = CF2launch_data(plist);
307
308 CFRelease(plist);
309
310 return r;
311 }
312
313 static void delay_to_second_pass2(launch_data_t o, const char *key, void *context)
314 {
315 bool *res = context;
316 size_t i;
317
318 if (key && 0 == strcmp(key, LAUNCH_JOBSOCKETKEY_BONJOUR)) {
319 *res = true;
320 return;
321 }
322
323 switch (launch_data_get_type(o)) {
324 case LAUNCH_DATA_DICTIONARY:
325 launch_data_dict_iterate(o, delay_to_second_pass2, context);
326 break;
327 case LAUNCH_DATA_ARRAY:
328 for (i = 0; i < launch_data_array_get_count(o); i++)
329 delay_to_second_pass2(launch_data_array_get_index(o, i), NULL, context);
330 break;
331 default:
332 break;
333 }
334 }
335
336 static bool delay_to_second_pass(launch_data_t o)
337 {
338 bool res = false;
339
340 launch_data_t socks = launch_data_dict_lookup(o, LAUNCH_JOBKEY_SOCKETS);
341
342 if (NULL == socks)
343 return false;
344
345 delay_to_second_pass2(socks, NULL, &res);
346
347 return res;
348 }
349
350 static void readfile(const char *what, launch_data_t pass1, launch_data_t pass2, bool editondisk, bool load)
351 {
352 launch_data_t tmpd, thejob;
353 bool job_disabled = false;
354
355 if (NULL == (thejob = read_plist_file(what, editondisk, load))) {
356 fprintf(stderr, "%s: no plist was returned for: %s\n", getprogname(), what);
357 return;
358 }
359
360 if ((tmpd = launch_data_dict_lookup(thejob, LAUNCH_JOBKEY_DISABLED)))
361 job_disabled = launch_data_get_bool(tmpd);
362
363 if (job_disabled && load) {
364 launch_data_free(thejob);
365 return;
366 }
367
368 if (delay_to_second_pass(thejob))
369 launch_data_array_append(pass2, thejob);
370 else
371 launch_data_array_append(pass1, thejob);
372 }
373
374 static void readpath(const char *what, launch_data_t pass1, launch_data_t pass2, bool editondisk, bool load)
375 {
376 char buf[MAXPATHLEN];
377 struct stat sb;
378 struct dirent *de;
379 DIR *d;
380
381 if (stat(what, &sb) == -1)
382 return;
383
384 if (S_ISREG(sb.st_mode) && !(sb.st_mode & S_IWOTH)) {
385 readfile(what, pass1, pass2, editondisk, load);
386 } else {
387 if ((d = opendir(what)) == NULL) {
388 fprintf(stderr, "%s: opendir() failed to open the directory\n", getprogname());
389 return;
390 }
391
392 while ((de = readdir(d))) {
393 if ((de->d_name[0] == '.'))
394 continue;
395 snprintf(buf, sizeof(buf), "%s/%s", what, de->d_name);
396
397 readfile(buf, pass1, pass2, editondisk, load);
398 }
399 closedir(d);
400 }
401 }
402
403 struct distill_context {
404 launch_data_t base;
405 launch_data_t newsockdict;
406 };
407
408 static void distill_config_file(launch_data_t id_plist)
409 {
410 struct distill_context dc = { id_plist, NULL };
411 launch_data_t tmp;
412
413 if ((tmp = launch_data_dict_lookup(id_plist, LAUNCH_JOBKEY_SOCKETS))) {
414 dc.newsockdict = launch_data_alloc(LAUNCH_DATA_DICTIONARY);
415 launch_data_dict_iterate(tmp, sock_dict_cb, &dc);
416 launch_data_dict_insert(dc.base, dc.newsockdict, LAUNCH_JOBKEY_SOCKETS);
417 }
418 }
419
420 static void sock_dict_cb(launch_data_t what, const char *key, void *context)
421 {
422 struct distill_context *dc = context;
423 launch_data_t fdarray = launch_data_alloc(LAUNCH_DATA_ARRAY);
424
425 launch_data_dict_insert(dc->newsockdict, fdarray, key);
426
427 if (launch_data_get_type(what) == LAUNCH_DATA_DICTIONARY) {
428 sock_dict_edit_entry(what, key, fdarray, dc->base);
429 } else if (launch_data_get_type(what) == LAUNCH_DATA_ARRAY) {
430 launch_data_t tmp;
431 size_t i;
432
433 for (i = 0; i < launch_data_array_get_count(what); i++) {
434 tmp = launch_data_array_get_index(what, i);
435 sock_dict_edit_entry(tmp, key, fdarray, dc->base);
436 }
437 }
438 }
439
440 static void sock_dict_edit_entry(launch_data_t tmp, const char *key, launch_data_t fdarray, launch_data_t thejob)
441 {
442 launch_data_t a, val;
443 int sfd, st = SOCK_STREAM;
444 bool passive = true;
445
446 if ((val = launch_data_dict_lookup(tmp, LAUNCH_JOBSOCKETKEY_TYPE))) {
447 if (!strcasecmp(launch_data_get_string(val), "stream")) {
448 st = SOCK_STREAM;
449 } else if (!strcasecmp(launch_data_get_string(val), "dgram")) {
450 st = SOCK_DGRAM;
451 } else if (!strcasecmp(launch_data_get_string(val), "seqpacket")) {
452 st = SOCK_SEQPACKET;
453 }
454 }
455
456 if ((val = launch_data_dict_lookup(tmp, LAUNCH_JOBSOCKETKEY_PASSIVE)))
457 passive = launch_data_get_bool(val);
458
459 if ((val = launch_data_dict_lookup(tmp, LAUNCH_JOBSOCKETKEY_SECUREWITHKEY))) {
460 char secdir[] = LAUNCH_SECDIR, buf[1024];
461 launch_data_t uenv = launch_data_dict_lookup(thejob, LAUNCH_JOBKEY_USERENVIRONMENTVARIABLES);
462
463 if (NULL == uenv) {
464 uenv = launch_data_alloc(LAUNCH_DATA_DICTIONARY);
465 launch_data_dict_insert(thejob, uenv, LAUNCH_JOBKEY_USERENVIRONMENTVARIABLES);
466 }
467
468 mkdtemp(secdir);
469
470 sprintf(buf, "%s/%s", secdir, key);
471
472 a = launch_data_new_string(buf);
473 launch_data_dict_insert(tmp, a, LAUNCH_JOBSOCKETKEY_PATHNAME);
474 a = launch_data_new_string(buf);
475 launch_data_dict_insert(uenv, a, launch_data_get_string(val));
476 }
477
478 if ((val = launch_data_dict_lookup(tmp, LAUNCH_JOBSOCKETKEY_PATHNAME))) {
479 struct sockaddr_un sun;
480
481 memset(&sun, 0, sizeof(sun));
482
483 sun.sun_family = AF_UNIX;
484
485 strncpy(sun.sun_path, launch_data_get_string(val), sizeof(sun.sun_path));
486
487 if ((sfd = _fd(socket(AF_UNIX, st, 0))) == -1)
488 return;
489
490 if (passive) {
491 if (unlink(sun.sun_path) == -1 && errno != ENOENT) {
492 close(sfd);
493 return;
494 }
495 if (bind(sfd, (struct sockaddr *)&sun, sizeof(sun)) == -1) {
496 close(sfd);
497 return;
498 }
499 if ((st == SOCK_STREAM || st == SOCK_SEQPACKET)
500 && listen(sfd, SOMAXCONN) == -1) {
501 close(sfd);
502 return;
503 }
504 } else if (connect(sfd, (struct sockaddr *)&sun, sizeof(sun)) == -1) {
505 close(sfd);
506 return;
507 }
508
509 val = launch_data_new_fd(sfd);
510 launch_data_array_append(fdarray, val);
511 } else {
512 launch_data_t rnames = NULL;
513 const char *node = NULL, *serv = NULL;
514 char servnbuf[50];
515 struct addrinfo hints, *res0, *res;
516 int gerr, sock_opt = 1;
517 bool rendezvous = false;
518
519 memset(&hints, 0, sizeof(hints));
520
521 hints.ai_socktype = st;
522 if (passive)
523 hints.ai_flags |= AI_PASSIVE;
524
525 if ((val = launch_data_dict_lookup(tmp, LAUNCH_JOBSOCKETKEY_NODENAME)))
526 node = launch_data_get_string(val);
527 if ((val = launch_data_dict_lookup(tmp, LAUNCH_JOBSOCKETKEY_SERVICENAME))) {
528 if (LAUNCH_DATA_INTEGER == launch_data_get_type(val)) {
529 sprintf(servnbuf, "%lld", launch_data_get_integer(val));
530 serv = servnbuf;
531 } else {
532 serv = launch_data_get_string(val);
533 }
534 }
535 if ((val = launch_data_dict_lookup(tmp, LAUNCH_JOBSOCKETKEY_FAMILY))) {
536 if (!strcasecmp("IPv4", launch_data_get_string(val)))
537 hints.ai_family = AF_INET;
538 else if (!strcasecmp("IPv6", launch_data_get_string(val)))
539 hints.ai_family = AF_INET6;
540 }
541 if ((val = launch_data_dict_lookup(tmp, LAUNCH_JOBSOCKETKEY_PROTOCOL))) {
542 if (!strcasecmp("TCP", launch_data_get_string(val)))
543 hints.ai_protocol = IPPROTO_TCP;
544 }
545 if ((rnames = launch_data_dict_lookup(tmp, LAUNCH_JOBSOCKETKEY_BONJOUR))) {
546 rendezvous = true;
547 if (LAUNCH_DATA_BOOL == launch_data_get_type(rnames)) {
548 rendezvous = launch_data_get_bool(rnames);
549 rnames = NULL;
550 }
551 }
552
553 if ((gerr = getaddrinfo(node, serv, &hints, &res0)) != 0) {
554 fprintf(stderr, "getaddrinfo(): %s\n", gai_strerror(gerr));
555 return;
556 }
557
558 for (res = res0; res; res = res->ai_next) {
559 launch_data_t rvs_fd = NULL;
560 if ((sfd = _fd(socket(res->ai_family, res->ai_socktype, res->ai_protocol))) == -1) {
561 fprintf(stderr, "socket(): %s\n", strerror(errno));
562 return;
563 }
564 if (hints.ai_flags & AI_PASSIVE) {
565 if (AF_INET6 == res->ai_family && -1 == setsockopt(sfd, IPPROTO_IPV6, IPV6_V6ONLY,
566 (void *)&sock_opt, sizeof(sock_opt))) {
567 fprintf(stderr, "setsockopt(IPV6_V6ONLY): %m");
568 return;
569 }
570 if (setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, (void *)&sock_opt, sizeof(sock_opt)) == -1) {
571 fprintf(stderr, "socket(): %s\n", strerror(errno));
572 return;
573 }
574 if (bind(sfd, res->ai_addr, res->ai_addrlen) == -1) {
575 fprintf(stderr, "bind(): %s\n", strerror(errno));
576 return;
577 }
578 if ((res->ai_socktype == SOCK_STREAM || res->ai_socktype == SOCK_SEQPACKET)
579 && listen(sfd, SOMAXCONN) == -1) {
580 fprintf(stderr, "listen(): %s\n", strerror(errno));
581 return;
582 }
583 if (rendezvous && (res->ai_family == AF_INET || res->ai_family == AF_INET6) &&
584 (res->ai_socktype == SOCK_STREAM || res->ai_socktype == SOCK_DGRAM)) {
585 launch_data_t rvs_fds = launch_data_dict_lookup(thejob, LAUNCH_JOBKEY_BONJOURFDS);
586 if (NULL == rvs_fds) {
587 rvs_fds = launch_data_alloc(LAUNCH_DATA_ARRAY);
588 launch_data_dict_insert(thejob, rvs_fds, LAUNCH_JOBKEY_BONJOURFDS);
589 }
590 if (NULL == rnames) {
591 rvs_fd = do_rendezvous_magic(res, serv);
592 if (rvs_fd)
593 launch_data_array_append(rvs_fds, rvs_fd);
594 } else if (LAUNCH_DATA_STRING == launch_data_get_type(rnames)) {
595 rvs_fd = do_rendezvous_magic(res, launch_data_get_string(rnames));
596 if (rvs_fd)
597 launch_data_array_append(rvs_fds, rvs_fd);
598 } else if (LAUNCH_DATA_ARRAY == launch_data_get_type(rnames)) {
599 size_t rn_i, rn_ac = launch_data_array_get_count(rnames);
600
601 for (rn_i = 0; rn_i < rn_ac; rn_i++) {
602 launch_data_t rn_tmp = launch_data_array_get_index(rnames, rn_i);
603
604 rvs_fd = do_rendezvous_magic(res, launch_data_get_string(rn_tmp));
605 if (rvs_fd)
606 launch_data_array_append(rvs_fds, rvs_fd);
607 }
608 }
609 }
610 } else {
611 if (connect(sfd, res->ai_addr, res->ai_addrlen) == -1) {
612 fprintf(stderr, "connect(): %s\n", strerror(errno));
613 return;
614 }
615 }
616 val = launch_data_new_fd(sfd);
617 if (rvs_fd) {
618 /* <rdar://problem/3964648> Launchd should not register the same service more than once */
619 /* <rdar://problem/3965154> Switch to DNSServiceRegisterAddrInfo() */
620 rendezvous = false;
621 }
622 launch_data_array_append(fdarray, val);
623 }
624 }
625 }
626
627 static launch_data_t do_rendezvous_magic(const struct addrinfo *res, const char *serv)
628 {
629 struct stat sb;
630 DNSServiceRef service;
631 DNSServiceErrorType error;
632 char rvs_buf[200];
633 short port;
634 static int statres = 1;
635
636 if (1 == statres)
637 statres = stat("/usr/sbin/mDNSResponder", &sb);
638
639 if (-1 == statres)
640 return NULL;
641
642 sprintf(rvs_buf, "_%s._%s.", serv, res->ai_socktype == SOCK_STREAM ? "tcp" : "udp");
643
644 if (res->ai_family == AF_INET)
645 port = ((struct sockaddr_in *)res->ai_addr)->sin_port;
646 else
647 port = ((struct sockaddr_in6 *)res->ai_addr)->sin6_port;
648
649 error = DNSServiceRegister(&service, 0, 0, NULL, rvs_buf, NULL, NULL, port, 0, NULL, NULL, NULL);
650
651 if (error == kDNSServiceErr_NoError)
652 return launch_data_new_fd(DNSServiceRefSockFD(service));
653
654 fprintf(stderr, "DNSServiceRegister(\"%s\"): %d\n", serv, error);
655 return NULL;
656 }
657
658 static CFPropertyListRef CreateMyPropertyListFromFile(const char *posixfile)
659 {
660 CFPropertyListRef propertyList;
661 CFStringRef errorString;
662 CFDataRef resourceData;
663 SInt32 errorCode;
664 CFURLRef fileURL;
665
666 fileURL = CFURLCreateFromFileSystemRepresentation(kCFAllocatorDefault, posixfile, strlen(posixfile), false);
667 if (!fileURL)
668 fprintf(stderr, "%s: CFURLCreateFromFileSystemRepresentation(%s) failed\n", getprogname(), posixfile);
669 if (!CFURLCreateDataAndPropertiesFromResource(kCFAllocatorDefault, fileURL, &resourceData, NULL, NULL, &errorCode))
670 fprintf(stderr, "%s: CFURLCreateDataAndPropertiesFromResource(%s) failed: %d\n", getprogname(), posixfile, (int)errorCode);
671 propertyList = CFPropertyListCreateFromXMLData(kCFAllocatorDefault, resourceData, kCFPropertyListMutableContainers, &errorString);
672 if (!propertyList)
673 fprintf(stderr, "%s: propertyList is NULL\n", getprogname());
674
675 return propertyList;
676 }
677
678 static void WriteMyPropertyListToFile(CFPropertyListRef plist, const char *posixfile)
679 {
680 CFDataRef resourceData;
681 CFURLRef fileURL;
682 SInt32 errorCode;
683
684 fileURL = CFURLCreateFromFileSystemRepresentation(kCFAllocatorDefault, posixfile, strlen(posixfile), false);
685 if (!fileURL)
686 fprintf(stderr, "%s: CFURLCreateFromFileSystemRepresentation(%s) failed\n", getprogname(), posixfile);
687 resourceData = CFPropertyListCreateXMLData(kCFAllocatorDefault, plist);
688 if (resourceData == NULL)
689 fprintf(stderr, "%s: CFPropertyListCreateXMLData(%s) failed", getprogname(), posixfile);
690 if (!CFURLWriteDataAndPropertiesToResource(fileURL, resourceData, NULL, &errorCode))
691 fprintf(stderr, "%s: CFURLWriteDataAndPropertiesToResource(%s) failed: %d\n", getprogname(), posixfile, (int)errorCode);
692 }
693
694 void myCFDictionaryApplyFunction(const void *key, const void *value, void *context)
695 {
696 launch_data_t ik, iw, where = context;
697
698 ik = CF2launch_data(key);
699 iw = CF2launch_data(value);
700
701 launch_data_dict_insert(where, iw, launch_data_get_string(ik));
702 launch_data_free(ik);
703 }
704
705 static launch_data_t CF2launch_data(CFTypeRef cfr)
706 {
707 launch_data_t r;
708 CFTypeID cft = CFGetTypeID(cfr);
709
710 if (cft == CFStringGetTypeID()) {
711 char buf[4096];
712 CFStringGetCString(cfr, buf, sizeof(buf), kCFStringEncodingUTF8);
713 r = launch_data_alloc(LAUNCH_DATA_STRING);
714 launch_data_set_string(r, buf);
715 } else if (cft == CFBooleanGetTypeID()) {
716 r = launch_data_alloc(LAUNCH_DATA_BOOL);
717 launch_data_set_bool(r, CFBooleanGetValue(cfr));
718 } else if (cft == CFArrayGetTypeID()) {
719 CFIndex i, ac = CFArrayGetCount(cfr);
720 r = launch_data_alloc(LAUNCH_DATA_ARRAY);
721 for (i = 0; i < ac; i++) {
722 CFTypeRef v = CFArrayGetValueAtIndex(cfr, i);
723 if (v) {
724 launch_data_t iv = CF2launch_data(v);
725 launch_data_array_set_index(r, iv, i);
726 }
727 }
728 } else if (cft == CFDictionaryGetTypeID()) {
729 r = launch_data_alloc(LAUNCH_DATA_DICTIONARY);
730 CFDictionaryApplyFunction(cfr, myCFDictionaryApplyFunction, r);
731 } else if (cft == CFDataGetTypeID()) {
732 r = launch_data_alloc(LAUNCH_DATA_ARRAY);
733 launch_data_set_opaque(r, CFDataGetBytePtr(cfr), CFDataGetLength(cfr));
734 } else if (cft == CFNumberGetTypeID()) {
735 long long n;
736 double d;
737 CFNumberType cfnt = CFNumberGetType(cfr);
738 switch (cfnt) {
739 case kCFNumberSInt8Type:
740 case kCFNumberSInt16Type:
741 case kCFNumberSInt32Type:
742 case kCFNumberSInt64Type:
743 case kCFNumberCharType:
744 case kCFNumberShortType:
745 case kCFNumberIntType:
746 case kCFNumberLongType:
747 case kCFNumberLongLongType:
748 CFNumberGetValue(cfr, kCFNumberLongLongType, &n);
749 r = launch_data_alloc(LAUNCH_DATA_INTEGER);
750 launch_data_set_integer(r, n);
751 break;
752 case kCFNumberFloat32Type:
753 case kCFNumberFloat64Type:
754 case kCFNumberFloatType:
755 case kCFNumberDoubleType:
756 CFNumberGetValue(cfr, kCFNumberDoubleType, &d);
757 r = launch_data_alloc(LAUNCH_DATA_REAL);
758 launch_data_set_real(r, d);
759 break;
760 default:
761 r = NULL;
762 break;
763 }
764 } else {
765 r = NULL;
766 }
767 return r;
768 }
769
770 static int help_cmd(int argc, char *const argv[])
771 {
772 FILE *where = stdout;
773 int l, cmdwidth = 0;
774 size_t i;
775
776 if (argc == 0 || argv == NULL)
777 where = stderr;
778
779 fprintf(where, "usage: %s <subcommand>\n", getprogname());
780 for (i = 0; i < (sizeof cmds / sizeof cmds[0]); i++) {
781 l = strlen(cmds[i].name);
782 if (l > cmdwidth)
783 cmdwidth = l;
784 }
785 for (i = 0; i < (sizeof cmds / sizeof cmds[0]); i++)
786 fprintf(where, "\t%-*s\t%s\n", cmdwidth, cmds[i].name, cmds[i].desc);
787
788 return 0;
789 }
790
791 static int _fd(int fd)
792 {
793 if (fd >= 0)
794 fcntl(fd, F_SETFD, 1);
795 return fd;
796 }
797
798 static int load_and_unload_cmd(int argc, char *const argv[])
799 {
800 launch_data_t pass1, pass2;
801 int i, ch;
802 bool wflag = false;
803 bool lflag = false;
804
805 if (!strcmp(argv[0], "load"))
806 lflag = true;
807
808 while ((ch = getopt(argc, argv, "w")) != -1) {
809 switch (ch) {
810 case 'w':
811 wflag = true;
812 break;
813 default:
814 fprintf(stderr, "usage: %s load [-w] paths...\n", getprogname());
815 return 1;
816 }
817 }
818 argc -= optind;
819 argv += optind;
820
821 if (argc == 0) {
822 fprintf(stderr, "usage: %s load [-w] paths...\n", getprogname());
823 return 1;
824 }
825
826 /* I wish I didn't need to do two passes, but I need to load mDNSResponder and use it too.
827 *
828 * In later versions of launchd, I hope to load everything in the first pass,
829 * then do the Bonjour magic on the jobs that need it, and reload them, but for now,
830 * I haven't thought through the various complexities of reloading jobs, and therefore
831 * launchd doesn't have reload support right now.
832 */
833
834 pass1 = launch_data_alloc(LAUNCH_DATA_ARRAY);
835 pass2 = launch_data_alloc(LAUNCH_DATA_ARRAY);
836
837 for (i = 0; i < argc; i++)
838 readpath(argv[i], pass1, pass2, wflag, lflag);
839
840 if (0 == launch_data_array_get_count(pass1) && 0 == launch_data_array_get_count(pass2)) {
841 fprintf(stderr, "nothing found to %s\n", lflag ? "load" : "unload");
842 launch_data_free(pass1);
843 launch_data_free(pass2);
844 return 1;
845 }
846
847 if (lflag) {
848 if (0 < launch_data_array_get_count(pass1)) {
849 submit_job_pass(pass1);
850 }
851 if (0 < launch_data_array_get_count(pass2)) {
852 submit_job_pass(pass2);
853 }
854 } else {
855 for (i = 0; i < (int)launch_data_array_get_count(pass1); i++)
856 unloadjob(launch_data_array_get_index(pass1, i));
857 for (i = 0; i < (int)launch_data_array_get_count(pass2); i++)
858 unloadjob(launch_data_array_get_index(pass2, i));
859 }
860
861 return 0;
862 }
863
864 static void submit_job_pass(launch_data_t jobs)
865 {
866 launch_data_t msg, resp;
867 size_t i;
868 int e;
869
870 for (i = 0; i < launch_data_array_get_count(jobs); i++)
871 distill_config_file(launch_data_array_get_index(jobs, i));
872
873 msg = launch_data_alloc(LAUNCH_DATA_DICTIONARY);
874
875 launch_data_dict_insert(msg, jobs, LAUNCH_KEY_SUBMITJOB);
876
877 resp = launch_msg(msg);
878
879 if (resp) {
880 switch (launch_data_get_type(resp)) {
881 case LAUNCH_DATA_ERRNO:
882 if ((e = launch_data_get_errno(resp)))
883 fprintf(stderr, "%s\n", strerror(e));
884 break;
885 case LAUNCH_DATA_ARRAY:
886 for (i = 0; i < launch_data_array_get_count(jobs); i++) {
887 launch_data_t obatind = launch_data_array_get_index(resp, i);
888 launch_data_t jatind = launch_data_array_get_index(jobs, i);
889 const char *lab4job = launch_data_get_string(launch_data_dict_lookup(jatind, LAUNCH_JOBKEY_LABEL));
890 if (LAUNCH_DATA_ERRNO == launch_data_get_type(obatind)) {
891 e = launch_data_get_errno(obatind);
892 switch (e) {
893 case EEXIST:
894 fprintf(stderr, "%s: %s\n", lab4job, "Already loaded");
895 break;
896 case ESRCH:
897 fprintf(stderr, "%s: %s\n", lab4job, "Not loaded");
898 break;
899 default:
900 fprintf(stderr, "%s: %s\n", lab4job, strerror(e));
901 case 0:
902 break;
903 }
904 }
905 }
906 break;
907 default:
908 fprintf(stderr, "unknown respose from launchd!\n");
909 break;
910 }
911 launch_data_free(resp);
912 } else {
913 fprintf(stderr, "launch_msg(): %s\n", strerror(errno));
914 }
915
916 launch_data_free(msg);
917 }
918
919 static int start_and_stop_cmd(int argc, char *const argv[])
920 {
921 launch_data_t resp, msg;
922 const char *lmsgcmd = LAUNCH_KEY_STOPJOB;
923 int e, r = 0;
924
925 if (!strcmp(argv[0], "start"))
926 lmsgcmd = LAUNCH_KEY_STARTJOB;
927
928 if (argc != 2) {
929 fprintf(stderr, "usage: %s %s <job label>\n", getprogname(), argv[0]);
930 return 1;
931 }
932
933 msg = launch_data_alloc(LAUNCH_DATA_DICTIONARY);
934 launch_data_dict_insert(msg, launch_data_new_string(argv[1]), lmsgcmd);
935
936 resp = launch_msg(msg);
937 launch_data_free(msg);
938
939 if (resp == NULL) {
940 fprintf(stderr, "launch_msg(): %s\n", strerror(errno));
941 return 1;
942 } else if (launch_data_get_type(resp) == LAUNCH_DATA_ERRNO) {
943 if ((e = launch_data_get_errno(resp))) {
944 fprintf(stderr, "%s %s error: %s\n", getprogname(), argv[0], strerror(e));
945 r = 1;
946 }
947 } else {
948 fprintf(stderr, "%s %s returned unknown response\n", getprogname(), argv[0]);
949 r = 1;
950 }
951
952 launch_data_free(resp);
953 return r;
954 }
955
956 static void print_jobs(launch_data_t j __attribute__((unused)), const char *label, void *context __attribute__((unused)))
957 {
958 fprintf(stdout, "%s\n", label);
959 }
960
961 static int list_cmd(int argc, char *const argv[])
962 {
963 launch_data_t resp, msg;
964 int ch, r = 0;
965 bool vflag = false;
966
967 while ((ch = getopt(argc, argv, "v")) != -1) {
968 switch (ch) {
969 case 'v':
970 vflag = true;
971 break;
972 default:
973 fprintf(stderr, "usage: %s list [-v]\n", getprogname());
974 return 1;
975 }
976 }
977
978 if (vflag) {
979 fprintf(stderr, "usage: %s list: \"-v\" flag not implemented yet\n", getprogname());
980 return 1;
981 }
982
983 msg = launch_data_new_string(LAUNCH_KEY_GETJOBS);
984 resp = launch_msg(msg);
985 launch_data_free(msg);
986
987 if (resp == NULL) {
988 fprintf(stderr, "launch_msg(): %s\n", strerror(errno));
989 return 1;
990 } else if (launch_data_get_type(resp) == LAUNCH_DATA_DICTIONARY) {
991 launch_data_dict_iterate(resp, print_jobs, NULL);
992 } else {
993 fprintf(stderr, "%s %s returned unknown response\n", getprogname(), argv[0]);
994 r = 1;
995 }
996
997 launch_data_free(resp);
998
999 return r;
1000 }
1001
1002 static int stdio_cmd(int argc, char *const argv[])
1003 {
1004 launch_data_t resp, msg, tmp;
1005 int e, fd = -1, r = 0;
1006
1007 if (argc != 2) {
1008 fprintf(stderr, "usage: %s %s <path>\n", getprogname(), argv[0]);
1009 return 1;
1010 }
1011
1012 fd = open(argv[1], O_CREAT|O_APPEND|O_WRONLY, DEFFILEMODE);
1013
1014 msg = launch_data_alloc(LAUNCH_DATA_DICTIONARY);
1015
1016 if (fd == -1) {
1017 tmp = launch_data_new_string(argv[1]);
1018 } else {
1019 tmp = launch_data_new_fd(fd);
1020 }
1021
1022 if (!strcmp(argv[0], "stdout")) {
1023 launch_data_dict_insert(msg, tmp, LAUNCH_KEY_SETSTDOUT);
1024 } else {
1025 launch_data_dict_insert(msg, tmp, LAUNCH_KEY_SETSTDERR);
1026 }
1027
1028 resp = launch_msg(msg);
1029 launch_data_free(msg);
1030
1031 if (resp == NULL) {
1032 fprintf(stderr, "launch_msg(): %s\n", strerror(errno));
1033 return 1;
1034 } else if (launch_data_get_type(resp) == LAUNCH_DATA_ERRNO) {
1035 if ((e = launch_data_get_errno(resp))) {
1036 fprintf(stderr, "%s %s error: %s\n", getprogname(), argv[0], strerror(e));
1037 r = 1;
1038 }
1039 } else {
1040 fprintf(stderr, "%s %s returned unknown response\n", getprogname(), argv[0]);
1041 r = 1;
1042 }
1043
1044 if (fd != -1)
1045 close(fd);
1046
1047 launch_data_free(resp);
1048
1049 return r;
1050 }
1051
1052 static int fyi_cmd(int argc, char *const argv[])
1053 {
1054 launch_data_t resp, msg;
1055 const char *lmsgk = LAUNCH_KEY_RELOADTTYS;
1056 int e, r = 0;
1057
1058 if (argc != 1) {
1059 fprintf(stderr, "usage: %s %s\n", getprogname(), argv[0]);
1060 return 1;
1061 }
1062
1063 if (!strcmp(argv[0], "shutdown"))
1064 lmsgk = LAUNCH_KEY_SHUTDOWN;
1065
1066 msg = launch_data_new_string(lmsgk);
1067 resp = launch_msg(msg);
1068 launch_data_free(msg);
1069
1070 if (resp == NULL) {
1071 fprintf(stderr, "launch_msg(): %s\n", strerror(errno));
1072 return 1;
1073 } else if (launch_data_get_type(resp) == LAUNCH_DATA_ERRNO) {
1074 if ((e = launch_data_get_errno(resp))) {
1075 fprintf(stderr, "%s %s error: %s\n", getprogname(), argv[0], strerror(e));
1076 r = 1;
1077 }
1078 } else {
1079 fprintf(stderr, "%s %s returned unknown response\n", getprogname(), argv[0]);
1080 r = 1;
1081 }
1082
1083 launch_data_free(resp);
1084
1085 return r;
1086 }
1087
1088 static int logupdate_cmd(int argc, char *const argv[])
1089 {
1090 launch_data_t resp, msg;
1091 int e, i, j, r = 0, m = 0;
1092 bool badargs = false, maskmode = false, onlymode = false, levelmode = false;
1093 const char *whichcmd = LAUNCH_KEY_SETLOGMASK;
1094 static const struct {
1095 const char *name;
1096 int level;
1097 } logtbl[] = {
1098 { "debug", LOG_DEBUG },
1099 { "info", LOG_INFO },
1100 { "notice", LOG_NOTICE },
1101 { "warning", LOG_WARNING },
1102 { "error", LOG_ERR },
1103 { "critical", LOG_CRIT },
1104 { "alert", LOG_ALERT },
1105 { "emergency", LOG_EMERG },
1106 };
1107 int logtblsz = sizeof logtbl / sizeof logtbl[0];
1108
1109 if (argc >= 2) {
1110 if (!strcmp(argv[1], "mask"))
1111 maskmode = true;
1112 else if (!strcmp(argv[1], "only"))
1113 onlymode = true;
1114 else if (!strcmp(argv[1], "level"))
1115 levelmode = true;
1116 else
1117 badargs = true;
1118 }
1119
1120 if (maskmode)
1121 m = LOG_UPTO(LOG_DEBUG);
1122
1123 if (argc > 2 && (maskmode || onlymode)) {
1124 for (i = 2; i < argc; i++) {
1125 for (j = 0; j < logtblsz; j++) {
1126 if (!strcmp(argv[i], logtbl[j].name)) {
1127 if (maskmode)
1128 m &= ~(LOG_MASK(logtbl[j].level));
1129 else
1130 m |= LOG_MASK(logtbl[j].level);
1131 break;
1132 }
1133 }
1134 if (j == logtblsz) {
1135 badargs = true;
1136 break;
1137 }
1138 }
1139 } else if (argc > 2 && levelmode) {
1140 for (j = 0; j < logtblsz; j++) {
1141 if (!strcmp(argv[2], logtbl[j].name)) {
1142 m = LOG_UPTO(logtbl[j].level);
1143 break;
1144 }
1145 }
1146 if (j == logtblsz)
1147 badargs = true;
1148 } else if (argc == 1) {
1149 whichcmd = LAUNCH_KEY_GETLOGMASK;
1150 } else {
1151 badargs = true;
1152 }
1153
1154 if (badargs) {
1155 fprintf(stderr, "usage: %s [[mask loglevels...] | [only loglevels...] [level loglevel]]\n", getprogname());
1156 return 1;
1157 }
1158
1159 if (whichcmd == LAUNCH_KEY_SETLOGMASK) {
1160 msg = launch_data_alloc(LAUNCH_DATA_DICTIONARY);
1161 launch_data_dict_insert(msg, launch_data_new_integer(m), whichcmd);
1162 } else {
1163 msg = launch_data_new_string(whichcmd);
1164 }
1165
1166 resp = launch_msg(msg);
1167 launch_data_free(msg);
1168
1169 if (resp == NULL) {
1170 fprintf(stderr, "launch_msg(): %s\n", strerror(errno));
1171 return 1;
1172 } else if (launch_data_get_type(resp) == LAUNCH_DATA_ERRNO) {
1173 if ((e = launch_data_get_errno(resp))) {
1174 fprintf(stderr, "%s %s error: %s\n", getprogname(), argv[0], strerror(e));
1175 r = 1;
1176 }
1177 } else if (launch_data_get_type(resp) == LAUNCH_DATA_INTEGER) {
1178 if (whichcmd == LAUNCH_KEY_GETLOGMASK) {
1179 m = launch_data_get_integer(resp);
1180 for (j = 0; j < logtblsz; j++) {
1181 if (m & LOG_MASK(logtbl[j].level))
1182 fprintf(stdout, "%s ", logtbl[j].name);
1183 }
1184 fprintf(stdout, "\n");
1185 }
1186 } else {
1187 fprintf(stderr, "%s %s returned unknown response\n", getprogname(), argv[0]);
1188 r = 1;
1189 }
1190
1191 launch_data_free(resp);
1192
1193 return r;
1194 }
1195
1196 static int limit_cmd(int argc __attribute__((unused)), char *const argv[])
1197 {
1198 char slimstr[100];
1199 char hlimstr[100];
1200 struct rlimit *lmts = NULL;
1201 launch_data_t resp, resp1 = NULL, msg, tmp;
1202 int r = 0;
1203 size_t i, lsz = -1, which = 0;
1204 rlim_t slim = -1, hlim = -1;
1205 bool badargs = false;
1206 static const struct {
1207 const char *name;
1208 int lim;
1209 } limlookup[] = {
1210 { "cpu", RLIMIT_CPU },
1211 { "filesize", RLIMIT_FSIZE },
1212 { "data", RLIMIT_DATA },
1213 { "stack", RLIMIT_STACK },
1214 { "core", RLIMIT_CORE },
1215 { "rss", RLIMIT_RSS },
1216 { "memlock", RLIMIT_MEMLOCK },
1217 { "maxproc", RLIMIT_NPROC },
1218 { "maxfiles", RLIMIT_NOFILE }
1219 };
1220 size_t limlookupcnt = sizeof limlookup / sizeof limlookup[0];
1221 bool name2num(const char *n) {
1222 for (i = 0; i < limlookupcnt; i++) {
1223 if (!strcmp(limlookup[i].name, n)) {
1224 which = limlookup[i].lim;
1225 return false;
1226 }
1227 }
1228 return true;
1229 };
1230 const char *num2name(int n) {
1231 for (i = 0; i < limlookupcnt; i++) {
1232 if (limlookup[i].lim == n)
1233 return limlookup[i].name;
1234 }
1235 return NULL;
1236 };
1237 const char *lim2str(rlim_t val, char *buf) {
1238 if (val == RLIM_INFINITY)
1239 strcpy(buf, "unlimited");
1240 else
1241 sprintf(buf, "%lld", val);
1242 return buf;
1243 };
1244 bool str2lim(const char *buf, rlim_t *res) {
1245 char *endptr;
1246 *res = strtoll(buf, &endptr, 10);
1247 if (!strcmp(buf, "unlimited")) {
1248 *res = RLIM_INFINITY;
1249 return false;
1250 } else if (*endptr == '\0') {
1251 return false;
1252 }
1253 return true;
1254 };
1255
1256 if (argc > 4)
1257 badargs = true;
1258
1259 if (argc >= 3 && str2lim(argv[2], &slim))
1260 badargs = true;
1261 else
1262 hlim = slim;
1263
1264 if (argc == 4 && str2lim(argv[3], &hlim))
1265 badargs = true;
1266
1267 if (argc >= 2 && name2num(argv[1]))
1268 badargs = true;
1269
1270 if (badargs) {
1271 fprintf(stderr, "usage: %s %s [", getprogname(), argv[0]);
1272 for (i = 0; i < limlookupcnt; i++)
1273 fprintf(stderr, "%s %s", limlookup[i].name, (i + 1) == limlookupcnt ? "" : "| ");
1274 fprintf(stderr, "[both | soft hard]]\n");
1275 return 1;
1276 }
1277
1278 msg = launch_data_new_string(LAUNCH_KEY_GETRESOURCELIMITS);
1279 resp = launch_msg(msg);
1280 launch_data_free(msg);
1281
1282 if (resp == NULL) {
1283 fprintf(stderr, "launch_msg(): %s\n", strerror(errno));
1284 return 1;
1285 } else if (launch_data_get_type(resp) == LAUNCH_DATA_OPAQUE) {
1286 lmts = launch_data_get_opaque(resp);
1287 lsz = launch_data_get_opaque_size(resp);
1288 if (argc <= 2) {
1289 for (i = 0; i < (lsz / sizeof(struct rlimit)); i++) {
1290 if (argc == 2 && which != i)
1291 continue;
1292 fprintf(stdout, "\t%-12s%-15s%-15s\n", num2name(i),
1293 lim2str(lmts[i].rlim_cur, slimstr),
1294 lim2str(lmts[i].rlim_max, hlimstr));
1295 }
1296 }
1297 } else if (launch_data_get_type(resp) == LAUNCH_DATA_STRING) {
1298 fprintf(stderr, "%s %s error: %s\n", getprogname(), argv[0], launch_data_get_string(resp));
1299 r = 1;
1300 } else {
1301 fprintf(stderr, "%s %s returned unknown response\n", getprogname(), argv[0]);
1302 r = 1;
1303 }
1304
1305 if (argc <= 2 || r != 0) {
1306 launch_data_free(resp);
1307 return r;
1308 } else {
1309 resp1 = resp;
1310 }
1311
1312 lmts[which].rlim_cur = slim;
1313 lmts[which].rlim_max = hlim;
1314
1315 msg = launch_data_alloc(LAUNCH_DATA_DICTIONARY);
1316 tmp = launch_data_new_opaque(lmts, lsz);
1317 launch_data_dict_insert(msg, tmp, LAUNCH_KEY_SETRESOURCELIMITS);
1318 resp = launch_msg(msg);
1319 launch_data_free(msg);
1320
1321 if (resp == NULL) {
1322 fprintf(stderr, "launch_msg(): %s\n", strerror(errno));
1323 return 1;
1324 } else if (launch_data_get_type(resp) == LAUNCH_DATA_STRING) {
1325 fprintf(stderr, "%s %s error: %s\n", getprogname(), argv[0], launch_data_get_string(resp));
1326 r = 1;
1327 } else if (launch_data_get_type(resp) != LAUNCH_DATA_OPAQUE) {
1328 fprintf(stderr, "%s %s returned unknown response\n", getprogname(), argv[0]);
1329 r = 1;
1330 }
1331
1332 launch_data_free(resp);
1333 launch_data_free(resp1);
1334
1335 return r;
1336 }
1337
1338 static int umask_cmd(int argc, char *const argv[])
1339 {
1340 launch_data_t resp, msg;
1341 bool badargs = false;
1342 char *endptr;
1343 long m = 0;
1344 int r = 0;
1345
1346 if (argc == 2) {
1347 m = strtol(argv[1], &endptr, 8);
1348 if (*endptr != '\0' || m > 0777)
1349 badargs = true;
1350 }
1351
1352 if (argc > 2 || badargs) {
1353 fprintf(stderr, "usage: %s %s <mask>\n", getprogname(), argv[0]);
1354 return 1;
1355 }
1356
1357
1358 if (argc == 1) {
1359 msg = launch_data_new_string(LAUNCH_KEY_GETUMASK);
1360 } else {
1361 msg = launch_data_alloc(LAUNCH_DATA_DICTIONARY);
1362 launch_data_dict_insert(msg, launch_data_new_integer(m), LAUNCH_KEY_SETUMASK);
1363 }
1364 resp = launch_msg(msg);
1365 launch_data_free(msg);
1366
1367 if (resp == NULL) {
1368 fprintf(stderr, "launch_msg(): %s\n", strerror(errno));
1369 return 1;
1370 } else if (launch_data_get_type(resp) == LAUNCH_DATA_STRING) {
1371 fprintf(stderr, "%s %s error: %s\n", getprogname(), argv[0], launch_data_get_string(resp));
1372 r = 1;
1373 } else if (launch_data_get_type(resp) != LAUNCH_DATA_INTEGER) {
1374 fprintf(stderr, "%s %s returned unknown response\n", getprogname(), argv[0]);
1375 r = 1;
1376 } else if (argc == 1) {
1377 fprintf(stdout, "%o\n", (unsigned int)launch_data_get_integer(resp));
1378 }
1379
1380 launch_data_free(resp);
1381
1382 return r;
1383 }
1384
1385 static int getrusage_cmd(int argc, char *const argv[])
1386 {
1387 launch_data_t resp, msg;
1388 bool badargs = false;
1389 int r = 0;
1390
1391 if (argc != 2)
1392 badargs = true;
1393 else if (strcmp(argv[1], "self") && strcmp(argv[1], "children"))
1394 badargs = true;
1395
1396 if (badargs) {
1397 fprintf(stderr, "usage: %s %s self | children\n", getprogname(), argv[0]);
1398 return 1;
1399 }
1400
1401 if (!strcmp(argv[1], "self")) {
1402 msg = launch_data_new_string(LAUNCH_KEY_GETRUSAGESELF);
1403 } else {
1404 msg = launch_data_new_string(LAUNCH_KEY_GETRUSAGECHILDREN);
1405 }
1406
1407 resp = launch_msg(msg);
1408 launch_data_free(msg);
1409
1410 if (resp == NULL) {
1411 fprintf(stderr, "launch_msg(): %s\n", strerror(errno));
1412 return 1;
1413 } else if (launch_data_get_type(resp) == LAUNCH_DATA_ERRNO) {
1414 fprintf(stderr, "%s %s error: %s\n", getprogname(), argv[0], strerror(launch_data_get_errno(resp)));
1415 r = 1;
1416 } else if (launch_data_get_type(resp) == LAUNCH_DATA_OPAQUE) {
1417 struct rusage *rusage = launch_data_get_opaque(resp);
1418 fprintf(stdout, "\t%-10f\tuser time used\n",
1419 (double)rusage->ru_utime.tv_sec + (double)rusage->ru_utime.tv_usec / (double)1000000);
1420 fprintf(stdout, "\t%-10f\tsystem time used\n",
1421 (double)rusage->ru_stime.tv_sec + (double)rusage->ru_stime.tv_usec / (double)1000000);
1422 fprintf(stdout, "\t%-10ld\tmax resident set size\n", rusage->ru_maxrss);
1423 fprintf(stdout, "\t%-10ld\tshared text memory size\n", rusage->ru_ixrss);
1424 fprintf(stdout, "\t%-10ld\tunshared data size\n", rusage->ru_idrss);
1425 fprintf(stdout, "\t%-10ld\tunshared stack size\n", rusage->ru_isrss);
1426 fprintf(stdout, "\t%-10ld\tpage reclaims\n", rusage->ru_minflt);
1427 fprintf(stdout, "\t%-10ld\tpage faults\n", rusage->ru_majflt);
1428 fprintf(stdout, "\t%-10ld\tswaps\n", rusage->ru_nswap);
1429 fprintf(stdout, "\t%-10ld\tblock input operations\n", rusage->ru_inblock);
1430 fprintf(stdout, "\t%-10ld\tblock output operations\n", rusage->ru_oublock);
1431 fprintf(stdout, "\t%-10ld\tmessages sent\n", rusage->ru_msgsnd);
1432 fprintf(stdout, "\t%-10ld\tmessages received\n", rusage->ru_msgrcv);
1433 fprintf(stdout, "\t%-10ld\tsignals received\n", rusage->ru_nsignals);
1434 fprintf(stdout, "\t%-10ld\tvoluntary context switches\n", rusage->ru_nvcsw);
1435 fprintf(stdout, "\t%-10ld\tinvoluntary context switches\n", rusage->ru_nivcsw);
1436 } else {
1437 fprintf(stderr, "%s %s returned unknown response\n", getprogname(), argv[0]);
1438 r = 1;
1439 }
1440
1441 launch_data_free(resp);
1442
1443 return r;
1444 }
1445
1446 static bool launch_data_array_append(launch_data_t a, launch_data_t o)
1447 {
1448 size_t offt = launch_data_array_get_count(a);
1449
1450 return launch_data_array_set_index(a, o, offt);
1451 }
mirror of launchd