static int read_tcp(const char *proc, const char *type, llist *l, probe_ctx *ctx)
{
int line = 0;
FILE *f;
char buf[256];
unsigned long rxq, txq, time_len, retr, inode;
unsigned local_port, rem_port, uid;
int d, state, timer_run, timeout;
char rem_addr[128], local_addr[128], more[512];
f = fopen(proc, "rt");
if (f == NULL) {
if (errno != ENOENT)
return 1;
else
return 0;
}
__fsetlocking(f, FSETLOCKING_BYCALLER);
while (fgets(buf, sizeof(buf), f)) {
if (line == 0) {
line++;
continue;
}
more[0] = 0;
sscanf(buf, "%d: %64[0-9A-Fa-f]:%X %64[0-9A-Fa-f]:%X %X "
"%lX:%lX %X:%lX %lX %d %d %lu %512s\n",
&d, local_addr, &local_port, rem_addr, &rem_port,
&state, &txq, &rxq, &timer_run, &time_len, &retr,
&uid, &timeout, &inode, more);
char src[NI_MAXHOST], dest[NI_MAXHOST];
addr_convert(local_addr, src, NI_MAXHOST);
addr_convert(rem_addr, dest, NI_MAXHOST);
dI("Have tcp port: %s:%u\n", src, local_port);
if (eval_data(type, src, local_port)) {
struct result_info r;
r.proto = type;
r.laddr = src;
r.lport = local_port;
r.raddr = dest;
r.rport = rem_port;
if (list_find_inode(l, inode)) {
report_finding(&r, l, ctx);
} else {
report_finding(&r, NULL, ctx);
}
}
}
fclose(f);
return 0;
}
i_population_wide_observer::eval_data_t rtp_single_objective::initialize(size_t pop_size) const
{
double initial = 0.0;
switch(m_merge)
{
case MergeMethod::Average:
initial = 0.0;
break;
case MergeMethod::Minimum:
initial = std::numeric_limits< double >::max();
break;
}
return eval_data_t(eval_data(pop_size, initial));
}
static void assemble(void)
{
section *sec;
atom *p;
char *attr;
int bss;
final_pass=1;
for(sec=first_section; sec; sec=sec->next) {
source *lasterrsrc=NULL;
int lasterrline=0;
sec->pc=sec->org;
attr=sec->attr;
bss=0;
while(*attr) {
if(*attr++=='u') {
bss=1;
break;
}
}
for(p=sec->first; p; p=p->next) {
sec->pc=(sec->pc+p->align-1)/p->align*p->align;
cur_src=p->src;
cur_src->line=p->line;
if(p->list&&p->list->atom==p) {
p->list->sec=sec;
p->list->pc=sec->pc;
}
if(p->type==INSTRUCTION) {
dblock *db;
cur_listing=p->list;
db=eval_instruction(p->content.inst,sec,sec->pc);
if(pic_check)
do_pic_check(db->relocs);
cur_listing=0;
if(DEBUG) {
if(db->size!=instruction_size(p->content.inst,sec,sec->pc))
ierror(0);
}
/*FIXME: sauber freigeben */
myfree(p->content.inst);
p->content.db=db;
p->type=DATA;
}
else if(p->type==DATADEF) {
dblock *db;
cur_listing=p->list;
db=eval_data(p->content.defb->op,p->content.defb->bitsize,sec,sec->pc);
if(pic_check)
do_pic_check(db->relocs);
cur_listing=0;
/*FIXME: sauber freigeben */
myfree(p->content.defb);
p->content.db=db;
p->type=DATA;
}
else if(p->type==RORG) {
sblock *sb;
taddr space;
if(eval_expr(p->content.roffs,&space,sec,sec->pc)) {
space=sec->org+space-sec->pc;
if (space>=0) {
sb=new_sblock(number_expr(space),1,0);
p->content.sb=sb;
p->type=SPACE;
}
else
general_error(20); /* rorg is lower than current pc */
}
else
general_error(30); /* expression must be constant */
}
else if(p->type==DATA&&bss) {
if(lasterrsrc!=p->src||lasterrline!=p->line) {
general_error(31); /* initialized data in bss */
lasterrsrc=p->src;
lasterrline=p->line;
}
}
#ifdef HAVE_CPU_OPTS
else if(p->type==OPTS)
cpu_opts(p->content.opts);
#endif
else if(p->type==PRINTTEXT)
printf("%s\n",p->content.ptext);
else if (p->type==PRINTEXPR) {
taddr val;
eval_expr(p->content.pexpr,&val,sec,sec->pc);
printf("%ld (0x%lx)\n",(long)val,(unsigned long)val);
}
sec->pc+=atom_size(p,sec,sec->pc);
}
}
}
//Main function
int main ( int argc, char *argv[] )
{
//--- VARIABLES ---//
//saving database descriptors
cv::Mat training_descriptors;
//for measuring processing time
clock_t t;
// --- ---//
std::cout << std::endl;
std::cout << "+++ BOW FOR DATA SET +++" << std::endl;
std::cout << TRAIN_PATH << std::endl;
//--- DESCRIPTORS EXTRACTION ---//
std::string train_path = TRAIN_PATH;
//read descriptors from file
std::cout << "*** TRAIN DESCRIPTORS INFO ***" << std::endl;
cv::FileStorage fstore_descrip(DESCRIP_MAT_NAME, cv::FileStorage::READ);
std::cout << "No Documents: " << (int)fstore_descrip["noDocuments"] << std::endl;
std::cout << "No Classes: " << (int)fstore_descrip["noClasses"] << std::endl;
std::cout << "No total descriptors: " << (int)fstore_descrip["totalDescriptors"] << std::endl;
std::cout << "No max desrcriptors in an image: " << (int)fstore_descrip["maxDescriptors"] << std::endl;
std::cout << "Descriptors processing time: " << (float)fstore_descrip["procTime"] << std::endl;
std::cout << std::endl;
fstore_descrip["matDescriptors"] >> training_descriptors;
fstore_descrip.release();
//--- BUILD A DICTIONARY ---//
cv::TermCriteria tc(CV_TERMCRIT_ITER,100,0.001);
int cluster_attempts = 1;
int dictionary_size = atoi(argv[1]);
std::cout << "*** BOW DICTIONARY INFO ***" << std::endl;
std::cout << "Dictionary size: " << dictionary_size << std::endl;
cv::BOWKMeansTrainer bowTrainer(dictionary_size,tc,cluster_attempts, cv::KMEANS_PP_CENTERS);
bowTrainer.add(training_descriptors);
t = clock();
cv::Mat my_dictionary = bowTrainer.cluster();
t = clock()-t;
std::cout << "Dictionary processing time:" << std::endl;
std::cout << t << " clicks " << ((float)t)/CLOCKS_PER_SEC << " seconds" << std::endl;
std::cout << std::endl;
//--- ---//
//--- NAIVE BAYES FOR CLASSIFICATION ---//
cv::NormalBayesClassifier nb_classifier;
cv::Mat training_data(0,dictionary_size,CV_32FC1);
cv::Mat labels(0,1,CV_32FC1);
//set the dictionary to bow descriptor extractor
bowDE.setVocabulary(my_dictionary);
std::cout << "*** CLASSIFIER TRAINING ***" << std::endl;
bow_encode(fs::path(train_path),training_data,labels);
// +++ for debugging - can be commented +++//
std::cout << training_data.size() << " * " << labels.size() << std::endl;
if(training_data.type() == CV_32FC1)
{std::cout << "training data matrix accepted" << std::endl;}
if(labels.type() == CV_32FC1)
{std::cout << "labels matrix accepted" << std::endl;}
// +++ +++ //
t = clock();
nb_classifier.train(training_data,labels,cv::Mat(),cv::Mat(),false);
t = clock() - t;
nb_classifier.save("nbModel_flavia_leaves_a.yml","nbModel_flavia_leaves_a");
std::cout << " Training processing time:" << std::endl;
std::cout << t << " clicks " << ((float)t)/CLOCKS_PER_SEC << " seconds" << std::endl;
std::cout << std::endl;
//if you already have a classifier uncomment the next line and comment the all the
//Classifier Training section
//nb_classifier.load("nbModel_flavia_leaves_b.yml","nbModel_flavia_leaves_b");
//std::cout << "Classfier model loaded"<< std::endl;
//--- ---//
//--- BOW ENCODING OF TEST SET AND EVALUATION ---//
cv::Mat ground_truth(0,1,CV_32FC1);
cv::Mat eval_data(0,dictionary_size,CV_32FC1);
cv::Mat results;
std::string test_path = TEST_PATH;
double accuRate = 0.;
std::cout << "*** CLASSIFIER EVALUATION ***" << std::endl;
bow_encode(fs::path(test_path),eval_data,ground_truth);
t = clock();
nb_classifier.predict(eval_data,&results);
t = clock()-t;
std::cout << " Classifier evaluation time:" << std::endl;
std::cout << t << " clicks " << ((float)t)/CLOCKS_PER_SEC << " seconds" << std::endl;
accuRate = 1. -( (double) cv::countNonZero(ground_truth - results) / eval_data.rows);
std::cout << "Accuracy rate: " << accuRate << std::endl;
std::cout << "Classifier Results" << std::endl;
std::cout << results << std::endl << std::endl;
return 0;
} /* ---------- end of function main ---------- */
