int parse_param_init(unsigned int type, void *val) { if (parse_param(val, &cc_init_avps) == -1) return E_CFG; return 0; }
static int parse_dollars(char **word, size_t * word_length, size_t * max_length, const char *words, size_t * offset, int flags, wordexp_t * pwordexp, const char *ifs, const char *ifs_white, int quoted) { /* We are poised _at_ "$" */ switch (words[1 + *offset]) { case '"': case '\'': case 0: *word = w_addchar(*word, word_length, max_length, '$'); return *word ? 0 : WRDE_NOSPACE; #ifdef __WORDEXP_FULL case '(': if (words[2 + *offset] == '(') { /* Differentiate between $((1+3)) and $((echo);(ls)) */ int i = 3 + *offset; int depth = 0; while (words[i] && !(depth == 0 && words[i] == ')')) { if (words[i] == '(') ++depth; else if (words[i] == ')') --depth; ++i; } if (words[i] == ')' && words[i + 1] == ')') { (*offset) += 3; /* Call parse_arith -- 0 is for "no brackets" */ return parse_arith(word, word_length, max_length, words, offset, flags, 0); } } if (flags & WRDE_NOCMD) return WRDE_CMDSUB; (*offset) += 2; return parse_comm(word, word_length, max_length, words, offset, flags, quoted ? NULL : pwordexp, ifs, ifs_white); case '[': (*offset) += 2; /* Call parse_arith -- 1 is for "brackets" */ return parse_arith(word, word_length, max_length, words, offset, flags, 1); case '{': default: ++(*offset); /* parse_param needs to know if "{" is there */ return parse_param(word, word_length, max_length, words, offset, flags, pwordexp, ifs, ifs_white, quoted); #else default: ++(*offset); /* parse_param needs to know if "{" is there */ return 0; #endif } }
int main(int argc, char **argv) { int ret; ret = odp_init_global(NULL, NULL); if(ret < 0) { fprintf(stderr, "global init failure!\n"); exit(EXIT_FAILURE); } ret = odp_init_local(ODP_THREAD_CONTROL); if(ret < 0) { fprintf(stderr, "local init failure!\n"); exit(EXIT_FAILURE); } parse_param(argc, argv); packet_classifier_init(glb_param.rule_file, glb_param.fib_file); hash_env_init(); sm_hdl = sm_build(glb_param.pat_file); hs_tbl = create_hash_table(); odp_pool_t pkt_pool; pkt_pool = create_pkt_pool("PACKET_POOL",PACKET_POOL_OBJ_SZ, PACKET_POOL_MAX_ELT_NUM); if(pkt_pool == ODP_POOL_INVALID) { fprintf(stderr, "create packet pool failure!\n"); exit(EXIT_FAILURE); } if(init_all_if(pkt_pool) == -1) { fprintf(stderr, "init nic faliure!\n"); exit(EXIT_FAILURE); } odph_linux_pthread_t thr_tbl[ODP_CONFIG_PKTIO_ENTRIES]; int thr_num; thr_num = odph_linux_pthread_create(thr_tbl, &glb_param.cpu_mask, thread_fwd_routine, NULL); if(thr_num != glb_param.nic.num) { fprintf(stderr, "some nic thread start failure!\n"); exit(EXIT_FAILURE); } odph_linux_pthread_t thr_stat_hdl; odp_cpumask_t thr_stat_mask; odp_cpumask_zero(&thr_stat_mask); odp_cpumask_set(&thr_stat_mask, glb_param.nic.num); if(odph_linux_pthread_create(&thr_stat_hdl, &thr_stat_mask, thread_stat_routine, NULL) != 1) { fprintf(stderr, "stat thread start failure!\n"); exit(EXIT_FAILURE); } odph_linux_pthread_join(thr_tbl, thr_num); odph_linux_pthread_join(&thr_stat_hdl, 1); int nic_id; for(nic_id = 0; nic_id < glb_param.nic.num; nic_id++) { odp_pktio_close(thr_data.nic_hdl[nic_id]); } sm_destroy(sm_hdl); odph_hash_free(hs_tbl); odp_pool_destroy(pkt_pool); odp_term_local(); odp_term_global(); return 0; }
int main (int argc, char **argv) { int c, errflg = 0; Dbptr db, tr; char *database,*outfile, *pfname=0; Flags flags ; Pf *pf,*pf_def,*pf_sta=NULL,*pf_stas; Tbl *input; char *start, *stop, *triggertimestring=NULL ; char *subset=0 ; long nrecords,nsamp1 ; int duration,nframes,sampsperframe; double tstart, tstop, triggertime=0; char sta[STA_LEN],sta1[STA_LEN]; char chan[STA_LEN],chan1[STA_LEN]; double samprate,samprate1,t1,t2; FILE *fout; size_t nw; unsigned char *hdrbuf=malloc(2040); unsigned char *framebuf=malloc(32); unsigned char *tagbuf=malloc(16); unsigned short cksum; unsigned char wfarr[3 * 12 * 100]; /*1000sps * 0.1 sec * 12 chan * 3bytes*/ int sampindex=0; K2EvtFile *myhdr=malloc(2040); K2EvtTag *mytag=malloc(sizeof(K2EvtTag)); K2EvtFrame *myframe=malloc(sizeof(K2EvtFrame)); float *data[12] ; unsigned short channelBitmap=0; int pf_serialno,pf_sensortype; double pf_sensitivity, pf_fullscale, pf_lat, pf_lon, pf_elev; memset ( &flags, 0, sizeof(flags)); elog_init ( argc, argv ) ; while ((c = getopt (argc, argv, "do:p:s:t:v")) != -1) { switch (c) { case 'd': flags.display = 1 ; break ; case 'p': pfname= optarg ; break; case 's': subset = optarg ; break ; case 't': triggertimestring = optarg ; break ; case 'v': flags.verbose++ ; break; default: errflg++; break ; } } if (errflg || argc-optind != 4) usage (); if (pfname==NULL) { pfname=Program_Name; } if (pfread (pfname, &pf) != 0) die (0, "Can't read parameter file %s\n",pfname); database = argv[optind++]; outfile = argv[optind++]; start = argv[optind++]; stop = argv[optind++]; tstart=str2epoch(start); tstop=str2epoch(stop); tstart=ceil(tstart); /* make sure we have second boundaries, this also makes sure we have a integer number of frames */ tstop=floor(tstop); duration=tstop - tstart; if ( dbopen(database, "r", &db) ) { die ( 0, "Can't open database %s", database ) ; } input = pfget_tbl (pf, "view" ) ; db = dbprocess ( db, input, 0 ) ; if (subset) { db=dbsubset(db,subset,0); } tr = dbinvalid() ; if ( trload_css ( db, start, stop, &tr, 0, 0 ) ) { die ( 1, "trload_css failed" ) ; } if ( trsplit(tr, 0, 0) ) { complain ( 0, "trsplit failed" ) ; } if ( trsplice(tr, 0, 0, 0) ) { complain ( 0, "trsplice failed" ) ; } if ( flags.display ) { trdisp (tr, "will try to convert this stuff to evt") ; } tr.record=0; dbgetv(tr,0,"time",&t1,"endtime",&t2,"sta",sta1,"chan",chan1,"samprate",&samprate1,"nsamp",&nsamp1,NULL); samprate1=round(samprate1); dbquery ( tr, dbRECORD_COUNT, &nrecords ) ; if (nrecords > 12) { printf("will only use the first 12 channels, consider modifying the subset..."); nrecords=12; } for ( tr.record = 0 ; tr.record < nrecords ; tr.record++ ) { double ts,te; dbgetv(tr,0,"time",&ts,"endtime",&te,"samprate",&samprate,"sta",sta,"chan",chan,NULL); samprate=round(samprate); if (t1 != ts || t2 != te) { die ( 0, "this simplistic version only works with 101% correct times and/or subsets, sorry..." ) ; } if (strcmp(sta,sta1) !=0) { die ( 0, "%s <=> %s this simplistic version only works with ONE station, but the subset left more",sta,sta1 ) ; } if (samprate != samprate1) { die ( 0, "all channels in a K2-EVT File MUST have the same samplerate!" ); } } newFileHeader(&myhdr, pf, sta); if (parse_param (pf, "sta_defaults", P_ARRPF, 1, &pf_def) < 0) { elog_die (0, "error parsing array sta_defaults.\n"); } if (parse_param (pf, "sta_params", P_ARRPF, 1, &pf_stas) < 0) { elog_die (0, "error parsing array sta_params.\n"); } if (parse_param (pf_stas, sta, P_ARRPF, 0, &pf_sta) < 0) { elog_die (0, "error parsing sta_params{%s}\n.",sta); } if (parse_param(pf_def,"sensortype",P_LINT,1,&pf_sensortype)< 0 ) { elog_die (0, "error parsing default sensortype.\n"); } if (parse_param(pf_def,"serialno",P_LINT,1,&pf_serialno)< 0 ) { elog_die (0, "error parsing default serialno.\n"); } if (parse_param(pf_def,"sensitivity",P_DBL,1,&pf_sensitivity)< 0 ) { elog_die (0, "error parsing default sensitivity.\n"); } if (parse_param(pf_def,"fullscale",P_DBL,1,&pf_fullscale)< 0 ) { elog_die (0, "error parsing default fullscale.\n"); } if (parse_param(pf_def,"lat",P_DBL,1,&pf_lat)< 0 ) { elog_die (0, "error parsing default lat.\n"); } if (parse_param(pf_def,"lon",P_DBL,1,&pf_lon)< 0 ) { elog_die (0, "error parsing default lon.\n"); } if (parse_param(pf_def,"elev",P_DBL,1,&pf_elev)< 0 ) { elog_die (0, "error parsing default elev.\n"); } if (pf_sta==NULL) { elog_notify (0, "can't parse array sta_params{%s}, will use defaults\n.",sta); pf_sta=pf_def; } else { if (parse_param(pf_def,"sensortype",P_LINT,0,&pf_sensortype)< 0 ) { elog_die (0, "error parsing sensortype.\n"); } if (parse_param(pf_sta,"serialno",P_LINT,0,&pf_serialno)< 0 ) { elog_die (0, "error parsing serialno.\n"); } if (parse_param(pf_sta,"sensitivity",P_DBL,0,&pf_sensitivity)< 0 ) { elog_die (0, "error parsing sensitivity.\n"); } if (parse_param(pf_sta,"fullscale",P_DBL,0,&pf_fullscale)< 0 ) { elog_die (0, "error parsing fullscale.\n"); } if (parse_param(pf_sta,"lat",P_DBL,0,&pf_lat)< 0 ) { elog_die (0, "error parsing lat.\n"); } if (parse_param(pf_sta,"lon",P_DBL,0,&pf_lon)< 0 ) { elog_die (0, "error parsing lon.\n"); } if (parse_param(pf_sta,"elev",P_DBL,0,&pf_elev)< 0 ) { elog_die (0, "error parsing elev.\n"); } } myhdr->rw_stream.sps=samprate; /* sampling rate */ myhdr->rw_stream.preEvent=1; /* in seconds */ myhdr->rw_stream.postEvent=5; /* in seconds */ myhdr->rw_stream.minRunTime=6; /* in seconds */ myhdr->ro_stream.duration=duration; myhdr->ro_stream.nscans=duration* 10; myhdr->ro_stream.startTime=epoch2k2time(t1); myhdr->ro_stream.startTimeMsec=0; int ttms=0; if (triggertimestring) { triggertime=str2epoch(triggertimestring); ttms=remainder(triggertime,1.0 ) * 1000.0; triggertime=epoch2k2time(triggertime); } else { triggertime=epoch2k2time(t1)+5; ttms=0; } myhdr->ro_stream.triggerTime=triggertime; myhdr->ro_stream.triggerTimeMsec=ttms; myhdr->rw_misc.nchannels=nrecords; for (int channo=0;channo< nrecords;channo++) { myhdr->rw_channel[channo].sensitivity=pf_sensitivity; myhdr->rw_channel[channo].sensitivity=pf_fullscale; } myhdr->rw_misc.elevation=pf_elev; /* meters above sea level */ myhdr->rw_misc.latitude=pf_lat; /* degrees north */ myhdr->rw_misc.longitude=pf_lon; /* degrees east */ nframes=duration * 10; myhdr->ro_stream.duration=nframes; myhdr->ro_stream.nscans=duration*samprate; channelBitmap=chanbitmap(nrecords); for ( tr.record = 0 ; tr.record < nrecords ; tr.record++ ) { unsigned long i ; int nsamp; char chan[7]; unsigned long minoffset=0; unsigned long maxoffset=0; int max=INT_MIN; int min=INT_MAX; dbgetv(tr, 0, "chan",chan,"data", &data[tr.record], "nsamp", &nsamp, NULL ) ; for ( i=0 ; i<nsamp ; i++ ) { if (data[tr.record][i] > max) { max=data[tr.record][i]; maxoffset=i; } if (data[tr.record][i] < min) { min=data[tr.record][i]; minoffset=i; } } myhdr->ro_channel[tr.record].maxPeak=max; myhdr->ro_channel[tr.record].maxPeakOffset=maxoffset; myhdr->ro_channel[tr.record].minPeak=min; myhdr->ro_channel[tr.record].minPeakOffset=minoffset; memcpy(myhdr->rw_channel[tr.record].id,chan,K2EVT_CHANNEL_ID_LENGTH); } for ( tr.record = 0 ; tr.record < nrecords ; tr.record++ ) { } newTag(&mytag,0, 2040, 0, 128,1234); encodek2header(hdrbuf,myhdr); cksum=k2_checksum(hdrbuf,2040); mytag->length=2040;/*header size*/ mytag->dataLength=0; mytag->checksum=cksum; encodek2tag(tagbuf,mytag); fout=fopen(outfile,"w+"); nw=fwrite(tagbuf,16,1,fout); nw=fwrite(hdrbuf,2040,1,fout); double t=t1 ; double k2t=round(epoch2k2time(t)); newFrameHeader(&myframe,128,(sampsperframe*3*nrecords)+32, k2t); sampsperframe=TIME2SAMP(0,samprate,0.1);/*samples per frame*/ for (int fn=0;fn < nframes;fn++) { cksum=0; sampindex=0; for (int s=0;s<sampsperframe;s++) { long val; unsigned char buf[4]; for ( int channo = 0 ; channo < nrecords ; channo++ ) { int index=((fn*sampsperframe) + s); val=round(data[channo][index]); /*debugging...*/ //val=66051;/*0x010203*/ memcpy(&buf,&val,4); val <<=8; #ifdef WORDS_BIGENDIAN cksum+=buf[1]; cksum+=buf[2]; cksum+=buf[3]; wfarr[sampindex++]=buf[1]; wfarr[sampindex++]=buf[2]; wfarr[sampindex++]=buf[3]; #else cksum+=buf[2]; cksum+=buf[1]; cksum+=buf[0]; wfarr[sampindex++]=buf[2]; wfarr[sampindex++]=buf[1]; wfarr[sampindex++]=buf[0]; #endif } } mytag->checksum=cksum; mytag->length=32;/*header size*/ mytag->dataLength=sampsperframe * nrecords * 3; myframe->frameSize=(sampsperframe*3*nrecords)+32; myframe->blockTime=round(k2t); myframe->msec=fmod(k2t,1.0) * 1000; myframe->channelBitMap=channelBitmap; encodek2Frame(framebuf,myframe); mytag->checksum+=k2_checksum(framebuf,32); encodek2tag(tagbuf,mytag); k2t+=0.1; //k2t=round((k2t+0.1)*10.0)/10.0; nw=fwrite(tagbuf,1,16,fout); if (nw!= 16) { die(0,"could not write file tag, wrote %d bytes instead of 16",nw); } nw=fwrite(framebuf,32,1,fout); nw=fwrite(&wfarr, 1,sampsperframe * 3 * nrecords, fout); } fclose(fout); tr.table = dbALL ; trfree(tr) ; pffree(pf) ; return 0; }
int parse_param_stop(unsigned int type, void *val) { if (parse_param(val, &stop_avps) == -1) return E_CFG; return 0; }
void hnd_post_rd(coap_context_t *ctx, struct coap_resource_t *resource, coap_address_t *peer, coap_pdu_t *request, str *token, coap_pdu_t *response, void *userdata) { coap_resource_t *r; coap_opt_iterator_t opt_iter; coap_opt_t *query; #define LOCSIZE 68 unsigned char *loc; size_t loc_size; str h = {0, NULL}, ins = {0, NULL}, rt = {0, NULL}, lt = {0, NULL}; /* store query parameters */ unsigned char *buf; loc = (unsigned char *)coap_malloc(LOCSIZE); if (!loc) { response->hdr->code = COAP_RESPONSE_CODE(500); return; } memcpy(loc, RD_ROOT_STR, RD_ROOT_SIZE); loc_size = RD_ROOT_SIZE; loc[loc_size++] = '/'; /* store query parameters for later use */ query = coap_check_option(request, COAP_OPTION_URI_QUERY, &opt_iter); if (query) { parse_param((unsigned char *)"h", 1, COAP_OPT_VALUE(query), COAP_OPT_LENGTH(query), &h); parse_param((unsigned char *)"ins", 3, COAP_OPT_VALUE(query), COAP_OPT_LENGTH(query), &ins); parse_param((unsigned char *)"lt", 2, COAP_OPT_VALUE(query), COAP_OPT_LENGTH(query), <); parse_param((unsigned char *)"rt", 2, COAP_OPT_VALUE(query), COAP_OPT_LENGTH(query), &rt); } if (h.length) { /* client has specified a node name */ memcpy(loc + loc_size, h.s, min(h.length, LOCSIZE - loc_size - 1)); loc_size += min(h.length, LOCSIZE - loc_size - 1); if (ins.length && loc_size > 1) { loc[loc_size++] = '-'; memcpy((char *)(loc + loc_size), ins.s, min(ins.length, LOCSIZE - loc_size - 1)); loc_size += min(ins.length, LOCSIZE - loc_size - 1); } } else { /* generate node identifier */ loc_size += snprintf((char *)(loc + loc_size), LOCSIZE - loc_size - 1, "%x", request->hdr->id); if (loc_size > 1) { if (ins.length) { loc[loc_size++] = '-'; memcpy((char *)(loc + loc_size), ins.s, min(ins.length, LOCSIZE - loc_size - 1)); loc_size += min(ins.length, LOCSIZE - loc_size - 1); } else { coap_tick_t now; coap_ticks(&now); loc_size += snprintf((char *)(loc + loc_size), LOCSIZE - loc_size - 1, "-%x", now); } } } /* TODO: * - use lt to check expiration */ r = coap_resource_init(loc, loc_size, COAP_RESOURCE_FLAGS_RELEASE_URI); coap_register_handler(r, COAP_REQUEST_GET, hnd_get_resource); coap_register_handler(r, COAP_REQUEST_PUT, hnd_put_resource); coap_register_handler(r, COAP_REQUEST_DELETE, hnd_delete_resource); if (ins.s) { buf = (unsigned char *)coap_malloc(ins.length + 2); if (buf) { /* add missing quotes */ buf[0] = '"'; memcpy(buf + 1, ins.s, ins.length); buf[ins.length + 1] = '"'; coap_add_attr(r, (unsigned char *)"ins", 3, buf, ins.length + 2, COAP_ATTR_FLAGS_RELEASE_VALUE); } } if (rt.s) { buf = (unsigned char *)coap_malloc(rt.length + 2); if (buf) { /* add missing quotes */ buf[0] = '"'; memcpy(buf + 1, rt.s, rt.length); buf[rt.length + 1] = '"'; coap_add_attr(r, (unsigned char *)"rt", 2, buf, rt.length + 2, COAP_ATTR_FLAGS_RELEASE_VALUE); } } add_source_address(r, peer); { rd_t *rd; rd = make_rd(peer, request); if (rd) { coap_hash_path(loc, loc_size, rd->key); HASH_ADD(hh, resources, key, sizeof(coap_key_t), rd); } else { /* FIXME: send error response and delete r */ } } coap_add_resource(ctx, r); /* create response */ response->hdr->code = COAP_RESPONSE_CODE(201); { /* split path into segments and add Location-Path options */ unsigned char _b[LOCSIZE]; unsigned char *b = _b; size_t buflen = sizeof(_b); int nseg; nseg = coap_split_path(loc, loc_size, b, &buflen); while (nseg--) { coap_add_option(response, COAP_OPTION_LOCATION_PATH, COAP_OPT_LENGTH(b), COAP_OPT_VALUE(b)); b += COAP_OPT_SIZE(b); } } }