const char* ConfigurationGetValue(const struct Configuration* configuration, const char* section, const char* key) {
const struct Table* currentSection = &configuration->root;
if (section) {
currentSection = HashTableLookup(&configuration->sections, section);
if (!currentSection) {
return 0;
}
}
return HashTableLookup(currentSection, key);
}
rc_t KVPFileFindOrInsert(KVPFile *self, KVPValue *xval,
bool *was_inserted, size_t alloc_size,
const void *key, size_t ksize
)
{
KVPValueImpl *val = ( KVPValueImpl* ) xval;
HashTableIterator iter = HashTableLookup(self->ht, key, ksize);
if (HashTableIteratorHasValue(&iter)) {
val->file = (void *)self;
val->offset = (intptr_t)HashTableIteratorGetValue(&iter);
val->size = 1;
*was_inserted = false;
return 0;
}
else {
size_t new_id = self->next_obj++;
my_key_t *new_key = KTempMMapPointer(&self->keys, new_id, 1);
new_key->len = ksize;
memmove(new_key->key, key, ksize);
*was_inserted = true;
val->file = (void *)self;
val->offset = new_id;
val->size = 1;
HashTableIteratorSetValue(&iter, (void *)(val->offset));
}
return 0;
}
void DigestCacheSet(DigestCache* self, const char* filename, uint32_t hash, uint64_t timestamp, const HashDigest& digest)
{
ReadWriteLockWrite(&self->m_Lock);
DigestCacheRecord* r;
if (nullptr != (r = (DigestCacheRecord*) HashTableLookup(&self->m_Table, hash, filename)))
{
r->m_Timestamp = timestamp;
r->m_ContentDigest = digest;
r->m_AccessTime = self->m_AccessTime;
}
else
{
r = LinearAllocate<DigestCacheRecord>(&self->m_Allocator);
r->m_Hash = hash;
r->m_ContentDigest = digest;
r->m_Next = nullptr;
r->m_String = StrDup(&self->m_Allocator, filename);
r->m_Timestamp = timestamp;
r->m_AccessTime = self->m_AccessTime;
HashTableInsert(&self->m_Table, r);
}
ReadWriteUnlockWrite(&self->m_Lock);
}
static FunctionMeta* FindFunction(lua_State* L, lua_Debug* ar)
{
// This is slow, it involves string formatting. It's mostly OK, because we're
// careful not to include this in the timings. It will of course affect cache
// and other things. Not that we can make a lot of informed decisions about
// that in an interpreted language anyway.
if (!lua_getinfo(L, "Sn", ar))
Croak("couldn't get debug info for function call");
char buffer[1024];
snprintf(buffer, sizeof(buffer), "%s;%s;%s;%d",
ar->name ? ar->name : "", ar->namewhat ? ar->namewhat : "", ar->source, ar->linedefined);
buffer[(sizeof buffer)-1] = 0;
const uint32_t hash = Djb2Hash(buffer);
HashRecord* r = HashTableLookup(&s_Profiler.m_Functions, hash, buffer);
if (!r) {
r = LinearAllocate<FunctionMeta>(s_Profiler.m_Allocator);
r->m_Hash = hash;
r->m_String = StrDup(s_Profiler.m_Allocator, buffer);
r->m_Next = nullptr;
HashTableInsert(&s_Profiler.m_Functions, r);
}
return static_cast<FunctionMeta*>(r);
}
static int HashTableTestFull02 (void)
{
int result = 0;
HashTable *ht = HashTableInit(32, HashTableGenericHash, NULL, NULL);
if (ht == NULL)
goto end;
int r = HashTableAdd(ht, "test", 4);
if (r != 0)
goto end;
char *rp = HashTableLookup(ht, "test", 4);
if (rp == NULL)
goto end;
r = HashTableRemove(ht, "test2", 5);
if (r == 0)
goto end;
/* all is good! */
result = 1;
end:
if (ht != NULL) HashTableFree(ht);
return result;
}
void ConfigurationEnumerate(const struct Configuration* configuration, const char* section, void (*handler)(const char* key, const char* value, void* user), void* user) {
struct ConfigurationHandlerData handlerData = { handler, user };
const struct Table* currentSection = &configuration->root;
if (section) {
currentSection = HashTableLookup(&configuration->sections, section);
}
if (currentSection) {
HashTableEnumerate(currentSection, _enumHandler, &handlerData);
}
}
void ConfigurationClearValue(struct Configuration* configuration, const char* section, const char* key) {
struct Table* currentSection = &configuration->root;
if (section) {
currentSection = HashTableLookup(&configuration->sections, section);
if (!currentSection) {
return;
}
}
HashTableRemove(currentSection, key);
}
/**
* \test Check if the reference info from the reference.config file have
* been loaded into the hash table.
*/
int SCRConfTest06(void)
{
DetectEngineCtx *de_ctx = DetectEngineCtxInit();
SCRConfReference *ref = NULL;
int result = 1;
if (de_ctx == NULL)
return 0;
SCRConfGenerateInValidDummyReferenceConfigFD02();
SCRConfLoadReferenceConfigFile(de_ctx);
SCRConfDeleteDummyReferenceConfigFD();
if (de_ctx->reference_conf_ht == NULL)
goto end;
result = (de_ctx->reference_conf_ht->count == 1);
ref = SCRConfAllocSCRConfReference("one", "one");
result &= (HashTableLookup(de_ctx->reference_conf_ht, ref, 0) != NULL);
SCRConfDeAllocSCRConfReference(ref);
ref = SCRConfAllocSCRConfReference("two", "two");
result &= (HashTableLookup(de_ctx->reference_conf_ht, ref, 0) == NULL);
SCRConfDeAllocSCRConfReference(ref);
ref = SCRConfAllocSCRConfReference("three", "three");
result &= (HashTableLookup(de_ctx->reference_conf_ht, ref, 0) == NULL);
SCRConfDeAllocSCRConfReference(ref);
ref = SCRConfAllocSCRConfReference("four", "four");
result &= (HashTableLookup(de_ctx->reference_conf_ht, ref, 0) == NULL);
SCRConfDeAllocSCRConfReference(ref);
ref = SCRConfAllocSCRConfReference("five", "five");
result &= (HashTableLookup(de_ctx->reference_conf_ht, ref, 0) == NULL);
SCRConfDeAllocSCRConfReference(ref);
end:
if (de_ctx != NULL)
DetectEngineCtxFree(de_ctx);
return result;
}
/**
* \brief Parses a line from the reference config file and adds it to Reference
* Config hash table DetectEngineCtx->reference_conf_ht.
*
* \param rawstr Pointer to the string to be parsed.
* \param de_ctx Pointer to the Detection Engine Context.
*
* \retval 0 On success.
* \retval -1 On failure.
*/
static int SCRConfAddReference(char *rawstr, DetectEngineCtx *de_ctx)
{
char system[64];
char url[1024];
SCRConfReference *ref_new = NULL;
SCRConfReference *ref_lookup = NULL;
#define MAX_SUBSTRINGS 30
int ret = 0;
int ov[MAX_SUBSTRINGS];
ret = pcre_exec(regex, regex_study, rawstr, strlen(rawstr), 0, 0, ov, 30);
if (ret < 0) {
SCLogError(SC_ERR_REFERENCE_CONFIG, "Invalid Reference Config in "
"reference.config file");
goto error;
}
/* retrieve the reference system */
ret = pcre_copy_substring((char *)rawstr, ov, 30, 1, system, sizeof(system));
if (ret < 0) {
SCLogError(SC_ERR_PCRE_GET_SUBSTRING, "pcre_copy_substring() failed");
goto error;
}
/* retrieve the reference url */
ret = pcre_copy_substring((char *)rawstr, ov, 30, 2, url, sizeof(url));
if (ret < 0) {
SCLogError(SC_ERR_PCRE_GET_SUBSTRING, "pcre_copy_substring() failed");
goto error;
}
/* Create a new instance of the parsed Reference string */
ref_new = SCRConfAllocSCRConfReference(system, url);
if (ref_new == NULL)
goto error;
/* Check if the Reference is present in the HashTable. In case it's present
* ignore it, as it's a duplicate. If not present, add it to the table */
ref_lookup = HashTableLookup(de_ctx->reference_conf_ht, ref_new, 0);
if (ref_lookup == NULL) {
if (HashTableAdd(de_ctx->reference_conf_ht, ref_new, 0) < 0) {
SCLogDebug("HashTable Add failed");
}
} else {
SCLogDebug("Duplicate reference found inside reference.config");
SCRConfDeAllocSCRConfReference(ref_new);
}
return 0;
error:
return -1;
}
rc_t KVPFileFind(const KVPFile *self, KVPValue *xval, const void *key, size_t ksize)
{
KVPValueImpl *val = ( KVPValueImpl* ) xval;
const HashTableIterator iter = HashTableLookup(self->ht, key, ksize);
if (HashTableIteratorHasValue(&iter)) {
val->file = (void *)self;
val->offset = (intptr_t)HashTableIteratorGetValue(&iter);
val->size = 1;
return 0;
}
return RC(rcApp, rcMemMap, rcReading, rcId, rcNotFound);
}
/**
* \brief Gets the refernce config from the corresponding hash table stored
* in the Detection Engine Context's reference conf ht, given the
* reference name.
*
* \param ct_name Pointer to the reference name that has to be looked up.
* \param de_ctx Pointer to the Detection Engine Context.
*
* \retval lookup_rconf_info Pointer to the SCRConfReference instance from
* the hash table on success; NULL on failure.
*/
SCRConfReference *SCRConfGetReference(const char *rconf_name,
DetectEngineCtx *de_ctx)
{
SCRConfReference *ref_conf = SCRConfAllocSCRConfReference(rconf_name, NULL);
if (ref_conf == NULL)
return NULL;
SCRConfReference *lookup_ref_conf = HashTableLookup(de_ctx->reference_conf_ht,
ref_conf, 0);
SCRConfDeAllocSCRConfReference(ref_conf);
return lookup_ref_conf;
}
/**
* \brief Gets the classtype from the corresponding hash table stored
* in the Detection Engine Context's class conf ht, given the
* classtype name.
*
* \param ct_name Pointer to the classtype name that has to be looked up.
* \param de_ctx Pointer to the Detection Engine Context.
*
* \retval lookup_ct_info Pointer to the SCClassConfClasstype instance from
* the hash table on success; NULL on failure.
*/
SCClassConfClasstype *SCClassConfGetClasstype(const char *ct_name,
DetectEngineCtx *de_ctx)
{
SCClassConfClasstype *ct_info = SCClassConfAllocClasstype(0, ct_name, NULL,
0);
if (ct_info == NULL)
return NULL;
SCClassConfClasstype *lookup_ct_info = HashTableLookup(de_ctx->class_conf_ht,
ct_info, 0);
SCClassConfDeAllocClasstype(ct_info);
return lookup_ct_info;
}
void
HashTableInsert(HashTable_t* h, HashEntry_t* e)
{
HashEntry_t *slot = HashTableLookup(h,e->key,1);
if (slot->key != 0xffffffff)
{
printf("Slot already used\n");
exit(-1);
}
slot->key = e->key;
slot->data = e->data;
}
/**
* \brief Gets the classtype from the corresponding hash table stored
* in the Detection Engine Context's class conf ht, given the
* classtype name.
*
* \param ct_name Pointer to the classtype name that has to be looked up.
* \param de_ctx Pointer to the Detection Engine Context.
*
* \retval lookup_ct_info Pointer to the SCClassConfClasstype instance from
* the hash table on success; NULL on failure.
*/
SCClassConfClasstype *SCClassConfGetClasstype(const char *ct_name,
DetectEngineCtx *de_ctx)
{
char name[strlen(ct_name) + 1];
size_t s;
for (s = 0; s < strlen(ct_name); s++)
name[s] = tolower((unsigned char)ct_name[s]);
name[s] = '\0';
SCClassConfClasstype ct_lookup = {0, name, NULL, 0 };
SCClassConfClasstype *lookup_ct_info = HashTableLookup(de_ctx->class_conf_ht,
&ct_lookup, 0);
return lookup_ct_info;
}
static NTSTATUS
GnttabUnmapForeignPages(
IN PINTERFACE Interface,
IN PHYSICAL_ADDRESS Address
)
{
PXENBUS_GNTTAB_CONTEXT Context = Interface->Context;
ULONG PageIndex;
PHYSICAL_ADDRESS PageAddress;
PXENBUS_GNTTAB_MAP_ENTRY MapEntry;
NTSTATUS status;
status = HashTableLookup(Context->MapTable,
(ULONG_PTR)Address.QuadPart,
(PULONG_PTR)&MapEntry);
if (!NT_SUCCESS(status))
goto fail1;
status = HashTableRemove(Context->MapTable,
(ULONG_PTR)Address.QuadPart);
if (!NT_SUCCESS(status))
goto fail2;
PageAddress.QuadPart = Address.QuadPart;
for (PageIndex = 0; PageIndex < MapEntry->NumberPages; PageIndex++) {
status = GrantTableUnmapForeignPage(MapEntry->MapHandles[PageIndex],
PageAddress);
BUG_ON(!NT_SUCCESS(status));
PageAddress.QuadPart += PAGE_SIZE;
}
FdoFreeIoSpace(Context->Fdo,
Address,
MapEntry->NumberPages * PAGE_SIZE);
__GnttabFree(MapEntry);
return STATUS_SUCCESS;
fail2:
Error("fail2\n");
fail1:
Error("fail1: (%08x)\n", status);
return status;
}
bool ConfigurationWriteSection(const struct Configuration* configuration, const char* path, const char* section) {
const struct Table* currentSection = &configuration->root;
FILE* file = fopen(path, "w");
if (!file) {
return false;
}
if (section) {
currentSection = HashTableLookup(&configuration->sections, section);
fprintf(file, "[%s]\n", section);
}
if (currentSection) {
HashTableEnumerate(currentSection, _sectionHandler, file);
}
fclose(file);
return true;
}
void ConfigurationSetValue(struct Configuration* configuration, const char* section, const char* key, const char* value) {
struct Table* currentSection = &configuration->root;
if (section) {
currentSection = HashTableLookup(&configuration->sections, section);
if (!currentSection) {
if (value) {
currentSection = malloc(sizeof(*currentSection));
HashTableInit(currentSection, 0, _sectionDeinit);
HashTableInsert(&configuration->sections, section, currentSection);
} else {
return;
}
}
}
if (value) {
HashTableInsert(currentSection, key, strdup(value));
} else {
HashTableRemove(currentSection, key);
}
}
bool ConfigurationWriteSection(const struct Configuration* configuration, const char* path, const char* section) {
const struct Table* currentSection = &configuration->root;
struct VFile* vf = VFileOpen(path, O_WRONLY | O_CREAT | O_APPEND);
if (!vf) {
return false;
}
if (section) {
currentSection = HashTableLookup(&configuration->sections, section);
char line[256];
size_t len = snprintf(line, sizeof(line), "[%s]\n", section);
if (len >= sizeof(line)) {
len = sizeof(line) - 1;
}
vf->write(vf, line, len);
}
if (currentSection) {
HashTableEnumerate(currentSection, _sectionHandler, vf);
}
vf->close(vf);
return true;
}
bool DigestCacheGet(DigestCache* self, const char* filename, uint32_t hash, uint64_t timestamp, HashDigest* digest_out)
{
bool result = false;
ReadWriteLockRead(&self->m_Lock);
if (DigestCacheRecord* r = (DigestCacheRecord*) HashTableLookup(&self->m_Table, hash, filename))
{
if (r->m_Timestamp == timestamp)
{
// Technically violates r/w lock - doesn't matter
r->m_AccessTime = self->m_AccessTime;
*digest_out = r->m_ContentDigest;
result = true;
}
}
ReadWriteUnlockRead(&self->m_Lock);
return result;
}
/**
* \test Check if the classtype info from the invalid classification.config file
* have not been loaded into the hash table, and cross verify to check
* that the hash table contains no classtype data.
*/
int SCClassConfTest05(void)
{
DetectEngineCtx *de_ctx = DetectEngineCtxInit();
SCClassConfClasstype *ct = NULL;
int result = 1;
if (de_ctx == NULL)
return 0;
SCClassConfGenerateInValidDummyClassConfigFD03();
SCClassConfLoadClassficationConfigFile(de_ctx);
SCClassConfDeleteDummyClassificationConfigFD();
if (de_ctx->class_conf_ht == NULL)
return 0;
result = (de_ctx->class_conf_ht->count == 0);
ct = SCClassConfAllocClasstype(0, "unknown", NULL, 0);
result &= (HashTableLookup(de_ctx->class_conf_ht, ct, 0) == NULL);
SCClassConfDeAllocClasstype(ct);
ct = SCClassConfAllocClasstype(0, "unKnoWn", NULL, 0);
result &= (HashTableLookup(de_ctx->class_conf_ht, ct, 0) == NULL);
SCClassConfDeAllocClasstype(ct);
ct = SCClassConfAllocClasstype(0, "bamboo", NULL, 0);
result &= (HashTableLookup(de_ctx->class_conf_ht, ct, 0) == NULL);
SCClassConfDeAllocClasstype(ct);
ct = SCClassConfAllocClasstype(0, "bad-unknown", NULL, 0);
result &= (HashTableLookup(de_ctx->class_conf_ht, ct, 0) == NULL);
SCClassConfDeAllocClasstype(ct);
ct = SCClassConfAllocClasstype(0, "BAD-UNKnOWN", NULL, 0);
result &= (HashTableLookup(de_ctx->class_conf_ht, ct, 0) == NULL);
SCClassConfDeAllocClasstype(ct);
ct = SCClassConfAllocClasstype(0, "bed-unknown", NULL, 0);
result &= (HashTableLookup(de_ctx->class_conf_ht, ct, 0) == NULL);
SCClassConfDeAllocClasstype(ct);
DetectEngineCtxFree(de_ctx);
return result;
}
/**
* \test Check if the classtype info from the classification.config file have
* been loaded into the hash table.
*/
int SCClassConfTest06(void)
{
DetectEngineCtx *de_ctx = DetectEngineCtxInit();
SCClassConfClasstype *ct = NULL;
int result = 1;
if (de_ctx == NULL)
return 0;
SCClassConfGenerateInValidDummyClassConfigFD02();
SCClassConfLoadClassficationConfigFile(de_ctx);
SCClassConfDeleteDummyClassificationConfigFD();
if (de_ctx->class_conf_ht == NULL)
return 0;
result = (de_ctx->class_conf_ht->count == 3);
ct = SCClassConfAllocClasstype(0, "unknown", NULL, 0);
result &= (HashTableLookup(de_ctx->class_conf_ht, ct, 0) == NULL);
SCClassConfDeAllocClasstype(ct);
ct = SCClassConfAllocClasstype(0, "not-suspicious", NULL, 0);
result &= (HashTableLookup(de_ctx->class_conf_ht, ct, 0) != NULL);
SCClassConfDeAllocClasstype(ct);
ct = SCClassConfAllocClasstype(0, "bamboola1", NULL, 0);
result &= (HashTableLookup(de_ctx->class_conf_ht, ct, 0) != NULL);
SCClassConfDeAllocClasstype(ct);
ct = SCClassConfAllocClasstype(0, "bamboola1", NULL, 0);
result &= (HashTableLookup(de_ctx->class_conf_ht, ct, 0) != NULL);
SCClassConfDeAllocClasstype(ct);
ct = SCClassConfAllocClasstype(0, "BAMBOolA1", NULL, 0);
result &= (HashTableLookup(de_ctx->class_conf_ht, ct, 0) != NULL);
SCClassConfDeAllocClasstype(ct);
ct = SCClassConfAllocClasstype(0, "unkNOwn", NULL, 0);
result &= (HashTableLookup(de_ctx->class_conf_ht, ct, 0) == NULL);
SCClassConfDeAllocClasstype(ct);
DetectEngineCtxFree(de_ctx);
return result;
}
bool ConfigurationHasSection(const struct Configuration* configuration, const char* section) {
return HashTableLookup(&configuration->sections, section);
}
char *var(char *name) {
char *ret;
if (!symtab) { shellinit(); return nullstring; }
ret = HashTableLookup(symtab,name);
return ret ? ret : nullstring;
}
int main(int argc, char* argv[])
{
//Check for the number of arguments
if(argc != 4){
printf("Invalid Input Argument\n");
printHelp();
exit(1);
}
//direcotry file path
int dirSize = strlen(argv[2]);
char dir[dirSize + 1];
dir[0] = '\0';
strcat(dir, argv[2]);
int urlSize = strlen(argv[1]);
char inputURL[urlSize + 1];
inputURL[0] = '\0';
strcat(inputURL, argv[1]);
//Get the max depth number.
int inputDepth = atoi(argv[3]);
//Check if correct depth is provided.
if(inputDepth > 4 || inputDepth < 0){
printf("Invalid [depth]\n");
printHelp();
exit(1);
}
//Check for URL validity
if(!strstr(inputURL,URL_PREFIX)){
printf("Invalid input [seed url]\n");
printHelp();
exit(1);
}
//checkf for directory location validity
DIR* directory = opendir(dir);
if(directory){
closedir(directory);
}
else if(ENOENT == errno){
printf("Directory does not exist\n");
printHelp();
exit(1);
}
else{
printf("Directory can't be opened\n");
printHelp();
exit(1);
}
// init curl
curl_global_init(CURL_GLOBAL_ALL);
// setup seed page
WebPage* seedWebPage = calloc(1, sizeof(WebPage));//Memory allocation for seed webpage
seedWebPage->url = calloc((strlen(inputURL) + 1), sizeof(char));//Memory allocation to the seedURL
seedWebPage->url[0] = '\0';
strcat(seedWebPage->url, inputURL);
seedWebPage->depth = 0;
seedWebPage->html = NULL;
//Initialize data structures
HashTable* visitedURLHash = initHashTable();
List* webPageList = initializeList();
webPageList->head->page = seedWebPage;
//get seed webpage.
if(GetWebPage(seedWebPage)){
// write seed file
FILE *fPointer;
char* pathVar1 = pathToDirectory(dir, fileNumber);
fPointer = fopen(pathVar1, "w");
free(pathVar1);
writeHTMLtoFile(fPointer, seedWebPage);
//free(fPointer);
if(inputDepth == 0){
curl_global_cleanup();
free(seedWebPage->html);
free(seedWebPage->url);
free(seedWebPage);
//free webPageList and hashtable
free(webPageList);
for(int i = 0; i < MAX_HASH_SLOT; i++){
free(visitedURLHash->table[i]->url);
free(visitedURLHash->table[i]);
}
free(visitedURLHash);
return 0;
}
fileNumber += 1;
depth += 1;
HashTableInsert(visitedURLHash, seedWebPage->url); //mark as visited
// extract urls from seed page
char * result;
int pos = 0;
while((pos = GetNextURL(seedWebPage->html, pos, seedWebPage->url, &result))>0){
if(NormalizeURL(result) && strstr(result,URL_PREFIX)){
strtok(result, "#");
//If not in hashtable, add it to the hashtable and add it to the webPageList.
if(HashTableLookup(visitedURLHash, result) == 0){
HashTableInsert(visitedURLHash, result);
AppendList(webPageList, webPageInit(result, depth));
free(result);
}
}
}
if(webPageList->head->next->next == NULL){ //seed redirect case
webPageList->head->next->page->depth = 0;
fileNumber = 1;
}
tempWebPage = PopList(webPageList); // Get rid of visited seedPage
}
else{
curl_global_cleanup();
tempWebPage = PopList(webPageList);
free(seedWebPage->html);
free(seedWebPage->url);
free(seedWebPage);
//free(tempWebPage);
free(webPageList);
for(int i = 0; i < MAX_HASH_SLOT; i++){
free(visitedURLHash->table[i]->url);
free(visitedURLHash->table[i]);
}
free(visitedURLHash);
exit(1);
}
//while there are urls to crawl
while(webPageList->head != NULL && webPageList->tail != NULL){
// get webpage for url
tempWebPage = PopList(webPageList);
if(GetWebPage(tempWebPage)){
// write page file
char* pathVar = pathToDirectory(dir, fileNumber);
FILE *fPointer = fopen(pathVar, "w");
free(pathVar);
printf("Found link: %s\n",tempWebPage->url);
writeHTMLtoFile(fPointer, tempWebPage);
fileNumber += 1;
if((tempWebPage->depth + 1) <= inputDepth ){
char * resultTemp;
int posTemp = 0;
while((posTemp = GetNextURL(tempWebPage->html, posTemp, tempWebPage->url, &resultTemp))>0){
if( NormalizeURL(resultTemp) && strstr(resultTemp,URL_PREFIX) ){
strtok(resultTemp, "#");
//insert to the hashtable and the webPageList if not already present
if(HashTableLookup(visitedURLHash, resultTemp) == 0){
HashTableInsert(visitedURLHash, resultTemp);
AppendList(webPageList, webPageInit(resultTemp, tempWebPage->depth+1));
}
}
free(resultTemp);
}
}
free(tempWebPage->url);
free(tempWebPage->html);
free(tempWebPage);
}
else{
free(tempWebPage->url);
free(tempWebPage->html);
free(tempWebPage);
}
sleep(INTERVAL_PER_FETCH);
}
// cleanup curl
curl_global_cleanup();
free(seedWebPage->url);
free(seedWebPage->html);
free(seedWebPage);
free(webPageList);
//free the hashtable
for(int i = 0; i < MAX_HASH_SLOT; i++){
if(visitedURLHash->table[i]->url != NULL){
HashTableNode* currNode = visitedURLHash->table[i];
while(currNode->next != NULL){
HashTableNode* tempNode = currNode;
currNode = currNode->next;
free(tempNode->url);
free(tempNode);
}
free(currNode->url);
free(currNode);
}
else{
free(visitedURLHash->table[i]);
}
}
free(visitedURLHash);
return 0;
}
/**
* \brief Parses a line from the classification file and adds it to Classtype
* hash table in DetectEngineCtx, i.e. DetectEngineCtx->class_conf_ht.
*
* \param rawstr Pointer to the string to be parsed.
* \param index Relative index of the string to be parsed.
* \param de_ctx Pointer to the Detection Engine Context.
*
* \retval 0 On success.
* \retval -1 On failure.
*/
int SCClassConfAddClasstype(char *rawstr, uint8_t index, DetectEngineCtx *de_ctx)
{
const char *ct_name = NULL;
const char *ct_desc = NULL;
const char *ct_priority_str = NULL;
int ct_priority = 0;
uint8_t ct_id = index;
SCClassConfClasstype *ct_new = NULL;
SCClassConfClasstype *ct_lookup = NULL;
#define MAX_SUBSTRINGS 30
int ret = 0;
int ov[MAX_SUBSTRINGS];
ret = pcre_exec(regex, regex_study, rawstr, strlen(rawstr), 0, 0, ov, 30);
if (ret < 0) {
SCLogError(SC_ERR_INVALID_SIGNATURE, "Invalid Classtype in "
"classification.config file");
goto error;
}
/* retrieve the classtype name */
ret = pcre_get_substring((char *)rawstr, ov, 30, 1, &ct_name);
if (ret < 0) {
SCLogInfo("pcre_get_substring() failed");
goto error;
}
/* retrieve the classtype description */
ret = pcre_get_substring((char *)rawstr, ov, 30, 2, &ct_desc);
if (ret < 0) {
SCLogInfo("pcre_get_substring() failed");
goto error;
}
/* retrieve the classtype priority */
ret = pcre_get_substring((char *)rawstr, ov, 30, 3, &ct_priority_str);
if (ret < 0) {
SCLogInfo("pcre_get_substring() failed");
goto error;
}
if (ct_priority_str == NULL) {
goto error;
}
ct_priority = atoi(ct_priority_str);
/* Create a new instance of the parsed Classtype string */
ct_new = SCClassConfAllocClasstype(ct_id, ct_name, ct_desc, ct_priority);
if (ct_new == NULL)
goto error;
/* Check if the Classtype is present in the HashTable. In case it's present
* ignore it, as it is a duplicate. If not present, add it to the table */
ct_lookup = HashTableLookup(de_ctx->class_conf_ht, ct_new, 0);
if (ct_lookup == NULL) {
if (HashTableAdd(de_ctx->class_conf_ht, ct_new, 0) < 0)
SCLogDebug("HashTable Add failed");
} else {
SCLogDebug("Duplicate classtype found inside classification.config");
if (ct_new->classtype_desc) SCFree(ct_new->classtype_desc);
if (ct_new->classtype) SCFree(ct_new->classtype);
SCFree(ct_new);
}
if (ct_name) SCFree((char *)ct_name);
if (ct_desc) SCFree((char *)ct_desc);
if (ct_priority_str) SCFree((char *)ct_priority_str);
return 0;
error:
if (ct_name) SCFree((char *)ct_name);
if (ct_desc) SCFree((char *)ct_desc);
if (ct_priority_str) SCFree((char *)ct_priority_str);
return -1;
}
