mbox-sync-rewrite.c revision a8b723249ec03ac5d39261c033df5d13aa590cd7
#include "lib.h"
#include "buffer.h"
#include "istream.h"
#include "ostream.h"
#include "str.h"
#include "write-full.h"
#include "message-parser.h"
#include "mbox-storage.h"
#include "mbox-sync-private.h"
#include "istream-raw-mbox.h"
{
return 0;
} else {
}
if (ret < 0) {
"o_stream_send_istream()");
}
return (int)ret;
}
{
const unsigned char *data;
void *p;
/* Add X-Keywords */
start_pos--;
} else {
/* Append at the end of X-Keywords header,
or X-UID if it doesn't exist */
}
/* possibly continues in next line */
break;
}
}
/* pos points to end of headers now, and start_pos to beginning of
whitespace. */
}
{
const unsigned char *data;
/* find the end of the LWSP */
/* possibly continues in next line */
break;
}
}
}
return;
/* and remove what we can */
/* remove it all */
return;
}
/* we have more space than needed. since we're removing from
the beginning of header instead of end, we don't have to
worry about multiline-headers. */
*size = 0;
}
}
{
static enum header_position space_positions[] = {
};
enum header_position pos;
int i;
for (i = 0; i < 3 && size > 0; i++) {
pos = space_positions[i];
&size);
}
}
/* FIXME: see if we could remove X-Keywords header completely */
}
{
/* do we have enough space? */
if (new_hdr_size < old_hdr_size) {
} else if (new_hdr_size > old_hdr_size) {
/* try removing the space where we can */
if (new_hdr_size <= old_hdr_size) {
/* good, we removed enough. */
} else if (move_diff < 0 &&
/* moving backwards - we can use the extra space from
it, just update expunged_space accordingly */
} else {
/* couldn't get enough space */
return 0;
}
}
/* no changes actually. we get here if index sync record told
us to do something that was already there */
return 1;
}
/* forget about partial write optimizations */
ctx->header_first_change = 0;
ctx->header_last_change = 0;
}
ctx->header_last_change != 0)
ctx->header_first_change) < 0) {
return -1;
}
return 1;
}
struct mbox_sync_mail *mails,
{
struct mbox_sync_mail_context mail_ctx;
/* mbox_sync_parse_next_mail() checks that UIDs are growing,
so we have to fool it. */
else {
/* updating might just try to add headers and mess up our
calculations completely. so only add the EOH here. */
}
} else {
}
/* now we have to move it. first move the body of the message,
then write the header and leave the extra space to beginning of
headers. */
return -1;
return -1;
}
return 0;
}
struct mbox_sync_mail *mails,
{
struct mbox_sync_mail_context mail_ctx;
/* mbox_sync_parse_next_mail() checks that UIDs are growing,
so we have to fool it. */
return -1;
}
return 0;
}
{
struct mbox_sync_mail *mails;
int ret = 0;
/* if there's expunges in mails[], we would get more correct balancing
by counting only them here. however, that might make us overwrite
data which hasn't yet been copied backwards. to avoid too much
complexity, we just leave all the rest of the extra space to first
mail */
/* after expunge the next mail must have been missing space, or we
would have moved it backwards already */
/* start moving backwards */
do {
idx--;
/* offset points to beginning of headers. read the
header again, update it and give enough space to
it */
&end_offset) < 0) {
ret = -1;
break;
}
} else {
/* X-Keywords: xx [offset] \n
...
X-Keywords: xx [end_offset] \n
move data forward so mails before us gets the extra
space (ie. we temporarily get more space to us) */
end_offset - dest_offset) < 0) {
ret = -1;
break;
}
}
} while (idx > 0);
if (end_offset != start_offset) {
/* some space was left over - give it to first message. */
/* "body" start_offset .. end_offset "\nFrom .."
we need to move From-line to start_offset */
offset - end_offset) < 0)
ret = -1;
idx++;
end_offset = offset;
} else {
/* "\nFrom ..\n" start_offset .. end_offset "hdr.." */
}
/* now parse it again and give it more space */
start_offset, end_offset) < 0)
ret = -1;
}
return ret;
}