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;
}
