Mercurial > dovecot > original-hg > dovecot-1.2
annotate src/lib-imap/imap-message-cache.c @ 22:a946ce1f09b7 HEAD
mbox fixes, not fully working yet but almost :)
author | Timo Sirainen <tss@iki.fi> |
---|---|
date | Sat, 24 Aug 2002 05:04:45 +0300 |
parents | 82b7de533f98 |
children | d493b9cc265e |
rev | line source |
---|---|
0 | 1 /* Copyright (C) 2002 Timo Sirainen */ |
2 | |
3 #include "lib.h" | |
5
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
4 #include "iobuffer.h" |
0 | 5 #include "temp-string.h" |
6 #include "mmap-util.h" | |
7 #include "message-parser.h" | |
8 #include "message-size.h" | |
9 #include "imap-bodystructure.h" | |
10 #include "imap-envelope.h" | |
11 #include "imap-message-cache.h" | |
12 | |
13 #include <unistd.h> | |
14 | |
15 /* It's not very useful to cache lots of messages, as they're mostly wanted | |
16 just once. The biggest reason for this cache to exist is to get just the | |
17 latest message. */ | |
18 #define MAX_CACHED_MESSAGES 16 | |
19 | |
20 #define DEFAULT_MESSAGE_POOL_SIZE 4096 | |
21 | |
22 typedef struct _CachedMessage CachedMessage; | |
23 | |
24 struct _CachedMessage { | |
25 CachedMessage *next; | |
26 | |
27 Pool pool; | |
28 unsigned int uid; | |
29 | |
30 MessagePart *part; | |
31 MessageSize *hdr_size; | |
32 MessageSize *body_size; | |
33 MessageSize *partial_size; | |
34 | |
35 char *cached_body; | |
36 char *cached_bodystructure; | |
37 char *cached_envelope; | |
38 | |
39 MessagePartEnvelopeData *envelope; | |
40 }; | |
41 | |
42 struct _ImapMessageCache { | |
43 CachedMessage *messages; | |
44 int messages_count; | |
45 | |
46 CachedMessage *open_msg; | |
5
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
47 IOBuffer *open_inbuf; |
22
a946ce1f09b7
mbox fixes, not fully working yet but almost :)
Timo Sirainen <tss@iki.fi>
parents:
10
diff
changeset
|
48 off_t open_virtual_size; |
5
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
49 |
10
82b7de533f98
s/user_data/context/ and some s/Data/Context/
Timo Sirainen <tss@iki.fi>
parents:
5
diff
changeset
|
50 IOBuffer *(*inbuf_rewind)(IOBuffer *inbuf, void *context); |
82b7de533f98
s/user_data/context/ and some s/Data/Context/
Timo Sirainen <tss@iki.fi>
parents:
5
diff
changeset
|
51 void *context; |
0 | 52 }; |
53 | |
54 ImapMessageCache *imap_msgcache_alloc(void) | |
55 { | |
5
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
56 return i_new(ImapMessageCache, 1); |
0 | 57 } |
58 | |
59 static void cached_message_free(CachedMessage *msg) | |
60 { | |
61 pool_unref(msg->pool); | |
62 } | |
63 | |
64 void imap_msgcache_clear(ImapMessageCache *cache) | |
65 { | |
66 CachedMessage *next; | |
67 | |
5
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
68 imap_msgcache_close(cache); |
0 | 69 |
70 while (cache->messages != NULL) { | |
71 next = cache->messages->next; | |
72 cached_message_free(cache->messages); | |
73 cache->messages = next; | |
74 } | |
75 } | |
76 | |
77 void imap_msgcache_free(ImapMessageCache *cache) | |
78 { | |
79 imap_msgcache_clear(cache); | |
80 i_free(cache); | |
81 } | |
82 | |
83 static CachedMessage *cache_new(ImapMessageCache *cache, unsigned int uid) | |
84 { | |
85 CachedMessage *msg, **msgp; | |
86 Pool pool; | |
87 | |
88 if (cache->messages_count < MAX_CACHED_MESSAGES) | |
89 cache->messages_count++; | |
90 else { | |
91 /* remove the last message from cache */ | |
92 msgp = &cache->messages; | |
93 while ((*msgp)->next != NULL) | |
94 msgp = &(*msgp)->next; | |
95 | |
96 cached_message_free(*msgp); | |
97 *msgp = NULL; | |
98 } | |
99 | |
100 pool = pool_create("CachedMessage", DEFAULT_MESSAGE_POOL_SIZE, FALSE); | |
101 | |
102 msg = p_new(pool, CachedMessage, 1); | |
103 msg->pool = pool; | |
104 msg->uid = uid; | |
105 | |
106 msg->next = cache->messages; | |
107 cache->messages = msg; | |
108 return msg; | |
109 } | |
110 | |
5
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
111 static CachedMessage *cache_open_or_create(ImapMessageCache *cache, |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
112 unsigned int uid) |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
113 { |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
114 CachedMessage **pos, *msg; |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
115 |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
116 pos = &cache->messages; |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
117 for (; *pos != NULL; pos = &(*pos)->next) { |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
118 if ((*pos)->uid == uid) |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
119 break; |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
120 } |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
121 |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
122 if (*pos == NULL) { |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
123 /* not found, add it */ |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
124 msg = cache_new(cache, uid); |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
125 } else if (*pos != cache->messages) { |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
126 /* move it to first in list */ |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
127 msg = *pos; |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
128 *pos = msg->next; |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
129 |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
130 msg->next = cache->messages; |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
131 cache->messages = msg; |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
132 } else { |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
133 msg = *pos; |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
134 } |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
135 |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
136 return msg; |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
137 } |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
138 |
0 | 139 static void parse_envelope_header(MessagePart *part, |
140 const char *name, unsigned int name_len, | |
141 const char *value, unsigned int value_len, | |
10
82b7de533f98
s/user_data/context/ and some s/Data/Context/
Timo Sirainen <tss@iki.fi>
parents:
5
diff
changeset
|
142 void *context) |
0 | 143 { |
10
82b7de533f98
s/user_data/context/ and some s/Data/Context/
Timo Sirainen <tss@iki.fi>
parents:
5
diff
changeset
|
144 CachedMessage *msg = context; |
0 | 145 |
146 if (part == NULL || part->parent == NULL) { | |
147 /* parse envelope headers if we're at the root message part */ | |
148 imap_envelope_parse_header(msg->pool, &msg->envelope, | |
149 t_strndup(name, name_len), | |
150 value, value_len); | |
151 } | |
152 } | |
153 | |
154 static CachedMessage *cache_find(ImapMessageCache *cache, unsigned int uid) | |
155 { | |
156 CachedMessage *msg; | |
157 | |
158 for (msg = cache->messages; msg != NULL; msg = msg->next) { | |
159 if (msg->uid == uid) | |
160 return msg; | |
161 } | |
162 | |
163 return NULL; | |
164 } | |
165 | |
5
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
166 static void imap_msgcache_get_inbuf(ImapMessageCache *cache, off_t offset) |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
167 { |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
168 if (offset < cache->open_inbuf->offset) { |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
169 /* need to rewind */ |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
170 cache->open_inbuf = cache->inbuf_rewind(cache->open_inbuf, |
10
82b7de533f98
s/user_data/context/ and some s/Data/Context/
Timo Sirainen <tss@iki.fi>
parents:
5
diff
changeset
|
171 cache->context); |
5
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
172 if (cache->open_inbuf == NULL) |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
173 i_fatal("Can't rewind message buffer"); |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
174 } |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
175 |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
176 io_buffer_skip(cache->open_inbuf, offset - cache->open_inbuf->offset); |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
177 } |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
178 |
0 | 179 int imap_msgcache_is_cached(ImapMessageCache *cache, unsigned int uid, |
180 ImapCacheField fields) | |
181 { | |
182 CachedMessage *msg; | |
183 | |
184 if (cache->open_msg != NULL && cache->open_msg->uid == uid) | |
185 return TRUE; | |
186 | |
187 /* not open, see if the wanted fields are cached */ | |
188 msg = cache_find(cache, uid); | |
189 if (msg == NULL) | |
190 return FALSE; | |
191 | |
192 if ((fields & IMAP_CACHE_BODY) && msg->cached_body == NULL) | |
193 return FALSE; | |
194 if ((fields & IMAP_CACHE_BODYSTRUCTURE) && | |
195 msg->cached_bodystructure == NULL) | |
196 return FALSE; | |
197 if ((fields & IMAP_CACHE_ENVELOPE) && msg->cached_envelope == NULL) | |
198 return FALSE; | |
199 | |
200 if ((fields & IMAP_CACHE_MESSAGE_OPEN) && msg != cache->open_msg) | |
201 return FALSE; | |
202 if ((fields & IMAP_CACHE_MESSAGE_PART) && msg->part == NULL) | |
203 return FALSE; | |
204 if ((fields & IMAP_CACHE_MESSAGE_HDR_SIZE) && msg->hdr_size == NULL) | |
205 return FALSE; | |
206 if ((fields & IMAP_CACHE_MESSAGE_BODY_SIZE) && msg->body_size == NULL) | |
207 return FALSE; | |
208 | |
209 return TRUE; | |
210 } | |
211 | |
212 /* Caches the fields for given message if possible */ | |
213 static void cache_fields(ImapMessageCache *cache, CachedMessage *msg, | |
214 ImapCacheField fields) | |
215 { | |
216 const char *value; | |
217 | |
218 t_push(); | |
219 if ((fields & IMAP_CACHE_BODY) && msg->cached_body == NULL && | |
220 msg == cache->open_msg) { | |
5
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
221 imap_msgcache_get_inbuf(cache, 0); |
0 | 222 value = imap_part_get_bodystructure(msg->pool, &msg->part, |
5
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
223 cache->open_inbuf, FALSE); |
0 | 224 msg->cached_body = p_strdup(msg->pool, value); |
225 } | |
226 | |
227 if ((fields & IMAP_CACHE_BODYSTRUCTURE) && | |
228 msg->cached_bodystructure == NULL && msg == cache->open_msg) { | |
5
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
229 imap_msgcache_get_inbuf(cache, 0); |
0 | 230 value = imap_part_get_bodystructure(msg->pool, &msg->part, |
5
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
231 cache->open_inbuf, TRUE); |
0 | 232 msg->cached_bodystructure = p_strdup(msg->pool, value); |
233 } | |
234 | |
5
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
235 if ((fields & IMAP_CACHE_ENVELOPE) && msg->cached_envelope == NULL) { |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
236 if (msg->envelope == NULL && msg == cache->open_msg) { |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
237 /* envelope isn't parsed yet, do it. header size |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
238 is calculated anyway so save it */ |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
239 if (msg->hdr_size == NULL) { |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
240 msg->hdr_size = p_new(msg->pool, |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
241 MessageSize, 1); |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
242 } |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
243 |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
244 imap_msgcache_get_inbuf(cache, 0); |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
245 message_parse_header(NULL, cache->open_inbuf, |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
246 msg->hdr_size, |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
247 parse_envelope_header, msg); |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
248 } |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
249 |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
250 if (msg->envelope != NULL) { |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
251 value = imap_envelope_get_part_data(msg->envelope); |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
252 msg->cached_envelope = p_strdup(msg->pool, value); |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
253 } |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
254 } |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
255 |
0 | 256 if ((fields & IMAP_CACHE_MESSAGE_PART) && msg->part == NULL && |
257 msg == cache->open_msg) { | |
258 /* we need to parse the message */ | |
259 MessageHeaderFunc func; | |
260 | |
261 if ((fields & IMAP_CACHE_ENVELOPE) && | |
262 msg->cached_envelope == NULL) { | |
263 /* we need envelope too, fill the info | |
264 while parsing headers */ | |
265 func = parse_envelope_header; | |
266 } else { | |
267 func = NULL; | |
268 } | |
269 | |
5
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
270 imap_msgcache_get_inbuf(cache, 0); |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
271 msg->part = message_parse(msg->pool, cache->open_inbuf, |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
272 func, msg); |
0 | 273 } |
274 | |
275 if ((fields & IMAP_CACHE_MESSAGE_BODY_SIZE) && | |
276 msg->body_size == NULL && | |
277 (msg == cache->open_msg || msg->part != NULL)) { | |
278 /* fill the body size, and while at it fill the header size | |
279 as well */ | |
280 if (msg->hdr_size == NULL) | |
281 msg->hdr_size = p_new(msg->pool, MessageSize, 1); | |
282 msg->body_size = p_new(msg->pool, MessageSize, 1); | |
283 | |
284 if (msg->part != NULL) { | |
285 /* easy, get it from root part */ | |
286 *msg->hdr_size = msg->part->header_size; | |
287 *msg->body_size = msg->part->body_size; | |
288 } else { | |
289 /* first get the header's size, then calculate the | |
290 body size from it and the total virtual size */ | |
5
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
291 imap_msgcache_get_inbuf(cache, 0); |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
292 message_get_header_size(cache->open_inbuf, |
0 | 293 msg->hdr_size); |
294 | |
22
a946ce1f09b7
mbox fixes, not fully working yet but almost :)
Timo Sirainen <tss@iki.fi>
parents:
10
diff
changeset
|
295 i_assert((off_t)msg->hdr_size->physical_size < |
a946ce1f09b7
mbox fixes, not fully working yet but almost :)
Timo Sirainen <tss@iki.fi>
parents:
10
diff
changeset
|
296 cache->open_inbuf->size); |
a946ce1f09b7
mbox fixes, not fully working yet but almost :)
Timo Sirainen <tss@iki.fi>
parents:
10
diff
changeset
|
297 i_assert((off_t)msg->hdr_size->virtual_size < |
a946ce1f09b7
mbox fixes, not fully working yet but almost :)
Timo Sirainen <tss@iki.fi>
parents:
10
diff
changeset
|
298 cache->open_virtual_size); |
a946ce1f09b7
mbox fixes, not fully working yet but almost :)
Timo Sirainen <tss@iki.fi>
parents:
10
diff
changeset
|
299 |
0 | 300 msg->body_size->lines = 0; |
22
a946ce1f09b7
mbox fixes, not fully working yet but almost :)
Timo Sirainen <tss@iki.fi>
parents:
10
diff
changeset
|
301 msg->body_size->physical_size = |
a946ce1f09b7
mbox fixes, not fully working yet but almost :)
Timo Sirainen <tss@iki.fi>
parents:
10
diff
changeset
|
302 cache->open_inbuf->size - |
0 | 303 msg->hdr_size->physical_size; |
304 msg->body_size->virtual_size = | |
305 cache->open_virtual_size - | |
306 msg->hdr_size->virtual_size; | |
307 } | |
308 } | |
309 | |
310 if ((fields & IMAP_CACHE_MESSAGE_HDR_SIZE) && msg->hdr_size == NULL && | |
311 (msg == cache->open_msg || msg->part != NULL)) { | |
312 msg->hdr_size = p_new(msg->pool, MessageSize, 1); | |
313 | |
314 if (msg->part != NULL) { | |
315 /* easy, get it from root part */ | |
316 *msg->hdr_size = msg->part->header_size; | |
317 } else { | |
318 /* need to do some light parsing */ | |
5
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
319 imap_msgcache_get_inbuf(cache, 0); |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
320 message_get_header_size(cache->open_inbuf, |
0 | 321 msg->hdr_size); |
322 } | |
323 } | |
324 | |
325 t_pop(); | |
326 } | |
327 | |
5
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
328 void imap_msgcache_message(ImapMessageCache *cache, unsigned int uid, |
22
a946ce1f09b7
mbox fixes, not fully working yet but almost :)
Timo Sirainen <tss@iki.fi>
parents:
10
diff
changeset
|
329 ImapCacheField fields, off_t virtual_size, |
a946ce1f09b7
mbox fixes, not fully working yet but almost :)
Timo Sirainen <tss@iki.fi>
parents:
10
diff
changeset
|
330 off_t pv_headers_size, off_t pv_body_size, |
5
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
331 IOBuffer *inbuf, |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
332 IOBuffer *(*inbuf_rewind)(IOBuffer *inbuf, |
10
82b7de533f98
s/user_data/context/ and some s/Data/Context/
Timo Sirainen <tss@iki.fi>
parents:
5
diff
changeset
|
333 void *context), |
82b7de533f98
s/user_data/context/ and some s/Data/Context/
Timo Sirainen <tss@iki.fi>
parents:
5
diff
changeset
|
334 void *context) |
0 | 335 { |
5
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
336 CachedMessage *msg; |
0 | 337 |
5
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
338 msg = cache_open_or_create(cache, uid); |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
339 if (cache->open_msg != msg) { |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
340 imap_msgcache_close(cache); |
0 | 341 |
342 cache->open_msg = msg; | |
5
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
343 cache->open_inbuf = inbuf; |
0 | 344 cache->open_virtual_size = virtual_size; |
345 | |
5
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
346 cache->inbuf_rewind = inbuf_rewind; |
10
82b7de533f98
s/user_data/context/ and some s/Data/Context/
Timo Sirainen <tss@iki.fi>
parents:
5
diff
changeset
|
347 cache->context = context; |
0 | 348 } |
349 | |
350 if (pv_headers_size != 0 && msg->hdr_size == NULL) { | |
351 /* physical size == virtual size */ | |
352 msg->hdr_size = p_new(msg->pool, MessageSize, 1); | |
353 msg->hdr_size->physical_size = msg->hdr_size->virtual_size = | |
354 pv_headers_size; | |
355 } | |
356 | |
357 if (pv_body_size != 0 && msg->body_size == NULL) { | |
358 /* physical size == virtual size */ | |
359 msg->body_size = p_new(msg->pool, MessageSize, 1); | |
360 msg->body_size->physical_size = msg->body_size->virtual_size = | |
361 pv_body_size; | |
362 } | |
363 | |
364 cache_fields(cache, msg, fields); | |
365 } | |
366 | |
5
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
367 void imap_msgcache_close(ImapMessageCache *cache) |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
368 { |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
369 if (cache->open_inbuf != NULL) { |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
370 (void)close(cache->open_inbuf->fd); |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
371 io_buffer_destroy(cache->open_inbuf); |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
372 cache->open_inbuf = NULL; |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
373 } |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
374 |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
375 cache->open_msg = NULL; |
22
a946ce1f09b7
mbox fixes, not fully working yet but almost :)
Timo Sirainen <tss@iki.fi>
parents:
10
diff
changeset
|
376 cache->open_virtual_size = 0; |
5
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
377 } |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
378 |
0 | 379 void imap_msgcache_set(ImapMessageCache *cache, unsigned int uid, |
380 ImapCacheField field, const char *value) | |
381 { | |
382 CachedMessage *msg; | |
383 | |
384 msg = cache_find(cache, uid); | |
385 if (msg == NULL) | |
386 msg = cache_new(cache, uid); | |
387 | |
388 switch (field) { | |
389 case IMAP_CACHE_BODY: | |
390 msg->cached_body = p_strdup(msg->pool, value); | |
391 break; | |
392 case IMAP_CACHE_BODYSTRUCTURE: | |
393 msg->cached_bodystructure = p_strdup(msg->pool, value); | |
394 break; | |
395 case IMAP_CACHE_ENVELOPE: | |
396 msg->cached_envelope = p_strdup(msg->pool, value); | |
397 break; | |
398 default: | |
399 i_assert(0); | |
400 } | |
401 } | |
402 | |
403 const char *imap_msgcache_get(ImapMessageCache *cache, unsigned int uid, | |
404 ImapCacheField field) | |
405 { | |
406 CachedMessage *msg; | |
407 | |
408 msg = cache_find(cache, uid); | |
409 if (msg == NULL) | |
410 return NULL; | |
411 | |
412 switch (field) { | |
413 case IMAP_CACHE_BODY: | |
414 if (msg->cached_body == NULL) | |
415 cache_fields(cache, msg, field); | |
416 return msg->cached_body; | |
417 case IMAP_CACHE_BODYSTRUCTURE: | |
418 if (msg->cached_bodystructure == NULL) | |
419 cache_fields(cache, msg, field); | |
420 return msg->cached_bodystructure; | |
421 case IMAP_CACHE_ENVELOPE: | |
422 if (msg->cached_envelope == NULL) | |
423 cache_fields(cache, msg, field); | |
424 return msg->cached_envelope; | |
425 default: | |
426 i_assert(0); | |
427 } | |
428 | |
429 return NULL; | |
430 } | |
431 | |
432 MessagePart *imap_msgcache_get_parts(ImapMessageCache *cache, unsigned int uid) | |
433 { | |
434 CachedMessage *msg; | |
435 | |
436 msg = cache_find(cache, uid); | |
437 if (msg == NULL) | |
438 return NULL; | |
439 | |
440 if (msg->part == NULL) | |
441 cache_fields(cache, msg, IMAP_CACHE_MESSAGE_PART); | |
442 return msg->part; | |
443 } | |
444 | |
445 int imap_msgcache_get_rfc822(ImapMessageCache *cache, unsigned int uid, | |
446 MessageSize *hdr_size, MessageSize *body_size, | |
5
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
447 IOBuffer **inbuf) |
0 | 448 { |
449 CachedMessage *msg; | |
5
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
450 off_t offset; |
0 | 451 |
5
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
452 if (inbuf != NULL) { |
0 | 453 if (cache->open_msg == NULL || cache->open_msg->uid != uid) |
454 return FALSE; | |
455 | |
456 msg = cache->open_msg; | |
5
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
457 |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
458 offset = hdr_size != NULL ? 0 : |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
459 msg->hdr_size->physical_size; |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
460 imap_msgcache_get_inbuf(cache, offset); |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
461 *inbuf = cache->open_inbuf; |
0 | 462 } else { |
463 msg = cache_find(cache, uid); | |
464 if (msg == NULL) | |
465 return FALSE; | |
466 } | |
467 | |
468 if (body_size != NULL) { | |
469 if (msg->body_size == NULL) | |
470 cache_fields(cache, msg, IMAP_CACHE_MESSAGE_BODY_SIZE); | |
471 if (msg->body_size == NULL) | |
472 return FALSE; | |
473 *body_size = *msg->body_size; | |
474 } | |
475 | |
476 if (hdr_size != NULL) { | |
477 if (msg->hdr_size == NULL) | |
478 cache_fields(cache, msg, IMAP_CACHE_MESSAGE_HDR_SIZE); | |
479 if (msg->hdr_size == NULL) | |
480 return FALSE; | |
481 *hdr_size = *msg->hdr_size; | |
482 } | |
483 | |
484 return TRUE; | |
485 } | |
486 | |
5
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
487 static void get_partial_size(IOBuffer *inbuf, |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
488 off_t virtual_skip, off_t max_virtual_size, |
0 | 489 MessageSize *partial, MessageSize *dest) |
490 { | |
5
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
491 unsigned char *msg; |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
492 unsigned int size; |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
493 int cr_skipped; |
0 | 494 |
495 /* see if we can use the existing partial */ | |
5
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
496 if ((off_t)partial->virtual_size > virtual_skip) |
0 | 497 memset(partial, 0, sizeof(MessageSize)); |
5
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
498 else { |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
499 io_buffer_skip(inbuf, partial->physical_size); |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
500 virtual_skip -= partial->virtual_size; |
0 | 501 } |
502 | |
5
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
503 message_skip_virtual(inbuf, virtual_skip, partial, &cr_skipped); |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
504 |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
505 if (!cr_skipped) { |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
506 /* see if we need to add virtual CR */ |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
507 while (io_buffer_read_data(inbuf, &msg, &size, 0) >= 0) { |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
508 if (size > 0) { |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
509 if (msg[0] == '\n') |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
510 dest->virtual_size++; |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
511 break; |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
512 } |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
513 } |
0 | 514 } |
515 | |
5
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
516 message_get_body_size(inbuf, dest, max_virtual_size); |
0 | 517 } |
518 | |
519 int imap_msgcache_get_rfc822_partial(ImapMessageCache *cache, unsigned int uid, | |
5
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
520 off_t virtual_skip, off_t max_virtual_size, |
0 | 521 int get_header, MessageSize *size, |
5
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
522 IOBuffer **inbuf) |
0 | 523 { |
524 CachedMessage *msg; | |
525 off_t physical_skip; | |
526 int size_got; | |
527 | |
528 msg = cache->open_msg; | |
529 if (msg == NULL || msg->uid != uid) | |
530 return FALSE; | |
531 | |
532 if (msg->hdr_size == NULL) { | |
533 msg->hdr_size = p_new(msg->pool, MessageSize, 1); | |
5
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
534 imap_msgcache_get_inbuf(cache, 0); |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
535 message_get_header_size(cache->open_inbuf, msg->hdr_size); |
0 | 536 } |
537 | |
538 physical_skip = get_header ? 0 : msg->hdr_size->physical_size; | |
539 | |
540 /* see if we can do this easily */ | |
541 size_got = FALSE; | |
542 if (virtual_skip == 0) { | |
5
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
543 if (max_virtual_size < 0 && msg->body_size == NULL) { |
0 | 544 msg->body_size = p_new(msg->pool, MessageSize, 1); |
22
a946ce1f09b7
mbox fixes, not fully working yet but almost :)
Timo Sirainen <tss@iki.fi>
parents:
10
diff
changeset
|
545 msg->body_size->physical_size = |
a946ce1f09b7
mbox fixes, not fully working yet but almost :)
Timo Sirainen <tss@iki.fi>
parents:
10
diff
changeset
|
546 cache->open_inbuf->size - |
0 | 547 msg->hdr_size->physical_size; |
548 msg->body_size->virtual_size = | |
549 cache->open_virtual_size - | |
550 msg->hdr_size->virtual_size; | |
551 } | |
552 | |
553 if (msg->body_size != NULL && | |
5
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
554 (max_virtual_size < 0 || |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
555 max_virtual_size >= (off_t)msg->body_size->virtual_size)) { |
0 | 556 *size = *msg->body_size; |
557 size_got = TRUE; | |
558 } | |
559 } | |
560 | |
561 if (!size_got) { | |
562 if (msg->partial_size == NULL) | |
563 msg->partial_size = p_new(msg->pool, MessageSize, 1); | |
564 | |
5
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
565 imap_msgcache_get_inbuf(cache, msg->hdr_size->physical_size); |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
566 get_partial_size(cache->open_inbuf, virtual_skip, |
0 | 567 max_virtual_size, msg->partial_size, size); |
568 | |
569 physical_skip += msg->partial_size->physical_size; | |
570 } | |
571 | |
572 if (get_header) | |
573 message_size_add(size, msg->hdr_size); | |
574 | |
575 /* seek to wanted position */ | |
5
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
576 imap_msgcache_get_inbuf(cache, physical_skip); |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
577 *inbuf = cache->open_inbuf; |
0 | 578 return TRUE; |
579 } | |
580 | |
581 int imap_msgcache_get_data(ImapMessageCache *cache, unsigned int uid, | |
5
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
582 IOBuffer **inbuf) |
0 | 583 { |
584 if (cache->open_msg == NULL || cache->open_msg->uid != uid) | |
585 return FALSE; | |
586 | |
5
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
587 imap_msgcache_get_inbuf(cache, 0); |
1b34ec11fff8
Message data is parsed in blocks (no longer entirely mmap()ed). Several
Timo Sirainen <tss@iki.fi>
parents:
0
diff
changeset
|
588 *inbuf = cache->open_inbuf; |
0 | 589 return TRUE; |
590 } |