syslogd.tproj/syslogd.c

   1 /*
   2  * Copyright (c) 2004-2012 Apple 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
  24 #include <TargetConditionals.h>
  25
  26 #include <assert.h>
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <unistd.h>
  30 #include <string.h>
  31 #include <mach/mach.h>
  32 #include <mach/mach_error.h>
  33 #include <mach/mach_time.h>
  34 #include <servers/bootstrap.h>
  35 #include <sys/types.h>
  36 #include <sys/socket.h>
  37 #include <sys/sysctl.h>
  38 #include <sys/stat.h>
  39 #include <sys/fcntl.h>
  40 #include <sys/errno.h>
  41 #include <sys/queue.h>
  42 #include <sys/time.h>
  43 #include <sys/un.h>
  44 #include <pthread.h>
  45 #include <dirent.h>
  46 #include <dlfcn.h>
  47 #include <libgen.h>
  48 #include <notify.h>
  49 #include <notify_keys.h>
  50 #include <utmpx.h>
  51 #include <vproc_priv.h>
  52 #include <asl_private.h>
  53 #include <pwd.h>
  54
  55 #if !TARGET_OS_IPHONE
  56 #include <quarantine.h>
  57 #endif
  58 #include "daemon.h"
  59
  60 #define SERVICE_NAME "com.apple.system.logger"
  61 #define SERVER_STATUS_ERROR -1
  62 #define SERVER_STATUS_INACTIVE 0
  63 #define SERVER_STATUS_ACTIVE 1
  64 #define SERVER_STATUS_ON_DEMAND 2
  65
  66 #define BILLION 1000000000
  67
  68 #define NOTIFY_DELAY 1
  69
  70 #define forever for(;;)
  71
  72 extern int _malloc_no_asl_log;
  73
  74 #if TARGET_IPHONE_SIMULATOR
  75 const char *_path_pidfile;
  76 const char *_path_syslogd_log;
  77 #endif
  78
  79 /* global */
  80 struct global_s global;
  81
  82 #if !TARGET_IPHONE_SIMULATOR
  83 /* Input Modules */
  84 int klog_in_init(void);
  85 int klog_in_reset(void);
  86 int klog_in_close(void);
  87 static int activate_klog_in = 1;
  88 #endif
  89
  90 int bsd_in_init(void);
  91 int bsd_in_reset(void);
  92 int bsd_in_close(void);
  93 static int activate_bsd_in = 1;
  94
  95 #if !TARGET_IPHONE_SIMULATOR
  96 int udp_in_init(void);
  97 int udp_in_reset(void);
  98 int udp_in_close(void);
  99 static int activate_udp_in = 1;
 100
 101 /* Output Modules */
 102 int bsd_out_init(void);
 103 int bsd_out_reset(void);
 104 int bsd_out_close(void);
 105 static int activate_bsd_out = 1;
 106 #endif
 107
 108 int asl_action_init(void);
 109 int asl_action_reset(void);
 110 int asl_action_close(void);
 111 static int activate_asl_action = 1;
 112
 113 #if !TARGET_IPHONE_SIMULATOR
 114 /* Interactive Module */
 115 int remote_init(void);
 116 int remote_reset(void);
 117 int remote_close(void);
 118 static int remote_enabled = 0;
 119 #endif
 120
 121 extern void database_server();
 122
 123 static void
 124 init_modules()
 125 {
 126 #if !TARGET_IPHONE_SIMULATOR
 127         module_t *m_klog_in, *m_bsd_out, *m_udp_in, *m_remote;
 128 #endif
 129         module_t *m_asl, *m_bsd_in;
 130         int m = 0;
 131
 132         /* ASL module (configured by /etc/asl.conf) */
 133         m_asl = (module_t *)calloc(1, sizeof(module_t));
 134         if (m_asl == NULL)
 135         {
 136                 asldebug("alloc failed (init_modules asl_action)\n");
 137                 exit(1);
 138         }
 139
 140         m_asl->name = "asl_action";
 141         m_asl->enabled = activate_asl_action;
 142         m_asl->init = asl_action_init;
 143         m_asl->reset = asl_action_reset;
 144         m_asl->close = asl_action_close;
 145
 146         if (m_asl->enabled) m_asl->init();
 147
 148 #if !TARGET_IPHONE_SIMULATOR
 149         /* BSD output module (configured by /etc/syslog.conf) */
 150         m_bsd_out = (module_t *)calloc(1, sizeof(module_t));
 151         if (m_bsd_out == NULL)
 152         {
 153                 asldebug("alloc failed (init_modules bsd_out)\n");
 154                 exit(1);
 155         }
 156
 157         m_bsd_out->name = "bsd_out";
 158         m_bsd_out->enabled = activate_bsd_out;
 159         m_bsd_out->init = bsd_out_init;
 160         m_bsd_out->reset = bsd_out_reset;
 161         m_bsd_out->close = bsd_out_close;
 162
 163         if (m_bsd_out->enabled)
 164         {
 165                 m_bsd_out->init();
 166                 global.bsd_out_enabled = 1;
 167         }
 168
 169         /* kernel input module */
 170         m_klog_in = (module_t *)calloc(1, sizeof(module_t));
 171         if (m_klog_in == NULL)
 172         {
 173                 asldebug("alloc failed (init_modules klog_in)\n");
 174                 exit(1);
 175         }
 176
 177         m_klog_in->name = "klog_in";
 178         m_klog_in->enabled = activate_klog_in;
 179         m_klog_in->init = klog_in_init;
 180         m_klog_in->reset = klog_in_reset;
 181         m_klog_in->close = klog_in_close;
 182
 183         if (m_klog_in->enabled) m_klog_in->init();
 184 #endif
 185
 186         /* BSD (UNIX domain socket) input module */
 187         m_bsd_in = (module_t *)calloc(1, sizeof(module_t));
 188         if (m_bsd_in == NULL)
 189         {
 190                 asldebug("alloc failed (init_modules bsd_in)\n");
 191                 exit(1);
 192         }
 193
 194         m_bsd_in->name = "bsd_in";
 195         m_bsd_in->enabled = activate_bsd_in;
 196         m_bsd_in->init = bsd_in_init;
 197         m_bsd_in->reset = bsd_in_reset;
 198         m_bsd_in->close = bsd_in_close;
 199
 200         if (m_bsd_in->enabled) m_bsd_in->init();
 201
 202 #if !TARGET_IPHONE_SIMULATOR
 203         /* network (syslog protocol) input module */
 204         m_udp_in = (module_t *)calloc(1, sizeof(module_t));
 205         if (m_udp_in == NULL)
 206         {
 207                 asldebug("alloc failed (init_modules udp_in)\n");
 208                 exit(1);
 209         }
 210
 211         m_udp_in->name = "udp_in";
 212         m_udp_in->enabled = activate_udp_in;
 213         m_udp_in->init = udp_in_init;
 214         m_udp_in->reset = udp_in_reset;
 215         m_udp_in->close = udp_in_close;
 216
 217         if (m_udp_in->enabled) m_udp_in->init();
 218
 219         /* remote (iOS support) module */
 220         m_remote = (module_t *)calloc(1, sizeof(module_t));
 221         if (m_remote == NULL)
 222         {
 223                 asldebug("alloc failed (init_modules remote)\n");
 224                 exit(1);
 225         }
 226
 227         m_remote->name = "remote";
 228         m_remote->enabled = remote_enabled;
 229         m_remote->init = remote_init;
 230         m_remote->reset = remote_reset;
 231         m_remote->close = remote_close;
 232
 233         if (m_remote->enabled) m_remote->init();
 234 #endif /* TARGET_IPHONE_SIMULATOR */
 235
 236         /* save modules in global.module array */
 237 #if TARGET_IPHONE_SIMULATOR
 238         global.module_count = 2;
 239 #else
 240         global.module_count = 6;
 241 #endif
 242         global.module = (module_t **)calloc(global.module_count, sizeof(module_t *));
 243         if (global.module == NULL)
 244         {
 245                 asldebug("alloc failed (init_modules)\n");
 246                 exit(1);
 247         }
 248
 249         global.module[m++] = m_asl;
 250         global.module[m++] = m_bsd_in;
 251 #if !TARGET_IPHONE_SIMULATOR
 252         global.module[m++] = m_bsd_out;
 253         global.module[m++] = m_klog_in;
 254         global.module[m++] = m_udp_in;
 255         global.module[m++] = m_remote;
 256 #endif
 257 }
 258
 259 static void
 260 writepid(int *first)
 261 {
 262         struct stat sb;
 263         FILE *fp;
 264
 265         if (first != NULL)
 266         {
 267                 *first = 1;
 268                 memset(&sb, 0, sizeof(struct stat));
 269                 if (stat(_PATH_PIDFILE, &sb) == 0)
 270                 {
 271                         if (S_ISREG(sb.st_mode)) *first = 0;
 272                 }
 273         }
 274
 275         fp = fopen(_PATH_PIDFILE, "w");
 276         if (fp != NULL)
 277         {
 278                 fprintf(fp, "%d\n", global.pid);
 279                 fclose(fp);
 280         }
 281 }
 282
 283 void
 284 launch_config()
 285 {
 286         launch_data_t tmp, pdict;
 287         kern_return_t status;
 288
 289         tmp = launch_data_new_string(LAUNCH_KEY_CHECKIN);
 290         global.launch_dict = launch_msg(tmp);
 291         launch_data_free(tmp);
 292
 293         if (global.launch_dict == NULL)
 294         {
 295                 asldebug("%d launchd checkin failed\n", global.pid);
 296                 exit(1);
 297         }
 298
 299         tmp = launch_data_dict_lookup(global.launch_dict, LAUNCH_JOBKEY_MACHSERVICES);
 300         if (tmp == NULL)
 301         {
 302                 asldebug("%d launchd lookup of LAUNCH_JOBKEY_MACHSERVICES failed\n", global.pid);
 303                 exit(1);
 304         }
 305
 306         pdict = launch_data_dict_lookup(tmp, SERVICE_NAME);
 307         if (pdict == NULL)
 308         {
 309                 asldebug("%d launchd lookup of SERVICE_NAME failed\n", global.pid);
 310                 exit(1);
 311         }
 312
 313         global.server_port = launch_data_get_machport(pdict);
 314
 315         /* port for receiving MACH_NOTIFY_DEAD_NAME notifications */
 316         status = mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &(global.dead_session_port));
 317         if (status != KERN_SUCCESS)
 318         {
 319                 asldebug("mach_port_allocate dead_session_port failed: %d", status);
 320                 exit(1);
 321         }
 322
 323         status = mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_PORT_SET, &(global.listen_set));
 324         if (status != KERN_SUCCESS)
 325         {
 326                 asldebug("mach_port_allocate listen_set failed: %d", status);
 327                 exit(1);
 328         }
 329
 330         status = mach_port_move_member(mach_task_self(), global.server_port, global.listen_set);
 331         if (status != KERN_SUCCESS)
 332         {
 333                 asldebug("mach_port_move_member server_port failed: %d", status);
 334                 exit(1);
 335         }
 336
 337         status = mach_port_move_member(mach_task_self(), global.dead_session_port, global.listen_set);
 338         if (status != KERN_SUCCESS)
 339         {
 340                 asldebug("mach_port_move_member dead_session_port failed (%u)", status);
 341                 exit(1);
 342         }
 343 }
 344
 345 void
 346 config_debug(int enable, const char *path)
 347 {
 348         OSSpinLockLock(&global.lock);
 349
 350         global.debug = enable;
 351         free(global.debug_file);
 352         global.debug_file = NULL;
 353         if (path != NULL) global.debug_file = strdup(path);
 354
 355         OSSpinLockUnlock(&global.lock);
 356 }
 357
 358 void
 359 config_data_store(int type, uint32_t file_max, uint32_t memory_max, uint32_t str_memory_max)
 360 {
 361         pthread_mutex_lock(global.db_lock);
 362
 363         if (global.dbtype & DB_TYPE_FILE)
 364         {
 365                 asl_store_close(global.file_db);
 366                 global.file_db = NULL;
 367         }
 368
 369         if (global.dbtype & DB_TYPE_MEMORY)
 370         {
 371                 asl_memory_close(global.memory_db);
 372                 global.memory_db = NULL;
 373         }
 374
 375         global.dbtype = type;
 376         global.db_file_max = file_max;
 377         global.db_memory_max = memory_max;
 378         global.db_memory_str_max = str_memory_max;
 379
 380         pthread_mutex_unlock(global.db_lock);
 381 }
 382
 383 void
 384 write_boot_log(int first)
 385 {
 386         int mib[2] = {CTL_KERN, KERN_BOOTTIME};
 387         size_t len;
 388         asl_msg_t *msg;
 389         char buf[256];
 390         struct utmpx utx;
 391
 392         if (first == 0)
 393         {
 394                 /* syslogd restart */
 395                 msg = asl_msg_new(ASL_TYPE_MSG);
 396                 if (msg == NULL) return;
 397
 398                 asl_msg_set_key_val(msg, ASL_KEY_SENDER, "syslogd");
 399                 asl_msg_set_key_val(msg, ASL_KEY_FACILITY, "daemon");
 400                 asl_msg_set_key_val(msg, ASL_KEY_LEVEL, "Notice");
 401                 asl_msg_set_key_val(msg, ASL_KEY_UID, "0");
 402                 asl_msg_set_key_val(msg, ASL_KEY_GID, "0");
 403                 snprintf(buf, sizeof(buf), "%u", global.pid);
 404                 asl_msg_set_key_val(msg, ASL_KEY_PID, buf);
 405                 asl_msg_set_key_val(msg, ASL_KEY_MSG, "--- syslogd restarted ---");
 406                 process_message(msg, SOURCE_INTERNAL);
 407                 return;
 408         }
 409
 410         bzero(&utx, sizeof(utx));
 411         utx.ut_type = BOOT_TIME;
 412         utx.ut_pid = 1;
 413
 414         /* get the boot time */
 415         len = sizeof(struct timeval);
 416         if (sysctl(mib, 2, &utx.ut_tv, &len, NULL, 0) < 0)
 417         {
 418                 gettimeofday(&utx.ut_tv, NULL);
 419         }
 420
 421         pututxline(&utx);
 422
 423         msg = asl_msg_new(ASL_TYPE_MSG);
 424         if (msg == NULL) return;
 425
 426         asl_msg_set_key_val(msg, ASL_KEY_SENDER, "bootlog");
 427         asl_msg_set_key_val(msg, ASL_KEY_FACILITY, "com.apple.system.utmpx");
 428         asl_msg_set_key_val(msg, ASL_KEY_LEVEL, "Notice");
 429         asl_msg_set_key_val(msg, ASL_KEY_UID, "0");
 430         asl_msg_set_key_val(msg, ASL_KEY_GID, "0");
 431         asl_msg_set_key_val(msg, ASL_KEY_PID, "0");
 432         snprintf(buf, sizeof(buf), "BOOT_TIME %lu %u", (unsigned long)utx.ut_tv.tv_sec, (unsigned int)utx.ut_tv.tv_usec);
 433         asl_msg_set_key_val(msg, ASL_KEY_MSG, buf);
 434         asl_msg_set_key_val(msg, "ut_id", "0x00 0x00 0x00 0x00");
 435         asl_msg_set_key_val(msg, "ut_pid", "1");
 436         asl_msg_set_key_val(msg, "ut_type", "2");
 437         snprintf(buf, sizeof(buf), "%lu", (unsigned long)utx.ut_tv.tv_sec);
 438         asl_msg_set_key_val(msg, ASL_KEY_TIME, buf);
 439         asl_msg_set_key_val(msg, "ut_tv.tv_sec", buf);
 440         snprintf(buf, sizeof(buf), "%u", (unsigned int)utx.ut_tv.tv_usec);
 441         asl_msg_set_key_val(msg, "ut_tv.tv_usec", buf);
 442         snprintf(buf, sizeof(buf), "%u%s", (unsigned int)utx.ut_tv.tv_usec, (utx.ut_tv.tv_usec == 0) ? "" : "000");
 443         asl_msg_set_key_val(msg, ASL_KEY_TIME_NSEC, buf);
 444
 445         process_message(msg, SOURCE_INTERNAL);
 446 }
 447
 448 int
 449 main(int argc, const char *argv[])
 450 {
 451         int32_t i;
 452         uint64_t master_val;
 453 #if !TARGET_IPHONE_SIMULATOR
 454         int network_change_token;
 455 #endif
 456         int quota_file_token, asl_db_token, master_token;
 457         char tstr[32], *notify_key;
 458         time_t now;
 459         int first_syslogd_start = 1;
 460
 461 #if TARGET_IPHONE_SIMULATOR
 462         const char *sim_log_dir = getenv("SIMULATOR_LOG_ROOT");
 463         const char *sim_resource_dir = getenv("SIMULATOR_SHARED_RESOURCES_DIRECTORY");
 464         char *p;
 465
 466         /* assert is evil */
 467         assert(sim_log_dir && sim_resource_dir);
 468
 469         asprintf((char **)&_path_syslogd_log, "%s/syslogd.log", sim_log_dir);
 470         asprintf((char **)&_path_pidfile, "%s/var/run/syslog.pid", sim_resource_dir);
 471
 472         if (_path_syslogd_log == NULL) _path_syslogd_log = "/tmp/syslogd.log";
 473         else mkpath_np(sim_log_dir, 0755);
 474
 475         if (_path_pidfile == NULL)
 476         {
 477                 _path_pidfile = "/tmp/syslog.pid";
 478         }
 479         else
 480         {
 481                 p = strrchr(_path_pidfile, '/');
 482                 *p = '\0';
 483                 mkpath_np(_path_pidfile, 0755);
 484                 *p = '/';
 485         }
 486 #endif
 487
 488 #if TARGET_OS_IPHONE
 489         /*
 490          * Reset owner, group, and permissions in /var/mobile/Library/Logs
 491          * in case something created them incorrectly.  syslogd was
 492          * guilty of this in the past, creating them with owner root.
 493          */
 494
 495         uid_t __mUserUID = 501;
 496         gid_t __mUserGID = 501;
 497         struct passwd * pw = getpwnam("mobile");
 498
 499         if (pw) {
 500                 __mUserUID = pw->pw_uid;
 501                 __mUserGID = pw->pw_gid;
 502         }
 503
 504         asl_secure_chown_chmod_dir("/private/var/mobile/Library/Logs", __mUserUID, __mUserGID, 0755);
 505         asl_secure_chown_chmod_dir("/private/var/mobile/Library/Logs/CrashReporter", __mUserUID, __mUserGID, 0755);
 506         asl_secure_chown_chmod_dir("/private/var/mobile/Library/Logs/CrashReporter/DiagnosticLogs", __mUserUID, __mUserGID, 0755);
 507 #endif
 508
 509         /* Set I/O policy */
 510         setiopolicy_np(IOPOL_TYPE_DISK, IOPOL_SCOPE_PROCESS, IOPOL_PASSIVE);
 511
 512 #if !TARGET_OS_IPHONE
 513         /* Set Quarantine */
 514         qtn_proc_t qp = qtn_proc_alloc();
 515         qtn_proc_set_identifier(qp, "com.apple.syslogd");
 516         qtn_proc_set_flags(qp, QTN_FLAG_SANDBOX | QTN_FLAG_HARD);
 517         qtn_proc_apply_to_self(qp);
 518         qtn_proc_free(qp);
 519 #endif
 520
 521         memset(&global, 0, sizeof(struct global_s));
 522
 523         global.db_lock = (pthread_mutex_t *)calloc(1, sizeof(pthread_mutex_t));
 524         pthread_mutex_init(global.db_lock, NULL);
 525
 526         /*
 527          * Create work queue, but suspend until output modules are initialized.
 528          */
 529         global.work_queue = dispatch_queue_create("Work Queue", NULL);
 530         dispatch_suspend(global.work_queue);
 531
 532         init_globals();
 533
 534 #if TARGET_OS_EMBEDDED
 535         remote_enabled = 1;
 536         activate_bsd_out = 0;
 537 #endif
 538
 539         /* prevent malloc from calling ASL on error */
 540         _malloc_no_asl_log = 1;
 541
 542         /* first pass sets up default configurations */
 543         for (i = 1; i < argc; i++)
 544         {
 545                 if (streq(argv[i], "-config"))
 546                 {
 547                         if (((i + 1) < argc) && (argv[i+1][0] != '-'))
 548                         {
 549                                 i++;
 550                                 if (streq(argv[i], "mac"))
 551                                 {
 552                                         global.dbtype = DB_TYPE_FILE;
 553                                         global.db_file_max = 25600000;
 554                                 }
 555                                 else if (streq(argv[i], "appletv"))
 556                                 {
 557                                         global.dbtype = DB_TYPE_FILE;
 558                                         global.db_file_max = 10240000;
 559                                 }
 560                                 else if (streq(argv[i], "iphone"))
 561                                 {
 562 #if TARGET_IPHONE_SIMULATOR
 563                                         global.dbtype = DB_TYPE_FILE;
 564                                         global.db_file_max = 25600000;
 565 #else
 566                                         global.dbtype = DB_TYPE_MEMORY;
 567                                         remote_enabled = 1;
 568 #endif
 569                                 }
 570                         }
 571                 }
 572         }
 573
 574         for (i = 1; i < argc; i++)
 575         {
 576                 if (streq(argv[i], "-d"))
 577                 {
 578                         global.debug = 1;
 579                         if (((i+1) < argc) && (argv[i+1][0] != '-')) global.debug_file = strdup(argv[++i]);
 580                 }
 581                 else if (streq(argv[i], "-db"))
 582                 {
 583                         if (((i + 1) < argc) && (argv[i+1][0] != '-'))
 584                         {
 585                                 i++;
 586                                 if (streq(argv[i], "file"))
 587                                 {
 588                                         global.dbtype |= DB_TYPE_FILE;
 589                                         if (((i + 1) < argc) && (argv[i+1][0] != '-')) global.db_file_max = atol(argv[++i]);
 590                                 }
 591                                 else if (streq(argv[i], "memory"))
 592                                 {
 593                                         global.dbtype |= DB_TYPE_MEMORY;
 594                                         if (((i + 1) < argc) && (argv[i+1][0] != '-')) global.db_memory_max = atol(argv[++i]);
 595                                 }
 596                         }
 597                 }
 598                 else if (streq(argv[i], "-m"))
 599                 {
 600                         if ((i + 1) < argc) global.mark_time = 60 * atoll(argv[++i]);
 601                 }
 602                 else if (streq(argv[i], "-utmp_ttl"))
 603                 {
 604                         if ((i + 1) < argc) global.utmp_ttl = atol(argv[++i]);
 605                 }
 606                 else if (streq(argv[i], "-mps_limit"))
 607                 {
 608                         if ((i + 1) < argc) global.mps_limit = atol(argv[++i]);
 609                 }
 610                 else if (streq(argv[i], "-dup_delay"))
 611                 {
 612                         if ((i + 1) < argc) global.bsd_max_dup_time = atoll(argv[++i]);
 613                 }
 614 #if !TARGET_IPHONE_SIMULATOR
 615                 else if (streq(argv[i], "-klog_in"))
 616                 {
 617                         if ((i + 1) < argc) activate_klog_in = atoi(argv[++i]);
 618                 }
 619                 else if (streq(argv[i], "-bsd_in"))
 620                 {
 621                         if ((i + 1) < argc) activate_bsd_in = atoi(argv[++i]);
 622                 }
 623                 else if (streq(argv[i], "-udp_in"))
 624                 {
 625                         if ((i + 1) < argc) activate_udp_in = atoi(argv[++i]);
 626                 }
 627 #endif
 628                 else if (streq(argv[i], "-launchd_in"))
 629                 {
 630                         if ((i + 1) < argc) global.launchd_enabled = atoi(argv[++i]);
 631                 }
 632 #if !TARGET_IPHONE_SIMULATOR
 633                 else if (streq(argv[i], "-bsd_out"))
 634                 {
 635                         if ((i + 1) < argc) activate_bsd_out = atoi(argv[++i]);
 636                 }
 637                 else if (streq(argv[i], "-remote"))
 638                 {
 639                         if ((i + 1) < argc) remote_enabled = atoi(argv[++i]);
 640                 }
 641 #endif
 642         }
 643
 644         if (global.dbtype == 0)
 645         {
 646                 global.dbtype = DB_TYPE_FILE;
 647                 global.db_file_max = 25600000;
 648         }
 649
 650         signal(SIGHUP, SIG_IGN);
 651
 652         memset(tstr, 0, sizeof(tstr));
 653         now = time(NULL);
 654         ctime_r(&now, tstr);
 655         tstr[19] = '\0';
 656         asldebug("\n%s syslogd PID %d starting\n", tstr, global.pid);
 657
 658         writepid(&first_syslogd_start);
 659
 660         /*
 661          * Log UTMPX boot time record
 662          */
 663         write_boot_log(first_syslogd_start);
 664
 665         /* default NOTIFY_SYSTEM_MASTER settings */
 666         master_val = 0x0;
 667         notify_register_plain(NOTIFY_SYSTEM_MASTER, &master_token);
 668         notify_set_state(master_token, master_val);
 669
 670         asldebug("reading launch plist\n");
 671         launch_config();
 672
 673         asldebug("initializing modules\n");
 674         init_modules();
 675
 676 #if !TARGET_IPHONE_SIMULATOR
 677         asldebug("setting up network change notification handler\n");
 678
 679         /* network change notification resets UDP and BSD modules */
 680         notify_register_dispatch(kNotifySCNetworkChange, &network_change_token, global.work_queue, ^(int x){
 681                 if (activate_udp_in != 0) udp_in_reset();
 682                 if (activate_bsd_out != 0) bsd_out_reset();
 683         });
 684 #endif
 685
 686         asldebug("setting up quota notification handler\n");
 687
 688         notify_key = NULL;
 689         asprintf(&notify_key, "%s%s", NOTIFY_PATH_SERVICE, NOQUOTA_FILE_PATH);
 690         if (notify_key != NULL)
 691         {
 692                 int status;
 693
 694                 status = notify_register_dispatch(notify_key, &quota_file_token, dispatch_get_main_queue(), ^(int t){
 695                         struct stat sb;
 696                         memset(&sb, 0, sizeof(sb));
 697                         if (stat(NOQUOTA_FILE_PATH, &sb) == 0)
 698                         {
 699                                 char *str = NULL;
 700                                 asprintf(&str, "[Sender syslogd] [Level 2] [PID %u] [Facility syslog] [Message *** MESSAGE QUOTAS DISABLED FOR ALL PROCESSES ***]", global.pid);
 701                                 internal_log_message(str);
 702                                 free(str);
 703                         }
 704                         else
 705                         {
 706                                 char *str = NULL;
 707                                 asprintf(&str, "[Sender syslogd] [Level 2] [PID %u] [Facility syslog] [Message *** MESSAGE QUOTAS ENABLED ***]", global.pid);
 708                                 internal_log_message(str);
 709                                 free(str);
 710                         }
 711                 });
 712
 713                 free(notify_key);
 714         }
 715
 716         /* SIGHUP resets all modules */
 717         global.sig_hup_src = dispatch_source_create(DISPATCH_SOURCE_TYPE_SIGNAL, (uintptr_t)SIGHUP, 0, dispatch_get_main_queue());
 718         dispatch_source_set_event_handler(global.sig_hup_src, ^{
 719                 dispatch_async(global.work_queue, ^{
 720                         int i;
 721
 722                         asldebug("SIGHUP reset\n");
 723                         for (i = 0; i < global.module_count; i++)
 724                         {
 725                                 if (global.module[i]->enabled != 0) global.module[i]->reset();
 726                         }
 727                 });
 728         });
 729
 730         dispatch_resume(global.sig_hup_src);
 731
 732         /* register for DB notification (posted by dbserver) for performance */
 733         notify_register_plain(kNotifyASLDBUpdate, &asl_db_token);
 734
 735         /* timer for MARK facility */
 736         if (global.mark_time > 0)
 737         {
 738                 global.mark_timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, dispatch_get_main_queue());
 739                 dispatch_source_set_event_handler(global.mark_timer, ^{
 740                         asl_mark();
 741                 });
 742                 dispatch_source_set_timer(global.mark_timer, dispatch_time(DISPATCH_TIME_NOW, global.mark_time * NSEC_PER_SEC), global.mark_time * NSEC_PER_SEC, 0);
 743                 dispatch_resume(global.mark_timer);
 744         }
 745
 746 #if !TARGET_IPHONE_SIMULATOR
 747         asldebug("starting launchd input channel\n");
 748         /*
 749          * Start launchd service
 750          * This pins a thread in _vprocmgr_log_drain.  Eventually we will either
 751          * remove the whole stderr/stdout -> ASL mechanism entirely, or come up
 752          * with a communication channel that we can trigger with a dispatch source.
 753          */
 754         dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
 755                 forever _vprocmgr_log_drain(NULL, NULL, launchd_callback);
 756         });
 757 #endif
 758
 759         asldebug("starting mach service\n");
 760         /*
 761          * Start mach server
 762          * Parks a thread in database_server.  In notifyd, we found that the overhead of
 763          * a dispatch source for mach calls was too high, especially on iOS.
 764          */
 765         dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
 766                 database_server();
 767         });
 768
 769         /* go to work */
 770         asldebug("starting work queue\n");
 771         dispatch_resume(global.work_queue);
 772         dispatch_main();
 773
 774         /* NOTREACHED */
 775         return 0;
 776 }