/**
* Search for a matching character string in the character map.
*/
static const wchar_t* charmap_search(CHARMAP* cm, wchar_t* s)
{
STATE_MACHINE* start;
const wchar_t* unicode;
int section;
/* Determine the starting state based on the charmap's active section */
section = cm->section;
if(!IN_RANGE(0, section, (int)ARRAYLEN(cm->sections))) section = 0;
start = &cm->sections[section];
cm->match_state = NULL;
cm->match_state_prev = NULL;
unicode = sm_search(start, s, &cm->match_count, &cm->match_state_prev, &cm->match_state);
/**
* Determine whether the match is final. A match is considered to be final
* in two cases: (1)if the last state mached has no exit paths, or (2)if we
* did not consume all of the search string. (1) is obvious - if there are
* no more states to transition to, then the unicode we find is the final
* code. (2) means we reached the final state that can be the only
* interpretation of the input string, so it must be the final state.
* If neither of these is true, that means further input from the user
* may allow us to get to a different state, so we have not reached the
* final state we possibly can.
*/
cm->match_is_final = 0;
if(cm->match_count < (int)wcslen(s)) {
cm->match_is_final = 1;
}
/* Statistics */
cm->match_stats = MATCH_STAT_NONE;
if(cm->match_state->next_size == 0) {
cm->match_is_final = 1;
cm->match_stats |= MATCH_STAT_NOMOSTATES;
}
if(cm->match_count == (int)wcslen(s)) {
cm->match_stats |= MATCH_STAT_NOMOBUF;
}
return unicode;
}
/**
* Search the state machine's transition keys, return the unicode output of the
* last state found. The search is done deep, recursing until no more match
* can be found.
*
* @param start Starting point of the state transition. Constant.
* @param key The key string to look for. Constant.
* @param matched The number of character strings matched. Return on output.
* @param end The last state found. Return on output.
* @param penult The penultimate state found.
*
* @return Found unicode character sequence output of the last state.
*/
static const wchar_t* sm_search(STATE_MACHINE* start, wchar_t* key, int* matched, STATE_MACHINE** penult, STATE_MACHINE** end)
{
STATE_MACHINE* sm = sm_search_shallow(start, (char)*key);
const wchar_t* unicode;
/* No match - stop recursion */
if(!sm) {
*matched = 0;
*end = start;
return start->output;
}
/* Match - recurse */
*penult = start;
unicode = sm_search(sm, key+1, matched, penult, end);
(*matched)++;
return unicode;
}
void* thread_fwd_routine(void *arg)
{
odp_packet_t pkt_tbl[PACKET_IO_BURST];
int rv_nb, sd_nb;
int thr_id;
int out_port;
int tuple[5];
int i;
thr_id = odp_thread_id();
printf("fwd thread %d start(on cpu %d)\n", thr_id, odp_cpu_id());
//match to port id
thr_id--;
memset(&port_stat.stat[thr_id], 0 , 3 * sizeof(uint64_t));
for(;;)
{
rv_nb = odp_pktio_recv(thr_data.nic_hdl[thr_id], pkt_tbl,
PACKET_IO_BURST);
port_stat.stat[thr_id].recv += rv_nb;
#ifdef EXECUTE_CLASSIFICATION
for(i = 0; i < rv_nb; i++)
{
if(extract_tuple(pkt_tbl[i], tuple) == 0)
{
int res;
res = packet_classifier_search(tuple);
}
}
#endif
#ifdef EXECUTE_HASH_LOOKUP
for(i = 0; i < rv_nb; i++)
{
if(extract_tuple(pkt_tbl[i], tuple) == 0)
{
int res;
res = odph_hash_lookup(hs_tbl, (void*)tuple);
}
}
#endif
#ifdef EXECUTE_DPI
unsigned char *payload;
int payload_len;
for(i = 0; i < rv_nb; i++)
{
if(get_payload(pkt_tbl[i], (unsigned char**)&payload, &payload_len) == 0)
{
int res;
//printf("%d %d %s\n", thr_id, strlen(payload), payload);
res = sm_search(sm_hdl, payload, payload_len);
//printf("search res: %d\n", res);
}
}
#endif
if((thr_id & 1) == 1)
{
out_port = thr_id - 1;
}
else
{
out_port = thr_id + 1 == glb_param.nic.num ? thr_id : thr_id + 1;
}
sd_nb = odp_pktio_send(thr_data.nic_hdl[out_port], pkt_tbl, rv_nb);
port_stat.stat[thr_id].send += sd_nb;
while(sd_nb < rv_nb)
{
odp_packet_free(pkt_tbl[sd_nb++]);
port_stat.stat[thr_id].drop++;
}
}
return NULL;
}
