aboutsummaryrefslogtreecommitdiffstats
path: root/lib/libesg/transport/session_partition_declaration.c
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--lib/libesg/transport/session_partition_declaration.c253
1 files changed, 253 insertions, 0 deletions
diff --git a/lib/libesg/transport/session_partition_declaration.c b/lib/libesg/transport/session_partition_declaration.c
new file mode 100644
index 0000000..d590bd3
--- /dev/null
+++ b/lib/libesg/transport/session_partition_declaration.c
@@ -0,0 +1,253 @@
+/*
+ * ESG parser
+ *
+ * Copyright (C) 2006 Stephane Este-Gracias (sestegra@free.fr)
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include <libesg/transport/session_partition_declaration.h>
+
+struct esg_session_partition_declaration *esg_session_partition_declaration_decode(uint8_t *buffer, uint32_t size) {
+ uint32_t pos;
+ struct esg_session_partition_declaration *partition;
+ struct esg_session_field *field;
+ struct esg_session_field *last_field;
+ uint8_t field_index;
+ struct esg_session_ip_stream *ip_stream;
+ struct esg_session_ip_stream *last_ip_stream;
+ uint8_t ip_stream_index;
+ uint8_t ip_index;
+ struct esg_session_ip_stream_field *ip_stream_field;
+ struct esg_session_ip_stream_field *last_ip_stream_field;
+ uint8_t *field_buffer;
+ uint32_t field_length;
+ union esg_session_ip_stream_field_value *field_value;
+
+ if ((buffer == NULL) || (size <= 2)) {
+ return NULL;
+ }
+
+ pos = 0;
+
+ partition = (struct esg_session_partition_declaration *) malloc(sizeof(struct esg_session_partition_declaration));
+ memset(partition, 0, sizeof(struct esg_session_partition_declaration));
+ partition->field_list = NULL;
+ partition->ip_stream_list = NULL;
+
+ partition->num_fields = buffer[pos];
+ pos += 1;
+
+ partition->overlapping = (buffer[pos] & 0x80) ? 1 : 0;
+ pos += 1;
+
+ if (size < (pos + 5*(partition->num_fields))) {
+ esg_session_partition_declaration_free(partition);
+ return NULL;
+ }
+
+ last_field = NULL;
+ for (field_index = 0; field_index < partition->num_fields; field_index++) {
+ field = (struct esg_session_field *) malloc(sizeof(struct esg_session_field));
+ memset(field, 0, sizeof(struct esg_session_field));
+ field->_next = NULL;
+
+ if (last_field == NULL) {
+ partition->field_list = field;
+ } else {
+ last_field->_next = field;
+ }
+ last_field = field;
+
+ field->identifier = (buffer[pos] << 8) | buffer[pos+1];
+ pos += 2;
+
+ field->encoding = (buffer[pos] << 8) | buffer[pos+1];
+ pos += 2;
+
+ field->length = buffer[pos];
+ pos += 1;
+ }
+
+ partition->n_o_ip_streams = buffer[pos];
+ pos += 1;
+
+ partition->ip_version_6 = (buffer[pos] & 0x80) ? 1 : 0;
+ pos += 1;
+
+ last_ip_stream = NULL;
+ for (ip_stream_index = 0; ip_stream_index < partition->n_o_ip_streams; ip_stream_index++) {
+ ip_stream = (struct esg_session_ip_stream *) malloc(sizeof(struct esg_session_ip_stream));
+ memset(ip_stream, 0, sizeof(struct esg_session_ip_stream));
+ ip_stream->_next = NULL;
+
+ if (last_ip_stream == NULL) {
+ partition->ip_stream_list = ip_stream;
+ } else {
+ last_ip_stream->_next = ip_stream;
+ }
+ last_ip_stream = ip_stream;
+
+ ip_stream->id = buffer[pos];
+ pos += 1;
+
+ if (partition->ip_version_6) {
+ for (ip_index = 0; ip_index < 16; ip_index++) {
+ ip_stream->source_ip.ipv6[ip_index] = buffer[pos+ip_index];
+ ip_stream->destination_ip.ipv6[ip_index] = buffer[pos+16+ip_index];
+ }
+ pos += 32;
+ } else {
+ for (ip_index = 0; ip_index < 4; ip_index++) {
+ ip_stream->source_ip.ipv4[ip_index] = buffer[pos+ip_index];
+ ip_stream->destination_ip.ipv4[ip_index] = buffer[pos+4+ip_index];
+ }
+ pos += 8;
+ }
+ ip_stream->port = (buffer[pos] << 8) | buffer[pos+1];
+ pos += 2;
+
+ ip_stream->session_id = (buffer[pos] << 8) | buffer[pos+1];
+ pos += 2;
+
+ last_ip_stream_field = NULL;
+ esg_session_partition_declaration_field_list_for_each(partition, field) {
+ ip_stream_field = (struct esg_session_ip_stream_field *) malloc(sizeof(struct esg_session_ip_stream_field));
+ memset(ip_stream_field, 0, sizeof(struct esg_session_ip_stream_field));
+ ip_stream_field->_next = NULL;
+ ip_stream_field->start_field_value = NULL;
+ ip_stream_field->end_field_value = NULL;
+
+ if (last_ip_stream_field == NULL) {
+ ip_stream->field_list = ip_stream_field;
+ } else {
+ last_ip_stream_field->_next = ip_stream_field;
+ }
+ last_ip_stream_field = ip_stream_field;
+
+ field_length = field->length;
+ if (field->length != 0) {
+ field_length = field->length;
+ } else {
+ pos += vluimsbf8(buffer + pos, size - pos, &field_length);
+ }
+
+ switch (field->encoding) {
+ case 0x0000: {
+ if (partition->overlapping == 1) {
+ field_value = (union esg_session_ip_stream_field_value *) malloc(sizeof(union esg_session_ip_stream_field_value));
+ memset(field_value, 0, sizeof(union esg_session_ip_stream_field_value));
+ ip_stream_field->start_field_value = field_value;
+
+ field_buffer = (uint8_t *) malloc(field_length);
+ memset(field_buffer, 0, field_length);
+ memcpy(field_buffer, buffer + pos, field_length);
+
+ ip_stream_field->start_field_value->string = field_buffer;
+ pos += field_length;
+ }
+ field_value = (union esg_session_ip_stream_field_value *) malloc(sizeof(union esg_session_ip_stream_field_value));
+ memset(field_value, 0, sizeof(union esg_session_ip_stream_field_value));
+ ip_stream_field->end_field_value = field_value;
+
+ field_buffer = (uint8_t *) malloc(field_length);
+ memset(field_buffer, 0, field_length);
+ memcpy(field_buffer, buffer + pos, field_length);
+
+ ip_stream_field->end_field_value->string = field_buffer;
+ pos += field_length;
+
+ break;
+ }
+ case 0x0101: {
+ if (partition->overlapping == 1) {
+ field_value = (union esg_session_ip_stream_field_value *) malloc(sizeof(union esg_session_ip_stream_field_value));
+ memset(field_value, 0, sizeof(union esg_session_ip_stream_field_value));
+ ip_stream_field->start_field_value = field_value;
+
+ ip_stream_field->start_field_value->unsigned_short = (buffer[pos] << 8) | buffer[pos+1];
+ pos += field_length;
+ }
+ field_value = (union esg_session_ip_stream_field_value *) malloc(sizeof(union esg_session_ip_stream_field_value));
+ memset(field_value, 0, sizeof(union esg_session_ip_stream_field_value));
+ ip_stream_field->end_field_value = field_value;
+
+ ip_stream_field->end_field_value->unsigned_short = (buffer[pos] << 8) | buffer[pos+1];
+ pos += field_length;
+
+ break;
+ }
+ default: {
+ esg_session_partition_declaration_free(partition);
+ return NULL;
+ }
+ }
+ }
+ }
+
+ return partition;
+}
+
+void esg_session_partition_declaration_free(struct esg_session_partition_declaration *partition) {
+ struct esg_session_field *field;
+ struct esg_session_field *next_field;
+ struct esg_session_ip_stream *ip_stream;
+ struct esg_session_ip_stream *next_ip_stream;
+ struct esg_session_ip_stream_field *ip_stream_field;
+ struct esg_session_ip_stream_field *next_ip_stream_field;
+
+ if (partition == NULL) {
+ return;
+ }
+
+ for(ip_stream = partition->ip_stream_list; ip_stream; ip_stream = next_ip_stream) {
+ next_ip_stream = ip_stream->_next;
+
+ field = partition->field_list;
+ for(ip_stream_field = next_ip_stream->field_list; ip_stream_field; ip_stream_field = next_ip_stream_field) {
+ next_ip_stream_field = ip_stream_field->_next;
+
+ switch (field->encoding) {
+ case 0x0000: {
+ if (ip_stream_field->start_field_value != NULL) {
+ free(ip_stream_field->start_field_value->string);
+ }
+ free(ip_stream_field->end_field_value->string);
+ break;
+ }
+ case 0x0101: {
+ // Nothing to free
+ break;
+ }
+ }
+
+ free(ip_stream_field);
+
+ field = field->_next;
+ }
+
+ free(ip_stream);
+ }
+
+ for(field = partition->field_list; field; field = next_field) {
+ next_field = field->_next;
+ free(field);
+ }
+
+ free(partition);
+}