int read_calibration_from_file(const char *calibration_file, struct calibration_data *accel, struct calibration_data *magn, struct calibration_data *gyro, double *magnetic_declination_mrad) { #define STR_BUFFER_SIZE 128 int ret = 0; FILE *stream; int len; char buffer[STR_BUFFER_SIZE]; stream = fopen(calibration_file, "r"); if (stream == NULL) { ret = -errno; fprintf(stderr, "Error: cannot open %s\n", calibration_file); return ret; } while (fgets(buffer, sizeof(buffer), stream) != NULL) { len = strlen(buffer); // strip trailing '\n' if it exists if (buffer[len-1] == '\n') { buffer[len-1] = 0; len--; } else { // line is longer than our buffer, skip to the next line continue; } if (buffer[0] != '#') { // find the '=' sign char *equal = strstr(buffer, "="); if (equal) { char *key = buffer; char *value = equal+1; *equal = 0; consume_white_space(&key); process_key_value(key, value, accel, magn, gyro, magnetic_declination_mrad); } } } fclose(stream); return ret; }
int fs_config_read_file(const char *path, int force) { if (!g_initialized) { initialize(); } fs_log("\n"); fs_log(LOG_LINE); fs_log("config (%s)\n", path); fs_log(LOG_LINE); fs_log("\n"); // FIXME: support checking a config key "end_config", which causes // later calls to fs_config_read_config_file to be ignored if (!force && fs_config_get_boolean("end_config") == 1) { fs_log("end_config is set, ignoring this config file\n"); return 1; } if (!fs_path_is_file(path)) { fs_log("config file %s does not exist\n", path); return 0; } fs_ini_file *ini_file = fs_ini_file_open(path); if (ini_file == NULL) { fs_log("error loading config file\n"); return 0; } char **groups = fs_ini_file_get_groups(ini_file, NULL); for (char **group = groups; *group; group++) { const char *prefix = ""; if (strcmp(*group, "theme") == 0) { prefix = "theme_"; } char **keys = fs_ini_file_get_keys(ini_file, *group, NULL); for (char **key = keys; *key; key++) { char *value = fs_ini_file_get_value(ini_file, *group, *key); if (value) { char *key2 = g_strconcat(prefix, *key, NULL); process_key_value(key2, value, 0); g_free(key2); } } g_strfreev(keys); } g_strfreev(groups); fs_ini_file_destroy(ini_file); return 1; }
/** * Helper function. Reads up to BUFFER_SIZE from a file descriptor into a * buffer and calls process_key_value() when for each and every key-value * pair that is read from the file descriptor. * * Each key-value must be in a "Key: Value" format, identical to MP1, and * each pair must be terminated by a newline ('\n'). *sorter * Each unique file descriptor must have a unisorterque buffer and the buffer * must be of size (BUFFER_SIZE + 1). Therefore, if you have two * unique file descriptors, you must have two buffers that each have * been malloc()'d to size (BUFFER_SIZE + 1). * * Note that read_from_fd() makes a read() call and will block if the * fd does not have data ready to be read. This function is complete * and does not need to be modified as part of this MP. * * @param fd * File descriptor to read from.sorter * @param buffer * A unique buffer associated with the fd. This buffer may have * a partial key-value pair between calls to read_from_fd() and * must not be modified outside the context of read_from_fd(). * @param mr * Pass-through mapreduce_t structure (to process_key_value()). * * @retval 1 * Data was available and was read successfully. * @retval 0 * The file descriptor fd has been closed, no more data to read. * @retval -1 * The call to read() produced an error. */ static int read_from_fd(int fd, char *buffer, mapreduce_t *mr) { /* Find the end of the string. */ int offset = strlen(buffer); /* Read bytes from the underlying stream. */ int bytes_read = read(fd, buffer + offset, BUFFER_SIZE - offset); if (bytes_read == 0) return 0; else if(bytes_read < 0) { fprintf(stderr, "error in read.\n"); return -1; } buffer[offset + bytes_read] = '\0'; /* Loop through each "key: value\n" line from the fd. */ char *line; while ((line = strstr(buffer, "\n")) != NULL) { *line = '\0'; /* Find the key/value split. */ char *split = strstr(buffer, ": "); if (split == NULL) continue; /* Allocate and assign memory */ char *key = malloc((split - buffer + 1) * sizeof(char)); char *value = malloc((strlen(split) - 2 + 1) * sizeof(char)); strncpy(key, buffer, split - buffer); key[split - buffer] = '\0'; strcpy(value, split + 2); /* Process the key/value. */ process_key_value(key, value, mr); /* Shift the contents of the buffer to remove the space used by the processed line. */ memmove(buffer, line + 1, BUFFER_SIZE - ((line + 1) - buffer)); buffer[BUFFER_SIZE - ((line + 1) - buffer)] = '\0'; } return 1; }
void fs_config_parse_options(int argc, char **argv) { if (!g_initialized) { initialize(); } int first = 1; for (int i = 0; i < argc; i++) { char *arg = argv[i]; if (!g_str_has_prefix(arg, "--")) { continue; } char *key = arg + 2; char *value = strchr(arg, '='); char *k, *v; if (value) { k = g_strndup(key, value - key); v = g_strdup(value + 1); } else { if (g_str_has_prefix(key, "no-")) { k = g_strdup(key + 3); v = g_strdup("0"); } else { k = g_strdup(key); v = g_strdup("1"); } } //if (value) { if (first) { fs_log("\n"); fs_log(LOG_LINE); fs_log("config (command line arguments)\n"); fs_log(LOG_LINE); fs_log("\n"); first = 0; } process_key_value(k, v, 0); g_free(k); // v is owned by process_key_file, do not free here } }
void fs_config_set_string(const char *key, const char *value) { process_key_value(key, g_strdup(value), 1); }
static int parse_config_file(shadowvpn_args_t *args, const char *filename) { char buf[512]; char *line; FILE *fp; size_t len = sizeof(buf); int lineno = 0; fp = fopen(filename, "rb"); if (fp == NULL) { err("fopen"); errf("Can't open config file: %s", filename); return -1; } while ((line = fgets(buf, len, fp))) { char *sp_pos; lineno++; sp_pos = strchr(line, '\r'); if (sp_pos) *sp_pos = '\n'; sp_pos = strchr(line, '\n'); if (sp_pos) { *sp_pos = 0; } else { errf("line %d too long in %s", lineno, filename); return -1; } if (*line == 0 || *line == '#') continue; sp_pos = strchr(line, '='); if (!sp_pos) { errf("%s:%d: \"=\" is not found in this line: %s", filename, lineno, line); return -1; } *sp_pos = 0; sp_pos++; // line points to key and sp_pos points to value if (0 != process_key_value(args, line, sp_pos)) return 1; } // check if every required arg is set if (!args->mode) { errf("mode not set in config file"); return -1; } if (!args->server) { errf("server not set in config file"); return -1; } if (!args->port) { errf("port not set in config file"); return -1; } if (!args->password) { errf("password not set in config file"); return -1; } #ifdef TARGET_WIN32 if (!args->tun_ip) { errf("tunip not set in config file"); return -1; } #endif return 0; }
int main(void) { int i; char inbuf[80]; char *key, *value; int status; employee temporary_record; int week; int blank_line = 1; int query = 0; // Store of all employee data employee employee_list[NUMBER_OF_EMPLOYEES]; for( i=0; i<NUMBER_OF_EMPLOYEES; i++) { initialize_employee(&employee_list[i]); } initialize_employee(&temporary_record); week = 0; // Process input and respond to queries until a blank line is received while(1) { // Read input from network in the form of key-value pairs status = get_key_value((char *)&inbuf, sizeof(inbuf), &key, &value); switch (status) { case READ_ERROR: print("ERROR: on receive\n"); _terminate(1); break; case NEWLINE_RECEIVED: // Process the input line by merging the temporary record with the global record if (blank_line == 1) { print("Exiting\n"); _terminate(0); } if (query > 0) { process_query(query, (employee *)&employee_list, &temporary_record, week); } else if ((temporary_record.id >= 0) && (temporary_record.id < NUMBER_OF_EMPLOYEES)) { merge_employee_records(&employee_list[temporary_record.id], &temporary_record); } // Get ready to process a new line initialize_employee(&temporary_record); week = 0; blank_line = 1; query = 0; break; case KEY_VALUE_RECEIVED: // If this is a query line remember it for processing later if ((blank_line == 1) && (equals(key, "query"))) { if (equals(value, "all")) query = QUERY_ALL; else if (equals(value, "one")) query = QUERY_ONE; else if (equals(value, "week")) query = QUERY_WEEK; else if (equals(value, "week_all")) query = QUERY_WEEK_ALL; else query = 0; } blank_line = 0; // Add the key_value information to a temporary record process_key_value(&temporary_record, key, value, &week); break; case OTHER_INPUT_RECEIVED: default: print("ERROR: invalid input\n"); _terminate(1); break; } } }
int main(int argc, char **argv) { int rc = 0; bootenv_t env = NULL; uint32_t boot_volno; myargs args = { .action = ACT_NORMAL, .file_in = NULL, .file_out = NULL, .side = -1, .x86 = 0, .both = 0, .env_in = NULL, .arg1 = NULL, .options = NULL, }; rc = bootenv_create(&env); if (rc != 0) { err_msg("Cannot create bootenv handle. rc: %d", rc); goto err; } rc = bootenv_create(&(args.env_in)); if (rc != 0) { err_msg("Cannot create bootenv handle. rc: %d", rc); goto err; } parse_opt(argc, argv, &args); if (args.action == ACT_ARGP_ERR) { rc = -1; goto err; } if (args.action == ACT_ARGP_ABORT) { rc = 0; goto out; } if ((args.side == 0) || (args.side == -1)) boot_volno = EXAMPLE_BOOTENV_VOL_ID_1; else boot_volno = EXAMPLE_BOOTENV_VOL_ID_2; if( args.x86 ) rc = read_bootenv(args.file_in, env); else rc = ubi_read_bootenv(EXAMPLE_UBI_DEVICE, boot_volno, env); if (rc != 0) { goto err; } if (args.action == ACT_LIST) { rc = list_bootenv(env); if (rc != 0) { goto err; } goto out; } rc = process_key_value(args.env_in, env); if (rc != 0) { goto err; } if( args.x86 ) rc = write_bootenv(args.file_in, env); else rc = ubi_write_bootenv(EXAMPLE_UBI_DEVICE, boot_volno, env); if (rc != 0) goto err; if( args.both ) /* No side specified, update both */ rc = do_mirror(boot_volno); out: err: bootenv_destroy(&env); bootenv_destroy(&(args.env_in)); return rc; }