Пример #1
0
bool FlowGrpIsEmpty(int flow_id)
{
    bool ret;

    FlowTblLock();
    
    /* with or without group */
    if (flow_tbl[flow_id].grp_id != -1) {
        ret = GrpIsEmpty(flow_tbl[flow_id].grp_id);
    }
    else {
        ret = FlowIsEmpty(flow_id);
    }
    
    FlowTblUnlock();

    return ret;
}
Пример #2
0
static packet *TcpCaDissectorGrp(int flow_id)
{
    int id;
    packet *pkt;
    tca_flow *init;
    tca_flow *setup;
    tca_flow *runing;
    tca_flow *elem, *tmp;
    bool loop, wpkt, all;
    unsigned int flow_t;
    struct timespec req;
    unsigned long pkt_num;
    
    /* init */
    init = setup = runing = NULL;
    loop = all = TRUE;
    flow_t = 0;
    req.tv_sec = 0;
    req.tv_nsec = 50000000;
    
    pthread_mutex_lock(&pthrs_mux);
    for (id=0; id!=pthrs_dim; id++) {
        if (prl_thrs_en[id] == 1) {
            if (flow_id == prl_thrs[id]->flow_id)
                break;
            elem = prl_thrs[id]->nxt;
            while (elem != NULL) {
                if (flow_id == elem->flow_id) {
                    break;
                }
                elem = elem->nxt;
            }
            if (elem != NULL)
                break;
        }
    }
    if (id == pthrs_dim) {
        LogPrintf(LV_FATAL, "Thread didn't seleced\n");
        printf("Thread didn't seleced %i\n", flow_id);
        for (id=0; id!=pthrs_dim; id++) {
            if (prl_thrs_en[id] == 1)
                printf("id: %i st: %i flw: %i\n", id, prl_thrs_en[id], prl_thrs[id]->flow_id);
        }
        exit(-1);
    }
    prl_thrs_en[id] = 2;
    pthread_mutex_unlock(&pthrs_mux);

    do {
        wpkt = TRUE;
        /* new flow */
        pthread_mutex_lock(&pthrs_mux);
        init = prl_thrs[id];
        prl_thrs[id] = NULL;
        pthread_mutex_unlock(&pthrs_mux);
        while (init != NULL) {
            flow_t++;
            tmp = init->nxt;
            init->nxt = setup;
            if (setup != NULL) {
                setup->pre = init;
            }
            setup = init;
            TcpCaDisFlowInit(init);
            
            init = tmp;
        }

        /* flow setup */
        elem = setup;
        while (elem != NULL) {
            tmp = elem->nxt;
            pkt = FlowGetPkt(elem->flow_id);
            if (pkt != NULL) {
                wpkt = FALSE;
                do {
                    if (TcpCaDisFlowSetUp(elem, pkt) == 0) {
                        if (elem->nxt != NULL) {
                            elem->nxt->pre = elem->pre;
                        }
                        if (elem->pre != NULL) {
                            elem->pre->nxt = elem->nxt;
                            elem->pre = NULL;
                        }
                        else if (elem == setup) {
                            setup = elem->nxt;
                        }
                        elem->nxt = runing;
                        if (runing != NULL) {
                            runing->pre = elem;
                        }
                        runing = elem;
                        break;
                    }
                    pkt = FlowGetPkt(elem->flow_id);
                } while (pkt != NULL);
            }
            else {
                if (FlowIsEmpty(elem->flow_id)) {
                    flow_t--;
                    if (elem->nxt != NULL) {
                        elem->nxt->pre = elem->pre;
                    }
                    if (elem->pre != NULL) {
                        elem->pre->nxt = elem->nxt;
                        elem->pre = NULL;
                    }
                    else if (elem == setup) {
                        setup = elem->nxt;
                    }
                    TcpCaDisFlowEnd(elem);
                }
            }
            elem = tmp;
        }
        
        /* flow elaboration */
        elem = runing;
        while (elem != NULL) {
            if (all == FALSE) {
                if (elem->pkt_elb == 0)
                    break;
            }
            tmp = elem->nxt;
            pkt = FlowGetPkt(elem->flow_id);
            if (pkt != NULL) {
                pkt_num = 0;
                wpkt = FALSE;
                do {
                    pkt_num++;
                    TcpCaDisFlow(elem, pkt);
                    pkt = FlowGetPkt(elem->flow_id);
                } while (pkt != NULL);
                elem->pkt_elb = pkt_num;
                FlowEval(&runing, elem);
            }
            else {
                if (FlowIsEmpty(elem->flow_id)) {
                    flow_t--;
                    if (elem->nxt != NULL) {
                        elem->nxt->pre = elem->pre;
                    }
                    if (elem->pre != NULL) {
                        elem->pre->nxt = elem->nxt;
                        elem->pre = NULL;
                    }
                    else if (elem == runing) {
                        runing = elem->nxt;
                    }
                    TcpCaDisFlowEnd(elem);
                }
            }
            elem = tmp;
        }
        all = FALSE;
        
        /* check */
        if (runing == NULL && setup == NULL) {
            pthread_mutex_lock(&pthrs_mux);
            if (prl_thrs[id] == NULL) {
                prl_thrs_en[id] = 0;
                loop = FALSE;
            }
            pthread_mutex_unlock(&pthrs_mux);
        }
        else if (wpkt) {
            nanosleep(&req, NULL);
            all = TRUE;
        }
    } while (loop);
    
    return NULL;
}