int main (int argc, char *argv[]) { /* Initialize command buffer */ char* cmdLine = malloc(sizeof(char*)*BUFSIZE); /* shell initialization */ if (signal(SIGINT, sig_handler) == SIG_ERR) PrintPError("SIGINT"); if (signal(SIGTSTP, sig_handler) == SIG_ERR) PrintPError("SIGTSTP"); while (!forceExit) /* repeat forever */ { /* read command line */ getCommandLine(&cmdLine, BUFSIZE); if(strcmp(cmdLine, "exit") == 0) { forceExit=TRUE; continue; } //printf("after exit\n"); /* checks the status of background jobs */ //if(strcmp(cmdLine, "jobs") != 0){ CheckJobs(); //printf("after checkjobs\n"); //} /* interpret command and line * includes executing of commands */ Interpret(cmdLine); } /* shell termination */ free(cmdLine); return 0; } /* end main */
void StopJob(){ if(fgpid > 0) { kill(-fgpid, SIGTSTP); stopped = 1; AddJobToBg(fgpid); MarkJobAsStopped(fgpid); fgpid = -1; CheckJobs(); } }
/* * main * * arguments: * int argc: the number of arguments provided on the command line * char *argv[]: array of strings provided on the command line * * returns: int: 0 = OK, else error * * This sets up signal handling and implements the main loop of tsh. */ int main(int argc, char *argv[]) { /* Initialize command buffer */ char* cmdLine = malloc(sizeof(char*) * BUFSIZE); /* shell initialization */ if (signal(SIGINT, sig) == SIG_ERR) PrintPError("SIGINT"); if (signal(SIGTSTP, sig) == SIG_ERR) PrintPError("SIGTSTP"); while (!forceExit) /* repeat forever */ { char* prompt = getenv("PS1"); if (prompt != NULL) { printf("%s", prompt); } /* read command line */ getCommandLine(&cmdLine, BUFSIZE); if (strcmp(cmdLine, "exit") == 0) forceExit = TRUE; /* checks the status of background jobs */ if (!forceExit) { CheckJobs(); } /* interpret command and line * includes executing of commands */ Interpret(cmdLine); } bgjobL* curr = bgjobs; while (curr != NULL) { curr = bgjobs; int status; int res = waitpid(curr->pid, &status, WNOHANG | WUNTRACED | WCONTINUED); if (!(res == curr->pid && !WIFCONTINUED(status))) { kill(curr->pid, SIGKILL); } RemoveJob(curr->jid); } /* shell termination */ free(cmdLine); return 0; } /* main */
int main (int argc, char *argv[]) { /* Initialize command buffer */ char* cmdLine = malloc(sizeof(char*)*BUFSIZE); fgcommands = (char *) malloc(500 * sizeof(char)); /* shell initialization */ if (signal(SIGINT, sig) == SIG_ERR) PrintPError("SIGINT"); if (signal(SIGTSTP, sig) == SIG_ERR) PrintPError("SIGTSTP"); if (signal(SIGCHLD, sig) == SIG_ERR) PrintPError("SIGCHLD"); // printPrompt(); while (!forceExit) /* repeat forever */ { //printPrompt(); /* read command line */ getCommandLine(&cmdLine, BUFSIZE); //cmdLine = strdup(checkAlias2(cmdLine)); //printf("The new is %s\n", cmdLine); if(strcmp(cmdLine, "exit") == 0 ) { forceExit=TRUE; continue; } else if (feof(stdin)){ //printf("\n"); forceExit = TRUE; break; } fgpid = 0; /* checks the status of background jobs */ CheckJobs(); /* interpret command and line * includes executing of commands */ Interpret(cmdLine); //fflush(stdout); fgpid = 0; } /* shell termination */ free(cmdLine); free(fgcommands); return 0; } /* end main */
int main (int argc, char *argv[]) { /* Initialize command buffer */ char* cmdLine = malloc(sizeof(char*)*BUFSIZE); /* shell initialization */ if (signal(SIGINT, sig_handler) == SIG_ERR) PrintPError("SIGINT"); if (signal(SIGTSTP, sig_handler) == SIG_ERR) PrintPError("SIGTSTP"); while (TRUE) /* repeat forever */ { /* print prompt */ printf("%%"); //printf("my status: %d", waitpid(getpid(), &status, WNOHANG)); //printf("%%"); /* read command line */ getCommandLine(&cmdLine, BUFSIZE); if(strcmp(cmdLine, "exit") == 0 || feof(stdin)) { forceExit=TRUE; break; } else { // If we juse printf(cmdLine), compiler gives a warning because the cmdLine can contain things like %s // and the program will try to find some string that does not exist. This could be exploited to run virus. //fprintf(stderr, "%s", cmdLine); } /* checks the status of background jobs */ CheckJobs(); /* interpret command and line * includes executing of commands */ Interpret(cmdLine); } // make sure all the shell's child processes are terminated if (forceExit == TRUE) { while (bgjobs != NULL) { kill(bgjobs->pid, SIGINT); bgjobs = bgjobs->next; } } /* shell termination */ free(cmdLine); return 0; } /* end main */
/* * main * * arguments: * int argc: the number of arguments provided on the command line * char *argv[]: array of strings provided on the command line * * returns: int: 0 = OK, else error * * This sets up signal handling and implements the main loop of tsh. */ int main(int argc, char *argv[]) { /* Initialize command buffer */ char* cmdLine = malloc(sizeof(char*) * BUFSIZE); /* shell initialization */ if (signal(SIGINT, sig) == SIG_ERR) PrintPError("SIGINT"); if (signal(SIGTSTP, sig) == SIG_ERR) PrintPError("SIGTSTP"); /* Terminated or stopped child */ while (!forceExit) /* repeat forever */ { /*Insert tsh$ prompt*/ printPrompt(); /* read command line */ getCommandLine(&cmdLine, BUFSIZE); if (strcmp(cmdLine, "exit") == 0) forceExit = TRUE; /* checks the status of background jobs */ if(!forceExit){ CheckJobs(); fflush(NULL); } /* interpret command and line * includes executing of commands */ Interpret(cmdLine); fflush(NULL); //getPath(); } /* shell termination */ free(cmdLine); return 0; } /* main */
int main (int argc, char *argv[]) { /* Initialize command buffer */ char* cmdLine = malloc(sizeof(char*)*BUFSIZE); /* shell initialization */ if (signal(SIGINT, sig) == SIG_ERR) PrintPError("SIGINT"); if (signal(SIGTSTP, sig) == SIG_ERR) PrintPError("SIGTSTP"); if (signal(SIGCONT, sig) == SIG_ERR) PrintPError("SIGCONT"); if (signal(SIGCHLD, sigHandler) == SIG_ERR) PrintPError("SIGCHLD"); while (!forceExit) /* repeat forever */ { printPrompt(); /* read command line */ getCommandLine(&cmdLine, BUFSIZE); // strcmp: string compare if(strcmp(cmdLine, "exit") == 0) { forceExit=TRUE; continue; } /* checks the status of background jobs */ CheckJobs(); /* interpret command and line * includes executing of commands */ Interpret(cmdLine); } /* shell termination */ free(cmdLine); releaseAlias(aliasList); /* print all lists and check printf("\n\n ---------TERMINATE SHELL--------\n"); printf("Alias:\n"); printAlias();*/ return 0; } /* end main */
int crond_main(int ac, char **av) { unsigned long opt; char *lopt, *Lopt, *copt; #ifdef FEATURE_DEBUG_OPT char *dopt; bb_opt_complementally = "f-b:b-f:S-L:L-S:d-l"; #else bb_opt_complementally = "f-b:b-f:S-L:L-S"; #endif opterr = 0; /* disable getopt 'errors' message. */ opt = bb_getopt_ulflags(ac, av, "l:L:fbSc:" #ifdef FEATURE_DEBUG_OPT "d:" #endif , &lopt, &Lopt, &copt #ifdef FEATURE_DEBUG_OPT , &dopt #endif ); if (opt & 1) { LogLevel = atoi(lopt); } if (opt & 2) { if (*Lopt != 0) { LogFile = Lopt; } } if (opt & 32) { if (*copt != 0) { CDir = copt; } } #ifdef FEATURE_DEBUG_OPT if (opt & 64) { DebugOpt = atoi(dopt); LogLevel = 0; } #endif /* * change directory */ if (chdir(CDir) != 0) { bb_perror_msg_and_die("%s", CDir); } signal(SIGHUP, SIG_IGN); /* hmm.. but, if kill -HUP original * version - his died. ;( */ /* * close stdin and stdout, stderr. * close unused descriptors - don't need. * optional detach from controlling terminal */ if (!(opt & 4)) { #if defined(__uClinux__) /* reexec for vfork() do continue parent */ vfork_daemon_rexec(1, 0, ac, av, "-f"); #else /* uClinux */ if (daemon(1, 0) < 0) { bb_perror_msg_and_die("daemon"); } #endif /* uClinux */ } (void) startlogger(); /* need if syslog mode selected */ /* * main loop - synchronize to 1 second after the minute, minimum sleep * of 1 second. */ crondlog("\011%s " VERSION " dillon, started, log level %d\n", bb_applet_name, LogLevel); SynchronizeDir(); { time_t t1 = time(NULL); time_t t2; long dt; short rescan = 60; short sleep_time = 60; for (;;) { sleep((sleep_time + 1) - (short) (time(NULL) % sleep_time)); t2 = time(NULL); dt = t2 - t1; /* * The file 'cron.update' is checked to determine new cron * jobs. The directory is rescanned once an hour to deal * with any screwups. * * check for disparity. Disparities over an hour either way * result in resynchronization. A reverse-indexed disparity * less then an hour causes us to effectively sleep until we * match the original time (i.e. no re-execution of jobs that * have just been run). A forward-indexed disparity less then * an hour causes intermediate jobs to be run, but only once * in the worst case. * * when running jobs, the inequality used is greater but not * equal to t1, and less then or equal to t2. */ if (--rescan == 0) { rescan = 60; SynchronizeDir(); } CheckUpdates(); #ifdef FEATURE_DEBUG_OPT if (DebugOpt) crondlog("\005Wakeup dt=%d\n", dt); #endif if (dt < -60 * 60 || dt > 60 * 60) { t1 = t2; crondlog("\111time disparity of %d minutes detected\n", dt / 60); } else if (dt > 0) { TestJobs(t1, t2); RunJobs(); sleep(5); if (CheckJobs() > 0) { sleep_time = 10; } else { sleep_time = 60; } t1 = t2; } } } /* not reached */ }
int crond_main(int argc ATTRIBUTE_UNUSED, char **argv) { unsigned opt; INIT_G(); /* "-b after -f is ignored", and so on for every pair a-b */ opt_complementary = "f-b:b-f:S-L:L-S" USE_DEBUG_CROND_OPTION(":d-l") ":l+:d+"; /* -l and -d have numeric param */ opt = getopt32(argv, "l:L:fbSc:" USE_DEBUG_CROND_OPTION("d:"), &LogLevel, &LogFile, &CDir USE_DEBUG_CROND_OPTION(,&LogLevel)); /* both -d N and -l N set the same variable: LogLevel */ if (!(opt & OPT_f)) { /* close stdin, stdout, stderr. * close unused descriptors - don't need them. */ bb_daemonize_or_rexec(DAEMON_CLOSE_EXTRA_FDS, argv); } if (!DebugOpt && LogFile == NULL) { /* logging to syslog */ openlog(applet_name, LOG_CONS | LOG_PID, LOG_CRON); logmode = LOGMODE_SYSLOG; } xchdir(CDir); //signal(SIGHUP, SIG_IGN); /* ? original crond dies on HUP... */ setenv("SHELL", DEFAULT_SHELL, 1); /* once, for all future children */ crondlog(LVL9 "crond (busybox "BB_VER") started, log level %d", LogLevel); SynchronizeDir(); /* main loop - synchronize to 1 second after the minute, minimum sleep * of 1 second. */ { time_t t1 = time(NULL); time_t t2; long dt; int rescan = 60; int sleep_time = 60; write_pidfile("/var/run/crond.pid"); for (;;) { sleep((sleep_time + 1) - (time(NULL) % sleep_time)); t2 = time(NULL); dt = (long)t2 - (long)t1; /* * The file 'cron.update' is checked to determine new cron * jobs. The directory is rescanned once an hour to deal * with any screwups. * * check for disparity. Disparities over an hour either way * result in resynchronization. A reverse-indexed disparity * less then an hour causes us to effectively sleep until we * match the original time (i.e. no re-execution of jobs that * have just been run). A forward-indexed disparity less then * an hour causes intermediate jobs to be run, but only once * in the worst case. * * when running jobs, the inequality used is greater but not * equal to t1, and less then or equal to t2. */ if (--rescan == 0) { rescan = 60; SynchronizeDir(); } CheckUpdates(); if (DebugOpt) crondlog(LVL5 "wakeup dt=%ld", dt); if (dt < -60 * 60 || dt > 60 * 60) { crondlog(WARN9 "time disparity of %d minutes detected", dt / 60); } else if (dt > 0) { TestJobs(t1, t2); RunJobs(); sleep(5); if (CheckJobs() > 0) { sleep_time = 10; } else { sleep_time = 60; } } t1 = t2; } } return 0; /* not reached */ }
int main(int ac, char **av) { const char *LevelAry[] = { "emerg", "alert", "crit", "err", "warning", "notice", "info", "debug", "panic", "error", "warn", NULL }; int i; /* * parse options */ DaemonUid = getuid(); opterr = 0; while ((i = getopt(ac,av,"dl:L:fbSc:s:m:M:t:")) != -1) { switch (i) { case 'l': { char *ptr; int j; ptr = optarg; for (j = 0; LevelAry[j]; ++j) { if (strncmp(ptr, LevelAry[j], strlen(LevelAry[j])) == 0) { break; } } switch(j) { case 0: case 8: /* #define LOG_EMERG 0 [* system is unusable *] */ LogLevel = LOG_EMERG; break; case 1: /* #define LOG_ALERT 1 [* action must be taken immediately *] */ LogLevel = LOG_ALERT; break; case 2: /* #define LOG_CRIT 2 [* critical conditions *] */ LogLevel = LOG_CRIT; break; case 3: case 9: /* #define LOG_ERR 3 [* error conditions *] */ LogLevel = LOG_ERR; break; case 4: case 10: /* #define LOG_WARNING 4 [* warning conditions *] */ LogLevel = LOG_WARNING; break; case 5: /* #define LOG_NOTICE 5 [* normal but significant condition *] */ LogLevel = LOG_NOTICE; break; case 6: /* #define LOG_INFO 6 [* informational *] */ LogLevel = LOG_INFO; break; case 7: /* #define LOG_DEBUG 7 [* debug-level messages *] */ LogLevel = LOG_DEBUG; break; default: LogLevel = atoi(optarg); } } break; case 'd': DebugOpt = 1; LogLevel = LOG_DEBUG; /* fall through to include f too */ case 'f': ForegroundOpt = 1; break; case 'b': ForegroundOpt = 0; break; case 'S': /* log through syslog */ SyslogOpt = 1; break; case 'L': /* use internal log formatter */ SyslogOpt = 0; LogFile = optarg; /* if LC_TIME is defined, we use it for logging to file instead of compiled-in TIMESTAMP_FMT */ if (getenv("LC_TIME") != NULL) { LogHeader = LOCALE_LOGHEADER; } break; case 'c': if (*optarg != 0) CDir = optarg; break; case 's': if (*optarg != 0) SCDir = optarg; break; case 't': if (*optarg != 0) TSDir = optarg; break; case 'M': if (*optarg != 0) SendMail = optarg; break; case 'm': if (*optarg != 0) Mailto = optarg; break; default: /* * check for parse error */ printf("dillon's cron daemon " VERSION "\n"); printf("crond [-s dir] [-c dir] [-t dir] [-m user@host] [-M mailer] [-S|-L [file]] [-l level] [-b|-f|-d]\n"); printf("-s directory of system crontabs (defaults to %s)\n", SCRONTABS); printf("-c directory of per-user crontabs (defaults to %s)\n", CRONTABS); printf("-t directory of timestamps (defaults to %s)\n", CRONSTAMPS); printf("-m user@host where should cron output be directed? (defaults to local user)\n"); printf("-M mailer (defaults to %s)\n", SENDMAIL); printf("-S log to syslog using identity '%s' (default)\n", LOG_IDENT); printf("-L file log to specified file instead of syslog\n"); printf("-l loglevel log events <= this level (defaults to %s (level %d))\n", LevelAry[LOG_LEVEL], LOG_LEVEL); printf("-b run in background (default)\n"); printf("-f run in foreground\n"); printf("-d run in debugging mode\n"); exit(2); } } /* * close stdin and stdout. * close unused descriptors - don't need. * optional detach from controlling terminal */ fclose(stdin); fclose(stdout); i = open("/dev/null", O_RDWR); if (i < 0) { perror("open: /dev/null"); exit(1); } dup2(i, 0); dup2(i, 1); /* create tempdir with permissions 0755 for cron output */ TempDir = strdup(TMPDIR "/cron.XXXXXX"); if (mkdtemp(TempDir) == NULL) { perror("mkdtemp"); exit(1); } if (chmod(TempDir, S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH)) { perror("chmod"); exit(1); } if (!(TempFileFmt = concat(TempDir, "/cron.%s.%d", NULL))) { errno = ENOMEM; perror("main"); exit(1); } if (ForegroundOpt == 0) { int fd; int pid; if ((pid = fork()) < 0) { /* fork failed */ perror("fork"); exit(1); } else if (pid > 0) { /* parent */ exit(0); } /* child continues */ /* become session leader, detach from terminal */ if (setsid() < 0) perror("setsid"); if ((fd = open("/dev/tty", O_RDWR)) >= 0) { ioctl(fd, TIOCNOTTY, 0); close(fd); } /* setup logging for backgrounded daemons */ if (SyslogOpt) { /* start SIGHUP and SIGCHLD handling while stderr still open */ initsignals(); /* 2> /dev/null */ fclose(stderr); dup2(1, 2); /* open syslog */ openlog(LOG_IDENT, LOG_CONS|LOG_PID, LOG_CRON); } else { /* open logfile */ if ((fd = open(LogFile, O_WRONLY|O_CREAT|O_APPEND, 0600)) >= 0) { /* start SIGHUP ignoring, SIGCHLD handling while stderr still open */ initsignals(); /* 2> LogFile */ fclose(stderr); dup2(fd, 2); } else { int n = errno; fdprintf(2, "failed to open logfile '%s', reason: %s", LogFile, strerror(n)); exit(n); } } } else { /* daemon in foreground */ /* stay in existing session, but start a new process group */ if (setpgid(0,0)) { perror("setpgid"); exit(1); } /* stderr stays open, start SIGHUP ignoring, SIGCHLD handling */ initsignals(); } /* close all other fds, including the ones we opened as /dev/null and LogFile */ for (i = 3; i < MAXOPEN; ++i) { close(i); } /* * main loop - synchronize to 1 second after the minute, minimum sleep * of 1 second. */ printlogf(LOG_NOTICE,"%s " VERSION " dillon's cron daemon, started with loglevel %s\n", av[0], LevelAry[LogLevel]); SynchronizeDir(CDir, NULL, 1); SynchronizeDir(SCDir, "root", 1); ReadTimestamps(NULL); TestStartupJobs(); /* @startup jobs only run when crond is started, not when their crontab is loaded */ { time_t t1 = time(NULL); time_t t2; long dt; short rescan = 60; short stime = 60; for (;;) { sleep((stime + 1) - (short)(time(NULL) % stime)); t2 = time(NULL); dt = t2 - t1; /* * The file 'cron.update' is checked to determine new cron * jobs. The directory is rescanned once an hour to deal * with any screwups. * * check for disparity. Disparities over an hour either way * result in resynchronization. A reverse-indexed disparity * less then an hour causes us to effectively sleep until we * match the original time (i.e. no re-execution of jobs that * have just been run). A forward-indexed disparity less then * an hour causes intermediate jobs to be run, but only once * in the worst case. * * when running jobs, the inequality used is greater but not * equal to t1, and less then or equal to t2. */ if (--rescan == 0) { /* * If we resynchronize while jobs are running, we'll clobber * the job pids, so we won't know what's already running. */ if (CheckJobs() > 0) { rescan = 1; } else { rescan = 60; SynchronizeDir(CDir, NULL, 0); SynchronizeDir(SCDir, "root", 0); ReadTimestamps(NULL); } } else { CheckUpdates(CDir, NULL, t1, t2); CheckUpdates(SCDir, "root", t1, t2); } if (DebugOpt) printlogf(LOG_DEBUG, "Wakeup dt=%d\n", dt); if (dt < -60*60 || dt > 60*60) { t1 = t2; printlogf(LOG_NOTICE,"time disparity of %d minutes detected\n", dt / 60); } else if (dt > 0) { TestJobs(t1, t2); RunJobs(); sleep(5); if (CheckJobs() > 0) stime = 10; else stime = 60; t1 = t2; } } } /* not reached */ }