static struct istream *mail_raw_create_stream
(struct mail_user *ruser, int fd, time_t *mtime_r, const char **sender)
{
struct istream *input, *input2, *input_list[2];
const unsigned char *data;
size_t i, size;
int ret, tz;
char *env_sender = NULL;
*mtime_r = (time_t)-1;
fd_set_nonblock(fd, FALSE);
input = i_stream_create_fd(fd, 4096, FALSE);
input->blocking = TRUE;
/* If input begins with a From-line, drop it */
ret = i_stream_read_data(input, &data, &size, 5);
if (ret > 0 && size >= 5 && memcmp(data, "From ", 5) == 0) {
/* skip until the first LF */
i_stream_skip(input, 5);
while ( i_stream_read_data(input, &data, &size, 0) > 0 ) {
for (i = 0; i < size; i++) {
if (data[i] == '\n')
break;
}
if (i != size) {
(void)mbox_from_parse(data, i, mtime_r, &tz, &env_sender);
i_stream_skip(input, i + 1);
break;
}
i_stream_skip(input, size);
}
}
if (env_sender != NULL && sender != NULL) {
*sender = t_strdup(env_sender);
}
i_free(env_sender);
if (input->v_offset == 0) {
input2 = input;
i_stream_ref(input2);
} else {
input2 = i_stream_create_limit(input, (uoff_t)-1);
}
i_stream_unref(&input);
input_list[0] = input2; input_list[1] = NULL;
input = i_stream_create_seekable(input_list, MAIL_MAX_MEMORY_BUFFER,
seekable_fd_callback, (void*)ruser);
i_stream_unref(&input2);
return input;
}
static int istream_raw_mbox_is_valid_from(struct raw_mbox_istream *rstream)
{
const unsigned char *data;
size_t size;
time_t received_time;
char *sender;
int tz;
/* minimal: "From x Thu Nov 29 22:33:52 2001" = 31 chars */
(void)i_stream_read_data(rstream->istream.parent, &data, &size, 30);
if ((size == 1 && data[0] == '\n') ||
(size == 2 && data[0] == '\r' && data[1] == '\n')) {
/* EOF */
return 1;
}
if (size > 31 && memcmp(data, "\nFrom ", 6) == 0) {
data += 6;
size -= 6;
} else if (size > 32 && memcmp(data, "\r\nFrom ", 7) == 0) {
data += 7;
size -= 7;
} else {
return 0;
}
while (memchr(data, '\n', size) == NULL) {
if (i_stream_read_data(rstream->istream.parent,
&data, &size, size) < 0)
break;
}
if (mbox_from_parse(data, size, &received_time, &tz, &sender) < 0)
return 0;
rstream->next_received_time = received_time;
i_free(rstream->next_sender);
rstream->next_sender = sender;
return 1;
}
static int mbox_read_from_line(struct raw_mbox_istream *rstream)
{
const unsigned char *buf, *p;
char *sender;
time_t received_time;
size_t pos, line_pos;
ssize_t ret;
unsigned int skip;
int tz;
buf = i_stream_get_data(rstream->istream.parent, &pos);
i_assert(pos > 0);
/* from_offset points to "\nFrom ", so unless we're at the beginning
of the file, skip the initial \n */
if (rstream->from_offset == 0)
skip = 0;
else {
skip = 1;
if (*buf == '\r')
skip++;
}
while ((p = memchr(buf+skip, '\n', pos-skip)) == NULL) {
ret = i_stream_read(rstream->istream.parent);
buf = i_stream_get_data(rstream->istream.parent, &pos);
if (ret < 0) {
if (ret == -2) {
/* From_-line is too long, but we should be
able to parse what we have so far. */
break;
}
/* EOF shouldn't happen */
rstream->istream.istream.eof =
rstream->istream.parent->eof;
rstream->istream.istream.stream_errno =
rstream->istream.parent->stream_errno;
return -1;
}
i_assert(pos > 0);
}
line_pos = p == NULL ? 0 : (size_t)(p - buf);
/* beginning of mbox */
if (memcmp(buf+skip, "From ", 5) != 0 ||
mbox_from_parse((buf+skip)+5, (pos-skip)-5,
&received_time, &tz, &sender) < 0) {
/* broken From - should happen only at beginning of
file if this isn't a mbox.. */
rstream->istream.istream.stream_errno = EINVAL;
return -1;
}
if (rstream->istream.istream.v_offset == rstream->from_offset) {
rstream->received_time = received_time;
i_free(rstream->sender);
rstream->sender = sender;
} else {
rstream->next_received_time = received_time;
i_free(rstream->next_sender);
rstream->next_sender = sender;
}
/* skip over From-line */
if (line_pos == 0) {
/* line was too long. skip the input until we find LF. */
rstream->istream.istream.v_offset += pos;
i_stream_skip(rstream->istream.parent, pos);
while ((ret = i_stream_read(rstream->istream.parent)) > 0) {
p = memchr(buf, '\n', pos);
if (p != NULL)
break;
rstream->istream.istream.v_offset += pos;
i_stream_skip(rstream->istream.parent, pos);
}
if (ret <= 0) {
i_assert(ret == -1);
/* EOF shouldn't happen */
rstream->istream.istream.eof =
rstream->istream.parent->eof;
rstream->istream.istream.stream_errno =
rstream->istream.parent->stream_errno;
return -1;
}
line_pos = (size_t)(p - buf);
}
rstream->istream.istream.v_offset += line_pos+1;
i_stream_skip(rstream->istream.parent, line_pos+1);
rstream->hdr_offset = rstream->istream.istream.v_offset;
return 0;
}
static ssize_t i_stream_raw_mbox_read(struct istream_private *stream)
{
static const char *mbox_from = "\nFrom ";
struct raw_mbox_istream *rstream = (struct raw_mbox_istream *)stream;
const unsigned char *buf;
const char *fromp;
char *sender;
time_t received_time;
size_t i, pos, new_pos, from_start_pos, from_after_pos;
ssize_t ret = 0;
int eoh_char, tz;
bool crlf_ending = FALSE;
i_assert(rstream->seeked);
i_assert(stream->istream.v_offset >= rstream->from_offset);
if (stream->istream.eof)
return -1;
if (rstream->corrupted) {
rstream->istream.istream.stream_errno = EINVAL;
return -1;
}
i_stream_seek(stream->parent, stream->istream.v_offset);
stream->pos -= stream->skip;
stream->skip = 0;
stream->buffer = NULL;
do {
buf = i_stream_get_data(stream->parent, &pos);
if (pos > 1 && stream->istream.v_offset + pos >
rstream->input_peak_offset) {
/* fake our read count. needed because if in the end
we have only one character in buffer and we skip it
(as potential CR), we want to get back to this
i_stream_raw_mbox_read() to read more data. */
ret = pos;
break;
}
ret = i_stream_read(stream->parent);
} while (ret > 0);
stream->istream.stream_errno = stream->parent->stream_errno;
if (ret < 0) {
if (ret == -2) {
if (stream->skip == stream->pos) {
/* From_-line is longer than our input buffer.
finish the check without seeing the LF. */
} else if (stream->istream.v_offset + pos ==
rstream->input_peak_offset) {
/* we've read everything our parent stream
has to offer. */
stream->buffer = buf;
return -2;
}
/* parent stream is full, but we haven't returned
all its bytes to our caller yet. */
} else if (stream->istream.v_offset != 0 || pos == 0) {
/* we've read the whole file, final byte should be
the \n trailer */
if (pos > 0 && buf[pos-1] == '\n') {
pos--;
if (pos > 0 && buf[pos-1] == '\r') {
crlf_ending = TRUE;
pos--;
}
}
i_assert(pos >= stream->pos);
ret = pos == stream->pos ? -1 :
(ssize_t)(pos - stream->pos);
stream->buffer = buf;
stream->pos = pos;
if (stream->istream.v_offset == rstream->from_offset) {
/* haven't seen From-line yet, so this mbox
stream is now at EOF */
rstream->eof = TRUE;
}
stream->istream.eof = TRUE;
rstream->crlf_ending = crlf_ending;
handle_end_of_mail(rstream, pos);
return ret < 0 ? i_stream_raw_mbox_read(stream) : ret;
}
}
if (stream->istream.v_offset == rstream->from_offset) {
/* beginning of message, we haven't yet read our From-line */
if (pos == 2 && ret > 0) {
/* we're at the end of file with CR+LF linefeeds?
need more data to verify it. */
rstream->input_peak_offset =
stream->istream.v_offset + pos;
return i_stream_raw_mbox_read(stream);
}
if (mbox_read_from_line(rstream) < 0) {
if (stream->istream.v_offset != 0) {
i_error("Next message unexpectedly corrupted in mbox file "
"%s at %"PRIuUOFF_T,
i_stream_get_name(&stream->istream),
stream->istream.v_offset);
}
stream->pos = 0;
rstream->eof = TRUE;
rstream->corrupted = TRUE;
return -1;
}
/* got it. we don't want to return it however,
so start again from headers */
buf = i_stream_get_data(stream->parent, &pos);
if (pos == 0)
return i_stream_raw_mbox_read(stream);
}
/* See if we have From-line here - note that it works right only
because all characters are different in mbox_from. */
fromp = mbox_from; from_start_pos = from_after_pos = (size_t)-1;
eoh_char = rstream->body_offset == (uoff_t)-1 ? '\n' : -1;
for (i = stream->pos; i < pos; i++) {
if (buf[i] == eoh_char &&
((i > 0 && buf[i-1] == '\n') ||
(i > 1 && buf[i-1] == '\r' && buf[i-2] == '\n') ||
stream->istream.v_offset + i == rstream->hdr_offset)) {
rstream->body_offset = stream->istream.v_offset + i + 1;
eoh_char = -1;
}
if ((char)buf[i] == *fromp) {
if (*++fromp == '\0') {
/* potential From-line, see if we have the
rest of the line buffered. */
i++;
if (i >= 7 && buf[i-7] == '\r') {
/* CR also belongs to it. */
crlf_ending = TRUE;
from_start_pos = i - 7;
} else {
crlf_ending = FALSE;
from_start_pos = i - 6;
}
if (rstream->hdr_offset + rstream->mail_size ==
stream->istream.v_offset + from_start_pos ||
rstream->mail_size == (uoff_t)-1) {
from_after_pos = i;
if (ret == -2) {
/* even if we don't have the
whole line, we need to
finish this check now. */
goto mbox_verify;
}
}
fromp = mbox_from;
} else if (from_after_pos != (size_t)-1) {
/* we have the whole From-line here now.
See if it's a valid one. */
mbox_verify:
if (mbox_from_parse(buf + from_after_pos,
pos - from_after_pos,
&received_time, &tz,
&sender) == 0) {
/* yep, we stop here. */
rstream->next_received_time =
received_time;
i_free(rstream->next_sender);
rstream->next_sender = sender;
stream->istream.eof = TRUE;
rstream->crlf_ending = crlf_ending;
handle_end_of_mail(rstream,
from_start_pos);
break;
}
from_after_pos = (size_t)-1;
}
} else {
fromp = mbox_from;
if ((char)buf[i] == *fromp)
fromp++;
}
}
/* we want to go at least one byte further next time */
rstream->input_peak_offset = stream->istream.v_offset + i;
if (from_after_pos != (size_t)-1) {
/* we're waiting for the \n at the end of From-line */
new_pos = from_start_pos;
} else {
/* leave out the beginnings of potential From-line + CR */
new_pos = i - (fromp - mbox_from);
if (new_pos > 0)
new_pos--;
}
if (stream->istream.v_offset -
rstream->hdr_offset + new_pos > rstream->mail_size) {
/* istream_raw_mbox_set_next_offset() used invalid
cached next_offset? */
i_error("Next message unexpectedly lost from mbox file "
"%s at %"PRIuUOFF_T" (%s)",
i_stream_get_name(&stream->istream),
rstream->hdr_offset + rstream->mail_size,
rstream->mail_size_forced ? "cached" : "noncached");
rstream->eof = TRUE;
rstream->corrupted = TRUE;
rstream->istream.istream.stream_errno = EINVAL;
stream->pos = 0;
return -1;
}
stream->buffer = buf;
if (new_pos == stream->pos) {
if (stream->istream.eof || ret > 0)
return i_stream_raw_mbox_read(stream);
i_assert(new_pos > 0);
ret = -2;
} else {
i_assert(new_pos > stream->pos);
ret = new_pos - stream->pos;
stream->pos = new_pos;
}
return ret;
}
