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


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