int main(int argc, char **argv) { VSTRING *inbuf = vstring_alloc(1); int have_tty = isatty(0); if (argc > 1) { while (--argc > 0 && *++argv) parse_sample(*argv); } else { for (;;) { if (have_tty) { vstream_printf("> "); vstream_fflush(VSTREAM_OUT); } if (vstring_fgets_nonl(inbuf, VSTREAM_IN) <= 0) break; if (have_tty == 0) vstream_printf("> %s\n", STR(inbuf)); if (*STR(inbuf) == 0 || *STR(inbuf) == '#') continue; parse_sample(STR(inbuf)); } } vstring_free(inbuf); return (0); }
imputed_data parse_imputed_data(const std::string &prefix, float call_rate) { imputed_data data; data.info = parse_info( prefix + "_info" ); data.samples = parse_sample( prefix + "_samples" ); data.genotypes = parse_genotypes( prefix, call_rate, data.samples ); return data; }
static void parse_named_action(enum ofputil_action_code code, char *arg, struct ofpbuf *ofpacts) { struct ofpact_tunnel *tunnel; uint16_t vid; uint16_t ethertype; ovs_be32 ip; uint8_t pcp; uint8_t tos; switch (code) { case OFPUTIL_ACTION_INVALID: NOT_REACHED(); case OFPUTIL_OFPAT10_OUTPUT: case OFPUTIL_OFPAT11_OUTPUT: parse_output(arg, ofpacts); break; case OFPUTIL_OFPAT10_SET_VLAN_VID: case OFPUTIL_OFPAT11_SET_VLAN_VID: vid = str_to_u32(arg); if (vid & ~VLAN_VID_MASK) { ovs_fatal(0, "%s: not a valid VLAN VID", arg); } ofpact_put_SET_VLAN_VID(ofpacts)->vlan_vid = vid; break; case OFPUTIL_OFPAT10_SET_VLAN_PCP: case OFPUTIL_OFPAT11_SET_VLAN_PCP: pcp = str_to_u32(arg); if (pcp & ~7) { ovs_fatal(0, "%s: not a valid VLAN PCP", arg); } ofpact_put_SET_VLAN_PCP(ofpacts)->vlan_pcp = pcp; break; case OFPUTIL_OFPAT12_SET_FIELD: set_field_parse(arg, ofpacts); break; case OFPUTIL_OFPAT10_STRIP_VLAN: case OFPUTIL_OFPAT11_POP_VLAN: ofpact_put_STRIP_VLAN(ofpacts); break; case OFPUTIL_OFPAT11_PUSH_VLAN: ethertype = str_to_u16(arg, "ethertype"); if (ethertype != ETH_TYPE_VLAN_8021Q) { /* XXX ETH_TYPE_VLAN_8021AD case isn't supported */ ovs_fatal(0, "%s: not a valid VLAN ethertype", arg); } ofpact_put_PUSH_VLAN(ofpacts); break; case OFPUTIL_OFPAT11_SET_QUEUE: ofpact_put_SET_QUEUE(ofpacts)->queue_id = str_to_u32(arg); break; case OFPUTIL_OFPAT10_SET_DL_SRC: case OFPUTIL_OFPAT11_SET_DL_SRC: str_to_mac(arg, ofpact_put_SET_ETH_SRC(ofpacts)->mac); break; case OFPUTIL_OFPAT10_SET_DL_DST: case OFPUTIL_OFPAT11_SET_DL_DST: str_to_mac(arg, ofpact_put_SET_ETH_DST(ofpacts)->mac); break; case OFPUTIL_OFPAT10_SET_NW_SRC: case OFPUTIL_OFPAT11_SET_NW_SRC: str_to_ip(arg, &ip); ofpact_put_SET_IPV4_SRC(ofpacts)->ipv4 = ip; break; case OFPUTIL_OFPAT10_SET_NW_DST: case OFPUTIL_OFPAT11_SET_NW_DST: str_to_ip(arg, &ip); ofpact_put_SET_IPV4_DST(ofpacts)->ipv4 = ip; break; case OFPUTIL_OFPAT10_SET_NW_TOS: case OFPUTIL_OFPAT11_SET_NW_TOS: tos = str_to_u32(arg); if (tos & ~IP_DSCP_MASK) { ovs_fatal(0, "%s: not a valid TOS", arg); } ofpact_put_SET_IPV4_DSCP(ofpacts)->dscp = tos; break; case OFPUTIL_OFPAT11_DEC_NW_TTL: NOT_REACHED(); case OFPUTIL_OFPAT10_SET_TP_SRC: case OFPUTIL_OFPAT11_SET_TP_SRC: ofpact_put_SET_L4_SRC_PORT(ofpacts)->port = str_to_u32(arg); break; case OFPUTIL_OFPAT10_SET_TP_DST: case OFPUTIL_OFPAT11_SET_TP_DST: ofpact_put_SET_L4_DST_PORT(ofpacts)->port = str_to_u32(arg); break; case OFPUTIL_OFPAT10_ENQUEUE: parse_enqueue(arg, ofpacts); break; case OFPUTIL_NXAST_RESUBMIT: parse_resubmit(arg, ofpacts); break; case OFPUTIL_NXAST_SET_TUNNEL: case OFPUTIL_NXAST_SET_TUNNEL64: tunnel = ofpact_put_SET_TUNNEL(ofpacts); tunnel->ofpact.compat = code; tunnel->tun_id = str_to_u64(arg); break; case OFPUTIL_NXAST_WRITE_METADATA: parse_metadata(ofpacts, arg); break; case OFPUTIL_NXAST_SET_QUEUE: ofpact_put_SET_QUEUE(ofpacts)->queue_id = str_to_u32(arg); break; case OFPUTIL_NXAST_POP_QUEUE: ofpact_put_POP_QUEUE(ofpacts); break; case OFPUTIL_NXAST_REG_MOVE: nxm_parse_reg_move(ofpact_put_REG_MOVE(ofpacts), arg); break; case OFPUTIL_NXAST_REG_LOAD: nxm_parse_reg_load(ofpact_put_REG_LOAD(ofpacts), arg); break; case OFPUTIL_NXAST_NOTE: parse_note(arg, ofpacts); break; case OFPUTIL_NXAST_MULTIPATH: multipath_parse(ofpact_put_MULTIPATH(ofpacts), arg); break; case OFPUTIL_NXAST_BUNDLE: bundle_parse(arg, ofpacts); break; case OFPUTIL_NXAST_BUNDLE_LOAD: bundle_parse_load(arg, ofpacts); break; case OFPUTIL_NXAST_RESUBMIT_TABLE: case OFPUTIL_NXAST_OUTPUT_REG: case OFPUTIL_NXAST_DEC_TTL_CNT_IDS: NOT_REACHED(); case OFPUTIL_NXAST_LEARN: learn_parse(arg, ofpacts); break; case OFPUTIL_NXAST_EXIT: ofpact_put_EXIT(ofpacts); break; case OFPUTIL_NXAST_DEC_TTL: parse_dec_ttl(ofpacts, arg); break; case OFPUTIL_NXAST_SET_MPLS_TTL: case OFPUTIL_OFPAT11_SET_MPLS_TTL: parse_set_mpls_ttl(ofpacts, arg); break; case OFPUTIL_OFPAT11_DEC_MPLS_TTL: case OFPUTIL_NXAST_DEC_MPLS_TTL: ofpact_put_DEC_MPLS_TTL(ofpacts); break; case OFPUTIL_NXAST_FIN_TIMEOUT: parse_fin_timeout(ofpacts, arg); break; case OFPUTIL_NXAST_CONTROLLER: parse_controller(ofpacts, arg); break; case OFPUTIL_OFPAT11_PUSH_MPLS: case OFPUTIL_NXAST_PUSH_MPLS: ofpact_put_PUSH_MPLS(ofpacts)->ethertype = htons(str_to_u16(arg, "push_mpls")); break; case OFPUTIL_OFPAT11_POP_MPLS: case OFPUTIL_NXAST_POP_MPLS: ofpact_put_POP_MPLS(ofpacts)->ethertype = htons(str_to_u16(arg, "pop_mpls")); break; case OFPUTIL_NXAST_STACK_PUSH: nxm_parse_stack_action(ofpact_put_STACK_PUSH(ofpacts), arg); break; case OFPUTIL_NXAST_STACK_POP: nxm_parse_stack_action(ofpact_put_STACK_POP(ofpacts), arg); break; case OFPUTIL_NXAST_SAMPLE: parse_sample(ofpacts, arg); break; } }
ambit_log_entry_t *libambit_pmem20_log_read_entry(ambit_object_t *object) { // Note! We assume that the caller has called libambit_pmem20_log_next_header just before uint8_t *periodic_sample_spec; uint16_t tmp_len, sample_len; size_t buffer_offset, sample_count = 0, i; ambit_log_entry_t *log_entry; ambit_log_sample_t *last_periodic = NULL, *utcsource = NULL, *altisource = NULL; ambit_date_time_t utcbase; uint32_t altisource_index = 0; uint32_t last_base_lat = 0, last_base_long = 0; uint32_t last_small_lat = 0, last_small_long = 0; uint32_t last_ehpe = 0; if (!object->pmem20.log.initialized) { LOG_ERROR("Trying to get log entry without initialization"); return NULL; } // Allocate log entry if ((log_entry = calloc(1, sizeof(ambit_log_entry_t))) == NULL) { object->pmem20.log.initialized = false; return NULL; } LOG_INFO("Reading log entry from address=%08x", object->pmem20.log.current.current); buffer_offset = (object->pmem20.log.current.current - PMEM20_LOG_START); buffer_offset += 12; // Read samples content definition tmp_len = read16inc(object->pmem20.log.buffer, &buffer_offset); periodic_sample_spec = object->pmem20.log.buffer + buffer_offset; buffer_offset += tmp_len; // Parse header tmp_len = read16inc(object->pmem20.log.buffer, &buffer_offset); if (libambit_pmem20_log_parse_header(object->pmem20.log.buffer + buffer_offset, tmp_len, &log_entry->header) != 0) { LOG_ERROR("Failed to parse log entry header correctly"); free(log_entry); object->pmem20.log.initialized = false; return NULL; } buffer_offset += tmp_len; // Now that we know number of samples, allocate space for them! if ((log_entry->samples = calloc(log_entry->header.samples_count, sizeof(ambit_log_sample_t))) == NULL) { free(log_entry); object->pmem20.log.initialized = false; return NULL; } log_entry->samples_count = log_entry->header.samples_count; LOG_INFO("Log entry got %d samples, reading", log_entry->samples_count); // OK, so we are at start of samples, get them all! while (sample_count < log_entry->samples_count) { /* NOTE! The double reads below seems a bit unoptimized, but if we need optimization, we should optimize read_upto instead... To ease the pain on wraparound we simply duplicate the sample to the end of the buffer. */ // First check for log area wrap if (buffer_offset >= PMEM20_LOG_SIZE - 1) { read_upto(object, PMEM20_LOG_START + PMEM20_LOG_WRAP_START_OFFSET, 2); sample_len = read16(object->pmem20.log.buffer, PMEM20_LOG_WRAP_START_OFFSET); } else if (buffer_offset == PMEM20_LOG_SIZE - 2) { read_upto(object, PMEM20_LOG_START + PMEM20_LOG_WRAP_START_OFFSET, 1); sample_len = object->pmem20.log.buffer[buffer_offset] | (object->pmem20.log.buffer[PMEM20_LOG_WRAP_START_OFFSET] << 8); } else { read_upto(object, PMEM20_LOG_START + buffer_offset, 2); sample_len = read16(object->pmem20.log.buffer, buffer_offset); } // Read all data if (buffer_offset + 2 < (PMEM20_LOG_SIZE-1)) { read_upto(object, PMEM20_LOG_START + buffer_offset + 2, sample_len); } if (buffer_offset + 2 + sample_len > PMEM20_LOG_SIZE) { read_upto(object, PMEM20_LOG_START + PMEM20_LOG_WRAP_START_OFFSET, (buffer_offset + 2 + sample_len) - PMEM20_LOG_SIZE); memcpy(object->pmem20.log.buffer + PMEM20_LOG_SIZE, object->pmem20.log.buffer + PMEM20_LOG_WRAP_START_OFFSET, (buffer_offset + 2 + sample_len) - PMEM20_LOG_SIZE); } if (parse_sample(object->pmem20.log.buffer, buffer_offset, &periodic_sample_spec, log_entry, &sample_count) == 1) { // Calculate times if (log_entry->samples[sample_count-1].type == ambit_log_sample_type_periodic) { last_periodic = &log_entry->samples[sample_count-1]; } else if (last_periodic != NULL) { log_entry->samples[sample_count-1].time += last_periodic->time; } else { log_entry->samples[sample_count-1].time = 0; } if (utcsource == NULL && log_entry->samples[sample_count-1].type == ambit_log_sample_type_gps_base) { utcsource = &log_entry->samples[sample_count-1]; // Calculate UTC base time add_time(&utcsource->u.gps_base.utc_base_time, 0-utcsource->time, &utcbase); } // Calculate positions if (log_entry->samples[sample_count-1].type == ambit_log_sample_type_gps_base) { last_base_lat = log_entry->samples[sample_count-1].u.gps_base.latitude; last_base_long = log_entry->samples[sample_count-1].u.gps_base.longitude; last_small_lat = log_entry->samples[sample_count-1].u.gps_base.latitude; last_small_long = log_entry->samples[sample_count-1].u.gps_base.longitude; last_ehpe = log_entry->samples[sample_count-1].u.gps_base.ehpe; } else if (log_entry->samples[sample_count-1].type == ambit_log_sample_type_gps_small) { log_entry->samples[sample_count-1].u.gps_small.latitude = last_base_lat + log_entry->samples[sample_count-1].u.gps_small.latitude*10; log_entry->samples[sample_count-1].u.gps_small.longitude = last_base_long + log_entry->samples[sample_count-1].u.gps_small.longitude*10; last_small_lat = log_entry->samples[sample_count-1].u.gps_small.latitude; last_small_long = log_entry->samples[sample_count-1].u.gps_small.longitude; last_ehpe = log_entry->samples[sample_count-1].u.gps_small.ehpe; } else if (log_entry->samples[sample_count-1].type == ambit_log_sample_type_gps_tiny) { log_entry->samples[sample_count-1].u.gps_tiny.latitude = last_small_lat + log_entry->samples[sample_count-1].u.gps_tiny.latitude*10; log_entry->samples[sample_count-1].u.gps_tiny.longitude = last_small_long + log_entry->samples[sample_count-1].u.gps_tiny.longitude*10; log_entry->samples[sample_count-1].u.gps_tiny.ehpe = (last_ehpe > 700 ? 700 : last_ehpe); last_small_lat = log_entry->samples[sample_count-1].u.gps_tiny.latitude; last_small_long = log_entry->samples[sample_count-1].u.gps_tiny.longitude; } if (altisource == NULL && log_entry->samples[sample_count-1].type == ambit_log_sample_type_altitude_source) { altisource = &log_entry->samples[sample_count-1]; altisource_index = sample_count-1; } } buffer_offset += 2 + sample_len; // Wrap if (buffer_offset >= PMEM20_LOG_SIZE) { buffer_offset = PMEM20_LOG_WRAP_START_OFFSET + (buffer_offset - PMEM20_LOG_SIZE); } } // Loop through samples again and correct times etc for (sample_count = 0; sample_count < log_entry->header.samples_count; sample_count++) { // Set UTC times (if UTC source found) if (utcsource != NULL) { add_time(&utcbase, log_entry->samples[sample_count].time, &log_entry->samples[sample_count].utc_time); } // Correct altitude based on altitude offset in altitude source if (altisource != NULL && log_entry->samples[sample_count].type == ambit_log_sample_type_periodic && sample_count < altisource_index) { for (i=0; i<log_entry->samples[sample_count].u.periodic.value_count; i++) { if (log_entry->samples[sample_count].u.periodic.values[i].type == ambit_log_sample_periodic_type_sealevelpressure) { log_entry->samples[sample_count].u.periodic.values[i].u.sealevelpressure += altisource->u.altitude_source.pressure_offset; } if (log_entry->samples[sample_count].u.periodic.values[i].type == ambit_log_sample_periodic_type_altitude) { log_entry->samples[sample_count].u.periodic.values[i].u.altitude += altisource->u.altitude_source.altitude_offset; } } } } return log_entry; }