void
feature_vector(nv_matrix_t *vec,
int vec_j,
nv_matrix_t *key_vec,
nv_matrix_t *desc_vec,
int desc_m
)
{
int i;
int procs = nv_omp_procs();
nv_matrix_t *vec_tmp = nv_matrix_alloc(vec->n, procs);
const nv_matrix_t *posi = POSI();
const nv_matrix_t *nega = NEGA();
nv_matrix_zero(vec_tmp);
#ifdef _OPENMP
#pragma omp parallel for num_threads(procs)
#endif
for (i = 0; i < desc_m; ++i) {
int j;
int thread_id = nv_omp_thread_id();
nv_vector_normalize(desc_vec, i);
if (NV_MAT_V(key_vec, i, NV_KEYPOINT_RESPONSE_IDX) > 0.0f) {
int label = nv_nn(posi, desc_vec, i);
for (j = 0; j < posi->n; ++j) {
NV_MAT_V(vec_tmp, thread_id, label * NV_KEYPOINT_DESC_N + j) +=
NV_MAT_V(desc_vec, i, j) - NV_MAT_V(posi, label, j);
}
} else {
int label = nv_nn(nega, desc_vec, i);
int vl = (KP + label) * NV_KEYPOINT_DESC_N;
for (j = 0; j < nega->n; ++j) {
NV_MAT_V(vec_tmp, thread_id, (vl + j)) +=
NV_MAT_V(desc_vec, i, j) - NV_MAT_V(nega, label, j);
}
}
}
nv_vector_zero(vec, vec_j);
for (i = 0; i < procs; ++i) {
nv_vector_add(vec, vec_j, vec, vec_j, vec_tmp, i);
}
nv_vector_normalize(vec, vec_j);
nv_matrix_free(&vec_tmp);
}
void cgen(QuadSP t)
{
if (t == NULL) {
fprintf(errlist, "ELF BUG:314\n");
return ;
}
switch (t->op) {
case ADD_op:
ADDA(t->r, t->s, t->d);
break;
case SUB_op:
SUBA(t->r, t->s, t->d);
break;
case MUL_op:
MULA(t->r, t->s, t->d);
break;
case DIV_op:
DIVA(t->r, t->s, t->d);
break;
case INC_op:
INCA(t->r, t->s, t->d);
break;
case DEC_op:
DECA(t->r, t->s, t->d);
break;
case NEG_op:
NEGA(t->r, t->s, t->d);
break;
case LOAD_op:
LOADA(t->r, t->s, t->d);
break;
case ASS_op:
ASSA(t->r, t->s, t->d);
break;
case AARR_op:
AARRA(t->r, t->s, t->d);
break;
case EQU_op:
EQUA(t->r, t->s, t->d);
break;
case NEQ_op:
NEQA(t->r, t->s, t->d);
break;
case GTT_op:
GTTA(t->r, t->s, t->d);
break;
case GEQ_op:
GEQA(t->r, t->s, t->d);
break;
case LST_op:
LSTA(t->r, t->s, t->d);
break;
case LEQ_op:
LEQA(t->r, t->s, t->d);
break;
case JMP_op:
JMPA(t->r, t->s, t->d);
break;
case PUSH_op:
PUSHA(t->r, t->s, t->d);
break;
case PUSHA_op:
PUSHAA(t->r, t->s, t->d);
break;
case POP_op:
POPA(t->r, t->s, t->d);
break;
case CALL_op:
CALLA(t->r, t->s, t->d);
break;
case SRET_op:
SRETA(t->r, t->s, t->d);
break;
case ENTER_op:
ENTERA(t->r, t->s, t->d);
break;
case FIN_op:
FINA(t->r, t->s, t->d);
break;
case READ_op:
READA(t->r, t->s, t->d);
break;
case READC_op:
READCA(t->r, t->s, t->d);
break;
case WRS_op:
WRSA(t->r, t->s, t->d);
break;
case WRI_op:
WRIA(t->r, t->s, t->d);
break;
case WRC_op:
WRCA(t->r, t->s, t->d);
break;
case LABEL_op:
LABELA(t->r, t->s, t->d);
break;
default:
fprintf(errlist, "ELF BUG:420\n");
}
}
static int cb_iptables_rule_common(const struct filterent *ent, struct fg_misc *misc, sa_family_t family, const char *iptables)
{
char *rulechain = NULL, *revchain = NULL, *natchain = NULL;
char *ruletarget = NULL, *revtarget = NULL, *nattarget = NULL;
char *natrule = NULL, *rule = NULL, *rule_r = NULL;
char *forchain = NULL, *forrevchain = NULL;
char *fortarget = NULL, *forrevtarget = NULL;
char *subchain = NULL, *subtarget = NULL;
int neednat = 0, needret = 0;
int islocal = (ent->rtype != ROUTEDONLY);
int isforward = (ent->rtype != LOCALONLY);
long *feat = (long*)misc->misc;
enum filtertype target = ent->target;
int orules = 0;
/* nat rule? */
if((target == MASQ) || (target == REDIRECT)) {
neednat = 1;
if(family == AF_INET6) {
fprintf(stderr, "can't NAT with IPv6\n");
return -1;
}
if((target == MASQ) && (ent->direction == INPUT)) {
fprintf(stderr, "can't masquerade on input\n");
return -1;
} else if((target == REDIRECT) && (ent->direction == OUTPUT)) {
fprintf(stderr, "can't redirect on output\n");
return -1;
}
}
/* sub-stuff? */
if(target == F_SUBGROUP) {
subtarget = strapp(strdup(ent->subgroup), "-");
needret = 1;
} else subtarget = strdup("");
if(ent->groupname) subchain = strapp(strdup(ent->groupname), "-");
else subchain = strdup("");
switch(ent->direction) {
case INPUT:
natchain = strdup("PREROUTING");
rulechain = strdup("INPUT");
revchain = strdup("OUTPUT");
forchain = strdup("FORWARD");
forrevchain = strdup("FORW_OUT");
if(ent->iface && strcmp(ent->iface, "*")) {
if(NEG(DIRECTION)) {
APPS(natrule, "!");
APPS(rule, "!");
APPS(rule_r, "!");
}
APPSS2(natrule, "-i", ent->iface);
APPSS2(rule, "-i", ent->iface);
APPSS2(rule_r, "-o", ent->iface);
}
break;
case OUTPUT:
natchain = strdup("POSTROUTING");
rulechain = strdup("OUTPUT");
revchain = strdup("INPUT");
forchain = strdup("FORW_OUT");
forrevchain = strdup("FORWARD");
if(ent->iface && strcmp(ent->iface, "*")) {
if(NEG(DIRECTION)) {
APPS(natrule, "!");
APPS(rule, "!");
APPS(rule_r, "!");
}
APPSS2(natrule, "-o", ent->iface);
APPSS2(rule, "-o", ent->iface);
APPSS2(rule_r, "-i", ent->iface);
}
break;
default:
fprintf(stderr, "unknown direction\n");
abort();
}
/* state and reverse rules here */
/* FIXME: state established on reverse for every rule, not just
* specifically udp and tcp */
if(ent->proto.name) {
int needstate = 0;
APPSS2(natrule, "-p", ent->proto.name);
APPSS2(rule, "-p", ent->proto.name);
APPSS2(rule_r, "-p", ent->proto.name);
switch(ent->proto.num) {
case IPPROTO_TCP:
needret++;
needstate++;
*feat |= A_TCP;
APPS(rule_r, "! --syn");
break;
case IPPROTO_UDP:
needret++;
needstate++;
*feat |= A_UDP;
break;
}
if(needstate) {
APPS(rule, "-m state --state NEW,ESTABLISHED");
APPS(rule_r, "-m state --state ESTABLISHED");
}
}
if(ent->srcaddr.addrstr) {
NEGA(natrule, SOURCE);
NEGA(rule, SOURCE);
NEGA(rule_r, SOURCE);
APPIP2("-s", natrule, &ent->srcaddr);
APPIP2("-s", rule, &ent->srcaddr);
APPIP2("-d", rule_r, &ent->srcaddr);
}
if(ent->dstaddr.addrstr) {
NEGA(natrule, DEST);
NEGA(rule, DEST);
NEGA(rule_r, DEST);
APPIP2("-d", natrule, &ent->dstaddr);
APPIP2("-d", rule, &ent->dstaddr);
APPIP2("-s", rule_r, &ent->dstaddr);
}
switch(ent->proto.num) {
case 0:
break;
case IPPROTO_UDP:
case IPPROTO_TCP:
if(ent->u.ports.src.minstr) {
NEGA(natrule, SPORT);
NEGA(rule, SPORT);
NEGA(rule_r, SPORT);
APPPORT2("--sport", natrule, &ent->u.ports.src);
APPPORT2("--sport", rule, &ent->u.ports.src);
APPPORT2("--dport", rule_r, &ent->u.ports.src);
}
if(ent->u.ports.dst.minstr) {
NEGA(natrule, DPORT);
NEGA(rule, DPORT);
NEGA(rule_r, DPORT);
APPPORT2("--dport", natrule, &ent->u.ports.dst);
APPPORT2("--dport", rule, &ent->u.ports.dst);
APPPORT2("--sport", rule_r, &ent->u.ports.dst);
}
break;
case IPPROTO_ICMP:
if(ent->u.icmp) {
NEGA(natrule, ICMPTYPE);
APPSS2(natrule, "--icmp-type", ent->u.icmp);
NEGA(rule, ICMPTYPE);
APPSS2(rule, "--icmp-type", ent->u.icmp);
}
break;
default:
;
}
APPS(natrule, "-j");
APPS(rule, "-j");
APPS(rule_r, "-j");
/* The "rule+1" in the printfs below are an ugly hack to
* prevent a double-space in the output rule */
/* Yuck, separate rules for logging packets. Be still my
* beating lunch.
*
* Logging and target rules have to be the last bits
* before output, or this doesn't work. This will also
* fail if any mangling has been done above.
*/
if(ESET(ent, LOG)) {
char *lc, *la, *ls;
if(ent->logmsg) {
lc = strdup(" --log-prefix=");
la = ent->logmsg;
ls = strdup("\" \"");
} else
lc = la = ls = strdup("");
if(islocal) orules++,oprintf("%s -A %s %s LOG%s%s%s\n", iptables, rulechain, rule+1, lc, la, ls);
if(isforward) orules++,oprintf("%s -A %s %s LOG%s%s%s\n", iptables, forchain, rule+1, lc, la, ls);
}
/* Do this twice, once for NAT, once for filter */
if(neednat) {
switch(target) {
case MASQ:
nattarget = strdup("MASQUERADE");
break;
case REDIRECT:
nattarget = strdup("REDIRECT");
break;
default:
abort();
}
}
switch(target) {
case MASQ:
case REDIRECT:
case T_ACCEPT:
ruletarget = revtarget =
fortarget = forrevtarget = strdup("ACCEPT");
switch(ent->direction) {
case INPUT:
fortarget = strdup("FORW_OUT");
break;
case OUTPUT:
forrevtarget = strdup("FORW_OUT");
break;
default:
abort();
}
break;
case DROP:
ruletarget = fortarget = strdup("DROP");
needret = 0;
break;
case T_REJECT:
ruletarget = fortarget = strdup("REJECT");
needret = 0;
*feat |= T_REJECT;
break;
case F_SUBGROUP:
switch(ent->direction) {
case INPUT:
ruletarget = strdup("INPUT");
revtarget = strdup("OUTPUT");
fortarget = strdup("FORWARD");
forrevtarget = strdup("FORW_OUT");
break;
case OUTPUT:
ruletarget = strdup("OUTPUT");
revtarget = strdup("INPUT");
fortarget = strdup("FORW_OUT");
forrevtarget = strdup("FORWARD");
break;
default:
abort();
}
break;
default:
abort();
}
if((misc->flags & FF_LSTATE) && (target != T_REJECT)) needret = 0;
if(ent->oneway) needret = 0;
if(neednat) orules++,oprintf("%s -t nat -A %s%s %s %s%s\n", iptables, subchain, natchain, natrule+1, subtarget, nattarget);
if(islocal) orules++,oprintf("%s -A %s%s %s %s%s\n", iptables, subchain, rulechain, rule+1, subtarget, ruletarget);
if(needret) orules++,oprintf("%s -I %s%s %s %s%s\n", iptables, subchain, revchain, rule_r+1, subtarget, revtarget);
if(isforward) {
orules++,oprintf("%s -A %s%s %s %s%s\n", iptables, subchain, forchain, rule+1, subtarget, fortarget);
if(needret) orules++,oprintf("%s -I %s%s %s %s%s\n", iptables, subchain, forrevchain, rule_r+1, subtarget, forrevtarget);
}
free(natrule);
free(rule);
free(rule_r);
free(subchain);
free(subtarget);
return orules;
}
/* Executa o programa */
int Mepa::exec(){
int op;
if(detalha)
{
p->imprime(); /* Imprime o programa */
}
op = p->next();
while( op != PARA )
{
if(detalha)
{
debug();
}
switch(op)
{
/* Funcoes MEPA */
case 0: { AMEM(); break; }
case 1: { ARMI(); break; }
case 2: { ARMP(); break; }
case 3: { ARMZ(); break; }
case 4: { CHPP(); break; }
case 5: { CHPR(); break; }
case 6: { CMAF(); break; }
case 7: { CMAG(); break; }
case 8: { CMDF(); break; }
case 9: { CMDG(); break; }
case 10: { CMEF(); break; }
case 11: { CMEG(); break; }
case 12: { CMIF(); break; }
case 13: { CMIG(); break; }
case 14: { CMMA(); break; }
case 15: { CMMF(); break; }
case 16: { CMME(); break; }
case 17: { CMNF(); break; }
case 18: { CONJ(); break; }
case 19: { CRCT(); break; }
case 20: { CRCF(); break; }
case 21: { CREG(); break; }
case 22: { CREN(); break; }
case 23: { CRVI(); break; }
case 24: { CRVL(); break; }
case 25: { CRVP(); break; }
case 26: { DISJ(); break; }
case 27: { DIVF(); break; }
case 28: { DIVI(); break; }
case 29: { DMEM(); break; }
case 30: { DSVF(); break; }
case 31: { DSVS(); break; }
case 32: { ENTR(); break; }
case 33: { IMPC(); break; }
case 34: { IMPF(); break; }
case 35: { IMPR(); break; }
case 36: { INPP(); break; }
case 37: { INVF(); break; }
case 38: { INVR(); break; }
case 39: { LEIT(); break; }
case 40: { LEIF(); break; }
case 41: { MULF(); break; }
case 42: { MULT(); break; }
case 43: { NEGA(); break; }
case 44: { RTPR(); break; }
case 45: { SOMA(); break; }
case 46: { SOMF(); break; }
case 47: { SUBT(); break; }
case 48: { SUBF(); break; }
default:{
cerr << "O programa executou uma operacao invalida." << endl;
cerr << "i = " << p->getI() << endl;
abort();
}
}
op = p->next();
}
return 0;
}
