Author: Pekka Riikonen <priikone@silcnet.org>
- Copyright (C) 2005 - 2006 Pekka Riikonen
+ Copyright (C) 2005 - 2007 Pekka Riikonen
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
#include "silc.h"
+/************************** Types and definitions ***************************/
+
+/* MIME fragment ID context */
+typedef struct {
+ char *id;
+ SilcInt64 starttime;
+} SilcMimeFragmentIdStruct, *SilcMimeFragmentId;
+
/************************ Static utility functions **************************/
/* MIME fields destructor */
static void silc_mime_assembler_dest(void *key, void *context,
void *user_context)
{
- silc_free(key);
+ SilcMimeFragmentId id = key;
+
+ silc_free(id->id);
+ silc_free(id);
+
+ /* Free all fragments */
silc_hash_table_free(context);
}
-/* Assembler partial MIME destructor */
+/* Assembler partial MIME fragmentn destructor */
static void silc_mime_assemble_dest(void *key, void *context,
void *user_context)
silc_mime_free(context);
}
+/* MIME fragment ID hashing */
+
+static SilcUInt32 silc_mime_hash_id(void *key, void *user_context)
+{
+ SilcMimeFragmentId id = key;
+ return silc_hash_string(id->id, user_context);
+}
+
+/* MIME fragment ID comparing */
+
+static SilcBool silc_mime_id_compare(void *key1, void *key2,
+ void *user_context)
+{
+ SilcMimeFragmentId id1 = key1, id2 = key2;
+ return silc_hash_string_compare(id1->id, id2->id, user_context);
+}
+
/******************************* Public API *********************************/
if (!mime)
return NULL;
- mime->fields = silc_hash_table_alloc(0, silc_hash_string, mime,
+ mime->fields = silc_hash_table_alloc(NULL, 0, silc_hash_string, mime,
silc_hash_string_compare, mime,
silc_mime_field_dest, mime, TRUE);
if (!mime->fields) {
return NULL;
assembler->fragments =
- silc_hash_table_alloc(0, silc_hash_string, NULL,
- silc_hash_string_compare, NULL,
+ silc_hash_table_alloc(NULL, 0, silc_mime_hash_id, NULL,
+ silc_mime_id_compare, NULL,
silc_mime_assembler_dest, assembler, TRUE);
if (!assembler->fragments) {
silc_mime_assembler_free(assembler);
silc_free(assembler);
}
+/* Purge assembler from old unfinished fragments */
+
+void silc_mime_assembler_purge(SilcMimeAssembler assembler,
+ SilcUInt32 purge_minutes)
+{
+ SilcMimeFragmentId id;
+ SilcHashTableList htl;
+ SilcInt64 curtime = silc_time();
+ SilcUInt32 timeout = purge_minutes ? purge_minutes * 60 : 5 * 60;
+
+ SILC_LOG_DEBUG(("Purge MIME assembler"));
+
+ silc_hash_table_list(assembler->fragments, &htl);
+ while (silc_hash_table_get(&htl, (void *)&id, NULL)) {
+ if (curtime - id->starttime <= timeout)
+ continue;
+
+ SILC_LOG_DEBUG(("Purge partial MIME id %s", id->id));
+
+ /* Purge */
+ silc_hash_table_del(assembler->fragments, id);
+ }
+ silc_hash_table_list_reset(&htl);
+}
+
/* Decode MIME message */
SilcMime silc_mime_decode(SilcMime mime, const unsigned char *data,
if (field && strstr(field, "multipart")) {
char b[1024];
SilcMime p;
+ unsigned int len;
mime->multiparts = silc_dlist_init();
if (!mime->multiparts)
if (!strchr(field, ';'))
goto err;
memset(b, 0, sizeof(b));
- strncat(b, value, strchr(field, ';') - value);
+ len = (unsigned int)(strchr(field, ';') - value);
+ if (len > sizeof(b) - 1)
+ goto err;
+ strncpy(b, value, len);
if (strchr(b, '"'))
*strchr(b, '"') = '\0';
mime->multitype = silc_memdup(b, strlen(b));
line = strdup(value);
if (strrchr(line, '"')) {
*strrchr(line, '"') = '\0';
- snprintf(b, sizeof(b) - 1, "--%s", line + 1);
+ silc_snprintf(b, sizeof(b) - 1, "--%s", line + 1);
mime->boundary = strdup(line + 1);
} else {
- snprintf(b, sizeof(b) - 1, "--%s", line);
+ silc_snprintf(b, sizeof(b) - 1, "--%s", line);
mime->boundary = strdup(line);
}
silc_free(line);
/* Encode the headers. Order doesn't matter */
i = 0;
silc_hash_table_list(mime->fields, &htl);
- while (silc_hash_table_get(&htl, (void **)&field, (void **)&value)) {
+ while (silc_hash_table_get(&htl, (void *)&field, (void *)&value)) {
memset(tmp, 0, sizeof(tmp));
SILC_LOG_DEBUG(("Header %s: %s", field, value));
- snprintf(tmp, sizeof(tmp) - 1, "%s: %s\r\n", field, value);
+ silc_snprintf(tmp, sizeof(tmp) - 1, "%s: %s\r\n", field, value);
silc_buffer_strformat(&buf, tmp, SILC_STRFMT_END);
i++;
}
if (silc_buffer_len(&buf)) {
silc_buffer_put(buffer, buf.head, silc_buffer_len(&buf));
silc_buffer_pull(buffer, silc_buffer_len(&buf));
+ silc_buffer_purge(&buf);
}
/* Add data */
/* If fields are not present, add extra CRLF */
if (!silc_hash_table_count(part->fields))
- snprintf(tmp2, sizeof(tmp2) - 1, "\r\n");
- snprintf(tmp, sizeof(tmp) - 1, "%s--%s\r\n%s",
+ silc_snprintf(tmp2, sizeof(tmp2) - 1, "\r\n");
+ silc_snprintf(tmp, sizeof(tmp) - 1, "%s--%s\r\n%s",
i != 0 ? "\r\n" : "", mime->boundary, tmp2);
i = 1;
}
memset(tmp, 0, sizeof(tmp));
- snprintf(tmp, sizeof(tmp) - 1, "\r\n--%s--\r\n", mime->boundary);
+ silc_snprintf(tmp, sizeof(tmp) - 1, "\r\n--%s--\r\n", mime->boundary);
buffer = silc_buffer_realloc(buffer, silc_buffer_truelen(buffer) +
strlen(tmp));
if (!buffer)
SilcMime silc_mime_assemble(SilcMimeAssembler assembler, SilcMime partial)
{
char *type, *id = NULL, *tmp;
+ SilcMimeFragmentIdStruct *fragid, query;
SilcHashTable f;
SilcMime p, complete;
int i, number, total = -1;
SILC_LOG_DEBUG(("Fragment number %d", number));
/* Find fragments with this ID. */
- if (!silc_hash_table_find(assembler->fragments, (void *)id,
- NULL, (void **)&f)) {
+ query.id = id;
+ if (!silc_hash_table_find(assembler->fragments, (void *)&query,
+ NULL, (void *)&f)) {
/* This is new fragment to new message. Add to hash table and return. */
- f = silc_hash_table_alloc(0, silc_hash_uint, NULL, NULL, NULL,
+ f = silc_hash_table_alloc(NULL, 0, silc_hash_uint, NULL, NULL, NULL,
silc_mime_assemble_dest, NULL, TRUE);
if (!f)
- goto err;
+ goto err;
+
+ fragid = silc_calloc(1, sizeof(*fragid));
+ if (!fragid)
+ goto err;
+ fragid->id = id;
+ fragid->starttime = silc_time();
+
silc_hash_table_add(f, SILC_32_TO_PTR(number), partial);
- silc_hash_table_add(assembler->fragments, id, f);
+ silc_hash_table_add(assembler->fragments, fragid, f);
return NULL;
}
/* If more fragments to come, add to hash table */
if (number != total) {
silc_hash_table_add(f, SILC_32_TO_PTR(number), partial);
+ silc_free(id);
return NULL;
}
silc_hash_table_add(f, SILC_32_TO_PTR(number), partial);
/* Verify that we really have all the fragments */
- if (silc_hash_table_count(f) < total)
+ if (silc_hash_table_count(f) < total) {
+ silc_free(id);
return NULL;
+ }
/* Assemble the complete MIME message now. We get them in order from
the hash table. */
for (i = 1; i <= total; i++) {
- if (!silc_hash_table_find(f, SILC_32_TO_PTR(i), NULL, (void **)&p))
+ if (!silc_hash_table_find(f, SILC_32_TO_PTR(i), NULL, (void *)&p))
goto err;
/* The fragment is in the data portion of the partial message */
goto err;
/* Delete the hash table entry. Destructors will free memory */
- silc_hash_table_del(assembler->fragments, (void *)id);
+ silc_hash_table_del(assembler->fragments, (void *)&query);
silc_free(id);
silc_buffer_free(compbuf);
memset(type, 0, sizeof(type));
gethostname(type, sizeof(type) - 1);
srand((time(NULL) + buf_len) ^ rand());
- snprintf(id, sizeof(id) - 1, "%X%X%X%s",
+ silc_snprintf(id, sizeof(id) - 1, "%X%X%X%s",
(unsigned int)rand(), (unsigned int)time(NULL),
(unsigned int)buf_len, type);
silc_mime_add_field(partial, "MIME-Version", "1.0");
memset(type, 0, sizeof(type));
- snprintf(type, sizeof(type) - 1,
+ silc_snprintf(type, sizeof(type) - 1,
"message/partial; id=\"%s\"; number=1", id);
silc_mime_add_field(partial, "Content-Type", type);
silc_mime_add_data(partial, buf, max_size);
silc_mime_add_field(partial, "MIME-Version", "1.0");
if (len > max_size) {
- snprintf(type, sizeof(type) - 1,
+ silc_snprintf(type, sizeof(type) - 1,
"message/partial; id=\"%s\"; number=%d",
id, num++);
silc_mime_add_data(partial, buf + off, max_size);
off += max_size;
len -= max_size;
} else {
- snprintf(type, sizeof(type) - 1,
+ silc_snprintf(type, sizeof(type) - 1,
"message/partial; id=\"%s\"; number=%d; total=%d",
id, num, num);
silc_mime_add_data(partial, buf + off, len);
return NULL;
if (!silc_hash_table_find(mime->fields, (void *)field,
- NULL, (void **)&value))
+ NULL, (void *)&value))
return NULL;
return (const char *)value;
return;
memset(tmp, 0, sizeof(tmp));
- snprintf(tmp, sizeof(tmp) - 1, "multipart/%s; boundary=%s", type, boundary);
+ silc_snprintf(tmp, sizeof(tmp) - 1, "multipart/%s; boundary=%s", type, boundary);
silc_mime_add_field(mime, "Content-Type", tmp);
silc_free(mime->boundary);
mime->boundary = strdup(boundary);