SilcBuffer silc_notify_payload_encode_args(SilcNotifyType type,
SilcUInt32 argc,
SilcBuffer args)
{
SilcBuffer buffer;
SilcUInt32 len;
len = 5 + (args ? silc_buffer_len(args) : 0);
buffer = silc_buffer_alloc_size(len);
if (!buffer)
return NULL;
silc_buffer_format(buffer,
SILC_STR_UI_SHORT(type),
SILC_STR_UI_SHORT(len),
SILC_STR_UI_CHAR(argc),
SILC_STR_END);
if (args)
silc_buffer_format(buffer,
SILC_STR_OFFSET(5),
SILC_STR_DATA(args->data, silc_buffer_len(args)),
SILC_STR_END);
return buffer;
}
SilcBuffer silc_public_key_payload_encode(SilcPublicKey public_key)
{
SilcBuffer buffer;
unsigned char *pk;
SilcUInt32 pk_len;
SilcPKCSType type;
if (!public_key)
return NULL;
type = silc_pkcs_get_type(public_key);
pk = silc_pkcs_public_key_encode(public_key, &pk_len);
if (!pk)
return NULL;
buffer = silc_buffer_alloc_size(4 + pk_len);
if (!buffer) {
silc_free(pk);
return NULL;
}
if (silc_buffer_format(buffer,
SILC_STR_UI_SHORT(pk_len),
SILC_STR_UI_SHORT(type),
SILC_STR_DATA(pk, pk_len),
SILC_STR_END) < 0) {
silc_buffer_free(buffer);
silc_free(pk);
return NULL;
}
silc_free(pk);
return buffer;
}
void silcpurple_wb_send(PurpleWhiteboard *wb, GList *draw_list)
{
SilcPurpleWb wbs = wb->proto_data;
SilcBuffer packet;
GList *list;
int len;
PurpleConnection *gc;
SilcPurple sg;
g_return_if_fail(draw_list);
gc = purple_account_get_connection(wb->account);
g_return_if_fail(gc);
sg = gc->proto_data;
g_return_if_fail(sg);
len = SILCPURPLE_WB_HEADER;
for (list = draw_list; list; list = list->next)
len += 4;
packet = silc_buffer_alloc_size(len);
if (!packet)
return;
/* Assmeble packet */
silc_buffer_format(packet,
SILC_STR_UI32_STRING(SILCPURPLE_WB_MIME),
SILC_STR_UI_CHAR(SILCPURPLE_WB_DRAW),
SILC_STR_UI_SHORT(wbs->width),
SILC_STR_UI_SHORT(wbs->height),
SILC_STR_UI_INT(wbs->brush_color),
SILC_STR_UI_SHORT(wbs->brush_size),
SILC_STR_END);
silc_buffer_pull(packet, SILCPURPLE_WB_HEADER);
for (list = draw_list; list; list = list->next) {
silc_buffer_format(packet,
SILC_STR_UI_INT(GPOINTER_TO_INT(list->data)),
SILC_STR_END);
silc_buffer_pull(packet, 4);
}
/* Send the message */
if (wbs->type == 0) {
/* Private message */
silc_client_send_private_message(sg->client, sg->conn,
wbs->u.client,
SILC_MESSAGE_FLAG_DATA, NULL,
packet->head, len);
} else if (wbs->type == 1) {
/* Channel message. Channel private keys are not supported. */
silc_client_send_channel_message(sg->client, sg->conn,
wbs->u.channel, NULL,
SILC_MESSAGE_FLAG_DATA, NULL,
packet->head, len);
}
silc_buffer_free(packet);
}
SilcBuffer silc_command_payload_encode(SilcCommand cmd,
SilcUInt32 argc,
unsigned char **argv,
SilcUInt32 *argv_lens,
SilcUInt32 *argv_types,
SilcUInt16 ident)
{
SilcBuffer buffer;
SilcBuffer args = NULL;
SilcUInt32 len = 0;
SILC_LOG_DEBUG(("Encoding command payload"));
if (argc) {
args = silc_argument_payload_encode(argc, argv, argv_lens, argv_types);
if (!args)
return NULL;
len = silc_buffer_len(args);
}
len += SILC_COMMAND_PAYLOAD_LEN;
buffer = silc_buffer_alloc_size(len);
if (!buffer)
return NULL;
/* Create Command payload */
silc_buffer_format(buffer,
SILC_STR_UI_SHORT(len),
SILC_STR_UI_CHAR(cmd),
SILC_STR_UI_CHAR(argc),
SILC_STR_UI_SHORT(ident),
SILC_STR_END);
/* Add arguments */
if (argc) {
silc_buffer_pull(buffer, SILC_COMMAND_PAYLOAD_LEN);
silc_buffer_format(buffer,
SILC_STR_UI_XNSTRING(args->data,
silc_buffer_len(args)),
SILC_STR_END);
silc_buffer_push(buffer, SILC_COMMAND_PAYLOAD_LEN);
silc_buffer_free(args);
}
return buffer;
}
void silcpurple_wb_clear(PurpleWhiteboard *wb)
{
SilcPurpleWb wbs = wb->proto_data;
SilcBuffer packet;
int len;
PurpleConnection *gc;
SilcPurple sg;
gc = purple_account_get_connection(wb->account);
g_return_if_fail(gc);
sg = gc->proto_data;
g_return_if_fail(sg);
len = SILCPURPLE_WB_HEADER;
packet = silc_buffer_alloc_size(len);
if (!packet)
return;
/* Assmeble packet */
silc_buffer_format(packet,
SILC_STR_UI32_STRING(SILCPURPLE_WB_MIME),
SILC_STR_UI_CHAR(SILCPURPLE_WB_CLEAR),
SILC_STR_UI_SHORT(wbs->width),
SILC_STR_UI_SHORT(wbs->height),
SILC_STR_UI_INT(wbs->brush_color),
SILC_STR_UI_SHORT(wbs->brush_size),
SILC_STR_END);
/* Send the message */
if (wbs->type == 0) {
/* Private message */
silc_client_send_private_message(sg->client, sg->conn,
wbs->u.client,
SILC_MESSAGE_FLAG_DATA, NULL,
packet->head, len);
} else if (wbs->type == 1) {
/* Channel message */
silc_client_send_channel_message(sg->client, sg->conn,
wbs->u.channel, NULL,
SILC_MESSAGE_FLAG_DATA, NULL,
packet->head, len);
}
silc_buffer_free(packet);
}
SilcBuffer silc_command_payload_encode_payload(SilcCommandPayload payload)
{
SilcBuffer buffer;
SilcBuffer args = NULL;
SilcUInt32 len = 0;
SilcUInt32 argc = 0;
SILC_LOG_DEBUG(("Encoding command payload"));
if (payload->args) {
args = silc_argument_payload_encode_payload(payload->args);
if (args)
len = silc_buffer_len(args);
argc = silc_argument_get_arg_num(payload->args);
}
len += SILC_COMMAND_PAYLOAD_LEN;
buffer = silc_buffer_alloc_size(len);
if (!buffer) {
if (args)
silc_buffer_free(args);
return NULL;
}
/* Create Command payload */
silc_buffer_format(buffer,
SILC_STR_UI_SHORT(len),
SILC_STR_UI_CHAR(payload->cmd),
SILC_STR_UI_CHAR(argc),
SILC_STR_UI_SHORT(payload->ident),
SILC_STR_END);
/* Add arguments */
if (args) {
silc_buffer_pull(buffer, SILC_COMMAND_PAYLOAD_LEN);
silc_buffer_format(buffer,
SILC_STR_UI_XNSTRING(args->data,
silc_buffer_len(args)),
SILC_STR_END);
silc_buffer_push(buffer, SILC_COMMAND_PAYLOAD_LEN);
silc_buffer_free(args);
}
return buffer;
}
static SilcBool silc_connauth_get_signature(SilcConnAuth connauth,
unsigned char **auth_data,
SilcUInt32 *auth_data_len)
{
int len;
SilcSKE ske;
SilcPrivateKey private_key;
SilcBuffer auth;
SILC_LOG_DEBUG(("Compute signature"));
ske = connauth->ske;
private_key = connauth->auth_data;
/* Make the authentication data. Protocol says it is HASH plus
KE Start Payload. */
len = ske->hash_len + silc_buffer_len(ske->start_payload_copy);
auth = silc_buffer_alloc_size(len);
if (!auth)
return FALSE;
silc_buffer_format(auth,
SILC_STR_UI_XNSTRING(ske->hash, ske->hash_len),
SILC_STR_UI_XNSTRING(
ske->start_payload_copy->data,
silc_buffer_len(ske->start_payload_copy)),
SILC_STR_END);
len = ((silc_pkcs_private_key_get_len(private_key) + 7) / 8) + 1;
*auth_data = silc_calloc(len, sizeof(**auth_data));
if (*auth_data == NULL) {
silc_buffer_free(auth);
return FALSE;
}
/* Compute signature */
if (!silc_pkcs_sign(private_key, auth->data, silc_buffer_len(auth),
*auth_data, len, auth_data_len, TRUE, ske->prop->hash)) {
silc_free(*auth_data);
silc_buffer_free(auth);
return FALSE;
}
silc_buffer_free(auth);
return TRUE;
}
static SilcBool silc_connauth_verify_signature(SilcConnAuth connauth,
SilcPublicKey pub_key,
unsigned char *sign,
SilcUInt32 sign_len)
{
int len;
SilcBuffer auth;
SilcSKE ske = connauth->ske;
if (!pub_key || !sign)
return FALSE;
/* Make the authentication data. Protocol says it is HASH plus
KE Start Payload. */
len = ske->hash_len + silc_buffer_len(ske->start_payload_copy);
auth = silc_buffer_alloc_size(len);
if (!auth)
return FALSE;
silc_buffer_format(auth,
SILC_STR_UI_XNSTRING(ske->hash, ske->hash_len),
SILC_STR_UI_XNSTRING(
ske->start_payload_copy->data,
silc_buffer_len(ske->start_payload_copy)),
SILC_STR_END);
/* Verify signature */
if (!silc_pkcs_verify(pub_key, sign, sign_len, auth->data,
silc_buffer_len(auth), ske->prop->hash)) {
silc_buffer_free(auth);
return FALSE;
}
silc_buffer_free(auth);
return TRUE;
}
static unsigned char *
silc_attribute_payload_encode_int(SilcAttribute attribute,
SilcAttributeFlags flags,
void *object,
SilcUInt32 object_size,
SilcUInt32 *ret_len)
{
SilcBuffer tmpbuf = NULL;
unsigned char tmp[4], *str = NULL, *ret;
SilcUInt32 len;
/* Encode according to attribute type */
if (flags & SILC_ATTRIBUTE_FLAG_VALID) {
if (!object && !object_size)
return NULL;
switch (attribute) {
case SILC_ATTRIBUTE_USER_INFO:
{
SilcVCard vcard = object;
if (object_size != sizeof(*vcard))
return NULL;
str = silc_vcard_encode(vcard, &object_size);
if (!str)
return NULL;
object = str;
}
break;
case SILC_ATTRIBUTE_SERVICE:
{
SilcAttributeObjService *service = object;
SilcUInt32 len2;
if (object_size != sizeof(*service))
return NULL;
len = strlen(service->address);
len2 = strlen(service->signon);
tmpbuf = silc_buffer_alloc_size(13 + len + len2);
if (!tmpbuf)
return NULL;
silc_buffer_format(tmpbuf,
SILC_STR_UI_INT(service->port),
SILC_STR_UI_SHORT(len),
SILC_STR_UI_XNSTRING(service->address, len),
SILC_STR_UI_CHAR(service->status),
SILC_STR_UI_SHORT(len2),
SILC_STR_UI_XNSTRING(service->signon, len2),
SILC_STR_UI_INT(service->idle),
SILC_STR_END);
object = tmpbuf->data;
object_size = silc_buffer_len(tmpbuf);
}
break;
case SILC_ATTRIBUTE_STATUS_MOOD:
case SILC_ATTRIBUTE_PREFERRED_CONTACT:
{
SilcUInt32 mask = SILC_PTR_TO_32(object);
if (object_size != sizeof(SilcUInt32))
return NULL;
SILC_PUT32_MSB(mask, tmp);
object = tmp;
object_size = sizeof(SilcUInt32);
}
break;
case SILC_ATTRIBUTE_STATUS_FREETEXT:
case SILC_ATTRIBUTE_PREFERRED_LANGUAGE:
case SILC_ATTRIBUTE_TIMEZONE:
{
unsigned char *string = object;
str = silc_malloc(2 + object_size);
if (!str)
return NULL;
SILC_PUT16_MSB(object_size, str);
memcpy(str + 2, string, object_size);
object = str;
object_size += 2;
}
break;
case SILC_ATTRIBUTE_STATUS_MESSAGE:
case SILC_ATTRIBUTE_EXTENSION:
case SILC_ATTRIBUTE_USER_ICON:
{
SilcMime mime = object;
if (object_size != sizeof(*mime))
return NULL;
str = silc_mime_encode(mime, &object_size);
if (!str)
return NULL;
object = str;
}
break;
case SILC_ATTRIBUTE_GEOLOCATION:
{
SilcAttributeObjGeo *geo = object;
SilcUInt32 len1, len2, len3, len4;
if (object_size != sizeof(*geo))
return NULL;
len1 = (geo->longitude ? strlen(geo->longitude) : 0);
len2 = (geo->latitude ? strlen(geo->latitude) : 0);
len3 = (geo->altitude ? strlen(geo->altitude) : 0);
len4 = (geo->accuracy ? strlen(geo->accuracy) : 0);
if (len1 + len2 + len3 + len4 == 0)
return NULL;
len = len1 + len2 + len3 + len4;
tmpbuf = silc_buffer_alloc_size(8 + len);
if (!tmpbuf)
return NULL;
silc_buffer_format(tmpbuf,
SILC_STR_UI_SHORT(len1),
SILC_STR_UI16_STRING(len1 ? geo->longitude : ""),
SILC_STR_UI_SHORT(len2),
SILC_STR_UI16_STRING(len2 ? geo->latitude : ""),
SILC_STR_UI_SHORT(len3),
SILC_STR_UI16_STRING(len3 ? geo->altitude : ""),
SILC_STR_UI_SHORT(len4),
SILC_STR_UI16_STRING(len4 ? geo->accuracy : ""),
SILC_STR_END);
object = tmpbuf->data;
object_size = silc_buffer_len(tmpbuf);
}
break;
case SILC_ATTRIBUTE_DEVICE_INFO:
{
SilcAttributeObjDevice *dev = object;
SilcUInt32 len1, len2, len3, len4;
if (object_size != sizeof(*dev))
return NULL;
len1 = (dev->manufacturer ? strlen(dev->manufacturer) : 0);
len2 = (dev->version ? strlen(dev->version) : 0);
len3 = (dev->model ? strlen(dev->model) : 0);
len4 = (dev->language ? strlen(dev->language) : 0);
if (len1 + len2 + len3 + len4 == 0)
return NULL;
len = len1 + len2 + len3 + len4;
tmpbuf = silc_buffer_alloc_size(4 + 8 + len);
if (!tmpbuf)
return NULL;
silc_buffer_format(tmpbuf,
SILC_STR_UI_INT(dev->type),
SILC_STR_UI_SHORT(len1),
SILC_STR_UI16_STRING(len1 ? dev->manufacturer : ""),
SILC_STR_UI_SHORT(len2),
SILC_STR_UI16_STRING(len2 ? dev->version : ""),
SILC_STR_UI_SHORT(len3),
SILC_STR_UI16_STRING(len3 ? dev->model : ""),
SILC_STR_UI_SHORT(len4),
SILC_STR_UI16_STRING(len4 ? dev->language : ""),
SILC_STR_END);
object = tmpbuf->data;
object_size = silc_buffer_len(tmpbuf);
}
break;
case SILC_ATTRIBUTE_PHONE_NUMBER:
{
SilcAttributeObjPN *pn = object;
if (object_size != sizeof(*pn))
return NULL;
if (!pn->number || strlen(pn->number) < 5)
return NULL;
tmpbuf = silc_buffer_alloc(0);
if (!tmpbuf)
return NULL;
if (silc_buffer_format(tmpbuf,
SILC_STR_UI_INT(pn->format),
SILC_STR_UI_SHORT(strlen(pn->number)),
SILC_STR_UI16_STRING(pn->number),
SILC_STR_END) < 0)
return NULL;
object = tmpbuf->data;
object_size = silc_buffer_len(tmpbuf);
}
break;
case SILC_ATTRIBUTE_USER_PUBLIC_KEY:
case SILC_ATTRIBUTE_SERVER_PUBLIC_KEY:
{
SilcAttributeObjPk *pk = object;
if (object_size != sizeof(*pk))
return NULL;
len = (pk->type ? strlen(pk->type) : 0);
tmpbuf = silc_buffer_alloc_size(2 + len + pk->data_len);
if (!tmpbuf)
return NULL;
silc_buffer_format(tmpbuf,
SILC_STR_UI_SHORT(len),
SILC_STR_UI16_STRING(pk->type),
SILC_STR_UI_XNSTRING(pk->data, pk->data_len),
SILC_STR_END);
object = tmpbuf->data;
object_size = silc_buffer_len(tmpbuf);
}
break;
case SILC_ATTRIBUTE_USER_DIGITAL_SIGNATURE:
case SILC_ATTRIBUTE_SERVER_DIGITAL_SIGNATURE:
{
SilcAttributeObjPk *pk = object;
if (object_size != sizeof(*pk))
return NULL;
object = pk->data;
object_size = pk->data_len;
}
break;
default:
return NULL;
break;
}
ret = silc_memdup(object, object_size);
if (tmpbuf)
silc_buffer_free(tmpbuf);
silc_free(str);
if (ret_len)
*ret_len = object_size;
return ret;
}
return NULL;
}
SilcBuffer silc_notify_payload_encode(SilcNotifyType type, SilcUInt32 argc,
va_list ap)
{
SilcBuffer buffer;
SilcBuffer args = NULL;
unsigned char **argv;
SilcUInt32 *argv_lens = NULL, *argv_types = NULL;
unsigned char *x;
SilcUInt32 x_len, len = 0;
int i, k = 0;
if (argc) {
argv = silc_calloc(argc, sizeof(unsigned char *));
if (!argv)
return NULL;
argv_lens = silc_calloc(argc, sizeof(SilcUInt32));
if (!argv_lens) {
silc_free(argv);
return NULL;
}
argv_types = silc_calloc(argc, sizeof(SilcUInt32));
if (!argv_types) {
silc_free(argv_lens);
silc_free(argv);
return NULL;
}
for (i = 0, k = 0; i < argc; i++) {
x = va_arg(ap, unsigned char *);
x_len = va_arg(ap, SilcUInt32);
if (!x || !x_len)
continue;
argv[k] = silc_memdup(x, x_len);
if (!argv[k])
return NULL;
argv_lens[k] = x_len;
argv_types[k] = i + 1;
k++;
}
args = silc_argument_payload_encode(k, argv, argv_lens, argv_types);
len = silc_buffer_len(args);
for (i = 0; i < k; i++)
silc_free(argv[i]);
silc_free(argv);
silc_free(argv_lens);
silc_free(argv_types);
}
len += 5;
buffer = silc_buffer_alloc_size(len);
if (!buffer)
return NULL;
silc_buffer_format(buffer,
SILC_STR_UI_SHORT(type),
SILC_STR_UI_SHORT(len),
SILC_STR_UI_CHAR(k),
SILC_STR_END);
if (k) {
silc_buffer_format(buffer,
SILC_STR_OFFSET(5),
SILC_STR_DATA(args->data, silc_buffer_len(args)),
SILC_STR_END);
silc_buffer_free(args);
}
return buffer;
}
SilcBuffer silc_sftp_attr_encode(SilcSFTPAttributes attr)
{
SilcBuffer buffer;
int i, ret;
SilcUInt32 len = 4;
if (attr->flags & SILC_SFTP_ATTR_SIZE)
len += 8;
if (attr->flags & SILC_SFTP_ATTR_UIDGID)
len += 8;
if (attr->flags & SILC_SFTP_ATTR_PERMISSIONS)
len += 4;
if (attr->flags & SILC_SFTP_ATTR_ACMODTIME)
len += 8;
if (attr->flags & SILC_SFTP_ATTR_EXTENDED) {
len += 4;
for (i = 0; i < attr->extended_count; i++) {
len += 8;
len += silc_buffer_len(attr->extended_type[i]);
len += silc_buffer_len(attr->extended_data[i]);
}
}
buffer = silc_buffer_alloc_size(len);
if (!buffer)
return NULL;
silc_buffer_format(buffer,
SILC_STR_UI_INT(attr->flags),
SILC_STR_END);
silc_buffer_pull(buffer, 4);
if (attr->flags & SILC_SFTP_ATTR_SIZE) {
silc_buffer_format(buffer,
SILC_STR_UI_INT64(attr->size),
SILC_STR_END);
silc_buffer_pull(buffer, 8);
}
if (attr->flags & SILC_SFTP_ATTR_UIDGID) {
silc_buffer_format(buffer,
SILC_STR_UI_INT(attr->uid),
SILC_STR_UI_INT(attr->gid),
SILC_STR_END);
silc_buffer_pull(buffer, 8);
}
if (attr->flags & SILC_SFTP_ATTR_PERMISSIONS) {
silc_buffer_format(buffer,
SILC_STR_UI_INT(attr->permissions),
SILC_STR_END);
silc_buffer_pull(buffer, 4);
}
if (attr->flags & SILC_SFTP_ATTR_ACMODTIME) {
silc_buffer_format(buffer,
SILC_STR_UI_INT(attr->atime),
SILC_STR_UI_INT(attr->mtime),
SILC_STR_END);
silc_buffer_pull(buffer, 8);
}
if (attr->flags & SILC_SFTP_ATTR_EXTENDED) {
silc_buffer_format(buffer,
SILC_STR_UI_INT(attr->extended_count),
SILC_STR_END);
silc_buffer_pull(buffer, 4);
for (i = 0; i < attr->extended_count; i++) {
ret =
silc_buffer_format(
buffer,
SILC_STR_UI_INT(silc_buffer_len(attr->extended_type[i])),
SILC_STR_DATA(silc_buffer_data(attr->extended_type[i]),
silc_buffer_len(attr->extended_type[i])),
SILC_STR_UI_INT(silc_buffer_len(attr->extended_data[i])),
SILC_STR_DATA(silc_buffer_data(attr->extended_data[i]),
silc_buffer_len(attr->extended_data[i])),
SILC_STR_END);
silc_buffer_pull(buffer, ret);
}
}
silc_buffer_push(buffer, buffer->data - buffer->head);
return buffer;
}
SilcDList silc_mime_encode_partial(SilcMime mime, int max_size)
{
unsigned char *buf, *tmp;
SilcUInt32 buf_len, len, tmp_len, off;
SilcDList list;
SilcBuffer buffer;
SilcMime partial;
char type[128], id[64];
int num;
SILC_LOG_DEBUG(("Fragmenting MIME message"));
/* Encode as normal */
buf = silc_mime_encode(mime, &buf_len);
if (!buf)
return NULL;
list = silc_dlist_init();
/* Fragment if it is too large */
if (buf_len > max_size) {
memset(id, 0, sizeof(id));
memset(type, 0, sizeof(type));
gethostname(type, sizeof(type) - 1);
srand((time(NULL) + buf_len) ^ rand());
silc_snprintf(id, sizeof(id) - 1, "%X%X%X%s",
(unsigned int)rand(), (unsigned int)time(NULL),
(unsigned int)buf_len, type);
SILC_LOG_DEBUG(("Fragment ID %s", id));
partial = silc_mime_alloc();
if (!partial)
return NULL;
silc_mime_add_field(partial, "MIME-Version", "1.0");
memset(type, 0, sizeof(type));
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);
tmp = silc_mime_encode(partial, &tmp_len);
if (!tmp)
return NULL;
silc_mime_free(partial);
/* Add to list */
buffer = silc_buffer_alloc_size(tmp_len);
if (!buffer)
return NULL;
silc_buffer_put(buffer, tmp, tmp_len);
silc_dlist_add(list, buffer);
silc_free(tmp);
len = buf_len - max_size;
off = max_size;
num = 2;
while (len > 0) {
partial = silc_mime_alloc();
if (!partial)
return NULL;
memset(type, 0, sizeof(type));
silc_mime_add_field(partial, "MIME-Version", "1.0");
if (len > max_size) {
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 {
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);
len = 0;
}
silc_mime_add_field(partial, "Content-Type", type);
tmp = silc_mime_encode(partial, &tmp_len);
if (!tmp)
return NULL;
silc_mime_free(partial);
/* Add to list */
buffer = silc_buffer_alloc_size(tmp_len);
if (!buffer)
return NULL;
silc_buffer_put(buffer, tmp, tmp_len);
silc_dlist_add(list, buffer);
silc_free(tmp);
}
} else {
/* No need to fragment */
buffer = silc_buffer_alloc_size(buf_len);
if (!buffer)
return NULL;
silc_buffer_put(buffer, buf, buf_len);
silc_dlist_add(list, buffer);
}
silc_free(buf);
return list;
}
SilcMime silc_mime_assemble(SilcMimeAssembler assembler, SilcMime partial)
{
char *type, *id = NULL, *tmp;
SilcHashTable f;
SilcMime p, complete;
int i, number, total = -1;
const unsigned char *data;
SilcUInt32 data_len;
SilcBuffer compbuf = NULL;
SILC_LOG_DEBUG(("Assembling MIME fragments"));
if (!assembler || !partial)
goto err;
type = (char *)silc_mime_get_field(partial, "Content-Type");
if (!type)
goto err;
/* Get ID */
tmp = strstr(type, "id=");
if (!tmp)
goto err;
if (strlen(tmp) <= 4)
goto err;
tmp += 3;
if (*tmp == '"')
tmp++;
id = strdup(tmp);
if (strchr(id, ';'))
*strchr(id, ';') = '\0';
if (strrchr(id, '"'))
*strrchr(id, '"') = '\0';
SILC_LOG_DEBUG(("Fragment ID %s", id));
/* Get fragment number */
tmp = strstr(type, "number=");
if (!tmp)
goto err;
tmp = strchr(tmp, '=');
if (strlen(tmp) < 2)
goto err;
tmp++;
if (strchr(tmp, ';')) {
tmp = strdup(tmp);
*strchr(tmp, ';') = '\0';
number = atoi(tmp);
silc_free(tmp);
} else {
number = atoi(tmp);
}
SILC_LOG_DEBUG(("Fragment number %d", number));
/* Find fragments with this ID. */
if (!silc_hash_table_find(assembler->fragments, (void *)id,
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,
silc_mime_assemble_dest, NULL, TRUE);
if (!f)
goto err;
silc_hash_table_add(f, SILC_32_TO_PTR(number), partial);
silc_hash_table_add(assembler->fragments, id, f);
return NULL;
}
/* Try to get total number */
tmp = strstr(type, "total=");
if (tmp) {
tmp = strchr(tmp, '=');
if (strlen(tmp) < 2)
goto err;
tmp++;
if (strchr(tmp, ';')) {
tmp = strdup(tmp);
*strchr(tmp, ';') = '\0';
total = atoi(tmp);
silc_free(tmp);
} else {
total = atoi(tmp);
}
SILC_LOG_DEBUG(("Fragment total %d", total));
}
/* If more fragments to come, add to hash table */
if (number != total) {
silc_hash_table_add(f, SILC_32_TO_PTR(number), partial);
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)
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))
goto err;
/* The fragment is in the data portion of the partial message */
data = silc_mime_get_data(p, &data_len);
if (!data)
goto err;
/* Assemble */
if (!compbuf) {
compbuf = silc_buffer_alloc_size(data_len);
if (!compbuf)
goto err;
silc_buffer_put(compbuf, data, data_len);
} else {
compbuf = silc_buffer_realloc(compbuf, silc_buffer_truelen(compbuf) +
data_len);
if (!compbuf)
goto err;
silc_buffer_put_tail(compbuf, data, data_len);
silc_buffer_pull_tail(compbuf, data_len);
}
}
/* Now parse the complete MIME message and deliver it */
complete = silc_mime_decode(NULL, (const unsigned char *)compbuf->head,
silc_buffer_truelen(compbuf));
if (!complete)
goto err;
/* Delete the hash table entry. Destructors will free memory */
silc_hash_table_del(assembler->fragments, (void *)id);
silc_free(id);
silc_buffer_free(compbuf);
return complete;
err:
silc_free(id);
if (compbuf)
silc_buffer_free(compbuf);
silc_mime_free(partial);
return NULL;
}
unsigned char *silc_mime_encode(SilcMime mime, SilcUInt32 *encoded_len)
{
SilcMime part;
SilcHashTableList htl;
SilcBufferStruct buf;
SilcBuffer buffer;
char *field, *value, tmp[1024], tmp2[4];
unsigned char *ret;
int i;
SILC_LOG_DEBUG(("Encoding MIME message"));
if (!mime)
return NULL;
memset(&buf, 0, sizeof(buf));
/* 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)) {
memset(tmp, 0, sizeof(tmp));
SILC_LOG_DEBUG(("Header %s: %s", field, value));
silc_snprintf(tmp, sizeof(tmp) - 1, "%s: %s\r\n", field, value);
silc_buffer_strformat(&buf, tmp, SILC_STRFMT_END);
i++;
}
silc_hash_table_list_reset(&htl);
if (i)
silc_buffer_strformat(&buf, "\r\n", SILC_STRFMT_END);
/* Assemble the whole buffer */
buffer = silc_buffer_alloc_size(mime->data_len + silc_buffer_len(&buf));
if (!buffer)
return NULL;
/* Add headers */
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 (mime->data) {
SILC_LOG_DEBUG(("Data len %d", mime->data_len));
silc_buffer_put(buffer, mime->data, mime->data_len);
}
/* Add multiparts */
if (mime->multiparts) {
SILC_LOG_DEBUG(("Encoding multiparts"));
silc_dlist_start(mime->multiparts);
i = 0;
while ((part = silc_dlist_get(mime->multiparts)) != SILC_LIST_END) {
unsigned char *pd;
SilcUInt32 pd_len;
/* Recursive encoding */
pd = silc_mime_encode(part, &pd_len);
if (!pd)
return NULL;
memset(tmp, 0, sizeof(tmp));
memset(tmp2, 0, sizeof(tmp2));
/* If fields are not present, add extra CRLF */
if (!silc_hash_table_count(part->fields))
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;
buffer = silc_buffer_realloc(buffer, silc_buffer_truelen(buffer) +
pd_len + strlen(tmp));
if (!buffer)
return NULL;
silc_buffer_put_tail(buffer, tmp, strlen(tmp));
silc_buffer_pull_tail(buffer, strlen(tmp));
silc_buffer_put_tail(buffer, pd, pd_len);
silc_buffer_pull_tail(buffer, pd_len);
silc_free(pd);
}
memset(tmp, 0, sizeof(tmp));
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)
return NULL;
silc_buffer_put_tail(buffer, tmp, strlen(tmp));
silc_buffer_pull_tail(buffer, strlen(tmp));
}
ret = silc_buffer_steal(buffer, encoded_len);
silc_buffer_free(buffer);
return ret;
}
