开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > 手机WAP编程 > 查看源码
start-stop-daemon.c
资源名称：gateway-1.2.1　[点击查看]
上传用户：gzpyjq
上传日期：2013-01-31
资源大小：1852k
文件大小：21k
源码类别：

手机WAP编程

开发平台：

WINDOWS

start-stop-daemon.c：源码内容
  1. /* This utility was added to the Kannel source tree for the benefit of
  2.  * those distributions that aren't Debian.  It is used by kannel-init.d
  3.  * to start and stop the run_kannel_box daemon. 
  4.  * It was copied from the dpkg 1.6.11 source tree on 21 March 2000.
  5.  * If that was very long ago, refreshing the copy would be a good idea,
  6.  * in case bugs were fixed.
  7.  * Richard Braakman
  8.  */
  10. /*
  11.  * A rewrite of the original Debian's start-stop-daemon Perl script
  12.  * in C (faster - it is executed many times during system startup).
  13.  *
  14.  * Written by Marek Michalkiewicz <marekm@i17linuxb.ists.pwr.wroc.pl>,
  15.  * public domain.  Based conceptually on start-stop-daemon.pl, by Ian
  16.  * Jackson <ijackson@gnu.ai.mit.edu>.  May be used and distributed
  17.  * freely for any purpose.  Changes by Christian Schwarz
  18.  * <schwarz@monet.m.isar.de>, to make output conform to the Debian
  19.  * Console Message Standard, also placed in public domain.  Minor
  20.  * changes by Klee Dienes <klee@debian.org>, also placed in the Public
  21.  * Domain.
  22.  *
  23.  * Changes by Ben Collins <bcollins@debian.org>, added --chuid, --background
  24.  * and --make-pidfile options, placed in public domain aswell.
  25.  */
  27. #include "config.h"
  29. #if defined(linux)
  30. #define OSLinux
  31. #elif defined(__GNU__)
  32. #define OSHURD
  33. #elif defined(SunOS)
  34. #elif defined(__FreeBSD__) || defined(__APPLE__)
  35. #define FreeBSD
  36. #else
  37. #error Unknown architecture - cannot build start-stop-daemon
  38. #endif
  40. #ifdef HAVE_HURH_H
  41. #include <hurd.h>
  42. #endif
  43. #ifdef HAVE_PS_H
  44. #include <ps.h>
  45. #endif
  47. #include <errno.h>
  48. #include <stdio.h>
  49. #include <stdlib.h>
  50. #include <string.h>
  51. #include <stdarg.h>
  52. #include <signal.h>
  53. #include <sys/stat.h>
  54. #include <dirent.h>
  55. #include <unistd.h>
  56. #if HAVE_GETOPT_H
  57. #include <getopt.h>
  58. #endif
  59. #include <unistd.h>
  60. #include <pwd.h>
  61. #include <grp.h>
  62. #include <sys/ioctl.h>
  63. #include <sys/types.h>
  64. #include <sys/termios.h>
  65. #include <fcntl.h>
  67. /*Solaris needs to be told how
  68. to talk to it's proc filesystem*/
  69. #define _STRUCTURED_PROC 1
  70. #ifdef SunOS
  71. #include <sys/procfs.h>
  72. #endif
  75. #ifdef HAVE_ERROR_H
  76. #include <error.h>
  77. #endif
  78. #ifdef HURD_IHASH_H
  79. #include <hurd/ihash.h>
  80. #endif
  82. static int testmode = 0;
  83. static int quietmode = 0;
  84. static int exitnodo = 1;
  85. static int start = 0;
  86. static int stop = 0;
  87. static int background = 0;
  88. static int mpidfile = 0;
  89. static int signal_nr = 15;
  90. static const char *signal_str = NULL;
  91. static int user_id = -1;
  92. static int runas_uid = -1;
  93. static int runas_gid = -1;
  94. static const char *userspec = NULL;
  95. static char *changeuser = NULL;
  96. static char *changegroup = NULL;
  97. static char *changeroot = NULL;
  98. static const char *cmdname = NULL;
  99. static char *execname = NULL;
  100. static char *startas = NULL;
  101. static const char *pidfile = NULL;
  102. static const char *progname = "";
  104. static struct stat exec_stat;
  105. #if defined(OSHURD)
  106. static struct ps_context *context;
  107. static struct proc_stat_list *procset;
  108. #endif
  111. struct pid_list {
  112. struct pid_list *next;
  113. int pid;
  114. };
  116. static struct pid_list *found = NULL;
  117. static struct pid_list *killed = NULL;
  119. static void *xmalloc(int size);
  120. static void push(struct pid_list **list, int pid);
  121. static void do_help(void);
  122. static void parse_options(int argc, char * const *argv);
  123. #if defined(OSLinux) || defined(OSHURD) || defined(SunOS) || defined(FreeBSD)
  124. static int pid_is_user(int pid, int uid);
  125. static int pid_is_cmd(int pid, const char *name);
  126. #endif
  127. static void check(int pid);
  128. static void do_pidfile(const char *name);
  129. static int do_stop(void);
  130. #if defined(OSLinux)
  131. static int pid_is_exec(int pid, const struct stat *esb);
  132. #endif
  133. #if defined(OSHURD)
  134. static void do_psinit(void);
  135. #endif
  138. #ifdef __GNUC__
  139. static void fatal(const char *format, ...)
  140. __attribute__((noreturn, format(printf, 1, 2)));
  141. static void badusage(const char *msg)
  142. __attribute__((noreturn));
  143. #else
  144. static void fatal(const char *format, ...);
  145. static void badusage(const char *msg);
  146. #endif
  148. static void
  149. fatal(const char *format, ...)
  150. {
  151. va_list arglist;
  153. fprintf(stderr, "%s: ", progname);
  154. va_start(arglist, format);
  155. vfprintf(stderr, format, arglist);
  156. va_end(arglist);
  157. putc('n', stderr);
  158. exit(2);
  159. }
  162. static void *
  163. xmalloc(int size)
  164. {
  165. void *ptr;
  167. ptr = malloc(size);
  168. if (ptr)
  169. return ptr;
  170. fatal("malloc(%d) failed", size);
  171. }
  174. static void
  175. push(struct pid_list **list, int pid)
  176. {
  177. struct pid_list *p;
  179. p = xmalloc(sizeof(*p));
  180. p->next = *list;
  181. p->pid = pid;
  182. *list = p;
  183. }
  186. static void
  187. do_help(void)
  188. {
  190. /*Print the help for systems that have getopt long*/
  192. #ifndef SunOS     /*Solaris doesn't*/
  194. printf("
  195. start-stop-daemon for Debian GNU/Linux - small and fast C version written byn
  196. Marek Michalkiewicz <marekm@i17linuxb.ists.pwr.wroc.pl>, public domain.n"
  197. VERSION "n
  198. n
  199. Usage:n
  200.   start-stop-daemon -S|--start options ... -- arguments ...n
  201.   start-stop-daemon -K|--stop options ...n
  202.   start-stop-daemon -H|--helpn
  203.   start-stop-daemon -V|--versionn
  204. n
  205. Options (at least one of --exec|--pidfile|--user is required):n
  206.   -x|--exec <executable>        program to start/check if it is runningn
  207.   -p|--pidfile <pid-file>       pid file to checkn
  208.   -c|--chuid <name|uid[:group|gid]>n
  209.    change to this user/group before starting processn
  210.   -u|--user <username>|<uid>    stop processes owned by this usern
  211.   -n|--name <process-name>      stop processes with this namen
  212.   -s|--signal <signal>          signal to send (default TERM)n
  213.   -a|--startas <pathname>       program to start (default is <executable>)n
  214.   -b|--background               force the process to detachn
  215.   -m|--make-pidfile             create the pidfile before startingn
  216.   -t|--test                     test mode, don't do anythingn
  217.   -o|--oknodo                   exit status 0 (not 1) if nothing donen
  218.   -q|--quiet                    be more quietn
  219.   -v|--verbose                  be more verbosen
  220. n
  221. Exit status:  0 = done  1 = nothing done (=> 0 if --oknodo)  2 = troublen");
  223. #else /* Deal with systems that don't have getopt long, like Solaris*/
  225. printf("
  226. start-stop-daemon for Debian GNU/Linux - small and fast C version written byn
  227. Marek Michalkiewicz <marekm@i17linuxb.ists.pwr.wroc.pl>, public domain.n"
  228. VERSION "n
  229. n
  230. Usage:n
  231.   start-stop-daemon -S options ... -- arguments ...n
  232.   start-stop-daemon -K options ...n
  233.   start-stop-daemon -Hn
  234.   start-stop-daemon -Vn
  235. n
  236. Options (at least one of --exec|--pidfile|--user is required):n
  237.   -x <executable>               program to start/check if it is runningn
  238.   -p <pid-file>                 pid file to checkn
  239.   -c <name|uid[:group|gid]>     change to this user/group before starting processn
  240.   -u <username>|<uid>           stop processes owned by this usern
  241.   -n <process-name>             stop processes with this namen
  242.   -s <signal>                   signal to send (default TERM)n
  243.   -a <pathname>                 program to start (default is <executable>)n
  244.   -b                            force the process to detachn
  245.   -m                            create the pidfile before startingn
  246.   -t                            test mode, don't do anythingn
  247.   -o                            exit status 0 (not 1) if nothing donen
  248.   -q                            be more quietn
  249.   -v                            be more verbosen
  250. n
  251. Exit status:  0 = done  1 = nothing done (=> 0 if -o)  2 = troublen");
  252. #endif   /*No more OS ( getopt ) specific stuff this function... */
  253. }
  256. static void
  257. badusage(const char *msg)
  258. {
  259. if (msg)
  260. fprintf(stderr, "%s: %sn", progname, msg);
  262. #ifndef SunOS
  263. fprintf(stderr, "Try `%s --help' for more information.n", progname);
  264. #else
  265. fprintf(stderr, "Try `%s -H' for more information.n", progname);
  266. #endif
  268. exit(2);
  269. }
  271. struct sigpair {
  272. const char *name;
  273. int signal;
  274. };
  276. static const struct sigpair siglist[] = {
  277. { "ABRT", SIGABRT },
  278. { "ALRM", SIGALRM },
  279. { "FPE", SIGFPE },
  280. { "HUP", SIGHUP },
  281. { "ILL", SIGILL },
  282. { "INT", SIGINT },
  283. { "KILL", SIGKILL },
  284. { "PIPE", SIGPIPE },
  285. { "QUIT", SIGQUIT },
  286. { "SEGV", SIGSEGV },
  287. { "TERM", SIGTERM },
  288. { "USR1", SIGUSR1 },
  289. { "USR2", SIGUSR2 },
  290. { "CHLD", SIGCHLD },
  291. { "CONT", SIGCONT },
  292. { "STOP", SIGSTOP },
  293. { "TSTP", SIGTSTP },
  294. { "TTIN", SIGTTIN },
  295. { "TTOU", SIGTTOU }
  296. };
  297. static int sigcount = sizeof (siglist) / sizeof (siglist[0]);
  299. static int parse_signal (const char *signal_str, int *signal_nr)
  300. {
  301. int i;
  302. for (i = 0; i < sigcount; i++) {
  303. if (strcmp (signal_str, siglist[i].name) == 0) {
  304. *signal_nr = siglist[i].signal;
  305. return 0;
  306. }
  307. }
  308. return -1;
  309. }
  311. static void
  312. parse_options(int argc, char * const *argv)
  313. {
  315. #if HAVE_GETOPT_LONG
  316. static struct option longopts[] = {
  317. { "help",   0, NULL, 'H'},
  318. { "stop",   0, NULL, 'K'},
  319. { "start",   0, NULL, 'S'},
  320. { "version",   0, NULL, 'V'},
  321. { "startas",   1, NULL, 'a'},
  322. { "name",   1, NULL, 'n'},
  323. { "oknodo",   0, NULL, 'o'},
  324. { "pidfile",   1, NULL, 'p'},
  325. { "quiet",   0, NULL, 'q'},
  326. { "signal",   1, NULL, 's'},
  327. { "test",   0, NULL, 't'},
  328. { "user",   1, NULL, 'u'},
  329. { "chroot",   1, NULL, 'r'},
  330. { "verbose",   0, NULL, 'v'},
  331. { "exec",   1, NULL, 'x'},
  332. { "chuid",   1, NULL, 'c'},
  333. { "background",   0, NULL, 'b'},
  334. { "make-pidfile", 0, NULL, 'm'},
  335. { NULL, 0, NULL, 0}
  336. };
  337. #endif
  338. int c;
  340. for (;;) {
  341. #if HAVE_GETOPT_LONG
  342. c = getopt_long(argc, argv, "HKSVa:n:op:qr:s:tu:vx:c:bm",
  343. longopts, (int *) 0);
  344. #else
  345. c = getopt(argc, argv, "HKSVa:n:op:qr:s:tu:vx:c:bm");
  346. #endif
  347. if (c == -1)
  348. break;
  349. switch (c) {
  350. case 'H':  /* --help */
  351. do_help();
  352. exit(0);
  353. case 'K':  /* --stop */
  354. stop = 1;
  355. break;
  356. case 'S':  /* --start */
  357. start = 1;
  358. break;
  359. case 'V':  /* --version */
  360. printf("start-stop-daemon " VERSION "n");
  361. exit(0);
  362. case 'a':  /* --startas <pathname> */
  363. startas = optarg;
  364. break;
  365. case 'n':  /* --name <process-name> */
  366. cmdname = optarg;
  367. break;
  368. case 'o':  /* --oknodo */
  369. exitnodo = 0;
  370. break;
  371. case 'p':  /* --pidfile <pid-file> */
  372. pidfile = optarg;
  373. break;
  374. case 'q':  /* --quiet */
  375. quietmode = 1;
  376. break;
  377. case 's':  /* --signal <signal> */
  378. signal_str = optarg;
  379. break;
  380. case 't':  /* --test */
  381. testmode = 1;
  382. break;
  383. case 'u':  /* --user <username>|<uid> */
  384. userspec = optarg;
  385. break;
  386. case 'v':  /* --verbose */
  387. quietmode = -1;
  388. break;
  389. case 'x':  /* --exec <executable> */
  390. execname = optarg;
  391. break;
  392. case 'c':  /* --chuid <username>|<uid> */
  393. /* we copy the string just in case we need the
  394.  * argument later. */
  395. changeuser = strdup(optarg);
  396. changeuser = strtok(changeuser, ":");
  397. changegroup = strtok(NULL, ":");
  398. break;
  399. case 'r':  /* --chroot /new/root */
  400. changeroot = optarg;
  401. break;
  402. case 'b':  /* --background */
  403. background = 1;
  404. break;
  405. case 'm':  /* --make-pidfile */
  406. mpidfile = 1;
  407. break;
  408. default:
  409. badusage(NULL);  /* message printed by getopt */
  410. }
  411. }
  413. if (signal_str != NULL) {
  414. if (sscanf (signal_str, "%d", &signal_nr) != 1) {
  415. if (parse_signal (signal_str, &signal_nr) != 0) {
  416. badusage ("--signal takes a numeric argument or name of signal (KILL, INTR, ...)");
  417. }
  418. }
  419. }
  421. if (start == stop)
  422. #ifndef SunOS
  423. badusage("need one of --start or --stop");
  424. #else
  425. badusage("need one of -S (start) or -K (stop)");
  426. #endif
  428. if (!execname && !pidfile && !userspec)
  429. badusage("need at least one of --exec, --pidfile or --user");
  431. if (!startas)
  432. startas = execname;
  434. if (start && !startas)
  435. badusage("--start needs --exec or --startas");
  437. if (mpidfile && pidfile == NULL)
  438. badusage("--make-pidfile is only relevant with --pidfile");
  440. if (background && !start)
  441. badusage("--background is only relevant with --start");
  443. }
  445. #if defined(OSLinux)
  446. static int
  447. pid_is_exec(int pid, const struct stat *esb)
  448. {
  449. struct stat sb;
  450. char buf[32];
  452. sprintf(buf, "/proc/%d/exe", pid);
  453. if (stat(buf, &sb) != 0)
  454. return 0;
  455. return (sb.st_dev == esb->st_dev && sb.st_ino == esb->st_ino);
  456. }
  459. static int
  460. pid_is_user(int pid, int uid)
  461. {
  462. struct stat sb;
  463. char buf[32];
  465. sprintf(buf, "/proc/%d", pid);
  466. if (stat(buf, &sb) != 0)
  467. return 0;
  468. return ((int) sb.st_uid == uid);
  469. }
  472. static int
  473. pid_is_cmd(int pid, const char *name)
  474. {
  475. char buf[32];
  476. FILE *f;
  477. int c;
  479. sprintf(buf, "/proc/%d/stat", pid);
  480. f = fopen(buf, "r");
  481. if (!f)
  482. return 0;
  483. while ((c = getc(f)) != EOF && c != '(')
  484. ;
  485. if (c != '(') {
  486. fclose(f);
  487. return 0;
  488. }
  489. /* this hopefully handles command names containing ')' */
  490. while ((c = getc(f)) != EOF && c == *name)
  491. name++;
  492. fclose(f);
  493. return (c == ')' && *name == '');
  494. }
  495. #endif /* OSLinux */
  497. #if defined(OSHURD)
  498. static int
  499. pid_is_user(int pid, int uid)
  500. {
  501.    struct stat sb;
  502.    char buf[32];
  503.    struct proc_stat *pstat;
  505.    sprintf(buf, "/proc/%d", pid);
  506.    if (stat(buf, &sb) != 0)
  507.        return 0;
  508.    return (sb.st_uid == uid);
  509.    pstat = proc_stat_list_pid_proc_stat (procset, pid);
  510.    if (pstat == NULL)
  511.        fatal ("Error getting process information: NULL proc_stat struct");
  512.    proc_stat_set_flags (pstat, PSTAT_PID | PSTAT_OWNER_UID);
  513.    return (pstat->owner_uid == uid);
  514. }
  516. static int
  517. pid_is_cmd(int pid, const char *name)
  518. {
  519.    struct proc_stat *pstat;
  520.    pstat = proc_stat_list_pid_proc_stat (procset, pid);
  521.    if (pstat == NULL)
  522.        fatal ("Error getting process information: NULL proc_stat struct");
  523.    proc_stat_set_flags (pstat, PSTAT_PID | PSTAT_ARGS);
  524.    return (!strcmp (name, pstat->args));
  525. }
  526. #endif /* OSHURD */
  528. #if defined(SunOS)
  529. /*
  530. Lots of lovely system dependant functions for Solaris.  I used to like the
  531. idea of proc, but now I'm not so sure.  It feels to much like a kludge.
  532. */
  534. /*
  535. pid_is_user, takes the pid and a uid, normally ours, but can be someone
  536. elses, to allow you to identify the process' owner. returns zero on success,
  537. and either true or the uid of the owner on failure (this may be undefined,
  538. or I may be misremembering.
  539. */
  540. static int
  541. pid_is_user(int pid, int uid)
  542. {
  543.    struct stat sb;
  544.    char buf[32];
  546.    sprintf(buf, "/proc/%d", pid);
  547.    if (stat(buf, &sb) != 0)
  548.       return 0; /*I can stat it so it seems to be mine...*/
  549.    return ((int) sb.st_uid == uid);
  550. }
  552. /*
  553. pid_is_cmd, takes a pid, and a string representing the process' (supposed)
  554. name.  Compares the process' supposed name with the name reported by the
  555. system.  Returns zero on failure, and nonzero on success.
  556. */
  557. static int
  558. pid_is_cmd(int pid, const char *name)
  559. {
  560.    char buf[32];
  561.    FILE *f;
  562.    psinfo_t pid_info;
  564.    sprintf(buf, "/proc/%d/psinfo", pid);
  565.    f = fopen(buf, "r");
  566.    if (!f)
  567.       return 0;
  568.    fread(&pid_info,sizeof(psinfo_t),1,f);
  569.    return (!strcmp(name,pid_info.pr_fname));
  570. }
  571. #endif /*SunOS*/
  573. #ifdef FreeBSD
  574. static int pid_is_user(int pid, int uid)
  575. {
  576.  struct stat sb;
  577.  char buf[32];
  579.  sprintf(buf, "/proc/%d", pid);
  580.  if (stat(buf, &sb) != 0)
  581.   return 0;
  582.  return ((int) sb.st_uid == uid);
  583. }
  585. static int
  586. pid_is_cmd(int pid, const char *name)
  587. {
  588. char buf[32];
  589. FILE *f;
  590. int c;
  592. sprintf(buf, "/proc/%d/stat", pid);
  593. f = fopen(buf, "r");
  594. if (!f)
  595. return 0;
  596. while ((c = getc(f)) != EOF && c != '(')
  597. ;
  598. if (c != '(') {
  599. fclose(f);
  600. return 0;
  601. }
  602. /* this hopefully handles command names containing ')' */
  603. while ((c = getc(f)) != EOF && c == *name)
  604. name++;
  605. fclose(f);
  606. return (c == ')' && *name == '');
  607. }
  608. #endif /*FreeBSD*/
  610. static void
  611. check(int pid)
  612. {
  613. #if defined(OSLinux)
  614. if (execname && !pid_is_exec(pid, &exec_stat))
  615. #elif defined(OSHURD)
  616.     /* I will try this to see if it works */
  617. if (execname && !pid_is_cmd(pid, execname))
  618. #endif
  619. return;
  620. if (userspec && !pid_is_user(pid, user_id))
  621. return;
  622. if (cmdname && !pid_is_cmd(pid, cmdname))
  623. return;
  624. push(&found, pid);
  625. }
  628. static void
  629. do_pidfile(const char *name)
  630. {
  631. FILE *f;
  632. int pid;
  634. f = fopen(name, "r");
  635. if (f) {
  636. if (fscanf(f, "%d", &pid) == 1)
  637. check(pid);
  638. fclose(f);
  639. }
  640. }
  642. /* WTA: this  needs to be an autoconf check for /proc/pid existance.
  643.  */
  644. #if defined(OSLinux) || defined (SunOS) || defined(FreeBSD)
  645. static void
  646. do_procinit(void)
  647. {
  648. DIR *procdir;
  649. struct dirent *entry;
  650. int foundany, pid;
  652. procdir = opendir("/proc");
  653. if (!procdir)
  654. fatal("opendir /proc: %s", strerror(errno));
  656. foundany = 0;
  657. while ((entry = readdir(procdir)) != NULL) {
  658. if (sscanf(entry->d_name, "%d", &pid) != 1)
  659. continue;
  660. foundany++;
  661. check(pid);
  662. }
  663. closedir(procdir);
  664. if (!foundany)
  665. fatal("nothing in /proc - not mounted?");
  666. }
  667. #endif /* OSLinux */
  670. #if defined(OSHURD)
  671. error_t
  672. check_all (void *ptr)
  673. {
  674.    struct proc_stat *pstat = ptr;
  676.    check (pstat->pid);
  677.    return (0);
  678. }
  680. static void
  681. do_psinit(void)
  682.    error_t err;
  684.    err = ps_context_create (getproc (), &context);
  685.    if (err)
  686.        error (1, err, "ps_context_create");
  688.    err = proc_stat_list_create (context, &procset);
  689.    if (err)
  690.        error (1, err, "proc_stat_list_create");
  692.    err = proc_stat_list_add_all (procset, 0, 0);
  693.    if (err)
  694.        error (1, err, "proc_stat_list_add_all");
  696.    /* Check all pids */
  697.    ihash_iterate (context->procs, check_all);
  698. }
  699. #endif /* OSHURD */
  701. /* return 1 on failure */
  702. static int
  703. do_stop(void)
  704. {
  705. char what[1024];
  706. struct pid_list *p;
  707. int retval = 0;
  709. if (cmdname)
  710. strcpy(what, cmdname);
  711. else if (execname)
  712. strcpy(what, execname);
  713. else if (pidfile)
  714. sprintf(what, "process in pidfile `%s'", pidfile);
  715. else if (userspec)
  716. sprintf(what, "process(es) owned by `%s'", userspec);
  717. else
  718. fatal("internal error, please report");
  720. if (!found) {
  721. if (quietmode <= 0)
  722. printf("No %s found running; none killed.n", what);
  723. exit(exitnodo);
  724. }
  725. for (p = found; p; p = p->next) {
  726. if (testmode)
  727. printf("Would send signal %d to %d.n",
  728.        signal_nr, p->pid);
  729. else if (kill(p->pid, signal_nr) == 0)
  730. push(&killed, p->pid);
  731. else {
  732. printf("%s: warning: failed to kill %d: %sn",
  733.        progname, p->pid, strerror(errno));
  734. retval += exitnodo;
  735. }
  736. }
  737. if (quietmode < 0 && killed) {
  738. printf("Stopped %s (pid", what);
  739. for (p = killed; p; p = p->next)
  740. printf(" %d", p->pid);
  741. printf(").n");
  742. }
  743. return retval;
  744. }
  747. int
  748. main(int argc, char **argv)
  749. {
  750. progname = argv[0];
  752. parse_options(argc, argv);
  753. argc -= optind;
  754. argv += optind;
  756. if (execname && stat(execname, &exec_stat))
  757. fatal("stat %s: %s", execname, strerror(errno));
  759. if (userspec && sscanf(userspec, "%d", &user_id) != 1) {
  760. struct passwd *pw;
  762. pw = getpwnam(userspec);
  763. if (!pw)
  764. fatal("user `%s' not foundn", userspec);
  766. user_id = pw->pw_uid;
  767. }
  769. if (changegroup && sscanf(changegroup, "%d", &runas_gid) != 1) {
  770. struct group *gr = getgrnam(changegroup);
  771. if (!gr)
  772. fatal("group `%s' not foundn", changegroup);
  773. runas_gid = gr->gr_gid;
  774. }
  775. if (changeuser && sscanf(changeuser, "%d", &runas_uid) != 1) {
  776. struct passwd *pw = getpwnam(changeuser);
  777. if (!pw)
  778. fatal("user `%s' not foundn", changeuser);
  779. runas_uid = pw->pw_uid;
  780. if (changegroup == NULL) { /* pass the default group of this user */
  781. changegroup = ""; /* just empty */
  782. runas_gid = pw->pw_gid;
  783. }
  784. }
  786. if (pidfile)
  787. do_pidfile(pidfile);
  788. else
  789. do_procinit();
  791. if (stop) {
  792. int i = do_stop();
  793. if (i) {
  794. if (quietmode <= 0)
  795. printf("%d pids were not killedn", i);
  796. exit(1);
  797. }
  798. exit(0);
  799. }
  801. if (found) {
  802. if (quietmode <= 0)
  803. printf("%s already running.n", execname);
  804. exit(exitnodo);
  805. }
  806. if (testmode) {
  807. printf("Would start %s ", startas);
  808. while (argc-- > 0)
  809. printf("%s ", *argv++);
  810. if (changeuser != NULL) {
  811. printf(" (as user %s[%d]", changeuser, runas_uid);
  812. if (changegroup != NULL)
  813. printf(", and group %s[%d])", changegroup, runas_gid);
  814. else
  815. printf(")");
  816. }
  817. if (changeroot != NULL)
  818. printf(" in directory %s", changeroot);
  819. printf(".n");
  820. exit(0);
  821. }
  822. if (quietmode < 0)
  823. printf("Starting %s...n", startas);
  824. *--argv = startas;
  825. if (changeroot != NULL) {
  826. if (chdir(changeroot) < 0)
  827. fatal("Unable to chdir() to %s", changeroot);
  828. if (chroot(changeroot) < 0)
  829. fatal("Unable to chroot() to %s", changeroot);
  830. }
  831. if (changeuser != NULL) {
  832.   if (setgid(runas_gid))
  833.   fatal("Unable to set gid to %d", runas_gid);
  834. if (initgroups(changeuser, runas_gid))
  835. fatal("Unable to set initgroups() with gid %d", runas_gid);
  836. if (setuid(runas_uid))
  837. fatal("Unable to set uid to %s", changeuser);
  838. }
  840. if (background) { /* ok, we need to detach this process */
  841. int i, fd;
  842. if (quietmode < 0)
  843. printf("Detatching to start %s...", startas);
  844. i = fork();
  845. if (i<0) {
  846. fatal("Unable to fork.n");
  847. }
  848. if (i) { /* parent */
  849. if (quietmode < 0)
  850. printf("done.n");
  851. exit(0);
  852. }
  853.  /* child continues here */
  854.  /* now close all extra fds */
  855. for (i=getdtablesize()-1; i>=0; --i) close(i);
  856.  /* change tty */
  857. fd = open("/dev/tty", O_RDWR);
  858. ioctl(fd, TIOCNOTTY, 0);
  859. close(fd);
  860. chdir("/");
  861. umask(022); /* set a default for dumb programs */
  862. #ifndef FreeBSD
  863. setpgrp();  /* set the process group */
  864. #else
  865. setpgrp(0, runas_gid);  /* set the process group */
  866. #endif
  867. fd=open("/dev/null", O_RDWR); /* stdin */
  868. dup(fd); /* stdout */
  869. dup(fd); /* stderr */
  870. }
  871. if (mpidfile && pidfile != NULL) { /* user wants _us_ to make the pidfile :) */
  872. FILE *pidf = fopen(pidfile, "w");
  873. pid_t pidt = getpid();
  874. if (pidf == NULL)
  875. fatal("Unable to open pidfile `%s' for writing: %s", pidfile,
  876. strerror(errno));
  877. fprintf(pidf, "%dn", (int)pidt);
  878. fclose(pidf);
  879. }
  880. execv(startas, argv);
  881. fatal("Unable to start %s: %s", startas, strerror(errno));
  882. }