static void
test_verify_detached (GMimeCryptoContext *ctx, GMimeStream *cleartext, GMimeStream *ciphertext)
{
GMimeSignatureList *signatures;
GMimeSignatureStatus status;
GError *err = NULL;
Exception *ex;
signatures = g_mime_crypto_context_verify (ctx, 0, cleartext, ciphertext, NULL, &err);
if (signatures == NULL) {
ex = exception_new ("%s", err->message);
g_error_free (err);
throw (ex);
}
status = get_sig_status (signatures);
if ((status & GMIME_SIGNATURE_STATUS_RED) != 0) {
g_object_unref (signatures);
throw (exception_new ("signature BAD"));
}
g_object_unref (signatures);
}
Exception
ooc_exception_caught( const Class exc_class )
{
Exception ret_exc;
if( try_pt == NULL )
ooc_throw( exception_new( err_bad_throw ) );
if( try_pt->exc_obj == NULL )
ooc_throw( exception_new( err_bad_throw ) );
if( try_pt->status & CAUGHT ) /* Every exception can be caught only once */
return NULL;
if( exc_class )
/* check if the actual exception is of the desired class */
ret_exc = _ooc_isInstanceOf( (Object) try_pt->exc_obj, exc_class ) ? try_pt->exc_obj : NULL;
else
/* Parameter is NULL: catch anything, let's return the Exception pointer */
ret_exc = try_pt->exc_obj;
if( ret_exc )
try_pt->status |= CAUGHT;
return ret_exc;
}
static void
test_stream_gets (GMimeStream *stream, const char *filename)
{
char sbuf[100], rbuf[100];
ssize_t slen;
FILE *fp;
/* '0x1a' character is treated as EOF (Ctrl+Z) on Windows if file is opened in text mode,
* thus it's opened in binary mode.
*/
if (!(fp = fopen (filename, "r+b")))
throw (exception_new ("could not open `%s': %s", filename, g_strerror (errno)));
while (!g_mime_stream_eos (stream)) {
rbuf[0] = '\0';
slen = g_mime_stream_buffer_gets (stream, sbuf, sizeof (sbuf));
if (!fgets (rbuf, sizeof (rbuf), fp))
break;
if (strcmp (sbuf, rbuf) != 0)
break;
}
fclose (fp);
if (strcmp (sbuf, rbuf) != 0) {
v(fprintf (stderr, "\tstream: \"%s\" (%" G_GSIZE_FORMAT ")\n", sbuf, strlen (sbuf)));
v(fprintf (stderr, "\treal: \"%s\" (%" G_GSIZE_FORMAT ")\n", rbuf, strlen (rbuf)));
throw (exception_new ("streams did not match"));
}
}
static void
test_cat_read (GMimeStream *whole, struct _StreamPart *parts, int bounded)
{
struct _StreamPart *part = parts;
GMimeStream *stream, *cat;
Exception *ex;
int fd;
cat = g_mime_stream_cat_new ();
while (part != NULL) {
d(fprintf (stderr, "adding %s start=%lld, end=%lld...\n",
part->filename, part->pstart, part->pend));
if ((fd = open (part->filename, O_RDONLY, 0)) == -1) {
ex = exception_new ("could not open `%s': %s", part->filename, g_strerror (errno));
g_object_unref (cat);
throw (ex);
}
stream = g_mime_stream_fs_new_with_bounds (fd, part->pstart, bounded ? part->pend : -1);
g_mime_stream_cat_add_source ((GMimeStreamCat *) cat, stream);
g_object_unref (stream);
part = part->next;
}
g_mime_stream_reset (whole);
if (check_streams_match (whole, cat, "stream.part*", TRUE) == -1) {
ex = exception_new ("streams do not match");
g_object_unref (cat);
throw (ex);
}
}
static void
test_cat_seek (GMimeStream *whole, struct _StreamPart *parts, int bounded)
{
struct _StreamPart *part = parts;
GMimeStream *stream, *cat;
gint64 offset, len;
Exception *ex;
int fd;
if (whole->bound_end != -1) {
len = whole->bound_end - whole->bound_start;
} else if ((len = g_mime_stream_length (whole)) == -1) {
ex = exception_new ("unable to get original stream length");
throw (ex);
}
cat = g_mime_stream_cat_new ();
while (part != NULL) {
d(fprintf (stderr, "adding %s start=%lld, end=%lld...\n",
part->filename, part->pstart, part->pend));
if ((fd = open (part->filename, O_RDONLY, 0)) == -1) {
ex = exception_new ("could not open `%s': %s", part->filename, g_strerror (errno));
g_object_unref (cat);
throw (ex);
}
stream = g_mime_stream_fs_new_with_bounds (fd, part->pstart, bounded ? part->pend : -1);
g_mime_stream_cat_add_source ((GMimeStreamCat *) cat, stream);
g_object_unref (stream);
part = part->next;
}
/* calculate a random seek offset to compare at */
offset = (gint64) (len * (rand () / (RAND_MAX + 1.0)));
if (g_mime_stream_seek (whole, offset, GMIME_STREAM_SEEK_SET) == -1) {
ex = exception_new ("could not seek to %lld in original stream: %s",
offset, g_strerror (errno));
throw (ex);
}
if (g_mime_stream_seek (cat, offset, GMIME_STREAM_SEEK_SET) == -1) {
ex = exception_new ("could not seek to %lld: %s",
offset, g_strerror (errno));
throw (ex);
}
if (check_streams_match (whole, cat, "stream.part*", TRUE) == -1) {
ex = exception_new ("streams did not match");
g_object_unref (cat);
throw (ex);
}
}
static void
test_remove_at (void)
{
const char *name, *value;
GMimeHeaderList *list;
GMimeHeader *header;
int count;
list = header_list_new ();
testsuite_check ("remove first header");
try {
/* remove the first header */
g_mime_header_list_remove_at (list, 0);
/* make sure the first header is now the same as the second original header */
header = g_mime_header_list_get_header_at (list, 0);
name = g_mime_header_get_name (header);
value = g_mime_header_get_value (header);
if (strcmp (initial[1].name, name) != 0 ||
strcmp (initial[1].value, value) != 0)
throw (exception_new ("expected second Received header"));
/* make sure that the internal hash table was properly updated */
if (!(header = g_mime_header_list_get_header (list, "Received")))
throw (exception_new ("lookup of Received header failed"));
if (!(value = g_mime_header_get_value (header)))
throw (exception_new ("getting Received header value failed"));
if (strcmp (initial[1].value, value) != 0)
throw (exception_new ("expected second Received header value"));
testsuite_check_passed ();
} catch (ex) {
testsuite_check_failed ("remove first header: %s", ex->message);
} finally;
testsuite_check ("remove last header");
try {
/* remove the last header */
count = g_mime_header_list_get_count (list);
g_mime_header_list_remove_at (list, count - 1);
if ((header = g_mime_header_list_get_header (list, "Message-Id")) != NULL)
throw (exception_new ("lookup of Message-Id should have failed"));
testsuite_check_passed ();
} catch (ex) {
testsuite_check_failed ("remove last header: %s", ex->message);
} finally;
g_object_unref (list);
}
static void
test_indexing (void)
{
const char *name, *value, *raw_value;
GMimeHeaderList *list;
GMimeHeader *header;
int index;
size_t len;
list = header_list_new ();
/* make sure indexing works as expected */
for (index = 0; index < G_N_ELEMENTS (initial); index++) {
testsuite_check ("headers[%d]", index);
try {
if (!(header = g_mime_header_list_get_header_at (list, index)))
throw (exception_new ("failed to get header at index"));
name = g_mime_header_get_name (header);
value = g_mime_header_get_value (header);
if (strcmp (initial[index].name, name) != 0 ||
strcmp (initial[index].value, value) != 0)
throw (exception_new ("resulted in unexpected value"));
if (!(raw_value = g_mime_header_get_raw_value (header)))
throw (exception_new ("null raw value"));
len = strlen (raw_value);
if (raw_value[len - 1] != '\n')
throw (exception_new ("raw value does not end with a \\n"));
testsuite_check_passed ();
} catch (ex) {
testsuite_check_failed ("next iter[%d]: %s", index, ex->message);
} finally;
}
/* make sure trying to advance past the last header fails */
testsuite_check ("indexing past end of headers");
try {
if (g_mime_header_list_get_header_at (list, index) != NULL)
throw (exception_new ("should not have worked"));
testsuite_check_passed ();
} catch (ex) {
testsuite_check_failed ("indexing past end of headers: %s", ex->message);
} finally;
g_object_unref (list);
}
static void
test_encrypt (GMimeCryptoContext *ctx, gboolean sign, GMimeStream *cleartext, GMimeStream *ciphertext)
{
GPtrArray *recipients;
GError *err = NULL;
Exception *ex;
recipients = g_ptr_array_new ();
g_ptr_array_add (recipients, "*****@*****.**");
g_mime_crypto_context_encrypt (ctx, sign, "*****@*****.**",
GMIME_ENCRYPT_ALWAYS_TRUST,
recipients, cleartext, ciphertext,
&err);
g_ptr_array_free (recipients, TRUE);
if (err != NULL) {
ex = exception_new ("%s", err->message);
g_error_free (err);
throw (ex);
}
v(fprintf (stderr, "ciphertext:\n%.*s\n",
GMIME_STREAM_MEM (ciphertext)->buffer->len,
GMIME_STREAM_MEM (ciphertext)->buffer->data));
}
static gboolean
check_stream_gio (const char *input, const char *output, const char *filename, gint64 start, gint64 end)
{
GMimeStream *streams[2];
Exception *ex = NULL;
GFile *file;
int fd;
if (!(file = g_file_new_for_path (input)))
return FALSE;
if ((fd = open (output, O_RDONLY, 0)) == -1) {
g_object_unref (file);
return FALSE;
}
streams[0] = g_mime_stream_gio_new_with_bounds (file, start, end);
streams[1] = g_mime_stream_fs_new (fd);
if (!streams_match (streams, filename))
ex = exception_new ("GMimeStreamBuffer (Cache Mode) streams did not match for `%s'", filename);
g_object_unref (streams[0]);
g_object_unref (streams[1]);
if (ex != NULL)
throw (ex);
return TRUE;
}
static gboolean
check_stream_mmap (const char *input, const char *output, const char *filename, gint64 start, gint64 end)
{
GMimeStream *streams[2], *stream;
Exception *ex = NULL;
int fd[2];
if ((fd[0] = open (input, O_RDONLY, 0)) == -1)
return FALSE;
if ((fd[1] = open (output, O_RDONLY, 0)) == -1) {
close (fd[0]);
return FALSE;
}
stream = g_mime_stream_mmap_new (fd[0], PROT_READ, MAP_PRIVATE);
streams[0] = g_mime_stream_substream (stream, start, end);
g_object_unref (stream);
streams[1] = g_mime_stream_mmap_new (fd[1], PROT_READ, MAP_PRIVATE);
if (!streams_match (streams, filename))
ex = exception_new ("streams did not match");
g_object_unref (streams[0]);
g_object_unref (streams[1]);
if (ex != NULL)
throw (ex);
return TRUE;
}
static gboolean
check_stream_file (const char *input, const char *output, const char *filename, gint64 start, gint64 end)
{
GMimeStream *streams[2], *stream;
Exception *ex = NULL;
FILE *fp[2];
if (!(fp[0] = fopen (input, "r")))
return FALSE;
if (!(fp[1] = fopen (output, "r"))) {
fclose (fp[0]);
return FALSE;
}
stream = g_mime_stream_file_new (fp[0]);
streams[0] = g_mime_stream_substream (stream, start, end);
g_object_unref (stream);
streams[1] = g_mime_stream_file_new (fp[1]);
if (!streams_match (streams, filename))
ex = exception_new ("GMimeStreamFile streams did not match for `%s'", filename);
g_object_unref (streams[0]);
g_object_unref (streams[1]);
if (ex != NULL)
throw (ex);
return TRUE;
}
static gboolean
check_stream_buffer_cache (const char *input, const char *output, const char *filename, gint64 start, gint64 end)
{
GMimeStream *streams[2], *stream;
Exception *ex = NULL;
int fd[2];
if ((fd[0] = open (input, O_RDONLY, 0)) == -1)
return FALSE;
if ((fd[1] = open (output, O_RDONLY, 0)) == -1) {
close (fd[0]);
return FALSE;
}
streams[0] = g_mime_stream_fs_new (fd[0]);
stream = g_mime_stream_buffer_new (streams[0], GMIME_STREAM_BUFFER_CACHE_READ);
g_object_unref (streams[0]);
streams[0] = g_mime_stream_substream (stream, start, end);
g_object_unref (stream);
streams[1] = g_mime_stream_fs_new (fd[1]);
if (!streams_match (streams, filename))
ex = exception_new ("GMimeStreamBuffer (Cache Mode) streams did not match for `%s'", filename);
g_object_unref (streams[0]);
g_object_unref (streams[1]);
if (ex != NULL)
throw (ex);
return TRUE;
}
static void
test_header_formatting (void)
{
const char *raw_value;
GMimeHeaderList *list;
GMimeHeader *header;
guint i;
list = g_mime_header_list_new (g_mime_parser_options_get_default ());
for (i = 0; i < G_N_ELEMENTS (headers); i++) {
testsuite_check ("header[%u]", i);
try {
g_mime_header_list_append (list, headers[i].name, headers[i].value, NULL);
header = g_mime_header_list_get_header_at (list, (int) i);
raw_value = g_mime_header_get_raw_value (header);
if (strcmp (headers[i].raw_value, raw_value) != 0)
throw (exception_new ("raw values do not match: %s", raw_value));
testsuite_check_passed ();
} catch (ex) {
testsuite_check_failed ("header[%u] failed: %s", i, ex->message);
} finally;
}
g_object_unref (list);
}
Exception::Exception(EXCEPTION *e) {
this->obj = exception_new();
exception_setId(this->obj, exception_getId(e));
exception_setMessage(this->obj, exception_getMessage(e));
exception_setCause(this->obj, exception_getCause(e));
exception_setAction(this->obj, exception_getAction(e));
exception_setComment(this->obj, exception_getComment(e));
}
void
ooc_rethrow( void )
{
if( try_pt && (try_pt->status & CAUGHT) )
try_pt->status |= RETHROWN;
else
ooc_throw( exception_new( err_bad_throw ) );
}
static void
test_verify (GMimeCryptoContext *ctx, GMimeStream *cleartext, GMimeStream *ciphertext)
{
GMimeSignatureList *signatures;
GMimeSignatureStatus status;
Exception *ex = NULL;
GMimeStream *stream;
GError *err = NULL;
GByteArray *buf[2];
stream = g_mime_stream_mem_new ();
signatures = g_mime_crypto_context_verify (ctx, 0, ciphertext, NULL, stream, &err);
if (signatures == NULL) {
ex = exception_new ("%s", err->message);
g_object_unref (stream);
g_error_free (err);
throw (ex);
}
status = get_sig_status (signatures);
if ((status & GMIME_SIGNATURE_STATUS_RED) != 0) {
g_object_unref (signatures);
g_object_unref (stream);
throw (exception_new ("signature BAD"));
}
g_object_unref (signatures);
buf[0] = GMIME_STREAM_MEM (cleartext)->buffer;
buf[1] = GMIME_STREAM_MEM (stream)->buffer;
if (buf[0]->len != buf[1]->len || memcmp (buf[0]->data, buf[1]->data, buf[0]->len) != 0)
ex = exception_new ("extracted data does not match original cleartext");
g_object_unref (stream);
if (ex != NULL)
throw (ex);
}
static void
import_key (GMimeCryptoContext *ctx, const char *path)
{
GMimeStream *stream;
GError *err = NULL;
Exception *ex;
int fd;
if ((fd = open (path, O_RDONLY, 0)) == -1)
throw (exception_new ("open() failed: %s", g_strerror (errno)));
stream = g_mime_stream_fs_new (fd);
g_mime_crypto_context_import_keys (ctx, stream, &err);
g_object_unref (stream);
if (err != NULL) {
ex = exception_new ("%s", err->message);
g_error_free (err);
throw (ex);
}
}
static void
test_decrypt (GMimeCryptoContext *ctx, gboolean sign, GMimeStream *cleartext, GMimeStream *ciphertext)
{
GMimeSignatureList *signatures;
GMimeSignatureStatus status;
GMimeDecryptResult *result;
Exception *ex = NULL;
GMimeStream *stream;
GError *err = NULL;
GByteArray *buf[2];
stream = g_mime_stream_mem_new ();
if (!(result = g_mime_crypto_context_decrypt (ctx, 0, NULL, ciphertext, stream, &err))) {
g_object_unref (stream);
ex = exception_new ("%s", err->message);
g_error_free (err);
throw (ex);
}
signatures = g_mime_decrypt_result_get_signatures (result);
if (sign) {
if (signatures != NULL) {
status = get_sig_status (signatures);
if ((status & GMIME_SIGNATURE_STATUS_RED) != 0)
ex = exception_new ("expected GOOD signature");
} else {
ex = exception_new ("Failed to get signatures");
}
} else {
if (signatures != NULL)
ex = exception_new ("unexpected signature");
}
/* Did not ask for session_key -- it should not be present.
We test asking for session_key over in test-pgpmime.c */
if (ex == NULL && result->session_key)
ex = exception_new ("got session_key when not requested");
g_object_unref (result);
if (ex != NULL) {
g_object_unref (stream);
throw (ex);
}
buf[0] = g_mime_stream_mem_get_byte_array ((GMimeStreamMem *) cleartext);
buf[1] = g_mime_stream_mem_get_byte_array ((GMimeStreamMem *) stream);
if (buf[0]->len != buf[1]->len || memcmp (buf[0]->data, buf[1]->data, buf[0]->len) != 0)
ex = exception_new ("decrypted data does not match original cleartext");
g_object_unref (stream);
if (ex != NULL)
throw (ex);
}
static void
test_stream_mem (const char *filename)
{
/* Note: this also tests g_mime_stream_write_to_stream */
GMimeStream *stream, *fstream;
int fd;
if ((fd = open (filename, O_RDONLY, 0)) == -1) {
v(fprintf (stderr, "failed to open %s: %s\n", filename, g_strerror (errno)));
return;
}
testsuite_start ("GMimeStreamMem");
fstream = g_mime_stream_fs_new (fd);
stream = g_mime_stream_mem_new ();
testsuite_check ("GMimeStreamMem::read()");
try {
if (g_mime_stream_write_to_stream (fstream, stream) == -1)
throw (exception_new ("g_mime_stream_write_to_stream() failed"));
if (g_mime_stream_length (stream) != g_mime_stream_length (fstream))
throw (exception_new ("stream lengths didn't match"));
test_stream_read (stream, filename);
testsuite_check_passed ();
} catch (ex) {
testsuite_check_failed ("GMimeStreamMem::read() failed: %s",
ex->message);
} finally;
g_object_unref (fstream);
g_object_unref (stream);
testsuite_end ();
}
static void
test_sign (GMimeCryptoContext *ctx, gboolean detached, GMimeStream *cleartext, GMimeStream *ciphertext)
{
GError *err = NULL;
Exception *ex;
int rv;
rv = g_mime_crypto_context_sign (ctx, detached, "*****@*****.**", cleartext, ciphertext, &err);
if (rv == -1 || err != NULL) {
ex = exception_new ("%s", err->message);
g_error_free (err);
throw (ex);
}
v(fprintf (stderr, "signature (%s):\n%.*s\n",
g_mime_crypto_context_digest_name (ctx, rv),
GMIME_STREAM_MEM (ciphertext)->buffer->len,
GMIME_STREAM_MEM (ciphertext)->buffer->data));
}
int main(void) {
EXCEPTION *e = exception_new();
printf ( "NEW\n" );
DATABASE *db = database_new();
database_setException(db, e);
exception_throw(e);
printf ( "PARAM\n" );
database_setHost(db, "localhost");
database_setName(db, "template1");
database_setUser(db, "postgres");
database_setPassword(db, "postgres");
printf ( "OPEN\n" );
database_open(db);
exception_throw(e);
printf ( "VERSION" );
char *ver = database_getVersion(db);
exception_throw(e);
printf ( " (%s)\n", ver );
free(ver);
printf ( "RANDOM" );
int rnd = database_getRandom(db);
exception_throw(e);
printf ( " (%d)\n", rnd );
printf ( "CLOSE\n" );
database_close(db);
exception_throw(e);
printf ( "FREE\n" );
database_free(db);
exception_throw(e);
exception_free(e);
return 0;
}
ACTIVE_SERVER *active_server_new() {
ACTIVE_SERVER *self = (ACTIVE_SERVER *)malloc(sizeof(ACTIVE_SERVER));
if (!self) {
error("unable to get memory");
}
memset(self, 0, sizeof(ACTIVE_SERVER));
ERR = exception_new();
exception_addCallback(ERR, active_server_error, self);
self->exception_internal = TRUE;
NET = network_new();
network_setException(NET, ERR);
network_setPort(NET, ACTIVE_PORT);
network_setTimeout(NET, ACTIVE_TIMEOUT);
self->timestamp = time(NULL);
self->root = NULL;
srand(time(NULL));
return self;
}
int main(void) {
EXCEPTION *e = exception_new();
printf ( "NEW\n" );
DATABASE *db = database_new();
database_setException(db, e);
exception_throw(e);
printf ( "PARAM\n" );
database_setName(db, "sqlite.db");
printf ( "OPEN\n" );
database_open(db);
exception_throw(e);
printf ( "VERSION" );
char *ver = database_getVersion(db);
exception_throw(e);
printf ( " (%s)\n", ver );
free(ver);
printf ( "RANDOM" );
int rnd = database_getRandom(db);
exception_throw(e);
printf ( " (%d)\n", rnd );
printf ( "CLOSE\n" );
database_close(db);
exception_throw(e);
printf ( "FREE\n" );
database_free(db);
exception_throw(e);
exception_free(e);
return 0;
}
void
ooc_throw( Exception exc_obj_ptr )
{
if( exc_obj_ptr == NULL )
exc_obj_ptr = exception_new( err_bad_throw );
/* Throwing Exception clears the managed stack */
clear_managed_stack();
if( try_pt ) {
/* if we are in an exception handling, then its a rethrow with the new Exception */
if( try_pt->exc_obj != NULL && try_pt->exc_obj != exc_obj_ptr ) {
#ifndef OOC_NO_DYNAMIC_MEM
if( try_pt->exc_obj != & static_exception )
ooc_delete( (Object) try_pt->exc_obj );
#else
ooc_release( (Object) try_pt->exc_obj );
#endif
try_pt->exc_obj = exc_obj_ptr;
try_pt->status |= RETHROWN;
}
else {
try_pt->exc_obj = exc_obj_ptr;
LONGJMP( try_pt->buffer, !0 );
}
}
else {
/* if no error handler was set, we call the system to handle the error */
/*
fprintf(stderr, "*** Unhandled exception! Exception object is:\n\n" );
//dump_item( exc_obj_ptr, 128 );
//dump_item( exc_obj_ptr->_vtab->_class, 16 );
//dump_item( exc_obj_ptr->_vtab->_class->name, 16 );
*/
abort();
}
}
static void
test_cat_substream (GMimeStream *whole, struct _StreamPart *parts, int bounded)
{
GMimeStream *stream, *cat, *sub1, *sub2;
struct _StreamPart *part = parts;
gint64 start, end, len;
Exception *ex;
int fd;
if (whole->bound_end != -1) {
len = whole->bound_end - whole->bound_start;
} else if ((len = g_mime_stream_length (whole)) == -1) {
ex = exception_new ("unable to get original stream length");
throw (ex);
}
cat = g_mime_stream_cat_new ();
while (part != NULL) {
d(fprintf (stderr, "adding %s start=%lld, end=%lld...\n",
part->filename, part->pstart, part->pend));
if ((fd = open (part->filename, O_RDONLY, 0)) == -1) {
ex = exception_new ("could not open `%s': %s", part->filename, g_strerror (errno));
g_object_unref (cat);
throw (ex);
}
stream = g_mime_stream_fs_new_with_bounds (fd, part->pstart, bounded ? part->pend : -1);
g_mime_stream_cat_add_source ((GMimeStreamCat *) cat, stream);
g_object_unref (stream);
part = part->next;
}
/* calculate a random start/end offsets */
start = (gint64) (len * (rand () / (RAND_MAX + 1.0)));
if (rand () % 2)
end = start + (gint64) ((len - start) * (rand () / (RAND_MAX + 1.0)));
else
end = -1;
if (!(sub1 = g_mime_stream_substream (whole, start, end))) {
ex = exception_new ("could not substream the original stream: %s",
g_strerror (errno));
g_object_unref (cat);
throw (ex);
}
if (!(sub2 = g_mime_stream_substream (cat, start, end))) {
ex = exception_new ("%s", g_strerror (errno));
g_object_unref (sub1);
g_object_unref (cat);
throw (ex);
}
g_object_unref (cat);
if (check_streams_match (sub1, sub2, "stream.part*", TRUE) == -1) {
ex = exception_new ("streams did not match");
g_object_unref (sub1);
g_object_unref (sub2);
throw (ex);
}
g_object_unref (sub1);
g_object_unref (sub2);
}
static void
test_cat_write (GMimeStream *whole, struct _StreamPart *parts, int bounded)
{
struct _StreamPart *part = parts;
GMimeStream *stream, *sub, *cat;
Exception *ex;
int fd;
cat = g_mime_stream_cat_new ();
while (part != NULL) {
d(fprintf (stderr, "adding %s start=%lld, end=%lld...\n",
part->filename, part->pstart, part->pend));
if ((fd = open (part->filename, O_CREAT | O_TRUNC | O_WRONLY, 0666)) == -1) {
ex = exception_new ("could not create `%s': %s", part->filename, g_strerror (errno));
throw (ex);
}
stream = g_mime_stream_fs_new_with_bounds (fd, part->pstart, part->pend);
g_mime_stream_cat_add_source ((GMimeStreamCat *) cat, stream);
g_object_unref (stream);
part = part->next;
}
g_mime_stream_reset (whole);
if (g_mime_stream_write_to_stream (whole, (GMimeStream *) cat) == -1) {
ex = exception_new ("%s", g_strerror (errno));
g_object_unref (cat);
throw (ex);
}
g_object_unref (cat);
/* now lets check that the content matches */
d(fprintf (stderr, "checking all part streams have correct data...\n"));
part = parts;
while (part != NULL) {
d(fprintf (stderr, "checking substream %s\n", part->filename));
if ((fd = open (part->filename, O_RDONLY, 0)) == -1) {
ex = exception_new ("could not open `%s': %s", part->filename, g_strerror (errno));
throw (ex);
}
if (!(sub = g_mime_stream_substream (whole, part->wstart, part->wend))) {
ex = exception_new ("could not substream original stream");
close (fd);
throw (ex);
}
if (!(stream = g_mime_stream_fs_new_with_bounds (fd, part->pstart, -1))) {
ex = exception_new ("could not instantiate stream for `%s'", part->filename);
close (fd);
throw (ex);
}
d(fprintf (stderr, "checking substream %s matches...\n", part->filename));
if (check_streams_match (sub, stream, part->filename, TRUE) == -1) {
ex = exception_new ("streams did not match");
g_object_unref (stream);
g_object_unref (sub);
throw (ex);
}
g_object_unref (stream);
g_object_unref (sub);
part = part->next;
}
}
static void
test_address_sync (void)
{
const char *raw_value, *value;
InternetAddress *addr, *ia;
InternetAddressList *list;
GMimeHeaderList *headers;
GMimeMessage *message;
GMimeObject *object;
GMimeHeader *header;
message = g_mime_message_new (TRUE);
list = g_mime_message_get_addresses (message, GMIME_ADDRESS_TYPE_TO);
object = (GMimeObject *) message;
headers = object->headers;
testsuite_check ("address header synchronization");
try {
/* first, check that the To recipients are empty */
if (list == NULL || internet_address_list_length (list) != 0)
throw (exception_new ("unexpected initial internet address list"));
/* now check that the initial header value is null */
if ((value = g_mime_object_get_header (object, "To")) != NULL)
throw (exception_new ("unexpected initial value"));
header = g_mime_header_list_get_header (headers, "To");
if ((raw_value = g_mime_header_get_raw_value (header)) != NULL)
throw (exception_new ("unexpected initial raw_value"));
/* now try adding an address */
addr = internet_address_mailbox_new ("Tester", "*****@*****.**");
internet_address_list_add (list, addr);
if (!(value = g_mime_object_get_header (object, "To")))
throw (exception_new ("address list header unexpectedly null after adding recipient"));
if (strcmp ("Tester <*****@*****.**>", value) != 0)
throw (exception_new ("unexpected address list header after adding recipient"));
header = g_mime_header_list_get_header (headers, "To");
if (!(raw_value = g_mime_header_get_raw_value (header)))
throw (exception_new ("raw_value is null after adding recipient"));
if (strcmp (" Tester <*****@*****.**>\n", raw_value) != 0)
throw (exception_new ("unexpected raw_value after adding recipient: %s", raw_value));
/* now let's try changing the address name to make sure signals properly chain up */
internet_address_set_name (addr, "Eva Lucy-Ann Tester");
if (!(value = g_mime_object_get_header (object, "To")))
throw (exception_new ("address list header unexpectedly null after changing name"));
if (strcmp ("Eva Lucy-Ann Tester <*****@*****.**>", value) != 0)
throw (exception_new ("unexpected address list header after changing name: %s", value));
header = g_mime_header_list_get_header (headers, "To");
if (!(raw_value = g_mime_header_get_raw_value (header)))
throw (exception_new ("raw_value is null after changing name"));
if (strcmp (" Eva Lucy-Ann Tester <*****@*****.**>\n", raw_value) != 0)
throw (exception_new ("unexpected raw_value after changing name"));
/* now let's try changing the address mailbox... */
internet_address_mailbox_set_addr ((InternetAddressMailbox *) addr, "*****@*****.**");
if (!(value = g_mime_object_get_header (object, "To")))
throw (exception_new ("address list header unexpectedly null after changing mailbox"));
if (strcmp ("Eva Lucy-Ann Tester <*****@*****.**>", value) != 0)
throw (exception_new ("unexpected address list header after changing mailbox"));
header = g_mime_header_list_get_header (headers, "To");
if (!(raw_value = g_mime_header_get_raw_value (header)))
throw (exception_new ("raw_value is null after changing mailbox"));
if (strcmp (" Eva Lucy-Ann Tester <*****@*****.**>\n", raw_value) != 0)
throw (exception_new ("unexpected raw_value after changing mailbox"));
/* now let's try inserting a group address */
g_object_unref (addr);
addr = internet_address_group_new ("Group");
internet_address_list_insert (list, 0, addr);
if (!(value = g_mime_object_get_header (object, "To")))
throw (exception_new ("address list header unexpectedly null after inserting group"));
if (strcmp ("Group: ;, Eva Lucy-Ann Tester <*****@*****.**>", value) != 0)
throw (exception_new ("unexpected address list header after inserting group"));
header = g_mime_header_list_get_header (headers, "To");
if (!(raw_value = g_mime_header_get_raw_value (header)))
throw (exception_new ("raw_value is null after inserting group"));
if (strcmp (" Group: ;, Eva Lucy-Ann Tester <*****@*****.**>\n", raw_value) != 0)
throw (exception_new ("unexpected raw_value after inserting group"));
/* now let's try removing the original recipient */
internet_address_list_remove_at (list, 1);
if (!(value = g_mime_object_get_header (object, "To")))
throw (exception_new ("address list header unexpectedly null after removing recipient"));
if (strcmp ("Group: ;", value) != 0)
throw (exception_new ("unexpected address list header after removing recipient"));
header = g_mime_header_list_get_header (headers, "To");
if (!(raw_value = g_mime_header_get_raw_value (header)))
throw (exception_new ("raw_value is null after removing recipient"));
if (strcmp (" Group: ;\n", raw_value) != 0)
throw (exception_new ("unexpected raw_value after removing recipient"));
/* now let's try adding an address to the group... */
ia = internet_address_mailbox_new ("Tester", "*****@*****.**");
internet_address_list_add (((InternetAddressGroup *) addr)->members, ia);
if (!(value = g_mime_object_get_header (object, "To")))
throw (exception_new ("address list header unexpectedly null after adding addr to group"));
if (strcmp ("Group: Tester <*****@*****.**>;", value) != 0)
throw (exception_new ("unexpected address list header after adding addr to group"));
header = g_mime_header_list_get_header (headers, "To");
if (!(raw_value = g_mime_header_get_raw_value (header)))
throw (exception_new ("raw_value is null after adding addr to group"));
if (strcmp (" Group: Tester <*****@*****.**>;\n", raw_value) != 0)
throw (exception_new ("unexpected raw_value after adding addr to group"));
/* let's try this in reverse... set the header value and make sure InternetAddressList gets updated */
g_mime_object_set_header (object, "To", "[email protected] (=?iso-8859-1?q?Fran=E7ois?= Pons)", NULL);
if (internet_address_list_length (list) != 1)
throw (exception_new ("unexpected number of addresses in addrlist after setting header value"));
ia = internet_address_list_get_address (list, 0);
value = internet_address_get_name (ia);
if (strcmp ("Fran\xc3\xa7ois Pons", value) != 0)
throw (exception_new ("unexpected name after setting header value"));
value = internet_address_mailbox_get_addr ((InternetAddressMailbox *) ia);
if (strcmp ("*****@*****.**", value) != 0)
throw (exception_new ("unexpected addr after setting header value"));
header = g_mime_header_list_get_header (headers, "To");
if (!(raw_value = g_mime_header_get_raw_value (header)))
throw (exception_new ("raw_value is null after setting header value"));
if (strcmp (" =?iso-8859-1?q?Fran=E7ois?= Pons <*****@*****.**>\n", raw_value) != 0)
throw (exception_new ("unexpected raw_value after setting header value: %s", raw_value));
testsuite_check_passed ();
} catch (ex) {
testsuite_check_failed ("address header not synchronized: %s", ex->message);
} finally;
g_object_unref (message);
}
static void
test_disposition_sync (void)
{
GMimeContentDisposition *disposition;
const char *raw_value, *value;
GMimeHeaderList *headers;
GMimeParamList *params;
GMimeObject *object;
GMimeHeader *header;
GMimePart *part;
object = (GMimeObject *) (part = g_mime_part_new ());
headers = g_mime_object_get_header_list (object);
testsuite_check ("content-disposition synchronization");
try {
g_mime_object_set_disposition (object, "attachment");
/* first, check that the current Content-Disposition header
* value is "application/octet-stream" as expected */
if (!(value = g_mime_object_get_header (object, "Content-Disposition")))
throw (exception_new ("initial content-disposition header was unexpectedly null"));
if (strcmp ("attachment", value) != 0)
throw (exception_new ("initial content-disposition header had unexpected value: %s", value));
header = g_mime_header_list_get_header (headers, "Content-Disposition");
if (!(raw_value = g_mime_header_get_raw_value (header)))
throw (exception_new ("initial content-disposition raw_value was unexpectedly null"));
if (strcmp (" attachment\n", raw_value) != 0)
throw (exception_new ("initial content-disposition raw_value had unexpected value: %s", raw_value));
/* now change the content-disposition's disposition */
disposition = g_mime_object_get_content_disposition (object);
g_mime_content_disposition_set_disposition (disposition, "inline");
if (!(value = g_mime_object_get_header (object, "Content-Disposition")))
throw (exception_new ("content-disposition header was unexpectedly null after changing type"));
if (strcmp ("inline", value) != 0)
throw (exception_new ("content-disposition header had unexpected value after changing type"));
header = g_mime_header_list_get_header (headers, "Content-Disposition");
if (!(raw_value = g_mime_header_get_raw_value (header)))
throw (exception_new ("content-disposition raw_value was unexpectedly null after changing type"));
if (strcmp (" inline\n", raw_value) != 0)
throw (exception_new ("content-disposition raw_value had unexpected value after changing type: %s", raw_value));
/* now change the content-disposition's parameters by setting a param */
g_mime_content_disposition_set_parameter (disposition, "filename", "hello.txt");
if (!(value = g_mime_object_get_header (object, "Content-Disposition")))
throw (exception_new ("content-disposition header was unexpectedly null after setting a param"));
if (strcmp ("inline; filename=hello.txt", value) != 0)
throw (exception_new ("content-disposition header had unexpected value after setting a param"));
header = g_mime_header_list_get_header (headers, "Content-Disposition");
if (!(raw_value = g_mime_header_get_raw_value (header)))
throw (exception_new ("content-disposition raw_value was unexpectedly null after setting a param"));
if (strcmp (" inline; filename=hello.txt\n", raw_value) != 0)
throw (exception_new ("content-disposition raw_value had unexpected value after setting a param: %s", raw_value));
/* now change the content-disposition's parameters by clearing the params */
params = g_mime_content_disposition_get_parameters (disposition);
g_mime_param_list_clear (params);
if (!(value = g_mime_object_get_header (object, "Content-Disposition")))
throw (exception_new ("content-disposition header was unexpectedly null after clearing params"));
if (strcmp ("inline", value) != 0)
throw (exception_new ("content-disposition header had unexpected value after clearing params"));
header = g_mime_header_list_get_header (headers, "Content-Disposition");
if (!(raw_value = g_mime_header_get_raw_value (header)))
throw (exception_new ("content-disposition raw_value was unexpectedly null after clearing params"));
if (strcmp (" inline\n", raw_value) != 0)
throw (exception_new ("content-disposition raw_value had unexpected value after clearing params: %s", raw_value));
/* let's try this in reverse... set the header value and make sure GMimeContentDisposition gets updated */
header = g_mime_header_list_get_header_at (headers, 1);
g_mime_header_set_value (header, NULL, "attachment; filename=xyz", NULL);
disposition = g_mime_object_get_content_disposition (object);
if (!g_mime_content_disposition_is_attachment (disposition))
throw (exception_new ("GMimeContentDisposition object was not updated"));
header = g_mime_header_list_get_header (headers, "Content-Disposition");
if (!(raw_value = g_mime_header_get_raw_value (header)))
throw (exception_new ("content-disposition raw_value was unexpectedly null after setting value"));
if (strcmp (" attachment; filename=xyz\n", raw_value) != 0)
throw (exception_new ("content-disposition raw_value had unexpected value after setting value: %s", raw_value));
testsuite_check_passed ();
} catch (ex) {
testsuite_check_failed ("content-disposition header not synchronized: %s", ex->message);
} finally;
g_object_unref (part);
}
static void
test_content_type_sync (void)
{
const char *raw_value, *value;
GMimeHeaderList *headers;
GMimeContentType *type;
GMimeParamList *params;
GMimeObject *object;
GMimeHeader *header;
GMimePart *part;
object = (GMimeObject *) (part = g_mime_part_new ());
headers = g_mime_object_get_header_list (object);
testsuite_check ("content-type synchronization");
try {
/* first, check that the current Content-Type header
* value is "application/octet-stream" as expected */
if (!(value = g_mime_object_get_header (object, "Content-Type")))
throw (exception_new ("initial content-type header was unexpectedly null"));
if (strcmp ("application/octet-stream", value) != 0)
throw (exception_new ("initial content-type header had unexpected value: %s", value));
/* now change the content-type's media type... */
type = g_mime_object_get_content_type (object);
g_mime_content_type_set_media_type (type, "text");
if (!(value = g_mime_object_get_header (object, "Content-Type")))
throw (exception_new ("content-type header was unexpectedly null after changing type"));
if (strcmp ("text/octet-stream", value) != 0)
throw (exception_new ("content-type header had unexpected value after changing type"));
header = g_mime_header_list_get_header (headers, "Content-Type");
if (!(raw_value = g_mime_header_get_raw_value (header)))
throw (exception_new ("content-type raw_value was unexpectedly null after changing type"));
if (strcmp (" text/octet-stream\n", raw_value) != 0)
throw (exception_new ("content-type raw_value had unexpected value after changing type"));
/* now change the content-type's media subtype... */
g_mime_content_type_set_media_subtype (type, "plain");
if (!(value = g_mime_object_get_header (object, "Content-Type")))
throw (exception_new ("content-type header was unexpectedly null after changing subtype"));
if (strcmp ("text/plain", value) != 0)
throw (exception_new ("content-type header had unexpected value after changing subtype"));
header = g_mime_header_list_get_header (headers, "Content-Type");
if (!(raw_value = g_mime_header_get_raw_value (header)))
throw (exception_new ("content-type raw_value was unexpectedly null after changing subtype"));
if (strcmp (" text/plain\n", raw_value) != 0)
throw (exception_new ("content-type raw_value had unexpected value after changing subtype"));
/* now change the content-type's parameters by setting a param */
g_mime_content_type_set_parameter (type, "format", "flowed");
if (!(value = g_mime_object_get_header (object, "Content-Type")))
throw (exception_new ("content-type header was unexpectedly null after setting a param"));
if (strcmp ("text/plain; format=flowed", value) != 0)
throw (exception_new ("content-type header had unexpected value after setting a param"));
header = g_mime_header_list_get_header (headers, "Content-Type");
if (!(raw_value = g_mime_header_get_raw_value (header)))
throw (exception_new ("content-type raw_value was unexpectedly null after setting a param"));
if (strcmp (" text/plain; format=flowed\n", raw_value) != 0)
throw (exception_new ("content-type raw_value had unexpected value after setting a param"));
/* now change the content-type's parameters by clearing the params */
params = g_mime_content_type_get_parameters (type);
g_mime_param_list_clear (params);
if (!(value = g_mime_object_get_header (object, "Content-Type")))
throw (exception_new ("content-type header was unexpectedly null after clearing params"));
if (strcmp ("text/plain", value) != 0)
throw (exception_new ("content-type header had unexpected value after clearing params"));
header = g_mime_header_list_get_header (headers, "Content-Type");
if (!(raw_value = g_mime_header_get_raw_value (header)))
throw (exception_new ("content-type raw_value was unexpectedly null after clearing params"));
if (strcmp (" text/plain\n", raw_value) != 0)
throw (exception_new ("content-type raw_value had unexpected value after clearing params"));
/* let's try this in reverse... set the header value and make sure GMimeContentType gets updated */
header = g_mime_header_list_get_header_at (headers, 0);
g_mime_header_set_value (header, NULL, "text/html; charset=utf-8", NULL);
type = g_mime_object_get_content_type (object);
if (!g_mime_content_type_is_type (type, "text", "html"))
throw (exception_new ("GMimeContentType object was not updated"));
header = g_mime_header_list_get_header (headers, "Content-Type");
if (!(raw_value = g_mime_header_get_raw_value (header)))
throw (exception_new ("content-type raw_value was unexpectedly null after setting value"));
if (strcmp (" text/html; charset=utf-8\n", raw_value) != 0)
throw (exception_new ("content-type raw_value had unexpected value after setting value"));
testsuite_check_passed ();
} catch (ex) {
testsuite_check_failed ("content-type header not synchronized: %s", ex->message);
} finally;
g_object_unref (part);
}
void obj_setException(OBJ *obj, EXCEPTION *e) {
if (e == NULL) obj->exception = exception_new();
else obj->exception = e;
}
