extern int utime(const char* path, const struct utimbuf* ut) { int r; int oerrno; char buf[PATH_MAX]; oerrno = errno; if ((r = sysutime(path, ut)) && errno == ENOENT && execrate(path, buf, sizeof(buf), 0)) { errno = oerrno; r = sysutime(path = buf, ut); } if (!r) ctime_now(path); return r; }
int main(int argc, char **argv) { int i; struct sigaction sa, osa; FILE *pf; int r; prog_name= strrchr(argv[0], '/'); if (prog_name == nil) prog_name= argv[0]; else prog_name++; i= 1; while (i < argc && argv[i][0] == '-') { char *opt= argv[i++] + 1; if (opt[0] == '-' && opt[1] == 0) break; /* -- */ while (*opt != 0) switch (*opt++) { case 'd': if (*opt == 0) { debug= 1; } else { debug= strtoul(opt, &opt, 10); if (*opt != 0) usage(); } break; default: usage(); } } if (i != argc) usage(); selectlog(SYSLOG); openlog(prog_name, LOG_PID, LOG_DAEMON); setlogmask(LOG_UPTO(LOG_INFO)); /* Save process id. */ if ((pf= fopen(PIDFILE, "w")) == NULL) { fprintf(stderr, "%s: %s\n", PIDFILE, strerror(errno)); exit(1); } fprintf(pf, "%d\n", getpid()); if (ferror(pf) || fclose(pf) == EOF) { fprintf(stderr, "%s: %s\n", PIDFILE, strerror(errno)); exit(1); } sigemptyset(&sa.sa_mask); sa.sa_flags= 0; sa.sa_handler= handler; /* Hangup: Reload crontab files. */ sigaction(SIGHUP, &sa, nil); /* User signal 1 & 2: Raise or reset debug level. */ sigaction(SIGUSR1, &sa, nil); sigaction(SIGUSR2, &sa, nil); /* Interrupt and Terminate: Cleanup and exit. */ if (sigaction(SIGINT, nil, &osa) == 0 && osa.sa_handler != SIG_IGN) { sigaction(SIGINT, &sa, nil); } if (sigaction(SIGTERM, nil, &osa) == 0 && osa.sa_handler != SIG_IGN) { sigaction(SIGTERM, &sa, nil); } /* Alarm: Wake up and run a job. */ sigaction(SIGALRM, &sa, nil); /* Initialize current time and time next to do something. */ time(&now); next= NEVER; /* Table load required first time. */ need_reload= 1; do { if (need_reload) { need_reload= 0; load_crontabs(); busy= 1; } /* Run jobs whose time has come. */ if (next <= now) { cronjob_t *job; if ((job= tab_nextjob()) != nil) run_job(job); busy= 1; } if (busy) { /* Did a job finish? */ r= waitpid(-1, nil, WNOHANG); busy= 0; } else { /* Sleep until the next job must be started. */ if (next == NEVER) { alarm(0); } else { #if __minix_vmd struct timeval tvnext; tvnext.tv_sec= next; tvnext.tv_usec= 0; sysutime(UTIME_SETALARM, &tvnext); #else alarm((next - now) > INT_MAX ? INT_MAX : (next - now)); #endif } if (debug >= 1) fprintf(stderr, "%s: sleep until %s", prog_name, ctime(&next)); closelog(); /* Don't keep resources open. */ /* Wait for a job to exit or a timeout. */ r= waitpid(-1, nil, 0); if (r == -1 && errno == ECHILD) pause(); alarm(0); time(&now); } if (r > 0) { /* A job has finished, reschedule it. */ if (debug >= 1) fprintf(stderr, "pid %d has exited\n", r); tab_reap_job((pid_t) r); busy= 1; } } while (!need_quit); /* Remove the pid file to signal that cron is gone. */ unlink(PIDFILE); return 0; }
PUBLIC void main() { mq_t *mq; int r; int source, timerand, fd; struct fssignon device; #ifdef __minix_vmd struct systaskinfo info; #endif u8_t randbits[32]; struct timeval tv; #if DEBUG printf("Starting inet...\n"); printf("%s\n", version); #endif /* Read configuration. */ nw_conf(); /* Get a random number */ timerand= 1; fd= open(RANDOM_DEV_NAME, O_RDONLY | O_NONBLOCK); if (fd != -1) { r= read(fd, randbits, sizeof(randbits)); if (r == sizeof(randbits)) timerand= 0; else { printf("unable to read random data from %s: %s\n", RANDOM_DEV_NAME, r == -1 ? strerror(errno) : r == 0 ? "EOF" : "not enough data"); } close(fd); } else { printf("unable to open random device %s: %s\n", RANDOM_DEV_NAME, strerror(errno)); } if (timerand) { printf("using current time for random-number seed\n"); #ifdef __minix_vmd r= sysutime(UTIME_TIMEOFDAY, &tv); #else /* Minix 3 */ r= gettimeofday(&tv, NULL); #endif if (r == -1) { printf("sysutime failed: %s\n", strerror(errno)); exit(1); } memcpy(randbits, &tv, sizeof(tv)); } init_rand256(randbits); #ifdef __minix_vmd if (svrctl(SYSSIGNON, (void *) &info) == -1) pause(); /* Our new identity as a server. */ this_proc = info.proc_nr; #else /* Minix 3 */ /* Our new identity as a server. */ if ((this_proc = getprocnr()) < 0) ip_panic(( "unable to get own process nr\n")); #endif /* Register the device group. */ device.dev= ip_dev; device.style= STYLE_CLONE; if (svrctl(FSSIGNON, (void *) &device) == -1) { printf("inet: error %d on registering ethernet devices\n", errno); pause(); } #ifdef BUF_CONSISTENCY_CHECK inet_buf_debug= (getenv("inetbufdebug") && (strcmp(getenv("inetbufdebug"), "on") == 0)); inet_buf_debug= 100; if (inet_buf_debug) { ip_warning(( "buffer consistency check enabled" )); } #endif if (getenv("killerinet")) { ip_warning(( "killer inet active" )); killer_inet= 1; } #ifdef __minix_vmd r= sys_findproc(SYN_AL_NAME, &synal_tasknr, 0); if (r != OK) ip_panic(( "unable to find synchronous alarm task: %d\n", r )); #endif nw_init(); while (TRUE) { #ifdef BUF_CONSISTENCY_CHECK if (inet_buf_debug) { static int buf_debug_count= 0; if (++buf_debug_count >= inet_buf_debug) { buf_debug_count= 0; if (!bf_consistency_check()) break; } } #endif if (ev_head) { ev_process(); continue; } if (clck_call_expire) { clck_expire_timers(); continue; } mq= mq_get(); if (!mq) ip_panic(("out of messages")); r= receive (ANY, &mq->mq_mess); if (r<0) { ip_panic(("unable to receive: %d", r)); } reset_time(); source= mq->mq_mess.m_source; if (source == FS_PROC_NR) { sr_rec(mq); } #ifdef __minix_vmd else if (source == synal_tasknr) { clck_tick (&mq->mq_mess); mq_free(mq); } #else /* Minix 3 */ else if (mq->mq_mess.m_type == SYN_ALARM) { clck_tick(&mq->mq_mess); mq_free(mq); } else if (mq->mq_mess.m_type == SYS_SIG) { /* signaled */ /* probably SIGTERM */ mq_free(mq); } else if (mq->mq_mess.m_type & NOTIFY_MESSAGE) { /* A driver is (re)started. */ eth_check_drivers(&mq->mq_mess); mq_free(mq); } #endif else { compare(mq->mq_mess.m_type, ==, DL_TASK_REPLY); eth_rec(&mq->mq_mess); mq_free(mq); } } ip_panic(("task is not allowed to terminate")); }
int main(int argc, char*argv[]) { char *ipstat_device; int fd, i, r; size_t psize; char *pval, *param; struct timeval uptime; clock_t now; int fl; int a_flag, n_flag; struct tms tmsbuf; (prog_name=strrchr(argv[0], '/')) ? prog_name++ : (prog_name=argv[0]); a_flag= 0; n_flag= 0; while ((fl= getopt(argc, argv, "?an")) != -1) { switch(fl) { case '?': usage(); case 'a': a_flag= 1; break; case 'n': n_flag= 1; break; default: fprintf(stderr, "%s: getopt failed: '%c'\n", prog_name, fl); exit(1); } } inclSel= !!a_flag; numerical= !!n_flag; ipstat_device= IPSTAT_DEVICE; if ((fd= open(ipstat_device, O_RDWR)) == -1) { fprintf(stderr, "%s: unable to open '%s': %s\n", prog_name, ipstat_device, strerror(errno)); exit(1); } v_size= 2*sizeof(udp_fd_table)+1; valuesl= realloc(valuesl, v_size); if (!valuesl) { fprintf(stderr, "%s: unable to malloc %u bytes for valuesl\n", prog_name, v_size); exit(1); } param= "udp_fd_table"; psize= strlen(param); r= write(fd, param, psize); if (r != psize) { fprintf(stderr, "%s: write to %s failed: %s\n", prog_name, ipstat_device, r < 0 ? strerror(errno) : "short write"); exit(1); } r= read(fd, valuesl, v_size); if (r < 0) { fprintf(stderr, "%s: read from %s failed: %s\n", prog_name, ipstat_device, strerror(errno)); exit(1); } pval= valuesl; if (paramvalue(&pval, udp_fd_table, sizeof(udp_fd_table)) != sizeof(udp_fd_table)) { fprintf(stderr, "%s: unable to decode the results from queryparam (udp_fd_table)\n", prog_name); exit(1); } /* Get address, size, and element size of the UDP port table */ param = "&udp_port_table,$udp_port_table,$udp_port_table[0]"; psize = strlen(param); r= write(fd, param, psize); if (r != psize) { fprintf(stderr, "%s: write to %s failed: %s\n", prog_name, ipstat_device, r < 0 ? strerror(errno) : "short write"); exit(1); } r= read(fd, values, sizeof(values)); if (r < 0) { fprintf(stderr, "%s: read from %s failed: %s\n", prog_name, ipstat_device, strerror(errno)); exit(1); } pval= values; if (paramvalue(&pval, &udp_port_tablep, sizeof(udp_port_tablep)) != sizeof(udp_port_tablep) || paramvalue(&pval, &udp_port_table_s, sizeof(udp_port_table_s)) != sizeof(udp_port_table_s) || paramvalue(&pval, &udp_port_table_rs, sizeof(udp_port_table_rs)) != sizeof(udp_port_table_rs)) { fprintf(stderr, "%s: unable to decode the results from queryparam (&udp_port_table, ...)\n", prog_name); exit(1); } if (udp_port_table_rs != sizeof(udp_port_table[0])) { fprintf(stderr, "%s: size mismatch in udp_port_table (different version of inet?)\n", prog_name); exit(1); } udp_port_nr= udp_port_table_s/udp_port_table_rs; assert(udp_port_table_s == udp_port_nr*udp_port_table_rs); udp_port_table= malloc(udp_port_table_s); if (!udp_port_table) { fprintf(stderr, "%s: unable to malloc %u bytes for udp_port_table\n", prog_name, udp_port_table_s); exit(1); } v_size= 2*udp_port_table_s+1; valuesl= realloc(valuesl, v_size); if (!valuesl) { fprintf(stderr, "%s: unable to malloc %u bytes for valuesl\n", prog_name, v_size); exit(1); } param = "udp_port_table"; psize = strlen(param); r= write(fd, param, psize); if (r != psize) { fprintf(stderr, "%s: write to %s failed: %s\n", prog_name, ipstat_device, r < 0 ? strerror(errno) : "short write"); exit(1); } r= read(fd, valuesl, v_size); if (r < 0) { fprintf(stderr, "%s: read from %s failed: %s\n", prog_name, ipstat_device, strerror(errno)); exit(1); } pval= valuesl; if (paramvalue(&pval, udp_port_table, udp_port_table_s) != udp_port_table_s) { fprintf(stderr, "%s: unable to decode the results from queryparam (udp_port_table)\n", prog_name); exit(1); } /* Get the uptime in clock ticks. */ #ifdef __minix_vmd if (sysutime(UTIME_UPTIME, &uptime) == -1) { fprintf(stderr, "%s: sysutime failed: %s\n", prog_name, strerror(errno)); exit(1); } now= uptime.tv_sec * HZ + (uptime.tv_usec*HZ/1000000); #else /* Minix 3 */ now= times(&tmsbuf); #endif for (i= 0; i<UDP_FD_NR; i++) print_fd(i, now); exit(0); }
int main(int argc, char*argv[]) { char *tcp_device; int fd, i; struct svrqueryparam qpar; char *pval; struct timeval uptime; clock_t now; int fl; int a_flag, n_flag, v_flag; (prog_name=strrchr(argv[0], '/')) ? prog_name++ : (prog_name=argv[0]); a_flag= 0; n_flag= 0; v_flag= 0; while ((fl= getopt(argc, argv, "?anv")) != -1) { switch(fl) { case '?': usage(); case 'a': a_flag= 1; break; case 'n': n_flag= 1; break; case 'v': v_flag= 1; break; default: fprintf(stderr, "%s: getopt failed: '%c'\n", prog_name, fl); exit(1); } } inclListen= !!a_flag; numerical= !!n_flag; verbose= !!v_flag; tcp_device= TCP_DEVICE; if ((fd= open(tcp_device, O_RDWR)) == -1) { fprintf(stderr, "%s: unable to open '%s': %s\n", prog_name, tcp_device, strerror(errno)); exit(1); } qpar.param = "tcp_conn_table"; qpar.psize = strlen(qpar.param); qpar.value = values; qpar.vsize = sizeof(values); if (ioctl(fd, NWIOQUERYPARAM, &qpar) == -1) { fprintf(stderr, "%s: queryparam failed: %s\n", prog_name, strerror(errno)); exit(1); } pval= values; if (paramvalue(&pval, tcp_conn_table, sizeof(tcp_conn_table)) != sizeof(tcp_conn_table)) { fprintf(stderr, "%s: unable to decode the results from queryparam\n", prog_name); exit(1); } #ifdef __minix_vmd /* Get the uptime in clock ticks. */ if (sysutime(UTIME_UPTIME, &uptime) == -1) { fprintf(stderr, "%s: sysutime failed: %s\n", prog_name, strerror(errno)); exit(1); } now= uptime.tv_sec * HZ + (uptime.tv_usec*HZ/1000000); #else /* Minix 3 */ now= times(NULL); #endif for (i= 0; i<TCP_CONN_NR; i++) print_conn(i, now); exit(0); }
int main(int argc, char*argv[]) { char *ipstat_device; int fd, i, r; char *query, *pval; size_t len; struct timeval uptime; clock_t now; int fl; int a_flag, n_flag, v_flag; struct tms tmsbuf; getsysinfo_up(PM_PROC_NR, SIU_SYSTEMHZ, sizeof(system_hz), &system_hz); (prog_name=strrchr(argv[0], '/')) ? prog_name++ : (prog_name=argv[0]); a_flag= 0; n_flag= 0; v_flag= 0; while ((fl= getopt(argc, argv, "?anv")) != -1) { switch(fl) { case '?': usage(); case 'a': a_flag= 1; break; case 'n': n_flag= 1; break; case 'v': v_flag= 1; break; default: fprintf(stderr, "%s: getopt failed: '%c'\n", prog_name, fl); exit(1); } } inclListen= !!a_flag; numerical= !!n_flag; verbose= !!v_flag; ipstat_device= IPSTAT_DEVICE; if ((fd= open(ipstat_device, O_RDWR)) == -1) { fprintf(stderr, "%s: unable to open '%s': %s\n", prog_name, ipstat_device, strerror(errno)); exit(1); } query= "tcp_conn_table"; len= strlen(query); r= write(fd, query, len); if (r != len) { fprintf(stderr, "%s: write to %s failed: %s\n", prog_name, ipstat_device, r < 0 ? strerror(errno) : "short write"); exit(1); } r= read(fd, values, sizeof(values)); if (r == -1) { fprintf(stderr, "%s: read from %s failed: %s\n", prog_name, ipstat_device, strerror(errno)); exit(1); } pval= values; if (paramvalue(&pval, tcp_conn_table, sizeof(tcp_conn_table)) != sizeof(tcp_conn_table)) { fprintf(stderr, "%s: unable to decode the results from queryparam\n", prog_name); exit(1); } #ifdef __minix_vmd /* Get the uptime in clock ticks. */ if (sysutime(UTIME_UPTIME, &uptime) == -1) { fprintf(stderr, "%s: sysutime failed: %s\n", prog_name, strerror(errno)); exit(1); } now= uptime.tv_sec * HZ + (uptime.tv_usec*HZ/1000000); #else /* Minix 3 */ now= times(&tmsbuf); #endif for (i= 0; i<TCP_CONN_NR; i++) print_conn(i, now); exit(0); }