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


2c37ee9613eee627b951605bff7fc0549c1be47f
[apple/launchd.git] / launchd / src / launchd_core_logic.c
1 /*
2 * Copyright (c) 2005 Apple Computer, Inc. All rights reserved.
3 *
4 * @APPLE_APACHE_LICENSE_HEADER_START@
5 *
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 *
18 * @APPLE_APACHE_LICENSE_HEADER_END@
19 */
20
21 static const char *const __rcs_file_version__ = "$Revision: 1.77 $";
22
23 #include <mach/mach.h>
24 #include <mach/mach_error.h>
25 #include <mach/boolean.h>
26 #include <mach/message.h>
27 #include <mach/notify.h>
28 #include <mach/mig_errors.h>
29 #include <mach/mach_traps.h>
30 #include <mach/mach_interface.h>
31 #include <mach/host_info.h>
32 #include <mach/mach_host.h>
33 #include <mach/exception.h>
34 #include <sys/types.h>
35 #include <sys/queue.h>
36 #include <sys/event.h>
37 #include <sys/ptrace.h>
38 #include <sys/stat.h>
39 #include <sys/ucred.h>
40 #include <sys/fcntl.h>
41 #include <sys/un.h>
42 #include <sys/wait.h>
43 #include <sys/sysctl.h>
44 #include <sys/sockio.h>
45 #include <sys/time.h>
46 #include <sys/resource.h>
47 #include <sys/ioctl.h>
48 #include <sys/mount.h>
49 #include <net/if.h>
50 #include <netinet/in.h>
51 #include <netinet/in_var.h>
52 #include <netinet6/nd6.h>
53 #include <unistd.h>
54 #include <signal.h>
55 #include <errno.h>
56 #include <syslog.h>
57 #include <libgen.h>
58 #include <stdio.h>
59 #include <stdlib.h>
60 #include <stdarg.h>
61 #include <stdbool.h>
62 #include <paths.h>
63 #include <pwd.h>
64 #include <grp.h>
65 #include <ttyent.h>
66 #include <dlfcn.h>
67 #include <dirent.h>
68 #include <string.h>
69 #include <ctype.h>
70 #include <glob.h>
71
72 #include "launch.h"
73 #include "launch_priv.h"
74 #include "launchd.h"
75 #include "launchd_core_logic.h"
76 #include "launchd_unix_ipc.h"
77 #include "bootstrap_private.h"
78 #include "bootstrap.h"
79 #include "bootstrapServer.h"
80 #include "mpm_reply.h"
81
82 /* <rdar://problem/2685209> sys/queue.h is not up to date */
83 #ifndef SLIST_FOREACH_SAFE
84 #define SLIST_FOREACH_SAFE(var, head, field, tvar) \
85 for ((var) = SLIST_FIRST((head)); \
86 (var) && ((tvar) = SLIST_NEXT((var), field), 1); \
87 (var) = (tvar))
88 #endif
89
90 struct machservice {
91 SLIST_ENTRY(machservice) sle;
92 struct jobcb *job;
93 mach_port_name_t port;
94 unsigned int isActive:1, reset:1, recv:1, hide:1, kUNCServer:1, __junk:27;
95 char name[0];
96 };
97
98 static void machservice_setup(launch_data_t obj, const char *key, void *context);
99 static void machservice_setup_options(launch_data_t obj, const char *key, void *context);
100 static void machservice_resetport(struct jobcb *j, struct machservice *ms);
101
102
103 struct socketgroup {
104 SLIST_ENTRY(socketgroup) sle;
105 int *fds;
106 unsigned int junkfds:1, fd_cnt:31;
107 char name[0];
108 };
109
110 static bool socketgroup_new(struct jobcb *j, const char *name, int *fds, unsigned int fd_cnt, bool junkfds);
111 static void socketgroup_delete(struct jobcb *j, struct socketgroup *sg);
112 static void socketgroup_watch(struct jobcb *j, struct socketgroup *sg);
113 static void socketgroup_ignore(struct jobcb *j, struct socketgroup *sg);
114 static void socketgroup_callback(struct jobcb *j, struct kevent *kev);
115 static void socketgroup_setup(launch_data_t obj, const char *key, void *context);
116
117 struct watchpath {
118 SLIST_ENTRY(watchpath) sle;
119 int fd;
120 unsigned int is_qdir:1, __junk:31;
121 char name[0];
122 };
123
124 static bool watchpath_new(struct jobcb *j, const char *name, bool qdir);
125 static void watchpath_delete(struct jobcb *j, struct watchpath *wp);
126 static void watchpath_watch(struct jobcb *j, struct watchpath *wp);
127 static void watchpath_ignore(struct jobcb *j, struct watchpath *wp);
128 static void watchpath_callback(struct jobcb *j, struct kevent *kev);
129
130 struct calendarinterval {
131 SLIST_ENTRY(calendarinterval) sle;
132 struct tm when;
133 };
134
135 static bool calendarinterval_new(struct jobcb *j, struct tm *w);
136 static bool calendarinterval_new_from_obj(struct jobcb *j, launch_data_t obj);
137 static void calendarinterval_delete(struct jobcb *j, struct calendarinterval *ci);
138 static void calendarinterval_setalarm(struct jobcb *j, struct calendarinterval *ci);
139 static void calendarinterval_callback(struct jobcb *j, struct kevent *kev);
140
141 struct envitem {
142 SLIST_ENTRY(envitem) sle;
143 char *value;
144 char key[0];
145 };
146
147 static bool envitem_new(struct jobcb *j, const char *k, const char *v, bool global);
148 static void envitem_delete(struct jobcb *j, struct envitem *ei, bool global);
149 static void envitem_setup(launch_data_t obj, const char *key, void *context);
150
151 struct limititem {
152 SLIST_ENTRY(limititem) sle;
153 struct rlimit lim;
154 unsigned int setsoft:1, sethard:1, which:30;
155 };
156
157 static bool limititem_update(struct jobcb *j, int w, rlim_t r);
158 static void limititem_delete(struct jobcb *j, struct limititem *li);
159 static void limititem_setup(launch_data_t obj, const char *key, void *context);
160
161 typedef enum {
162 NETWORK_UP = 1,
163 NETWORK_DOWN,
164 SUCCESSFUL_EXIT,
165 FAILED_EXIT,
166 PATH_EXISTS,
167 PATH_MISSING,
168 // FILESYSTEMTYPE_IS_MOUNTED, /* for nfsiod, but maybe others */
169 } semaphore_reason_t;
170
171 struct semaphoreitem {
172 SLIST_ENTRY(semaphoreitem) sle;
173 semaphore_reason_t why;
174 char what[0];
175 };
176
177 static bool semaphoreitem_new(struct jobcb *j, semaphore_reason_t why, const char *what);
178 static void semaphoreitem_delete(struct jobcb *j, struct semaphoreitem *si);
179 static void semaphoreitem_setup(launch_data_t obj, const char *key, void *context);
180 static void semaphoreitem_setup_paths(launch_data_t obj, const char *key, void *context);
181
182
183 struct jobcb {
184 kq_callback kqjob_callback;
185 SLIST_ENTRY(jobcb) sle;
186 SLIST_HEAD(, socketgroup) sockets;
187 SLIST_HEAD(, watchpath) vnodes;
188 SLIST_HEAD(, calendarinterval) cal_intervals;
189 SLIST_HEAD(, envitem) global_env;
190 SLIST_HEAD(, envitem) env;
191 SLIST_HEAD(, limititem) limits;
192 SLIST_HEAD(, machservice) machservices;
193 SLIST_HEAD(, semaphoreitem) semaphores;
194 SLIST_HEAD(, jobcb) jobs;
195 struct rusage ru;
196 struct jobcb *parent;
197 mach_port_t bs_port;
198 mach_port_t req_port;
199 mach_port_t wait_reply_port;
200 uid_t mach_uid;
201 char **argv;
202 char *prog;
203 char *rootdir;
204 char *workingdir;
205 char *username;
206 char *groupname;
207 char *stdinpath;
208 char *stdoutpath;
209 char *stderrpath;
210 pid_t p;
211 int argc;
212 int last_exit_status;
213 int execfd;
214 int nice;
215 int timeout;
216 time_t start_time;
217 size_t failed_exits;
218 unsigned int start_interval;
219 unsigned int checkedin:1, firstborn:1, debug:1, throttle:1, inetcompat:1, inetcompat_wait:1,
220 ondemand:1, session_create:1, low_pri_io:1, init_groups:1, priv_port_has_senders:1,
221 importing_global_env:1, importing_hard_limits:1, setmask:1, legacy_mach_job:1, runatload:1;
222 mode_t mask;
223 unsigned int globargv:1, wait4debugger:1, transfer_bstrap:1, unload_at_exit:1, force_ppc:1, stall_before_exec:1, __pad:26;
224 char label[0];
225 };
226
227 static struct jobcb *job_import2(launch_data_t pload);
228 static void job_import_keys(launch_data_t obj, const char *key, void *context);
229 static void job_import_bool(struct jobcb *j, const char *key, bool value);
230 static void job_import_string(struct jobcb *j, const char *key, const char *value);
231 static void job_import_integer(struct jobcb *j, const char *key, long long value);
232 static void job_import_dictionary(struct jobcb *j, const char *key, launch_data_t value);
233 static void job_import_array(struct jobcb *j, const char *key, launch_data_t value);
234 static void job_watch(struct jobcb *j);
235 static void job_ignore(struct jobcb *j);
236 static void job_reap(struct jobcb *j);
237 static bool job_useless(struct jobcb *j);
238 static bool job_keepalive(struct jobcb *j);
239 static void job_start_child(struct jobcb *j, int execfd) __attribute__((noreturn));
240 static void job_setup_attributes(struct jobcb *j);
241 static bool job_setup_machport(struct jobcb *j);
242 static void job_callback(void *obj, struct kevent *kev);
243 static pid_t job_fork(struct jobcb *j);
244 static size_t job_prep_log_preface(struct jobcb *j, char *buf);
245 static void job_setup_env_from_other_jobs(struct jobcb *j);
246 static void job_export_all2(struct jobcb *j, launch_data_t where);
247 static launch_data_t job_export2(struct jobcb *j, bool subjobs);
248
249
250 static const struct {
251 const char *key;
252 int val;
253 } launchd_keys2limits[] = {
254 { LAUNCH_JOBKEY_RESOURCELIMIT_CORE, RLIMIT_CORE },
255 { LAUNCH_JOBKEY_RESOURCELIMIT_CPU, RLIMIT_CPU },
256 { LAUNCH_JOBKEY_RESOURCELIMIT_DATA, RLIMIT_DATA },
257 { LAUNCH_JOBKEY_RESOURCELIMIT_FSIZE, RLIMIT_FSIZE },
258 { LAUNCH_JOBKEY_RESOURCELIMIT_MEMLOCK, RLIMIT_MEMLOCK },
259 { LAUNCH_JOBKEY_RESOURCELIMIT_NOFILE, RLIMIT_NOFILE },
260 { LAUNCH_JOBKEY_RESOURCELIMIT_NPROC, RLIMIT_NPROC },
261 { LAUNCH_JOBKEY_RESOURCELIMIT_RSS, RLIMIT_RSS },
262 { LAUNCH_JOBKEY_RESOURCELIMIT_STACK, RLIMIT_STACK },
263 };
264
265 static time_t cronemu(int mon, int mday, int hour, int min);
266 static time_t cronemu_wday(int wday, int hour, int min);
267 static bool cronemu_mon(struct tm *wtm, int mon, int mday, int hour, int min);
268 static bool cronemu_mday(struct tm *wtm, int mday, int hour, int min);
269 static bool cronemu_hour(struct tm *wtm, int hour, int min);
270 static bool cronemu_min(struct tm *wtm, int min);
271
272 static void simple_zombie_reaper(void *, struct kevent *);
273
274 kq_callback kqsimple_zombie_reaper = simple_zombie_reaper;
275
276 static int dir_has_files(const char *path);
277 static char **mach_cmd2argv(const char *string);
278 struct jobcb *root_job = NULL;
279 struct jobcb *gc_this_job = NULL;
280 size_t total_children = 0;
281
282 void
283 simple_zombie_reaper(void *obj __attribute__((unused)), struct kevent *kev)
284 {
285 waitpid(kev->ident, NULL, 0);
286 }
287
288 void
289 job_ignore(struct jobcb *j)
290 {
291 struct socketgroup *sg;
292 struct machservice *ms;
293 struct watchpath *wp;
294
295 SLIST_FOREACH(sg, &j->sockets, sle)
296 socketgroup_ignore(j, sg);
297
298 SLIST_FOREACH(wp, &j->vnodes, sle)
299 watchpath_ignore(j, wp);
300
301 SLIST_FOREACH(ms, &j->machservices, sle)
302 launchd_assumes(launchd_mport_request_callback(ms->port, NULL, false) == KERN_SUCCESS);
303 }
304
305 void
306 job_watch(struct jobcb *j)
307 {
308 struct socketgroup *sg;
309 struct machservice *ms;
310 struct watchpath *wp;
311
312 SLIST_FOREACH(sg, &j->sockets, sle)
313 socketgroup_watch(j, sg);
314
315 SLIST_FOREACH(wp, &j->vnodes, sle)
316 watchpath_watch(j, wp);
317
318 SLIST_FOREACH(ms, &j->machservices, sle)
319 launchd_assumes(launchd_mport_request_callback(ms->port, j, false) == KERN_SUCCESS);
320 }
321
322 void
323 job_stop(struct jobcb *j)
324 {
325 if (j->p)
326 kill(j->p, SIGTERM);
327 }
328
329 launch_data_t
330 job_export(struct jobcb *j)
331 {
332 return job_export2(j, true);
333 }
334
335 launch_data_t
336 job_export2(struct jobcb *j, bool subjobs)
337 {
338 launch_data_t tmp, tmp2, tmp3, r = launch_data_alloc(LAUNCH_DATA_DICTIONARY);
339
340 if (r == NULL)
341 return NULL;
342
343 if ((tmp = launch_data_new_string(j->label)))
344 launch_data_dict_insert(r, tmp, LAUNCH_JOBKEY_LABEL);
345
346 if ((tmp = launch_data_new_bool(j->ondemand)))
347 launch_data_dict_insert(r, tmp, LAUNCH_JOBKEY_ONDEMAND);
348
349 if ((tmp = launch_data_new_integer(j->last_exit_status)))
350 launch_data_dict_insert(r, tmp, LAUNCH_JOBKEY_LASTEXITSTATUS);
351
352 if (j->p && (tmp = launch_data_new_integer(j->p)))
353 launch_data_dict_insert(r, tmp, LAUNCH_JOBKEY_PID);
354
355 if ((tmp = launch_data_new_integer(j->timeout)))
356 launch_data_dict_insert(r, tmp, LAUNCH_JOBKEY_TIMEOUT);
357
358 if (j->prog && (tmp = launch_data_new_string(j->prog)))
359 launch_data_dict_insert(r, tmp, LAUNCH_JOBKEY_PROGRAM);
360
361 if (j->stdoutpath && (tmp = launch_data_new_string(j->stdoutpath)))
362 launch_data_dict_insert(r, tmp, LAUNCH_JOBKEY_STANDARDOUTPATH);
363
364 if (j->stderrpath && (tmp = launch_data_new_string(j->stderrpath)))
365 launch_data_dict_insert(r, tmp, LAUNCH_JOBKEY_STANDARDERRORPATH);
366
367 if (j->argv && (tmp = launch_data_alloc(LAUNCH_DATA_ARRAY))) {
368 int i;
369
370 for (i = 0; i < j->argc; i++) {
371 if ((tmp2 = launch_data_new_string(j->argv[i])))
372 launch_data_array_set_index(tmp, tmp2, i);
373 }
374
375 launch_data_dict_insert(r, tmp, LAUNCH_JOBKEY_PROGRAMARGUMENTS);
376 }
377
378 if (j->inetcompat && (tmp = launch_data_alloc(LAUNCH_DATA_DICTIONARY))) {
379 if ((tmp2 = launch_data_new_bool(j->inetcompat_wait)))
380 launch_data_dict_insert(tmp, tmp2, LAUNCH_JOBINETDCOMPATIBILITY_WAIT);
381 launch_data_dict_insert(r, tmp, LAUNCH_JOBKEY_INETDCOMPATIBILITY);
382 }
383
384 if (!SLIST_EMPTY(&j->sockets) && (tmp = launch_data_alloc(LAUNCH_DATA_DICTIONARY))) {
385 struct socketgroup *sg;
386 int i;
387
388 SLIST_FOREACH(sg, &j->sockets, sle) {
389 if ((tmp2 = launch_data_alloc(LAUNCH_DATA_ARRAY))) {
390 for (i = 0; i < sg->fd_cnt; i++) {
391 if ((tmp3 = launch_data_new_fd(sg->fds[i])))
392 launch_data_array_set_index(tmp2, tmp3, i);
393 }
394 launch_data_dict_insert(tmp, tmp2, sg->name);
395 }
396 }
397
398 launch_data_dict_insert(r, tmp, LAUNCH_JOBKEY_SOCKETS);
399 }
400
401 if (!SLIST_EMPTY(&j->machservices) && (tmp = launch_data_alloc(LAUNCH_DATA_DICTIONARY))) {
402 struct machservice *ms;
403
404 SLIST_FOREACH(ms, &j->machservices, sle) {
405 tmp2 = launch_data_new_machport(MACH_PORT_NULL);
406 launch_data_dict_insert(tmp, tmp2, ms->name);
407 }
408
409 launch_data_dict_insert(r, tmp, LAUNCH_JOBKEY_MACHSERVICES);
410 }
411
412 if (subjobs && !SLIST_EMPTY(&j->jobs) && (tmp = launch_data_alloc(LAUNCH_DATA_ARRAY))) {
413 struct jobcb *ji;
414 size_t i = 0;
415
416 SLIST_FOREACH(ji, &j->jobs, sle) {
417 tmp2 = job_export2(ji, true);
418 launch_data_array_set_index(tmp, tmp2, i);
419 i++;
420 }
421
422 launch_data_dict_insert(r, tmp, LAUNCH_JOBKEY_SUBJOBS);
423 }
424
425 return r;
426 }
427
428 void
429 job_remove_all_inactive(struct jobcb *j)
430 {
431 struct jobcb *ji;
432
433 SLIST_FOREACH(ji, &j->jobs, sle)
434 job_remove_all_inactive(ji);
435
436 if (!job_active(j)) {
437 job_remove(j);
438 } else if (getpid() != 1) {
439 job_stop(j);
440 }
441 }
442
443 void
444 job_remove(struct jobcb *j)
445 {
446 struct jobcb *ji;
447 struct calendarinterval *ci;
448 struct socketgroup *sg;
449 struct watchpath *wp;
450 struct limititem *li;
451 struct envitem *ei;
452 struct machservice *ms;
453 struct semaphoreitem *si;
454
455 job_log(j, LOG_DEBUG, "Removed");
456
457 if (j->p) {
458 if (kevent_mod(j->p, EVFILT_PROC, EV_ADD, NOTE_EXIT, 0, &kqsimple_zombie_reaper) == -1) {
459 job_reap(j);
460 } else {
461 /* we've attached the simple zombie reaper, we're going to delete the job before it is dead */
462 total_children--;
463 job_stop(j);
464 }
465 }
466
467 if (j->parent)
468 SLIST_REMOVE(&j->parent->jobs, j, jobcb, sle);
469
470 if (j->execfd)
471 launchd_assumes(close(j->execfd) == 0);
472
473 if (j->bs_port) {
474 if (j->transfer_bstrap) {
475 launchd_assumes(launchd_mport_deallocate(j->bs_port) == KERN_SUCCESS);
476 } else {
477 launchd_assumes(launchd_mport_close_recv(j->bs_port) == KERN_SUCCESS);
478 }
479 }
480
481 if (j->req_port)
482 launchd_assumes(launchd_mport_deallocate(j->req_port) == KERN_SUCCESS);
483
484 #if 0
485 if (j->wait_reply_port) {
486 }
487 #endif
488
489 while ((ji = SLIST_FIRST(&j->jobs)))
490 job_remove(ji);
491
492 while ((sg = SLIST_FIRST(&j->sockets)))
493 socketgroup_delete(j, sg);
494
495 while ((wp = SLIST_FIRST(&j->vnodes)))
496 watchpath_delete(j, wp);
497
498 while ((ci = SLIST_FIRST(&j->cal_intervals)))
499 calendarinterval_delete(j, ci);
500
501 while ((ei = SLIST_FIRST(&j->env)))
502 envitem_delete(j, ei, false);
503
504 while ((ei = SLIST_FIRST(&j->global_env)))
505 envitem_delete(j, ei, true);
506
507 while ((li = SLIST_FIRST(&j->limits)))
508 limititem_delete(j, li);
509
510 while ((ms = SLIST_FIRST(&j->machservices)))
511 machservice_delete(ms);
512
513 while ((si = SLIST_FIRST(&j->semaphores)))
514 semaphoreitem_delete(j, si);
515
516 if (j->prog)
517 free(j->prog);
518
519 if (j->argv)
520 free(j->argv);
521
522 if (j->rootdir)
523 free(j->rootdir);
524
525 if (j->workingdir)
526 free(j->workingdir);
527
528 if (j->username)
529 free(j->username);
530
531 if (j->groupname)
532 free(j->groupname);
533
534 if (j->stdinpath)
535 free(j->stdinpath);
536
537 if (j->stdoutpath)
538 free(j->stdoutpath);
539
540 if (j->stderrpath)
541 free(j->stderrpath);
542
543 if (j->start_interval)
544 kevent_mod((uintptr_t)&j->start_interval, EVFILT_TIMER, EV_DELETE, 0, 0, NULL);
545
546 kevent_mod((uintptr_t)j, EVFILT_TIMER, EV_DELETE, 0, 0, NULL);
547 free(j);
548 }
549
550 void
551 socketgroup_setup(launch_data_t obj, const char *key, void *context)
552 {
553 launch_data_t tmp_oai;
554 struct jobcb *j = context;
555 unsigned int i, fd_cnt = 1;
556 int *fds;
557
558 if (launch_data_get_type(obj) == LAUNCH_DATA_ARRAY)
559 fd_cnt = launch_data_array_get_count(obj);
560
561 fds = alloca(fd_cnt * sizeof(int));
562
563 for (i = 0; i < fd_cnt; i++) {
564 if (launch_data_get_type(obj) == LAUNCH_DATA_ARRAY)
565 tmp_oai = launch_data_array_get_index(obj, i);
566 else
567 tmp_oai = obj;
568
569 fds[i] = launch_data_get_fd(tmp_oai);
570 }
571
572 socketgroup_new(j, key, fds, fd_cnt, strcmp(key, LAUNCH_JOBKEY_BONJOURFDS) == 0);
573
574 ipc_revoke_fds(obj);
575 }
576
577 bool
578 job_setup_machport(struct jobcb *j)
579 {
580 if (!launchd_assumes(launchd_mport_create_recv(&j->bs_port) == KERN_SUCCESS))
581 goto out_bad;
582
583 if (!launchd_assumes(launchd_mport_request_callback(j->bs_port, j, true) == KERN_SUCCESS))
584 goto out_bad2;
585
586 return true;
587 out_bad2:
588 launchd_assumes(launchd_mport_close_recv(j->bs_port) == KERN_SUCCESS);
589 out_bad:
590 return false;
591 }
592
593 struct jobcb *
594 job_new_via_mach_init(struct jobcb *jbs, const char *cmd, uid_t uid, bool ond)
595 {
596 const char **argv = (const char **)mach_cmd2argv(cmd);
597 struct jobcb *j = NULL;
598 char buf[1000];
599
600 if (!launchd_assumes(argv != NULL))
601 goto out_bad;
602
603 /* preflight the string so we know how big it is */
604 sprintf(buf, "100000.%s", basename((char *)argv[0]));
605
606 j = job_new(jbs, buf, NULL, argv, NULL, MACH_PORT_NULL);
607
608 free(argv);
609
610 if (!launchd_assumes(j != NULL))
611 goto out_bad;
612
613 j->mach_uid = uid;
614 j->ondemand = ond;
615 j->legacy_mach_job = true;
616 j->priv_port_has_senders = true; /* the IPC that called us will make-send on this port */
617
618 if (!job_setup_machport(j))
619 goto out_bad;
620
621 if (!launchd_assumes(launchd_mport_notify_req(j->bs_port, MACH_NOTIFY_NO_SENDERS) == KERN_SUCCESS)) {
622 launchd_assumes(launchd_mport_close_recv(j->bs_port) == KERN_SUCCESS);
623 goto out_bad;
624 }
625
626 sprintf(j->label, "%d.%s", MACH_PORT_INDEX(j->bs_port), basename(j->argv[0]));
627
628 job_log(j, LOG_INFO, "New%s server in bootstrap: %x", ond ? " on-demand" : "", jbs->bs_port);
629
630 return j;
631
632 out_bad:
633 if (j)
634 job_remove(j);
635 return NULL;
636 }
637
638 kern_return_t
639 job_handle_mpm_wait(struct jobcb *j, mach_port_t srp, int *waitstatus)
640 {
641 if (j->p) {
642 j->wait_reply_port = srp;
643 return MIG_NO_REPLY;
644 }
645
646 *waitstatus = j->last_exit_status;
647
648 return 0;
649 }
650
651 struct jobcb *
652 job_new_spawn(const char *label, const char *path, const char *workingdir, const char *const *argv, const char *const *env, mode_t *u_mask, bool w4d, bool fppc)
653 {
654 struct jobcb *jr;
655
656 if ((jr = job_find(root_job, label)) != NULL) {
657 errno = EEXIST;
658 return NULL;
659 }
660
661 jr = job_new(root_job, label, path, argv, NULL, MACH_PORT_NULL);
662
663 if (!jr)
664 return NULL;
665
666 jr->unload_at_exit = true;
667 jr->stall_before_exec = w4d;
668 jr->force_ppc = fppc;
669
670 if (!job_setup_machport(jr)) {
671 job_remove(jr);
672 return NULL;
673 }
674
675 if (workingdir)
676 jr->workingdir = strdup(workingdir);
677
678 if (u_mask) {
679 jr->mask = *u_mask;
680 jr->setmask = true;
681 }
682
683 if (env) for (; *env; env++) {
684 char newkey[strlen(*env) + 1], *eqoff = strchr(*env, '=');
685 if (!eqoff) {
686 job_log(jr, LOG_WARNING, "Environmental variable missing '=' separator: %s", *env);
687 continue;
688 }
689 strcpy(newkey, *env);
690 *eqoff = '\0';
691 envitem_new(jr, newkey, eqoff + 1, false);
692 }
693
694 job_start(jr);
695
696 return jr;
697 }
698
699 struct jobcb *
700 job_new(struct jobcb *p, const char *label, const char *prog, const char *const *argv, const char *stdinpath, mach_port_t reqport)
701 {
702 const char *const *argv_tmp = argv;
703 char *co;
704 int i, cc = 0;
705 struct jobcb *j;
706
707 if (reqport == MACH_PORT_NULL && prog == NULL && argv == NULL) {
708 errno = EINVAL;
709 return NULL;
710 }
711
712 j = calloc(1, sizeof(struct jobcb) + strlen(label) + 1);
713
714 if (!launchd_assumes(j != NULL))
715 goto out_bad;
716
717 strcpy(j->label, label);
718 j->kqjob_callback = job_callback;
719 j->parent = p ? job_get_bs(p) : NULL;
720 j->ondemand = true;
721 j->checkedin = true;
722 j->firstborn = (strcmp(label, FIRSTBORN_LABEL) == 0);
723
724 if (reqport != MACH_PORT_NULL) {
725 j->req_port = reqport;
726 if (!launchd_assumes(launchd_mport_notify_req(reqport, MACH_NOTIFY_DEAD_NAME) == KERN_SUCCESS))
727 goto out_bad;
728 }
729
730 if (prog) {
731 j->prog = strdup(prog);
732 if (!launchd_assumes(j->prog != NULL))
733 goto out_bad;
734 }
735
736 if (stdinpath) {
737 j->stdinpath = strdup(stdinpath);
738 if (!launchd_assumes(j->stdinpath != NULL))
739 goto out_bad;
740 }
741
742 if (argv) {
743 while (*argv_tmp++)
744 j->argc++;
745
746 for (i = 0; i < j->argc; i++)
747 cc += strlen(argv[i]) + 1;
748
749 j->argv = malloc((j->argc + 1) * sizeof(char *) + cc);
750
751 if (!launchd_assumes(j != NULL))
752 goto out_bad;
753
754 co = ((char *)j->argv) + ((j->argc + 1) * sizeof(char *));
755
756 for (i = 0; i < j->argc; i++) {
757 j->argv[i] = co;
758 strcpy(co, argv[i]);
759 co += strlen(argv[i]) + 1;
760 }
761 j->argv[i] = NULL;
762 }
763
764 if (j->parent) {
765 SLIST_INSERT_HEAD(&j->parent->jobs, j, sle);
766 job_log(j->parent, LOG_DEBUG, "Conceived");
767 }
768
769 return j;
770
771 out_bad:
772 if (j) {
773 if (j->prog)
774 free(j->prog);
775 if (j->stdinpath)
776 free(j->stdinpath);
777 free(j);
778 }
779 return NULL;
780 }
781
782 struct jobcb *
783 job_import(launch_data_t pload)
784 {
785 struct jobcb *j = job_import2(pload);
786
787 if (j == NULL)
788 return NULL;
789
790 job_dispatch(j);
791
792 return j;
793 }
794
795 launch_data_t
796 job_import_bulk(launch_data_t pload)
797 {
798 launch_data_t resp = launch_data_alloc(LAUNCH_DATA_ARRAY);
799 struct jobcb **ja;
800 size_t i, c = launch_data_array_get_count(pload);
801
802 ja = alloca(c * sizeof(struct jobcb *));
803
804 for (i = 0; i < c; i++) {
805 if ((ja[i] = job_import2(launch_data_array_get_index(pload, i))))
806 errno = 0;
807 launch_data_array_set_index(resp, launch_data_new_errno(errno), i);
808 }
809
810 for (i = 0; i < c; i++) {
811 if (ja[i] == NULL)
812 continue;
813 job_dispatch(ja[i]);
814 }
815
816 return resp;
817 }
818
819 void
820 job_import_bool(struct jobcb *j, const char *key, bool value)
821 {
822 switch (key[0]) {
823 case 'f':
824 case 'F':
825 if (strcasecmp(key, LAUNCH_JOBKEY_FORCEPOWERPC) == 0)
826 j->force_ppc = value;
827 break;
828 case 'k':
829 case 'K':
830 if (strcasecmp(key, LAUNCH_JOBKEY_KEEPALIVE) == 0)
831 j->ondemand = !value;
832 break;
833 case 'o':
834 case 'O':
835 if (strcasecmp(key, LAUNCH_JOBKEY_ONDEMAND) == 0)
836 j->ondemand = value;
837 break;
838 case 'd':
839 case 'D':
840 if (strcasecmp(key, LAUNCH_JOBKEY_DEBUG) == 0)
841 j->debug = value;
842 break;
843 case 's':
844 case 'S':
845 if (strcasecmp(key, LAUNCH_JOBKEY_SESSIONCREATE) == 0)
846 j->session_create = value;
847 break;
848 case 'l':
849 case 'L':
850 if (strcasecmp(key, LAUNCH_JOBKEY_LOWPRIORITYIO) == 0)
851 j->low_pri_io = value;
852 break;
853 case 'i':
854 case 'I':
855 if (strcasecmp(key, LAUNCH_JOBKEY_INITGROUPS) == 0)
856 j->init_groups = value;
857 break;
858 case 'r':
859 case 'R':
860 if (strcasecmp(key, LAUNCH_JOBKEY_RUNATLOAD) == 0)
861 j->runatload = value;
862 break;
863 case 'e':
864 case 'E':
865 if (strcasecmp(key, LAUNCH_JOBKEY_ENABLEGLOBBING) == 0)
866 j->globargv = value;
867 break;
868 case 'w':
869 case 'W':
870 if (strcasecmp(key, LAUNCH_JOBKEY_WAITFORDEBUGGER) == 0)
871 j->wait4debugger = value;
872 break;
873 default:
874 break;
875 }
876 }
877
878 void
879 job_import_string(struct jobcb *j, const char *key, const char *value)
880 {
881 char **where2put = NULL;
882 char **ignore = (char **)-1;
883
884 switch (key[0]) {
885 case 'p':
886 case 'P':
887 if (strcasecmp(key, LAUNCH_JOBKEY_PROGRAM) == 0)
888 where2put = ignore;
889 break;
890 case 'l':
891 case 'L':
892 if (strcasecmp(key, LAUNCH_JOBKEY_LABEL) == 0)
893 where2put = ignore;
894 break;
895 case 'r':
896 case 'R':
897 if (strcasecmp(key, LAUNCH_JOBKEY_ROOTDIRECTORY) == 0)
898 where2put = &j->rootdir;
899 break;
900 case 'w':
901 case 'W':
902 if (strcasecmp(key, LAUNCH_JOBKEY_WORKINGDIRECTORY) == 0)
903 where2put = &j->workingdir;
904 break;
905 case 'u':
906 case 'U':
907 if (strcasecmp(key, LAUNCH_JOBKEY_USERNAME) == 0)
908 where2put = &j->username;
909 break;
910 case 'g':
911 case 'G':
912 if (strcasecmp(key, LAUNCH_JOBKEY_GROUPNAME) == 0)
913 where2put = &j->groupname;
914 break;
915 case 's':
916 case 'S':
917 if (strcasecmp(key, LAUNCH_JOBKEY_STANDARDOUTPATH) == 0) {
918 where2put = &j->stdoutpath;
919 } else if (strcasecmp(key, LAUNCH_JOBKEY_STANDARDERRORPATH) == 0) {
920 where2put = &j->stderrpath;
921 }
922 break;
923 default:
924 break;
925 }
926
927 if (where2put) {
928 if (where2put == ignore)
929 return;
930
931 launchd_assumes((*where2put = strdup(value)) != NULL);
932 } else {
933 job_log(j, LOG_WARNING, "Unknown value for key %s: %s", key, value);
934 }
935 }
936
937 void
938 job_import_integer(struct jobcb *j, const char *key, long long value)
939 {
940 switch (key[0]) {
941 case 'n':
942 case 'N':
943 if (strcasecmp(key, LAUNCH_JOBKEY_NICE) == 0)
944 j->nice = value;
945 break;
946 case 't':
947 case 'T':
948 if (strcasecmp(key, LAUNCH_JOBKEY_TIMEOUT) == 0) {
949 if (value <= 0)
950 job_log(j, LOG_WARNING, "Timeout less than or equal to zero. Ignoring.");
951 else
952 j->timeout = value;
953 }
954 break;
955 case 'u':
956 case 'U':
957 if (strcasecmp(key, LAUNCH_JOBKEY_UMASK) == 0) {
958 j->mask = value;
959 j->setmask = true;
960 }
961 break;
962 case 's':
963 case 'S':
964 if (strcasecmp(key, LAUNCH_JOBKEY_STARTINTERVAL) == 0) {
965 if (value <= 0)
966 job_log(j, LOG_WARNING, "StartInterval is not greater than zero, ignoring");
967 else
968 j->start_interval = value;
969 if (-1 == kevent_mod((uintptr_t)&j->start_interval, EVFILT_TIMER, EV_ADD, NOTE_SECONDS, value, j))
970 job_log_error(j, LOG_ERR, "adding kevent timer");
971 }
972 break;
973 default:
974 break;
975 }
976 }
977
978 void
979 job_import_dictionary(struct jobcb *j, const char *key, launch_data_t value)
980 {
981 launch_data_t tmp;
982
983 switch (key[0]) {
984 case 'k':
985 case 'K':
986 if (strcasecmp(key, LAUNCH_JOBKEY_KEEPALIVE) == 0)
987 launch_data_dict_iterate(value, semaphoreitem_setup, j);
988 break;
989 case 'i':
990 case 'I':
991 if (strcasecmp(key, LAUNCH_JOBKEY_INETDCOMPATIBILITY) == 0) {
992 j->inetcompat = true;
993 if ((tmp = launch_data_dict_lookup(value, LAUNCH_JOBINETDCOMPATIBILITY_WAIT)))
994 j->inetcompat_wait = launch_data_get_bool(tmp);
995 }
996 break;
997 case 'e':
998 case 'E':
999 if (strcasecmp(key, LAUNCH_JOBKEY_ENVIRONMENTVARIABLES) == 0)
1000 launch_data_dict_iterate(value, envitem_setup, j);
1001 break;
1002 case 'u':
1003 case 'U':
1004 if (strcasecmp(key, LAUNCH_JOBKEY_USERENVIRONMENTVARIABLES) == 0) {
1005 j->importing_global_env = true;
1006 launch_data_dict_iterate(value, envitem_setup, j);
1007 j->importing_global_env = false;
1008 }
1009 break;
1010 case 's':
1011 case 'S':
1012 if (strcasecmp(key, LAUNCH_JOBKEY_SOCKETS) == 0) {
1013 launch_data_dict_iterate(value, socketgroup_setup, j);
1014 } else if (strcasecmp(key, LAUNCH_JOBKEY_STARTCALENDARINTERVAL) == 0) {
1015 calendarinterval_new_from_obj(j, value);
1016 } else if (strcasecmp(key, LAUNCH_JOBKEY_SOFTRESOURCELIMITS) == 0) {
1017 launch_data_dict_iterate(value, limititem_setup, j);
1018 }
1019 break;
1020 case 'h':
1021 case 'H':
1022 if (strcasecmp(key, LAUNCH_JOBKEY_HARDRESOURCELIMITS) == 0) {
1023 j->importing_hard_limits = true;
1024 launch_data_dict_iterate(value, limititem_setup, j);
1025 j->importing_hard_limits = false;
1026 }
1027 break;
1028 case 'm':
1029 case 'M':
1030 if (strcasecmp(key, LAUNCH_JOBKEY_MACHSERVICES) == 0) {
1031 launch_data_dict_iterate(value, machservice_setup, j);
1032 if (!SLIST_EMPTY(&j->machservices))
1033 job_setup_machport(j);
1034 }
1035 break;
1036 default:
1037 break;
1038 }
1039 }
1040
1041 void
1042 job_import_array(struct jobcb *j, const char *key, launch_data_t value)
1043 {
1044 bool is_q_dir = false;
1045 bool is_wp = false;
1046
1047 switch (key[0]) {
1048 case 'q':
1049 case 'Q':
1050 if (strcasecmp(key, LAUNCH_JOBKEY_QUEUEDIRECTORIES) == 0) {
1051 is_q_dir = true;
1052 is_wp = true;
1053 }
1054 break;
1055 case 'w':
1056 case 'W':
1057 if (strcasecmp(key, LAUNCH_JOBKEY_WATCHPATHS) == 0)
1058 is_wp = true;
1059 break;
1060 case 'b':
1061 case 'B':
1062 if (strcasecmp(key, LAUNCH_JOBKEY_BONJOURFDS) == 0)
1063 socketgroup_setup(value, LAUNCH_JOBKEY_BONJOURFDS, j);
1064 break;
1065 case 's':
1066 case 'S':
1067 if (strcasecmp(key, LAUNCH_JOBKEY_STARTCALENDARINTERVAL) == 0) {
1068 size_t i = 0, ci_cnt = launch_data_array_get_count(value);
1069 for (i = 0; i < ci_cnt; i++)
1070 calendarinterval_new_from_obj(j, launch_data_array_get_index(value, i));
1071 }
1072 break;
1073 default:
1074 break;
1075 }
1076
1077 if (is_wp) {
1078 size_t i, wp_cnt = launch_data_array_get_count(value);
1079 const char *thepath;
1080 for (i = 0; i < wp_cnt; i++) {
1081 thepath = launch_data_get_string(launch_data_array_get_index(value, i));
1082 watchpath_new(j, thepath, is_q_dir);
1083 }
1084 }
1085 }
1086
1087 void
1088 job_import_keys(launch_data_t obj, const char *key, void *context)
1089 {
1090 struct jobcb *j = context;
1091 launch_data_type_t kind;
1092
1093 if (obj == NULL)
1094 return;
1095
1096 kind = launch_data_get_type(obj);
1097
1098 switch (kind) {
1099 case LAUNCH_DATA_BOOL:
1100 job_import_bool(j, key, launch_data_get_bool(obj));
1101 break;
1102 case LAUNCH_DATA_STRING:
1103 job_import_string(j, key, launch_data_get_string(obj));
1104 break;
1105 case LAUNCH_DATA_INTEGER:
1106 job_import_integer(j, key, launch_data_get_integer(obj));
1107 break;
1108 case LAUNCH_DATA_DICTIONARY:
1109 job_import_dictionary(j, key, obj);
1110 break;
1111 case LAUNCH_DATA_ARRAY:
1112 job_import_array(j, key, obj);
1113 break;
1114 default:
1115 job_log(j, LOG_WARNING, "Unknown value type '%d' for key: %s", kind, key);
1116 break;
1117 }
1118 }
1119
1120 struct jobcb *
1121 job_import2(launch_data_t pload)
1122 {
1123 launch_data_t tmp, ldpa;
1124 const char *label = NULL, *prog = NULL;
1125 const char **argv = NULL;
1126 struct jobcb *j;
1127
1128 if (pload == NULL)
1129 return NULL;
1130
1131 if (launch_data_get_type(pload) != LAUNCH_DATA_DICTIONARY)
1132 return NULL;
1133
1134 if ((tmp = launch_data_dict_lookup(pload, LAUNCH_JOBKEY_LABEL)) &&
1135 (launch_data_get_type(tmp) == LAUNCH_DATA_STRING)) {
1136 label = launch_data_get_string(tmp);
1137 }
1138 if ((tmp = launch_data_dict_lookup(pload, LAUNCH_JOBKEY_PROGRAM)) &&
1139 (launch_data_get_type(tmp) == LAUNCH_DATA_STRING)) {
1140 prog = launch_data_get_string(tmp);
1141 }
1142 ldpa = launch_data_dict_lookup(pload, LAUNCH_JOBKEY_PROGRAMARGUMENTS);
1143
1144 if (label == NULL) {
1145 errno = EINVAL;
1146 return NULL;
1147 } else if ((j = job_find(root_job, label)) != NULL) {
1148 errno = EEXIST;
1149 return NULL;
1150 } else if (label[0] == '\0' || (strncasecmp(label, "", strlen("com.apple.launchd")) == 0) ||
1151 (strtol(label, NULL, 10) != 0)) {
1152 syslog(LOG_ERR, "Somebody attempted to use a reserved prefix for a label: %s", label);
1153 /* the empty string, com.apple.launchd and number prefixes for labels are reserved */
1154 errno = EINVAL;
1155 return NULL;
1156 }
1157
1158 if (ldpa) {
1159 size_t i, c = launch_data_array_get_count(ldpa);
1160
1161 argv = alloca((c + 1) * sizeof(char *));
1162
1163 for (i = 0; i < c; i++)
1164 argv[i] = launch_data_get_string(launch_data_array_get_index(ldpa, i));
1165 argv[i] = NULL;
1166 }
1167
1168 if ((j = job_new(root_job, label, prog, argv, NULL, MACH_PORT_NULL)))
1169 launch_data_dict_iterate(pload, job_import_keys, j);
1170
1171 return j;
1172 }
1173
1174 struct jobcb *
1175 job_find(struct jobcb *j, const char *label)
1176 {
1177 struct jobcb *jr, *ji;
1178
1179 if (label[0] == '\0')
1180 return root_job;
1181
1182 if (strcmp(j->label, label) == 0)
1183 return j;
1184
1185 SLIST_FOREACH(ji, &j->jobs, sle) {
1186 if ((jr = job_find(ji, label)))
1187 return jr;
1188 }
1189
1190 errno = ESRCH;
1191 return NULL;
1192 }
1193
1194 struct jobcb *
1195 job_find_by_pid(struct jobcb *j, pid_t p)
1196 {
1197 struct jobcb *jr, *ji;
1198
1199 if (j->p == p)
1200 return j;
1201
1202 SLIST_FOREACH(ji, &j->jobs, sle) {
1203 if ((jr = job_find_by_pid(ji, p)))
1204 return jr;
1205 }
1206
1207 errno = ESRCH;
1208 return NULL;
1209 }
1210
1211 void
1212 job_export_all2(struct jobcb *j, launch_data_t where)
1213 {
1214 launch_data_t tmp;
1215 struct jobcb *ji;
1216
1217 if (launchd_assumes((tmp = job_export2(j, false)) != NULL))
1218 launch_data_dict_insert(where, tmp, j->label);
1219
1220 SLIST_FOREACH(ji, &j->jobs, sle)
1221 job_export_all2(ji, where);
1222 }
1223
1224 launch_data_t
1225 job_export_all(void)
1226 {
1227 launch_data_t resp = launch_data_alloc(LAUNCH_DATA_DICTIONARY);
1228
1229 job_export_all2(root_job, resp);
1230
1231 return resp;
1232 }
1233
1234 void
1235 job_reap(struct jobcb *j)
1236 {
1237 struct rusage ru;
1238 time_t td = time(NULL) - j->start_time;
1239 bool bad_exit = false;
1240 int status;
1241
1242 job_log(j, LOG_DEBUG, "Reaping");
1243
1244 if (j->execfd) {
1245 launchd_assumes(close(j->execfd) == 0);
1246 j->execfd = 0;
1247 }
1248
1249 if (!launchd_assumes(wait4(j->p, &status, 0, &ru) != -1)) {
1250 return;
1251 }
1252
1253 if (j->wait_reply_port) {
1254 job_log(j, LOG_DEBUG, "MPM wait reply being sent");
1255 launchd_assumes(mpm_wait_reply(j->wait_reply_port, 0, status) == 0);
1256 j->wait_reply_port = MACH_PORT_NULL;
1257 }
1258
1259 timeradd(&ru.ru_utime, &j->ru.ru_utime, &j->ru.ru_utime);
1260 timeradd(&ru.ru_stime, &j->ru.ru_stime, &j->ru.ru_stime);
1261 j->ru.ru_maxrss += ru.ru_maxrss;
1262 j->ru.ru_ixrss += ru.ru_ixrss;
1263 j->ru.ru_idrss += ru.ru_idrss;
1264 j->ru.ru_isrss += ru.ru_isrss;
1265 j->ru.ru_minflt += ru.ru_minflt;
1266 j->ru.ru_majflt += ru.ru_majflt;
1267 j->ru.ru_nswap += ru.ru_nswap;
1268 j->ru.ru_inblock += ru.ru_inblock;
1269 j->ru.ru_oublock += ru.ru_oublock;
1270 j->ru.ru_msgsnd += ru.ru_msgsnd;
1271 j->ru.ru_msgrcv += ru.ru_msgrcv;
1272 j->ru.ru_nsignals += ru.ru_nsignals;
1273 j->ru.ru_nvcsw += ru.ru_nvcsw;
1274 j->ru.ru_nivcsw += ru.ru_nivcsw;
1275
1276 if (WIFEXITED(status) && WEXITSTATUS(status) != 0) {
1277 job_log(j, LOG_WARNING, "exited with exit code: %d", WEXITSTATUS(status));
1278 bad_exit = true;
1279 }
1280
1281 if (WIFSIGNALED(status)) {
1282 int s = WTERMSIG(status);
1283 if (SIGKILL == s || SIGTERM == s) {
1284 job_log(j, LOG_NOTICE, "Exited: %s", strsignal(s));
1285 } else {
1286 job_log(j, LOG_WARNING, "Exited abnormally: %s", strsignal(s));
1287 bad_exit = true;
1288 }
1289 }
1290
1291 if (!j->ondemand && !j->legacy_mach_job) {
1292 if (td < LAUNCHD_MIN_JOB_RUN_TIME) {
1293 job_log(j, LOG_WARNING, "respawning too quickly! throttling");
1294 bad_exit = true;
1295 j->throttle = true;
1296 } else if (td >= LAUNCHD_REWARD_JOB_RUN_TIME) {
1297 job_log(j, LOG_INFO, "lived long enough, forgiving past exit failures");
1298 j->failed_exits = 0;
1299 }
1300 }
1301
1302 if (!j->legacy_mach_job && bad_exit)
1303 j->failed_exits++;
1304
1305 if (j->failed_exits > 0) {
1306 int failures_left = LAUNCHD_FAILED_EXITS_THRESHOLD - j->failed_exits;
1307 if (failures_left)
1308 job_log(j, LOG_WARNING, "%d more failure%s without living at least %d seconds will cause job removal",
1309 failures_left, failures_left > 1 ? "s" : "", LAUNCHD_REWARD_JOB_RUN_TIME);
1310 }
1311
1312 total_children--;
1313 j->last_exit_status = status;
1314 j->p = 0;
1315 }
1316
1317 void
1318 job_dispatch(struct jobcb *j)
1319 {
1320 if (job_active(j)) {
1321 return;
1322 } else if (job_useless(j)) {
1323 job_remove(j);
1324 } else if (job_keepalive(j)) {
1325 job_start(j);
1326 } else {
1327 job_watch(j);
1328 }
1329 }
1330
1331 void
1332 job_callback(void *obj, struct kevent *kev)
1333 {
1334 struct jobcb *j = obj;
1335 bool d = j->debug;
1336 int oldmask = 0;
1337
1338 if (d) {
1339 oldmask = setlogmask(LOG_UPTO(LOG_DEBUG));
1340 }
1341
1342 switch (kev->filter) {
1343 case EVFILT_PROC:
1344 job_reap(j);
1345
1346 if (j->firstborn) {
1347 job_log(j, LOG_DEBUG, "first born died, begin shutdown");
1348 launchd_shutdown();
1349 } else {
1350 job_dispatch(j);
1351 }
1352 break;
1353 case EVFILT_TIMER:
1354 if ((uintptr_t)j == kev->ident) {
1355 job_start(j);
1356 } else {
1357 calendarinterval_callback(j, kev);
1358 }
1359 break;
1360 case EVFILT_VNODE:
1361 watchpath_callback(j, kev);
1362 break;
1363 case EVFILT_READ:
1364 if ((int)kev->ident != j->execfd) {
1365 socketgroup_callback(j, kev);
1366 break;
1367 }
1368 if (j->wait4debugger) {
1369 /* Allow somebody else to attach */
1370 launchd_assumes(kill(j->p, SIGSTOP) != -1);
1371 launchd_assumes(ptrace(PT_DETACH, j->p, NULL, 0) != -1);
1372 }
1373 if (kev->data > 0) {
1374 int e;
1375
1376 read(j->execfd, &e, sizeof(e));
1377 errno = e;
1378 job_log_error(j, LOG_ERR, "execve()");
1379 job_remove(j);
1380 j = NULL;
1381 } else {
1382 launchd_assumes(close(j->execfd) == 0);
1383 j->execfd = 0;
1384 }
1385 break;
1386 case EVFILT_MACHPORT:
1387 job_start(j);
1388 break;
1389 default:
1390 launchd_assumes(false);
1391 break;
1392 }
1393
1394 if (d) {
1395 /* the job might have been removed, must not call job_log() */
1396 setlogmask(oldmask);
1397 }
1398 }
1399
1400 void
1401 job_start(struct jobcb *j)
1402 {
1403 int spair[2];
1404 int execspair[2];
1405 char nbuf[64];
1406 pid_t c;
1407 bool sipc = false;
1408
1409 if (!launchd_assumes(j->req_port == MACH_PORT_NULL))
1410 return;
1411
1412 if (!launchd_assumes(j->parent != NULL))
1413 return;
1414
1415 if (job_active(j)) {
1416 job_log(j, LOG_DEBUG, "Already started");
1417 return;
1418 } else if (!j->legacy_mach_job && j->throttle) {
1419 j->throttle = false;
1420 job_log(j, LOG_WARNING, "Throttling: Will restart in %d seconds", LAUNCHD_MIN_JOB_RUN_TIME);
1421 launchd_assumes(kevent_mod((uintptr_t)j, EVFILT_TIMER, EV_ADD|EV_ONESHOT,
1422 NOTE_SECONDS, LAUNCHD_MIN_JOB_RUN_TIME, j) != -1);
1423 return;
1424 }
1425
1426 job_log(j, LOG_DEBUG, "Starting");
1427
1428 if (!j->legacy_mach_job)
1429 sipc = (!SLIST_EMPTY(&j->sockets) || !SLIST_EMPTY(&j->machservices));
1430
1431 /* FIXME, using stdinpath is a hack for re-reading the conf file */
1432 if (j->stdinpath)
1433 sipc = true;
1434
1435 j->checkedin = false;
1436
1437 if (sipc)
1438 socketpair(AF_UNIX, SOCK_STREAM, 0, spair);
1439
1440 socketpair(AF_UNIX, SOCK_STREAM, 0, execspair);
1441
1442 time(&j->start_time);
1443
1444 if (j->bs_port) {
1445 launchd_assumes(launchd_mport_notify_req(j->bs_port, MACH_NOTIFY_NO_SENDERS) == KERN_SUCCESS);
1446 }
1447
1448 switch (c = job_fork(j->bs_port ? j : j->parent)) {
1449 case -1:
1450 job_log_error(j, LOG_ERR, "fork() failed, will try again in one second");
1451 launchd_assumes(close(execspair[0]) == 0);
1452 launchd_assumes(close(execspair[1]) == 0);
1453 if (sipc) {
1454 launchd_assumes(close(spair[0]) == 0);
1455 launchd_assumes(close(spair[1]) == 0);
1456 }
1457 break;
1458 case 0:
1459 launchd_assumes(close(execspair[0]) == 0);
1460 /* wait for our parent to say they've attached a kevent to us */
1461 read(_fd(execspair[1]), &c, sizeof(c));
1462 if (j->firstborn) {
1463 setpgid(getpid(), getpid());
1464 if (isatty(STDIN_FILENO)) {
1465 if (tcsetpgrp(STDIN_FILENO, getpid()) == -1)
1466 job_log_error(j, LOG_WARNING, "tcsetpgrp()");
1467 }
1468 }
1469
1470 if (sipc) {
1471 launchd_assumes(close(spair[0]) == 0);
1472 sprintf(nbuf, "%d", spair[1]);
1473 setenv(LAUNCHD_TRUSTED_FD_ENV, nbuf, 1);
1474 }
1475 job_start_child(j, execspair[1]);
1476 break;
1477 default:
1478 if (!SLIST_EMPTY(&j->machservices))
1479 j->priv_port_has_senders = true;
1480 j->p = c;
1481 total_children++;
1482 launchd_assumes(close(execspair[1]) == 0);
1483 j->execfd = _fd(execspair[0]);
1484 if (sipc) {
1485 launchd_assumes(close(spair[1]) == 0);
1486 ipc_open(_fd(spair[0]), j);
1487 }
1488 if (kevent_mod(j->execfd, EVFILT_READ, EV_ADD, 0, 0, &j->kqjob_callback) == -1)
1489 job_log_error(j, LOG_ERR, "kevent_mod(j->execfd): %m");
1490 if (kevent_mod(c, EVFILT_PROC, EV_ADD, NOTE_EXIT, 0, &j->kqjob_callback) == -1) {
1491 job_log_error(j, LOG_ERR, "kevent()");
1492 job_reap(j);
1493 } else {
1494 if (j->ondemand)
1495 job_ignore(j);
1496 }
1497
1498 if (!j->stall_before_exec) {
1499 /* this unblocks the child and avoids a race
1500 * between the above fork() and the kevent_mod() */
1501 write(j->execfd, &c, sizeof(c));
1502 }
1503 break;
1504 }
1505 }
1506
1507 void
1508 job_start_child(struct jobcb *j, int execfd)
1509 {
1510 const char *file2exec = "/usr/libexec/launchproxy";
1511 const char **argv;
1512 int gflags = GLOB_NOSORT|GLOB_NOCHECK|GLOB_TILDE|GLOB_DOOFFS;
1513 glob_t g;
1514 int i;
1515
1516 job_setup_attributes(j);
1517
1518 if (j->argv && j->globargv) {
1519 g.gl_offs = 1;
1520 for (i = 0; i < j->argc; i++) {
1521 if (i > 0)
1522 gflags |= GLOB_APPEND;
1523 if (glob(j->argv[i], gflags, NULL, &g) != 0) {
1524 job_log_error(j, LOG_ERR, "glob(\"%s\")", j->argv[i]);
1525 exit(EXIT_FAILURE);
1526 }
1527 }
1528 g.gl_pathv[0] = (char *)file2exec;
1529 argv = (const char **)g.gl_pathv;
1530 } else if (j->argv) {
1531 argv = alloca((j->argc + 2) * sizeof(char *));
1532 argv[0] = file2exec;
1533 for (i = 0; i < j->argc; i++)
1534 argv[i + 1] = j->argv[i];
1535 argv[i + 1] = NULL;
1536 } else {
1537 argv = alloca(3 * sizeof(char *));
1538 argv[0] = file2exec;
1539 argv[1] = j->prog;
1540 argv[2] = NULL;
1541 }
1542
1543 if (!j->inetcompat)
1544 argv++;
1545
1546 if (j->wait4debugger && ptrace(PT_TRACE_ME, getpid(), NULL, 0) == -1)
1547 job_log_error(j, LOG_ERR, "ptrace(PT_TRACE_ME, ...)");
1548
1549 if (j->force_ppc) {
1550 int affinmib[] = { CTL_KERN, KERN_AFFINITY, 1, 1 };
1551 size_t mibsz = sizeof(affinmib) / sizeof(affinmib[0]);
1552
1553 if (sysctl(affinmib, mibsz, NULL, NULL, NULL, 0) == -1)
1554 job_log_error(j, LOG_WARNING, "Failed to force PowerPC execution");
1555 }
1556
1557 if (j->prog) {
1558 execv(j->inetcompat ? file2exec : j->prog, (char *const*)argv);
1559 job_log_error(j, LOG_ERR, "execv(\"%s\", ...)", j->prog);
1560 } else {
1561 execvp(j->inetcompat ? file2exec : argv[0], (char *const*)argv);
1562 job_log_error(j, LOG_ERR, "execvp(\"%s\", ...)", argv[0]);
1563 }
1564
1565 write(execfd, &errno, sizeof(errno));
1566 exit(EXIT_FAILURE);
1567 }
1568
1569 void job_setup_env_from_other_jobs(struct jobcb *j)
1570 {
1571 struct envitem *ei;
1572 struct jobcb *ji;
1573
1574 SLIST_FOREACH(ji, &j->jobs, sle)
1575 job_setup_env_from_other_jobs(ji);
1576
1577 SLIST_FOREACH(ei, &j->global_env, sle)
1578 setenv(ei->key, ei->value, 1);
1579 }
1580
1581 void
1582 job_setup_attributes(struct jobcb *j)
1583 {
1584 struct limititem *li;
1585 struct envitem *ei;
1586 struct group *gre = NULL;
1587 gid_t gre_g = 0;
1588
1589 setpriority(PRIO_PROCESS, 0, j->nice);
1590
1591 SLIST_FOREACH(li, &j->limits, sle) {
1592 struct rlimit rl;
1593
1594 if (getrlimit(li->which, &rl) == -1) {
1595 job_log_error(j, LOG_WARNING, "getrlimit()");
1596 continue;
1597 }
1598
1599 if (li->sethard)
1600 rl.rlim_max = li->lim.rlim_max;
1601 if (li->setsoft)
1602 rl.rlim_cur = li->lim.rlim_cur;
1603
1604 if (setrlimit(li->which, &rl) == -1)
1605 job_log_error(j, LOG_WARNING, "setrlimit()");
1606 }
1607
1608 if (!j->inetcompat && j->session_create)
1609 launchd_SessionCreate();
1610
1611 if (j->low_pri_io) {
1612 int lowprimib[] = { CTL_KERN, KERN_PROC_LOW_PRI_IO };
1613 int val = 1;
1614
1615 if (sysctl(lowprimib, sizeof(lowprimib) / sizeof(lowprimib[0]), NULL, NULL, &val, sizeof(val)) == -1)
1616 job_log_error(j, LOG_WARNING, "sysctl(\"%s\")", "kern.proc_low_pri_io");
1617 }
1618 if (j->rootdir) {
1619 chroot(j->rootdir);
1620 chdir(".");
1621 }
1622 if (j->groupname) {
1623 gre = getgrnam(j->groupname);
1624 if (gre) {
1625 gre_g = gre->gr_gid;
1626 if (-1 == setgid(gre_g)) {
1627 job_log_error(j, LOG_ERR, "setgid(%d)", gre_g);
1628 exit(EXIT_FAILURE);
1629 }
1630 } else {
1631 job_log(j, LOG_ERR, "getgrnam(\"%s\") failed", j->groupname);
1632 exit(EXIT_FAILURE);
1633 }
1634 }
1635 if (j->username || j->mach_uid) {
1636 struct passwd *pwe;
1637
1638 if (j->username)
1639 pwe = getpwnam(j->username);
1640 else
1641 pwe = getpwuid(j->mach_uid);
1642
1643 if (pwe) {
1644 uid_t pwe_u = pwe->pw_uid;
1645 uid_t pwe_g = pwe->pw_gid;
1646
1647 if (pwe->pw_expire && time(NULL) >= pwe->pw_expire) {
1648 job_log(j, LOG_ERR, "expired account: %s", j->username);
1649 exit(EXIT_FAILURE);
1650 }
1651 if (j->init_groups) {
1652 if (-1 == initgroups(j->username, gre ? gre_g : pwe_g)) {
1653 job_log_error(j, LOG_ERR, "initgroups()");
1654 exit(EXIT_FAILURE);
1655 }
1656 }
1657 if (!gre) {
1658 if (-1 == setgid(pwe_g)) {
1659 job_log_error(j, LOG_ERR, "setgid(%d)", pwe_g);
1660 exit(EXIT_FAILURE);
1661 }
1662 }
1663 if (-1 == setuid(pwe_u)) {
1664 job_log_error(j, LOG_ERR, "setuid(%d)", pwe_u);
1665 exit(EXIT_FAILURE);
1666 }
1667 } else {
1668 if (j->username) {
1669 job_log(j, LOG_WARNING, "getpwnam(\"%s\") failed", j->username);
1670 } else {
1671 job_log(j, LOG_WARNING, "getpwuid(\"%d\") failed", j->mach_uid);
1672 }
1673 exit(EXIT_FAILURE);
1674 }
1675 }
1676 if (j->workingdir)
1677 chdir(j->workingdir);
1678 if (j->setmask)
1679 umask(j->mask);
1680 if (j->stdinpath) {
1681 int sifd = open(j->stdinpath, O_RDONLY|O_NOCTTY);
1682 if (sifd == -1) {
1683 job_log_error(j, LOG_WARNING, "open(\"%s\", ...)", j->stdinpath);
1684 } else {
1685 launchd_assumes(dup2(sifd, STDIN_FILENO) != -1);
1686 launchd_assumes(close(sifd) == 0);
1687 }
1688 }
1689 if (j->stdoutpath) {
1690 int sofd = open(j->stdoutpath, O_WRONLY|O_APPEND|O_CREAT|O_NOCTTY, DEFFILEMODE);
1691 if (sofd == -1) {
1692 job_log_error(j, LOG_WARNING, "open(\"%s\", ...)", j->stdoutpath);
1693 } else {
1694 launchd_assumes(dup2(sofd, STDOUT_FILENO) != -1);
1695 launchd_assumes(close(sofd) == 0);
1696 }
1697 }
1698 if (j->stderrpath) {
1699 int sefd = open(j->stderrpath, O_WRONLY|O_APPEND|O_CREAT|O_NOCTTY, DEFFILEMODE);
1700 if (sefd == -1) {
1701 job_log_error(j, LOG_WARNING, "open(\"%s\", ...)", j->stderrpath);
1702 } else {
1703 launchd_assumes(dup2(sefd, STDERR_FILENO) != -1);
1704 launchd_assumes(close(sefd) == 0);
1705 }
1706 }
1707
1708 job_setup_env_from_other_jobs(root_job);
1709
1710 SLIST_FOREACH(ei, &j->env, sle)
1711 setenv(ei->key, ei->value, 1);
1712
1713 setsid();
1714 }
1715
1716 int
1717 dir_has_files(const char *path)
1718 {
1719 DIR *dd = opendir(path);
1720 struct dirent *de;
1721 bool r = 0;
1722
1723 if (!dd)
1724 return -1;
1725
1726 while ((de = readdir(dd))) {
1727 if (strcmp(de->d_name, ".") && strcmp(de->d_name, "..")) {
1728 r = 1;
1729 break;
1730 }
1731 }
1732
1733 launchd_assumes(closedir(dd) == 0);
1734 return r;
1735 }
1736
1737 void
1738 calendarinterval_setalarm(struct jobcb *j, struct calendarinterval *ci)
1739 {
1740 time_t later;
1741
1742 later = cronemu(ci->when.tm_mon, ci->when.tm_mday, ci->when.tm_hour, ci->when.tm_min);
1743
1744 if (ci->when.tm_wday != -1) {
1745 time_t otherlater = cronemu_wday(ci->when.tm_wday, ci->when.tm_hour, ci->when.tm_min);
1746
1747 if (ci->when.tm_mday == -1) {
1748 later = otherlater;
1749 } else {
1750 later = later < otherlater ? later : otherlater;
1751 }
1752 }
1753
1754 if (-1 == kevent_mod((uintptr_t)ci, EVFILT_TIMER, EV_ADD, NOTE_ABSOLUTE|NOTE_SECONDS, later, j)) {
1755 job_log_error(j, LOG_ERR, "adding kevent alarm");
1756 } else {
1757 job_log(j, LOG_INFO, "scheduled to run again at %s", ctime(&later));
1758 }
1759 }
1760
1761 size_t
1762 job_prep_log_preface(struct jobcb *j, char *buf)
1763 {
1764 size_t lsz = strlen(j->label);
1765 char newlabel[lsz * 2 + 1];
1766 size_t i, o, r = 0;
1767
1768 for (i = 0, o = 0; i < lsz; i++, o++) {
1769 if (j->label[i] == '%') {
1770 newlabel[o] = '%';
1771 o++;
1772 newlabel[o] = '%';
1773 } else {
1774 newlabel[o] = j->label[i];
1775 }
1776 }
1777 newlabel[o] = '\0';
1778
1779 if (j->parent)
1780 r = job_prep_log_preface(j->parent, buf);
1781
1782 return r + sprintf(buf + r, "%s%s", j->parent ? "/" : "", newlabel);
1783 }
1784
1785 void
1786 job_log_error(struct jobcb *j, int pri, const char *msg, ...)
1787 {
1788 char newmsg[10000];
1789 va_list ap;
1790 size_t o;
1791
1792 o = job_prep_log_preface(j, newmsg);
1793
1794 sprintf(newmsg + o, ": %s: %s", msg, strerror(errno));
1795
1796 va_start(ap, msg);
1797 vsyslog(pri, newmsg, ap);
1798 va_end(ap);
1799 }
1800
1801 void
1802 job_log(struct jobcb *j, int pri, const char *msg, ...)
1803 {
1804 char newmsg[10000];
1805 va_list ap;
1806 size_t o;
1807
1808 o = job_prep_log_preface(j, newmsg);
1809
1810 sprintf(newmsg + o, ": %s", msg);
1811
1812 va_start(ap, msg);
1813 vsyslog(pri, newmsg, ap);
1814 va_end(ap);
1815 }
1816
1817 bool
1818 watchpath_new(struct jobcb *j, const char *name, bool qdir)
1819 {
1820 struct watchpath *wp = calloc(1, sizeof(struct watchpath) + strlen(name) + 1);
1821
1822 if (!launchd_assumes(wp != NULL))
1823 return false;
1824
1825 wp->is_qdir = qdir;
1826
1827 wp->fd = -1; /* watchpath_watch() will open this */
1828
1829 strcpy(wp->name, name);
1830
1831 SLIST_INSERT_HEAD(&j->vnodes, wp, sle);
1832
1833 return true;
1834 }
1835
1836 void
1837 watchpath_delete(struct jobcb *j, struct watchpath *wp)
1838 {
1839 if (wp->fd != -1)
1840 launchd_assumes(close(wp->fd) != -1);
1841
1842 SLIST_REMOVE(&j->vnodes, wp, watchpath, sle);
1843
1844 free(wp);
1845 }
1846
1847 void
1848 watchpath_ignore(struct jobcb *j, struct watchpath *wp)
1849 {
1850 if (wp->fd != -1) {
1851 job_log(j, LOG_DEBUG, "Ignoring Vnode: %d", wp->fd);
1852 launchd_assumes(kevent_mod(wp->fd, EVFILT_VNODE, EV_DELETE, 0, 0, NULL) != -1);
1853 }
1854 }
1855
1856 void
1857 watchpath_watch(struct jobcb *j, struct watchpath *wp)
1858 {
1859 int fflags = NOTE_WRITE|NOTE_EXTEND|NOTE_ATTRIB|NOTE_LINK;
1860 int qdir_file_cnt;
1861
1862 if (!wp->is_qdir)
1863 fflags |= NOTE_DELETE|NOTE_RENAME|NOTE_REVOKE;
1864
1865 if (wp->fd == -1)
1866 wp->fd = _fd(open(wp->name, O_EVTONLY|O_NOCTTY|O_NOFOLLOW));
1867
1868 if (wp->fd == -1)
1869 return job_log_error(j, LOG_ERR, "Watchpath monitoring failed on \"%s\"", wp->name);
1870
1871 job_log(j, LOG_DEBUG, "Watching Vnode: %d", wp->fd);
1872 launchd_assumes(kevent_mod(wp->fd, EVFILT_VNODE, EV_ADD|EV_CLEAR, fflags, 0, j) != -1);
1873
1874 if (!wp->is_qdir)
1875 return;
1876
1877 if (-1 == (qdir_file_cnt = dir_has_files(wp->name))) {
1878 job_log_error(j, LOG_ERR, "dir_has_files(\"%s\", ...)", wp->name);
1879 } else if (qdir_file_cnt > 0) {
1880 job_start(j);
1881 }
1882 }
1883
1884 void
1885 watchpath_callback(struct jobcb *j, struct kevent *kev)
1886 {
1887 struct watchpath *wp;
1888 int dir_file_cnt;
1889
1890 SLIST_FOREACH(wp, &j->vnodes, sle) {
1891 if (wp->fd == (int)kev->ident)
1892 break;
1893 }
1894
1895 launchd_assumes(wp != NULL);
1896
1897 if ((NOTE_DELETE|NOTE_RENAME|NOTE_REVOKE) & kev->fflags) {
1898 job_log(j, LOG_DEBUG, "Path invalidated: %s", wp->name);
1899 launchd_assumes(close(wp->fd) == 0);
1900 wp->fd = -1; /* this will get fixed in watchpath_watch() */
1901 } else if (!wp->is_qdir) {
1902 job_log(j, LOG_DEBUG, "Watch path modified: %s", wp->name);
1903 } else {
1904 job_log(j, LOG_DEBUG, "Queue directory modified: %s", wp->name);
1905
1906 if (-1 == (dir_file_cnt = dir_has_files(wp->name))) {
1907 job_log_error(j, LOG_ERR, "dir_has_files(\"%s\", ...)", wp->name);
1908 } else if (0 == dir_file_cnt) {
1909 job_log(j, LOG_DEBUG, "Spurious wake up, directory is empty again: %s", wp->name);
1910 return;
1911 }
1912 }
1913
1914 job_start(j);
1915 }
1916
1917 bool
1918 calendarinterval_new_from_obj(struct jobcb *j, launch_data_t obj)
1919 {
1920 launch_data_t tmp_k;
1921 struct tm tmptm;
1922
1923 memset(&tmptm, 0, sizeof(0));
1924
1925 tmptm.tm_min = -1;
1926 tmptm.tm_hour = -1;
1927 tmptm.tm_mday = -1;
1928 tmptm.tm_wday = -1;
1929 tmptm.tm_mon = -1;
1930
1931 if (LAUNCH_DATA_DICTIONARY != launch_data_get_type(obj))
1932 return false;
1933
1934 if ((tmp_k = launch_data_dict_lookup(obj, LAUNCH_JOBKEY_CAL_MINUTE)))
1935 tmptm.tm_min = launch_data_get_integer(tmp_k);
1936 if ((tmp_k = launch_data_dict_lookup(obj, LAUNCH_JOBKEY_CAL_HOUR)))
1937 tmptm.tm_hour = launch_data_get_integer(tmp_k);
1938 if ((tmp_k = launch_data_dict_lookup(obj, LAUNCH_JOBKEY_CAL_DAY)))
1939 tmptm.tm_mday = launch_data_get_integer(tmp_k);
1940 if ((tmp_k = launch_data_dict_lookup(obj, LAUNCH_JOBKEY_CAL_WEEKDAY)))
1941 tmptm.tm_wday = launch_data_get_integer(tmp_k);
1942 if ((tmp_k = launch_data_dict_lookup(obj, LAUNCH_JOBKEY_CAL_MONTH)))
1943 tmptm.tm_mon = launch_data_get_integer(tmp_k);
1944
1945 return calendarinterval_new(j, &tmptm);
1946 }
1947
1948 bool
1949 calendarinterval_new(struct jobcb *j, struct tm *w)
1950 {
1951 struct calendarinterval *ci = calloc(1, sizeof(struct calendarinterval));
1952
1953 if (!launchd_assumes(ci != NULL))
1954 return false;
1955
1956 ci->when = *w;
1957
1958 SLIST_INSERT_HEAD(&j->cal_intervals, ci, sle);
1959
1960 calendarinterval_setalarm(j, ci);
1961
1962 return true;
1963 }
1964
1965 void
1966 calendarinterval_delete(struct jobcb *j, struct calendarinterval *ci)
1967 {
1968 launchd_assumes(kevent_mod((uintptr_t)ci, EVFILT_TIMER, EV_DELETE, 0, 0, NULL) != -1);
1969
1970 SLIST_REMOVE(&j->cal_intervals, ci, calendarinterval, sle);
1971
1972 free(ci);
1973 }
1974
1975 void
1976 calendarinterval_callback(struct jobcb *j, struct kevent *kev)
1977 {
1978 struct calendarinterval *ci;
1979
1980 SLIST_FOREACH(ci, &j->cal_intervals, sle) {
1981 if ((uintptr_t)ci == kev->ident)
1982 break;
1983 }
1984
1985 if (launchd_assumes(ci != NULL)) {
1986 calendarinterval_setalarm(j, ci);
1987 job_start(j);
1988 }
1989 }
1990
1991 bool
1992 socketgroup_new(struct jobcb *j, const char *name, int *fds, unsigned int fd_cnt, bool junkfds)
1993 {
1994 struct socketgroup *sg = calloc(1, sizeof(struct socketgroup) + strlen(name) + 1);
1995
1996 if (!launchd_assumes(sg != NULL))
1997 return false;
1998
1999 sg->fds = calloc(1, fd_cnt * sizeof(int));
2000 sg->fd_cnt = fd_cnt;
2001 sg->junkfds = junkfds;
2002
2003 if (!launchd_assumes(sg->fds != NULL)) {
2004 free(sg);
2005 return false;
2006 }
2007
2008 memcpy(sg->fds, fds, fd_cnt * sizeof(int));
2009 strcpy(sg->name, name);
2010
2011 SLIST_INSERT_HEAD(&j->sockets, sg, sle);
2012
2013 return true;
2014 }
2015
2016 void
2017 socketgroup_delete(struct jobcb *j, struct socketgroup *sg)
2018 {
2019 unsigned int i;
2020
2021 for (i = 0; i < sg->fd_cnt; i++)
2022 launchd_assumes(close(sg->fds[i]) != -1);
2023
2024 SLIST_REMOVE(&j->sockets, sg, socketgroup, sle);
2025
2026 free(sg->fds);
2027 free(sg);
2028 }
2029
2030 void
2031 socketgroup_ignore(struct jobcb *j, struct socketgroup *sg)
2032 {
2033 char buf[10000];
2034 unsigned int i, buf_off = 0;
2035
2036 if (sg->junkfds)
2037 return;
2038
2039 for (i = 0; i < sg->fd_cnt; i++)
2040 buf_off += sprintf(buf + buf_off, " %d", sg->fds[i]);
2041
2042 job_log(j, LOG_DEBUG, "Ignoring Sockets:%s", buf);
2043
2044 for (i = 0; i < sg->fd_cnt; i++)
2045 launchd_assumes(kevent_mod(sg->fds[i], EVFILT_READ, EV_DELETE, 0, 0, NULL) != -1);
2046 }
2047
2048 void
2049 socketgroup_watch(struct jobcb *j, struct socketgroup *sg)
2050 {
2051 char buf[10000];
2052 unsigned int i, buf_off = 0;
2053
2054 if (sg->junkfds)
2055 return;
2056
2057 for (i = 0; i < sg->fd_cnt; i++)
2058 buf_off += sprintf(buf + buf_off, " %d", sg->fds[i]);
2059
2060 job_log(j, LOG_DEBUG, "Watching sockets:%s", buf);
2061
2062 for (i = 0; i < sg->fd_cnt; i++)
2063 launchd_assumes(kevent_mod(sg->fds[i], EVFILT_READ, EV_ADD, 0, 0, j) != -1);
2064 }
2065
2066 void
2067 socketgroup_callback(struct jobcb *j, struct kevent *kev)
2068 {
2069 job_start(j);
2070 }
2071
2072 bool
2073 envitem_new(struct jobcb *j, const char *k, const char *v, bool global)
2074 {
2075 struct envitem *ei = calloc(1, sizeof(struct envitem) + strlen(k) + 1 + strlen(v) + 1);
2076
2077 if (!launchd_assumes(ei != NULL))
2078 return false;
2079
2080 strcpy(ei->key, k);
2081 ei->value = ei->key + strlen(k) + 1;
2082 strcpy(ei->value, v);
2083
2084 if (global) {
2085 SLIST_INSERT_HEAD(&j->global_env, ei, sle);
2086 } else {
2087 SLIST_INSERT_HEAD(&j->env, ei, sle);
2088 }
2089
2090 return true;
2091 }
2092
2093 void
2094 envitem_delete(struct jobcb *j, struct envitem *ei, bool global)
2095 {
2096 if (global) {
2097 SLIST_REMOVE(&j->global_env, ei, envitem, sle);
2098 } else {
2099 SLIST_REMOVE(&j->env, ei, envitem, sle);
2100 }
2101
2102 free(ei);
2103 }
2104
2105 void
2106 envitem_setup(launch_data_t obj, const char *key, void *context)
2107 {
2108 struct jobcb *j = context;
2109
2110 if (launch_data_get_type(obj) != LAUNCH_DATA_STRING)
2111 return;
2112
2113 envitem_new(j, key, launch_data_get_string(obj), j->importing_global_env);
2114 }
2115
2116 bool
2117 limititem_update(struct jobcb *j, int w, rlim_t r)
2118 {
2119 struct limititem *li;
2120
2121 SLIST_FOREACH(li, &j->limits, sle) {
2122 if (li->which == w)
2123 break;
2124 }
2125
2126 if (li == NULL) {
2127 li = calloc(1, sizeof(struct limititem));
2128
2129 if (!launchd_assumes(li != NULL))
2130 return false;
2131
2132 li->which = w;
2133 }
2134
2135 if (j->importing_hard_limits) {
2136 li->lim.rlim_max = r;
2137 li->sethard = true;
2138 } else {
2139 li->lim.rlim_cur = r;
2140 li->setsoft = true;
2141 }
2142
2143 return true;
2144 }
2145
2146 void
2147 limititem_delete(struct jobcb *j, struct limititem *li)
2148 {
2149 SLIST_REMOVE(&j->limits, li, limititem, sle);
2150
2151 free(li);
2152 }
2153
2154 void
2155 limititem_setup(launch_data_t obj, const char *key, void *context)
2156 {
2157 struct jobcb *j = context;
2158 int i, limits_cnt = (sizeof(launchd_keys2limits) / sizeof(launchd_keys2limits[0]));
2159 rlim_t rl;
2160
2161 if (launch_data_get_type(obj) != LAUNCH_DATA_INTEGER)
2162 return;
2163
2164 rl = launch_data_get_integer(obj);
2165
2166 for (i = 0; i < limits_cnt; i++) {
2167 if (strcasecmp(launchd_keys2limits[i].key, key) == 0)
2168 break;
2169 }
2170
2171 if (i == limits_cnt)
2172 return;
2173
2174 limititem_update(j, launchd_keys2limits[i].val, rl);
2175 }
2176
2177 bool
2178 job_useless(struct jobcb *j)
2179 {
2180 if (j->unload_at_exit) {
2181 job_log(j, LOG_INFO, "Exited. Was only configured to run once.");
2182 return true;
2183 } else if (shutdown_in_progress) {
2184 job_log(j, LOG_INFO, "Exited while shutdown in progress.");
2185 return true;
2186 } else if (j->failed_exits >= LAUNCHD_FAILED_EXITS_THRESHOLD) {
2187 job_log(j, LOG_WARNING, "too many failures in succession");
2188 return true;
2189 } else if (!j->checkedin && (!SLIST_EMPTY(&j->sockets) || !SLIST_EMPTY(&j->machservices))) {
2190 job_log(j, LOG_WARNING, "Failed to check-in!");
2191 return true;
2192 } else if (j->legacy_mach_job && SLIST_EMPTY(&j->machservices)) {
2193 job_log(j, LOG_INFO, "Garbage collecting");
2194 return true;
2195 }
2196
2197 return false;
2198 }
2199
2200 bool
2201 job_keepalive(struct jobcb *j)
2202 {
2203 mach_msg_type_number_t statusCnt;
2204 mach_port_status_t status;
2205 struct semaphoreitem *si;
2206 struct machservice *ms;
2207 struct stat sb;
2208 bool good_exit = (WIFEXITED(j->last_exit_status) && WEXITSTATUS(j->last_exit_status) == 0);
2209 bool dispatch_others = false;
2210
2211 if (j->runatload && j->start_time == 0) {
2212 job_log(j, LOG_DEBUG, "KeepAlive check: job needs to run at least once.");
2213 return true;
2214 }
2215
2216 if (!j->ondemand) {
2217 job_log(j, LOG_DEBUG, "KeepAlive check: job configured to run continuously.");
2218 return true;
2219 }
2220
2221 SLIST_FOREACH(ms, &j->machservices, sle) {
2222 statusCnt = MACH_PORT_RECEIVE_STATUS_COUNT;
2223 if (mach_port_get_attributes(mach_task_self(), ms->port, MACH_PORT_RECEIVE_STATUS,
2224 (mach_port_info_t)&status, &statusCnt) != KERN_SUCCESS)
2225 continue;
2226 if (status.mps_msgcount) {
2227 job_log(j, LOG_DEBUG, "KeepAlive check: job restarted due to %d queued Mach messages on service: %s",
2228 status.mps_msgcount, ms->name);
2229 return true;
2230 }
2231 }
2232
2233
2234 SLIST_FOREACH(si, &j->semaphores, sle) {
2235 bool wanted_state = false;
2236 switch (si->why) {
2237 case NETWORK_UP:
2238 wanted_state = true;
2239 case NETWORK_DOWN:
2240 if (network_up == wanted_state) {
2241 job_log(j, LOG_DEBUG, "KeepAlive check: job configured to run while the network is %s.",
2242 wanted_state ? "up" : "down");
2243 return true;
2244 }
2245 break;
2246 case SUCCESSFUL_EXIT:
2247 wanted_state = true;
2248 case FAILED_EXIT:
2249 if (good_exit == wanted_state) {
2250 job_log(j, LOG_DEBUG, "KeepAlive check: job configured to run while the exit state was %s.",
2251 wanted_state ? "successful" : "failure");
2252 return true;
2253 }
2254 break;
2255 case PATH_EXISTS:
2256 wanted_state = true;
2257 case PATH_MISSING:
2258 if ((bool)(stat(si->what, &sb) == 0) == wanted_state) {
2259 job_log(j, LOG_DEBUG, "KeepAlive check: job configured to run while the following path %s: %s",
2260 wanted_state ? "exists" : "is missing", si->what);
2261 return true;
2262 }
2263 dispatch_others = true;
2264 break;
2265 }
2266 }
2267
2268 /* Maybe another job has the inverse path based semaphore as this job */
2269 if (dispatch_others)
2270 job_dispatch_all_other_semaphores(root_job, j);
2271
2272 return false;
2273 }
2274
2275 const char *
2276 job_prog(struct jobcb *j)
2277 {
2278 if (j->prog) {
2279 return j->prog;
2280 } else if (j->argv) {
2281 return j->argv[0];
2282 } else {
2283 return "";
2284 }
2285 }
2286
2287 bool
2288 job_active(struct jobcb *j)
2289 {
2290 struct machservice *ms;
2291
2292 if (j->req_port)
2293 return true;
2294
2295 if (j->p)
2296 return true;
2297
2298 if (j->priv_port_has_senders) {
2299 if (j->start_time && !j->checkedin) {
2300 if (j->legacy_mach_job) {
2301 job_log(j, LOG_NOTICE, "Daemonized. Extremely expensive no-op.");
2302 } else if (!j->unload_at_exit) {
2303 job_log(j, LOG_ERR, "Daemonization is not supported under launchd.");
2304 return false;
2305 }
2306 }
2307 return true;
2308 }
2309
2310 SLIST_FOREACH(ms, &j->machservices, sle) {
2311 if (ms->isActive)
2312 return true;
2313 }
2314
2315 return false;
2316 }
2317
2318 pid_t
2319 launchd_fork(void)
2320 {
2321 return job_fork(root_job);
2322 }
2323
2324 pid_t
2325 job_fork(struct jobcb *j)
2326 {
2327 mach_port_t p = j->bs_port;
2328 pid_t r = -1;
2329
2330 sigprocmask(SIG_BLOCK, &blocked_signals, NULL);
2331
2332 launchd_assumes(launchd_mport_make_send(p) == KERN_SUCCESS);
2333 launchd_assumes(launchd_set_bport(p) == KERN_SUCCESS);
2334 launchd_assumes(launchd_mport_deallocate(p) == KERN_SUCCESS);
2335
2336 r = fork();
2337
2338 if (r != 0) {
2339 launchd_assumes(launchd_set_bport(MACH_PORT_NULL) == KERN_SUCCESS);
2340 } else if (r == 0) {
2341 size_t i;
2342
2343 for (i = 0; i < NSIG; i++) {
2344 if (sigismember(&blocked_signals, i))
2345 signal(i, SIG_DFL);
2346 }
2347 }
2348
2349 sigprocmask(SIG_UNBLOCK, &blocked_signals, NULL);
2350
2351 return r;
2352 }
2353
2354 void
2355 machservice_resetport(struct jobcb *j, struct machservice *ms)
2356 {
2357 launchd_assumes(launchd_mport_close_recv(ms->port) == KERN_SUCCESS);
2358 launchd_assumes(launchd_mport_deallocate(ms->port) == KERN_SUCCESS);
2359 launchd_assumes(launchd_mport_create_recv(&ms->port) == KERN_SUCCESS);
2360 launchd_assumes(launchd_mport_make_send(ms->port) == KERN_SUCCESS);
2361 }
2362
2363 struct machservice *
2364 machservice_new(struct jobcb *j, const char *name, mach_port_t *serviceport)
2365 {
2366 struct machservice *ms;
2367
2368 if ((ms = calloc(1, sizeof(struct machservice) + strlen(name) + 1)) == NULL)
2369 return NULL;
2370
2371 strcpy(ms->name, name);
2372 ms->job = j;
2373
2374 if (*serviceport == MACH_PORT_NULL) {
2375 if (!launchd_assumes(launchd_mport_create_recv(&ms->port) == KERN_SUCCESS))
2376 goto out_bad;
2377
2378 if (!launchd_assumes(launchd_mport_make_send(ms->port) == KERN_SUCCESS))
2379 goto out_bad2;
2380 *serviceport = ms->port;
2381 ms->isActive = false;
2382 ms->recv = true;
2383 } else {
2384 ms->port = *serviceport;
2385 ms->isActive = true;
2386 }
2387
2388 SLIST_INSERT_HEAD(&j->machservices, ms, sle);
2389
2390 job_log(j, LOG_INFO, "Mach service added: %s", name);
2391
2392 return ms;
2393 out_bad2:
2394 launchd_assumes(launchd_mport_close_recv(ms->port) == KERN_SUCCESS);
2395 out_bad:
2396 free(ms);
2397 return NULL;
2398 }
2399
2400 bootstrap_status_t
2401 machservice_status(struct machservice *ms)
2402 {
2403 if (ms->isActive) {
2404 return BOOTSTRAP_STATUS_ACTIVE;
2405 } else if (ms->job->ondemand) {
2406 return BOOTSTRAP_STATUS_ON_DEMAND;
2407 } else {
2408 return BOOTSTRAP_STATUS_INACTIVE;
2409 }
2410 }
2411
2412 void
2413 machservice_setup_options(launch_data_t obj, const char *key, void *context)
2414 {
2415 struct machservice *ms = context;
2416 mach_port_t mhp = mach_host_self();
2417 mach_port_t mts = mach_task_self();
2418 thread_state_flavor_t f = 0;
2419 int which_port;
2420 bool b;
2421
2422 #if defined (__ppc__)
2423 f = PPC_THREAD_STATE64;
2424 #elif defined(__i386__)
2425 f = x86_THREAD_STATE;
2426 #endif
2427
2428 if (!launchd_assumes(mhp != MACH_PORT_NULL)) {
2429 return;
2430 }
2431
2432 switch (launch_data_get_type(obj)) {
2433 case LAUNCH_DATA_INTEGER:
2434 which_port = launch_data_get_integer(obj);
2435 if (strcasecmp(key, LAUNCH_JOBKEY_MACH_TASKSPECIALPORT) == 0) {
2436 launchd_assumes((errno = task_set_special_port(mts, which_port, ms->port)) == KERN_SUCCESS);
2437 } else if (strcasecmp(key, LAUNCH_JOBKEY_MACH_HOSTSPECIALPORT) == 0 && getpid() == 1) {
2438 launchd_assumes((errno = host_set_special_port(mhp, which_port, ms->port)) == KERN_SUCCESS);
2439 }
2440 case LAUNCH_DATA_BOOL:
2441 b = launch_data_get_bool(obj);
2442 if (strcasecmp(key, LAUNCH_JOBKEY_MACH_RESETATCLOSE) == 0) {
2443 ms->reset = b;
2444 } else if (strcasecmp(key, LAUNCH_JOBKEY_MACH_HIDEUNTILCHECKIN) == 0) {
2445 ms->hide = b;
2446 } else if (strcasecmp(key, LAUNCH_JOBKEY_MACH_EXCEPTIONSERVER) == 0) {
2447 launchd_assumes(task_set_exception_ports(mts, EXC_MASK_ALL, ms->port,
2448 EXCEPTION_STATE_IDENTITY, f) == KERN_SUCCESS);
2449 } else if (strcasecmp(key, LAUNCH_JOBKEY_MACH_KUNCSERVER) == 0) {
2450 ms->kUNCServer = b;
2451 launchd_assumes(host_set_UNDServer(mhp, ms->port) == KERN_SUCCESS);
2452 }
2453 break;
2454 default:
2455 break;
2456 }
2457
2458 launchd_assumes(launchd_mport_deallocate(mhp) == KERN_SUCCESS);
2459 }
2460
2461 void
2462 machservice_setup(launch_data_t obj, const char *key, void *context)
2463 {
2464 struct jobcb *j = context;
2465 struct machservice *ms;
2466 mach_port_t p = MACH_PORT_NULL;
2467
2468 if ((ms = job_lookup_service(j->parent, key, false))) {
2469 job_log(j, LOG_WARNING, "Conflict with job: %s over Mach service: %s", ms->job->label, key);
2470 return;
2471 }
2472
2473 if ((ms = machservice_new(j, key, &p)) == NULL) {
2474 job_log_error(j, LOG_WARNING, "Cannot add service: %s", key);
2475 return;
2476 }
2477
2478 ms->isActive = false;
2479
2480 if (launch_data_get_type(obj) == LAUNCH_DATA_DICTIONARY) {
2481 launch_data_dict_iterate(obj, machservice_setup_options, ms);
2482 }
2483 }
2484
2485 struct jobcb *
2486 job_parent(struct jobcb *j)
2487 {
2488 return j->parent;
2489 }
2490
2491 void
2492 job_uncork_fork(struct jobcb *j)
2493 {
2494 pid_t c = j->p;
2495
2496 if (j->stall_before_exec) {
2497 job_log(j, LOG_DEBUG, "Uncorking the fork().");
2498 /* this unblocks the child and avoids a race
2499 * between the above fork() and the kevent_mod() */
2500 write(j->execfd, &c, sizeof(c));
2501 j->stall_before_exec = false;
2502 } else {
2503 job_log(j, LOG_WARNING, "Attempt to uncork a job that isn't in the middle of a fork().");
2504 }
2505 }
2506
2507 void
2508 job_foreach_service(struct jobcb *j, void (*bs_iter)(struct machservice *, void *), void *context, bool include_subjobs)
2509 {
2510 struct machservice *ms;
2511 struct jobcb *ji;
2512
2513 j = job_get_bs(j);
2514
2515 if (include_subjobs) {
2516 SLIST_FOREACH(ji, &j->jobs, sle) {
2517 if (ji->req_port)
2518 continue;
2519
2520 SLIST_FOREACH(ms, &ji->machservices, sle)
2521 bs_iter(ms, context);
2522 }
2523 }
2524
2525 SLIST_FOREACH(ms, &j->machservices, sle)
2526 bs_iter(ms, context);
2527 }
2528
2529 struct jobcb *
2530 job_new_bootstrap(struct jobcb *p, mach_port_t requestorport, mach_port_t checkin_port)
2531 {
2532 char bslabel[1024] = "100000";
2533 struct jobcb *j;
2534
2535 if (requestorport == MACH_PORT_NULL) {
2536 if (p) {
2537 job_log(p, LOG_ERR, "Mach sub-bootstrap create request requires a requester port");
2538 }
2539 return NULL;
2540 }
2541
2542 j = job_new(p, bslabel, NULL, NULL, NULL, requestorport);
2543
2544 if (j == NULL)
2545 return NULL;
2546
2547 if (checkin_port != MACH_PORT_NULL) {
2548 j->bs_port = checkin_port;
2549 } else if (!launchd_assumes(launchd_mport_create_recv(&j->bs_port) == KERN_SUCCESS)) {
2550 goto out_bad;
2551 }
2552
2553 sprintf(j->label, "%d", MACH_PORT_INDEX(j->bs_port));
2554
2555 if (!launchd_assumes(launchd_mport_request_callback(j->bs_port, j, true) == KERN_SUCCESS))
2556 goto out_bad;
2557
2558 if (p) {
2559 job_log(p, LOG_DEBUG, "Mach sub-bootstrap created: %s", j->label);
2560 }
2561
2562 return j;
2563
2564 out_bad:
2565 if (j)
2566 job_remove(j);
2567 return NULL;
2568 }
2569
2570 void
2571 job_delete_anything_with_port(struct jobcb *j, mach_port_t port)
2572 {
2573 struct machservice *ms, *next_ms;
2574 struct jobcb *ji, *jn;
2575
2576 /* Mach ports, unlike Unix descriptors, are reference counted. In other
2577 * words, when some program hands us a second or subsequent send right
2578 * to a port we already have open, the Mach kernel gives us the same
2579 * port number back and increments an reference count associated with
2580 * the port. This forces us, when discovering that a receive right at
2581 * the other end has been deleted, to wander all of our objects to see
2582 * what weird places clients might have handed us the same send right
2583 * to use.
2584 */
2585
2586 if (j->req_port == port)
2587 return job_remove(j);
2588
2589 SLIST_FOREACH_SAFE(ji, &j->jobs, sle, jn)
2590 job_delete_anything_with_port(ji, port);
2591
2592 SLIST_FOREACH_SAFE(ms, &j->machservices, sle, next_ms) {
2593 if (ms->port == port)
2594 machservice_delete(ms);
2595 }
2596 }
2597
2598 struct machservice *
2599 job_lookup_service(struct jobcb *j, const char *name, bool check_parent)
2600 {
2601 struct machservice *ms;
2602 struct jobcb *ji;
2603
2604 j = job_get_bs(j);
2605
2606 SLIST_FOREACH(ji, &j->jobs, sle) {
2607 if (ji->req_port)
2608 continue;
2609
2610 SLIST_FOREACH(ms, &ji->machservices, sle) {
2611 if (strcmp(name, ms->name) == 0)
2612 return ms;
2613 }
2614 }
2615
2616 SLIST_FOREACH(ms, &j->machservices, sle) {
2617 if (strcmp(name, ms->name) == 0)
2618 return ms;
2619 }
2620
2621 if (j->parent == NULL)
2622 return NULL;
2623
2624 if (!check_parent)
2625 return NULL;
2626
2627 return job_lookup_service(j->parent, name, true);
2628 }
2629
2630 mach_port_t
2631 machservice_port(struct machservice *ms)
2632 {
2633 return ms->port;
2634 }
2635
2636 struct jobcb *
2637 machservice_job(struct machservice *ms)
2638 {
2639 return ms->job;
2640 }
2641
2642 bool
2643 machservice_hidden(struct machservice *ms)
2644 {
2645 return ms->hide;
2646 }
2647
2648 bool
2649 machservice_active(struct machservice *ms)
2650 {
2651 return ms->isActive;
2652 }
2653
2654 const char *
2655 machservice_name(struct machservice *ms)
2656 {
2657 return ms->name;
2658 }
2659
2660 void
2661 machservice_delete(struct machservice *ms)
2662 {
2663 if (ms->recv) {
2664 if (ms->isActive) {
2665 /* FIXME we should cancel the notification */
2666 } else {
2667 launchd_assumes(launchd_mport_close_recv(ms->port) == KERN_SUCCESS);
2668 }
2669 }
2670
2671 launchd_assumes(launchd_mport_deallocate(ms->port) == KERN_SUCCESS);
2672
2673 job_log(ms->job, LOG_INFO, "Mach service deleted: %s", ms->name);
2674
2675 SLIST_REMOVE(&ms->job->machservices, ms, machservice, sle);
2676
2677 free(ms);
2678 }
2679
2680 void
2681 machservice_watch(struct machservice *ms)
2682 {
2683 mach_msg_id_t which = MACH_NOTIFY_DEAD_NAME;
2684
2685 ms->isActive = true;
2686
2687 if (ms->job->req_port == MACH_PORT_NULL) {
2688 which = MACH_NOTIFY_PORT_DESTROYED;
2689 job_checkin(ms->job);
2690 }
2691
2692 launchd_assumes(launchd_mport_notify_req(ms->port, which) == KERN_SUCCESS);
2693 }
2694
2695 #define NELEM(x) (sizeof(x)/sizeof(x[0]))
2696 #define END_OF(x) (&(x)[NELEM(x)])
2697
2698 char **
2699 mach_cmd2argv(const char *string)
2700 {
2701 char *argv[100], args[1000];
2702 const char *cp;
2703 char *argp = args, term, **argv_ret, *co;
2704 unsigned int nargs = 0, i;
2705
2706 for (cp = string; *cp;) {
2707 while (isspace(*cp))
2708 cp++;
2709 term = (*cp == '"') ? *cp++ : '\0';
2710 if (nargs < NELEM(argv))
2711 argv[nargs++] = argp;
2712 while (*cp && (term ? *cp != term : !isspace(*cp)) && argp < END_OF(args)) {
2713 if (*cp == '\\')
2714 cp++;
2715 *argp++ = *cp;
2716 if (*cp)
2717 cp++;
2718 }
2719 *argp++ = '\0';
2720 }
2721 argv[nargs] = NULL;
2722
2723 if (nargs == 0)
2724 return NULL;
2725
2726 argv_ret = malloc((nargs + 1) * sizeof(char *) + strlen(string) + 1);
2727
2728 if (!launchd_assumes(argv_ret != NULL))
2729 return NULL;
2730
2731 co = (char *)argv_ret + (nargs + 1) * sizeof(char *);
2732
2733 for (i = 0; i < nargs; i++) {
2734 strcpy(co, argv[i]);
2735 argv_ret[i] = co;
2736 co += strlen(argv[i]) + 1;
2737 }
2738 argv_ret[i] = NULL;
2739
2740 return argv_ret;
2741 }
2742
2743 void
2744 job_checkin(struct jobcb *j)
2745 {
2746 j->checkedin = true;
2747 }
2748
2749 bool
2750 job_ack_port_destruction(struct jobcb *j, mach_port_t p)
2751 {
2752 struct jobcb *ji;
2753 struct machservice *ms;
2754
2755 SLIST_FOREACH(ji, &j->jobs, sle) {
2756 if (job_ack_port_destruction(ji, p))
2757 return true;
2758 }
2759
2760 SLIST_FOREACH(ms, &j->machservices, sle) {
2761 if (ms->port == p)
2762 break;
2763 }
2764
2765 if (ms == NULL)
2766 return false;
2767
2768 ms->isActive = false;
2769
2770 if (ms->reset)
2771 machservice_resetport(j, ms);
2772
2773 job_log(j, LOG_DEBUG, "Receive right returned to us: %s", ms->name);
2774
2775 job_dispatch(j);
2776
2777 return true;
2778 }
2779
2780 void
2781 job_ack_no_senders(struct jobcb *j)
2782 {
2783 j->priv_port_has_senders = false;
2784
2785 job_log(j, LOG_DEBUG, "No more senders on privileged Mach bootstrap port");
2786
2787 job_dispatch(j);
2788 }
2789
2790 mach_port_t
2791 job_get_reqport(struct jobcb *j)
2792 {
2793 j->transfer_bstrap = true;
2794 gc_this_job = j;
2795
2796 return j->req_port;
2797 }
2798
2799 mach_port_t
2800 job_get_bsport(struct jobcb *j)
2801 {
2802 return j->bs_port;
2803 }
2804
2805 struct jobcb *
2806 job_get_bs(struct jobcb *j)
2807 {
2808 if (j->req_port)
2809 return j;
2810
2811 if (launchd_assumes(j->parent != NULL))
2812 return j->parent;
2813
2814 return NULL;
2815 }
2816
2817 pid_t
2818 job_get_pid(struct jobcb *j)
2819 {
2820 return j->p;
2821 }
2822
2823 bool
2824 semaphoreitem_new(struct jobcb *j, semaphore_reason_t why, const char *what)
2825 {
2826 struct semaphoreitem *si;
2827 size_t alloc_sz = sizeof(struct semaphoreitem);
2828
2829 if (what)
2830 alloc_sz += strlen(what) + 1;
2831
2832 if (!launchd_assumes(si = calloc(1, alloc_sz)))
2833 return false;
2834
2835 si->why = why;
2836
2837 if (what)
2838 strcpy(si->what, what);
2839
2840 SLIST_INSERT_HEAD(&j->semaphores, si, sle);
2841
2842 return true;
2843 }
2844
2845 void
2846 semaphoreitem_delete(struct jobcb *j, struct semaphoreitem *ri)
2847 {
2848 SLIST_REMOVE(&j->semaphores, ri, semaphoreitem, sle);
2849
2850 free(ri);
2851 }
2852
2853 void
2854 semaphoreitem_setup_paths(launch_data_t obj, const char *key, void *context)
2855 {
2856 struct jobcb *j = context;
2857 semaphore_reason_t why;
2858
2859 why = launch_data_get_bool(obj) ? PATH_EXISTS : PATH_MISSING;
2860
2861 semaphoreitem_new(j, why, key);
2862 }
2863
2864 void
2865 semaphoreitem_setup(launch_data_t obj, const char *key, void *context)
2866 {
2867 struct jobcb *j = context;
2868 semaphore_reason_t why;
2869
2870 if (strcasecmp(key, LAUNCH_JOBKEY_KEEPALIVE_NETWORKSTATE) == 0) {
2871 why = launch_data_get_bool(obj) ? NETWORK_UP : NETWORK_DOWN;
2872 semaphoreitem_new(j, why, NULL);
2873 } else if (strcasecmp(key, LAUNCH_JOBKEY_KEEPALIVE_SUCCESSFULEXIT) == 0) {
2874 why = launch_data_get_bool(obj) ? SUCCESSFUL_EXIT : FAILED_EXIT;
2875 semaphoreitem_new(j, why, NULL);
2876 j->runatload = true;
2877 } else if (strcasecmp(key, LAUNCH_JOBKEY_KEEPALIVE_PATHSTATE) == 0 &&
2878 launch_data_get_type(obj) == LAUNCH_DATA_DICTIONARY) {
2879 launch_data_dict_iterate(obj, semaphoreitem_setup_paths, j);
2880 }
2881 }
2882
2883 void
2884 job_dispatch_all_other_semaphores(struct jobcb *j, struct jobcb *nj)
2885 {
2886 struct jobcb *ji;
2887
2888 if (j == nj)
2889 return;
2890
2891 if (!SLIST_EMPTY(&j->semaphores))
2892 job_dispatch(j);
2893
2894 SLIST_FOREACH(ji, &j->jobs, sle)
2895 job_dispatch_all_other_semaphores(ji, nj);
2896 }
2897
2898 time_t
2899 cronemu(int mon, int mday, int hour, int min)
2900 {
2901 struct tm workingtm;
2902 time_t now;
2903
2904 now = time(NULL);
2905 workingtm = *localtime(&now);
2906
2907 workingtm.tm_isdst = -1;
2908 workingtm.tm_sec = 0;
2909 workingtm.tm_min++;
2910
2911 while (!cronemu_mon(&workingtm, mon, mday, hour, min)) {
2912 workingtm.tm_year++;
2913 workingtm.tm_mon = 0;
2914 workingtm.tm_mday = 1;
2915 workingtm.tm_hour = 0;
2916 workingtm.tm_min = 0;
2917 mktime(&workingtm);
2918 }
2919
2920 return mktime(&workingtm);
2921 }
2922
2923 time_t
2924 cronemu_wday(int wday, int hour, int min)
2925 {
2926 struct tm workingtm;
2927 time_t now;
2928
2929 now = time(NULL);
2930 workingtm = *localtime(&now);
2931
2932 workingtm.tm_isdst = -1;
2933 workingtm.tm_sec = 0;
2934 workingtm.tm_min++;
2935
2936 if (wday == 7)
2937 wday = 0;
2938
2939 while (!(workingtm.tm_wday == wday && cronemu_hour(&workingtm, hour, min))) {
2940 workingtm.tm_mday++;
2941 workingtm.tm_hour = 0;
2942 workingtm.tm_min = 0;
2943 mktime(&workingtm);
2944 }
2945
2946 return mktime(&workingtm);
2947 }
2948
2949 bool
2950 cronemu_mon(struct tm *wtm, int mon, int mday, int hour, int min)
2951 {
2952 if (mon == -1) {
2953 struct tm workingtm = *wtm;
2954 int carrytest;
2955
2956 while (!cronemu_mday(&workingtm, mday, hour, min)) {
2957 workingtm.tm_mon++;
2958 workingtm.tm_mday = 1;
2959 workingtm.tm_hour = 0;
2960 workingtm.tm_min = 0;
2961 carrytest = workingtm.tm_mon;
2962 mktime(&workingtm);
2963 if (carrytest != workingtm.tm_mon)
2964 return false;
2965 }
2966 *wtm = workingtm;
2967 return true;
2968 }
2969
2970 if (mon < wtm->tm_mon)
2971 return false;
2972
2973 if (mon > wtm->tm_mon) {
2974 wtm->tm_mon = mon;
2975 wtm->tm_mday = 1;
2976 wtm->tm_hour = 0;
2977 wtm->tm_min = 0;
2978 }
2979
2980 return cronemu_mday(wtm, mday, hour, min);
2981 }
2982
2983 bool
2984 cronemu_mday(struct tm *wtm, int mday, int hour, int min)
2985 {
2986 if (mday == -1) {
2987 struct tm workingtm = *wtm;
2988 int carrytest;
2989
2990 while (!cronemu_hour(&workingtm, hour, min)) {
2991 workingtm.tm_mday++;
2992 workingtm.tm_hour = 0;
2993 workingtm.tm_min = 0;
2994 carrytest = workingtm.tm_mday;
2995 mktime(&workingtm);
2996 if (carrytest != workingtm.tm_mday)
2997 return false;
2998 }
2999 *wtm = workingtm;
3000 return true;
3001 }
3002
3003 if (mday < wtm->tm_mday)
3004 return false;
3005
3006 if (mday > wtm->tm_mday) {
3007 wtm->tm_mday = mday;
3008 wtm->tm_hour = 0;
3009 wtm->tm_min = 0;
3010 }
3011
3012 return cronemu_hour(wtm, hour, min);
3013 }
3014
3015 bool
3016 cronemu_hour(struct tm *wtm, int hour, int min)
3017 {
3018 if (hour == -1) {
3019 struct tm workingtm = *wtm;
3020 int carrytest;
3021
3022 while (!cronemu_min(&workingtm, min)) {
3023 workingtm.tm_hour++;
3024 workingtm.tm_min = 0;
3025 carrytest = workingtm.tm_hour;
3026 mktime(&workingtm);
3027 if (carrytest != workingtm.tm_hour)
3028 return false;
3029 }
3030 *wtm = workingtm;
3031 return true;
3032 }
3033
3034 if (hour < wtm->tm_hour)
3035 return false;
3036
3037 if (hour > wtm->tm_hour) {
3038 wtm->tm_hour = hour;
3039 wtm->tm_min = 0;
3040 }
3041
3042 return cronemu_min(wtm, min);
3043 }
3044
3045 bool
3046 cronemu_min(struct tm *wtm, int min)
3047 {
3048 if (min == -1)
3049 return true;
3050
3051 if (min < wtm->tm_min)
3052 return false;
3053
3054 if (min > wtm->tm_min) {
3055 wtm->tm_min = min;
3056 }
3057
3058 return true;
3059 }
mirror of launchd