/* * Display the contents of a uio structure on a terminal. Used by wall(1), * syslogd(8), and talkd(8). Forks and finishes in child if write would block, * waiting up to tmout seconds. Returns pointer to error string on unexpected * error; string is not newline-terminated. Various "normal" errors are * ignored (exclusive-use, lack of permission, etc.). */ char * ttymsg(struct iovec *iov, int iovcnt, char *line, int tmout) { static char device[MAXNAMLEN]; static char errbuf[MAXNAMLEN+1024]; register int cnt, fd, left, wret; struct iovec localiov[6]; int forked = 0, errsv; if (iovcnt > sizeof(localiov) / sizeof(localiov[0])) return (_("too many iov's (change code in wall/ttymsg.c)")); /* The old code here rejected the line argument when it contained a '/', saying: "A slash may be an attempt to break security...". However, if a user can control the line argument here then he can make this routine write to /dev/hda or /dev/sda already. So, this test was worthless, and these days it is also wrong since people use /dev/pts/xxx. */ if (strlen(line) + sizeof(_PATH_DEV) + 1 > sizeof(device)) { (void) sprintf(errbuf, _("excessively long line arg")); return (errbuf); } (void) sprintf(device, "%s%s", _PATH_DEV, line); /* * open will fail on slip lines or exclusive-use lines * if not running as root; not an error. */ if ((fd = open(device, O_WRONLY|O_NONBLOCK, 0)) < 0) { if (errno == EBUSY || errno == EACCES) return (NULL); if (strlen(strerror(errno)) > 1000) return (NULL); (void) sprintf(errbuf, "%s: %s", device, strerror(errno)); errbuf[1024] = 0; return (errbuf); } for (cnt = left = 0; cnt < iovcnt; ++cnt) left += iov[cnt].iov_len; for (;;) { wret = writev(fd, iov, iovcnt); if (wret >= left) break; if (wret >= 0) { left -= wret; if (iov != localiov) { bcopy(iov, localiov, iovcnt * sizeof(struct iovec)); iov = localiov; } for (cnt = 0; wret >= iov->iov_len; ++cnt) { wret -= iov->iov_len; ++iov; --iovcnt; } if (wret) { iov->iov_base += wret; iov->iov_len -= wret; } continue; } if (errno == EWOULDBLOCK) { int cpid, off = 0; if (forked) { (void) close(fd); _exit(1); } cpid = fork(); if (cpid < 0) { if (strlen(strerror(errno)) > 1000) (void) sprintf(errbuf, _("cannot fork")); else { errsv = errno; (void) sprintf(errbuf, _("fork: %s"), strerror(errsv)); } (void) close(fd); return (errbuf); } if (cpid) { /* parent */ (void) close(fd); return (NULL); } forked++; /* wait at most tmout seconds */ (void) signal(SIGALRM, SIG_DFL); (void) signal(SIGTERM, SIG_DFL); /* XXX */ (void) sigsetmask(0); (void) alarm((u_int)tmout); (void) fcntl(fd, O_NONBLOCK, &off); continue; } /* * We get ENODEV on a slip line if we're running as root, * and EIO if the line just went away. */ if (errno == ENODEV || errno == EIO) break; (void) close(fd); if (forked) _exit(1); if (strlen(strerror(errno)) > 1000) (void) sprintf(errbuf, _("%s: BAD ERROR"), device); else { errsv = errno; (void) sprintf(errbuf, "%s: %s", device, strerror(errsv)); } errbuf[1024] = 0; return (errbuf); } (void) close(fd); if (forked) _exit(0); return (NULL); }
void alarmHandler(int s) { alarm(1); alarmSignal = true; return; }
int main(int argc, char **argv) { gzFile *infp; char buf[BUFSIZ], *bp, **aliases; struct hostent *he; int ch, errors = 0; int backcount = 0; progname = argv[0]; while ((ch = getopt(argc, argv, "a:")) != -1) switch(ch) { case 'a': backcount = atoi(optarg); break; case 'h': case '?': default: usage(); } argc -= optind; argv += optind; if (argc) usage(); openlog("genlastlog", LOG_PID, LOG_TESTBED); syslog(LOG_NOTICE, "genlastlog starting"); if (!dbinit()) { syslog(LOG_ERR, "Could not connect to DB!"); exit(1); } /* * We need the canonical hostname for the usersnode so that we can * put those logins in another table. */ if ((he = gethostbyname(USERNODE)) == NULL) { syslog(LOG_ERR, "gethostname %s: %s", USERNODE, hstrerror(h_errno)); exit(-1); } strncpy(opshostname, he->h_name, sizeof(opshostname)); if (bp = strchr(opshostname, '.')) *bp = 0; while (backcount) { sprintf(buf, "%s/%s.%d.gz", USERSVAR, LOGINS, backcount); /* * Use setjmp and timer to prevent NFS lockup. */ if (setjmp(deadline) == 0) { alarm(15); if ((infp = gzopen(buf, "r")) == NULL) { syslog(LOG_ERR, "Opening %s: %m", buf); errors++; } else { doit(infp); gzclose(infp); } } backcount--; alarm(0); } sprintf(buf, "%s/%s", USERSVAR, LOGINS); if (setjmp(deadline) == 0) { alarm(15); if ((infp = gzopen(buf, "r")) == NULL) { syslog(LOG_ERR, "Opening %s: %m", buf); errors++; } else { doit(infp); gzclose(infp); } } alarm(0); syslog(LOG_NOTICE, "genlastlog ending"); exit(errors); }
void start_watchdog(void) { alarm( 3 ); watchdog = 0; }
static xmp_main(lua_State *L) { /* * called in lua as fuse.main(dispatch_table, fuse_table) */ L_VM = L; int argc = lua_objlen(L, 2); char *argv[256]; int i; if (argc < 2) luaL_error(L, "check parameter fusemount parameter table"); #if 0 lua_pushstring(L, "pulse_freq"); lua_gettable(L, 1); pulse_freq = lua_tointeger(L,-1); lua_pop(L,1); if (pulse_freq == 0) pulse_freq = 10; #endif /* * save dispatch table for future reference by C program */ lua_pushvalue(L, 1); dispatch_table = luaL_ref(L_VM, LUA_REGISTRYINDEX); /* * turn fuse option table(effectively cmdline) to argv style */ for (i=0; i < argc && i < 255; i++) { lua_rawgeti(L, 2, i + 1); argv[i]=lua_tostring(L, -1); } argv[i] = NULL; #if 0 if (pulse_freq > 0) { signal(SIGALRM,l_signal); alarm(pulse_freq); } #endif /* * hand over to fuse loop */ fuse_main(argc, argv, &xmp_oper); /* * remove argv strings from L stack */ lua_pop(L, i); /* * discard reference to dispatch_table */ luaL_unref(L, LUA_REGISTRYINDEX, dispatch_table); #if 0 signal(SIGALRM, SIG_DFL); #endif return 0; }
int main(int argc, char **argv) { char ch; int task = ZBX_TASK_START; char *TEST_METRIC = NULL; zbx_sock_t s_in; zbx_sock_t s_out; int ret; char **value, *command; AGENT_RESULT result; memset(&result, 0, sizeof(AGENT_RESULT)); progname = get_program_name(argv[0]); /* Parse the command-line. */ while ((ch = (char)zbx_getopt_long(argc, argv, "c:hVpt:", longopts, NULL)) != (char)EOF) switch (ch) { case 'c': CONFIG_FILE = strdup(zbx_optarg); break; case 'h': help(); exit(-1); break; case 'V': version(); #ifdef _AIX tl_version(); #endif /* _AIX */ exit(-1); break; case 'p': if (task == ZBX_TASK_START) task = ZBX_TASK_PRINT_SUPPORTED; break; case 't': if (task == ZBX_TASK_START) { task = ZBX_TASK_TEST_METRIC; TEST_METRIC = strdup(zbx_optarg); } break; default: task = ZBX_TASK_SHOW_USAGE; break; } if (CONFIG_FILE == NULL) CONFIG_FILE = DEFAULT_CONFIG_FILE; init_metrics(); if (ZBX_TASK_START == task) { load_config(); load_user_parameters(0); } /* Do not create debug files */ zabbix_open_log(LOG_TYPE_SYSLOG, LOG_LEVEL_EMPTY, NULL); switch (task) { case ZBX_TASK_PRINT_SUPPORTED: load_user_parameters(1); test_parameters(); exit(-1); break; case ZBX_TASK_TEST_METRIC: load_user_parameters(1); test_parameter(TEST_METRIC, PROCESS_TEST); exit(-1); break; case ZBX_TASK_SHOW_USAGE: usage(); exit(-1); break; } signal(SIGINT, child_signal_handler); signal(SIGTERM, child_signal_handler); signal(SIGQUIT, child_signal_handler); signal(SIGALRM, child_signal_handler); alarm(CONFIG_TIMEOUT); zbx_tcp_init(&s_in, (ZBX_SOCKET)fileno(stdin)); zbx_tcp_init(&s_out, (ZBX_SOCKET)fileno(stdout)); if( SUCCEED == (ret = zbx_tcp_check_security(&s_in, CONFIG_HOSTS_ALLOWED, 0)) ) { if( SUCCEED == (ret = zbx_tcp_recv(&s_in, &command)) ) { zbx_rtrim(command, "\r\n"); zabbix_log(LOG_LEVEL_DEBUG, "Requested [%s]", command); init_result(&result); process(command, 0, &result); if( NULL == (value = GET_TEXT_RESULT(&result)) ) value = GET_MSG_RESULT(&result); if(value) { zabbix_log(LOG_LEVEL_DEBUG, "Sending back [%s]", *value); ret = zbx_tcp_send(&s_out, *value); } free_result(&result); } if( FAIL == ret ) { zabbix_log(LOG_LEVEL_DEBUG, "Processing error: %s", zbx_tcp_strerror()); } } fflush(stdout); free_metrics(); alias_list_free(); alarm(0); zabbix_close_log(); return SUCCEED; }
static int cour_connect(void) { char c; int volatile nc; int volatile nl; int n; char dialer_buf[64]; struct baud_msg *bm; sig_t f; if (cour_swallow("\r\n") == 0) return (0); f = signal(SIGALRM, sigALRM); again: (void)memset(dialer_buf, 0, sizeof(dialer_buf)); timeout = 0; for (nc = 0, nl = sizeof(dialer_buf) - 1 ; nl > 0 ; nc++, nl--) { if (setjmp(timeoutbuf)) break; (void)alarm((unsigned)number(value(DIALTIMEOUT))); n = read(FD, &c, 1); (void)alarm(0); if (n <= 0) break; c &= 0x7f; if (c == '\r') { if (cour_swallow("\n") == 0) break; if (!dialer_buf[0]) goto again; if (strcmp(dialer_buf, "RINGING") == 0 && boolean(value(VERBOSE))) { #ifdef DEBUG (void)printf("%s\r\n", dialer_buf); #endif goto again; } if (strncmp(dialer_buf, "CONNECT", sizeof("CONNECT")-1) != 0) break; for (bm = baud_msg ; bm->msg ; bm++) if (strcmp(bm->msg, dialer_buf+sizeof("CONNECT")-1) == 0) { struct termios cntrl; (void)tcgetattr(FD, &cntrl); (void)cfsetospeed(&cntrl, bm->baud); (void)cfsetispeed(&cntrl, bm->baud); (void)tcsetattr(FD, TCSAFLUSH, &cntrl); (void)signal(SIGALRM, f); #ifdef DEBUG if (boolean(value(VERBOSE))) (void)printf("%s\r\n", dialer_buf); #endif return (1); } break; } dialer_buf[nc] = c; #ifdef notdef if (boolean(value(VERBOSE))) (void)putchar(c); #endif } (void)printf("%s\r\n", dialer_buf); (void)signal(SIGALRM, f); return (0); }
int collect (char *iface, u_long seq) { struct libnet_tcp_hdr *tcp; pid_t pid; struct pcap_pkthdr hdr; pcap_t *desc; char errbuf[PCAP_ERRBUF_SIZE]; u_char *in_pkt; struct bpf_program bp; char *filter = "ip6 and tcp"; struct timeval timenow, timethen; int hdr_size; desc = pcap_open_live (iface, 1500, 1, 0, errbuf); if (desc == NULL) { fprintf (stderr, "error opening device for capture: %s", errbuf); return 0; } pcap_compile (desc, &bp, filter, 1, 65535); pcap_setfilter (desc, &bp); switch (pcap_datalink (desc)) { case DLT_RAW: hdr_size = 40; if (verbose) printf ("Datalink: Raw\n"); break; case DLT_EN10MB: hdr_size = 54; if (verbose) printf ("Datalink: Ethernet\n"); break; default: fprintf (stderr, "Datalink type not supported\n"); return 0; } if ((pid = fork ())) { /*chld */ setsid (); signal (SIGALRM, (void *) (finish)); if (verbose) gettimeofday (&timethen, NULL); do { alarm (timeout); in_pkt = (u_char *) pcap_next (desc, &hdr); if (in_pkt != NULL) { /* we should check for extra headers...someday */ tcp = ((struct libnet_tcp_hdr *) (in_pkt + hdr_size)); if (ntohl (tcp->th_ack) == seq + 1) { alarm (0); if ((tcp->th_flags & TH_SYN) && (tcp->th_flags & TH_ACK)) { if (verbose) gettimeofday (&timenow, NULL); !verbose ? printf ("Open: %d\n", ntohs (tcp-> th_sport)) : printf ("Open: %d %u.%.4us\n", ntohs (tcp->th_sport), timenow.tv_sec - timethen.tv_sec, timenow.tv_usec - timethen.tv_usec); } } } } while (1); } return 1; }
int start(int argc, char **argv) { int res = 0; int fd; int i, rc; void *rc1; static struct scst_user_dev_desc desc; pthread_t thread[MAX_VDEVS][threads]; memset(thread, 0, sizeof(thread)); i = 0; optind -= 2; while (1) { int j; optind += 2; if (optind > (argc-2)) break; devs[i].block_size = block_size; devs[i].block_shift = block_shift; devs[i].alloc_fn = alloc_fn; devs[i].rd_only_flag = rd_only_flag; devs[i].wt_flag = wt_flag; devs[i].nv_cache = nv_cache; devs[i].o_direct_flag = o_direct_flag; devs[i].nullio = nullio; devs[i].non_blocking = non_blocking; #if defined(DEBUG_TM_IGNORE) || defined(DEBUG_TM_IGNORE_ALL) devs[i].debug_tm_ignore = debug_tm_ignore; #endif devs[i].type = TYPE_DISK; devs[i].name = argv[optind]; devs[i].file_name = argv[optind+1]; TRACE_DBG("Opening file %s", devs[i].file_name); fd = open(devs[i].file_name, O_RDONLY|O_LARGEFILE); if (fd < 0) { res = -errno; PRINT_ERROR("Unable to open file %s (%s)", devs[i].file_name, strerror(-res)); continue; } devs[i].file_size = lseek64(fd, 0, SEEK_END); devs[i].nblocks = devs[i].file_size >> devs[i].block_shift; close(fd); PRINT_INFO("%s", " "); PRINT_INFO("Virtual device \"%s\", path \"%s\", size %"PRId64"MB, " "block size %d, nblocks %"PRId64", options:", devs[i].name, devs[i].file_name, (uint64_t)devs[i].file_size/1024/1024, devs[i].block_size, (uint64_t)devs[i].nblocks); snprintf(devs[i].usn, sizeof(devs[i].usn), "%"PRIx64, gen_dev_id_num(&devs[i])); TRACE_DBG("usn %s", devs[i].usn); devs[i].scst_usr_fd = open(DEV_USER_PATH DEV_USER_NAME, O_RDWR | (devs[i].non_blocking ? O_NONBLOCK : 0)); if (devs[i].scst_usr_fd < 0) { res = -errno; PRINT_ERROR("Unable to open SCST device %s (%s)", DEV_USER_PATH DEV_USER_NAME, strerror(-res)); goto out_unreg; } memset(&desc, 0, sizeof(desc)); desc.license_str = (unsigned long)"GPL"; desc.version_str = (unsigned long)DEV_USER_VERSION; strncpy(desc.name, devs[i].name, sizeof(desc.name)-1); desc.name[sizeof(desc.name)-1] = '\0'; if (sgv_shared) { desc.sgv_shared = 1; strncpy(desc.sgv_name, devs[0].name, sizeof(desc.sgv_name)-1); desc.sgv_name[sizeof(desc.sgv_name)-1] = '\0'; } desc.sgv_single_alloc_pages = sgv_single_alloc_pages; desc.sgv_purge_interval = sgv_purge_interval; desc.sgv_disable_clustered_pool = sgv_disable_clustered_pool; desc.type = devs[i].type; desc.block_size = devs[i].block_size; desc.opt.parse_type = parse_type; desc.opt.on_free_cmd_type = on_free_cmd_type; desc.opt.memory_reuse_type = memory_reuse_type; desc.opt.tst = SCST_CONTR_MODE_SEP_TASK_SETS; desc.opt.queue_alg = SCST_CONTR_MODE_QUEUE_ALG_UNRESTRICTED_REORDER; desc.opt.d_sense = SCST_CONTR_MODE_FIXED_SENSE; res = ioctl(devs[i].scst_usr_fd, SCST_USER_REGISTER_DEVICE, &desc); if (res != 0) { res = errno; PRINT_ERROR("Unable to register device: %s", strerror(res)); goto out_unreg; } if ((prealloc_buffers_num > 0) && (prealloc_buffer_size > 0)) { res = prealloc_buffers(&devs[i]); if (res != 0) goto out_unreg; } #if 1 { /* Not needed, added here only as a test */ struct scst_user_opt opt; res = ioctl(devs[i].scst_usr_fd, SCST_USER_GET_OPTIONS, &opt); if (res != 0) { res = errno; PRINT_ERROR("Unable to get options: %s", strerror(res)); goto out_unreg; } opt.parse_type = parse_type; opt.on_free_cmd_type = on_free_cmd_type; opt.memory_reuse_type = memory_reuse_type; res = ioctl(devs[i].scst_usr_fd, SCST_USER_SET_OPTIONS, &opt); if (res != 0) { res = errno; PRINT_ERROR("Unable to set options: %s", strerror(res)); goto out_unreg; } } #endif res = pthread_mutex_init(&devs[i].dev_mutex, NULL); if (res != 0) { res = errno; PRINT_ERROR("pthread_mutex_init() failed: %s", strerror(res)); goto out_unreg; } for (j = 0; j < threads; j++) { rc = pthread_create(&thread[i][j], NULL, main_loop, &devs[i]); if (rc != 0) { res = errno; PRINT_ERROR("pthread_create() failed: %s", strerror(res)); break; } } i++; num_devs++; if (num_devs >= MAX_VDEVS) { PRINT_INFO("Max devices limit %d reached", i); break; } } for (i = 0; i < num_devs; i++) { int j = 0; while (thread[i][j] != 0) { rc = pthread_join(thread[i][j], &rc1); if (rc != 0) { res = errno; PRINT_ERROR("pthread_join() failed: %s", strerror(res)); } else if (rc1 != NULL) { res = (long)rc1; PRINT_INFO("Thread %d exited (dev %s), res %lx", j, devs[i].name, (long)rc1); } else PRINT_INFO("Thread %d exited (dev %s)", j, devs[i].name); j++; } pthread_mutex_destroy(&devs[i].dev_mutex); } out_unreg: alarm(0); for (i = 0; i < num_devs; i++) { if (unreg_before_close) { res = ioctl(devs[i].scst_usr_fd, SCST_USER_UNREGISTER_DEVICE, NULL); if (res != 0) { res = errno; PRINT_ERROR("Unable to unregister device: %s", strerror(res)); /* go through */ } } close(devs[i].scst_usr_fd); } return res; }
int simple_eval(char *const argv[], char *path, int timeout, int *ppid) { pid_t pid; int status; int fd; int flags; int sig; int i; switch (pid = fork()) { case -1: // error perror("fork"); return errno; case 0: // child // Reset signal handlers set for parent process for (sig = 0; sig < (_NSIG-1); sig++) signal(sig, SIG_DFL); // Clean up //ioctl(0, TIOCNOTTY, 0); //close(STDIN_FILENO); setsid(); for (i=3; i<256; ++i) // close un-needed fd close(i); // Redirect stdout to <path> if (path) { flags = O_WRONLY | O_CREAT; if (!strncmp(path, ">>", 2)) { // append to <path> flags |= O_APPEND; path += 2; } else if (!strncmp(path, ">", 1)) { // overwrite <path> flags |= O_TRUNC; path += 1; } if ((fd = open(path, flags, 0644)) < 0) perror(path); else { dup2(fd, STDOUT_FILENO); dup2(fd, STDERR_FILENO); close(fd); } } // execute command dprintf("%s\n", argv[0]); setenv("PATH", "/sbin:/bin:/usr/sbin:/usr/bin", 1); alarm(timeout); execvp(argv[0], argv); perror(argv[0]); exit(errno); default: // parent if (ppid) { *ppid = pid; return 0; } else { if (waitpid(pid, &status, 0) == -1) { perror("waitpid"); return errno; } if (WIFEXITED(status)) return WEXITSTATUS(status); else return status; } } }
int _eval(char *const argv[], char *path, int timeout, int *ppid) { sigset_t set; pid_t pid, ret; int status; int fd; int flags; int sig, i; switch (pid = fork()) { case -1: /* error */ perror("fork"); return errno; case 0: /* child */ /* Reset signal handlers set for parent process */ for (sig = 0; sig < (_NSIG-1); sig++) signal(sig, SIG_DFL); /* Unblock signals if called from signal handler */ sigemptyset(&set); sigprocmask(SIG_SETMASK, &set, NULL); /* Clean up */ for (i=3; i<256; i++) // close un-needed fd close(i); ioctl(0, TIOCNOTTY, 0); // detach from current process setsid(); /* Redirect stdout to <path> */ if (path) { flags = O_WRONLY | O_CREAT; if (!strncmp(path, ">>", 2)) { /* append to <path> */ flags |= O_APPEND; path += 2; } else if (!strncmp(path, ">", 1)) { /* overwrite <path> */ flags |= O_TRUNC; path += 1; } if ((fd = open(path, flags, 0644)) < 0) perror(path); else { dup2(fd, STDOUT_FILENO); dup2(fd, STDERR_FILENO); close(fd); } } /* execute command */ dprintf("%s\n", argv[0]); setenv("PATH", "/sbin:/bin:/usr/sbin:/usr/bin", 1); alarm(timeout); execvp(argv[0], argv); perror(argv[0]); exit(errno); default: /* parent */ if (ppid) { *ppid = pid; return 0; } else { do ret = waitpid(pid, &status, 0); while ((ret == -1) && (errno == EINTR)); if (ret != pid) { perror("waitpid"); return errno; } if (WIFEXITED(status)) return WEXITSTATUS(status); else return status; } } }
int main(int argc, char *argv[]) { ///////////////*****SETUP****///////////////// int sock, port, nbytes, size, base; struct sockaddr_in serv_addr, client_addr; //initialize the alarm signal signal(SIGALRM, catch_alarm); if (argc < 5) { fprintf(stderr,"usage %s port CWind Pl Pc\n", argv[0]); exit(1); } int windowSize = atoi(argv[2]); struct packet packets[windowSize]; int acks[windowSize]; char fileName[DATA_SIZE]; int packetsSent = 0; int pCorrupt = atoi(argv[3]); int pLoss= atoi(argv[4]); sock = socket(AF_INET, SOCK_DGRAM, 0); //set socket to not block and set the buffer size int flags = fcntl(sock, F_GETFL); fcntl(sock, F_SETFL, flags | O_NONBLOCK); if (sock < 0) error("ERROR opening socket"); bzero((char *) &serv_addr, sizeof(serv_addr)); port = atoi(argv[1]); serv_addr.sin_family = AF_INET; serv_addr.sin_addr.s_addr = INADDR_ANY; serv_addr.sin_port = htons(port); //bind the socket size = sizeof(serv_addr); if ( bind(sock, (struct sockaddr*) &serv_addr, (socklen_t) size) < 0) { error("bind error"); } ///////////////*****HANDSHAKE****///////////////// //wait for connections struct packet handshake; fprintf (stderr, "waiting for message \n"); size = sizeof(client_addr); while(1) { if( nbytes = recvfrom(sock, &handshake, DATAGRAM_SIZE, 0, (struct sockaddr *) &client_addr, &size) < 0) { if( errno == EWOULDBLOCK ) { continue; } error("recvfrom failed"); } break; } //print diagnostic to console char addr[256]; inet_ntop(AF_INET, &(client_addr.sin_addr), addr, INET_ADDRSTRLEN); fprintf (stderr, "Sender: got message: %s From: %s : %d\n", handshake.data, addr, client_addr.sin_port); dump(&handshake); //get the requested filename strcpy(fileName, handshake.data); //init connection by sending an ack //seq stays the same handshake.ack = 1; size = sizeof(client_addr); while(1) { if( nbytes = sendto (sock, &handshake, DATAGRAM_SIZE, 0, (struct sockaddr *) &client_addr , size) < 0) { if( errno == EWOULDBLOCK ) { continue; } printf("error: %d\n", errno); error("sendto failed"); } break; } //print diagnostic to console inet_ntop(AF_INET, &(client_addr.sin_addr), addr, INET_ADDRSTRLEN); printf ("Sender: Sent ack for : %d To: %s : %d ", handshake.seq, addr, client_addr.sin_port); dump(&handshake); /////// FILE IO ///////// // open file FILE * fd = fopen(fileName,"r"); if (fd == NULL) // open failed { error("failed open file"); } ////////////initial window of packets//////////// base = 1; int k; for(k = 0; k < windowSize; k++) { // get the next chunk of the file struct packet p; initPacket(&p); p.seq = k+1; p.size = fread(p.data, 1, DATA_SIZE, fd); printf ("Sender: size is %d\n", p.size); packets[k] = p; //send the packet size = sizeof(client_addr); while(1) { if( nbytes = sendto (sock, &packets[k], DATAGRAM_SIZE, 0, (struct sockaddr *) &client_addr , size) < 0) { if( errno == EWOULDBLOCK ) { continue; } error("sendto failed"); } break; } packetsSent++; //print diagnostic to console inet_ntop(AF_INET, &(client_addr.sin_addr), addr, INET_ADDRSTRLEN); printf ("Sender: Sent datagram to: %s : %d :\n", addr, client_addr.sin_port); dump(&packets[k]); if(feof(fd) || ferror(fd) ) { //done reading file break; } } //start the timer setTimeout(TIMEOUT); ////////****** MAIN LOOP *********/////////// // wait for acks // when we receive an ack, update the packet window and send out the new packets while(1) { if(timeout) { //we timed out, retransmit the window printf("packet timed out Seq: \n"); int k; for(k = 0; k < windowSize; k++) { //send the packet size = sizeof(client_addr); while(1) { if( nbytes = sendto (sock, &packets[k], DATAGRAM_SIZE, 0, (struct sockaddr *) &client_addr , size) < 0) { if( errno == EWOULDBLOCK ) { continue; } error("sendto failed"); } break; } } setTimeout(TIMEOUT); } //if file is empty or done reading, terminate connection if(feof(fd)) { } struct packet ack; initPacket(&ack); //wait for packet size = sizeof(client_addr); if( nbytes = recvfrom(sock, &ack, DATAGRAM_SIZE, 0, (struct sockaddr *) &client_addr, &size) < 0) { if( errno == EWOULDBLOCK ) { continue; } error("recvfrom failed"); } if (prob(pCorrupt) || prob(pLoss)) { fprintf(stderr, "packet was corrupted or lost\n"); continue; } char addr[256]; inet_ntop(AF_INET, &(client_addr.sin_addr), addr, INET_ADDRSTRLEN); /////********* PACKET IS ACK *********//// if( ack.ack == 1) { fprintf (stderr, "Sender: got ack From: %s : %d\n", addr, client_addr.sin_port); dump(&ack); if( feof(fd) && ack.seq == packetsSent) { fclose(fd); struct packet terminate; initPacket(&terminate); terminate.fin = 1; //send the packet size = sizeof(client_addr); while(1) { if( nbytes = sendto (sock, &terminate, DATAGRAM_SIZE, 0, (struct sockaddr *) &client_addr , size) < 0) { if( errno == EWOULDBLOCK ) { continue; } error("sendto failed"); } break; } //print diagnostic to console inet_ntop(AF_INET, &(client_addr.sin_addr), addr, INET_ADDRSTRLEN); printf ("Sender: Sent termination: To: %s : %d \n", addr, client_addr.sin_port); dump(&terminate); break; } // update the packets in the window and send new packets if(base <= ack.seq) { //stop the timeout alarm alarm(0); for(k=0; k < windowSize; k++) { if(packets[k].seq <= ack.seq ) { if(feof(fd) || ferror(fd) ) { //done reading file printf("done reading file\n"); break; } //get the next packet struct packet p; p.seq = base + windowSize; //read the next chunk from the file p.size = fread(p.data, 1, DATA_SIZE, fd); packets[k] = p; //send the packet size = sizeof(client_addr); while(1) { if( nbytes = sendto (sock, &packets[k], DATAGRAM_SIZE, 0, (struct sockaddr *) &client_addr , size) < 0) { if( errno == EWOULDBLOCK ) { continue; } error("sendto failed"); } break; } packetsSent++; //print diagnostic to console inet_ntop(AF_INET, &(client_addr.sin_addr), addr, INET_ADDRSTRLEN); printf ("Sender: Sent datagram To: %s : %d \n", addr, client_addr.sin_port); dump(&packets[k]); base++; } } //reset the timer setTimeout(TIMEOUT); } } else { fprintf (stderr, "Sender: message wasn't an ack From: %s : %d\n", addr, client_addr.sin_port); dump(&ack); } } }
int main(int argc, char **argv) { long count; static unsigned char buf[BUFSIZE]; static DES_cblock key = {0x12,0x34,0x56,0x78,0x9a,0xbc,0xde,0xf0}; static DES_cblock key2= {0x34,0x56,0x78,0x9a,0xbc,0xde,0xf0,0x12}; static DES_cblock key3= {0x56,0x78,0x9a,0xbc,0xde,0xf0,0x12,0x34}; DES_key_schedule sch,sch2,sch3; double d,tm[16],max=0; int rank[16]; char *str[16]; int max_idx=0,i,num=0,j; #ifndef SIGALARM long ca,cb,cc,cd,ce; #endif for (i=0; i<12; i++) { tm[i]=0.0; rank[i]=0; } #ifndef TIMES fprintf(stderr,"To get the most accurate results, try to run this\n"); fprintf(stderr,"program when this computer is idle.\n"); #endif DES_set_key_unchecked(&key,&sch); DES_set_key_unchecked(&key2,&sch2); DES_set_key_unchecked(&key3,&sch3); #ifndef SIGALRM fprintf(stderr,"First we calculate the approximate speed ...\n"); DES_set_key_unchecked(&key,sch); count=10; do { long i; unsigned long data[2]; count*=2; Time_F(START); for (i=count; i; i--) DES_encrypt1(data,&(sch[0]),DES_ENCRYPT); d=Time_F(STOP); } while (d < 3.0); ca=count; cb=count*3; cc=count*3*8/BUFSIZE+1; cd=count*8/BUFSIZE+1; ce=count/20+1; #define COND(d) (count != (d)) #define COUNT(d) (d) #else #define COND(c) (run) #define COUNT(d) (count) signal(SIGALRM,sig_done); alarm(10); #endif #ifdef PART1 time_it(des_encrypt_u4_cisc_idx, "des_encrypt_u4_cisc_idx ", 0); time_it(des_encrypt_u16_cisc_idx, "des_encrypt_u16_cisc_idx ", 1); time_it(des_encrypt_u4_risc1_idx, "des_encrypt_u4_risc1_idx ", 2); num+=3; #endif #ifdef PART2 time_it(des_encrypt_u16_risc1_idx,"des_encrypt_u16_risc1_idx", 3); time_it(des_encrypt_u4_risc2_idx, "des_encrypt_u4_risc2_idx ", 4); time_it(des_encrypt_u16_risc2_idx,"des_encrypt_u16_risc2_idx", 5); num+=3; #endif #ifdef PART3 time_it(des_encrypt_u4_cisc_ptr, "des_encrypt_u4_cisc_ptr ", 6); time_it(des_encrypt_u16_cisc_ptr, "des_encrypt_u16_cisc_ptr ", 7); time_it(des_encrypt_u4_risc1_ptr, "des_encrypt_u4_risc1_ptr ", 8); num+=3; #endif #ifdef PART4 time_it(des_encrypt_u16_risc1_ptr,"des_encrypt_u16_risc1_ptr", 9); time_it(des_encrypt_u4_risc2_ptr, "des_encrypt_u4_risc2_ptr ",10); time_it(des_encrypt_u16_risc2_ptr,"des_encrypt_u16_risc2_ptr",11); num+=3; #endif #ifdef PART1 str[0]=" 4 c i"; print_it("des_encrypt_u4_cisc_idx ",0); max=tm[0]; max_idx=0; str[1]="16 c i"; print_it("des_encrypt_u16_cisc_idx ",1); if (max < tm[1]) { max=tm[1]; max_idx=1; } str[2]=" 4 r1 i"; print_it("des_encrypt_u4_risc1_idx ",2); if (max < tm[2]) { max=tm[2]; max_idx=2; } #endif #ifdef PART2 str[3]="16 r1 i"; print_it("des_encrypt_u16_risc1_idx",3); if (max < tm[3]) { max=tm[3]; max_idx=3; } str[4]=" 4 r2 i"; print_it("des_encrypt_u4_risc2_idx ",4); if (max < tm[4]) { max=tm[4]; max_idx=4; } str[5]="16 r2 i"; print_it("des_encrypt_u16_risc2_idx",5); if (max < tm[5]) { max=tm[5]; max_idx=5; } #endif #ifdef PART3 str[6]=" 4 c p"; print_it("des_encrypt_u4_cisc_ptr ",6); if (max < tm[6]) { max=tm[6]; max_idx=6; } str[7]="16 c p"; print_it("des_encrypt_u16_cisc_ptr ",7); if (max < tm[7]) { max=tm[7]; max_idx=7; } str[8]=" 4 r1 p"; print_it("des_encrypt_u4_risc1_ptr ",8); if (max < tm[8]) { max=tm[8]; max_idx=8; } #endif #ifdef PART4 str[9]="16 r1 p"; print_it("des_encrypt_u16_risc1_ptr",9); if (max < tm[9]) { max=tm[9]; max_idx=9; } str[10]=" 4 r2 p"; print_it("des_encrypt_u4_risc2_ptr ",10); if (max < tm[10]) { max=tm[10]; max_idx=10; } str[11]="16 r2 p"; print_it("des_encrypt_u16_risc2_ptr",11); if (max < tm[11]) { max=tm[11]; max_idx=11; } #endif printf("options des ecb/s\n"); printf("%s %12.2f 100.0%%\n",str[max_idx],tm[max_idx]); d=tm[max_idx]; tm[max_idx]= -2.0; max= -1.0; for (;;) { for (i=0; i<12; i++) { if (max < tm[i]) { max=tm[i]; j=i; } } if (max < 0.0) break; printf("%s %12.2f %4.1f%%\n",str[j],tm[j],tm[j]/d*100.0); tm[j]= -2.0; max= -1.0; } switch (max_idx) { case 0: printf("-DDES_DEFAULT_OPTIONS\n"); break; case 1: printf("-DDES_UNROLL\n"); break; case 2: printf("-DDES_RISC1\n"); break; case 3: printf("-DDES_UNROLL -DDES_RISC1\n"); break; case 4: printf("-DDES_RISC2\n"); break; case 5: printf("-DDES_UNROLL -DDES_RISC2\n"); break; case 6: printf("-DDES_PTR\n"); break; case 7: printf("-DDES_UNROLL -DDES_PTR\n"); break; case 8: printf("-DDES_RISC1 -DDES_PTR\n"); break; case 9: printf("-DDES_UNROLL -DDES_RISC1 -DDES_PTR\n"); break; case 10: printf("-DDES_RISC2 -DDES_PTR\n"); break; case 11: printf("-DDES_UNROLL -DDES_RISC2 -DDES_PTR\n"); break; } exit(0); #if defined(LINT) || defined(OPENSSL_SYS_MSDOS) return(0); #endif }
void daemonize() { pid_t pid, sid, parent; char *lockfile; lockfile = "/var/lock/subsys/" DAEMON_NAME; openlog(DAEMON_NAME, LOG_PID, LOG_LOCAL5); /* already a daemon */ if ( getppid() == 1 ) return; /* Create the lock file as the current user */ /* if ( lockfile && lockfile[0] ) { lfp = open(lockfile,O_RDWR|O_CREAT,0660); if ( lfp < 0 ) { fprintf(stderr,"Unable to create lock file %s\n", lockfile); syslog( LOG_ERR, "unable to create lock file %s, code=%d (%s)", lockfile, errno, strerror(errno) ); exit(EXIT_FAILURE); } } */ /* Drop user if there is one, and we were run as root */ if ( getuid() == 0 || geteuid() == 0 ) { struct passwd *pw = getpwnam(RUN_AS_USER); if ( pw ) { syslog( LOG_NOTICE, "setting user to " RUN_AS_USER ); setuid( pw->pw_uid ); } } /* Trap signals that we expect to recieve */ signal(SIGCHLD,child_handler); signal(SIGUSR1,child_handler); signal(SIGALRM,child_handler); /* Fork off the parent process */ pid = fork(); if (pid < 0) { syslog( LOG_ERR, "unable to fork daemon, code=%d (%s)", errno, strerror(errno) ); exit(EXIT_FAILURE); } /* If we got a good PID, then we can exit the parent process. */ if (pid > 0) { /* Wait for confirmation from the child via SIGTERM or SIGCHLD, or for two seconds to elapse (SIGALRM). pause() should not return. */ alarm(2); pause(); exit(EXIT_FAILURE); } /* At this point we are executing as the child process */ parent = getppid(); syslog(LOG_INFO, "Starting daemon " DAEMON_NAME); /* Cancel certain signals */ signal(SIGCHLD,SIG_DFL); /* A child process dies */ signal(SIGTSTP,SIG_IGN); /* Various TTY signals */ signal(SIGTTOU,SIG_IGN); signal(SIGTTIN,SIG_IGN); signal(SIGHUP, SIG_IGN); /* Ignore hangup signal */ signal(SIGTERM,sigterm_handler); /* Die on SIGTERM */ /* Change the file mode mask */ umask(0); /* Create a new SID for the child process */ sid = setsid(); if (sid < 0) { syslog( LOG_ERR, "unable to create a new session, code %d (%s)", errno, strerror(errno) ); exit(EXIT_FAILURE); } /* Change the current working directory. This prevents the current directory from being locked; hence not being able to remove it. */ if ((chdir("/")) < 0) { syslog( LOG_ERR, "unable to change directory to %s, code %d (%s)", "/", errno, strerror(errno) ); exit(EXIT_FAILURE); } /* // write our pid to /var/run/DAEMON_NAME.pid pid_filename = "/var/run/" DAEMON_NAME ".pid"; pid_file = fopen(pid_filename, "w"); if (pid_file != NULL) { fprintf(pid_file, "%d\n", getpid()); } else { syslog (LOG_ERR, "Unable to create pid file %s %d %s", pid_filename, errno, strerror(errno)); } */ /* Redirect standard files to /dev/null */ freopen( "/dev/null", "r", stdin); freopen( "/dev/null", "w", stdout); freopen( "/var/tmp/" DAEMON_NAME, "w", stderr); chmod( "/var/tmp/" DAEMON_NAME, 0660); /* Tell the parent process that we are A-okay */ kill( parent, SIGUSR1 ); } // daemonize()
hotkey_t *find_hotkey(xcb_keysym_t keysym, xcb_button_t button, uint16_t modfield, uint8_t event_type, bool *replay_event) { int num_active = 0; hotkey_t *result = NULL; for (hotkey_t *hk = hotkeys_head; hk != NULL; hk = hk->next) { chain_t *c = hk->chain; if (chained && c->state == c->head) continue; if (match_chord(c->state, event_type, keysym, button, modfield)) { if (status_fifo != NULL && num_active == 0) { if (!chained) { snprintf(progress, sizeof(progress), "%s", c->state->repr); } else { strncat(progress, LNK_SEP, sizeof(progress) - strlen(progress) - 1); strncat(progress, c->state->repr, sizeof(progress) - strlen(progress) - 1); } put_status(HOTKEY_PREFIX, progress); } if (replay_event != NULL && c->state->replay_event) *replay_event = true; if (!locked && c->state->lock_chain) { locked = true; if (timeout > 0) alarm(0); } if (c->state == c->tail) { if (hk->cycle != NULL) { unsigned char delay = hk->cycle->delay; hk->cycle->delay = (delay == 0 ? hk->cycle->period - 1 : delay - 1); if (delay == 0) result = hk; continue; } if (chained && !locked) abort_chain(); return hk; } else { c->state = c->state->next; num_active++; grab_chord(c->state); } } else if (chained) { if (!locked && c->state->event_type == event_type) c->state = c->head; else num_active++; } } if (result != NULL) return result; if (!chained) { if (num_active > 0) { chained = true; grab_chord(escape_chord); } } else if (num_active == 0 || match_chord(escape_chord, event_type, keysym, button, modfield)) { abort_chain(); return find_hotkey(keysym, button, modfield, event_type, replay_event); } if (chained && !locked && timeout > 0) alarm(timeout); PRINTF("num active %i\n", num_active); return NULL; }
int main(int argc, char **argv) { int res = 0; int ch, longindex; struct sigaction act; setlinebuf(stdout); res = debug_init(); if (res != 0) goto out; app_name = argv[0]; memset(devs, 0, sizeof(devs)); while ((ch = getopt_long(argc, argv, "+b:e:trongluF:I:cp:f:m:d:vsS:P:hDR:Z:", long_options, &longindex)) >= 0) { switch (ch) { case 'b': block_size = atoi(optarg); PRINT_INFO("block_size %x (%s)", block_size, optarg); block_shift = scst_calc_block_shift(block_size); if (block_shift < 9) { res = -EINVAL; goto out_usage; } break; case 'e': threads = strtol(optarg, (char **)NULL, 0); break; case 't': wt_flag = 1; break; #if defined(DEBUG) || defined(TRACING) case 'd': trace_flag = strtol(optarg, (char **)NULL, 0); break; #endif case 'r': rd_only_flag = 1; break; case 'o': o_direct_flag = 1; break; case 'n': nullio = 1; break; case 'c': nv_cache = 1; break; case 'p': if (strncmp(optarg, "std", 3) == 0) parse_type = SCST_USER_PARSE_STANDARD; else if (strncmp(optarg, "call", 3) == 0) parse_type = SCST_USER_PARSE_CALL; else if (strncmp(optarg, "excpt", 5) == 0) parse_type = SCST_USER_PARSE_EXCEPTION; else goto out_usage; break; case 'f': on_free_cmd_type_set = 1; if (strncmp(optarg, "ignore", 6) == 0) on_free_cmd_type = SCST_USER_ON_FREE_CMD_IGNORE; else if (strncmp(optarg, "call", 3) == 0) on_free_cmd_type = SCST_USER_ON_FREE_CMD_CALL; else goto out_usage; break; case 's': sgv_shared = 1; break; case 'S': sgv_single_alloc_pages = atoi(optarg); break; case 'P': sgv_purge_interval = atoi(optarg); break; case 'D': sgv_disable_clustered_pool = 1; break; case 'R': prealloc_buffers_num = atoi(optarg); break; case 'Z': prealloc_buffer_size = atoi(optarg) * 1024; break; case 'm': if (strncmp(optarg, "all", 3) == 0) memory_reuse_type = SCST_USER_MEM_REUSE_ALL; else if (strncmp(optarg, "read", 4) == 0) memory_reuse_type = SCST_USER_MEM_REUSE_READ; else if (strncmp(optarg, "write", 5) == 0) memory_reuse_type = SCST_USER_MEM_REUSE_WRITE; else if (strncmp(optarg, "none", 4) == 0) memory_reuse_type = SCST_USER_MEM_NO_REUSE; else goto out_usage; break; case 'l': non_blocking = 1; break; case 'I': vdisk_ID = strtol(optarg, (char **)NULL, 0); break; case 'F': flush_interval = strtol(optarg, (char **)NULL, 0); if (flush_interval < 0) { PRINT_ERROR("Wrong flush interval %d", flush_interval); flush_interval = 0; } break; case 'u': unreg_before_close = 1; break; #if defined(DEBUG_TM_IGNORE) || defined(DEBUG_TM_IGNORE_ALL) case 'g': debug_tm_ignore = 1; break; #endif case 'v': printf("%s version %s\n", app_name, VERSION_STR); goto out_done; default: goto out_usage; } } if (optind > (argc-2)) goto out_usage; if (!on_free_cmd_type_set && (memory_reuse_type != SCST_USER_MEM_REUSE_ALL)) on_free_cmd_type = SCST_USER_ON_FREE_CMD_CALL; PRINT_INFO("%s", "Options:"); if (rd_only_flag) PRINT_INFO(" %s", "READ ONLY"); if (wt_flag) PRINT_INFO(" %s", "WRITE THROUGH"); if (nv_cache) PRINT_INFO(" %s", "NV_CACHE"); if (o_direct_flag) PRINT_INFO(" %s", "O_DIRECT"); if (nullio) PRINT_INFO(" %s", "NULLIO"); if (non_blocking) PRINT_INFO(" %s", "NON-BLOCKING"); switch(parse_type) { case SCST_USER_PARSE_STANDARD: PRINT_INFO(" %s", "Standard parse"); break; case SCST_USER_PARSE_CALL: PRINT_INFO(" %s", "Call parse"); break; case SCST_USER_PARSE_EXCEPTION: PRINT_INFO(" %s", "Exception parse"); break; default: sBUG(); } switch(on_free_cmd_type) { case SCST_USER_ON_FREE_CMD_IGNORE: PRINT_INFO(" %s", "Ignore on_free_cmd"); break; case SCST_USER_ON_FREE_CMD_CALL: PRINT_INFO(" %s", "Call on_free_cmd"); break; default: sBUG(); } switch(memory_reuse_type) { case SCST_USER_MEM_REUSE_ALL: PRINT_INFO(" %s", "Full memory reuse enabled"); break; case SCST_USER_MEM_REUSE_READ: PRINT_INFO(" %s", "READ memory reuse enabled"); break; case SCST_USER_MEM_REUSE_WRITE: PRINT_INFO(" %s", "WRITE memory reuse enabled"); break; case SCST_USER_MEM_NO_REUSE: PRINT_INFO(" %s", "Memory reuse disabled"); break; default: sBUG(); } if (sgv_shared) PRINT_INFO(" %s", "SGV shared"); if (sgv_single_alloc_pages != 0) PRINT_INFO(" Use single entry SGV cache with %d pages/entry", sgv_single_alloc_pages); if (sgv_purge_interval != 0) { if (sgv_purge_interval > 0) PRINT_INFO(" Use SGV cache purge interval %d seconds", sgv_purge_interval); else PRINT_INFO(" %s", "SGV cache purging disabled"); } if (sgv_disable_clustered_pool) PRINT_INFO(" %s", "Disable clustered SGV pool"); if ((prealloc_buffers_num > 0) && (prealloc_buffer_size > 0)) PRINT_INFO(" Prealloc %d buffers of %dKB", prealloc_buffers_num, prealloc_buffer_size / 1024); if (!o_direct_flag && (memory_reuse_type == SCST_USER_MEM_NO_REUSE)) { PRINT_INFO(" %s", "Using unaligned buffers"); alloc_fn = malloc; } #if defined(DEBUG_TM_IGNORE) || defined(DEBUG_TM_IGNORE_ALL) if (debug_tm_ignore) PRINT_INFO(" %s", "DEBUG_TM_IGNORE"); #endif #ifdef DEBUG PRINT_INFO("trace_flag %lx", trace_flag); #endif memset(&act, 0, sizeof(act)); act.sa_handler = sigusr1_handler; act.sa_flags = SA_RESTART; sigemptyset(&act.sa_mask); res = sigaction(SIGUSR1, &act, NULL); if (res != 0) { res = errno; PRINT_ERROR("sigaction() failed: %s", strerror(res)); /* don't do anything */ } if (flush_interval != 0) { memset(&act, 0, sizeof(act)); act.sa_handler = sigalrm_handler; act.sa_flags = SA_RESTART; sigemptyset(&act.sa_mask); res = sigaction(SIGALRM, &act, NULL); if (res != 0) { res = errno; PRINT_ERROR("sigaction() failed: %s", strerror(res)); goto out_done; } res = alarm(flush_interval); if (res != 0) { res = errno; PRINT_ERROR("alarm() failed: %s", strerror(res)); goto out_done; } } res = start(argc, argv); out_done: debug_done(); out: return res; out_usage: usage(); goto out_done; }
int main() { int cnt = 0; int rc; pthread_t child_thread; struct sigaction act; /* Set up main thread to handle SIGALRM */ act.sa_flags = 0; act.sa_handler = sig_handler; sigfillset(&act.sa_mask); sigaction(SIGALRM, &act, 0); printf("Initialize barrier with count = 2\n"); if (pthread_barrier_init(&barrier, NULL, 2) != 0) { printf("main: Error at pthread_barrier_init()\n"); return PTS_UNRESOLVED; } printf("main: create child thread\n"); thread_state = NOT_CREATED_THREAD; if (pthread_create(&child_thread, NULL, fn_chld, NULL) != 0) { printf("main: Error at pthread_create()\n"); return PTS_UNRESOLVED; } /* Expect the child to block*/ cnt = 0; do{ sleep(1); }while (thread_state !=EXITING_THREAD && cnt++ < 2); if (thread_state == EXITING_THREAD) { /* child thread did not block */ printf("Test FAILED: child thread did not block on " "pthread_barrier_wait()\n"); exit(PTS_FAIL); } else if (thread_state != ENTERED_THREAD) { printf("Unexpected thread state: %d\n", thread_state); exit(PTS_UNRESOLVED); } printf("main: call barrier wait\n"); /* we should not block here, but just in case we do */ alarm(2); rc = pthread_barrier_wait(&barrier); if (rc != 0 && rc != PTHREAD_BARRIER_SERIAL_THREAD) { printf("Test FAILED: main: pthread_barrier_wait() get unexpected " "return code : %d\n" , rc); exit(PTS_FAIL); } else if (rc == PTHREAD_BARRIER_SERIAL_THREAD) { printf("main: got PTHREAD_BARRIER_SERIAL_THREAD\n"); } /* We expected the child returned from barrier wait */ cnt = 1; do{ sleep(1); }while (thread_state != EXITING_THREAD && cnt++ < 3); if (thread_state == ENTERED_THREAD) { printf("Test FAILED: child thread still blocked on " "barrier wait\n"); return PTS_FAIL; } else if (thread_state != EXITING_THREAD) { printf("main: Unexpected thread state: %d\n", thread_state); return PTS_UNRESOLVED; } if (pthread_join(child_thread, NULL) != 0) { printf("main: Error at pthread_join()\n"); exit(PTS_UNRESOLVED); } if (pthread_barrier_destroy(&barrier) != 0) { printf("Error at pthread_barrier_destroy()"); return PTS_UNRESOLVED; } printf("Test PASSED\n"); return PTS_PASS; }
int main (int argc, char **argv) { /* Local Vars */ int status; char *clustername = NULL; long int clusterstatus = 255; char *clusterstatusdesc = NULL; long int clustervotes = 0; long int clusterquorum = 0; long int clusternodes = 0; netsnmp_session *ss; /* OIDs to query */ mp_snmp_query_cmd snmpcmd[] = { {{1,3,6,1,4,1,2312,8,2,1,0}, 11, ASN_OCTET_STR, (void *)&clustername, 0}, {{1,3,6,1,4,1,2312,8,2,2,0}, 11, ASN_INTEGER, (void *)&clusterstatus, sizeof(long int)}, {{1,3,6,1,4,1,2312,8,2,3,0}, 11, ASN_OCTET_STR, (void *)&clusterstatusdesc, 0}, {{1,3,6,1,4,1,2312,8,2,5,0}, 11, ASN_INTEGER, (void *)&clustervotes, sizeof(long int)}, {{1,3,6,1,4,1,2312,8,2,4,0}, 11, ASN_INTEGER, (void *)&clusterquorum, sizeof(long int)}, {{1,3,6,1,4,1,2312,8,2,7,0}, 11, ASN_INTEGER, (void *)&clusternodes, sizeof(long int)}, {{0}, 0, 0, 0}, }; /* Set signal handling and alarm */ if (signal(SIGALRM, timeout_alarm_handler) == SIG_ERR) critical("Setup SIGALRM trap failed!"); /* Process check arguments */ if (process_arguments(argc, argv) != OK) unknown("Parsing arguments failed!"); /* Start plugin timeout */ alarm(mp_timeout); /* Init Net-SNMP */ ss = mp_snmp_init(); /* Query target agent */ status = mp_snmp_query(ss, snmpcmd); switch (status) { case STAT_ERROR: unknown("Error in libnetsnmp"); break; case STAT_TIMEOUT: critical("Timeout in libnetsnmp"); break; } /* Finish Net-SNMP */ mp_snmp_deinit(); if (!clustername || clusterstatus == 255) unknown("No Cluster Status found"); /* Perfdata */ if (mp_showperfdata) mp_perfdata_int3("votes", clustervotes, "", 1, clusterquorum, 1, clusterquorum-1, 1, 0, 1, clusternodes); /* Output and return */ if (clusterstatus < 2) ok("%s [%s]", clustername, clusterstatusdesc); if (clusterstatus < 16) warning("%s [%s]", clustername, clusterstatusdesc); critical("%s [%s]", clustername, clusterstatusdesc); }
static cairo_test_status_t cairo_test_for_target (cairo_test_context_t *ctx, const cairo_boilerplate_target_t *target, int dev_offset, int dev_scale, cairo_bool_t similar) { cairo_test_status_t status; cairo_surface_t *surface = NULL; cairo_t *cr; const char *empty_str = ""; char *offset_str; char *scale_str; char *base_name, *base_path; char *out_png_path; char *ref_path = NULL, *ref_png_path, *cmp_png_path = NULL; char *new_path = NULL, *new_png_path; char *xfail_path = NULL, *xfail_png_path; char *base_ref_png_path; char *base_new_png_path; char *base_xfail_png_path; char *diff_png_path; char *test_filename = NULL, *pass_filename = NULL, *fail_filename = NULL; cairo_test_status_t ret; cairo_content_t expected_content; cairo_font_options_t *font_options; const char *format; cairo_bool_t have_output = FALSE; cairo_bool_t have_result = FALSE; void *closure; double width, height; cairo_bool_t have_output_dir; #if HAVE_MEMFAULT int malloc_failure_iterations = ctx->malloc_failure; int last_fault_count = 0; #endif /* Get the strings ready that we'll need. */ format = cairo_boilerplate_content_name (target->content); if (dev_offset) xasprintf (&offset_str, ".%d", dev_offset); else offset_str = (char *) empty_str; if (dev_scale != 1) xasprintf (&scale_str, ".x%d", dev_scale); else scale_str = (char *) empty_str; xasprintf (&base_name, "%s.%s.%s%s%s%s", ctx->test_name, target->name, format, similar ? ".similar" : "", offset_str, scale_str); if (offset_str != empty_str) free (offset_str); if (scale_str != empty_str) free (scale_str); ref_png_path = cairo_test_reference_filename (ctx, base_name, ctx->test_name, target->name, target->basename, format, CAIRO_TEST_REF_SUFFIX, CAIRO_TEST_PNG_EXTENSION); new_png_path = cairo_test_reference_filename (ctx, base_name, ctx->test_name, target->name, target->basename, format, CAIRO_TEST_NEW_SUFFIX, CAIRO_TEST_PNG_EXTENSION); xfail_png_path = cairo_test_reference_filename (ctx, base_name, ctx->test_name, target->name, target->basename, format, CAIRO_TEST_XFAIL_SUFFIX, CAIRO_TEST_PNG_EXTENSION); base_ref_png_path = cairo_test_reference_filename (ctx, base_name, ctx->test_name, NULL, NULL, format, CAIRO_TEST_REF_SUFFIX, CAIRO_TEST_PNG_EXTENSION); base_new_png_path = cairo_test_reference_filename (ctx, base_name, ctx->test_name, NULL, NULL, format, CAIRO_TEST_NEW_SUFFIX, CAIRO_TEST_PNG_EXTENSION); base_xfail_png_path = cairo_test_reference_filename (ctx, base_name, ctx->test_name, NULL, NULL, format, CAIRO_TEST_XFAIL_SUFFIX, CAIRO_TEST_PNG_EXTENSION); if (target->file_extension != NULL) { ref_path = cairo_test_reference_filename (ctx, base_name, ctx->test_name, target->name, target->basename, format, CAIRO_TEST_REF_SUFFIX, target->file_extension); new_path = cairo_test_reference_filename (ctx, base_name, ctx->test_name, target->name, target->basename, format, CAIRO_TEST_NEW_SUFFIX, target->file_extension); xfail_path = cairo_test_reference_filename (ctx, base_name, ctx->test_name, target->name, target->basename, format, CAIRO_TEST_XFAIL_SUFFIX, target->file_extension); } have_output_dir = cairo_test_mkdir (ctx->output); xasprintf (&base_path, "%s/%s", have_output_dir ? ctx->output : ".", base_name); xasprintf (&out_png_path, "%s" CAIRO_TEST_OUT_PNG, base_path); xasprintf (&diff_png_path, "%s" CAIRO_TEST_DIFF_PNG, base_path); if (ctx->test->requirements != NULL) { const char *required; required = target->is_vector ? "target=raster" : "target=vector"; if (strstr (ctx->test->requirements, required) != NULL) { cairo_test_log (ctx, "Error: Skipping for %s target %s\n", target->is_vector ? "vector" : "raster", target->name); ret = CAIRO_TEST_UNTESTED; goto UNWIND_STRINGS; } required = target->is_recording ? "target=!recording" : "target=recording"; if (strstr (ctx->test->requirements, required) != NULL) { cairo_test_log (ctx, "Error: Skipping for %s target %s\n", target->is_recording ? "recording" : "non-recording", target->name); ret = CAIRO_TEST_UNTESTED; goto UNWIND_STRINGS; } } width = ctx->test->width; height = ctx->test->height; if (width && height) { width *= dev_scale; height *= dev_scale; width += dev_offset; height += dev_offset; } #if HAVE_MEMFAULT REPEAT: MEMFAULT_CLEAR_FAULTS (); MEMFAULT_RESET_LEAKS (); ctx->last_fault_count = 0; last_fault_count = MEMFAULT_COUNT_FAULTS (); /* Pre-initialise fontconfig so that the configuration is loaded without * malloc failures (our primary goal is to test cairo fault tolerance). */ #if HAVE_FCINIT FcInit (); #endif MEMFAULT_ENABLE_FAULTS (); #endif have_output = FALSE; have_result = FALSE; /* Run the actual drawing code. */ ret = CAIRO_TEST_SUCCESS; surface = (target->create_surface) (base_path, target->content, width, height, ctx->test->width * NUM_DEVICE_SCALE + 25 * NUM_DEVICE_OFFSETS, ctx->test->height * NUM_DEVICE_SCALE + 25 * NUM_DEVICE_OFFSETS, CAIRO_BOILERPLATE_MODE_TEST, &closure); if (surface == NULL) { cairo_test_log (ctx, "Error: Failed to set %s target\n", target->name); ret = CAIRO_TEST_UNTESTED; goto UNWIND_STRINGS; } #if HAVE_MEMFAULT if (ctx->malloc_failure && MEMFAULT_COUNT_FAULTS () - last_fault_count > 0 && cairo_surface_status (surface) == CAIRO_STATUS_NO_MEMORY) { goto REPEAT; } #endif if (cairo_surface_status (surface)) { MF (MEMFAULT_PRINT_FAULTS ()); cairo_test_log (ctx, "Error: Created an error surface: %s\n", cairo_status_to_string (cairo_surface_status (surface))); ret = CAIRO_TEST_FAILURE; goto UNWIND_STRINGS; } /* Check that we created a surface of the expected type. */ if (cairo_surface_get_type (surface) != target->expected_type) { MF (MEMFAULT_PRINT_FAULTS ()); cairo_test_log (ctx, "Error: Created surface is of type %d (expected %d)\n", cairo_surface_get_type (surface), target->expected_type); ret = CAIRO_TEST_UNTESTED; goto UNWIND_SURFACE; } /* Check that we created a surface of the expected content, * (ignore the artificial CAIRO_TEST_CONTENT_COLOR_ALPHA_FLATTENED value). */ expected_content = cairo_boilerplate_content (target->content); if (cairo_surface_get_content (surface) != expected_content) { MF (MEMFAULT_PRINT_FAULTS ()); cairo_test_log (ctx, "Error: Created surface has content %d (expected %d)\n", cairo_surface_get_content (surface), expected_content); ret = CAIRO_TEST_FAILURE; goto UNWIND_SURFACE; } if (cairo_surface_set_user_data (surface, &cairo_boilerplate_output_basename_key, base_path, NULL)) { #if HAVE_MEMFAULT cairo_surface_destroy (surface); if (target->cleanup) target->cleanup (closure); goto REPEAT; #else ret = CAIRO_TEST_FAILURE; goto UNWIND_SURFACE; #endif } cairo_surface_set_device_offset (surface, dev_offset, dev_offset); cairo_surface_set_device_scale (surface, dev_scale, dev_scale); cr = cairo_create (surface); if (cairo_set_user_data (cr, &_cairo_test_context_key, (void*) ctx, NULL)) { #if HAVE_MEMFAULT cairo_destroy (cr); cairo_surface_destroy (surface); if (target->cleanup) target->cleanup (closure); goto REPEAT; #else ret = CAIRO_TEST_FAILURE; goto UNWIND_CAIRO; #endif } if (similar) cairo_push_group_with_content (cr, expected_content); /* Clear to transparent (or black) depending on whether the target * surface supports alpha. */ cairo_save (cr); cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR); cairo_paint (cr); cairo_restore (cr); /* Set all components of font_options to avoid backend differences * and reduce number of needed reference images. */ font_options = cairo_font_options_create (); cairo_font_options_set_hint_style (font_options, CAIRO_HINT_STYLE_NONE); cairo_font_options_set_hint_metrics (font_options, CAIRO_HINT_METRICS_ON); cairo_font_options_set_antialias (font_options, CAIRO_ANTIALIAS_GRAY); cairo_set_font_options (cr, font_options); cairo_font_options_destroy (font_options); cairo_save (cr); alarm (ctx->timeout); status = (ctx->test->draw) (cr, ctx->test->width, ctx->test->height); alarm (0); cairo_restore (cr); if (similar) { cairo_pop_group_to_source (cr); cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE); cairo_paint (cr); } #if HAVE_MEMFAULT MEMFAULT_DISABLE_FAULTS (); /* repeat test after malloc failure injection */ if (ctx->malloc_failure && MEMFAULT_COUNT_FAULTS () - last_fault_count > 0 && (status == CAIRO_TEST_NO_MEMORY || cairo_status (cr) == CAIRO_STATUS_NO_MEMORY || cairo_surface_status (surface) == CAIRO_STATUS_NO_MEMORY)) { cairo_destroy (cr); cairo_surface_destroy (surface); if (target->cleanup) target->cleanup (closure); cairo_debug_reset_static_data (); #if HAVE_FCFINI FcFini (); #endif if (MEMFAULT_COUNT_LEAKS () > 0) { MEMFAULT_PRINT_FAULTS (); MEMFAULT_PRINT_LEAKS (); } goto REPEAT; } #endif /* Then, check all the different ways it could fail. */ if (status) { cairo_test_log (ctx, "Error: Function under test failed\n"); ret = status; goto UNWIND_CAIRO; } #if HAVE_MEMFAULT if (MEMFAULT_COUNT_FAULTS () - last_fault_count > 0 && MEMFAULT_HAS_FAULTS ()) { VALGRIND_PRINTF ("Unreported memfaults..."); MEMFAULT_PRINT_FAULTS (); } #endif if (target->finish_surface != NULL) { #if HAVE_MEMFAULT /* We need to re-enable faults as most recording-surface processing * is done during cairo_surface_finish(). */ MEMFAULT_CLEAR_FAULTS (); last_fault_count = MEMFAULT_COUNT_FAULTS (); MEMFAULT_ENABLE_FAULTS (); #endif /* also check for infinite loops whilst replaying */ alarm (ctx->timeout); status = target->finish_surface (surface); alarm (0); #if HAVE_MEMFAULT MEMFAULT_DISABLE_FAULTS (); if (ctx->malloc_failure && MEMFAULT_COUNT_FAULTS () - last_fault_count > 0 && status == CAIRO_STATUS_NO_MEMORY) { cairo_destroy (cr); cairo_surface_destroy (surface); if (target->cleanup) target->cleanup (closure); cairo_debug_reset_static_data (); #if HAVE_FCFINI FcFini (); #endif if (MEMFAULT_COUNT_LEAKS () > 0) { MEMFAULT_PRINT_FAULTS (); MEMFAULT_PRINT_LEAKS (); } goto REPEAT; } #endif if (status) { cairo_test_log (ctx, "Error: Failed to finish surface: %s\n", cairo_status_to_string (status)); ret = CAIRO_TEST_FAILURE; goto UNWIND_CAIRO; } } /* Skip image check for tests with no image (width,height == 0,0) */ if (ctx->test->width != 0 && ctx->test->height != 0) { cairo_surface_t *ref_image; cairo_surface_t *test_image; cairo_surface_t *diff_image; buffer_diff_result_t result; cairo_status_t diff_status; if (ref_png_path == NULL) { cairo_test_log (ctx, "Error: Cannot find reference image for %s\n", base_name); /* we may be running this test to generate reference images */ _xunlink (ctx, out_png_path); /* be more generous as we may need to use external renderers */ alarm (4 * ctx->timeout); test_image = target->get_image_surface (surface, 0, ctx->test->width, ctx->test->height); alarm (0); diff_status = cairo_surface_write_to_png (test_image, out_png_path); cairo_surface_destroy (test_image); if (diff_status) { if (cairo_surface_status (test_image) == CAIRO_STATUS_INVALID_STATUS) ret = CAIRO_TEST_CRASHED; else ret = CAIRO_TEST_FAILURE; cairo_test_log (ctx, "Error: Failed to write output image: %s\n", cairo_status_to_string (diff_status)); } have_output = TRUE; ret = CAIRO_TEST_XFAILURE; goto UNWIND_CAIRO; } if (target->file_extension != NULL) { /* compare vector surfaces */ char *filenames[] = { ref_png_path, ref_path, new_png_path, new_path, xfail_png_path, xfail_path, base_ref_png_path, base_new_png_path, base_xfail_png_path, }; xasprintf (&test_filename, "%s.out%s", base_path, target->file_extension); xasprintf (&pass_filename, "%s.pass%s", base_path, target->file_extension); xasprintf (&fail_filename, "%s.fail%s", base_path, target->file_extension); if (cairo_test_file_is_older (pass_filename, filenames, ARRAY_LENGTH (filenames))) { _xunlink (ctx, pass_filename); } if (cairo_test_file_is_older (fail_filename, filenames, ARRAY_LENGTH (filenames))) { _xunlink (ctx, fail_filename); } if (cairo_test_files_equal (out_png_path, ref_path)) { cairo_test_log (ctx, "Vector surface matches reference.\n"); have_output = FALSE; ret = CAIRO_TEST_SUCCESS; goto UNWIND_CAIRO; } if (cairo_test_files_equal (out_png_path, new_path)) { cairo_test_log (ctx, "Vector surface matches current failure.\n"); have_output = FALSE; ret = CAIRO_TEST_NEW; goto UNWIND_CAIRO; } if (cairo_test_files_equal (out_png_path, xfail_path)) { cairo_test_log (ctx, "Vector surface matches known failure.\n"); have_output = FALSE; ret = CAIRO_TEST_XFAILURE; goto UNWIND_CAIRO; } if (cairo_test_files_equal (test_filename, pass_filename)) { /* identical output as last known PASS */ cairo_test_log (ctx, "Vector surface matches last pass.\n"); have_output = TRUE; ret = CAIRO_TEST_SUCCESS; goto UNWIND_CAIRO; } if (cairo_test_files_equal (test_filename, fail_filename)) { /* identical output as last known FAIL, fail */ cairo_test_log (ctx, "Vector surface matches last fail.\n"); have_result = TRUE; /* presume these were kept around as well */ have_output = TRUE; ret = CAIRO_TEST_FAILURE; goto UNWIND_CAIRO; } } /* be more generous as we may need to use external renderers */ alarm (4 * ctx->timeout); test_image = target->get_image_surface (surface, 0, ctx->test->width, ctx->test->height); alarm (0); if (cairo_surface_status (test_image)) { cairo_test_log (ctx, "Error: Failed to extract image: %s\n", cairo_status_to_string (cairo_surface_status (test_image))); if (cairo_surface_status (test_image) == CAIRO_STATUS_INVALID_STATUS) ret = CAIRO_TEST_CRASHED; else ret = CAIRO_TEST_FAILURE; cairo_surface_destroy (test_image); goto UNWIND_CAIRO; } _xunlink (ctx, out_png_path); diff_status = cairo_surface_write_to_png (test_image, out_png_path); if (diff_status) { cairo_test_log (ctx, "Error: Failed to write output image: %s\n", cairo_status_to_string (diff_status)); cairo_surface_destroy (test_image); ret = CAIRO_TEST_FAILURE; goto UNWIND_CAIRO; } have_output = TRUE; /* binary compare png files (no decompression) */ if (target->file_extension == NULL) { char *filenames[] = { ref_png_path, new_png_path, xfail_png_path, base_ref_png_path, base_new_png_path, base_xfail_png_path, }; xasprintf (&test_filename, "%s", out_png_path); xasprintf (&pass_filename, "%s.pass.png", base_path); xasprintf (&fail_filename, "%s.fail.png", base_path); if (cairo_test_file_is_older (pass_filename, filenames, ARRAY_LENGTH (filenames))) { _xunlink (ctx, pass_filename); } if (cairo_test_file_is_older (fail_filename, filenames, ARRAY_LENGTH (filenames))) { _xunlink (ctx, fail_filename); } if (cairo_test_files_equal (test_filename, pass_filename)) { cairo_test_log (ctx, "PNG file exactly matches last pass.\n"); have_result = TRUE; cairo_surface_destroy (test_image); ret = CAIRO_TEST_SUCCESS; goto UNWIND_CAIRO; } if (cairo_test_files_equal (out_png_path, ref_png_path)) { cairo_test_log (ctx, "PNG file exactly matches reference image.\n"); have_result = TRUE; cairo_surface_destroy (test_image); ret = CAIRO_TEST_SUCCESS; goto UNWIND_CAIRO; } if (cairo_test_files_equal (out_png_path, new_png_path)) { cairo_test_log (ctx, "PNG file exactly matches current failure image.\n"); have_result = TRUE; cairo_surface_destroy (test_image); ret = CAIRO_TEST_NEW; goto UNWIND_CAIRO; } if (cairo_test_files_equal (out_png_path, xfail_png_path)) { cairo_test_log (ctx, "PNG file exactly matches known failure image.\n"); have_result = TRUE; cairo_surface_destroy (test_image); ret = CAIRO_TEST_XFAILURE; goto UNWIND_CAIRO; } if (cairo_test_files_equal (test_filename, fail_filename)) { cairo_test_log (ctx, "PNG file exactly matches last fail.\n"); have_result = TRUE; /* presume these were kept around as well */ cairo_surface_destroy (test_image); ret = CAIRO_TEST_FAILURE; goto UNWIND_CAIRO; } } else { if (cairo_test_files_equal (out_png_path, ref_png_path)) { cairo_test_log (ctx, "PNG file exactly matches reference image.\n"); have_result = TRUE; cairo_surface_destroy (test_image); ret = CAIRO_TEST_SUCCESS; goto UNWIND_CAIRO; } if (cairo_test_files_equal (out_png_path, new_png_path)) { cairo_test_log (ctx, "PNG file exactly matches current failure image.\n"); have_result = TRUE; cairo_surface_destroy (test_image); ret = CAIRO_TEST_NEW; goto UNWIND_CAIRO; } if (cairo_test_files_equal (out_png_path, xfail_png_path)) { cairo_test_log (ctx, "PNG file exactly matches known failure image.\n"); have_result = TRUE; cairo_surface_destroy (test_image); ret = CAIRO_TEST_XFAILURE; goto UNWIND_CAIRO; } } if (cairo_test_files_equal (out_png_path, base_ref_png_path)) { cairo_test_log (ctx, "PNG file exactly reference image.\n"); have_result = TRUE; cairo_surface_destroy (test_image); ret = CAIRO_TEST_SUCCESS; goto UNWIND_CAIRO; } if (cairo_test_files_equal (out_png_path, base_new_png_path)) { cairo_test_log (ctx, "PNG file exactly current failure image.\n"); have_result = TRUE; cairo_surface_destroy (test_image); ret = CAIRO_TEST_NEW; goto UNWIND_CAIRO; } if (cairo_test_files_equal (out_png_path, base_xfail_png_path)) { cairo_test_log (ctx, "PNG file exactly known failure image.\n"); have_result = TRUE; cairo_surface_destroy (test_image); ret = CAIRO_TEST_XFAILURE; goto UNWIND_CAIRO; } /* first compare against the ideal reference */ ref_image = cairo_test_get_reference_image (ctx, base_ref_png_path, target->content == CAIRO_TEST_CONTENT_COLOR_ALPHA_FLATTENED); if (cairo_surface_status (ref_image)) { cairo_test_log (ctx, "Error: Cannot open reference image for %s: %s\n", base_ref_png_path, cairo_status_to_string (cairo_surface_status (ref_image))); cairo_surface_destroy (test_image); ret = CAIRO_TEST_FAILURE; goto UNWIND_CAIRO; } diff_image = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, ctx->test->width, ctx->test->height); cmp_png_path = base_ref_png_path; diff_status = image_diff (ctx, test_image, ref_image, diff_image, &result); _xunlink (ctx, diff_png_path); if (diff_status || image_diff_is_failure (&result, target->error_tolerance)) { /* that failed, so check against the specific backend */ ref_image = cairo_test_get_reference_image (ctx, ref_png_path, target->content == CAIRO_TEST_CONTENT_COLOR_ALPHA_FLATTENED); if (cairo_surface_status (ref_image)) { cairo_test_log (ctx, "Error: Cannot open reference image for %s: %s\n", ref_png_path, cairo_status_to_string (cairo_surface_status (ref_image))); cairo_surface_destroy (test_image); ret = CAIRO_TEST_FAILURE; goto UNWIND_CAIRO; } cmp_png_path = ref_png_path; diff_status = image_diff (ctx, test_image, ref_image, diff_image, &result); if (diff_status) { cairo_test_log (ctx, "Error: Failed to compare images: %s\n", cairo_status_to_string (diff_status)); ret = CAIRO_TEST_FAILURE; } else if (image_diff_is_failure (&result, target->error_tolerance)) { ret = CAIRO_TEST_FAILURE; diff_status = cairo_surface_write_to_png (diff_image, diff_png_path); if (diff_status) { cairo_test_log (ctx, "Error: Failed to write differences image: %s\n", cairo_status_to_string (diff_status)); } else { have_result = TRUE; } cairo_test_copy_file (test_filename, fail_filename); } else { /* success */ cairo_test_copy_file (test_filename, pass_filename); } } else { /* success */ cairo_test_copy_file (test_filename, pass_filename); } /* If failed, compare against the current image output, * and attempt to detect systematic failures. */ if (ret == CAIRO_TEST_FAILURE) { char *image_out_path; image_out_path = cairo_test_reference_filename (ctx, base_name, ctx->test_name, "image", "image", format, CAIRO_TEST_OUT_SUFFIX, CAIRO_TEST_PNG_EXTENSION); if (image_out_path != NULL) { if (cairo_test_files_equal (out_png_path, image_out_path)) { ret = CAIRO_TEST_XFAILURE; } else { ref_image = cairo_image_surface_create_from_png (image_out_path); if (cairo_surface_status (ref_image) == CAIRO_STATUS_SUCCESS) { diff_status = image_diff (ctx, test_image, ref_image, diff_image, &result); if (diff_status == CAIRO_STATUS_SUCCESS && !image_diff_is_failure (&result, target->error_tolerance)) { ret = CAIRO_TEST_XFAILURE; } cairo_surface_destroy (ref_image); } } free (image_out_path); } } cairo_surface_destroy (test_image); cairo_surface_destroy (diff_image); } if (cairo_status (cr) != CAIRO_STATUS_SUCCESS) { cairo_test_log (ctx, "Error: Function under test left cairo status in an error state: %s\n", cairo_status_to_string (cairo_status (cr))); ret = CAIRO_TEST_ERROR; goto UNWIND_CAIRO; } UNWIND_CAIRO: free (test_filename); free (fail_filename); free (pass_filename); test_filename = fail_filename = pass_filename = NULL; #if HAVE_MEMFAULT if (ret == CAIRO_TEST_FAILURE) MEMFAULT_PRINT_FAULTS (); #endif cairo_destroy (cr); UNWIND_SURFACE: cairo_surface_destroy (surface); if (target->cleanup) target->cleanup (closure); #if HAVE_MEMFAULT cairo_debug_reset_static_data (); #if HAVE_FCFINI FcFini (); #endif if (MEMFAULT_COUNT_LEAKS () > 0) { if (ret != CAIRO_TEST_FAILURE) MEMFAULT_PRINT_FAULTS (); MEMFAULT_PRINT_LEAKS (); } if (ret == CAIRO_TEST_SUCCESS && --malloc_failure_iterations > 0) goto REPEAT; #endif if (have_output) cairo_test_log (ctx, "OUTPUT: %s\n", out_png_path); if (have_result) { if (cmp_png_path == NULL) { /* XXX presume we matched the normal ref last time */ cmp_png_path = ref_png_path; } cairo_test_log (ctx, "REFERENCE: %s\nDIFFERENCE: %s\n", cmp_png_path, diff_png_path); } UNWIND_STRINGS: free (out_png_path); free (ref_png_path); free (base_ref_png_path); free (ref_path); free (new_png_path); free (base_new_png_path); free (new_path); free (xfail_png_path); free (base_xfail_png_path); free (xfail_path); free (diff_png_path); free (base_path); free (base_name); return ret; }
unsigned int Alarm(unsigned int seconds) { return alarm(seconds); }
int main (int argc, char *argv[]) { LDAP *ld; LDAPMessage *result; /* should be int result = STATE_UNKNOWN; */ int status = STATE_UNKNOWN; long microsec; double elapsed_time; /* for ldap tls */ int tls; int version=3; setlocale (LC_ALL, ""); bindtextdomain (PACKAGE, LOCALEDIR); textdomain (PACKAGE); if (strstr(argv[0],"check_ldaps")) { xasprintf (&progname, "check_ldaps"); } /* Parse extra opts if any */ argv=np_extra_opts (&argc, argv, progname); if (process_arguments (argc, argv) == ERROR) usage4 (_("Could not parse arguments")); if (strstr(argv[0],"check_ldaps") && ! starttls && ! ssl_on_connect) starttls = TRUE; /* initialize alarm signal handling */ signal (SIGALRM, socket_timeout_alarm_handler); /* set socket timeout */ alarm (socket_timeout); /* get the start time */ gettimeofday (&tv, NULL); /* initialize ldap */ #ifdef HAVE_LDAP_INIT if (!(ld = ldap_init (ld_host, ld_port))) { printf ("Could not connect to the server at port %i\n", ld_port); return STATE_CRITICAL; } #else if (!(ld = ldap_open (ld_host, ld_port))) { if (verbose) ldap_perror(ld, "ldap_open"); printf (_("Could not connect to the server at port %i\n"), ld_port); return STATE_CRITICAL; } #endif /* HAVE_LDAP_INIT */ #ifdef HAVE_LDAP_SET_OPTION /* set ldap options */ if (ldap_set_option (ld, LDAP_OPT_PROTOCOL_VERSION, &ld_protocol) != LDAP_OPT_SUCCESS ) { printf(_("Could not set protocol version %d\n"), ld_protocol); return STATE_CRITICAL; } #endif if (ld_port == LDAPS_PORT || ssl_on_connect) { xasprintf (&SERVICE, "LDAPS"); #if defined(HAVE_LDAP_SET_OPTION) && defined(LDAP_OPT_X_TLS) /* ldaps: set option tls */ tls = LDAP_OPT_X_TLS_HARD; if (ldap_set_option (ld, LDAP_OPT_X_TLS, &tls) != LDAP_SUCCESS) { if (verbose) ldap_perror(ld, "ldaps_option"); printf (_("Could not init TLS at port %i!\n"), ld_port); return STATE_CRITICAL; } #else printf (_("TLS not supported by the libraries!\n")); return STATE_CRITICAL; #endif /* LDAP_OPT_X_TLS */ } else if (starttls) { xasprintf (&SERVICE, "LDAP-TLS"); #if defined(HAVE_LDAP_SET_OPTION) && defined(HAVE_LDAP_START_TLS_S) /* ldap with startTLS: set option version */ if (ldap_get_option(ld,LDAP_OPT_PROTOCOL_VERSION, &version) == LDAP_OPT_SUCCESS ) { if (version < LDAP_VERSION3) { version = LDAP_VERSION3; ldap_set_option(ld, LDAP_OPT_PROTOCOL_VERSION, &version); } } /* call start_tls */ if (ldap_start_tls_s(ld, NULL, NULL) != LDAP_SUCCESS) { if (verbose) ldap_perror(ld, "ldap_start_tls"); printf (_("Could not init startTLS at port %i!\n"), ld_port); return STATE_CRITICAL; } #else printf (_("startTLS not supported by the library, needs LDAPv3!\n")); return STATE_CRITICAL; #endif /* HAVE_LDAP_START_TLS_S */ } /* bind to the ldap server */ if (ldap_bind_s (ld, ld_binddn, ld_passwd, LDAP_AUTH_SIMPLE) != LDAP_SUCCESS) { if (verbose) ldap_perror(ld, "ldap_bind"); printf (_("Could not bind to the LDAP server\n")); return STATE_CRITICAL; } /* do a search of all objectclasses in the base dn */ if (ldap_search_s (ld, ld_base, LDAP_SCOPE_BASE, ld_attr, NULL, 0, &result) != LDAP_SUCCESS) { if (verbose) ldap_perror(ld, "ldap_search"); printf (_("Could not search/find objectclasses in %s\n"), ld_base); return STATE_CRITICAL; } /* unbind from the ldap server */ ldap_unbind (ld); /* reset the alarm handler */ alarm (0); /* calcutate the elapsed time and compare to thresholds */ microsec = deltime (tv); elapsed_time = (double)microsec / 1.0e6; if (crit_time!=UNDEFINED && elapsed_time>crit_time) status = STATE_CRITICAL; else if (warn_time!=UNDEFINED && elapsed_time>warn_time) status = STATE_WARNING; else status = STATE_OK; /* print out the result */ printf (_("LDAP %s - %.3f seconds response time|%s\n"), state_text (status), elapsed_time, fperfdata ("time", elapsed_time, "s", (int)warn_time, warn_time, (int)crit_time, crit_time, TRUE, 0, FALSE, 0)); return status; }
/* * Receive a file. */ void recvfile (int fd, char *name, char *mode) { register struct tftphdr *ap; struct tftphdr *dp, *w_init (); register int n; volatile int block, size, firsttrip; volatile unsigned long amount; struct sockaddr_in from; socklen_t fromlen; FILE *file; volatile int convert; /* true if converting crlf -> lf */ startclock (); dp = w_init (); ap = (struct tftphdr *) ackbuf; file = fdopen (fd, "w"); convert = !strcmp (mode, "netascii"); block = 1; firsttrip = 1; amount = 0; signal (SIGALRM, timer); do { if (firsttrip) { size = makerequest (RRQ, name, ap, mode); firsttrip = 0; } else { ap->th_opcode = htons ((u_short) ACK); ap->th_block = htons ((u_short) (block)); size = 4; block++; } timeout = 0; setjmp (timeoutbuf); send_ack: if (trace) tpacket ("sent", ap, size); if (sendto (f, ackbuf, size, 0, (struct sockaddr *) &peeraddr, sizeof (peeraddr)) != size) { alarm (0); perror ("tftp: sendto"); goto abort; } write_behind (file, convert); for (;;) { alarm (rexmtval); do { fromlen = sizeof (from); n = recvfrom (f, (char *) dp, PKTSIZE, 0, (struct sockaddr *) &from, &fromlen); } while (n <= 0); alarm (0); if (n < 0) { perror ("tftp: recvfrom"); goto abort; } peeraddr.sin_port = from.sin_port; /* added */ if (trace) tpacket ("received", dp, n); /* should verify client address */ dp->th_opcode = ntohs (dp->th_opcode); dp->th_block = ntohs (dp->th_block); if (dp->th_opcode == ERROR) { printf ("Error code %d: %s\n", dp->th_code, dp->th_msg); goto abort; } if (dp->th_opcode == DATA) { int j; if (dp->th_block == block) break; /* have next packet */ /* On an error, try to synchronize * both sides. */ j = synchnet (f); if (j && trace) printf ("discarded %d packets\n", j); if (dp->th_block == (block - 1)) goto send_ack; /* resend ack */ } } /* size = write(fd, dp->th_data, n - 4); */ size = writeit (file, &dp, n - 4, convert); if (size < 0) { nak (errno + 100); break; } amount += size; } while (size == SEGSIZE); abort: /* ok to ack, since user */ ap->th_opcode = htons ((u_short) ACK); /* has seen err msg */ ap->th_block = htons ((u_short) block); sendto (f, ackbuf, 4, 0, (struct sockaddr *) &peeraddr, sizeof (peeraddr)); write_behind (file, convert); /* flush last buffer */ fclose (file); stopclock (); if (amount > 0) printstats ("Received", amount); }
void stop_watchdog(void) { alarm( 0 ); watchdog = 0; }
int RemoteConnect(char *host,char forceipv4,short oldport, char *newport) { int err; #if defined(HAVE_GETADDRINFO) if (forceipv4 == 'n') { struct addrinfo query, *response, *ap; struct addrinfo query2, *response2, *ap2; int err,connected = false; memset(&query,0,sizeof(struct addrinfo)); query.ai_family = AF_UNSPEC; query.ai_socktype = SOCK_STREAM; if ((err = getaddrinfo(host,newport,&query,&response)) != 0) { snprintf(OUTPUT,CF_BUFSIZE,"Unable to find hostname or cfengine service: (%s/%s) %s",host,STR_CFENGINEPORT,gai_strerror(err)); CfLog(cfinform,OUTPUT,""); return false; } for (ap = response; ap != NULL; ap = ap->ai_next) { Verbose("Connect to %s = %s on port %s\n",host,sockaddr_ntop(ap->ai_addr),newport); if ((CONN->sd = socket(ap->ai_family,ap->ai_socktype,ap->ai_protocol)) == -1) { CfLog(cfinform,"Couldn't open a socket","socket"); continue; } if (BINDINTERFACE[0] != '\0') { memset(&query2,0,sizeof(struct addrinfo)); query.ai_family = AF_UNSPEC; query.ai_socktype = SOCK_STREAM; if ((err = getaddrinfo(BINDINTERFACE,NULL,&query2,&response2)) != 0) { snprintf(OUTPUT,CF_BUFSIZE,"Unable to lookup hostname or cfengine service: %s",gai_strerror(err)); CfLog(cferror,OUTPUT,""); return false; } for (ap2 = response2; ap2 != NULL; ap2 = ap2->ai_next) { if (bind(CONN->sd, ap2->ai_addr, ap2->ai_addrlen) == 0) { freeaddrinfo(response2); response2 = NULL; break; } } if (response2) { freeaddrinfo(response2); } } signal(SIGALRM,(void *)TimeOut); alarm(CF_TIMEOUT); if (connect(CONN->sd,ap->ai_addr,ap->ai_addrlen) >= 0) { connected = true; alarm(0); signal(SIGALRM,SIG_DFL); break; } alarm(0); signal(SIGALRM,SIG_DFL); } if (connected) { CONN->family = ap->ai_family; snprintf(CONN->remoteip,CF_MAX_IP_LEN-1,"%s",sockaddr_ntop(ap->ai_addr)); } else { close(CONN->sd); snprintf(OUTPUT,CF_BUFSIZE*2,"Couldn't connect to host %s\n",host); CONN->sd = CF_NOT_CONNECTED; } if (response != NULL) { freeaddrinfo(response); } if (!connected) { return false; } } else #endif /* ---------------------- only have ipv4 ---------------------------------*/ { struct hostent *hp; struct sockaddr_in cin; memset(&cin,0,sizeof(cin)); if ((hp = gethostbyname(host)) == NULL) { snprintf(OUTPUT,CF_BUFSIZE,"Unable to look up IP address of %s",host); CfLog(cferror,OUTPUT,"gethostbyname"); return false; } cin.sin_port = oldport; cin.sin_addr.s_addr = ((struct in_addr *)(hp->h_addr))->s_addr; cin.sin_family = AF_INET; Verbose("Connect to %s = %s, port =%u\n",host,inet_ntoa(cin.sin_addr),SHORT_CFENGINEPORT); if ((CONN->sd = socket(AF_INET,SOCK_STREAM,0)) == -1) { CfLog(cferror,"Couldn't open a socket","socket"); return false; } if (BINDINTERFACE[0] != '\0') { Verbose("Cannot bind interface with this OS.\n"); /* Could fix this - any point? */ } CONN->family = AF_INET; snprintf(CONN->remoteip,CF_MAX_IP_LEN-1,"%s",inet_ntoa(cin.sin_addr)); signal(SIGALRM,(void *)TimeOut); alarm(CF_TIMEOUT); if (err=connect(CONN->sd,(void *)&cin,sizeof(cin)) == -1) { snprintf(OUTPUT,CF_BUFSIZE*2,"Couldn't connect to host %s\n",host); CfLog(cfinform,OUTPUT,"connect"); return false; } alarm(0); signal(SIGALRM,SIG_DFL); } LastSeen(host,cf_connect); return true; }
int main (int argc, char **argv) { int i, pid, children = 0, retval = 0; long starttime, stoptime, runtime, forks; /* Variables that indicate which options have been selected. */ int do_dryrun = 0; long long do_backoff = 3000; long long do_timeout = 0; long long do_cpu = 0; long long do_io = 0; long long do_vm = 0; long long do_vm_bytes = 256 * 1024 * 1024; long long do_vm_stride = 4096; long long do_vm_hang = -1; int do_vm_keep = 0; long long do_hdd = 0; int do_hdd_clean = 2; long long do_hdd_bytes = 1024 * 1024 * 1024; /* Record our start time. */ if ((starttime = time (NULL)) == -1) { err (stderr, "failed to acquire current time: %s\n", strerror (errno)); exit (1); } /* SuSv3 does not define any error conditions for this function. */ global_progname = basename (argv[0]); /* For portability, parse command line options without getopt_long. */ for (i = 1; i < argc; i++) { char *arg = argv[i]; if (strcmp (arg, "--help") == 0 || strcmp (arg, "-?") == 0) { usage (0); } else if (strcmp (arg, "--version") == 0) { version (0); } else if (strcmp (arg, "--verbose") == 0 || strcmp (arg, "-v") == 0) { global_debug = 3; } else if (strcmp (arg, "--quiet") == 0 || strcmp (arg, "-q") == 0) { global_debug = 0; } else if (strcmp (arg, "--dry-run") == 0 || strcmp (arg, "-n") == 0) { do_dryrun = 1; } else if (strcmp (arg, "--backoff") == 0) { assert_arg ("--backoff"); if (sscanf (arg, "%lli", &do_backoff) != 1) { err (stderr, "invalid number: %s\n", arg); exit (1); } if (do_backoff < 0) { err (stderr, "invalid backoff factor: %lli\n", do_backoff); exit (1); } dbg (stdout, "setting backoff coeffient to %llius\n", do_backoff); } else if (strcmp (arg, "--timeout") == 0 || strcmp (arg, "-t") == 0) { assert_arg ("--timeout"); do_timeout = atoll_s (arg); if (do_timeout <= 0) { err (stderr, "invalid timeout value: %llis\n", do_timeout); exit (1); } } else if (strcmp (arg, "--cpu") == 0 || strcmp (arg, "-c") == 0) { assert_arg ("--cpu"); do_cpu = atoll_b (arg); if (do_cpu <= 0) { err (stderr, "invalid number of cpu hogs: %lli\n", do_cpu); exit (1); } } else if (strcmp (arg, "--io") == 0 || strcmp (arg, "-i") == 0) { assert_arg ("--io"); do_io = atoll_b (arg); if (do_io <= 0) { err (stderr, "invalid number of io hogs: %lli\n", do_io); exit (1); } } else if (strcmp (arg, "--vm") == 0 || strcmp (arg, "-m") == 0) { assert_arg ("--vm"); do_vm = atoll_b (arg); if (do_vm <= 0) { err (stderr, "invalid number of vm hogs: %lli\n", do_vm); exit (1); } } else if (strcmp (arg, "--vm-bytes") == 0) { assert_arg ("--vm-bytes"); do_vm_bytes = atoll_b (arg); if (do_vm_bytes <= 0) { err (stderr, "invalid vm byte value: %lli\n", do_vm_bytes); exit (1); } } else if (strcmp (arg, "--vm-stride") == 0) { assert_arg ("--vm-stride"); do_vm_stride = atoll_b (arg); if (do_vm_stride <= 0) { err (stderr, "invalid stride value: %lli\n", do_vm_stride); exit (1); } } else if (strcmp (arg, "--vm-hang") == 0) { assert_arg ("--vm-hang"); do_vm_hang = atoll_b (arg); if (do_vm_hang < 0) { err (stderr, "invalid value: %lli\n", do_vm_hang); exit (1); } } else if (strcmp (arg, "--vm-keep") == 0) { do_vm_keep = 1; } else if (strcmp (arg, "--hdd") == 0 || strcmp (arg, "-d") == 0) { assert_arg ("--hdd"); do_hdd = atoll_b (arg); if (do_hdd <= 0) { err (stderr, "invalid number of hdd hogs: %lli\n", do_hdd); exit (1); } } else if (strcmp (arg, "--hdd-noclean") == 0) { do_hdd_clean = 0; } else if (strcmp (arg, "--hdd-bytes") == 0) { assert_arg ("--hdd-bytes"); do_hdd_bytes = atoll_b (arg); if (do_hdd_bytes <= 0) { err (stderr, "invalid hdd byte value: %lli\n", do_hdd_bytes); exit (1); } } else { err (stderr, "unrecognized option: %s\n", arg); exit (1); } } /* Print startup message if we have work to do, bail otherwise. */ if (do_cpu + do_io + do_vm + do_hdd) { out (stdout, "dispatching hogs: %lli cpu, %lli io, %lli vm, %lli hdd\n", do_cpu, do_io, do_vm, do_hdd); } else usage (0); /* Round robin dispatch our worker processes. */ while ((forks = (do_cpu + do_io + do_vm + do_hdd))) { long long backoff, timeout = 0; /* Calculate the backoff value so we get good fork throughput. */ backoff = do_backoff * forks; dbg (stdout, "using backoff sleep of %llius\n", backoff); /* If we are supposed to respect a timeout, calculate it. */ if (do_timeout) { long long currenttime; /* Acquire current time. */ if ((currenttime = time (NULL)) == -1) { perror ("error acquiring current time"); exit (1); } /* Calculate timeout based on current time. */ timeout = do_timeout - (currenttime - starttime); if (timeout > 0) { dbg (stdout, "setting timeout to %llis\n", timeout); } else { wrn (stderr, "used up time before all workers dispatched\n"); break; } } if (do_cpu) { switch (pid = fork ()) { case 0: /* child */ alarm (timeout); usleep (backoff); if (do_dryrun) exit (0); exit (hogcpu ()); case -1: /* error */ err (stderr, "fork failed: %s\n", strerror (errno)); break; default: /* parent */ dbg (stdout, "--> hogcpu worker %lli [%i] forked\n", do_cpu, pid); ++children; } --do_cpu; } if (do_io) { switch (pid = fork ()) { case 0: /* child */ alarm (timeout); usleep (backoff); if (do_dryrun) exit (0); exit (hogio ()); case -1: /* error */ err (stderr, "fork failed: %s\n", strerror (errno)); break; default: /* parent */ dbg (stdout, "--> hogio worker %lli [%i] forked\n", do_io, pid); ++children; } --do_io; } if (do_vm) { switch (pid = fork ()) { case 0: /* child */ alarm (timeout); usleep (backoff); if (do_dryrun) exit (0); exit (hogvm (do_vm_bytes, do_vm_stride, do_vm_hang, do_vm_keep)); case -1: /* error */ err (stderr, "fork failed: %s\n", strerror (errno)); break; default: /* parent */ dbg (stdout, "--> hogvm worker %lli [%i] forked\n", do_vm, pid); ++children; } --do_vm; } if (do_hdd) { switch (pid = fork ()) { case 0: /* child */ alarm (timeout); usleep (backoff); if (do_dryrun) exit (0); exit (hoghdd (do_hdd_bytes, do_hdd_clean)); case -1: /* error */ err (stderr, "fork failed: %s\n", strerror (errno)); break; default: /* parent */ dbg (stdout, "--> hoghdd worker %lli [%i] forked\n", do_hdd, pid); ++children; } --do_hdd; } } /* Wait for our children to exit. */ while (children) { int status, ret; if ((pid = wait (&status)) > 0) { --children; if (WIFEXITED (status)) { if ((ret = WEXITSTATUS (status)) == 0) { dbg (stdout, "<-- worker %i returned normally\n", pid); } else { err (stderr, "<-- worker %i returned error %i\n", pid, ret); ++retval; wrn (stderr, "now reaping child worker processes\n"); if (signal (SIGUSR1, SIG_IGN) == SIG_ERR) err (stderr, "handler error: %s\n", strerror (errno)); if (kill (-1 * getpid (), SIGUSR1) == -1) err (stderr, "kill error: %s\n", strerror (errno)); } } else if (WIFSIGNALED (status)) { if ((ret = WTERMSIG (status)) == SIGALRM) { dbg (stdout, "<-- worker %i signalled normally\n", pid); } else if ((ret = WTERMSIG (status)) == SIGUSR1) { dbg (stdout, "<-- worker %i reaped\n", pid); } else { err (stderr, "<-- worker %i got signal %i\n", pid, ret); ++retval; wrn (stderr, "now reaping child worker processes\n"); if (signal (SIGUSR1, SIG_IGN) == SIG_ERR) err (stderr, "handler error: %s\n", strerror (errno)); if (kill (-1 * getpid (), SIGUSR1) == -1) err (stderr, "kill error: %s\n", strerror (errno)); } } else { err (stderr, "<-- worker %i exited abnormally\n", pid); ++retval; } } else { err (stderr, "error waiting for worker: %s\n", strerror (errno)); ++retval; break; } } /* Record our stop time. */ if ((stoptime = time (NULL)) == -1) { err (stderr, "failed to acquire current time\n"); exit (1); } /* Calculate our runtime. */ runtime = stoptime - starttime; /* Print final status message. */ if (retval) { err (stderr, "failed run completed in %lis\n", runtime); } else { out (stdout, "successful run completed in %lis\n", runtime); } exit (retval); }
static void writefile(time_t runtimer, char queue) { /* This does most of the work if at or batch are invoked for writing a job. */ long jobno; char *ap, *ppos, *mailname; struct passwd *pass_entry; struct stat statbuf; int fdes, lockdes, fd2; FILE *fp, *fpin; struct sigaction act; char **atenv; int ch; mode_t cmask; struct flock lock; #ifdef __FreeBSD__ (void) setlocale(LC_TIME, ""); #endif /* Install the signal handler for SIGINT; terminate after removing the * spool file if necessary */ act.sa_handler = sigc; sigemptyset(&(act.sa_mask)); act.sa_flags = 0; sigaction(SIGINT, &act, NULL); ppos = atfile + strlen(ATJOB_DIR); /* Loop over all possible file names for running something at this * particular time, see if a file is there; the first empty slot at any * particular time is used. Lock the file LFILE first to make sure * we're alone when doing this. */ PRIV_START if ((lockdes = open(LFILE, O_WRONLY | O_CREAT, S_IWUSR | S_IRUSR)) < 0) perr("cannot open lockfile " LFILE); lock.l_type = F_WRLCK; lock.l_whence = SEEK_SET; lock.l_start = 0; lock.l_len = 0; act.sa_handler = alarmc; sigemptyset(&(act.sa_mask)); act.sa_flags = 0; /* Set an alarm so a timeout occurs after ALARMC seconds, in case * something is seriously broken. */ sigaction(SIGALRM, &act, NULL); alarm(ALARMC); fcntl(lockdes, F_SETLKW, &lock); alarm(0); if ((jobno = nextjob()) == EOF) perr("cannot generate job number"); sprintf(ppos, "%c%5lx%8lx", queue, jobno, (unsigned long) (runtimer/60)); for(ap=ppos; *ap != '\0'; ap ++) if (*ap == ' ') *ap = '0'; if (stat(atfile, &statbuf) != 0) if (errno != ENOENT) perr("cannot access " ATJOB_DIR); /* Create the file. The x bit is only going to be set after it has * been completely written out, to make sure it is not executed in the * meantime. To make sure they do not get deleted, turn off their r * bit. Yes, this is a kluge. */ cmask = umask(S_IRUSR | S_IWUSR | S_IXUSR); if ((fdes = creat(atfile, O_WRONLY)) == -1) perr("cannot create atjob file"); if ((fd2 = dup(fdes)) <0) perr("error in dup() of job file"); if(fchown(fd2, real_uid, real_gid) != 0) perr("cannot give away file"); PRIV_END /* We no longer need suid root; now we just need to be able to write * to the directory, if necessary. */ REDUCE_PRIV(DAEMON_UID, DAEMON_GID) /* We've successfully created the file; let's set the flag so it * gets removed in case of an interrupt or error. */ fcreated = 1; /* Now we can release the lock, so other people can access it */ lock.l_type = F_UNLCK; lock.l_whence = SEEK_SET; lock.l_start = 0; lock.l_len = 0; fcntl(lockdes, F_SETLKW, &lock); close(lockdes); if((fp = fdopen(fdes, "w")) == NULL) panic("cannot reopen atjob file"); /* Get the userid to mail to, first by trying getlogin(), * then from LOGNAME, finally from getpwuid(). */ mailname = getlogin(); if (mailname == NULL) mailname = getenv("LOGNAME"); if ((mailname == NULL) || (mailname[0] == '\0') || (strlen(mailname) >= MAXLOGNAME) || (getpwnam(mailname)==NULL)) { pass_entry = getpwuid(real_uid); if (pass_entry != NULL) mailname = pass_entry->pw_name; } if (atinput != (char *) NULL) { fpin = freopen(atinput, "r", stdin); if (fpin == NULL) perr("cannot open input file"); } fprintf(fp, "#!/bin/sh\n# atrun uid=%ld gid=%ld\n# mail %*s %d\n", (long) real_uid, (long) real_gid, MAXLOGNAME - 1, mailname, send_mail); /* Write out the umask at the time of invocation */ fprintf(fp, "umask %lo\n", (unsigned long) cmask); /* Write out the environment. Anything that may look like a * special character to the shell is quoted, except for \n, which is * done with a pair of "'s. Don't export the no_export list (such * as TERM or DISPLAY) because we don't want these. */ for (atenv= environ; *atenv != NULL; atenv++) { int export = 1; char *eqp; eqp = strchr(*atenv, '='); if (ap == NULL) eqp = *atenv; else { size_t i; for (i=0; i<sizeof(no_export)/sizeof(no_export[0]); i++) { export = export && (strncmp(*atenv, no_export[i], (size_t) (eqp-*atenv)) != 0); } eqp++; } if (export) { (void)fputs("export ", fp); fwrite(*atenv, sizeof(char), eqp-*atenv, fp); for(ap = eqp; *ap != '\0'; ap++) { if (*ap == '\n') fprintf(fp, "\"\n\""); else { if (!isalnum(*ap)) { switch (*ap) { case '%': case '/': case '{': case '[': case ']': case '=': case '}': case '@': case '+': case '#': case ',': case '.': case ':': case '-': case '_': break; default: fputc('\\', fp); break; } } fputc(*ap, fp); } } fputc('\n', fp); } }
static int process_trap(zbx_sock_t *sock, char *s, int max_len) { char *pl, *pr, *data, value_dec[MAX_BUFFER_LEN]; char lastlogsize[11], timestamp[11], source[HISTORY_LOG_SOURCE_LEN_MAX], severity[11]; int sender_nodeid, nodeid; char *answer; int ret = SUCCEED, res; size_t datalen; struct zbx_json_parse jp; char value[MAX_STRING_LEN]; AGENT_VALUE av; memset(&av, 0, sizeof(AGENT_VALUE)); zbx_rtrim(s, " \r\n"); datalen = strlen(s); zabbix_log(LOG_LEVEL_DEBUG, "Trapper got [%s] len %zd", s, datalen); if (0 == strncmp(s, "stats", 5)) /* Request performance stats */ { ret = send_perf_stats(sock, s); return ret; } else if (0 == strncmp(s, "ZBX_GET_ACTIVE_CHECKS", 21)) /* Request for list of active checks */ { ret = send_list_of_active_checks(sock, s, zbx_process); } else if (strncmp(s, "ZBX_GET_HISTORY_LAST_ID", 23) == 0) /* Request for last ids */ { send_history_last_id(sock, s); return ret; } else /* Process information sent by zabbix_sender */ { /* Node data exchange? */ if (strncmp(s, "Data", 4) == 0) { node_sync_lock(0); res = node_sync(s, &sender_nodeid, &nodeid); if (FAIL == res) { alarm(CONFIG_TIMEOUT); send_data_to_node(sender_nodeid, sock, "FAIL"); alarm(0); } else { res = calculate_checksums(nodeid, NULL, 0); if (SUCCEED == res && NULL != (data = get_config_data(nodeid, ZBX_NODE_SLAVE))) { zabbix_log( LOG_LEVEL_WARNING, "NODE %d: Sending configuration changes" " to slave node %d for node %d datalen %d", CONFIG_NODEID, sender_nodeid, nodeid, strlen(data)); alarm(CONFIG_TRAPPER_TIMEOUT); res = send_data_to_node(sender_nodeid, sock, data); zbx_free(data); if (SUCCEED == res) res = recv_data_from_node(sender_nodeid, sock, &answer); if (SUCCEED == res && 0 == strcmp(answer, "OK")) res = update_checksums(nodeid, ZBX_NODE_SLAVE, SUCCEED, NULL, 0, NULL); alarm(0); } } node_sync_unlock(0); return ret; } /* Slave node history ? */ if (strncmp(s, "History", 7) == 0) { const char *reply; reply = (SUCCEED == node_history(s, datalen) ? "OK" : "FAIL"); alarm(CONFIG_TIMEOUT); if (SUCCEED != zbx_tcp_send_raw(sock, reply)) { zabbix_log(LOG_LEVEL_WARNING, "Error sending %s to node", reply); zabbix_syslog("Trapper: error sending %s to node", reply); } alarm(0); return ret; } /* JSON protocol? */ else if (SUCCEED == zbx_json_open(s, &jp)) { if (SUCCEED == zbx_json_value_by_name(&jp, ZBX_PROTO_TAG_REQUEST, value, sizeof(value))) { if (0 == strcmp(value, ZBX_PROTO_VALUE_PROXY_CONFIG)) { if (0 != (zbx_process & ZBX_PROCESS_SERVER)) send_proxyconfig(sock, &jp); else if (0 != (zbx_process & ZBX_PROCESS_PROXY_PASSIVE)) recv_proxyconfig(sock, &jp); } else if (0 == strcmp(value, ZBX_PROTO_VALUE_AGENT_DATA) || 0 == strcmp(value, ZBX_PROTO_VALUE_SENDER_DATA)) { recv_agenthistory(sock, &jp); } else if (0 == strcmp(value, ZBX_PROTO_VALUE_HISTORY_DATA)) { if (0 != (zbx_process & ZBX_PROCESS_SERVER)) recv_proxyhistory(sock, &jp); else if (0 != (zbx_process & ZBX_PROCESS_PROXY_PASSIVE)) send_proxyhistory(sock); } else if (0 == strcmp(value, ZBX_PROTO_VALUE_DISCOVERY_DATA)) { if (0 != (zbx_process & ZBX_PROCESS_SERVER)) recv_discovery_data(sock, &jp); else if (0 != (zbx_process & ZBX_PROCESS_PROXY_PASSIVE)) send_discovery_data(sock); } else if (0 == strcmp(value, ZBX_PROTO_VALUE_AUTO_REGISTRATION_DATA)) { if (0 != (zbx_process & ZBX_PROCESS_SERVER)) recv_areg_data(sock, &jp); else if (0 != (zbx_process & ZBX_PROCESS_PROXY_PASSIVE)) send_areg_data(sock); } else if (0 == strcmp(value, ZBX_PROTO_VALUE_PROXY_HEARTBEAT)) { if (0 != (zbx_process & ZBX_PROCESS_SERVER)) recv_proxy_heartbeat(sock, &jp); } else if (0 == strcmp(value, ZBX_PROTO_VALUE_GET_ACTIVE_CHECKS)) { ret = send_list_of_active_checks_json(sock, &jp, zbx_process); } else if (0 == strcmp(value, ZBX_PROTO_VALUE_HOST_AVAILABILITY)) { if (0 != (zbx_process & ZBX_PROCESS_SERVER)) recv_host_availability(sock, &jp); else if (0 != (zbx_process & ZBX_PROCESS_PROXY_PASSIVE)) send_host_availability(sock); } else if (0 == strcmp(value, ZBX_PROTO_VALUE_COMMAND)) { ret = node_process_command(sock, s, &jp); } else { zabbix_log(LOG_LEVEL_WARNING, "Unknown request received [%s]", value); } } return ret; } /* XML protocol? */ else if (*s == '<') { comms_parse_response(s, av.host_name, sizeof(av.host_name), av.key, sizeof(av.key), value_dec, sizeof(value_dec), lastlogsize, sizeof(lastlogsize), timestamp, sizeof(timestamp), source, sizeof(source), severity, sizeof(severity)); av.value = value_dec; av.lastlogsize = atoi(lastlogsize); av.timestamp = atoi(timestamp); av.source = source; av.severity = atoi(severity); } else { pl = s; if (NULL == (pr = strchr(pl, ':'))) return FAIL; *pr = '\0'; zbx_strlcpy(av.host_name, pl, sizeof(av.host_name)); *pr = ':'; pl = pr + 1; if (NULL == (pr = strchr(pl, ':'))) return FAIL; *pr = '\0'; zbx_strlcpy(av.key, pl, sizeof(av.key)); *pr = ':'; av.value = pr + 1; av.severity = 0; } av.clock = time(NULL); process_mass_data(sock, 0, &av, 1, NULL); alarm(CONFIG_TIMEOUT); if (SUCCEED != zbx_tcp_send_raw(sock, SUCCEED == ret ? "OK" : "NOT OK")) { zabbix_log(LOG_LEVEL_WARNING, "Error sending result back"); zabbix_syslog("Trapper: error sending result back"); } alarm(0); } return ret; }
int64_t HHVM_FUNCTION(pcntl_alarm, int seconds) { return alarm(seconds); }
/* * Send the requested file. */ void send_file(int fd, char *name, char *mode) { register struct tftphdr *ap; /* data and ack packets */ struct tftphdr *r_init(), *dp; register int n; volatile int block, size, convert; volatile unsigned long amount; struct sockaddr_in from; int fromlen; FILE *file; startclock(); /* start stat's clock */ dp = r_init(); /* reset fillbuf/read-ahead code */ ap = (struct tftphdr *)ackbuf; file = fdopen(fd, "r"); convert = !strcmp(mode, "netascii"); block = 0; amount = 0; signal(SIGALRM, timer); do { if (block == 0) size = makerequest(WRQ, name, dp, mode) - 4; else { /* size = read(fd, dp->th_data, SEGSIZE); */ size = readit(file, &dp, convert); if (size < 0) { nak(errno + 100); break; } dp->th_opcode = htons((u_short)DATA); dp->th_block = htons((u_short)block); } timeout = 0; (void) setjmp(timeoutbuf); send_data: if (trace) tpacket("sent", dp, size + 4); n = sendto(f, (const char *)dp, size + 4, 0, (struct sockaddr *)&peeraddr, sizeof(peeraddr)); if (n != size + 4) { perror("tftp: sendto"); goto abort; } read_ahead(file, convert); for ( ; ; ) { alarm(rexmtval); do { fromlen = sizeof(from); n = recvfrom(f, ackbuf, sizeof(ackbuf), 0, (struct sockaddr *)&from, &fromlen); } while (n <= 0); alarm(0); if (n < 0) { perror("tftp: recvfrom"); goto abort; } peeraddr.sin_port = from.sin_port; /* added */ if (trace) tpacket("received", ap, n); /* should verify packet came from server */ ap->th_opcode = ntohs(ap->th_opcode); ap->th_block = ntohs(ap->th_block); if (ap->th_opcode == ERROR) { printf("Error code %d: %s\n", ap->th_code, ap->th_msg); goto abort; } if (ap->th_opcode == ACK) { int j; if (ap->th_block == block) { break; } /* On an error, try to synchronize * both sides. */ j = synchnet(f); if (j && trace) { printf("discarded %d packets\n", j); } if (ap->th_block == (block-1)) { goto send_data; } } } if (block > 0) amount += size; block++; } while (size == SEGSIZE || block == 1); abort: fclose(file); stopclock(); if (amount > 0) printstats("Sent", amount); }
/* helper processes start here via fork()/exec() in the parent */ void DCC_NORET helper_child(DCC_SOCKET s, int fd, int total_helpers) { sigset_t sigs; socklen_t soc_len; DNSBL_REQ req; int req_len; DNSBL_RESP resp; DCC_SOCKU req_su; socklen_t su_len; struct timeval now; u_char wake_buf; int secs, i; /* this process inherits via exec() by dccm or dccifd odd signal * blocking from some pthreads implementations including FreeBSD 5.* */ signal(SIGHUP, SIG_IGN); signal(SIGINT, SIG_IGN); signal(SIGTERM, SIG_IGN); sigemptyset(&sigs); sigaddset(&sigs, SIGALRM); sigprocmask(SIG_UNBLOCK, &sigs, 0); helper_init(0); if (have_helpers) dcc_logbad(EX_SOFTWARE, "no threads for DNSBL helpers"); helper.total_helpers = total_helpers; helper.pipe_read = fd; helper.soc = s; soc_len = sizeof(helper.su); if (0 > getsockname(helper.soc, &helper.su.sa, &soc_len)) dcc_logbad(EX_IOERR, "DNSBL helper getsockname(%d): %s", helper.soc, ERROR_STR()); if (helper.debug > 1) dcc_trace_msg("DNSBL helper process starting on %s", dcc_su2str_err(&helper.su)); for (;;) { /* Use read() and SIGALRM to watch for a wake-up byte * from the parent, the parent ending and closing the pipe, * or enough idle time to require our retirement. This * tactic awakens a single child for each wake-up call * from the parent. Using select() or poll() on the main * socket awakens a thundering herd of children */ secs = HELPER_IDLE_STOP_SECS+1; if (helper.total_helpers > 0) secs /= helper.total_helpers+1; if (secs < 5) secs = 5; signal(SIGALRM, helper_alarm); #ifdef HAVE_SIGINTERRUPT siginterrupt(SIGALRM, 1); #endif helper_alarm_hit = 0; alarm(secs); for (;;) { su_len = sizeof(req_su); req_len = recvfrom(helper.soc, &req, ISZ(req), 0, &req_su.sa, &su_len); /* sleep until awakened if no work is ready */ if (req_len <= 0) { if (req_len == 0) dcc_logbad(EX_IOERR, "DNSBL helper recvfrom()=0"); if (!DCC_BLOCK_ERROR()) dcc_logbad(EX_IOERR, "DNSBL helper recvfrom():" " %s", ERROR_STR()); if (helper_alarm_hit) helper_exit("idle helper exit"); i = read(helper.pipe_read, &wake_buf, 1); /* The other end of the pipe can be marked * non-blocking by some pthreads * implementations. That makes read() on this * end fail with EAGAIN. When that happens, * fall back on select() or poll(). * Even on such pthread implementations, * it rarely happens. */ if (i < 0 && DCC_BLOCK_ERROR()) { DCC_POLLFD pollfd; DCC_EMSG emsg; pollfd.fd = helper.pipe_read; i = select_poll(emsg, &pollfd, 1, 0, -1); if (i < 0) dcc_logbad(EX_IOERR, "dnsbl HELPER %s", emsg); } /* loof for work after a wake-up call */ if (i > 0) continue; if (helper_alarm_hit) continue; if (i == 0) helper_exit("shutdown"); if (i < 0) { dcc_logbad(EX_OSERR, "DNSBL read(terminate): %s", ERROR_STR()); } } if (req_len != helper.req_len) { if (helper.debug) dcc_trace_msg("DNSBL helper" " recvfrom(parent %s)=%d" " instead of %d", dcc_su2str_err(&req_su), req_len, helper.req_len); continue; } /* we might get stray packets because we cannot * connect to a single port */ if (!DCC_SUnP_EQ(&helper.su, &req_su)) { if (helper.debug) dcc_trace_msg("DNSBL helper" " request from" " %s instead of %s", dcc_su2str_err(&req_su), dcc_su2str_err(&helper.su)); continue; } if (req.hdr.magic != HELPER_MAGIC_REQ || req.hdr.version != HELPER_VERSION) { if (helper.debug) dcc_trace_msg("DNSBL helper" " recvfrom(parent %s)" " magic=%#08x", dcc_su2str_err(&req_su), req.hdr.magic); continue; } break; } gettimeofday(&now, 0); alarm(0); /* do not bother working if it is already too late to answer, * perhaps because a previous helper died */ i = tv_diff2us(&now, &req.hdr.start); if (i >= req.hdr.avail_us) { if (helper.debug > 1) dcc_trace_msg("%s DNSBL helper" " already too late to start;" " used %.1f of %.1f seconds", req.hdr.id, i / (DCC_US*1.0), req.hdr.avail_us / (DCC_US*1.0)); continue; } memset(&resp, 0, sizeof(resp)); resp.hdr.magic = HELPER_MAGIC_RESP; resp.hdr.version = HELPER_VERSION; resp.hdr.sn = req.hdr.sn; /* do the work and send an answer if we have one */ if (!dnsbl_work(&req, &resp)) continue; /* do not answer if it is too late */ gettimeofday(&now, 0); i = tv_diff2us(&now, &req.hdr.start); if (i > (req.hdr.avail_us + DCC_US/2)) { if (helper.debug > 1) dcc_trace_msg("%s DNSBL helper" " too late to answer;" " used %.1f of %.1f seconds", req.hdr.id, i / (DCC_US*1.0), req.hdr.avail_us / (DCC_US*1.0)); continue; } i = sendto(helper.soc, &resp, sizeof(resp), 0, &req_su.sa, DCC_SU_LEN(&req_su)); if (i != sizeof(resp)) { if (i < 0) dcc_error_msg("%s helper sendto(%s): %s", req.hdr.id, dcc_su2str_err(&req_su), ERROR_STR()); else dcc_error_msg("%s helper sendto(%s)=%d", req.hdr.id, dcc_su2str_err(&req_su), i); } } }