~ubuntu-branches/ubuntu/precise/suricata/precise-proposed

 

#include "app-layer-protos.h"

#include "util-cidr.h"

#include "util-unittest.h"

 

    if (sghid->sig_array != NULL) {

        SCFree(sghid->sig_array);

        sghid->sig_array = NULL;

 

        detect_siggroup_sigarray_free_cnt++;

        detect_siggroup_sigarray_memory -= sghid->sig_size;

    }

static SigGroupHeadInitData *SigGroupHeadInitDataAlloc(uint32_t size) {

    SigGroupHeadInitData *sghid = SCMalloc(sizeof(SigGroupHeadInitData));

    if (sghid == NULL)

        return NULL;

 

    memset(sghid, 0x00, sizeof(SigGroupHeadInitData));

 

    detect_siggroup_head_initdata_init_cnt++;

    detect_siggroup_head_initdata_memory += sizeof(SigGroupHeadInitData);

 

    /* initialize the signature bitarray */

    sghid->sig_size = size;

    if ( (sghid->sig_array = SCMalloc(sghid->sig_size)) == NULL)

        goto error;

 

    memset(sghid->sig_array, 0, sghid->sig_size);

 

    detect_siggroup_sigarray_init_cnt++;

    detect_siggroup_sigarray_memory += sghid->sig_size;

 

    return sghid;

error:

    SigGroupHeadInitDataFree(sghid);

    return NULL;

}

 

void SigGroupHeadStore(DetectEngineCtx *de_ctx, SigGroupHead *sgh) {

    //printf("de_ctx->sgh_array_cnt %u, de_ctx->sgh_array_size %u, de_ctx->sgh_array %p\n", de_ctx->sgh_array_cnt, de_ctx->sgh_array_size, de_ctx->sgh_array);

    if (de_ctx->sgh_array_cnt < de_ctx->sgh_array_size) {

        de_ctx->sgh_array[de_ctx->sgh_array_cnt] = sgh;

    } else {

        de_ctx->sgh_array = SCRealloc(de_ctx->sgh_array, sizeof(SigGroupHead *) * (16 + de_ctx->sgh_array_size));

        if (de_ctx->sgh_array == NULL)

            return;

        de_ctx->sgh_array_size += 10;

        de_ctx->sgh_array[de_ctx->sgh_array_cnt] = sgh;

    }

    de_ctx->sgh_array_cnt++;

}

 

static SigGroupHead *SigGroupHeadAlloc(DetectEngineCtx *de_ctx, uint32_t size)

        detect_siggroup_matcharray_memory -= (sgh->sig_cnt * sizeof(Signature *));

    sgh->sig_cnt = 0;

 

 * \brief The hash function to be the used by the mpm uri SigGroupHead hash

 *        table - DetectEngineCtx->sgh_mpm_uri_hash_table.

 *

 * \param ht      Pointer to the hash table.

 * \param data    Pointer to the SigGroupHead.

 * \param datalen Not used in our case.

 *

 * \retval hash The generated hash value.

 */

uint32_t SigGroupHeadMpmStreamHashFunc(HashListTable *ht, void *data, uint16_t datalen)

{

    SigGroupHead *sgh = (SigGroupHead *)data;

    uint32_t hash = 0;

    uint32_t b = 0;

 

    for (b = 0; b < sgh->init->stream_content_size; b++)

        hash += sgh->init->stream_content_array[b];

 

    return hash % ht->array_size;

}

 

/**

 * \brief The Compare function to be used by the mpm uri SigGroupHead hash

 *        table - DetectEngineCtx->sgh_mpm_uri_hash_table.

 *

 * \param data1 Pointer to the first SigGroupHead.

 * \param len1  Not used.

 * \param data2 Pointer to the second SigGroupHead.

 * \param len2  Not used.

 *

 * \retval 1 If the 2 SigGroupHeads sent as args match.

 * \retval 0 If the 2 SigGroupHeads sent as args do not match.

 */

char SigGroupHeadMpmStreamCompareFunc(void *data1, uint16_t len1, void *data2,

                                   uint16_t len2)

{

    SigGroupHead *sgh1 = (SigGroupHead *)data1;

    SigGroupHead *sgh2 = (SigGroupHead *)data2;

 

    if (sgh1->init->stream_content_size != sgh2->init->stream_content_size)

        return 0;

 

    if (memcmp(sgh1->init->stream_content_array, sgh2->init->stream_content_array,

               sgh1->init->stream_content_size) != 0) {

        return 0;

    }

 

    return 1;

}

 

/**

 * \brief Initializes the mpm uri hash table to be used by the detection engine

 *        context.

 *

 * \param de_ctx Pointer to the detection engine context.

 *

 * \retval  0 On success.

 * \retval -1 On failure.

 */

int SigGroupHeadMpmStreamHashInit(DetectEngineCtx *de_ctx)

{

    de_ctx->sgh_mpm_stream_hash_table = HashListTableInit(4096,

            SigGroupHeadMpmStreamHashFunc, SigGroupHeadMpmStreamCompareFunc, NULL);

    if (de_ctx->sgh_mpm_stream_hash_table == NULL)

        goto error;

 

    return 0;

 

error:

    return -1;

}

 

/**

 * \brief Adds a SigGroupHead to the detection engine context SigGroupHead

 *        mpm uri hash table.

 *

 * \param de_ctx Pointer to the detection engine context.

 * \param sgh    Pointer to the SigGroupHead.

 *

 * \retval ret 0 on Successfully adding the argument sgh and -1 on failure.

 */

int SigGroupHeadMpmStreamHashAdd(DetectEngineCtx *de_ctx, SigGroupHead *sgh)

{

    int ret = HashListTableAdd(de_ctx->sgh_mpm_stream_hash_table, (void *)sgh, 0);

 

    return ret;

}

 

/**

 * \brief Used to lookup a SigGroupHead from the detection engine context

 *        SigGroupHead mpm uri hash table.

 *

 * \param de_ctx Pointer to the detection engine context.

 * \param sgh    Pointer to the SigGroupHead.

 *

 * \retval rsgh On success a pointer to the SigGroupHead if the SigGroupHead is

 *              found in the hash table; NULL on failure.

 */

SigGroupHead *SigGroupHeadMpmStreamHashLookup(DetectEngineCtx *de_ctx,

                                           SigGroupHead *sgh)

{

    SigGroupHead *rsgh = HashListTableLookup(de_ctx->sgh_mpm_stream_hash_table,

                                             (void *)sgh, 0);

 

    return rsgh;

}

 

/**

 * \brief Frees the hash table - DetectEngineCtx->sgh_mpm_uri_hash_table,

 *        allocated by SigGroupHeadMpmUriHashInit() function.

 *

 * \param de_ctx Pointer to the detection engine context.

 */

void SigGroupHeadMpmStreamHashFree(DetectEngineCtx *de_ctx)

{

    if (de_ctx->sgh_mpm_stream_hash_table == NULL)

        return;

 

    HashListTableFree(de_ctx->sgh_mpm_stream_hash_table);

    de_ctx->sgh_mpm_stream_hash_table = NULL;

 

    return;

}

 

/**

    for (b = 0; b < sgh->init->sig_size; b++)

        hash += sgh->init->sig_array[b];

    SCLogDebug("hash %"PRIu32" (sig_size %"PRIu32")", hash, sgh->init->sig_size);

    if (sgh1->init->sig_size != sgh2->init->sig_size)

    if (memcmp(sgh1->init->sig_array, sgh2->init->sig_array, sgh1->init->sig_size) != 0)

         htb = HashListTableGetListNext(htb))

    {

        if (sgh->init->sig_array != NULL) {

            detect_siggroup_sigarray_memory -= sgh->init->sig_size;

            SCFree(sgh->init->sig_array);

            sgh->init->sig_array = NULL;

            sgh->init->sig_size = 0;

        *sgh = SigGroupHeadAlloc(de_ctx, DetectEngineGetMaxSigId(de_ctx) / 8 + 1);

    (*sgh)->init->sig_array[s->num / 8] |= 1 << (s->num % 8);

    if (s->flags & SIG_FLAG_MPM_URI) {

    if (sgh->init->sig_array != NULL)

        memset(sgh->init->sig_array, 0, sgh->init->sig_size);

        *dst = SigGroupHeadAlloc(de_ctx, DetectEngineGetMaxSigId(de_ctx) / 8 + 1);

    for (idx = 0; idx < src->init->sig_size; idx++)

        (*dst)->init->sig_array[idx] = (*dst)->init->sig_array[idx] | src->init->sig_array[idx];

        if (sgh->init->sig_array[sig / 8] & (1 << (sig % 8)))

    for (u = 0; u < (sgh->init->sig_size * 8); u++) {

        if (sgh->init->sig_array[u / 8] & (1 << (u % 8))) {

        s = sgh->match_array[sig];

        if (s->alproto != ALPROTO_UNKNOWN)

            continue;

 

        s = sgh->match_array[sig];

 * \brief Loads all the content ids from all the contents belonging to all the

 *        Signatures in this SigGroupHead, into a bitarray.  A fast and an

 *        efficient way of comparing pattern sets.

 *

 * \param de_ctx Pointer to the detection engine context.

 * \param sgh    Pointer to the SigGroupHead.

 *

 * \retval  0 On success, i.e. on either the detection engine context being NULL

 *            or on succesfully allocating memory and updating it with relevant

 *            data.

 * \retval -1 On failure.

 */

int SigGroupHeadLoadStreamContent(DetectEngineCtx *de_ctx, SigGroupHead *sgh)

{

    Signature *s = NULL;

    SigMatch *sm = NULL;

    uint32_t sig = 0;

    DetectContentData *co = NULL;

 

    if (sgh == NULL)

        return 0;

 

    if (DetectContentMaxId(de_ctx) == 0)

        return 0;

 

    BUG_ON(sgh->init == NULL);

 

    sgh->init->stream_content_size = (DetectContentMaxId(de_ctx) / 8) + 1;

    sgh->init->stream_content_array = SCMalloc(sgh->init->stream_content_size);

    if (sgh->init->stream_content_array == NULL)

        return -1;

 

    memset(sgh->init->stream_content_array,0, sgh->init->stream_content_size);

 

    for (sig = 0; sig < sgh->sig_cnt; sig++) {

        s = sgh->match_array[sig];

        if (s == NULL)

            continue;

 

        if (!(s->flags & SIG_FLAG_MPM))

            continue;

 

        if (s->flags & SIG_FLAG_DSIZE)

            continue;

 

        sm = s->pmatch;

        if (sm == NULL)

            continue;

 

        for ( ;sm != NULL; sm = sm->next) {

            if (sm->type == DETECT_CONTENT) {

                co = (DetectContentData *)sm->ctx;

 

                sgh->init->stream_content_array[co->id / 8] |= 1 << (co->id % 8);

            }

        }

    }

 

    return 0;

}

 

/**

 * \brief Clears the memory allocated by SigGroupHeadLoadContent() for the

 *        bitarray to hold the content ids for a SigGroupHead.

 *

 * \param Pointer to the SigGroupHead whose content_array would to be cleared.

 *

 * \ret 0 Always.

 */

int SigGroupHeadClearStreamContent(SigGroupHead *sh)

{

    if (sh == NULL)

        return 0;

 

    if (sh->init->stream_content_array != NULL) {

        SCFree(sh->init->stream_content_array);

        sh->init->stream_content_array = NULL;

        sh->init->stream_content_size = 0;

    }

    return 0;

}

 

/**

    sgh->match_array = SCMalloc(sgh->sig_cnt * sizeof(Signature *));

    memset(sgh->match_array,0, sgh->sig_cnt * sizeof(Signature *));

    detect_siggroup_matcharray_memory += (sgh->sig_cnt * sizeof(Signature *));

        if (!(sgh->init->sig_array[(sig / 8)] & (1 << (sig % 8))) )

        sgh->match_array[idx] = s;

        idx++;

    }

 

    return 0;

}

 

int SigGroupHeadBuildHeadArray(DetectEngineCtx *de_ctx, SigGroupHead *sgh)

{

    Signature *s = NULL;

    uint32_t idx = 0;

    uint32_t sig = 0;

 

    if (sgh == NULL)

        return 0;

 

    BUG_ON(sgh->head_array != NULL);

 

    sgh->head_array = SCMalloc(sgh->sig_cnt * sizeof(SignatureHeader));

    if (sgh->head_array == NULL)

        return -1;

 

    memset(sgh->head_array, 0, sgh->sig_cnt * sizeof(SignatureHeader));

 

    detect_siggroup_matcharray_init_cnt++;

    detect_siggroup_matcharray_memory += (sgh->sig_cnt * sizeof(SignatureHeader *));

 

    for (sig = 0; sig < sgh->sig_cnt; sig++) {

        s = sgh->match_array[sig];

        if (s == NULL)

            continue;

 

        sgh->head_array[idx].flags = s->flags;

        sgh->head_array[idx].mpm_pattern_id = s->mpm_pattern_id;

        sgh->head_array[idx].alproto = s->alproto;

        sgh->head_array[idx].num = s->num;

        sgh->head_array[idx].full_sig = s;

 

        BUG_ON(s->flags != sgh->head_array[idx].flags);

        BUG_ON(s->alproto != sgh->head_array[idx].alproto);

        BUG_ON(s->mpm_pattern_id != sgh->head_array[idx].mpm_pattern_id);

        BUG_ON(s->num != sgh->head_array[idx].num);

        BUG_ON(s != sgh->head_array[idx].full_sig);

 

        if (sgh->init->sig_array == NULL) {

        if ( !(sgh->init->sig_array[sig / 8] & (1 << (sig % 8))) )

    result &= (sh->match_array[0] == de_ctx->sig_list);

    result &= (sh->match_array[1] == de_ctx->sig_list->next->next);

    result &= (sh->match_array[2] == de_ctx->sig_list->next->next->next->next);

    SigGroupHead *sgh = SigMatchSignaturesGetSgh(de_ctx, det_ctx, &p);