void track_who(void) { int pkts = 0, bytes = 0; mapi_results_t *res = NULL; who.bytes = 0; who.pkts = 0; pthread_mutex_init(&who.lock, NULL); if(offline) { who.fd = mapi_create_offline_flow(readfile, MFF_PCAP); } else { who.fd = mapi_create_flow(DEVICE); } who.filter = mapi_apply_function(who.fd, "BPF_FILTER", "udp port 513"); who.pkt_counter = mapi_apply_function(who.fd, "PKT_COUNTER"); who.byte_counter = mapi_apply_function(who.fd, "BYTE_COUNTER"); mapi_connect(who.fd); while(1) { sleep(2); res = mapi_read_results(who.fd, who.pkt_counter); if(res) { pkts = *((int*)res->res); res = NULL; } res = mapi_read_results(who.fd, who.byte_counter); if(res) { bytes = *((int*)res->res); res = NULL; } pthread_mutex_lock(&who.lock); who.pkts = pkts; who.bytes = bytes; pthread_mutex_unlock(&who.lock); } }
int main(MAPI_UNUSED int argc, char *argv[]) { int fd; mapi_flow_info_t info; int err_no; char error[512]; if((fd = mapi_create_offline_flow(argv[1], MFF_PCAP)) < 0) { fprintf(stderr,"Could not create offline flow\n"); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if(mapi_apply_function(fd, "ANONYMIZE", "IP,SRC_IP,RANDOM") < 0) { printf("Could not apply ANONYMIZE IP,SRC_IP,RANDOM \n"); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if(mapi_apply_function(fd, "TO_FILE", MFF_PCAP, argv[2], 0) < 0) { fprintf(stderr, "Could not apply TO_FILE to flow %d\n", fd); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if (mapi_connect(fd) < 0) { fprintf(stderr,"Could not connect to flow %d\n", fd); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; do { if(mapi_get_flow_info(fd, &info) < 0) { fprintf(stderr, "Could not apply PKT_COUNTER to flow %d\n", fd); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; }while(info.status != FLOW_FINISHED); if (mapi_close_flow(fd) < 0) { fprintf(stderr, "Could not close flow %d\n", fd); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; return 0; }
void track_ssdp(void) { int pkts = 0, bytes = 0; mapi_results_t *res = NULL; ssdp.bytes = 0; ssdp.pkts = 0; pthread_mutex_init(&ssdp.lock, NULL); if(offline) { ssdp.fd = mapi_create_offline_flow(readfile, MFF_PCAP); } else { ssdp.fd = mapi_create_flow(DEVICE); } ssdp.filter = mapi_apply_function(ssdp.fd, "BPF_FILTER", "port 1900"); ssdp.pkt_counter = mapi_apply_function(ssdp.fd, "PKT_COUNTER"); ssdp.byte_counter = mapi_apply_function(ssdp.fd, "BYTE_COUNTER"); mapi_connect(ssdp.fd); while(1) { sleep(2); res = mapi_read_results(ssdp.fd, ssdp.pkt_counter); if(res) { pkts = *((int*)res->res); res = NULL; } res = mapi_read_results(ssdp.fd, ssdp.byte_counter); if(res) { bytes = *((int*)res->res); res = NULL; } pthread_mutex_lock(&ssdp.lock); ssdp.pkts = pkts; ssdp.bytes = bytes; pthread_mutex_unlock(&ssdp.lock); } }
void createFlows(char *dev,int ifindex,char *start, char *stop, char *path) { int byte,pkt,stats1[INTERVALS],stats2[INTERVALS]; int i; char str[256],*space; char fids[128],types[128]; char intervals[4][20]={"1s","100ms","10ms"}; for(i=0;i<INTERVALS;i++) { nextfd[i]=mapi_create_flow(dev); mapi_apply_function(nextfd[i],"INTERFACE",ifindex); mapi_apply_function(nextfd[i],"STARTSTOP",start,stop); byte=mapi_apply_function(nextfd[i],"BYTE_COUNTER"); pkt=mapi_apply_function(nextfd[i],"PKT_COUNTER"); stats1[i]=mapi_apply_function(nextfd[i],"STATS",nextfd[i],byte,intervals[i]); stats2[i]=mapi_apply_function(nextfd[i],"STATS",nextfd[i],pkt,intervals[i]); mapi_connect(nextfd[i]); } nextfd[INTERVALS]=mapi_create_flow(dev); mapi_apply_function(nextfd[INTERVALS],"INTERFACE",ifindex); mapi_apply_function(nextfd[INTERVALS],"STARTSTOP",start,stop); byte=mapi_apply_function(nextfd[INTERVALS],"BYTE_COUNTER"); pkt=mapi_apply_function(nextfd[INTERVALS],"PKT_COUNTER"); mapi_connect(nextfd[INTERVALS]); nextfd[INTERVALS+1]=mapi_create_flow(dev); mapi_apply_function(nextfd[INTERVALS+1],"INTERFACE",ifindex); mapi_apply_function(nextfd[INTERVALS+1],"STARTSTOP",start,"+400s"); snprintf(fids,128,"%d@%d,%d@%d,%d@%d,%d@%d,%d@%d,%d@%d,%d@%d,%d@%d", byte,nextfd[INTERVALS],pkt,nextfd[INTERVALS], stats1[0],nextfd[0],stats2[0],nextfd[0],stats1[1],nextfd[1],stats2[1],nextfd[1], stats1[2],nextfd[2],stats2[2],nextfd[2]); snprintf(types,128,"%d,%d,%d,%d,%d,%d,%d,%d",R2F_ULLSTR,R2F_ULLSTR,R2F_STATS,R2F_STATS,R2F_STATS,R2F_STATS,R2F_STATS,R2F_STATS); sprintf(str,"%s/tmp_%s.txt",path,start); space=strchr(str,' '); *space='_'; mapi_apply_function(nextfd[INTERVALS+1],"RES2FILE",types,fids,"bytes1s packets1s bytes100ms packets100ms bytes10ms packets10ms",str,"300s",1); mapi_connect(nextfd[INTERVALS+1]); }
int main(int argc, char **argv) { Mapi dbh; MapiHdl hdl = NULL; int i, port, n = 20000; char buf[40]; int lang = 1; char *l = "sql"; /* char *line; */ if (argc != 2 && argc != 3) { printf("usage:smack00 <port> [<language>]\n"); exit(-1); } if (argc == 3) { l = argv[2]; if (strcmp(argv[2], "sql") == 0) lang = 1; else if (strcmp(argv[2], "mal") == 0) lang = 3; } port = atol(argv[1]); dbh = mapi_connect("localhost", port, "monetdb", "monetdb", l, NULL); if (dbh == NULL || mapi_error(dbh)) die(dbh, hdl); /* switch of autocommit */ if (lang==1 && (mapi_setAutocommit(dbh, 0) != MOK || mapi_error(dbh))) die(dbh,NULL); for (i = 0; i < n; i++) { if (lang==1) snprintf(buf, 40, "select %d;", i); else snprintf(buf, 40, "io.print(%d);", i); if ((hdl = mapi_query(dbh, buf)) == NULL || mapi_error(dbh)) die(dbh, hdl); while ( (/*line= */ mapi_fetch_line(hdl)) != NULL) { /*printf("%s \n", line); */ } if (mapi_error(dbh)) die(dbh, hdl); if (mapi_close_handle(hdl) != MOK) die(dbh, hdl); } mapi_destroy(dbh); return 0; }
CAMLprim value mapi_connect_stub_bc(value *argv, int argn) { assert(argn == 6); const char *host_str = String_val(argv[0]); const int port_i = Int_val(argv[1]); assert(port_i > 0 && port_i < 65536); const char *user_str = String_val(argv[2]); const char *passwd_str = String_val(argv[3]); const char *lang_str = String_val(argv[4]); const char *db_str = String_val(argv[5]); Mapi conn = mapi_connect(host_str, port_i, user_str, passwd_str, lang_str, db_str); if (conn) { return Val_some((value) conn); } else { return Val_none; } }
CAMLprim value mapi_connect_stub_native(value host, value port, value user, value passwd, value lang, value db) { const char *host_str = String_val(host); const int port_i = Int_val(port); assert(port_i > 0 && port_i < 65536); const char *user_str = String_val(user); const char *passwd_str = String_val(passwd); const char *lang_str = String_val(lang); const char *db_str = String_val(db); Mapi conn = mapi_connect(host_str, port_i, user_str, passwd_str, lang_str, db_str); if (conn) { return Val_some((value) conn); } else { return Val_none; } }
int main(MAPI_UNUSED int argc, char *argv[]) { int fd; int fid,fid2,fid3,fid4; int *cnt,*cnt2,*cnt3,*cnt4; if(!argv[1]) { printf("\nWrong arguments\n"); return -1; } fd=mapi_create_offline_flow(argv[1],MFF_PCAP); mapi_apply_function(fd, "BPF_FILTER", "tcp or udp"); fid=mapi_apply_function(fd,"PKT_COUNTER"); fid2=mapi_apply_function(fd,"BYTE_COUNTER"); // mapi_apply_function(fd,"TRACK_FTP"); // mapi_apply_function(fd,"TRACK_GNUTELLA"); // mapi_apply_function(fd,"TRACK_TORRENT"); // mapi_apply_function(fd,"TRACK_DC"); mapi_apply_function(fd, "TRACK_EDONKEY"); fid3=mapi_apply_function(fd,"PKT_COUNTER"); fid4=mapi_apply_function(fd,"BYTE_COUNTER"); mapi_connect(fd); cnt=mapi_read_results(fd,fid,MAPI_REF); cnt2=mapi_read_results(fd,fid2,MAPI_REF); cnt3=mapi_read_results(fd,fid3,MAPI_REF); cnt4=mapi_read_results(fd,fid4,MAPI_REF); while(1) { sleep(1); printf("Total packets: %d Total bytes: %d FTP packets: %d FTP bytes: %d\n",*cnt,*cnt2,*cnt3,*cnt4); } mapi_close_flow(fd); printf("\nPKT_COUNTER OK\n"); return 0; }
int main(int argc, char *argv[]) { int fd; int fid; mapi_results_t *cnt; int err_no =0 , flag=0; char error[512]; if(argc!=2) { printf("\nWrong arguments\n"); return -1; } if ((fd = mapi_create_flow(argv[1]))<0){ fprintf(stderr, "Could not create flow using '%s'\n", argv[1]); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if((fid=mapi_apply_function(fd, "PKT_COUNTER"))<0){ fprintf(stderr, "Could not apply PKT_COUNTER to flow %d\n", fd); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if(mapi_connect(fd)<0){ fprintf(stderr, "Connecting to flow failed %d\n", fd); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; sleep(3); if( (cnt = mapi_read_results(fd, fid))==NULL ){ fprintf(stderr, "Mapi read results failed\n"); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } /* * Sanity check. Assuming that we have presence of network traffic */ if( *((int*)cnt->res)<=0) fprintf(stderr, "WARNING: No packets captured. Maybe no traffic on line..\n"); else printf("\nRead_results : %d\n", *((int*)cnt->res)); DOT; if(mapi_close_flow(fd)<0){ fprintf(stderr,"Close flow failed\n"); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; /* * Error checking */ fd = fid = 0; if ((fd = mapi_create_flow(argv[1]))<0){ fprintf(stderr, "Could not create flow using '%s'\n", argv[1]); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if((fid=mapi_apply_function(fd, "PKT_COUNTER"))<0){ fprintf(stderr, "Could not apply PKT_COUNTER to flow %d\n", fd); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if(mapi_connect(fd)<0){ fprintf(stderr, "Connecting to flow failed %d\n", fd); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if(mapi_read_results(123,fid) ==NULL || mapi_read_results(fd,-1244655) ==NULL){ mapi_read_error( &err_no, error); printf("Testing error case1: Errorcode :%d description: %s \n" ,err_no, error); if(err_no != 6145){ printf(" Wrong ERRORCODE returned\n"); flag = 1; } } DOT; if(mapi_close_flow(fd)<0){ fprintf(stderr,"Close flow failed\n"); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; /* * Offline tests */ if ((fd = mapi_create_offline_flow("./tracefile" , MFF_PCAP))<0){ fprintf(stderr, "Could not create flow using '%s'\n", argv[1]); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if((fid=mapi_apply_function(fd, "PKT_COUNTER"))<0){ fprintf(stderr, "Could not apply PKT_COUNTER to flow %d\n", fd); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if(mapi_connect(fd)<0){ fprintf(stderr, "Connecting to flow failed %d\n", fd); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if( (cnt = mapi_read_results(fd, fid))==NULL ){ fprintf(stderr, "Mapi read results failed\n"); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } /* * Sanity check. Assuming that we have presence of network traffic */ sleep(10); if( *((int*)cnt->res)!=893) fprintf(stderr, "WARNING: No packets captured. Maybe no traffic on line.. %d\n" ,*((int*)cnt->res) ); else printf("\nRead_results : %d\n", *((int*)cnt->res)); DOT; if(mapi_close_flow(fd)<0){ fprintf(stderr,"Close flow failed\n"); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; /* * Error checking */ fd = fid = 0; if ((fd = mapi_create_offline_flow("./tracefile",MFF_PCAP))<0){ fprintf(stderr, "Could not create flow using '%s'\n", argv[1]); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if((fid=mapi_apply_function(fd, "PKT_COUNTER"))<0){ fprintf(stderr, "Could not apply PKT_COUNTER to flow %d\n", fd); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if(mapi_connect(fd)<0){ fprintf(stderr, "Connecting to flow failed %d\n", fd); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if(mapi_read_results(123,fid) ==NULL || mapi_read_results(fd,-1244655) ==NULL){ mapi_read_error( &err_no, error); printf("Testing error case2: Errorcode :%d description: %s \n" ,err_no, error); if(err_no != 6145){ printf(" Wrong ERRORCODE returned\n"); flag = 1; } } DOT; if(mapi_close_flow(fd)<0){ fprintf(stderr,"Close flow failed\n"); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; printf("\nmapi_read_results OK\n"); if(!flag) printf("\nMAPI read results Error Checking OK\n"); else printf("\nMAPI read results Error Checking :FAILED:\n"); return 0; }
int main(int argc, char *argv[]) { int fd, fd2; int err; int fid_bpf2; int fid_cnt2; int fid_to_buffer; mapi_results_t *cnt; struct mapipkt *pkt; int err_no =0 , flag=0 , ret; char error[512]; if(argc!=2) { printf("\nWrong arguments\n"); return -1; } if ((fd = mapi_create_flow(argv[1]))<0){ fprintf(stderr, "Could not create flow using '%s'\n", argv[1]); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if((fid_to_buffer = mapi_apply_function(fd, "TO_BUFFER", 0))<0){ fprintf(stderr, "Could not apply TO_BUFFER to flow %d\n", fd); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if ((fd2 = mapi_create_flow(argv[1]))<0){ fprintf(stderr, "Could not create flow using '%s'\n", argv[1]); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if((fid_bpf2 = mapi_apply_function(fd2, "BPF_FILTER", "ip src net 195.113.0.0/16 and ip dst net 147.251.0.0/16"))<0){ fprintf(stderr, "Could not apply BPF_FILTER to flow %d\n", fd); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if((fid_cnt2 = mapi_apply_function(fd2, "PKT_COUNTER"))<0){ fprintf(stderr, "Could not apply PKT_COUNTER to flow %d\n", fd); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if((err=mapi_connect(fd))<0){ fprintf(stderr, "Connecting to flow failed %d\n", fd); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if((err=mapi_connect(fd2))<0){ fprintf(stderr, "Connecting to flow failed %d\n", fd); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if(err == 0) { printf("\nConnected\n"); } else if(err == -2) { printf("\nauthorization error\n"); return -1; } else if(err == -1) { printf("\nACK error\n"); return -1; } else { printf("\nerror at mapi_connect\n"); return -1; } if ((pkt=mapi_get_next_pkt(fd, fid_to_buffer)) != NULL) printf("Got packet\n"); else printf("Error in mapi_get_next_packet\n"); cnt = mapi_read_results(fd2, fid_cnt2); DOT; if(mapi_close_flow(fd)<0){ fprintf(stderr,"Close flow failed\n"); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if(mapi_close_flow(fd2)<0){ fprintf(stderr,"Close flow failed\n"); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; printf("\nmapi_connect OK\n"); /* * Error checking */ fd = 0; if( (ret = mapi_connect(13244)) == -1){ mapi_read_error( &err_no, error); printf("\nTesting error case1: Errorcode :%d description: %s \n" ,err_no, error); if(err_no != 6145){ printf(" Wrong ERRORCODE returned\n"); flag = 1; } } DOT; fd = mapi_create_flow(argv[1]); if( (ret = mapi_connect(fd)) == -1){ mapi_read_error( &err_no, error); printf("\nERROR: Errorcode :%d description: %s \n" ,err_no, error); flag=1; } DOT; if( (ret = mapi_connect(fd)) == -1){ mapi_read_error( &err_no, error); printf("\nTesting error case2: Errorcode :%d description: %s \n" ,err_no, error); if(err_no != 3081){ printf(" Wrong ERRORCODE returned\n"); flag = 1; } } DOT; /* * Offline testing */ if ((fd = mapi_create_offline_flow("./tracefile", MFF_PCAP))<0){ fprintf(stderr, "Could not create flow using '%s'\n", argv[1]); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if((fid_to_buffer = mapi_apply_function(fd, "TO_BUFFER", 0))<0){ fprintf(stderr, "Could not apply TO_BUFFER to flow %d\n", fd); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if ((fd2 = mapi_create_flow(argv[1]))<0){ fprintf(stderr, "Could not create flow using '%s'\n", argv[1]); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if((fid_bpf2 = mapi_apply_function(fd2, "BPF_FILTER", "ip src net 195.113.0.0/16 and ip dst net 147.251.0.0/16"))<0){ fprintf(stderr, "Could not apply BPF_FILTER to flow %d\n", fd); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if((fid_cnt2 = mapi_apply_function(fd2, "PKT_COUNTER"))<0){ fprintf(stderr, "Could not apply PKT_COUNTER to flow %d\n", fd); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if((err=mapi_connect(fd))<0){ fprintf(stderr, "Connecting to flow failed %d\n", fd); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if((err=mapi_connect(fd2))<0){ fprintf(stderr, "Connecting to flow failed %d\n", fd); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if(err == 0){ printf("\nConnected\n"); } else if(err == -2){ printf("\nauthorization error\n"); return -1; } else if(err == -1){ printf("\nACK error\n"); return -1; } else { printf("\nerror at mapi_connect\n"); return -1; } if ((pkt=mapi_get_next_pkt(fd, fid_to_buffer)) != NULL) printf("Got packet\n"); else printf("Error in mapi_get_next_packet\n"); cnt = mapi_read_results(fd2, fid_cnt2); DOT; if(mapi_close_flow(fd)<0){ fprintf(stderr,"Close flow failed\n"); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if(mapi_close_flow(fd2)<0){ fprintf(stderr,"Close flow failed\n"); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; printf("\nmapi_connect OK\n"); /* * Error checking */ fd = 0; if( (ret = mapi_connect(13244)) == -1){ mapi_read_error( &err_no, error); printf("\nTesting error case1: Errorcode :%d description: %s \n" ,err_no, error); if(err_no != 6145){ printf(" Wrong ERRORCODE returned\n"); flag = 1; } } DOT; fd = mapi_create_offline_flow("./tracefile" , MFF_PCAP); if( (ret = mapi_connect(fd)) == -1){ mapi_read_error( &err_no, error); printf("\nERROR: Errorcode :%d description: %s \n" ,err_no, error); flag=1; } DOT; if( (ret = mapi_connect(fd)) == -1){ mapi_read_error( &err_no, error); printf("\nTesting error case2: Errorcode :%d description: %s \n" ,err_no, error); if(err_no != 3081){ printf(" Wrong ERRORCODE returned\n"); flag = 1; } } DOT; if(!flag) printf("\nMAPI Connect Error Checking OK\n"); else printf("\nMAPI Connect Error Checking :FAILED:\n"); return 0; }
int main(MAPI_UNUSED int argc, char *argv[]) { int size; int fd; int fid; mapi_flow_info_t info; mapi_results_t* res; stats_t *stats; int err_no =0 , flag=0; char error[512]; if(!argv[1]) { printf("\nWrong arguments\n"); return -1; } if(argc!=2){ // just for uniformity reasons fprintf(stderr, "Wrong Arguments\n"); return -1; } if ((fd = mapi_create_offline_flow("./tracefile" , MFF_PCAP))<0){ fprintf(stderr, "Could not create flow using '%s'\n", argv[1]); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if((size=mapi_apply_function(fd,"PKTINFO",PKT_SIZE))<0){ fprintf(stderr, "Could not apply PKTINFO to flow %d\n", fd); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if((fid=mapi_apply_function(fd,"STATS",fd,size,"0"))<0){ fprintf(stderr, "Could not apply STATS to flow %d\n", fd); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if(mapi_connect(fd)<0){ fprintf(stderr, "Connecting to flow failed %d\n", fd); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; do { sleep(1); mapi_get_flow_info(fd,&info); } while(info.status!=FLOW_FINISHED); res = mapi_read_results(fd,fid); stats = (stats_t*)res->res; /* * Sanity Checks */ if(stats->count!=893 || stats->sum!=283464.0 || stats->sum2!=309175572.0 || stats->min!=42.0 || stats->max!=1514) { printf("Wrong values\n"); return -1; } if(mapi_close_flow(fd)<0){ fprintf(stderr,"Close flow failed\n"); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; printf("Offline STATS OK\n"); /* * Error checking test postponed till correcting a */ if ((fd = mapi_create_offline_flow("./tracefile" , MFF_PCAP))<0){ fprintf(stderr, "Could not create flow using '%s'\n", argv[1]); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if((size=mapi_apply_function(fd,"PKTINFO",PKT_SIZE))<0){ fprintf(stderr, "Could not apply PKTINFO to flow %d\n", fd); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; fid=mapi_apply_function(fd,"STATS",1234343,size,"0"); if (fid<0){ mapi_read_error( &err_no, error); printf("Testing error case1: Errorcode :%d description: %s \n" ,err_no, error); if(err_no != 7001){ printf(" Wrong ERRORCODE returned\n"); flag = 1; } } DOT; fid=mapi_apply_function(fd,"STATS",fd,-12352,"0"); if (fid<0){ mapi_read_error( &err_no, error); printf("Testing error case2: Errorcode :%d description: %s \n" ,err_no, error); if(err_no != 7001){ printf(" Wrong ERRORCODE returned\n"); flag = 1; } } DOT; if(!flag) printf("\nTest offline stats Error Checking OK\n"); else printf("\nTest offline stats Error Checking :FAILED:\n"); if(mapi_close_flow(fd)<0){ fprintf(stderr,"Close flow failed\n"); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; return 0; }
int main(int argc, char **argv) { int port = 0; char *user = NULL; char *passwd = NULL; char *host = NULL; char *dbname = NULL; int trace = 0; int describe = 0; int functions = 0; int useinserts = 0; int c; Mapi mid; int quiet = 0; stream *out; char user_set_as_flag = 0; char *table = NULL; static struct option long_options[] = { {"host", 1, 0, 'h'}, {"port", 1, 0, 'p'}, {"database", 1, 0, 'd'}, {"describe", 0, 0, 'D'}, {"functions", 0, 0, 'f'}, {"table", 1, 0, 't'}, {"inserts", 0, 0, 'N'}, {"Xdebug", 0, 0, 'X'}, {"user", 1, 0, 'u'}, {"quiet", 0, 0, 'q'}, {"help", 0, 0, '?'}, {0, 0, 0, 0} }; parse_dotmonetdb(&user, &passwd, NULL, NULL, NULL, NULL); while ((c = getopt_long(argc, argv, "h:p:d:Dft:NXu:q?", long_options, NULL)) != -1) { switch (c) { case 'u': if (user) free(user); user = strdup(optarg); user_set_as_flag = 1; break; case 'h': host = optarg; break; case 'p': assert(optarg != NULL); port = atoi(optarg); break; case 'd': dbname = optarg; break; case 'D': describe = 1; break; case 'N': useinserts = 1; break; case 'f': if (table) usage(argv[0], -1); functions = 1; break; case 't': if (table || functions) usage(argv[0], -1); table = optarg; break; case 'q': quiet = 1; break; case 'X': trace = MAPI_TRACE; break; case '?': /* a bit of a hack: look at the option that the current `c' is based on and see if we recognize it: if -? or --help, exit with 0, else with -1 */ usage(argv[0], strcmp(argv[optind - 1], "-?") == 0 || strcmp(argv[optind - 1], "--help") == 0 ? 0 : -1); default: usage(argv[0], -1); } } if (optind == argc - 1) dbname = argv[optind]; else if (optind != argc) usage(argv[0], -1); /* when config file would provide defaults */ if (user_set_as_flag) passwd = NULL; if (user == NULL) user = simple_prompt("user", BUFSIZ, 1, prompt_getlogin()); if (passwd == NULL) passwd = simple_prompt("password", BUFSIZ, 0, NULL); mid = mapi_connect(host, port, user, passwd, "sql", dbname); if (user) free(user); if (passwd) free(passwd); if (mid == NULL) { fprintf(stderr, "failed to allocate Mapi structure\n"); exit(2); } if (mapi_error(mid)) { mapi_explain(mid, stderr); exit(2); } if (!quiet) { char *motd = mapi_get_motd(mid); if (motd) fprintf(stderr, "%s", motd); } mapi_trace(mid, trace); mapi_cache_limit(mid, 10000); out = file_wastream(stdout, "stdout"); if (out == NULL) { fprintf(stderr, "failed to allocate stream\n"); exit(2); } if (!quiet) { char buf[27]; time_t t = time(0); char *p; #ifdef HAVE_CTIME_R3 ctime_r(&t, buf, sizeof(buf)); #else #ifdef HAVE_CTIME_R ctime_r(&t, buf); #else strncpy(buf, ctime(&t), sizeof(buf)); #endif #endif if ((p = strrchr(buf, '\n')) != NULL) *p = 0; mnstr_printf(out, "-- msqldump %s %s%s %s\n", describe ? "describe" : "dump", functions ? "functions" : table ? "table " : "database", table ? table : "", buf); dump_version(mid, out, "--"); } if (functions) c = dump_functions(mid, out, NULL, NULL); else if (table) c = dump_table(mid, NULL, table, out, describe, 1, useinserts); else c = dump_database(mid, out, describe, useinserts); mnstr_flush(out); mapi_destroy(mid); if (mnstr_errnr(out)) { fprintf(stderr, "%s: %s", argv[0], mnstr_error(out)); return 1; } mnstr_destroy(out); return c; }
int main(MAPI_UNUSED int argc, char *argv[]) { int fd, ok; mapi_flow_info_t info; int err_no =0 , flag=0; char error[512]; if(!argv[1]) { printf("\nwrong arguments\n"); return -1; } if ((fd = mapi_create_flow(argv[1]))<0){ fprintf(stderr, "Could not create flow using '%s'\n", argv[1]); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if((ok = mapi_apply_function(fd, "PKT_COUNTER"))<0){ fprintf(stderr,"Could not apply function PKT_COUNTER\n"); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if((ok = mapi_apply_function(fd, "BYTE_COUNTER"))<0){ fprintf(stderr,"Could not apply function BYTE_COUNTER\n"); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if((ok = mapi_apply_function(fd, "PKT_COUNTER"))<0){ fprintf(stderr,"Could not apply function PKT_COUNTER\n"); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if((ok = mapi_apply_function(fd, "BYTE_COUNTER"))<0){ fprintf(stderr,"Could not apply function BYTE_COUNTER\n"); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if((ok = mapi_apply_function(fd, "PKT_COUNTER"))<0){ fprintf(stderr,"Could not apply function PKT_COUNTER\n"); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if((ok = mapi_apply_function(fd, "BYTE_COUNTER"))<0){ fprintf(stderr,"Could not apply function BYTE_COUNTER\n"); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if((ok = mapi_apply_function(fd, "PKT_COUNTER"))<0){ fprintf(stderr,"Could not apply function PKT_COUNTER\n"); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if((ok = mapi_apply_function(fd, "BYTE_COUNTER"))<0){ fprintf(stderr,"Could not apply function BYTE_COUNTER\n"); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if((ok = mapi_apply_function(fd, "PKT_COUNTER"))<0){ fprintf(stderr,"Could not apply function PKT_COUNTER\n"); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if((ok = mapi_apply_function(fd, "BYTE_COUNTER"))<0){ fprintf(stderr,"Could not apply function BYTE_COUNTER\n"); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if(mapi_connect(fd)<0){ fprintf(stderr, "Connecting to flow failed %d\n", fd); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if((ok = mapi_get_flow_info(fd, &info))<0){ fprintf(stderr, "Getting flow info failed on fd:%d\n", fd); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; printf("\nflow info : "); printf("\n\t uid = %d", info.uid); printf("\n\t device = %s", info.device); printf("\n\t num_functions: %u", info.num_functions); printf("\n\t start = %lu", info.start); printf("\n\t end = %lu", info.end); printf("\n"); /* * Sanity checks */ if(info.num_functions != 10){ fprintf(stderr, "WARNING: Sanity check failed %d functions found\n" , info.num_functions); } if(mapi_close_flow(fd)<0){ fprintf(stderr,"Close flow failed\n"); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; /* * Wrong argument error checking */ fd =0; if(mapi_get_flow_info(fd, &info)<0){ mapi_read_error( &err_no, error); printf("Testing error case0. Errorcode :%d description: %s \n" ,err_no, error); if(err_no != 6145){ printf(" Wrong ERRORCODE returned\n"); flag = 1; } } DOT; if ((fd = mapi_create_flow(argv[1]))<0){ fprintf(stderr, "Could not create flow using '%s'\n", argv[1]); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if(mapi_get_flow_info(fd, NULL)<0){ mapi_read_error( &err_no, error); printf("Testing error case1. Errorcode :%d description: %s \n" ,err_no, error); if(err_no != 7002){ printf(" Wrong ERRORCODE returned\n"); flag = 1; } } DOT; if(mapi_get_flow_info(12345, &info)<0){ mapi_read_error( &err_no, error); printf("Testing error case2. Errorcode :%d description: %s \n" ,err_no, error); if(err_no != 6145){ printf(" Wrong ERRORCODE returned\n"); flag = 1; } } DOT; if ((fd = mapi_create_offline_flow("./tracefile" , MFF_PCAP))<0){ fprintf(stderr, "Could not create flow using '%s'\n", argv[1]); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if((ok = mapi_apply_function(fd, "PKT_COUNTER"))<0){ fprintf(stderr,"Could not apply function PKT_COUNTER\n"); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if((ok = mapi_apply_function(fd, "BYTE_COUNTER"))<0){ fprintf(stderr,"Could not apply function BYTE_COUNTER\n"); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if((ok = mapi_apply_function(fd, "PKT_COUNTER"))<0){ fprintf(stderr,"Could not apply function PKT_COUNTER\n"); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if((ok = mapi_apply_function(fd, "BYTE_COUNTER"))<0){ fprintf(stderr,"Could not apply function BYTE_COUNTER\n"); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if(mapi_connect(fd)<0){ fprintf(stderr, "Connecting to flow failed %d\n", fd); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } info.num_functions=0; DOT; if((ok = mapi_get_flow_info(fd, &info))<0){ fprintf(stderr, "Getting flow info failed on fd:%d\n", fd); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; /* * Sanity checks */ if(info.num_functions != 4){ fprintf(stderr, "WARNING: Sanity check failed %d functions found\n" , info.num_functions); } if(mapi_close_flow(fd)<0){ fprintf(stderr,"Close flow failed\n"); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if(!flag) printf("\nGet Flow Info Error Checking OK\n"); else printf("\nGet Flow Info Error Checking :FAILED:\n"); return 0; }
int main(int argc, char *argv[]) { configuration_t configuration; int i, j; struct timeval tm; struct timezone tz; measurement_t *measurement; struct timeval next, wait; int subject_id, flow_id; unsigned long long packets, bytes; double mbps; char command[MAX_COMMAND+1]; char hostname_interface[MAX_HOSTNAME_INTERFACE+1]; /* DiMAPI connect string as "hostname:interface,..." */ struct timeval tv_start, tv_stop; /* to measure how fast mapi_read_result() responds */ int tv_diff_pkt, tv_diff_byte; /* time used by mapi_read_results() */ int tv_diff_threshold; /* 1 if threshold was reached */ mapi_results_t *pkt_counter_res; mapi_results_t *byte_counter_res; unsigned long long pkt_counter; unsigned long long byte_counter; int scope_size; double pkt_sec; /* seconds from previous packet result */ double byte_sec; /* seconds from previous byte result */ mapi_flow_info_t info; mapi_device_info_t dinfo; openlog("abw", LOG_PID, LOG_LOCAL0); syslog(LOG_DEBUG, "starting abw"); memset((void *)&configuration, 0, (size_t)(sizeof(configuration))); /* Create global configuration */ if ((configuration.global=malloc(sizeof(global_t)))==NULL) { fprintf(stderr, "%s: malloc() failed\n", __func__); return -1; } memset(configuration.global, 0, sizeof(global_t)); /* Create first subject, scope, parameters and measurement so that they can be filled-in by command-line options */ /* if ((configuration.subject=new_subject())==NULL) { fprintf(stderr, "%s: new_subject() failed\n", __func__); return -1; } if ((configuration.scope=new_scope())==NULL) { fprintf(stderr, "%s: new_subject() failed\n", __func__); return -1; } if ((configuration.parameters=new_parameters())==NULL) { fprintf(stderr, "%s: new_parameters() failed\n", __func__); return -1; } if ((configuration.measurement=new_measurement())==NULL) { fprintf(stderr, "%s: new_measurement() failed\n", __func__); return -1; } */ /* Read command line */ if (read_command_line(argc, argv, &configuration)<0) { fprintf(stderr, "%s: read_command_line() failed\n", __func__); return -1; } /* Read configuration file */ if (configuration.global->conf_filename) { if (read_conf_file(&configuration)<0) { fprintf(stderr, "%s: read_conf_file() failed\n", __func__); return -1; } } /* Fill-in local hostname */ if (get_local_hostname(&(configuration.global->hostname))<0) { fprintf(stderr, "%s: get_local_hostname() failed\n", __func__); return -1; } /* Check if specified values are within acceptable limits */ if (check_conf(&configuration)<0) { fprintf(stderr, "%s: check_conf() failed\n", __func__); exit(-1); } /* Print configuration */ if (debug) print_conf(&configuration); if (daemonize) { printf("Switching to daemon\n"); if (continue_as_daemon()<0) { fprintf(stderr, "%s: continue_as_daemon() failed\n", __func__); return -1; } printf("Continuing as daemon\n"); } /* * Create RRD files */ /* Go over all measurements */ measurement=configuration.measurement; while (measurement) { int parameters_id; char *filename; parameters_id = measurement->parameters_id; /* Go over all protocols */ j=0; while (protocols[j].protocol) { if ((filename= abw_rrd_create_filename(measurement->scope, parameters_id, protocols[j].protocol))==NULL) { fprintf(stderr, "%s: rrd_create_filename() failed\n", __func__); return -1; } if (abw_rrd_create_file(filename)<0) { fprintf(stderr, "%s: abw_rrd_create_file() failed\n", __func__); return -1; } j++; } /* Go over all protocols */ /* Go over all tracked protocols */ j=0; while (tracked_protocols[j].protocol) { if ((filename= abw_rrd_create_filename(measurement->scope, parameters_id, tracked_protocols[j].protocol))==NULL) { fprintf(stderr, "%s: rrd_create_filename() failed\n", __func__); return -1; } if (abw_rrd_create_file(filename)<0) { fprintf(stderr, "%s: abw_rrd_create_file() failed\n", __func__); return -1; } j++; } /* Go over all tracked protocols */ /* Create RRD file for "all" protocol (all traffic together) */ if ((filename= abw_rrd_create_filename(measurement->scope, parameters_id, "all"))==NULL) { fprintf(stderr, "%s: rrd_create_filename() failed\n", __func__); return -1; } if (abw_rrd_create_file(filename)<0) { fprintf(stderr, "%s: abw_rrd_create_file() failed\n", __func__); return -1; } measurement=measurement->next; } /* while (measurement) */ /* * Create MAPI flows */ flow_id=0; /* Go over all measurements */ measurement=configuration.measurement; while (measurement) { /* Go over all monitored protocols */ i=0; while (measurement->protocols_array[i] && i<MAX_PROTOCOLS) { int parameters_id; char *protocol; /* Create data structure to maintain MAPI information */ if (flow_id>=MAX_FLOWS) { fprintf(stderr, "%s: more than %d flows requested\n", __func__, MAX_FLOWS); return -1; } if ((flow[flow_id]=new_flow())==NULL) { fprintf(stderr, "%s: new_flow() failed\n", __func__); return -1; } flow[flow_id]->measurement=measurement; flow[flow_id]->protocol=measurement->protocols_array[i]; parameters_id = measurement->parameters_id; protocol = measurement->protocols_array[i]; if ((flow[flow_id]->rrd_filename= abw_rrd_create_filename(measurement->scope, parameters_id, protocol))==NULL) { fprintf(stderr, "%s: rrd_create_filename() failed\n", __func__); return -1; } /* * If scope has only one subject and if hostname is "localhost" or * equal to local hostname, then use MAPI connect string (not DiMAPI) */ if (!(measurement->scope->subject[1]) && (!strcmp(measurement->scope->subject[0]->hostname, "localhost") || !strcmp(measurement->scope->subject[0]->hostname, configuration.global->hostname))) strcpy(hostname_interface, measurement->scope->subject[0]->interface); /* * Prepare DiMAPI connect string as hostname:interface, ... */ else { j=0; hostname_interface[0]='\0'; while (measurement->scope->subject[j] && j<MAX_SUBJECTS) { /* Append comma "," */ if (hostname_interface[0]) { if (strlen(hostname_interface)+1>=MAX_HOSTNAME_INTERFACE) { fprintf(stderr, "%s: DiMAPI connect string is longer than %d characters\n", __func__, MAX_HOSTNAME_INTERFACE); return -1; } strcat(hostname_interface, ","); } /* Append next hostname:interface */ if (strlen(hostname_interface) + strlen(measurement->scope->subject[j]->hostname) + strlen(measurement->scope->subject[j]->interface) >= MAX_HOSTNAME_INTERFACE) { fprintf(stderr, "%s: DiMAPI connect string is longer than %d characters\n", __func__, MAX_HOSTNAME_INTERFACE); return -1; } sprintf(hostname_interface + strlen(hostname_interface), "%s:%s", measurement->scope->subject[j]->hostname, measurement->scope->subject[j]->interface); j++; } /* while (measurement->scope->subject[j] && j<MAX_SUBJECTS) */ } /* Creating DiMAPI connect string */ /* Create a new MAPI flow */ if (debug) printf("%s: mapi_create_flow(%s)\n", __func__, hostname_interface); if ((flow[flow_id]->fd=mapi_create_flow(hostname_interface))<0) { fprintf(stderr, "%s: mapi_create_flow(%s) failed\n", __func__, hostname_interface); fprintf(stderr, "%s: Do you run mapid daemon on the machine where you connect to?\n", __func__); fprintf(stderr, "%s: Do you run mapicommd daemon on the machine where you connect to? (if you are connecting to a non-local machine or to multiple machines)\n", __func__); return -1; } /* If this is a MAPI flow (not DiMAPI flow), then set MPLS and VLAN flags according to mapi.conf. Otherwise the flags were set in abw.conf */ if (!strchr(hostname_interface, ':')) { if (debug) printf("%s: MAPI flow on \"%s\", setting MPLS and VLAN flags from mapi.conf\n", __func__, hostname_interface); if ((mapi_get_flow_info(flow[flow_id]->fd, &info)) < 0){ fprintf(stderr, "%s: mapi_get_flow_info() failed\n", __func__); return -1; } if ((mapi_get_device_info(info.devid, &dinfo)) < 0) { fprintf(stderr, "%s: mapi_get_device_info() failed\n", __func__); return -1; } measurement->scope->mpls = dinfo.mpls; measurement->scope->vlan = dinfo.vlan; } else if (debug) printf("%s: DiMAPI flow on \"%s\", setting MPLS and VLAN flags from abw.conf\n", __func__, hostname_interface); /* Prepare header filter for this protocol */ if ((flow[flow_id]->tracked_protocol= protocol_filter(measurement->parameters->header_filter, flow[flow_id]->protocol, measurement->scope->mpls, measurement->scope->vlan, &(flow[flow_id]->header_filter)))<0) { fprintf(stderr, "%s: protocol_filter() failed\n", __func__); return -1; } if (debug) printf("measurement->parameters->header_filter: %s, flow[flow_id]->protocol: %s, flow[flow_id]->header_filter: %s, track_function: %s\n", (measurement->parameters->header_filter)?measurement->parameters->header_filter:"NULL", flow[flow_id]->protocol, (flow[flow_id]->header_filter)?flow[flow_id]->header_filter:"NULL", (flow[flow_id]->tracked_protocol)?tracked_protocols[flow[flow_id]->tracked_protocol-1].track_function:"none"); /* Filter based on input port, we can use port number in the first subject of the scope, because all subjects in a scope must have the same port number */ if (measurement->scope->subject[0]->port >= 0) { if ((flow[flow_id]->interface_fid=mapi_apply_function(flow[flow_id]->fd, "INTERFACE", measurement->scope->subject[0]->port))<0) { fprintf(stderr, "%s: INTERFACE failed\n", __func__); return -1; } } /* Note that BPF_FILTER uses compiled header filter that selects packets of the given protocol */ /* BPF_FILTER is applied if a) header_filter was specified in [parameters] section or b) protocol other than "all" and other than some that requires tracking was specified in [parameters] section or c) MPLS is used on links in this [scope] */ if (flow[flow_id]->header_filter) { if (debug) printf("%s: mapi_apply_function(%d, BPF_FILTER, \"%s\")\n", __func__, flow[flow_id]->fd, flow[flow_id]->header_filter); if ((flow[flow_id]->bpf_filter_fid= mapi_apply_function(flow[flow_id]->fd, "BPF_FILTER", flow[flow_id]->header_filter))<0) { fprintf(stderr, "%s: BPF_FILTER (\"%s\") failed\n", __func__, flow[flow_id]->header_filter); return -1; } } /* Track application protocol, BPF_FILTER could have been applied before */ if (flow[flow_id]->tracked_protocol) { if (debug) printf("%s: mapi_apply_function(%d, %s)\n", __func__, flow[flow_id]->fd, tracked_protocols[flow[flow_id]->tracked_protocol-1]. track_function); if ((flow[flow_id]->track_function_fid= mapi_apply_function(flow[flow_id]->fd, tracked_protocols[flow[flow_id]->tracked_protocol-1]. track_function))<0) { fprintf(stderr, "%s: tracking (%s) failed\n", __func__, tracked_protocols[flow[flow_id]->tracked_protocol-1]. track_function); return -1; } } /* Sampling */ if (measurement->parameters->sau_mode == 'd' && (unsigned int)(measurement->parameters->sau_threshold) != 1) { if ((flow[flow_id]->sample_fid= mapi_apply_function(flow[flow_id]->fd, "SAMPLE", measurement->parameters->sau_threshold, PERIODIC))<0) { fprintf(stderr, "%s: SAMPLE (PERIODIC, %.02f) failed\n", __func__, measurement->parameters->sau_threshold); return -1; } } else if (measurement->parameters->sau_mode == 'p' && (unsigned int)(measurement->parameters->sau_threshold) != 1) { if ((flow[flow_id]->sample_fid= mapi_apply_function(flow[flow_id]->fd, "SAMPLE", (measurement->parameters->sau_threshold)*100, PROBABILISTIC))<0) { fprintf(stderr, "%s: SAMPLE (PROBABILISTIC, %.02f) failed\n", __func__, (measurement->parameters->sau_threshold)*100); return -1; } } /* Payload searching */ if (measurement->parameters->payload_strings[0]) { if ((flow[flow_id]->str_search_fid= mapi_apply_function(flow[flow_id]->fd, "STR_SEARCH", measurement->parameters->payload_strings[0], 0, 0))<0) { fprintf(stderr, "%s: STR_SEARCH (%s) failed\n", __func__, measurement->parameters->payload_strings[0]); return -1; } } /* Counting packets and bytes */ if ((flow[flow_id]->pkt_counter_fid= mapi_apply_function(flow[flow_id]->fd, "PKT_COUNTER"))<0) { fprintf(stderr, "%s: PKT_COUNTER failed\n", __func__); return -1; } /* Simultaneous use of PKT_COUNTER and BYTE_COUNTER does not work with DAG4.3GE. Temporary hack: always use stflib version */ if ((flow[flow_id]->byte_counter_fid= mapi_apply_function(flow[flow_id]->fd, "stdflib:BYTE_COUNTER"))<0) { fprintf(stderr, "%s: BYTE_COUNTER failed\n", __func__); return -1; } /* Connect to flow */ if (!configuration.global->no_measure) { if (mapi_connect(flow[flow_id]->fd)<0) { fprintf(stderr, "%s: mapi_connect() (%s) failed\n", __func__, hostname_interface); return -1; } if ((scope_size=mapi_get_scope_size(flow[flow_id]->fd)) != flow[flow_id]->measurement->scope->subject_no) { fprintf(stderr, "%s: mapi_get_scope_size() returned %d for %d subjects\n", __func__, scope_size, flow[flow_id]->measurement->scope->subject_no); return -1; } } i++; flow_id++; } /* while (measurement->protocols_array[i] && i<MAX_PROTOCOLS) */ measurement=measurement->next; } /* while (measurement) */ if (configuration.global->no_measure || !configuration.measurement) return 0; /* Periodically get results from MAPI flows */ while (1) { if (gettimeofday(&tm, &tz)<0) { fprintf(stderr, "%s: gettimeofday() failed\n", __func__); return -1; } flow_id=0; while (flow[flow_id] && flow_id<MAX_FLOWS) { int scope_packets, scope_bytes; if (!configuration.global->no_stdout) { printf("%d %u.%u", flow[flow_id]->measurement->scope->id, (unsigned int)(tm.tv_sec), (unsigned int)(tm.tv_usec)); if (!configuration.global->stdout_simple) printf(" %s\n", flow[flow_id]->protocol); } gettimeofday(&tv_start, NULL); if ((pkt_counter_res=mapi_read_results(flow[flow_id]->fd, flow[flow_id]->pkt_counter_fid))==NULL) { fprintf(stderr, "%s: mapi_read_results() for flow %d failed\n", __func__, flow_id); return -1; } gettimeofday(&tv_stop, NULL); tv_diff_pkt=timestamp_diff(&tv_start, &tv_stop); gettimeofday(&tv_start, NULL); if ((byte_counter_res=mapi_read_results(flow[flow_id]->fd, flow[flow_id]->byte_counter_fid))==NULL) { fprintf(stderr, "%s: mapi_read_results() for flow %d failed\n", __func__, flow_id); return -1; } gettimeofday(&tv_stop, NULL); tv_diff_byte=timestamp_diff(&tv_start, &tv_stop); if (tv_diff_pkt>=TV_DIFF_THRESHOLD || tv_diff_byte>=TV_DIFF_THRESHOLD) tv_diff_threshold=1; else tv_diff_threshold=0; if (tv_diff_pkt>=TV_DIFF_THRESHOLD) syslog(LOG_DEBUG, "mapi_read_result() for PKT_COUNTER takes %d us for measurement ID %d and protocol %s (threshold %d us reached)", tv_diff_pkt, flow[flow_id]->measurement->id, flow[flow_id]->protocol, TV_DIFF_THRESHOLD); if (tv_diff_byte>=TV_DIFF_THRESHOLD) syslog(LOG_DEBUG, "mapi_read_result() for BYTE_COUNTER takes %d us for measurement ID %d and protocol %s (threshold %d us reached)", tv_diff_byte, flow[flow_id]->measurement->id, flow[flow_id]->protocol, TV_DIFF_THRESHOLD); scope_size = flow[flow_id]->measurement->scope->subject_no; scope_packets=0; scope_bytes=0; for (subject_id=0; subject_id<scope_size; subject_id++) { pkt_counter= *((unsigned long long*)(pkt_counter_res[subject_id].res)); byte_counter= *((unsigned long long*)(byte_counter_res[subject_id].res)); packets=pkt_counter - flow[flow_id]->pkt_counter[subject_id]; bytes=byte_counter - flow[flow_id]->byte_counter[subject_id]; mbps=(double)bytes*8/1000000; flow[flow_id]->pkt_counter[subject_id]=pkt_counter; flow[flow_id]->byte_counter[subject_id]=byte_counter; /* Determine seconds from previous result */ if (flow[flow_id]->pkt_ts[subject_id]) pkt_sec=(double)(pkt_counter_res[subject_id].ts - flow[flow_id]->pkt_ts[subject_id])/1000000; else pkt_sec= flow[flow_id]->measurement->parameters->interval.tv_sec + (double)(flow[flow_id]->measurement->parameters->interval.tv_usec)/1000000; if (flow[flow_id]->byte_ts[subject_id]) byte_sec=(double)(byte_counter_res[subject_id].ts - flow[flow_id]->byte_ts[subject_id])/1000000; else byte_sec= flow[flow_id]->measurement->parameters->interval.tv_sec + (double)(flow[flow_id]->measurement->parameters->interval.tv_usec)/1000000; scope_packets+=(packets/pkt_sec); scope_bytes+=(bytes/byte_sec); flow[flow_id]->pkt_ts[subject_id]= pkt_counter_res[subject_id].ts; flow[flow_id]->byte_ts[subject_id]= byte_counter_res[subject_id].ts; if (tv_diff_threshold) { syslog(LOG_DEBUG, "%s:%s: %.02f seconds from previous result", flow[flow_id]->measurement->scope->subject[subject_id]->hostname, flow[flow_id]->measurement->scope->subject[subject_id]->interface, byte_sec); } /* Print result */ if (!configuration.global->no_stdout) { if (configuration.global->stdout_simple) printf(" %0.2f %0.2f %0.2f", packets/pkt_sec, bytes/byte_sec, mbps/byte_sec); else printf(" %0.2f packets/s, %0.2f bytes/s, %0.2f Mb/s, time %uus/%uus, interval %0.2fs/%0.2fs\n", packets/pkt_sec, bytes/byte_sec, mbps/byte_sec, tv_diff_pkt, tv_diff_byte, pkt_sec, byte_sec); } } /* for (subject_id=0; subject_id++; subject_id<scope_size) */ if (!configuration.global->no_stdout) printf("\n"); /* If interval is at least 1 second, then store results to RRD file */ if (flow[flow_id]->measurement->parameters->interval.tv_sec) { sprintf(command, "rrdtool update %s %u:%lu:%lu:%.6f", flow[flow_id]->rrd_filename, (unsigned int)(tm.tv_sec), (unsigned long)(scope_packets), (unsigned long)(scope_bytes), (double)scope_bytes*8/1000000); if (configuration.global->debug > 1) syslog(LOG_DEBUG, "system(%s)", command); if (tm.tv_sec == flow[flow_id]->rrd_ts) syslog(LOG_ERR, "duplicate RRD timestamp %u for scope %d\n", (unsigned int)(tm.tv_sec), flow[flow_id]->measurement->scope->id); else flow[flow_id]->rrd_ts=tm.tv_sec; if (debug) printf("%s: system(%s)\n", __func__, command); if (system(command)<0) { fprintf(stderr, "%s: command(%s) failed\n", __func__, command); return -1; } } flow_id++; } /* while (flow[flow_id] && flow_id<MAX_FLOWS) */ abw_next_timestamp(&(configuration.measurement->parameters->interval), &next, &wait); if (!configuration.global->no_stdout && !configuration.global->stdout_simple) { printf("next.tv_sec: %d, next.tv_usec: %d, wait.tv_sec: %d, wait.tv_usec: %d\n", (int)(next.tv_sec), (int)(next.tv_usec), (int)(wait.tv_sec), (int)(wait.tv_usec)); printf("===============================================================================\n"); } usleep(wait.tv_sec * 1000000 + wait.tv_usec); } /* while (1) */ return 0; } /* main() */
int main(int argc, char **argv) { Mapi dbh; MapiHdl hdl = NULL; mapi_int64 rows, i; char *parm[] = { "peter", 0 }; char *parm2[] = { "25", 0 }; int j; if (argc != 4) { printf("usage:%s <host> <port> <language>\n", argv[0]); exit(-1); } dbh = mapi_connect(argv[1], atoi(argv[2]), "monetdb", "monetdb", argv[3], NULL); if (dbh == NULL || mapi_error(dbh)) die(dbh, hdl); /* mapi_trace(dbh, 1); */ if (strcmp(argv[3], "sql") == 0) { /* switch of autocommit */ if (mapi_setAutocommit(dbh, 0) != MOK || mapi_error(dbh)) die(dbh,NULL); if ((hdl = mapi_query(dbh, "create table emp(name varchar(20), age int)")) == NULL || mapi_error(dbh)) die(dbh, hdl); if (mapi_close_handle(hdl) != MOK) die(dbh, hdl); if ((hdl = mapi_query(dbh, "insert into emp values('John', 23)")) == NULL || mapi_error(dbh)) die(dbh, hdl); if (mapi_close_handle(hdl) != MOK) die(dbh, hdl); if ((hdl = mapi_query(dbh, "insert into emp values('Mary', 22)")) == NULL || mapi_error(dbh)) die(dbh, hdl); if (mapi_close_handle(hdl) != MOK) die(dbh, hdl); if ((hdl = mapi_query(dbh, "select * from emp")) == NULL || mapi_error(dbh)) die(dbh, hdl); } else if (strcmp(argv[3], "mal") == 0) { if ((hdl = mapi_query(dbh, "emp := bat.new(:oid,:str);")) == NULL || mapi_error(dbh)) die(dbh, hdl); if ((hdl = mapi_query(dbh, "age := bat.new(:oid,:int);")) == NULL || mapi_error(dbh)) die(dbh, hdl); if (mapi_close_handle(hdl) != MOK) die(dbh, hdl); if ((hdl = mapi_query_array(dbh, "bat.append(emp,\"?\");", parm)) == NULL || mapi_error(dbh)) die(dbh, hdl); if ((hdl = mapi_query_array(dbh, "bat.append(age,?);", parm2)) == NULL || mapi_error(dbh)) die(dbh, hdl); if (mapi_close_handle(hdl) != MOK) die(dbh, hdl); if ((hdl = mapi_query(dbh, "io.print(emp,age);")) == NULL || mapi_error(dbh)) die(dbh, hdl); } else { fprintf(stderr, "%s: unknown language, only mal and sql supported\n", argv[0]); exit(1); } /* Retrieve all tuples in the client cache first */ rows = mapi_fetch_all_rows(hdl); if (mapi_error(dbh)) die(dbh, hdl); printf("rows received " LLFMT " with %d fields\n", rows, mapi_get_field_count(hdl)); /* Interpret the cache as a two-dimensional array */ for (i = 0; i < rows; i++) { if (mapi_seek_row(hdl, i, MAPI_SEEK_SET) || mapi_fetch_row(hdl) == 0) break; for (j = 0; j < mapi_get_field_count(hdl); j++) { printf("%s=%s ", mapi_get_name(hdl, j), mapi_fetch_field(hdl, j)); } printf("\n"); } if (mapi_error(dbh)) die(dbh, hdl); if (mapi_close_handle(hdl) != MOK) die(dbh, hdl); mapi_destroy(dbh); return 0; }
int main(int argc, char **argv) { /* a parameter binding test */ char *nme = 0; int age = 0; char *parm[] = { "peter", 0 }; char *parm2[] = { "25", 0 }; char *parm3[] = { "peter", "25", 0 }; Mapi dbh= NULL; MapiHdl hdl = NULL; if (argc != 4) { printf("usage:%s <host> <port> <language>\n", argv[0]); exit(-1); } dbh = mapi_connect(argv[1], atoi(argv[2]), "monetdb", "monetdb", argv[3], NULL); if (dbh == NULL || mapi_error(dbh)) die(dbh, hdl); /* mapi_trace(dbh,1); */ if (strcmp(argv[3], "sql") == 0) { /* switch of autocommit */ if (mapi_setAutocommit(dbh, 0) != MOK || mapi_error(dbh)) die(dbh,NULL); if ((hdl = mapi_query(dbh, "create table emp(name varchar(20), age int)")) == NULL || mapi_error(dbh)) die(dbh, hdl); if (mapi_close_handle(hdl) != MOK) die(dbh, hdl); if ((hdl = mapi_query_array(dbh, "insert into emp values('?', ?)", parm3)) == NULL || mapi_error(dbh)) die(dbh, hdl); if (mapi_close_handle(hdl) != MOK) die(dbh, hdl); if ((hdl = mapi_query(dbh, "select * from emp")) == NULL || mapi_error(dbh)) die(dbh, hdl); if (mapi_bind(hdl, 0, &nme)) die(dbh, hdl); if (mapi_bind_var(hdl, 1, MAPI_INT, &age)) die(dbh, hdl); while (mapi_fetch_row(hdl)) { printf("%s is %d\n", nme, age); } } else if (strcmp(argv[3], "mal") == 0) { if ((hdl = mapi_query(dbh, "emp := bat.new(:oid,:str);")) == NULL || mapi_error(dbh)) die(dbh, hdl); if ((hdl = mapi_query(dbh, "age := bat.new(:oid,:int);")) == NULL || mapi_error(dbh)) die(dbh, hdl); if (mapi_close_handle(hdl) != MOK) die(dbh, hdl); if ((hdl = mapi_query_array(dbh, "bat.append(emp,\"?\");", parm)) == NULL || mapi_error(dbh)) die(dbh, hdl); if ((hdl = mapi_query_array(dbh, "bat.append(age,?);", parm2)) == NULL || mapi_error(dbh)) die(dbh, hdl); if (mapi_close_handle(hdl) != MOK) die(dbh, hdl); if ((hdl = mapi_query(dbh, "io.print(emp,age);")) == NULL || mapi_error(dbh)) die(dbh, hdl); if (mapi_bind(hdl, 1, &nme)) die(dbh, hdl); if (mapi_bind_var(hdl, 2, MAPI_INT, &age)) die(dbh, hdl); while (mapi_fetch_row(hdl)) { printf("%s is %d\n", nme, age); } } else { fprintf(stderr, "%s: unknown language, only mal and sql supported\n", argv[0]); exit(1); } if (mapi_error(dbh)) die(dbh, hdl); if (mapi_close_handle(hdl) != MOK) die(dbh, hdl); mapi_destroy(dbh); return 0; }
int main(int argc, char *argv[]) { int fd; int fid, fidc, fids; mapi_results_t *cntc, *cnts; int err_no =0, flag=0; char error[512]; mapi_flow_info_t info; if(argc != 2) { printf("Usage: %s <interface> \n", argv[0]); return -1; } if( (fd = mapi_create_flow(argv[1])) < 0) { fprintf(stderr, "Could not create flow using '%s'\n", argv[1]); mapi_read_error(&err_no, error); fprintf(stderr, "Errorcode :%d description: %s \n", err_no, error); return -1; } DOT; if( (fidc = mapi_apply_function(fd, "PKT_COUNTER")) < 0) { fprintf(stderr, "Could not apply PKT_COUNTER to flow %d\n", fd); mapi_read_error(&err_no, error); fprintf(stderr, "Errorcode :%d description: %s \n", err_no, error); return -1; } DOT; if( (fid = mapi_apply_function(fd, "REGEXP", "HTTP.*OK")) < 0) { fprintf(stderr, "Could not apply REGEXP to flow %d\n", fd); mapi_read_error(&err_no, error); fprintf(stderr, "Errorcode :%d description: %s \n", err_no, error); return -1; } DOT; if( (fids = mapi_apply_function(fd, "PKT_COUNTER")) < 0) { fprintf(stderr, "Could not apply PKT_COUNTER to flow %d\n", fd); mapi_read_error(&err_no, error); fprintf(stderr, "Errorcode :%d description: %s \n", err_no, error); return -1; } DOT; if(mapi_connect(fd) < 0) { fprintf(stderr, "Connecting to flow failed %d\n", fd); mapi_read_error(&err_no, error); fprintf(stderr, "Errorcode :%d description: %s \n", err_no, error); return -1; } DOT; /* * Sanity checks */ sleep(5); cntc = mapi_read_results(fd, fidc); DOT; cnts = mapi_read_results(fd, fids); DOT; printf("\n\nPackets read: %d\t Packets matched : %d", *((int*)cntc->res), *((int*)cnts->res)); if (*((int*)cntc->res) <= *((int*)cnts->res)) fprintf(stderr,"\nWARNING: REGXEP failed\n"); else printf("\nREGEXP OK\n\n"); if(mapi_close_flow(fd) < 0) { fprintf(stderr, "Close flow failed\n"); mapi_read_error(&err_no, error); fprintf(stderr, "Errorcode :%d description: %s \n", err_no, error); return -1; } DOT; /* *Error Checking */ if ( (fd = mapi_create_flow(argv[1])) < 0) { fprintf(stderr, "Could not create flow using '%s'\n", argv[1]); mapi_read_error(&err_no, error); fprintf(stderr, "Errorcode :%d description: %s \n", err_no, error); return -1; } DOT; if( (fid = mapi_apply_function(fd, "REGEXP", "*)!@#@!##############@$#@@@@@@@@@@@@@@@@^^^^^^^^^^^^^^^^^^^#$$^^^^^^^^^^^^ \ $#!!!!!!!!!!!!!!!!!!!!!!#$^^^^^^^^^^^^^^%%%%%%%%&&&&&&&&&&&&&&%%%%%%%%%%%%%% \ *&&&&&&&&&&&&&&&&&&&&&&&&&&&@@@@@@@@@@@@@@@@@@%%%%%%%%%%%%%%%%^^^^^^^^^^^^^^^ \ @@@@@@@@@@@@@")) < 0) { /* invalid pattern - nothing to repeat */ mapi_read_error(&err_no, error); printf("Testing error case1: Errorcode :%d description: %s \n", err_no, error); if(err_no != 7000) { printf("\t\tWrong ERRORCODE returned\n"); flag = 1; } }
int main(int argc, char **argv) { Mapi dbh; MapiHdl hdl = NULL; mapi_int64 rows; if (argc != 4) { printf("usage:%s <host> <port> <language>\n", argv[0]); exit(-1); } dbh = mapi_connect(argv[1], atoi(argv[2]), "monetdb", "monetdb", argv[3], NULL); if (dbh == NULL || mapi_error(dbh)) die(dbh, hdl); mapi_cache_limit(dbh, 2); /* mapi_trace_log(dbh, "/tmp/mapilog"); */ /* mapi_trace(dbh, 1); */ if (strcmp(argv[3], "sql") == 0) { /* switch of autocommit */ if (mapi_setAutocommit(dbh, 0) != MOK || mapi_error(dbh)) die(dbh,NULL); if ((hdl = mapi_query(dbh, "create table emp(name varchar(20), age int)")) == NULL || mapi_error(dbh)) die(dbh, hdl); if (mapi_close_handle(hdl) != MOK) die(dbh, hdl); if ((hdl = mapi_query(dbh, "insert into emp values('John', 23)")) == NULL || mapi_error(dbh)) die(dbh, hdl); if (mapi_close_handle(hdl) != MOK) die(dbh, hdl); if ((hdl = mapi_query(dbh, "insert into emp values('Mary', 22)")) == NULL || mapi_error(dbh)) die(dbh, hdl); if (mapi_close_handle(hdl) != MOK) die(dbh, hdl); if ((hdl = mapi_query(dbh, "select * from emp")) == NULL || mapi_error(dbh)) die(dbh, hdl); rows = mapi_fetch_all_rows(hdl); if (mapi_error(dbh)) die(dbh, hdl); printf("rows received " LLFMT "\n", rows); while (mapi_fetch_row(hdl)) { char *nme = mapi_fetch_field(hdl, 0); char *age = mapi_fetch_field(hdl, 1); printf("%s is %s\n", nme, age); } } else if (strcmp(argv[3], "mal") == 0) { if ((hdl = mapi_query(dbh, "emp := bat.new(:oid,:str);")) == NULL || mapi_error(dbh)) die(dbh, hdl); if ((hdl = mapi_query(dbh, "age := bat.new(:oid,:int);")) == NULL || mapi_error(dbh)) die(dbh, hdl); if (mapi_close_handle(hdl) != MOK) die(dbh, hdl); if ((hdl = mapi_query(dbh, "bat.append(emp, \"John\");")) == NULL || mapi_error(dbh)) die(dbh, hdl); if ((hdl = mapi_query(dbh, "bat.append(age, 23);")) == NULL || mapi_error(dbh)) die(dbh, hdl); if (mapi_close_handle(hdl) != MOK) die(dbh, hdl); if ((hdl = mapi_query(dbh, "bat.append(emp, \"Mary\");")) == NULL || mapi_error(dbh)) die(dbh, hdl); if ((hdl = mapi_query(dbh, "bat.append(age, 22);")) == NULL || mapi_error(dbh)) die(dbh, hdl); if (mapi_close_handle(hdl) != MOK) die(dbh, hdl); if ((hdl = mapi_query(dbh, "io.print(emp,age);")) == NULL || mapi_error(dbh)) die(dbh, hdl); rows = mapi_fetch_all_rows(hdl); if (mapi_error(dbh)) die(dbh, hdl); printf("rows received " LLFMT "\n", rows); while (mapi_fetch_row(hdl)) { char *nme = mapi_fetch_field(hdl, 1); char *age = mapi_fetch_field(hdl, 2); printf("%s is %s\n", nme, age); } } else { fprintf(stderr, "%s: unknown language, only mal and sql supported\n", argv[0]); exit(1); } if (mapi_error(dbh)) die(dbh, hdl); /* mapi_stat(dbh); printf("mapi_ping %d\n",mapi_ping(dbh)); */ if (mapi_close_handle(hdl) != MOK) die(dbh, hdl); mapi_destroy(dbh); return 0; }
int main(int argc, char *argv[]) { int fd; int fid; int err_no =0 , flag=0; char error[512]; int ok; mapi_flow_info_t info; if(argc!=2){ printf("\nWrong arguments\n"); return -1; } if ((fd = mapi_create_flow(argv[1]))<0){ fprintf(stderr, "Could not create flow using '%s'\n", argv[1]); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if((fid=mapi_apply_function(fd, "PKT_COUNTER"))<0){ fprintf(stderr, "Could not apply PKT_COUNTER to flow %d\n", fd); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if(mapi_connect(fd)<0){ fprintf(stderr, "Connecting to flow failed %d\n", fd); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if((ok = mapi_get_flow_info(fd, &info))<0){ fprintf(stderr, "Getting flow info failed on fd:%d\n", fd); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } /* *Sanity check */ if(info.num_functions!=1) fprintf(stderr,"WARNING: Apply function sanity check failed\n"); else printf("Mapi_apply_function OK\n"); DOT; if(mapi_close_flow(fd)<0){ fprintf(stderr,"Close flow failed\n"); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; /* * Error checking */ fd = fid = 0; if ((fd = mapi_create_flow(argv[1]))<0){ fprintf(stderr, "Could not create flow using '%s'\n", argv[1]); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if( (fid = mapi_apply_function(fd, "IMAGINARY FUNCTION")) == -1){ mapi_read_error( &err_no, error); printf("\nTesting error case1: Errorcode :%d description: %s \n" ,err_no, error); if(err_no != 6144){ fprintf(stderr,"WARNING:Wrong ERRORCODE returned\n"); flag = 1; } } DOT; if( (fid = mapi_apply_function(-12314, "TO_BUFFER")) == -1){ mapi_read_error( &err_no, error); printf("\nTesting error case2: Errorcode :%d description: %s \n" ,err_no, error); if(err_no != 6147){ fprintf(stderr,"WARNING:Wrong ERRORCODE returned\n"); flag = 1; } } DOT; if(mapi_connect(fd)<0){ fprintf(stderr, "Connecting to flow failed %d\n", fd); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if(mapi_close_flow(fd)<0){ fprintf(stderr,"Close flow failed\n"); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; /* *Offline checking */ if ((fd = mapi_create_offline_flow("./tracefile" , MFF_PCAP))<0){ fprintf(stderr, "Could not create flow using '%s'\n", argv[1]); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if((fid=mapi_apply_function(fd, "PKT_COUNTER"))<0){ fprintf(stderr, "Could not apply PKT_COUNTER to flow %d\n", fd); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if(mapi_connect(fd)<0){ fprintf(stderr, "Connecting to flow failed %d\n", fd); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if((ok = mapi_get_flow_info(fd, &info))<0){ fprintf(stderr, "Getting flow info failed on fd:%d\n", fd); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } /* *Sanity check */ if(info.num_functions!=1) fprintf(stderr,"WARNING: Apply function sanity check failed\n"); else printf("Mapi_apply_function OK\n"); DOT; if(mapi_close_flow(fd)<0){ fprintf(stderr,"Close flow failed\n"); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; /* * Error checking */ fd = fid = 0; if ((fd = mapi_create_offline_flow("./tracefile" , MFF_PCAP))<0){ fprintf(stderr, "Could not create flow using '%s'\n", argv[1]); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if( (fid = mapi_apply_function(fd, "IMAGINARY FUNCTION")) == -1){ mapi_read_error( &err_no, error); printf("\nTesting error case3: Errorcode :%d description: %s \n" ,err_no, error); if(err_no != 6144){ fprintf(stderr,"WARNING:Wrong ERRORCODE returned\n"); flag = 1; } } DOT; if( (fid = mapi_apply_function(-12314, "TO_BUFFER")) == -1){ mapi_read_error( &err_no, error); printf("\nTesting error case4: Errorcode :%d description: %s \n" ,err_no, error); if(err_no != 6147){ fprintf(stderr,"WARNING:Wrong ERRORCODE returned\n"); flag = 1; } } DOT; if(mapi_connect(fd)<0){ fprintf(stderr, "Connecting to flow failed %d\n", fd); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if(mapi_close_flow(fd)<0){ fprintf(stderr,"Close flow failed\n"); mapi_read_error( &err_no, error); fprintf(stderr,"Errorcode :%d description: %s \n" ,err_no, error); return -1; } DOT; if(!flag) printf("\nMAPI apply function Error Checking OK\n"); else printf("\nMAPI apply function Error Checking :FAILED:\n"); return 0; }