SilcBuffer silc_attribute_payload_encode_data(SilcBuffer attrs,
SilcAttribute attribute,
SilcAttributeFlags flags,
const unsigned char *data,
SilcUInt32 data_len)
{
SilcBuffer buffer = attrs;
SilcUInt32 len;
len = 4 + (SilcUInt16)data_len;
buffer = silc_buffer_realloc(buffer,
(buffer ? silc_buffer_truelen(buffer) +
len : len));
if (!buffer)
return NULL;
silc_buffer_pull(buffer, silc_buffer_len(buffer));
silc_buffer_pull_tail(buffer, len);
silc_buffer_format(buffer,
SILC_STR_UI_CHAR(attribute),
SILC_STR_UI_CHAR(flags),
SILC_STR_UI_SHORT((SilcUInt16)data_len),
SILC_STR_UI_XNSTRING(data, (SilcUInt16)data_len),
SILC_STR_END);
silc_buffer_push(buffer, buffer->data - buffer->head);
return buffer;
}
SilcBuffer silc_sftp_packet_encode_vp(SilcSFTPPacket packet,
SilcBuffer packet_buf, SilcUInt32 len,
va_list vp)
{
SilcBuffer buffer;
bool dyn;
int ret;
if (packet_buf) {
if (silc_buffer_truelen(packet_buf) < 4 + 1 + len) {
packet_buf = silc_buffer_realloc(packet_buf, 4 + 1 + len);
if (!packet_buf)
return NULL;
}
buffer = packet_buf;
dyn = FALSE;
} else {
buffer = silc_buffer_alloc(4 + 1 + len);
if (!buffer)
return NULL;
dyn = TRUE;
}
silc_buffer_pull_tail(buffer, 4 + 1 + len);
silc_buffer_format(buffer,
SILC_STR_UI_INT(len),
SILC_STR_UI_CHAR(packet),
SILC_STR_END);
silc_buffer_pull(buffer, 5);
ret = silc_buffer_format_vp(buffer, vp);
if (ret < 0) {
if (dyn)
silc_buffer_free(buffer);
return NULL;
}
silc_buffer_push(buffer, 5);
return buffer;
}
unsigned char *silc_vcard_encode(SilcVCard vcard, SilcUInt32 *vcard_len)
{
SilcBufferStruct buffer;
int i;
if (!vcard->full_name || !vcard->family_name || !vcard->first_name)
return NULL;
memset(&buffer, 0, sizeof(buffer));
silc_buffer_strformat(
&buffer,
VCARD_HEADER,
VCARD_VERSION,
"FN:", vcard->full_name, "\n",
"N:", vcard->family_name, ";", vcard->first_name, ";",
vcard->middle_names, ";", vcard->prefix, ";", vcard->suffix, "\n",
SILC_STRFMT_END);
if (vcard->nickname)
silc_buffer_strformat(&buffer,
"NICKNAME:", vcard->nickname, "\n",
SILC_STRFMT_END);
if (vcard->bday)
silc_buffer_strformat(&buffer,
"BDAY:", vcard->bday, "\n",
SILC_STRFMT_END);
if (vcard->title)
silc_buffer_strformat(&buffer,
"TITLE:", vcard->title, "\n",
SILC_STRFMT_END);
if (vcard->role)
silc_buffer_strformat(&buffer,
"ROLE:", vcard->role, "\n",
SILC_STRFMT_END);
if (vcard->org_name)
silc_buffer_strformat(&buffer,
"ORG:", vcard->org_name, ";", vcard->org_unit, "\n",
SILC_STRFMT_END);
if (vcard->categories)
silc_buffer_strformat(&buffer,
"CATEGORIES:", vcard->categories, "\n",
SILC_STRFMT_END);
if (vcard->catclass)
silc_buffer_strformat(&buffer,
"CLASS:", vcard->catclass, "\n",
SILC_STRFMT_END);
if (vcard->url)
silc_buffer_strformat(&buffer,
"URL:", vcard->url, "\n",
SILC_STRFMT_END);
if (vcard->label)
silc_buffer_strformat(&buffer,
"LABEL;", vcard->url, "\n",
SILC_STRFMT_END);
for (i = 0; i < vcard->num_addrs; i++) {
silc_buffer_strformat(&buffer,
"ADR;TYPE=",
vcard->addrs[i].type, ":",
vcard->addrs[i].pbox, ";",
vcard->addrs[i].ext_addr, ";",
vcard->addrs[i].street_addr, ";",
vcard->addrs[i].city, ";",
vcard->addrs[i].state, ";",
vcard->addrs[i].code, ";",
vcard->addrs[i].country, "\n",
SILC_STRFMT_END);
}
for (i = 0; i < vcard->num_tels; i++) {
silc_buffer_strformat(&buffer,
"TEL;TYPE=",
vcard->tels[i].type, ":",
vcard->tels[i].telnum, "\n",
SILC_STRFMT_END);
}
for (i = 0; i < vcard->num_emails; i++) {
silc_buffer_strformat(&buffer,
"EMAIL;TYPE=",
vcard->emails[i].type, ":",
vcard->emails[i].address, "\n",
SILC_STRFMT_END);
}
if (vcard->note)
silc_buffer_strformat(&buffer,
"NOTE:", vcard->note, "\n",
SILC_STRFMT_END);
if (vcard->rev)
silc_buffer_strformat(&buffer,
"REV:", vcard->rev, "\n",
SILC_STRFMT_END);
silc_buffer_strformat(&buffer, VCARD_FOOTER, SILC_STRFMT_END);
if (vcard_len)
*vcard_len = silc_buffer_truelen(&buffer);
return buffer.head;
}
int main(int argc, char **argv)
{
int opt, ret, i;
SilcAsn1 asn1;
SilcBufferStruct buf;
unsigned char *data, *tmp;
SilcUInt32 data_len;
if (argc < 2) {
usage();
return 1;
}
while ((opt = getopt(argc, argv, "hxbai")) != EOF) {
switch (opt) {
case 'h':
usage();
return 1;
break;
case 'x':
hexdump = TRUE;
break;
case 'b':
dec_base64 = TRUE;
break;
case 'i':
ignore_header = TRUE;
break;
case 'a':
parse_all = TRUE;
break;
default:
usage();
return 1;
}
}
data = tmp = silc_file_readfile(argv[argc - 1], &data_len, NULL);
if (!data) {
fprintf(stderr, "Error: Cannot read file '%s': %s\n", argv[argc - 1],
silc_errno_string(silc_errno));
return 1;
}
silc_buffer_set(&buf, data, data_len);
if (ignore_header) {
SilcBool header = FALSE;
for (i = 0; i < data_len; i++) {
if (data_len > i + 4 &&
data[i ] == '-' && data[i + 1] == '-' &&
data[i + 2] == '-' && data[i + 3] == '-') {
if (data_len > i + 5 && (data[i + 4] == '\r' ||
tmp[i + 4] == '\n')) {
/* End of line, header */
if (data_len > i + 6 && data[i + 4] == '\r' &&
data[i + 5] == '\n')
i++;
i += 5;
silc_buffer_pull(&buf, i);
header = TRUE;
} else if (i > 0 && data_len > i + 5 && data[i + 4] != '-' &&
header) {
/* Start of line, footer */
silc_buffer_push_tail(&buf, silc_buffer_truelen(&buf) - i);
break;
}
}
}
}
if (dec_base64) {
data = silc_base64_decode(NULL, silc_buffer_data(&buf),
silc_buffer_len(&buf), &data_len);
if (!data) {
fprintf(stderr, "Error: Cannot decode Base64 encoding\n");
return 1;
}
silc_buffer_set(&buf, data, data_len);
silc_free(tmp);
}
asn1 = silc_asn1_alloc(NULL);
ret = asn1_dump(asn1, &buf, 0);
silc_asn1_free(asn1);
silc_free(data);
return ret;
}
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;
}
static void silc_buffer_stream_io(SilcStream stream,
SilcStreamStatus status,
void *context)
{
SilcBufferStream bs = context;
SilcBuffer buffer = NULL;
SilcUInt32 buf_len;
int ret, len;
if (bs->closed)
return;
if (status == SILC_STREAM_CAN_READ) {
/* Read data */
SILC_LOG_DEBUG(("Read data from buffer stream %p", bs));
while ((ret = silc_stream_read(bs->stream, bs->inbuf->tail,
silc_buffer_taillen(bs->inbuf))) > 0) {
if (!buffer) {
buffer = silc_buffer_alloc(0);
if (!buffer)
return;
}
silc_buffer_pull_tail(bs->inbuf, ret);
/* Parse the buffer */
while ((len = silc_buffer_unformat(bs->inbuf,
SILC_STR_BUFFER_ALLOC(buffer),
SILC_STR_END)) > 0) {
/* Deliver the buffer */
SILC_LOG_HEXDUMP(("Received buffer, size %d",
silc_buffer_len(buffer)),
silc_buffer_data(buffer), silc_buffer_len(buffer));
bs->receiver(SILC_OK, (SilcStream)bs, buffer, bs->context);
silc_buffer_pull(bs->inbuf, len);
buffer = silc_buffer_alloc(0);
if (!buffer)
return;
}
if (silc_buffer_len(bs->inbuf) > 0) {
/* Not complete buffer, read more data */
buf_len = 4;
if (silc_buffer_len(bs->inbuf) >= 4) {
SILC_GET32_MSB(buf_len, bs->inbuf->data);
SILC_LOG_DEBUG(("Incomplete buffer, wait for rest, buffer size %d",
buf_len));
}
/* Enlarge inbuf if needed */
if (silc_buffer_taillen(bs->inbuf) < buf_len)
silc_buffer_realloc(bs->inbuf, silc_buffer_truelen(bs->inbuf) +
buf_len);
continue;
}
/* All data read, read more */
silc_buffer_reset(bs->inbuf);
}
silc_buffer_free(buffer);
if (ret == 0 || ret == -2) {
bs->receiver(silc_errno, (SilcStream)bs, NULL, bs->context);
return;
}
} else {
/* Write any pending data */
SILC_LOG_DEBUG(("Write pending data to buffer stream %p", bs));
while (silc_buffer_len(&bs->queue) > 0) {
ret = silc_stream_write(bs->stream, silc_buffer_data(&bs->queue),
silc_buffer_len(&bs->queue));
if (silc_unlikely(ret == 0))
return;
if (silc_unlikely(ret == -2))
return;
if (silc_unlikely(ret == -1)) {
SILC_LOG_DEBUG(("Buffer stream %p would block, send later", bs));
return;
}
/* Wrote data */
silc_buffer_pull(&bs->queue, ret);
}
memset(&bs->queue, 0, sizeof(bs->queue));
silc_buffer_reset(bs->outbuf);
}
}
