void journal_read(const char *path, GQueue *queue) { FILE *file; char line[1024]; struct record record; journal_file_empty = true; file = fopen(path, "r"); if (file == NULL) { if (errno != ENOENT) /* ENOENT is ignored silently, because the * user might be starting mpdcron for the * first time */ g_warning("Failed to load %s: %s", path, g_strerror(errno)); return; } record_clear(&record); while (fgets(line, sizeof(line), file) != NULL) { char *key, *value; key = g_strchug(line); if (*key == 0 || *key == '#') continue; value = strchr(key, '='); if (value == NULL || value == key) continue; *value++ = 0; key = g_strchomp(key); value = g_strstrip(value); if (!strcmp("a", key)) { journal_commit_record(queue, &record); record.artist = g_strdup(value); } else if (!strcmp("t", key)) record.track = g_strdup(value); else if (!strcmp("b", key)) record.album = g_strdup(value); else if (!strcmp("n", key)) record.number = g_strdup(value); else if (!strcmp("m", key)) record.mbid = g_strdup(value); else if (!strcmp("i", key)) record.time = parse_timestamp(value); else if (!strcmp("l", key)) record.length = atoi(value); else if (strcmp("o", key) == 0 && value[0] == 'R') record.source = "R"; } fclose(file); journal_commit_record(queue, &record); }
void library_clear(struct library *li) { int n; /* This object is responsible for all the record pointers */ for (n = 0; n < li->all.by_artist.entries; n++) { struct record *re; re = li->all.by_artist.record[n]; record_clear(re); free(re); } /* Clear crates */ for (n = 1; n < li->crates; n++) { /* skip the 'all' crate */ struct crate *crate; crate = li->crate[n]; crate_clear(crate); free(crate); } free(li->crate); crate_clear(&li->all); }
bool record_create(record_t *record, const char *prog, int argc, char **argv) { char hash_buf[SHA1_STRING_LEN]; const char *prog_bin = prog; unsigned i; record_clear(record); if (strrchr(prog, '/')) prog_bin = strrchr(prog, '/') + 1; if (!sha1_file(prog, hash_buf)) return false; strlist_push_back(&record->prog_line, prog_bin); strlist_push_back(&record->prog_line, sha1_file(prog, hash_buf)); for (i = 0; i < (unsigned)argc; ++i) strlist_push_back(&record->prog_line, argv[i]); strlist lib_list = STRLIST_INITIALIZER; get_libs(&lib_list, prog); for (i = 0; i < lib_list.count; ++i) { const char *lib_path = strlist_get(&lib_list, i); if (!sha1_file(lib_path, hash_buf)) continue; strlist_push_back(&record->lib_line, lib_path); strlist_push_back(&record->lib_line, sha1_file(lib_path, hash_buf)); } record->enabled = true; return true; }
addr_id_t addr_udp(inet_t inet, net_port_t port) { addr_id_t id ; record_clear(&id) ; id.kind = ADDR_UDP ; id.u.udp.inet = inet ; id.u.udp.port = port ; return id ; }
//清除脱机存储的条码 int setcode_MEM_CLEAR_proc(void) { hw_platform_start_led_blink(LED_GREEN,6); record_clear(); hw_platform_stop_led_blink(LED_GREEN); if ((device_current_state == STATE_Memory_Mode)||(device_current_state == STATE_Memory_Mode_BT_Connect)||(device_current_state == STATE_Memory_Mode_BT_WaitPair)) { hw_platform_led_ctrl(LED_GREEN,1); } return 0; }
static void journal_commit_record(GQueue *queue, struct record *record) { if (record->artist != NULL && record->track != NULL) { /* append record to the queue; reuse allocated strings */ g_queue_push_tail(queue, g_memdup(record, sizeof(*record))); journal_file_empty = false; } else { /* free and clear the record, it was not used */ record_deinit(record); } record_clear(record); }
void unmarsh_addr_id(unmarsh_t m, addr_id_t *ret) { addr_id_t id ; record_clear(&id) ; id.kind = unmarsh_enum_ret(m, ADDR_MAX) ; switch(id.kind) { case ADDR_UDP: unmarsh_net_port(m, &id.u.udp.port) ; unmarsh_inet(m, &id.u.udp.inet) ; break ; case ADDR_NETSIM: unmarsh_mux(m, &id.u.netsim) ; break ; OTHERWISE_ABORT() ; } *ret = id ; }
alarm_t alarm_create( name_t name, alarm_gettime_t gettime, alarm_schedule_t schedule, alarm_check_t check, alarm_min_t min, alarm_add_sock_recv_t add_sock_recv, alarm_rmv_sock_recv_t rmv_sock_recv, alarm_add_sock_xmit_t add_sock_xmit, alarm_rmv_sock_xmit_t rmv_sock_xmit, alarm_add_poll_t add_poll, alarm_rmv_poll_t rmv_poll, alarm_block_t block, alarm_block_extern_t block_extern, alarm_poll_t poll, env_t env ) { alarm_t a = record_create(alarm_t, a) ; record_clear(a) ; a->last_time = time_zero() ; a->name = name ; a->env = env ; a->gettime = gettime ; a->schedule = schedule ; a->check = check ; a->min = min ; a->add_sock_recv = add_sock_recv ; a->rmv_sock_recv = rmv_sock_recv ; a->add_sock_xmit = add_sock_xmit ; a->rmv_sock_xmit = rmv_sock_xmit ; a->add_poll = add_poll ; a->rmv_poll = rmv_poll ; a->block = block ; a->block_extern = block_extern ; a->poll = poll ; return a ; }
int library_import(struct library *li, const char *scan, const char *path) { int fd, status; char *cratename, *pathname; pid_t pid; FILE *fp; struct crate *crate; fprintf(stderr, "Scanning '%s'...\n", path); pathname = strdupa(path); cratename = basename(pathname); /* POSIX version, see basename(3) */ assert(cratename != NULL); crate = use_crate(li, cratename); if (crate == NULL) return -1; pid = fork_pipe(&fd, scan, "scan", path, NULL); if (pid == -1) return -1; fp = fdopen(fd, "r"); if (fp == NULL) { perror("fdopen"); abort(); /* recovery not implemented */ } for (;;) { struct record *d, *x; if (get_record(fp, &d) == -1) return -1; if (d == NULL) break; /* Add to the crate of all records */ x = crate_add(&li->all, d); if (x == NULL) return -1; /* If there is an existing entry, use it instead */ if (x != d) { record_clear(d); free(d); d = x; } /* Insert into the user's crate */ if (crate_add(crate, d) == NULL) return -1; } if (fclose(fp) == -1) { perror("close"); abort(); /* assumption fclose() can't on read-only descriptor */ } if (waitpid(pid, &status, 0) == -1) { perror("waitpid"); return -1; } if (!WIFEXITED(status) || WEXITSTATUS(status) != EXIT_SUCCESS) { fputs("Library scan exited reporting failure.\n", stderr); return -1; } return 0; }