/*
* Add a pattern to the list of patterns for this state machine
*/
int
acsmAddPattern (ACSM_STRUCT * p, unsigned char *pat, int n, int nocase,
int offset, int depth, int negative, void * id, int iid)
{
ACSM_PATTERN * plist;
plist = (ACSM_PATTERN *) AC_MALLOC (sizeof (ACSM_PATTERN));
MEMASSERT (plist, "acsmAddPattern");
plist->patrn = (unsigned char *) AC_MALLOC (n);
ConvertCaseEx (plist->patrn, pat, n);
plist->casepatrn = (unsigned char *) AC_MALLOC (n);
memcpy (plist->casepatrn, pat, n);
plist->udata = (ACSM_USERDATA *)AC_MALLOC(sizeof(ACSM_USERDATA));
MEMASSERT (plist->udata, "acsmAddPattern");
plist->udata->ref_count = 1;
plist->udata->id = id;
plist->n = n;
plist->nocase = nocase;
plist->negative = negative;
plist->offset = offset;
plist->depth = depth;
plist->iid = iid;
plist->next = p->acsmPatterns;
p->acsmPatterns = plist;
p->numPatterns++;
return 0;
}
/******************************************************************************
* FUNCTION: node_init
* Initialize node
******************************************************************************/
void node_init(AC_NODE_t * thiz)
{
memset(thiz, 0, sizeof(AC_NODE_t));
thiz->outgoing_max = REALLOC_CHUNK_OUTGOING;
thiz->outgoing = (struct edge *) AC_MALLOC
(thiz->outgoing_max*sizeof(struct edge));
thiz->matched_patterns_max = REALLOC_CHUNK_MATCHSTR;
thiz->matched_patterns = (AC_PATTERN_t *) AC_MALLOC
(thiz->matched_patterns_max*sizeof(AC_PATTERN_t));
}
/*
* Add a pattern to the list of patterns for this state machine
*/
int acsmAddPattern (ACSM_STRUCT * p, unsigned char *pat, int n)
{
ACSM_PATTERN * plist;
plist = (ACSM_PATTERN *) AC_MALLOC (sizeof (ACSM_PATTERN));
plist->patrn = (unsigned char *) AC_MALLOC (n+1);
memset(plist->patrn+n,0,1);
memcpy (plist->patrn, pat, n);
plist->n = n;
//plist->nmatch=0;
/*Add the pattern into the pattern list*/
plist->next = p->acsmPatterns;
p->acsmPatterns = plist;
return 0;
}
/*
* Compile State Machine
*/
int acsmCompile (ACSM_STRUCT * acsm)
{
int i, k;
ACSM_PATTERN * plist;
/* Count number of states */
acsm->acsmMaxStates = 1; /*State 0*/
for (plist = acsm->acsmPatterns; plist != NULL; plist = plist->next)
{
acsm->acsmMaxStates += plist->n;
}
acsm->acsmStateTable = (ACSM_STATETABLE *) AC_MALLOC (sizeof (ACSM_STATETABLE) * acsm->acsmMaxStates);
// MEMASSERT (acsm->acsmStateTable, "acsmCompile");
memset (acsm->acsmStateTable, 0,sizeof (ACSM_STATETABLE) * acsm->acsmMaxStates);
/* Initialize state zero as a branch */
acsm->acsmNumStates = 0;
/*
//del by ybr, modify to c
ACSM_STATETABLE state_p;
state_p.MatchList=0;
acsm->acsmStateTable.push_back(state_p);
for (i = 0; i < ALPHABET_SIZE; i++)
{
acsm->acsmStateTable[0].NextState[i] = ACSM_FAIL_STATE;
}
*/
/* Initialize all States NextStates to FAILED */
for (k = 0; k < acsm->acsmMaxStates; k++)
{
for (i = 0; i < ALPHABET_SIZE; i++)
{
acsm->acsmStateTable[k].NextState[i] = ACSM_FAIL_STATE;
}
}
/* This is very import */
/* Add each Pattern to the State Table */
for (plist = acsm->acsmPatterns; plist != NULL; plist = plist->next)
{
AddPatternStates (acsm, plist);
}
/* Set all failed state transitions which from state 0 to return to the 0'th state */
for (i = 0; i < ALPHABET_SIZE; i++)
{
if (acsm->acsmStateTable[0].NextState[i] == ACSM_FAIL_STATE)
{
acsm->acsmStateTable[0].NextState[i] = 0;
}
}
/* Build the NFA */
Build_DFA (acsm);
{
// std::vector<ACSM_STATETABLE>(acsm->acsmStateTable).swap(acsm->acsmStateTable);
}
return 0;
}
/******************************************************************************
* FUNCTION: node_create
* Create the node
******************************************************************************/
struct node * node_create(void)
{
AC_NODE_t * thiz;
thiz = (AC_NODE_t *) AC_MALLOC (sizeof(AC_NODE_t));
node_init(thiz);
node_assign_id(thiz);
return thiz;
}
/*
* Init the acsm DataStruct
*/
ACSM_STRUCT * acsmNew ()
{
ACSM_STRUCT * p;
p = (ACSM_STRUCT *) AC_MALLOC (sizeof (ACSM_STRUCT));
if (p)
memset (p, 0, sizeof (ACSM_STRUCT));
return p;
}
/*
* Add a pattern to the list of patterns terminated at this state.
* Insert at front of list.
*/
static void AddMatchListEntry (ACSM_STRUCT * acsm, int state, ACSM_PATTERN * px)
{
ACSM_PATTERN * p;
p = (ACSM_PATTERN *) AC_MALLOC (sizeof (ACSM_PATTERN));
MEMASSERT (p, "AddMatchListEntry");
memcpy (p, px, sizeof (ACSM_PATTERN));
p->next = acsm->acsmStateTable[state].MatchList;
acsm->acsmStateTable[state].MatchList = p;
}
static ACSM_PATTERN *CopyMatchListEntry (ACSM_PATTERN * px)
{
ACSM_PATTERN * p;
p = (ACSM_PATTERN *) AC_MALLOC (sizeof (ACSM_PATTERN));
MEMASSERT (p, "CopyMatchListEntry");
memcpy (p, px, sizeof (ACSM_PATTERN));
p->next = 0;
return p;
}
ACSM_STRUCT * acsmNew ()
{
ACSM_STRUCT * p;
init_xlatcase ();
p = (ACSM_STRUCT *) AC_MALLOC (sizeof (ACSM_STRUCT));
MEMASSERT (p, "acsmNew");
if (p)
memset (p, 0, sizeof (ACSM_STRUCT));
return p;
}
/*
* Add a pattern to the list of patterns terminated at this state.
* Insert at front of list.
*/
static void AddMatchListEntry (ACSM_STRUCT * acsm, int state, ACSM_PATTERN * px)
{
ACSM_PATTERN * p;
p = (ACSM_PATTERN *) AC_MALLOC (sizeof (ACSM_PATTERN));
memcpy (p, px, sizeof (ACSM_PATTERN));
/*Add the new pattern to the pattern list*/
p->next = acsm->acsmStateTable[state].MatchList;
acsm->acsmStateTable[state].MatchList = p;
}
/*
* Add Tail Item to queue
*/
static void queue_add (QUEUE * s, int state)
{
QNODE * q;
if (!s->head)
{
q = s->tail = s->head = (QNODE *) AC_MALLOC (sizeof (QNODE));
MEMASSERT (q, "queue_add");
q->state = state;
q->next = 0;
}
else
{
q = (QNODE *) AC_MALLOC (sizeof (QNODE));
MEMASSERT (q, "queue_add");
q->state = state;
q->next = 0;
s->tail->next = q;
s->tail = q;
}
s->count++;
}
/*
* Add Tail Item to queue
*/
static void queue_add (QUEUE * s, int state)
{
QNODE * q;
/*Queue is empty*/
if (!s->head)
{
q = s->tail = s->head = (QNODE *) AC_MALLOC (sizeof (QNODE));
/*if malloc failed,exit the problom*/
q->state = state;
q->next = 0; /*Set the New Node's Next Null*/
}
else
{
q = (QNODE *) AC_MALLOC (sizeof (QNODE));
q->state = state;
q->next = 0;
/*Add the new Node into the queue*/
s->tail->next = q;
/*set the new node is the Queue's Tail*/
s->tail = q;
}
s->count++;
}
ACSM_STRUCT * acsmNew (void (*userfree)(void *p),
void (*optiontreefree)(void **p),
void (*neg_list_free)(void **p))
{
ACSM_STRUCT * p;
init_xlatcase ();
p = (ACSM_STRUCT *) AC_MALLOC (sizeof (ACSM_STRUCT));
MEMASSERT (p, "acsmNew");
if (p)
{
memset (p, 0, sizeof (ACSM_STRUCT));
p->userfree = userfree;
p->optiontreefree = optiontreefree;
p->neg_list_free = neg_list_free;
}
return p;
}
/*
* Compile State Machine
*/
int
acsmCompile (ACSM_STRUCT * acsm
#ifdef DETECTION_OPTION_TREE
, int (*build_tree)(void * id, void **existing_tree)
#endif
)
{
int i, k;
ACSM_PATTERN * plist;
/* Count number of states */
acsm->acsmMaxStates = 1;
for (plist = acsm->acsmPatterns; plist != NULL; plist = plist->next)
{
acsm->acsmMaxStates += plist->n;
}
acsm->acsmStateTable =
(ACSM_STATETABLE *) AC_MALLOC (sizeof (ACSM_STATETABLE) *
acsm->acsmMaxStates);
MEMASSERT (acsm->acsmStateTable, "acsmCompile");
memset (acsm->acsmStateTable, 0,
sizeof (ACSM_STATETABLE) * acsm->acsmMaxStates);
/* Initialize state zero as a branch */
acsm->acsmNumStates = 0;
/* Initialize all States NextStates to FAILED */
for (k = 0; k < acsm->acsmMaxStates; k++)
{
for (i = 0; i < ALPHABET_SIZE; i++)
{
acsm->acsmStateTable[k].NextState[i] = ACSM_FAIL_STATE;
}
}
/* Add each Pattern to the State Table */
for (plist = acsm->acsmPatterns; plist != NULL; plist = plist->next)
{
AddPatternStates (acsm, plist);
}
/* Set all failed state transitions to return to the 0'th state */
for (i = 0; i < ALPHABET_SIZE; i++)
{
if (acsm->acsmStateTable[0].NextState[i] == ACSM_FAIL_STATE)
{
acsm->acsmStateTable[0].NextState[i] = 0;
}
}
/* Build the NFA */
Build_NFA (acsm);
/* Convert the NFA to a DFA */
Convert_NFA_To_DFA (acsm);
/*
printf ("ACSMX-Max Memory: %d bytes, %d states\n", max_memory,
acsm->acsmMaxStates);
*/
//Print_DFA( acsm );
#ifdef DETECTION_OPTION_TREE
if (build_tree)
{
acsmBuildMatchStateTrees(acsm, build_tree);
}
#endif
return 0;
}
