/* * stdin_read * Description: standard read * INPUTS: int32_t fd -- file descriptor void* buf -- buffer address int32_t nbytes -- number of bytes pcb_t* mypcb -- Process control block * OUTPUTS: None * RETURN: None * SIDE EFFECTS: None */ extern int32_t stdin_read(int32_t fd, void* buf, int32_t nbytes, pcb_t* mypcb) { if (fd == 0) { int i; while(1) { if (check_signal((uint32_t)mypcb)){ return EPENDSIG; } if (cur_terminal == kernel_pid[get_cur_pid()].terminal_num) { for (i=0; i<nbytes; i++) { ((int8_t*)buf)[i] = c_buffer[terminal_index].data[i]; if (c_buffer[terminal_index].data[i] == '\0') break; else if (c_buffer[terminal_index].data[i] == '\n') { clear_c_buffer(); return i; } } } } } return -1; }
gboolean g_dbus_send_message(DBusConnection *connection, DBusMessage *message) { dbus_bool_t result = FALSE; if (dbus_message_get_type(message) == DBUS_MESSAGE_TYPE_METHOD_CALL) dbus_message_set_no_reply(message, TRUE); else if (dbus_message_get_type(message) == DBUS_MESSAGE_TYPE_SIGNAL) { const char *path = dbus_message_get_path(message); const char *interface = dbus_message_get_interface(message); const char *name = dbus_message_get_member(message); const GDBusArgInfo *args; if (!check_signal(connection, path, interface, name, &args)) goto out; } /* Flush pending signal to guarantee message order */ g_dbus_flush(connection); result = dbus_connection_send(connection, message, NULL); out: dbus_message_unref(message); return result; }
gboolean g_dbus_emit_signal_valist(DBusConnection *connection, const char *path, const char *interface, const char *name, int type, va_list args) { DBusMessage *signal; dbus_bool_t ret; const GDBusArgInfo *args_info; if (!check_signal(connection, path, interface, name, &args_info)) return FALSE; signal = dbus_message_new_signal(path, interface, name); if (signal == NULL) { error("Unable to allocate new %s.%s signal", interface, name); return FALSE; } ret = dbus_message_append_args_valist(signal, type, args); if (!ret) goto fail; if (g_dbus_args_have_signature(args_info, signal) == FALSE) { error("%s.%s: got unexpected signature '%s'", interface, name, dbus_message_get_signature(signal)); ret = FALSE; goto fail; } return g_dbus_send_message(connection, signal); fail: dbus_message_unref(signal); return ret; }
int father_n_son(char **cmd, char **env, t_duo **env_cpy) { pid_t father; int stat_loc; father = fork(); if (father > 0) { check_signal(3); wait(&stat_loc); } if (father == 0) { check_signal(2); check_fct(cmd, env, env_cpy); ft_putstr("minishell: "); ft_putstr(cmd[0]); ft_putendl(": command not found"); exit(EXIT_FAILURE); } return (0); }
int get_signal(unsigned int listsig){ if(check_signal(listsig,THREAD_SIGKILL)) return THREAD_SIGKILL; if(check_signal(listsig,THREAD_SIGKILL)) return THREAD_SIGSTOP; int i,k = 0; for(i = 1; i < 23; i++){ if(check_signal(listsig,i)){ k = i; if ((k == THREAD_SIGUSR1) || (k == THREAD_SIGUSR2)) // traitement des sig user après les autres k = 0; if (k != 0) return k; } } if(check_signal(listsig,THREAD_SIGUSR1)) return THREAD_SIGUSR1; if(check_signal(listsig,THREAD_SIGUSR2)) return THREAD_SIGUSR2; return 0; }
int main(int argc, char **argv){ misc_init(); argc_ = argc; argv_ = argv; init(menu()); for(uint_ i = 0;i < server_loop_code->code.size();i++){ try{ loop_entry_t *tmp = (loop_entry_t*)find_pointer(server_loop_code->code[i]); throw_if_nullptr(tmp); tmp->settings = 0; }catch(const std::logic_error &e){} } printf("Starting the main loop\n"); while(likely(check_signal(SIGINT) == false && check_signal(SIGKILL) == false && check_signal(SIGTERM) == false)){ loop_run(server_loop_code); once_per_second_update(); if(once_per_second){ server_time->update_timestamp(); // Should I make a new thread for this or is it good enough here w/ hangs? } } close(); last_thing_to_execute(); return 0; }
int main(void) { //系统初始化 //1.GPIO口初始化 port_init(); //2.计时器初始化 timer_init(); //3.串口初始化 ustra_init(); //4.中断初始化,关中断 cli(); //开机显示 cur_state = SYS_START; show_start_image(); //读取工作模式 work_mode = read_work_mode(); //读取时间设置 time_set = read_time_set(work_mode); //开中断,进入过渡状态 cur_state = SYS_INTERIM; time_count = FIVE_MININUTES; stop_work_mode(work_mode); sei(); while(1) { //检查是否有信号来 // 有信号,进入工作模式 if ((uchar)((uchar)(cur_state != SYS_WORK) && ((uchar)check_signal(work_mode)))) { //?不强制类型转化会出错!!!why?!!! cur_state = SYS_WORK; //设置系统当前状态为工作状态 time_count = time_set; //重置时间 start_work_mode(work_mode); //设置系统开始工作 } //无信号,继续检查 } }
int start_execution(t_cmd *cmd, t_42sh *shell, int i) { cmd[i].close_fd = which_one_to_close(cmd, i); if (cmd[i].type == 0) { if (check_and_close_father(cmd, shell, i) == -42) return (-42); } else exec_redir(cmd, i); if (cmd[i].token != NULL && (strcmp(cmd[i].token, "||") == 0 || strcmp(cmd[i].token, "&&") == 0)) waitpid(cmd[i].pid, &cmd[i].status, 0); else if (i > 0 && (strcmp(cmd[i - 1].token, "|") != 0)) waitpid(cmd[i].pid, &cmd[i].status, 0); check_signal(cmd[i].status); return (0); }
/* * stdout_write * Description: write standard output * INPUTS: int32_t fd -- file descriptor void* buf -- buffer address int32_t nbytes -- number of bytes pcb_t* mypcb -- Process control block * OUTPUTS: None * RETURN: None * SIDE EFFECTS: None */ extern int32_t stdout_write(int32_t fd, const void* buf, int32_t nbytes, pcb_t* mypcb) //this function do nothing { if (fd == 1) { int i; uint32_t flag; //int8_t local[2000]; int8_t * local = (int8_t *)r_kmalloc(nbytes+1); //strcpy(local, (int8_t *)buf); memcpy(local, buf, nbytes); local[nbytes] = '\0'; //((int8_t *)buf)[nbytes-1] = '\0'; cli_and_save(flag); //printf("%s", local); if (modeX_enabled == 0) { if (check_signal((uint32_t)mypcb)){ return EPENDSIG; } for (i=0;i<nbytes;i++){ //if (local[i]!='\0') putc(local[i]); } }else { puts(local); } restore_flags(flag); mypcb->file_array[fd].file_position = nbytes; r_kfree((uint32_t)local); return nbytes; } return -1; }
int global_exec(t_cmd *cmd, t_42sh *shell, int tok) { int i; i = 0; shell->tok = tok; while (shell->tok > 0) { global_prepa(cmd, i); prepa_pipes(cmd, i); prepa_semi_col(cmd, i); if (execution(cmd, shell, tok, i) == -42) return (-42); while (cmd[i].token != NULL && cmd[i].token[0] != ';') i++; i++; } check_signal(cmd->status); return (0); }
/* * rtc_read * DESCRITPION: waits for an interrupt to occur * INPUT: none * OUTPUT: none * RETURN: 0 on success * SIDE EFFECT: wait until an interrupt */ int32_t rtc_read(pcb_t* mypcb, uint32_t fd, const uint32_t* buf, uint32_t nbytes){ // reset RTC flag RTC_INT_FLAG = RESET; // printf("RTC Interrupt! \n"); // wait for next interrupt while (RTC_INT_FLAG != SET){ if (check_signal((uint32_t)mypcb)){ return EPENDSIG; } } // printf("----------------RTC Interrupt---------------\n"); // return on success return RET_SUCCESS; }
static dbus_bool_t emit_signal_valist(DBusConnection *conn, const char *path, const char *interface, const char *name, int first, va_list var_args) { DBusMessage *signal; dbus_bool_t ret; const char *signature, *args; if (!check_signal(conn, path, interface, name, &args)) return FALSE; signal = dbus_message_new_signal(path, interface, name); if (signal == NULL) { error("Unable to allocate new %s.%s signal", interface, name); return FALSE; } ret = dbus_message_append_args_valist(signal, first, var_args); if (!ret) goto fail; signature = dbus_message_get_signature(signal); if (strcmp(args, signature) != 0) { error("%s.%s: expected signature'%s' but got '%s'", interface, name, args, signature); ret = FALSE; goto fail; } ret = dbus_connection_send(conn, signal, NULL); fail: dbus_message_unref(signal); return ret; }
int main(int argc, char **argv) { struct protoent *pe; int s; usage(argc); if (!(pe = getprotobyname("TCP"))) return (EXIT_FAILURE); if ((s = _set_from_hostname(argv[1], argv[2], pe)) == -1) { perror("./client"); return (EXIT_FAILURE); } check_signal(s); _handle_server(s); if (user(s, NULL, NULL, NULL)) { my_close(s); return (EXIT_FAILURE); } (void)_loop(s); my_close(s); return (EXIT_SUCCESS); }
void main_loop() /* main loop - get the time to sleep until next job execution, * sleep, and then test all jobs and execute if needed. */ { time_t save; /* time remaining until next save */ time_t stime; /* time to sleep until next job * execution */ #ifdef HAVE_GETTIMEOFDAY struct timeval tv; /* we use usec field to get more precision */ #endif #ifdef FCRONDYN int retcode = 0; #endif debug("Entering main loop"); now = time(NULL); synchronize_dir(".", is_system_startup()); /* synchronize save with jobs execution */ save = now + save_time; if (serial_num > 0 || once) stime = first_sleep; else if ((stime = time_to_sleep(save)) < first_sleep) /* force first execution after first_sleep sec : execution of jobs * during system boot time is not what we want */ stime = first_sleep; debug("initial sleep time : %ld", stime); for (;;) { #ifdef HAVE_GETTIMEOFDAY #ifdef FCRONDYN gettimeofday(&tv, NULL); tv.tv_sec = (stime > 1) ? stime - 1 : 0; /* we set tv_usec to slightly more than necessary so as * we don't wake up too early, in which case we would * have to sleep again for some time */ tv.tv_usec = 1001000 - tv.tv_usec; /* On some systems (BSD, etc), tv_usec cannot be greater than 999999 */ if (tv.tv_usec > 999999) tv.tv_usec = 999999; /* note: read_set is set in socket.c */ if ((retcode = select(set_max_fd + 1, &read_set, NULL, NULL, &tv)) < 0 && errno != EINTR) die_e("select returned %d", errno); #else if (stime > 1) sleep(stime - 1); gettimeofday(&tv, NULL); /* we set tv_usec to slightly more than necessary to avoid * infinite loop */ usleep(1001000 - tv.tv_usec); #endif /* FCRONDYN */ #else sleep(stime); #endif /* HAVE_GETTIMEOFDAY */ now = time(NULL); check_signal(); debug("\n"); test_jobs(); while (serial_num > 0 && serial_running < serial_max_running) run_serial_job(); if (once) { explain("Running with option once : exiting ... "); xexit(EXIT_OK); } if (save <= now) { save = now + save_time; /* save all files */ save_file(NULL); } #ifdef FCRONDYN /* check if there's a new connection, a new command to answer, etc ... */ /* we do that *after* other checks, to avoid Denial Of Service attacks */ check_socket(retcode); #endif stime = check_lavg(save); debug("next sleep time : %ld", stime); check_signal(); } }
bool infinite_loop(){ return unlikely(check_signal(SIGNAL_QUIT_LOOP) == false); }
static int connect_socket(int *sv, int *sk) { int v,k; int i; /* create socket */ for(i = 5; i > 0; i--){ v = lm_create_server_socket(); if(v >= 0) break; /* SUCCESS */ else{ if(check_signal() == -1){ #ifdef DEBUG write_log("socket create error(signal detected)\n"); #endif break; } } #ifdef DEBUG write_log("socket create error(no signal and retry)\n"); #endif } if(v < 0){ /* create error */ *sv = -1; *sk = -1; return -1; } *sv = v; /* connect wait */ for(i = 5; i > 0; i--){ #ifdef DEBUG write_log("start accept (LM main)\n"); #endif k = lm_wait_client_connect(v); if(k >= 0) break; /* SUCCESS */ else{ if(check_signal() == -1){ #ifdef DEBUG write_log("socket connect error(signal detected)\n"); #endif break; } } #ifdef DEBUG write_log("socket connect error(no signal and retry)\n"); #endif } if(k < 0){ /* connect error */ *sk = -1; return -1; } *sk = k; return 0; }
extern int evt_wait (int *p_fd, boolean *p_read, timeout_t *timeout) { fd_set select_read_mask, select_write_mask; timeout_t exp_time, *timeout_ptr; boolean timeout_is_active; int start_fd; int n; ssize_t size; char c; /* Activate signal handling if necessary*/ activate_signal_handling (); /* Compute exp_time = cur_time + timeout_ms */ timeout_is_active = (timeout->tv_sec >= 0) && (timeout->tv_usec >= 0); if (timeout_is_active) { get_time (&exp_time); add_time (&exp_time, timeout); timeout_ptr = timeout; } else { timeout_ptr = NULL; } /* Init wake-up pipe */ init_sig_and_wake_up (); for (;;) { /* Check for signal */ if (check_signal() ) { *p_fd = SIG_EVENT; evt_time_remaining (timeout, &exp_time); return (WAIT_OK); } /* Copy select mask */ memcpy (&select_read_mask, &global_read_mask, sizeof(fd_set)); memcpy (&select_write_mask, &global_write_mask, sizeof(fd_set)); /* Default result */ *p_fd = NO_EVENT; *p_read = TRUE; /* Compute select timeout */ if (timeout_is_active) { evt_time_remaining (timeout, &exp_time); } /* The select */ n = select (last_fd + 1, &select_read_mask, &select_write_mask, NULL, timeout_ptr); if (n > 0) { /* Start from 0 or from prev fd + 1 (round robin) */ if (n == 1) { start_fd = 0; } else { start_fd = (prev_fd + 1) % (last_fd + 1); } /* Check read events first */ *p_fd = check_fd (start_fd, &select_read_mask); if (*p_fd != NO_EVENT) { *p_read = TRUE; } else { /* Check write events second */ *p_read = FALSE; *p_fd = check_fd (start_fd, &select_write_mask); } /* Check if p_fd is wake-up fd) */ if (*p_fd == wake_up_fds[0] ) { for (;;) { size = read (wake_up_fds[0], &c, sizeof(c)); if ( (size == -1) && (errno != EINTR) ) { #ifdef DEBUG perror ("read"); #endif break; } if (size == 1) { break; } } *p_fd = WAKE_EVENT; } else if (*p_fd == NO_EVENT) { #ifdef DEBUG fprintf (stderr, "No fd found\n"); #endif return (WAIT_ERR); } prev_fd = *p_fd; if (prev_fd < -1) { /* Not a fd => end of round robin */ prev_fd = -1; } evt_time_remaining (timeout, &exp_time); return (WAIT_OK); } else if (n < 0) { if (errno != EINTR) { /* Real error */ #ifdef DEBUG perror ("select"); #endif return (WAIT_ERR); } } /* Check for timeout reached */ if ( (!check_signal()) && timeout_is_active && time_is_reached (&exp_time) ) { /* Done on timeout */ *p_fd = NO_EVENT; timeout->tv_sec = 0; timeout->tv_usec = 0; return (WAIT_OK); } } /* for (;;) */ }
static void *copy_thread_no_hashmap(void *_me) { struct worker_thread *me = _me; while (1) { uint8_t buf[block_size]; uint8_t hash[hash_size]; off_t off; int ret; xsem_wait(&me->sem0); off = fd_off; if (off == sizeblocks) { xsem_post(&me->next->sem0); break; } if (check_signal()) { fd_off = sizeblocks; xsem_post(&me->next->sem0); break; } fd_off++; posix_fadvise(fd_src, off * block_size, 4 * block_size, POSIX_FADV_WILLNEED); ret = xpread(fd_src, buf, block_size, off * block_size); xsem_post(&me->next->sem0); if (ret < block_size && off != sizeblocks - 1) { fprintf(stderr, "short read\n"); break; } gcry_md_hash_buffer(hash_algo, hash, buf, ret); xsem_wait(&me->sem1); if (memcmp(dsthashmap + off * hash_size, hash, hash_size)) { xpwrite(fd_dst, buf, ret, off * block_size); xpwrite(fd_dsthashmap, hash, hash_size, off * hash_size); memcpy(dsthashmap + off * hash_size, hash, hash_size); fprintf(stderr, "%Ld ", (long long)off); progress_reported(); again = 1; } else if (should_report_progress()) { char str[256]; ret = sprintf(str, "%Ld/%Ld", (long long)off, (long long)sizeblocks); memset(str + ret, '\b', ret); str[2 * ret] = 0; fputs(str, stderr); } xsem_post(&me->next->sem1); } return NULL; }
static void *copy_thread_hashmap(void *_me) { struct worker_thread *me = _me; while (1) { uint8_t buf[block_size]; uint8_t hash[hash_size]; off_t off; int ret; xsem_wait(&me->sem0); for (off = fd_off; off < sizeblocks; off++) { if (memcmp(srchashmap + off * hash_size, dsthashmap + off * hash_size, hash_size)) { break; } } if (off == sizeblocks || check_signal()) { fd_off = sizeblocks; xsem_post(&me->next->sem0); break; } if (should_report_progress()) { char str[256]; int ret; ret = sprintf(str, "%Ld/%Ld (%Ld/%Ld mismatches)", (long long)off, (long long)sizeblocks, (long long)mismatch_idx, (long long)mismatch_cnt); memset(str + ret, '\b', ret); str[2 * ret] = 0; fputs(str, stderr); } ret = xpread(fd_src, buf, block_size, off * block_size); fd_off = off + 1; mismatch_idx++; xsem_post(&me->next->sem0); if (ret < block_size && off != sizeblocks - 1) { fprintf(stderr, "short read\n"); break; } gcry_md_hash_buffer(hash_algo, hash, buf, ret); if (memcmp(hash, srchashmap + off * hash_size, hash_size)) { fprintf(stderr, "warning: source image inconsistent " "with its hashmap at block %Ld\n", (long long)off); } xsem_wait(&me->sem1); xpwrite(fd_dst, buf, ret, off * block_size); memcpy(dsthashmap + off * hash_size, hash, hash_size); xpwrite(fd_dsthashmap, hash, hash_size, off * hash_size); xsem_post(&me->next->sem1); } return NULL; }