diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/Makefile | 31 | ||||
| -rw-r--r-- | src/initlog.1 | 48 | ||||
| -rw-r--r-- | src/initlog.c | 317 | ||||
| -rw-r--r-- | src/initlog.h | 16 | ||||
| -rw-r--r-- | src/minilogd.c | 164 | ||||
| -rw-r--r-- | src/process.c | 216 | ||||
| -rw-r--r-- | src/process.h | 9 |
7 files changed, 792 insertions, 9 deletions
diff --git a/src/Makefile b/src/Makefile index c0e3f573..c2751e9e 100644 --- a/src/Makefile +++ b/src/Makefile @@ -1,6 +1,6 @@ -CFLAGS+=-Wall +CFLAGS+=-Wall -D_GNU_SOURCE -PROGS=usernetctl doexec netreport testd usleep ipcalc +PROGS=usernetctl doexec netreport testd usleep ipcalc initlog minilogd all: $(PROGS) @@ -9,11 +9,14 @@ clean: install: mkdir -p $(ROOT)/bin $(ROOT)/usr/sbin $(ROOT)/usr/man/man1 - install -o 0 -g 0 -s -m 755 doexec $(ROOT)/bin/doexec - install -o 0 -g 0 -s -m 755 usleep $(ROOT)/bin/usleep - install -o 0 -g 0 -s -m 4755 usernetctl $(ROOT)/usr/sbin/usernetctl - install -o 0 -g 0 -s -m 2755 netreport $(ROOT)/sbin/netreport - install -o 0 -g 0 -s -m 755 ipcalc $(ROOT)/bin/ipcalc + install -s -m 755 doexec $(ROOT)/bin/doexec + install -s -m 755 usleep $(ROOT)/bin/usleep + install -s -m 4755 usernetctl $(ROOT)/usr/sbin/usernetctl + install -s -m 2755 netreport $(ROOT)/sbin/netreport + install -s -m 755 ipcalc $(ROOT)/bin/ipcalc + install -s -m 755 initlog $(ROOT)/sbin/initlog + install -s -m 755 minilogd $(ROOT)/sbin/minilogd + install -m 644 initlog.1 $(ROOT)/usr/man/man1 install -m 644 doexec.1 $(ROOT)/usr/man/man1 install -m 644 netreport.1 $(ROOT)/usr/man/man1 install -m 644 usleep.1 $(ROOT)/usr/man/man1 @@ -23,8 +26,18 @@ install: # this daemon and initscript are useful for testing the up/down/status stuff # not installed by default, only comes from sources. install-test: - install -o 0 -g 0 -s -m 755 testd $(ROOT)/usr/sbin/testd - install -o 0 -g 0 -m 755 testdinit $(ROOT)/etc/rc.d/init.d/testd + install -s -m 755 testd $(ROOT)/usr/sbin/testd + install -m 755 testdinit $(ROOT)/etc/rc.d/init.d/testd ipcalc: ipcalc.o $(CC) $(LDFLAGS) -o $@ $< -lpopt + +minilogd: minilogd.o + $(CC) $(LDFLAGS) -o $@ $< + +initlog: initlog.o process.o + $(CC) $(LDFLAGS) -o $@ $< -lpopt + +clean: + rm ipcalc initlog minilogd *.o core *~ + diff --git a/src/initlog.1 b/src/initlog.1 new file mode 100644 index 00000000..103ef3fd --- /dev/null +++ b/src/initlog.1 @@ -0,0 +1,48 @@ +.TH initlog 8 "Sun Jan 24 1999" +.SH NAME +initlog \- log messages and events to the system logger +.SH SYNOPSIS +.B initlog +[\-cefnprs] [\-\-cmd=ARG] [\-\-event=ARG] [\-\-facility=ARG] +[\-\-name=ARG] [\-\-priority=ARG] [\-\-run=ARG] [\-\-string=ARG] +.SH DESCRIPTION +\fBinitlog\fR logs messages and events to the system logger. +It is mainly designed for use in init scripts. + +.SS OPTIONS +.TP +.I "\-c, \-\-cmd=[program]" +Execute the specified program, logging anything output to +stdout or stderr. +.TP +.I "\-e, \-\-event=[number]" +Logs that the specified event happened. Usually used in conjuction +with \fB\-\-name\fR. Currently specified events are: +.nf + \fB1\fR the action completed successfully + \fB2\fR the action failed + \fB3\fR the action was cancelled at user request + \fB4\fR the action failed due to the failure of a dependent action +.TP +.I "\-f, \-\-facility=[facility]" + +Log at the specified syslog facility. The default +is \fBdaemon\fR (see syslog(3)). +.TP +.I "\-n, \-\-name=[string]" +Log the event under the specified string, such as +"inetd". +.TP +.I "\-p, \-\-priority=[priority]" +Log at the specified syslog priority. The default +is \fBnotice\fR (see syslog(3)). +.TP +.I "\-r, \-\-run=[program]" +Execute the specified program, with an open file +descriptor so that the program can pass back +commands to initlog. +.TP +.I "\-s, \-\-string=[string] +Log the specified string to the logger. +.SH "SEE ALSO" +syslog(3), logger(1) diff --git a/src/initlog.c b/src/initlog.c new file mode 100644 index 00000000..96b5af87 --- /dev/null +++ b/src/initlog.c @@ -0,0 +1,317 @@ + +#include <errno.h> +#include <fcntl.h> +#include <libintl.h> +#include <locale.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> + +#define SYSLOG_NAMES +#include <syslog.h> + +#include <sys/wait.h> + +#define _(String) gettext((String)) + +#include <popt.h> + +#include "initlog.h" +#include "process.h" + +static int logfacility=LOG_DAEMON; +static int logpriority=LOG_NOTICE; +static int reexec=0; +static int quiet=0; + +static int logEntries = 0; +struct logInfo *logData = NULL; + +char *getLine(char **data) { + /* Get one line from data */ + char *x, *y; + + if (!*data) return NULL; + + for (x = *data; *x && (*x != '\n'); x++); + if (*x) { + x++; + } else { + if (x-*data) { + y=malloc(x-*data+1); + y[x-*data] = 0; + y[x-*data-1] = '\n'; + memcpy(y,*data,x-*data); + } else { + y=NULL; + } + *data = NULL; + return y; + } + y = malloc(x-*data); + y[x-*data-1] = 0; + memcpy(y,*data,x-*data-1); + *data = x; + return y; +} + +char **toArray(char *line, int *num) { + /* Converts a long string into an array of lines. */ + char **lines; + char *tmpline; + + *num = 0; + lines = NULL; + + while ((tmpline=getLine(&line))) { + if (!*num) + lines = (char **) malloc(sizeof(char *)); + else + lines = (char **) realloc(lines, (*num+1)*sizeof(char *)); + lines[*num] = tmpline; + (*num)++; + } + return lines; +} + +int startDaemon() { + int pid; + int rc; + + if ( (pid = fork()) == -1 ) { + perror("fork"); + return -1; + } + if ( pid ) { + /* parent */ + waitpid(pid,&rc,0); + if (rc) + return -1; + else + return 0; + } else { + int fd; + + fd=open("/dev/null",O_RDWR); + dup2(fd,0); + dup2(fd,1); + dup2(fd,2); + /* kid */ + execlp("minilogd","minilogd",NULL); + perror("exec"); + exit(-1); + } +} + +int logLine(struct logInfo *logEnt) { + /* Logs a line... somewhere. */ + int x; + + /* Don't log empty or null lines */ + if (!logEnt->line || !strcmp(logEnt->line,"\n")) return 0; + + if ((x=access(_PATH_LOG,W_OK))) { + /* syslog isn't running, so start something... */ + if ( (x=startDaemon()) ==-1) { + logData=realloc(logData,(logEntries+1)*sizeof(struct logInfo)); + logData[logEntries]= (*logEnt); + logEntries++; + } else { + if (logEntries>0) { + for (x=0;x<logEntries;x++) { + openlog(logData[x].cmd,0,logData[x].fac); + printf("flushing %s\n",logData[x].line); + syslog(logData[x].pri,"%s",logData[x].line); + closelog(); + } + free(logData); + logEntries = 0; + } + openlog(logEnt->cmd,0,logEnt->fac); + syslog(logEnt->pri,"%s",logEnt->line); + closelog(); + } + } else { + if (logEntries>0) { + for (x=0;x<logEntries;x++) { + openlog(logData[x].cmd,0,logData[x].fac); + printf("flushing %s\n",logData[x].line); + syslog(logData[x].pri,"%s",logData[x].line); + closelog(); + } + free(logData); + logEntries = 0; + } + openlog(logEnt->cmd,0,logEnt->fac); + syslog(logEnt->pri,"%s",logEnt->line); + closelog(); + } + return 0; +} + +int logEvent(char *cmd, int eventtype,char *string) { + char *eventtable [] = { + _("%s babbles incoherently"), + _("%s succeeded"), + _("%s failed"), + _("%s cancelled at user request"), + _("%s failed due to a failed dependency"), + /* insert more here */ + NULL + }; + int x=0,len; + struct logInfo logentry; + + + if (cmd) { + logentry.cmd = strdup(basename(cmd)); + if ((logentry.cmd[0] =='K' || logentry.cmd[0] == 'S') && ( 30 <= logentry.cmd[1] <= 39 ) + && ( 30 <= logentry.cmd[2] <= 39 ) ) + logentry.cmd+=3; + } else + logentry.cmd = strdup(_("(none)")); + if (!string) + string = strdup(cmd); + + while (eventtable[x] && x<eventtype) x++; + if (!(eventtable[x])) x=0; + + len=strlen(eventtable[x])+strlen(string); + logentry.line=malloc(len); + snprintf(logentry.line,len,eventtable[x],string); + + logentry.pri = logpriority; + logentry.fac = logfacility; + + return logLine(&logentry); +} + +int logString(char *cmd, char *string) { + struct logInfo logentry; + + if (cmd) { + logentry.cmd = strdup(basename(cmd)); + if ((logentry.cmd[0] =='K' || logentry.cmd[0] == 'S') && ( 30 <= logentry.cmd[1] <= 39 ) + && ( 30 <= logentry.cmd[2] <= 39 ) ) + logentry.cmd+=3; + } else + logentry.cmd = strdup(_("")); + logentry.line = strdup(string); + logentry.pri = logpriority; + logentry.fac = logfacility; + + return logLine(&logentry); +} + +void processArgs(int argc, char **argv) { + char *cmdname=NULL; + int cmdevent=0; + char *cmd=NULL; + char *logstring=NULL; + char *fac=NULL,*pri=NULL; + poptContext context; + int rc; + struct poptOption optTable[] = { + POPT_AUTOHELP + { "name", 'n', POPT_ARG_STRING, &cmdname, 0, + "name of service being logged", NULL + }, + { "event", 'e', POPT_ARG_INT, &cmdevent, 0, + "event being logged (see man page)", NULL + }, + { "cmd", 'c', POPT_ARG_STRING, &cmd, 0, + "command to run, logging output", NULL + }, + { "run", 'r', POPT_ARG_STRING, &cmd, 3, + "command to run, accepting input on open fd", NULL + }, + { "string", 's', POPT_ARG_STRING, &logstring, 0, + "string to log", NULL + }, + { "facility", 'f', POPT_ARG_STRING, &fac, 1, + "facility to log at (default: 'daemon')", NULL + }, + { "priority", 'p', POPT_ARG_STRING, &pri, 2, + "priority to log at (default: 'notice')", NULL + }, + { "quiet", 'q', POPT_ARG_NONE, &quiet, 0, + "suppress stdout/stderr", NULL + }, + { 0, 0, 0, 0, 0, 0 } + }; + + context = poptGetContext("initlog", argc, argv, optTable, 0); + + while ((rc = poptGetNextOpt(context)) > 0) { + switch (rc) { + case 1: + logfacility=atoi(fac); + if ((logfacility == 0) && strcmp(fac,"0")) { + int x =0; + + logfacility = LOG_DAEMON; + for (x=0;facilitynames[x].c_name;x++) { + if (!strcmp(fac,facilitynames[x].c_name)) { + logfacility = facilitynames[x].c_val; + break; + } + } + } + break; + case 2: + logpriority = atoi(pri); + if ((logpriority == 0) && strcmp(pri,"0")) { + int x=0; + + logpriority = LOG_NOTICE; + for (x=0;prioritynames[x].c_name;x++) { + if (!strcmp(pri,prioritynames[x].c_name)) { + logpriority = prioritynames[x].c_val; + break; + } + } + } + break; + case 3: + reexec = 1; + break; + default: + break; + } + } + + if ((rc < -1)) { + fprintf(stderr, "%s: %s\n", + poptBadOption(context, POPT_BADOPTION_NOALIAS), + poptStrerror(rc)); + exit(-1); + } + if ( (cmd && logstring) || (cmd && cmdname) ) { + fprintf(stderr, _("--cmd and --run are incompatible with --string or --name\n")); + exit(-1); + } + if ( cmdname && (!logstring && !cmdevent)) { + fprintf(stderr, _("--name requires one of --event or --string\n")); + exit(-1); + } + if (cmdevent) { + logEvent(cmdname,cmdevent,logstring); + } else if (logstring) { + logString(cmdname,logstring); + } else if ( cmd ) { + exit(runCommand(cmd,reexec,quiet)); + } else { + fprintf(stderr,"nothing to do!\n"); + exit(-1); + } +} + +int main(int argc, char **argv) { + + setlocale(LC_ALL,""); + bindtextdomain("initlog","/etc/locale"); + textdomain("initlog"); + processArgs(argc,argv); + exit (0); +} diff --git a/src/initlog.h b/src/initlog.h new file mode 100644 index 00000000..244ff9a0 --- /dev/null +++ b/src/initlog.h @@ -0,0 +1,16 @@ + +#ifndef INITLOG_H +#define INITLOG_H + +struct logInfo { + char *cmd; + char *line; + int fac; + int pri; +}; + +char *getLine(char **data); +int logString(char *cmd, char *string); +void processArgs(int argc, char **argv); + +#endif diff --git a/src/minilogd.c b/src/minilogd.c new file mode 100644 index 00000000..d15b8d9a --- /dev/null +++ b/src/minilogd.c @@ -0,0 +1,164 @@ + +/* minilogd.c + * + * A pale imitation of syslogd. Most notably, doesn't write anything + * anywhere except possibly back to syslogd. + * + */ + +#include <errno.h> +#include <fcntl.h> +#include <signal.h> +#include <stdio.h> +#include <stdlib.h> +#include <syslog.h> +#include <unistd.h> + +#include <sys/poll.h> +#include <sys/socket.h> +#include <sys/stat.h> +#include <sys/un.h> + +static int we_own_log=0; +static char **buffer=NULL; +static int buflines=0; + +void freeBuffer() { + struct sockaddr_un addr; + int sock; + int x=0,conn; + + bzero(&addr,sizeof(addr)); + addr.sun_family = AF_LOCAL; + strncpy(addr.sun_path,_PATH_LOG,sizeof(addr.sun_path)-1); + /* wait for klogd to hit syslog */ + sleep(1); + sock = socket(AF_LOCAL, SOCK_STREAM,0); + conn=connect(sock,(struct sockaddr *) &addr,sizeof(addr)); + while (x<buflines) { + if (!conn) write(sock,buffer[x],strlen(buffer[x])+1); + free(buffer[x]); + x++; + } +} + +void cleanup(int exitcode) { + /* If we own the log, unlink it before trying to free our buffer. + * Otherwise, sending the buffer to /dev/log doesn't make much sense.... */ + if (we_own_log) { + perror("wol"); + unlink(_PATH_LOG); + } + /* Don't try to free buffer if we were called from a signal handler */ + perror("foo"); + if (exitcode<=0) { + if (buffer) freeBuffer(); + exit(exitcode); + } else + exit(exitcode+128); +} + +void runDaemon(int sock) { + struct sockaddr_un addr; + int x,len,addrlen,recvsock,done=0; + char *message; + struct stat s1,s2; + struct pollfd pfds; + FILE *foo; + + foo=fopen("./foo","a"); + + daemon(0,-1); + /* try not to leave stale sockets lying around */ + /* Hopefully, we won't actually get any of these */ + signal(SIGHUP,cleanup); + signal(SIGINT,cleanup); + signal(SIGQUIT,cleanup); + signal(SIGILL,cleanup); + signal(SIGABRT,cleanup); + signal(SIGFPE,cleanup); + signal(SIGSEGV,cleanup); + signal(SIGPIPE,cleanup); + signal(SIGBUS,cleanup); + signal(SIGTERM,cleanup); + done = 0; + /* Get stat info on dev log so we can later check to make sure we + * still own it... */ + stat(_PATH_LOG,&s1); + while (!done) { + pfds.fd = sock; + pfds.events = POLLIN|POLLPRI; + if ( ( (x=poll(&pfds,1,500))==-1) && errno !=EINTR) { + perror("poll"); + cleanup(-1); + } + if ( (x>0) && pfds.revents & (POLLIN | POLLPRI)) { + printf("foo!\n"); + message = calloc(8192,sizeof(char)); + recvsock = accept(sock,(struct sockaddr *) &addr, &addrlen); + len = read(recvsock,message,8192); + if (buffer) + buffer = realloc(buffer,(buflines+1)*sizeof(char *)); + else + buffer = malloc(sizeof(char *)); + if (len>0) { + message[strlen(message)]='\n'; + fprintf(foo,"%s",message); + buffer[buflines]=message; + buflines++; + close(recvsock); + } + else { + close(recvsock); + recvsock=-1; + } + } + if ( (x>0) && ( pfds.revents & (POLLHUP | POLLNVAL)) ) + done = 1; + /* Check to see if syslogd's yanked our socket out from under us */ + if ( (stat(_PATH_LOG,&s2)!=0) || + (s1.st_ino != s2.st_ino ) || (s1.st_ctime != s2.st_ctime) || + (s1.st_mtime != s2.st_mtime) || (s1.st_atime != s2.st_atime) ) { + done = 1; + we_own_log = 0; + } + } + fclose(foo); + cleanup(0); +} + +int main() { + struct sockaddr_un addr; + int sock; + int pid; + + /* just in case */ + sock = open("/dev/null",O_RDWR); + dup2(sock,0); + dup2(sock,1); + dup2(sock,2); + + bzero(&addr, sizeof(addr)); + addr.sun_family = AF_LOCAL; + strncpy(addr.sun_path,_PATH_LOG,sizeof(addr.sun_path)-1); + sock = socket(AF_LOCAL, SOCK_STREAM,0); + unlink(_PATH_LOG); + /* Bind socket before forking, so we know if the server started */ + if (!bind(sock,(struct sockaddr *) &addr, sizeof(addr))) { + we_own_log = 1; + listen(sock,5); + if ((pid=fork())==-1) { + perror("fork"); + exit(-1); + } + if (pid) { + exit(0); + } else { + runDaemon(sock); + /* shouldn't get back here... */ + exit(-1); + } + } else { + exit(-1); + } +} diff --git a/src/process.c b/src/process.c new file mode 100644 index 00000000..48f3b314 --- /dev/null +++ b/src/process.c @@ -0,0 +1,216 @@ + +#include <errno.h> +#include <fcntl.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> + +#include <sys/poll.h> +#include <sys/wait.h> + +#include <popt.h> + +#include "initlog.h" +#include "process.h" + +int forkCommand(char **args, int *outfd, int *errfd, int *cmdfd, int quiet) { + /* Fork command 'cmd', returning pid, and optionally pointer + * to open file descriptor fd */ + int fdin, fdout, fderr, fdcmd, pid; + int outpipe[2], errpipe[2], fdpipe[2]; + + if ( (pipe(outpipe)==-1) || (pipe(errpipe)==-1) || (pipe(fdpipe)==-1) ) { + perror("pipe"); + return -1; + } + + dup2(0,fdin); + if (outfd) { + fdout = outpipe[1]; + *outfd = outpipe[0]; + } else { + if (!quiet) + dup2(1,fdout); + } + if (errfd) { + fderr = errpipe[1]; + *errfd = errpipe[0]; + } else { + if (!quiet) + dup2(2,fderr); + } + fdcmd = fdpipe[1]; + if (cmdfd) + *cmdfd = fdpipe[0]; + if ((pid = fork())==-1) { + perror("fork"); + return -1; + } + if (pid) { + /* parent */ + close(fdin); + close(fdout); + close(fderr); + close(fdcmd); + return pid; + } else { + /* kid */ + if (outfd) { + if ( (dup2(fdout,1)==-1) ) { + perror("dup2"); + exit(-1); + } + } else if (quiet) + if ((dup2(open("/dev/null",O_WRONLY),1))==-1) { + perror("dup2"); + exit(-1); + } + + if (errfd) { + if ((dup2(fderr,2)==-1)) { + perror("dup2"); + exit(-1); + } + } else if (quiet) + if ((dup2(open("/dev/null",O_WRONLY),2))==-1) { + perror("dup2"); + exit(-1); + } + + + if ((dup2(fdcmd,CMD_FD)==-1)) { + perror("dup2"); + exit(-1); + } + close(fdout); + close(fderr); + close(fdcmd); + if (outfd) + close(*outfd); + if (errfd) + close(*errfd); + if (cmdfd) + close(*cmdfd); + execvp(args[0],args); + perror("execvp"); + exit(-1); + } +} + +int monitor(char *cmdname, int pid, int numfds, int *fds, int reexec, int quiet) { + struct pollfd *pfds; + char *buf=malloc(2048*sizeof(char)); + int outpipe[2]; + char *tmpstr=NULL; + int x,y,rc=-1; + int done=0; + int output=0; + + pipe(outpipe); + + pfds = malloc(numfds*sizeof(struct pollfd)); + for (x=0;x<numfds;x++) { + pfds[x].fd = fds[x]; + pfds[x].events = POLLIN | POLLPRI; + } + + while (!done) { + if ((x=poll(pfds,numfds,500))==-1) { + perror("poll"); + return -1; + } + if (waitpid(pid,&rc,WNOHANG)) + done=1; + y=0; + while (y<numfds) { + if ( x && ((pfds[y].revents & (POLLIN | POLLPRI)) )) { + int bytesread = 0; + + do { + buf=calloc(2048,sizeof(char)); + bytesread = read(pfds[y].fd,buf,2048); + if (bytesread==-1) { + perror("read"); + return -1; + } + if (bytesread) { + if (!quiet && !reexec) + write(1,buf,bytesread); + if (quiet) { + output = 1; + write(outpipe[1],buf,bytesread); + } + while ((tmpstr=getLine(&buf))) { + if (!reexec) + logString(cmdname,tmpstr); + else { + char **cmdargs=NULL; + char **tmpargs=NULL; + int cmdargc,x; + + poptParseArgvString(tmpstr,&cmdargc,&tmpargs); + cmdargs=malloc( (cmdargc++) * sizeof(char *) ); + cmdargs[0]=strdup("initlog"); + for (x=0;x<(cmdargc-1);x++) { + cmdargs[x+1]=tmpargs[x]; + } + processArgs(cmdargc,cmdargs); + } + } + } + + } while ( bytesread==2048 ); + } + y++; + } + } + rc = rc>>8; + + if (!rc) + return 0; + else { + /* If there was an error and we're quiet, be loud */ + int x; + + if (quiet && output) { + buf=calloc(2048,sizeof(char)); + do { + x=read(outpipe[0],buf,2048); + write(1,buf,x); + buf=calloc(2048,sizeof(char)); + } while (x==2048); + } + return (rc); + } +} + +int runCommand(char *cmd, int reexec, int quiet) { + int fds[2]; + int pid,x; + char **args, **tmpargs; + char *cmdname; + + poptParseArgvString(cmd,&x,&tmpargs); + args = malloc((x+1)*sizeof(char *)); + for ( pid = 0; pid < x ; pid++) { + args[pid] = strdup(tmpargs[pid]); + } + args[pid] = NULL; + if (strcmp(args[0],"sh") && strcmp(args[0],"/bin/sh")) + cmdname = basename(args[0]); + else + cmdname = basename(args[1]); + if ((cmdname[0] =='K' || cmdname[0] == 'S') && ( 30 <= cmdname[1] <= 39 ) + && ( 30 <= cmdname[2] <= 39 ) ) + cmdname+=3; + if (!reexec) { + pid=forkCommand(args,&fds[0],&fds[1],NULL,quiet); + x=monitor(cmdname,pid,2,fds,reexec,quiet); + } else { + setenv("IN_INITLOG","yes",1); + pid=forkCommand(args,NULL,NULL,&fds[0],quiet); + unsetenv("IN_INITLOG"); + x=monitor(cmdname,pid,1,&fds[0],reexec,quiet); + } + return x; +} diff --git a/src/process.h b/src/process.h new file mode 100644 index 00000000..6c796cb2 --- /dev/null +++ b/src/process.h @@ -0,0 +1,9 @@ +#ifndef PROCESS_H +#define PROCESS_H + + +#define CMD_FD 21 + +int runCommand(char *cmd, int reexec, int quiet); + +#endif |