return file_process(context, file_data, data_size, position);
}
-void FileFlows::set_file_name(uint8_t* fname, uint32_t name_size)
+void FileFlows::set_file_name(const uint8_t* fname, uint32_t name_size)
{
FileContext* context = get_current_file_context();
if (context)
context->print();
}
-
FilePosition get_file_position(Packet* pkt)
{
FilePosition position = SNORT_FILE_POSITION_UNKNOWN;
#ifndef FILE_FLOWS_H
#define FILE_FLOWS_H
-// This provides a wrapper to start/stop file service
+// This provides a wrapper to manage several file contexts
#include <sys/types.h>
#include "main/snort_types.h"
uint32_t get_new_file_instance();
- void set_file_name(uint8_t* fname, uint32_t name_size);
+ void set_file_name(const uint8_t* fname, uint32_t name_size);
// This is used when there is only one file per session
bool file_process(const uint8_t* file_data, int data_size,
bool file_type_enabled = false;
bool file_signature_enabled = false;
bool file_capture_enabled = false;
- uint8_t* file_name = NULL;
+ uint8_t* file_name = nullptr;
uint32_t file_name_size = 0;
uint64_t file_size = 0;
FileDirection direction = DIRECTION_UNKNOWN;
file_mime_paf.cc
file_mime_process.h
file_mime_process.cc
- decode_base.h.cc
+ decode_base.cc
decode_base.h
decode_b64.cc
decode_b64.h
#include <mime/decode_base.h>
#include "decode_uu.h"
-
#include "utils/snort_bounds.h"
#include "utils/util.h"
#include "utils/util_unfold.h"
-
#define UU_DECODE_CHAR(c) (((c) - 0x20) & 0x3f)
-
void UUDecode::reset_decode_state()
{
reset_decoded_bytes();
* Decode: supports Base64, UU-encoding, QP-encoding, and Bit-encoding
* Log: logs file names and email headers
* Configuration: configure decode and log
-* PAF: provides common processing for PAF (Protocol Wware Flushing)
+* PAF: provides common processing for PAF (Protocol Aware Flushing)
// Main function for mime processing
// This should be called when mime data is available
const uint8_t* MimeSession::process_mime_data(Flow* flow, const uint8_t* start,
- const uint8_t* data_end_marker, bool upload, FilePosition position)
+ int data_size, bool upload, FilePosition position)
{
const uint8_t* attach_start = start;
const uint8_t* attach_end;
+ const uint8_t* data_end_marker = start + data_size;
+
if (position != SNORT_FILE_POSITION_UNKNOWN)
{
- //FilePosition position = file_api->get_file_position(p);
process_mime_data_paf(flow, attach_start, data_end_marker,
upload, position);
return data_end_marker;
virtual ~MimeSession();
static void init();
static void exit();
- const uint8_t* process_mime_data(Flow *flow, const uint8_t *start, const uint8_t *end,
+ const uint8_t* process_mime_data(Flow *flow, const uint8_t *data, int data_size,
bool upload, FilePosition position);
int get_data_state();
void set_data_state(int);
{
if (hsd->mime_ssn)
{
- uint8_t* end = ( uint8_t*)(p->data) + p->dsize;
- hsd->mime_ssn->process_mime_data(p->flow, p->data, end, 1,
+ hsd->mime_ssn->process_mime_data(p->flow, p->data, p->dsize, 1,
SNORT_FILE_POSITION_UNKNOWN);
}
else if (get_file_processed_size(p->flow) >0)
&(conf->global->mime_conf));
}
- end = (uint8_t*)(session->client.request.post_raw +
- session->client.request.post_raw_size);
- hsd->mime_ssn->process_mime_data(p->flow, start, end, 1,
- SNORT_FILE_POSITION_UNKNOWN);
+ hsd->mime_ssn->process_mime_data(p->flow, start,
+ session->client.request.post_raw_size, 1, SNORT_FILE_POSITION_UNKNOWN);
}
else
{
{
if (hsd->mime_ssn)
{
- uint8_t* end = ( uint8_t*)(p->data) + p->dsize;
- hsd->mime_ssn->process_mime_data(p->flow, p->data, end, 1,
+ hsd->mime_ssn->process_mime_data(p->flow, p->data, p->dsize, 1,
SNORT_FILE_POSITION_UNKNOWN);
}
else if (get_file_processed_size(p->flow) >0)
DebugMessage(DEBUG_IMAP, "DATA STATE ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
if ( imap_ssn->body_len > imap_ssn->body_read)
{
- uint32_t len = imap_ssn->body_len - imap_ssn->body_read;
+ int len = imap_ssn->body_len - imap_ssn->body_read;
- if ( (uint32_t)(end - ptr) < len )
+ if ( (end - ptr) < len )
{
data_end = end;
len = data_end - ptr;
data_end = ptr + len;
FilePosition position = get_file_position(p);
- ptr = imap_ssn->mime_ssn->process_mime_data(p->flow, ptr, end, 0,
+
+ int data_len = end - ptr;
+ ptr = imap_ssn->mime_ssn->process_mime_data(p->flow, ptr, data_len, 0,
position);
if ( ptr < data_end)
len = len - (data_end - ptr);
if (mime_state != nullptr)
{
- delete(mime_state);
+ delete mime_state;
}
delete_pipeline();
{
FileFlows* file_flows = FileFlows::get_file_flows(flow);
- if (file_flows && file_flows->file_process(const_cast<uint8_t*>(file_data.start), fp_length,
+ if (file_flows && file_flows->file_process(file_data.start, fp_length,
file_position, false, false))
{
session_data->file_depth_remaining[source_id] -= fp_length;
const Field& tranaction_uri = request->get_uri_norm_legacy();
if (tranaction_uri.length > 0)
{
- file_flows->set_file_name(const_cast<uint8_t*>(tranaction_uri.start),
- tranaction_uri.length);
+ file_flows->set_file_name(tranaction_uri.start, tranaction_uri.length);
}
}
}
session_data->file_depth_remaining[source_id] = 0;
}
}
- else if (session_data->mime_state != nullptr)
+ else
{
session_data->mime_state->process_mime_data(flow, file_data.start,
- file_data.start + fp_length, true, file_position);
+ fp_length, true, file_position);
session_data->file_depth_remaining[source_id] -= fp_length;
if (session_data->file_depth_remaining[source_id] == 0)
{
- delete(session_data->mime_state);
+ delete session_data->mime_state;
session_data->mime_state = nullptr;
}
}
if ((source_id == SRC_CLIENT) && (session_data->mime_state != nullptr))
{
- delete(session_data->mime_state);
+ delete session_data->mime_state;
session_data->mime_state = nullptr;
}
}
{
session_data->mime_state->process_mime_data(flow, nullptr, 0, true,
SNORT_FILE_END);
- delete(session_data->mime_state);
+ delete session_data->mime_state;
session_data->mime_state = nullptr;
}
return false;
DebugMessage(DEBUG_POP, "DATA STATE ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
//ptr = POP_HandleData(p, ptr, end);
FilePosition position = get_file_position(p);
- ptr = pop_ssn->mime_ssn->process_mime_data(p->flow, ptr, end, 0, position);
+ int len = end - ptr;
+ ptr = pop_ssn->mime_ssn->process_mime_data(p->flow, ptr, len, 0, position);
continue;
}
POP_GetEOL(ptr, end, &eol, &eolm);
SmtpFlowData::~SmtpFlowData()
{
if (session.mime_ssn)
- delete(session.mime_ssn);
+ delete session.mime_ssn;
}
unsigned SmtpFlowData::flow_id = 0;
while ((ptr != NULL) && (ptr < end))
{
FilePosition position;
+ int len = end - ptr;
+
switch (smtp_ssn->state)
{
case STATE_COMMAND:
case STATE_BDATA:
DebugMessage(DEBUG_SMTP, "DATA STATE ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
position = get_file_position(p);
- ptr = smtp_ssn->mime_ssn->process_mime_data(p->flow, ptr, end, 1, position);
+ ptr = smtp_ssn->mime_ssn->process_mime_data(p->flow, ptr, len, 1, position);
//ptr = SMTP_HandleData(p, ptr, end, &(smtp_ssn->mime_ssn));
break;
case STATE_XEXCH50:
return NULL;
}
-static inline void* new_calloc(size_t num, size_t size)
-{
- void* ret_val = calloc(num, size);
- if (ret_val == nullptr)
- throw std::bad_alloc();
-
- return ret_val;
-}
-
static inline long SnortStrtol(const char* nptr, char** endptr, int base)
{
long iRet;