void signal_handler(int sig) { if(sig==SIGUSR1) { open_door(1); } else if(sig==SIGHUP) { clear_config(); read_config(); } else if(sig==SIGINT) { printf("Got SIGINT! Exiting..."); clear_config(); exit(0); } }
/* * This function is called to get the value of the failure_action * tunable stored in /etc/libaudit.conf. The function returns 1 if * the tunable is not found or there is an error. If the tunable is found, * 0 is returned the the tunable value is saved in the failmode parameter. */ int get_auditfail_action(auditfail_t *failmode) { clear_config(); if (load_libaudit_config(CONFIG_FILE)) { *failmode = config.failure_action; return 1; } *failmode = config.failure_action; return 0; }
void PREFAST_NORETURN my_exit( int status ) { fflush( stdout ); fflush( stderr ); if ( ! status ) { clear_config(); } exit( status ); }
/* * Important: The below generated source_foo.o and deps_foo.o variable * assignments are parsed not only by make, but also by the rather simple * parser in scripts/mod/sumversion.c. */ static void parse_dep_file(void *map, size_t len) { char *m = map; char *end = m + len; char *p; char s[PATH_MAX]; int first; p = strchr(m, ':'); if (!p) { fprintf(stderr, "fixdep: parse error\n"); exit(1); } memcpy(s, m, p-m); s[p-m] = 0; m = p+1; clear_config(); first = 1; while (m < end) { while (m < end && (*m == ' ' || *m == '\\' || *m == '\n')) m++; p = m; while (p < end && *p != ' ') p++; if (p == end) { do p--; while (!isalnum(*p)); p++; } memcpy(s, m, p-m); s[p-m] = 0; if (strrcmp(s, "include/generated/autoconf.h") && strrcmp(s, "arch/um/include/uml-config.h") && strrcmp(s, "include/linux/kconfig.h") && strrcmp(s, ".ver")) { /* * Do not list the source file as dependency, so that * kbuild is not confused if a .c file is rewritten * into .S or vice versa. Storing it in source_* is * needed for modpost to compute srcversions. */ if (first) { printf("source_%s := %s\n\n", target, s); printf("deps_%s := \\\n", target); } else printf(" %s \\\n", s); do_config_file(s); } first = 0; m = p + 1; } printf("\n%s: $(deps_%s)\n\n", target, target); printf("$(deps_%s):\n", target); }
int main(int count, char **options) { int res; if (strcmp(options[1], "-d") != 0) { res = daemon(0, 0); printf("return value: %s\n", res); } res_init(); _res.retrans = 4; _res.retry = 2; int running = 1; if (parse_config()) { printf("error reading configuration!\n"); return 1; } if (open_status_socket()) printf("error opening status socket; no status will be provided\n"); stat(config_file, &config_last_mod); printf("last config modified time: %s\n", ctime(&config_last_mod.st_mtime)); while (running) { struct config_interfaces *cur = config; printf("checking if conf file has changed\n"); if (config_changed()) { printf("modifying:\n"); clear_config(config); cur = 0; if (parse_config()) printf("error reading configuration!\n"); else cur = config; } while (cur) { if (check_interface(cur)) { printf("media type: %s\n", mediatype(cur->if_name)); if (strcmp(mediatype(cur->if_name), "Ethernet") == 0) { if (setup_ethernetinterface(cur)) break; } else if (strcmp(mediatype(cur->if_name), "IEEE802.11") == 0) { if (setup_wlaninterface(cur)) break; } } cur = cur->next; } printf("Sleeping... waiting %d seconds\n", poll_wait); sleep(poll_wait); printf("restarto\n"); } return 0; }
/* * Generate dependencies for one file. */ void do_depend(const char * filename, const char * command) { int mapsize; int pagesizem1 = getpagesize()-1; int fd; struct stat st; char * map; fd = open(filename, O_RDONLY); if (fd < 0) { perror(filename); return; } fstat(fd, &st); if (st.st_size == 0) { fprintf(stderr,"%s is empty\n",filename); close(fd); return; } mapsize = st.st_size; mapsize = (mapsize+pagesizem1) & ~pagesizem1; map = mmap(NULL, mapsize, PROT_READ, MAP_PRIVATE, fd, 0); if ((long) map == -1) { perror("mkdep: mmap"); close(fd); return; } if ((unsigned long) map % sizeof(unsigned long) != 0) { fprintf(stderr, "do_depend: map not aligned\n"); exit(1); } hasdep = 0; clear_config(); state_machine(map, map+st.st_size); if (hasdep) { puts(command); if (*command) define_precious(filename); } munmap(map, mapsize); close(fd); }
//****************************************************************** // configuration //****************************************************************** int cliNoRouterOspfCmd(CliMode mode, int argc, char **argv) { struct tms tm; uint32_t tic1 = times(&tm); char *data = (char *) pktout + sizeof(RcpPkt); *data = '\0'; // clear all configuration clear_config(); // clear areas clear_areas(); // remove areas remove_areas(); // clear routes clear_routes(); // remove summary addresses memset(shm->config.ospf_sum_addr, 0, sizeof(RcpOspfSummaryAddr) * RCP_OSPF_SUMMARY_ADDR_LIMIT); shm->config.ospf_discard_external = 1; // range memset(shm->config.ospf_range, 0, sizeof(RcpOspfRange) * RCP_OSPF_RANGE_LIMIT); shm->config.ospf_discard_internal = 1; // remove all external lsa clear_external(); uint32_t tic2 = times(&tm); uint32_t delta; if (tic2 > tic1) delta = tic2 - tic1; else delta = tic1 - tic2; if (delta > systic_delta_operation) { systic_delta_operation = delta; rcpDebug("operation timeout delta %u\n", systic_delta_operation); } return 0; }
void parse_dep_file(void *map, size_t len) { char *m = map; char *end = m + len; char *p; char s[PATH_MAX]; p = strchr(m, ':'); if (!p) { fprintf(stderr, "fixdep: parse error\n"); exit(1); } memcpy(s, m, p-m); s[p-m] = 0; printf("deps_%s := \\\n", target); m = p+1; clear_config(); while (m < end) { while (m < end && (*m == ' ' || *m == '\\' || *m == '\n')) m++; p = m; while (p < end && *p != ' ') p++; if (p == end) { do p--; while (!isalnum(*p)); p++; } memcpy(s, m, p-m); s[p-m] = 0; if (strrcmp(s, "include/linux/autoconf.h") && strrcmp(s, "arch/um/include/uml-config.h") && strrcmp(s, ".ver")) { printf(" %s \\\n", s); do_config_file(s); } m = p + 1; } printf("\n%s: $(deps_%s)\n\n", target, target); printf("$(deps_%s):\n", target); }
int cec_init(int init_video) { int res; /* Set the CEC configuration */ clear_config(&cec_config); snprintf(cec_config.strDeviceName, 13, "pidvbip"); cec_config.clientVersion = CEC_CONFIG_VERSION; cec_config.bActivateSource = 0; /* Say we are a recording/tuner/playback device */ cec_config.deviceTypes.types[0] = CEC_DEVICE_TYPE_RECORDING_DEVICE; /* Set the callbacks */ clear_callbacks(&cec_callbacks); cec_callbacks.CBCecLogMessage = &CecLogMessage; cec_callbacks.CBCecKeyPress = &CecKeyPress; cec_callbacks.CBCecCommand = &CecCommand; cec_callbacks.CBCecAlert = &CecAlert; cec_callbacks.CBCecSourceActivated= &CecSourceActivated; cec_config.callbacks = &cec_callbacks; /* Initialise the library */ if (!cec_initialise(&cec_config)) { fprintf(stderr,"Error initialising libcec, aborting\n"); return 1; } if (init_video) { /* init video on targets that need this */ cec_init_video_standalone(); } /* Locate CEC device */ cec_adapter devices[10]; int nadapters = cec_find_adapters(devices, 10, NULL); if (nadapters <= 0) { fprintf(stderr,"Error, no CEC adapters found.\n"); cec_destroy(); return 2; } if (nadapters > 1) { fprintf(stderr,"WARNING: %d adapters found, using first.\n",nadapters); } fprintf(stderr,"Using CEC adapter \"%s\", path=\"%s\"\n",devices[0].comm,devices[0].path); /* Open device with a 10000ms (10s) timeout */ if (!cec_open(devices[0].comm, CEC_DEFAULT_CONNECT_TIMEOUT)) { fprintf(stderr,"Error, cannot open device %s\n",devices[0].comm); cec_destroy(); return 3; } /* Enable callbacks, first parameter is the callback data passed to every callback */ cec_enable_callbacks(NULL, &cec_callbacks); /* Get the menu language of the TV */ cec_menu_language language; cec_get_device_menu_language(CEC_DEFAULT_BASE_DEVICE, &language); fprintf(stderr,"TV menu language: \"%c%c%c\"\n",language.language[0],language.language[1],language.language[2]); /* Get the power status of the TV */ cec_power_status power_status = cec_get_device_power_status(CEC_DEFAULT_BASE_DEVICE); fprintf(stderr,"TV Power Status: %d\n",power_status); /* Select ourselves as the source - this will also power-on the TV if needed */ fprintf(stderr,"Setting ourselves as the source\n"); cec_set_active_source(CEC_DEVICE_TYPE_RECORDING_DEVICE); /* Clear the keypress queue */ key_queue.numkeys = 0; pthread_mutex_init(&key_queue.mutex,NULL); return 0; }
/* * Important: The below generated source_foo.o and deps_foo.o variable * assignments are parsed not only by make, but also by the rather simple * parser in scripts/mod/sumversion.c. */ static void parse_dep_file(void *map, size_t len) { char *m = map; char *end = m + len; char *p; char s[PATH_MAX]; int is_target; int saw_any_target = 0; int is_first_dep = 0; clear_config(); while (m < end) { /* Skip any "white space" */ while (m < end && (*m == ' ' || *m == '\\' || *m == '\n')) m++; /* Find next "white space" */ p = m; while (p < end && *p != ' ' && *p != '\\' && *p != '\n') p++; /* Is the token we found a target name? */ is_target = (*(p-1) == ':'); /* Don't write any target names into the dependency file */ if (is_target) { /* The /next/ file is the first dependency */ is_first_dep = 1; } else { /* Save this token/filename */ memcpy(s, m, p-m); s[p - m] = 0; /* Ignore certain dependencies */ if (strrcmp(s, "include/generated/autoconf.h") && strrcmp(s, "arch/um/include/uml-config.h") && strrcmp(s, "include/linux/kconfig.h") && strrcmp(s, ".ver")) { /* * Do not list the source file as dependency, * so that kbuild is not confused if a .c file * is rewritten into .S or vice versa. Storing * it in source_* is needed for modpost to * compute srcversions. */ if (is_first_dep) { /* * If processing the concatenation of * multiple dependency files, only * process the first target name, which * will be the original source name, * and ignore any other target names, * which will be intermediate temporary * files. */ if (!saw_any_target) { saw_any_target = 1; printf("source_%s := %s\n\n", target, s); printf("deps_%s := \\\n", target); } is_first_dep = 0; } else printf(" %s \\\n", s); do_config_file(s); } } /* * Start searching for next token immediately after the first * "whitespace" character that follows this token. */ m = p + 1; } if (!saw_any_target) { fprintf(stderr, "fixdep: parse error; no targets found\n"); exit(1); } printf("\n%s: $(deps_%s)\n\n", target, target); printf("$(deps_%s):\n", target); }
static int process_logs(void) { struct daemon_conf config; char *filename; int len, num = 0; if (user_file && userfile_is_dir) { char dirname[MAXPATHLEN]; clear_config (&config); strcpy(dirname, user_file); if (dirname[strlen(dirname)-1] != '/') strcat(dirname, "/"); strcat (dirname, "audit.log"); free((void *)config.log_file); config.log_file=strdup(dirname); fprintf(stderr, "NOTE - using logs in %s\n", config.log_file); } else { /* Load config so we know where logs are */ if (load_config(&config, TEST_SEARCH)) fprintf(stderr, "NOTE - using built-in logs: %s\n", config.log_file); } /* for each file */ len = strlen(config.log_file) + 16; filename = malloc(len); if (!filename) { fprintf(stderr, "No memory\n"); free_config(&config); return 1; } /* Find oldest log file */ snprintf(filename, len, "%s", config.log_file); do { if (access(filename, R_OK) != 0) break; // FIXME: do a time check and put them on linked list for later num++; snprintf(filename, len, "%s.%d", config.log_file, num); } while (1); num--; /* * We note how many files we need to process */ files_to_process = num; /* Got it, now process logs from last to first */ if (num > 0) snprintf(filename, len, "%s.%d", config.log_file, num); else snprintf(filename, len, "%s", config.log_file); do { int ret; if ((ret = process_file(filename))) { free(filename); free_config(&config); return ret; } /* Get next log file */ files_to_process--; /* one less file to process */ num--; if (num > 0) snprintf(filename, len, "%s.%d", config.log_file, num); else if (num == 0) snprintf(filename, len, "%s", config.log_file); else break; } while (1); free(filename); free_config(&config); return 0; }
int do_reload_config (int create_conn) { int res; need_reload_config = 0; fd[0] = open (config_filename, O_RDONLY); if (fd[0] < 0) { fprintf (stderr, "cannot re-read config file %s: %m\n", config_filename); return -1; } res = kdb_load_hosts (); if (res > 0 && verbosity > 0) { fprintf (stderr, "/etc/hosts changed, reloaded\n"); } res = parse_config (NextConf, CurConf, 0); close (fd[0]); // clear_config (NextConf); if (res < 0) { vkprintf (0, "error while re-reading config file %s, new configuration NOT applied\n", config_filename); return res; } res = try_open_new_listening_sockets (NextConf); if (res < 0) { vkprintf (0, "error while re-reading config file %s, new configuration NOT applied: cannot open listening ports\n", config_filename); return res; } res = parse_config (NextConf, CurConf, 1); if (res < 0) { clear_config (NextConf, 0); vkprintf (0, "fatal error while re-reading config file %s\n", config_filename); exit (-res); } if (create_conn) { transfer_listening_sockets (NextConf, CurConf); } struct mc_config *tmp = CurConf; CurConf = NextConf; NextConf = tmp; clear_config (NextConf, 1); if (create_conn) { create_all_outbound_connections (); } CurConf->config_loaded_at = now ? now : time (0); CurConf->config_bytes = config_bytes; CurConf->config_md5_hex = zmalloc (33); md5_hex (config_buff, config_bytes, CurConf->config_md5_hex); CurConf->config_md5_hex[32] = 0; vkprintf (0, "configuration file %s re-read successfully, new configuration active\n", config_filename); return 0; }
int load_config(remote_conf_t *config, const char *file) { int fd, rc, mode, lineno = 1; struct stat st; FILE *f; char buf[128]; clear_config(config); /* open the file */ mode = O_RDONLY; rc = open(file, mode); if (rc < 0) { if (errno != ENOENT) { syslog(LOG_ERR, "Error opening %s (%s)", file, strerror(errno)); return 1; } syslog(LOG_WARNING, "Config file %s doesn't exist, skipping", file); return 0; } fd = rc; /* check the file's permissions: owned by root, not world writable, * not symlink. */ if (fstat(fd, &st) < 0) { syslog(LOG_ERR, "Error fstat'ing config file (%s)", strerror(errno)); close(fd); return 1; } if (st.st_uid != 0) { syslog(LOG_ERR, "Error - %s isn't owned by root", file); close(fd); return 1; } if ((st.st_mode & S_IWOTH) == S_IWOTH) { syslog(LOG_ERR, "Error - %s is world writable", file); close(fd); return 1; } if (!S_ISREG(st.st_mode)) { syslog(LOG_ERR, "Error - %s is not a regular file", file); close(fd); return 1; } /* it's ok, read line by line */ f = fdopen(fd, "r"); if (f == NULL) { syslog(LOG_ERR, "Error - fdopen failed (%s)", strerror(errno)); close(fd); return 1; } while (get_line(f, buf)) { // convert line into name-value pair const struct kw_pair *kw; struct nv_pair nv; rc = nv_split(buf, &nv); switch (rc) { case 0: // fine break; case 1: // not the right number of tokens. syslog(LOG_ERR, "Wrong number of arguments for line %d in %s", lineno, file); break; case 2: // no '=' sign syslog(LOG_ERR, "Missing equal sign for line %d in %s", lineno, file); break; default: // something else went wrong... syslog(LOG_ERR, "Unknown error for line %d in %s", lineno, file); break; } if (nv.name == NULL) { lineno++; continue; } if (nv.value == NULL) { fclose(f); return 1; } /* identify keyword or error */ kw = kw_lookup(nv.name); if (kw->name == NULL) { syslog(LOG_ERR, "Unknown keyword \"%s\" in line %d of %s", nv.name, lineno, file); fclose(f); return 1; } /* Check number of options */ if (kw->max_options == 0 && nv.option != NULL) { syslog(LOG_ERR, "Keyword \"%s\" has invalid option " "\"%s\" in line %d of %s", nv.name, nv.option, lineno, file); fclose(f); return 1; } /* dispatch to keyword's local parser */ rc = kw->parser(&nv, lineno, config); if (rc != 0) { fclose(f); return 1; // local parser puts message out } lineno++; } fclose(f); if (lineno > 1) return sanity_check(config, file); return 0; }