diff --git a/src/flow-file.c b/src/flow-file.c new file mode 100644 index 0000000000..6581c7427c --- /dev/null +++ b/src/flow-file.c @@ -0,0 +1,136 @@ +/* Copyright (C) 2007-2010 Open Information Security Foundation + * + * You can copy, redistribute or modify this Program under the terms of + * the GNU General Public License version 2 as published by the Free + * Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * version 2 along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA. + */ + +/** + * \file + * + * \author Pablo Rincon + * + */ + +#include "suricata-common.h" +#include "suricata.h" +#include "debug.h" +#include "flow.h" +#include "flow-file.h" +#include "util-hash.h" +#include "util-debug.h" + + +FlowFileContainer *FlowFileContainerAlloc() { + FlowFileContainer *new = SCMalloc(sizeof(FlowFileContainer)); + if (new == NULL) { + SCLogError(SC_ERR_MEM_ALLOC, "Error allocating mem"); + return NULL; + } + memset(new, 0, sizeof(new)); + new->start = new->end = NULL; + new->cnt = 0; + return new; +} + +void FlowFileContainerRecycle(FlowFileContainer *ffc) { + FlowFile *ptr = ffc->start; + FlowFile *next = NULL; + for (;ptr != NULL && ffc->cnt > 0; ptr = next) { + next = ptr->next; + FlowFileFree(ptr); + ffc->cnt--; + } + ffc->start = ffc->end = NULL; + ffc->cnt = 0; +} + +void FlowFileContainerFree(FlowFileContainer *ffc) { + if (ffc == NULL) + return; + FlowFile *ptr = ffc->start; + FlowFile *next = NULL; + for (;ptr != NULL && ffc->cnt > 0; ptr = next) { + next = ptr->next; + FlowFileFree(ptr); + ffc->cnt--; + } + ffc->start = ffc->end = NULL; + ffc->cnt = 0; + SCFree(ffc); +} + +FlowFileChunk *FlowFileChunkAlloc() { + FlowFileChunk *new = SCMalloc(sizeof(FlowFileChunk)); + if (new == NULL) { + SCLogError(SC_ERR_MEM_ALLOC, "Error allocating mem"); + return NULL; + } + memset(new, 0, sizeof(new)); + return new; +} + +void FlowFileChunkFree(FlowFileChunk *ffc) { + //TODO: To implement + SCFree(ffc); +} + +FlowFile *FlowFileAlloc() { + FlowFile *new = SCMalloc(sizeof(FlowFile)); + if (new == NULL) { + SCLogError(SC_ERR_MEM_ALLOC, "Error allocating mem"); + return NULL; + } + memset(new, 0, sizeof(new)); + new->state = FLOWFILE_STATE_EMPTY; + new->name = NULL; + new->ext = NULL; + new->next = NULL; + return new; +} + +void FlowFileFree(FlowFile *ff) { + if (ff->name != NULL) + SCFree(ff->name); + if (ff->ext != NULL) + SCFree(ff->ext); + SCFree(ff); +} + +void FlowFileContainerAdd(FlowFileContainer *ffc, FlowFile *ff) { + if (ffc->start == NULL) { + ffc->start = ffc->end = ff; + } else { + ffc->end->next = ff; + ffc->end = ff; + } + ffc->cnt += 1; +} + +FlowFile *FlowFileContainerRetrieve(FlowFileContainer *ffc, uint8_t *name, uint16_t alproto, uint8_t *proto_type) { + FlowFile *ptr = ffc->start; + if (ffc->cnt > 0) { + while (ptr != NULL) { + if ( (strcmp((char *)ptr->name, (char *)name) == 0) && ptr->alproto == alproto && (!proto_type || strcmp((char *)ptr->proto_type, (char *)proto_type) == 0)) { + return ptr; + } + ptr = ptr->next; + } + } + return NULL; +} + +FlowFile *FlowFileAppendChunk(FlowFile *ff, FlowFileChunk *ffc) { + //TODO: To implement + return NULL; +} diff --git a/src/flow-file.h b/src/flow-file.h new file mode 100644 index 0000000000..6c7de2ebf2 --- /dev/null +++ b/src/flow-file.h @@ -0,0 +1,90 @@ +/* Copyright (C) 2007-2010 Open Information Security Foundation + * + * You can copy, redistribute or modify this Program under the terms of + * the GNU General Public License version 2 as published by the Free + * Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * version 2 along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA. + */ + +/** + * \file + * + * \author Pablo Rincon + * + */ + +#ifndef __FLOW_FILE_H__ +#define __FLOW_FILE_H__ + +#include "flow.h" +#include "util-hash.h" + + +typedef enum _FlowFileState { + FLOWFILE_STATE_EMPTY, + FLOWFILE_STATE_DATA, + FLOWFILE_STATE_COMPLETED, + FLOWFILE_STATE_STORING, + FLOWFILE_STATE_MAX +} FlowFileState; + +typedef uint8_t FlowFileHash; + +typedef struct _FlowFileChunk { + uint8_t *buf; + uint32_t *len; + struct _FlowFileChunk *next; +} FlowFileChunk; + +typedef struct _FlowFile { + uint8_t *name; + uint16_t name_len; + uint8_t *ext; + uint16_t ext_len; + uint8_t *real_type; + uint16_t real_type_len; + uint8_t *proto_type; /* The content type set at Content-Type in the MIME header (of http or smtp..) */ + uint16_t proto_type_len; + uint16_t alproto; + uint32_t size; + uint8_t flags; + + FlowFileState state; + FlowFileChunk *chunks_start; + FlowFileChunk *chunks_end; + + uint32_t chunk_cnt; + struct _FlowFile *next; +} FlowFile; + +typedef struct _FlowFileContainer { + FlowFile *start; + FlowFile *end; + uint32_t cnt; +} FlowFileContainer; + +FlowFileContainer *FlowFileContainerAlloc(); +void FlowFileContainerFree(FlowFileContainer *); + +void FlowFileContainerRecycle(FlowFileContainer *); + +FlowFileChunk *FlowFileChunkAlloc(); +void FlowFileChunkFree(FlowFileChunk *); + +FlowFile *FlowFileAlloc(); +void FlowFileFree(FlowFile *); + +void FlowFileContainerAdd(FlowFileContainer *, FlowFile *); +FlowFile *FlowFileContainerRetrieve(FlowFileContainer *, uint8_t *, uint16_t, uint8_t *); +FlowFile *FlowFileAppendChunk(FlowFile *, FlowFileChunk *); + +#endif /* __FLOW_FILE_H__ */