Mercurial > dovecot > core-2.2
annotate src/doveadm/dsync/dsync-slave-stream.c @ 15036:5943cace4e05
dsync: Renamed "io" slave to "stream".
| author | Timo Sirainen <tss@iki.fi> |
|---|---|
| date | Fri, 07 Sep 2012 16:19:35 +0300 |
| parents | src/doveadm/dsync/dsync-slave-io.c@0af20585964d |
| children |
| rev | line source |
|---|---|
| 14584 | 1 /* Copyright (c) 2012 Dovecot authors, see the included COPYING file */ |
| 2 | |
| 3 #include "lib.h" | |
| 4 #include "array.h" | |
| 5 #include "fd-set-nonblock.h" | |
| 6 #include "safe-mkstemp.h" | |
| 7 #include "ioloop.h" | |
| 8 #include "istream.h" | |
| 9 #include "istream-seekable.h" | |
| 10 #include "istream-dot.h" | |
| 11 #include "ostream.h" | |
| 12 #include "str.h" | |
| 13 #include "strescape.h" | |
| 14 #include "master-service.h" | |
| 15 #include "mail-cache.h" | |
| 16 #include "mail-storage-private.h" | |
| 17 #include "dsync-serializer.h" | |
| 18 #include "dsync-deserializer.h" | |
| 19 #include "dsync-mail.h" | |
| 20 #include "dsync-mailbox.h" | |
| 21 #include "dsync-mailbox-state.h" | |
| 22 #include "dsync-mailbox-tree.h" | |
| 23 #include "dsync-slave-private.h" | |
| 24 | |
| 25 #include <stdlib.h> | |
| 26 | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
27 #define DSYNC_SLAVE_STREAM_TIMEOUT_MSECS (60*10*1000) |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
28 #define DSYNC_SLAVE_STREAM_OUTBUF_THROTTLE_SIZE (1024*128) |
| 14584 | 29 |
| 30 #define DSYNC_PROTOCOL_VERSION_MAJOR 3 | |
| 31 #define DSYNC_HANDSHAKE_VERSION "VERSION\tdsync\t3\t0\n" | |
| 32 | |
| 33 enum item_type { | |
| 34 ITEM_NONE, | |
| 35 | |
| 36 ITEM_HANDSHAKE, | |
| 37 ITEM_MAILBOX_STATE, | |
| 38 ITEM_MAILBOX_TREE_NODE, | |
| 39 ITEM_MAILBOX_DELETE, | |
| 40 ITEM_MAILBOX, | |
| 41 | |
| 42 ITEM_MAIL_CHANGE, | |
| 43 ITEM_MAIL_REQUEST, | |
| 44 ITEM_MAIL, | |
| 45 | |
| 46 ITEM_MAILBOX_CACHE_FIELD, | |
| 47 | |
| 48 ITEM_END_OF_LIST | |
| 49 }; | |
| 50 | |
| 51 #define END_OF_LIST_LINE "." | |
| 52 static const struct { | |
| 53 /* full human readable name of the item */ | |
| 54 const char *name; | |
| 55 /* unique character identifying the item */ | |
| 56 char chr; | |
| 57 const char *required_keys; | |
| 58 const char *optional_keys; | |
| 59 } items[ITEM_END_OF_LIST+1] = { | |
| 60 { NULL, '\0', NULL, NULL }, | |
| 61 { .name = "handshake", | |
| 62 .chr = 'H', | |
| 63 .optional_keys = "sync_ns_prefix sync_type " | |
| 64 "guid_requests mails_have_guids" | |
| 65 }, | |
| 66 { .name = "mailbox_state", | |
| 67 .chr = 'S', | |
| 68 .required_keys = "mailbox_guid last_uidvalidity last_common_uid " | |
| 69 "last_common_modseq" | |
| 70 }, | |
| 71 { .name = "mailbox_tree_node", | |
| 72 .chr = 'N', | |
| 73 .required_keys = "name existence", | |
| 74 .optional_keys = "mailbox_guid uid_validity " | |
|
15035
0af20585964d
dsync: Rewritten syncing for mailbox renames.
Timo Sirainen <tss@iki.fi>
parents:
14691
diff
changeset
|
75 "last_renamed_or_created subscribed last_subscription_change" |
| 14584 | 76 }, |
| 77 { .name = "mailbox_delete", | |
| 78 .chr = 'D', | |
| 79 .required_keys = "hierarchy_sep", | |
| 80 .optional_keys = "mailboxes dirs" | |
| 81 }, | |
| 82 { .name = "mailbox", | |
| 83 .chr = 'B', | |
| 84 .required_keys = "mailbox_guid uid_validity uid_next " | |
| 85 "messages_count first_recent_uid highest_modseq", | |
| 86 .optional_keys = "cache_fields" | |
| 87 }, | |
| 88 { .name = "mail_change", | |
| 89 .chr = 'C', | |
| 90 .required_keys = "type uid", | |
| 91 .optional_keys = "guid hdr_hash modseq save_timestamp " | |
| 92 "add_flags remove_flags final_flags " | |
| 93 "keywords_reset keyword_changes" | |
| 94 }, | |
| 95 { .name = "mail_request", | |
| 96 .chr = 'R', | |
| 97 .optional_keys = "guid uid" | |
| 98 }, | |
| 99 { .name = "mail", | |
| 100 .chr = 'M', | |
| 101 .optional_keys = "guid uid pop3_uidl pop3_order received_date stream" | |
| 102 }, | |
| 103 { .name = "mailbox_cache_field", | |
| 104 .chr = 'c', | |
| 105 .required_keys = "name decision", | |
| 106 .optional_keys = "last_used" | |
| 107 }, | |
| 108 | |
| 109 { "end_of_list", '\0', NULL, NULL } | |
| 110 }; | |
| 111 | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
112 struct dsync_slave_stream { |
| 14584 | 113 struct dsync_slave slave; |
| 114 | |
| 115 char *name, *temp_path_prefix; | |
| 116 int fd_in, fd_out; | |
| 117 struct istream *input; | |
| 118 struct ostream *output; | |
| 119 struct io *io; | |
| 120 struct timeout *to; | |
| 121 | |
| 122 struct dsync_serializer *serializers[ITEM_END_OF_LIST]; | |
| 123 struct dsync_deserializer *deserializers[ITEM_END_OF_LIST]; | |
| 124 | |
| 125 pool_t ret_pool; | |
| 126 struct dsync_deserializer_decoder *cur_decoder; | |
| 127 | |
| 128 struct istream *mail_output, *mail_input; | |
| 129 struct dsync_mail *cur_mail; | |
| 130 char mail_output_last; | |
| 131 | |
| 132 unsigned int version_received:1; | |
| 133 unsigned int handshake_received:1; | |
| 134 unsigned int has_pending_data:1; | |
| 135 }; | |
| 136 | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
137 static void dsync_slave_stream_stop(struct dsync_slave_stream *slave) |
| 14584 | 138 { |
| 139 i_stream_close(slave->input); | |
| 140 o_stream_close(slave->output); | |
| 141 io_loop_stop(current_ioloop); | |
| 142 } | |
| 143 | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
144 static int dsync_slave_stream_read_mail_stream(struct dsync_slave_stream *slave) |
| 14584 | 145 { |
| 146 if (i_stream_read(slave->mail_input) < 0) { | |
| 147 if (slave->mail_input->stream_errno != 0) { | |
| 148 errno = slave->mail_input->stream_errno; | |
| 149 i_error("dsync(%s): read() failed: %m", slave->name); | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
150 dsync_slave_stream_stop(slave); |
| 14584 | 151 return -1; |
| 152 } | |
| 153 /* finished reading the mail stream */ | |
| 154 i_assert(slave->mail_input->eof); | |
| 155 i_stream_seek(slave->mail_input, 0); | |
| 156 slave->mail_input = NULL; | |
| 157 return 1; | |
| 158 } | |
|
14683
9646f80ac3e9
Added i_stream_get_data_size(). Used it where possible.
Timo Sirainen <tss@iki.fi>
parents:
14681
diff
changeset
|
159 i_stream_skip(slave->mail_input, |
|
9646f80ac3e9
Added i_stream_get_data_size(). Used it where possible.
Timo Sirainen <tss@iki.fi>
parents:
14681
diff
changeset
|
160 i_stream_get_data_size(slave->mail_input)); |
| 14584 | 161 return 0; |
| 162 } | |
| 163 | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
164 static void dsync_slave_stream_input(struct dsync_slave_stream *slave) |
| 14584 | 165 { |
| 166 if (slave->mail_input != NULL) { | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
167 if (dsync_slave_stream_read_mail_stream(slave) == 0) |
| 14584 | 168 return; |
| 169 } | |
| 170 slave->slave.io_callback(slave->slave.io_context); | |
| 171 } | |
| 172 | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
173 static int dsync_slave_stream_send_mail_stream(struct dsync_slave_stream *slave) |
| 14584 | 174 { |
| 175 const unsigned char *data; | |
| 176 unsigned char add; | |
| 177 size_t i, size; | |
| 178 int ret; | |
| 179 | |
| 180 while ((ret = i_stream_read_data(slave->mail_output, | |
| 181 &data, &size, 0)) > 0) { | |
| 182 add = '\0'; | |
| 183 for (i = 0; i < size; i++) { | |
| 184 if (data[i] == '\n') { | |
| 185 if ((i == 0 && slave->mail_output_last != '\r') || | |
| 186 (i > 0 && data[i-1] != '\r')) { | |
| 187 /* missing CR */ | |
| 188 add = '\r'; | |
| 189 break; | |
| 190 } | |
| 191 } else if (data[i] == '.' && | |
| 192 ((i == 0 && slave->mail_output_last == '\n') || | |
| 193 (i > 0 && data[i-1] == '\n'))) { | |
| 194 /* escape the dot */ | |
| 195 add = '.'; | |
| 196 break; | |
| 197 } | |
| 198 } | |
| 199 | |
| 200 if (i > 0) { | |
|
14681
ca37d1577291
Added o_stream_nsend*() and related functions to make delayed error handling safer.
Timo Sirainen <tss@iki.fi>
parents:
14629
diff
changeset
|
201 o_stream_nsend(slave->output, data, i); |
| 14584 | 202 slave->mail_output_last = data[i-1]; |
| 203 i_stream_skip(slave->mail_output, i); | |
| 204 } | |
| 205 | |
| 206 if (o_stream_get_buffer_used_size(slave->output) >= 4096) { | |
| 207 if ((ret = o_stream_flush(slave->output)) < 0) { | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
208 dsync_slave_stream_stop(slave); |
| 14584 | 209 return -1; |
| 210 } | |
| 211 if (ret == 0) { | |
| 212 /* continue later */ | |
| 213 o_stream_set_flush_pending(slave->output, TRUE); | |
| 214 return 0; | |
| 215 } | |
| 216 } | |
| 217 | |
| 218 if (add != '\0') { | |
|
14681
ca37d1577291
Added o_stream_nsend*() and related functions to make delayed error handling safer.
Timo Sirainen <tss@iki.fi>
parents:
14629
diff
changeset
|
219 o_stream_nsend(slave->output, &add, 1); |
| 14584 | 220 slave->mail_output_last = add; |
| 221 } | |
| 222 } | |
| 223 i_assert(ret == -1); | |
| 224 | |
| 225 if (slave->mail_output->stream_errno != 0) { | |
| 226 i_error("dsync(%s): read(%s) failed: %m", | |
| 227 slave->name, i_stream_get_name(slave->mail_output)); | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
228 dsync_slave_stream_stop(slave); |
| 14584 | 229 return -1; |
| 230 } | |
| 231 | |
| 232 /* finished sending the stream */ | |
|
14681
ca37d1577291
Added o_stream_nsend*() and related functions to make delayed error handling safer.
Timo Sirainen <tss@iki.fi>
parents:
14629
diff
changeset
|
233 o_stream_nsend_str(slave->output, "\r\n.\r\n"); |
| 14584 | 234 i_stream_unref(&slave->mail_output); |
| 235 return 1; | |
| 236 } | |
| 237 | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
238 static int dsync_slave_stream_output(struct dsync_slave_stream *slave) |
| 14584 | 239 { |
| 240 struct ostream *output = slave->output; | |
| 241 int ret; | |
| 242 | |
| 243 if ((ret = o_stream_flush(output)) < 0) | |
| 244 ret = 1; | |
| 245 else if (slave->mail_output != NULL) { | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
246 if (dsync_slave_stream_send_mail_stream(slave) < 0) |
| 14584 | 247 ret = 1; |
| 248 } | |
| 249 timeout_reset(slave->to); | |
| 250 | |
| 251 if (!dsync_slave_is_send_queue_full(&slave->slave)) | |
| 252 slave->slave.io_callback(slave->slave.io_context); | |
| 253 return ret; | |
| 254 } | |
| 255 | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
256 static void dsync_slave_stream_timeout(struct dsync_slave_stream *slave) |
| 14584 | 257 { |
| 258 i_error("dsync(%s): I/O has stalled, no activity for %u seconds", | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
259 slave->name, DSYNC_SLAVE_STREAM_TIMEOUT_MSECS/1000); |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
260 dsync_slave_stream_stop(slave); |
| 14584 | 261 } |
| 262 | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
263 static void dsync_slave_stream_init(struct dsync_slave_stream *slave) |
| 14584 | 264 { |
| 265 unsigned int i; | |
| 266 | |
| 267 fd_set_nonblock(slave->fd_in, TRUE); | |
| 268 fd_set_nonblock(slave->fd_out, TRUE); | |
| 269 | |
| 270 slave->input = i_stream_create_fd(slave->fd_in, (size_t)-1, FALSE); | |
| 271 slave->output = o_stream_create_fd(slave->fd_out, (size_t)-1, FALSE); | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
272 slave->io = io_add(slave->fd_in, IO_READ, |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
273 dsync_slave_stream_input, slave); |
|
14681
ca37d1577291
Added o_stream_nsend*() and related functions to make delayed error handling safer.
Timo Sirainen <tss@iki.fi>
parents:
14629
diff
changeset
|
274 o_stream_set_no_error_handling(slave->output, TRUE); |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
275 o_stream_set_flush_callback(slave->output, dsync_slave_stream_output, |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
276 slave); |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
277 slave->to = timeout_add(DSYNC_SLAVE_STREAM_TIMEOUT_MSECS, |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
278 dsync_slave_stream_timeout, slave); |
| 14584 | 279 o_stream_cork(slave->output); |
|
14681
ca37d1577291
Added o_stream_nsend*() and related functions to make delayed error handling safer.
Timo Sirainen <tss@iki.fi>
parents:
14629
diff
changeset
|
280 o_stream_nsend_str(slave->output, DSYNC_HANDSHAKE_VERSION); |
| 14584 | 281 |
| 282 /* initialize serializers and send their headers to remote */ | |
| 283 for (i = 1; i < ITEM_END_OF_LIST; i++) T_BEGIN { | |
| 284 const char *keys; | |
| 285 | |
| 286 keys = items[i].required_keys == NULL ? items[i].optional_keys : | |
| 287 t_strconcat(items[i].required_keys, " ", | |
| 288 items[i].optional_keys, NULL); | |
| 289 if (keys != NULL) { | |
| 290 i_assert(items[i].chr != '\0'); | |
| 291 | |
| 292 slave->serializers[i] = | |
| 293 dsync_serializer_init(t_strsplit_spaces(keys, " ")); | |
|
14681
ca37d1577291
Added o_stream_nsend*() and related functions to make delayed error handling safer.
Timo Sirainen <tss@iki.fi>
parents:
14629
diff
changeset
|
294 o_stream_nsend(slave->output, &items[i].chr, 1); |
|
ca37d1577291
Added o_stream_nsend*() and related functions to make delayed error handling safer.
Timo Sirainen <tss@iki.fi>
parents:
14629
diff
changeset
|
295 o_stream_nsend_str(slave->output, |
| 14584 | 296 dsync_serializer_encode_header_line(slave->serializers[i])); |
| 297 } | |
| 298 } T_END; | |
|
14681
ca37d1577291
Added o_stream_nsend*() and related functions to make delayed error handling safer.
Timo Sirainen <tss@iki.fi>
parents:
14629
diff
changeset
|
299 o_stream_nsend_str(slave->output, ".\n"); |
| 14584 | 300 |
| 301 dsync_slave_flush(&slave->slave); | |
| 302 } | |
| 303 | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
304 static void dsync_slave_stream_deinit(struct dsync_slave *_slave) |
| 14584 | 305 { |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
306 struct dsync_slave_stream *slave = (struct dsync_slave_stream *)_slave; |
| 14584 | 307 |
| 308 if (slave->cur_decoder != NULL) | |
| 309 dsync_deserializer_decode_finish(&slave->cur_decoder); | |
| 310 if (slave->mail_output != NULL) | |
| 311 i_stream_unref(&slave->mail_output); | |
| 312 | |
| 313 timeout_remove(&slave->to); | |
| 314 if (slave->io != NULL) | |
| 315 io_remove(&slave->io); | |
| 316 i_stream_destroy(&slave->input); | |
| 317 o_stream_destroy(&slave->output); | |
| 318 if (close(slave->fd_in) < 0) | |
| 319 i_error("close(%s) failed: %m", slave->name); | |
| 320 if (slave->fd_in != slave->fd_out) { | |
| 321 if (close(slave->fd_out) < 0) | |
| 322 i_error("close(%s) failed: %m", slave->name); | |
| 323 } | |
| 324 pool_unref(&slave->ret_pool); | |
| 325 i_free(slave->temp_path_prefix); | |
| 326 i_free(slave->name); | |
| 327 i_free(slave); | |
| 328 } | |
| 329 | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
330 static int dsync_slave_stream_next_line(struct dsync_slave_stream *slave, |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
331 const char **line_r) |
| 14584 | 332 { |
| 333 const char *line; | |
| 334 | |
| 335 line = i_stream_next_line(slave->input); | |
| 336 if (line != NULL) { | |
| 337 *line_r = line; | |
| 338 return 1; | |
| 339 } | |
| 340 | |
| 341 /* try reading some */ | |
| 342 switch (i_stream_read(slave->input)) { | |
| 343 case -1: | |
| 344 if (slave->input->stream_errno != 0) { | |
| 345 errno = slave->input->stream_errno; | |
| 346 i_error("read(%s) failed: %m", slave->name); | |
| 347 } else { | |
| 348 i_assert(slave->input->eof); | |
| 349 i_error("read(%s) failed: EOF", slave->name); | |
| 350 } | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
351 dsync_slave_stream_stop(slave); |
| 14584 | 352 return -1; |
| 353 case 0: | |
| 354 return 0; | |
| 355 } | |
| 356 *line_r = i_stream_next_line(slave->input); | |
| 357 if (*line_r == NULL) { | |
| 358 slave->has_pending_data = FALSE; | |
| 359 return 0; | |
| 360 } | |
| 361 slave->has_pending_data = TRUE; | |
| 362 return 1; | |
| 363 } | |
| 364 | |
|
14629
c93ca5e46a8a
Marked functions parameters that are allowed to be NULL. Some APIs were also changed.
Timo Sirainen <tss@iki.fi>
parents:
14584
diff
changeset
|
365 static void ATTR_FORMAT(3, 4) ATTR_NULL(2) |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
366 dsync_slave_input_error(struct dsync_slave_stream *slave, |
| 14584 | 367 struct dsync_deserializer_decoder *decoder, |
| 368 const char *fmt, ...) | |
| 369 { | |
| 370 va_list args; | |
| 371 const char *error; | |
| 372 | |
| 373 va_start(args, fmt); | |
| 374 error = t_strdup_vprintf(fmt, args); | |
| 375 if (decoder == NULL) | |
| 376 i_error("dsync(%s): %s", slave->name, error); | |
| 377 else { | |
| 378 i_error("dsync(%s): %s: %s", slave->name, | |
| 379 dsync_deserializer_decoder_get_name(decoder), error); | |
| 380 } | |
| 381 va_end(args); | |
| 382 | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
383 dsync_slave_stream_stop(slave); |
| 14584 | 384 } |
| 385 | |
| 386 static void | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
387 dsync_slave_stream_send_string(struct dsync_slave_stream *slave, |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
388 const string_t *str) |
| 14584 | 389 { |
| 390 i_assert(slave->mail_output == NULL); | |
|
14681
ca37d1577291
Added o_stream_nsend*() and related functions to make delayed error handling safer.
Timo Sirainen <tss@iki.fi>
parents:
14629
diff
changeset
|
391 o_stream_nsend(slave->output, str_data(str), str_len(str)); |
| 14584 | 392 } |
| 393 | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
394 static int |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
395 dsync_slave_check_missing_deserializers(struct dsync_slave_stream *slave) |
| 14584 | 396 { |
| 397 unsigned int i; | |
| 398 int ret = 0; | |
| 399 | |
| 400 for (i = 1; i < ITEM_END_OF_LIST; i++) { | |
| 401 if (slave->deserializers[i] == NULL && | |
| 402 (items[i].required_keys != NULL || | |
| 403 items[i].optional_keys != NULL)) { | |
| 404 dsync_slave_input_error(slave, NULL, | |
| 405 "Remote didn't handshake deserializer for %s", | |
| 406 items[i].name); | |
| 407 ret = -1; | |
| 408 } | |
| 409 } | |
| 410 return ret; | |
| 411 } | |
| 412 | |
| 413 static bool | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
414 dsync_slave_stream_handshake(struct dsync_slave_stream *slave, const char *line) |
| 14584 | 415 { |
| 416 enum item_type item = ITEM_NONE; | |
| 417 const char *const *required_keys, *error; | |
| 418 unsigned int i; | |
| 419 | |
| 420 if (slave->handshake_received) | |
| 421 return TRUE; | |
| 422 | |
| 423 if (!slave->version_received) { | |
| 424 if (!version_string_verify(line, "dsync", | |
| 425 DSYNC_PROTOCOL_VERSION_MAJOR)) { | |
| 426 dsync_slave_input_error(slave, NULL, | |
| 427 "Remote dsync doesn't use compatible protocol"); | |
| 428 return DSYNC_SLAVE_RECV_RET_TRYAGAIN; | |
| 429 } | |
| 430 slave->version_received = TRUE; | |
| 431 return FALSE; | |
| 432 } | |
| 433 | |
| 434 if (strcmp(line, END_OF_LIST_LINE) == 0) { | |
| 435 /* finished handshaking */ | |
| 436 if (dsync_slave_check_missing_deserializers(slave) < 0) | |
| 437 return FALSE; | |
| 438 slave->handshake_received = TRUE; | |
| 439 return FALSE; | |
| 440 } | |
| 441 | |
| 442 for (i = 1; i < ITEM_END_OF_LIST; i++) { | |
| 443 if (items[i].chr == line[0]) { | |
| 444 item = i; | |
| 445 break; | |
| 446 } | |
| 447 } | |
| 448 if (item == ITEM_NONE) { | |
| 449 /* unknown deserializer, ignore */ | |
| 450 return FALSE; | |
| 451 } | |
| 452 | |
| 453 required_keys = items[item].required_keys == NULL ? NULL : | |
| 454 t_strsplit(items[item].required_keys, " "); | |
| 455 if (dsync_deserializer_init(items[item].name, | |
| 456 required_keys, line + 1, | |
| 457 &slave->deserializers[item], &error) < 0) { | |
| 458 dsync_slave_input_error(slave, NULL, | |
| 459 "Remote sent invalid handshake for %s: %s", | |
| 460 items[item].name, error); | |
| 461 } | |
| 462 return FALSE; | |
| 463 } | |
| 464 | |
| 465 static enum dsync_slave_recv_ret | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
466 dsync_slave_stream_input_next(struct dsync_slave_stream *slave, enum item_type item, |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
467 struct dsync_deserializer_decoder **decoder_r) |
| 14584 | 468 { |
| 469 enum item_type line_item = ITEM_NONE; | |
| 470 const char *line, *error; | |
| 471 unsigned int i; | |
| 472 | |
| 473 i_assert(slave->mail_input == NULL); | |
| 474 | |
| 475 timeout_reset(slave->to); | |
| 476 | |
| 477 do { | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
478 if (dsync_slave_stream_next_line(slave, &line) <= 0) |
| 14584 | 479 return DSYNC_SLAVE_RECV_RET_TRYAGAIN; |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
480 } while (!dsync_slave_stream_handshake(slave, line)); |
| 14584 | 481 |
| 482 if (strcmp(line, END_OF_LIST_LINE) == 0) { | |
| 483 /* end of this list */ | |
| 484 return DSYNC_SLAVE_RECV_RET_FINISHED; | |
| 485 } | |
| 486 for (i = 1; i < ITEM_END_OF_LIST; i++) { | |
| 487 if (*line == items[i].chr) { | |
| 488 line_item = i; | |
| 489 break; | |
| 490 } | |
| 491 } | |
| 492 if (line_item != item) { | |
| 493 dsync_slave_input_error(slave, NULL, | |
| 494 "Received unexpected input %c != %c", | |
| 495 *line, items[item].chr); | |
| 496 return DSYNC_SLAVE_RECV_RET_TRYAGAIN; | |
| 497 } | |
| 498 | |
| 499 if (slave->cur_decoder != NULL) | |
| 500 dsync_deserializer_decode_finish(&slave->cur_decoder); | |
| 501 if (dsync_deserializer_decode_begin(slave->deserializers[item], | |
| 502 line+1, &slave->cur_decoder, | |
| 503 &error) < 0) { | |
| 504 dsync_slave_input_error(slave, NULL, "Invalid input to %s: %s", | |
| 505 items[item].name, error); | |
| 506 return DSYNC_SLAVE_RECV_RET_TRYAGAIN; | |
| 507 } | |
| 508 *decoder_r = slave->cur_decoder; | |
| 509 return DSYNC_SLAVE_RECV_RET_OK; | |
| 510 } | |
| 511 | |
| 512 static void | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
513 dsync_slave_stream_send_handshake(struct dsync_slave *_slave, |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
514 const struct dsync_slave_settings *set) |
| 14584 | 515 { |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
516 struct dsync_slave_stream *slave = (struct dsync_slave_stream *)_slave; |
| 14584 | 517 struct dsync_serializer_encoder *encoder; |
| 518 string_t *str = t_str_new(128); | |
| 519 char sync_type[2]; | |
| 520 | |
| 521 str_append_c(str, items[ITEM_HANDSHAKE].chr); | |
| 522 encoder = dsync_serializer_encode_begin(slave->serializers[ITEM_HANDSHAKE]); | |
| 523 if (set->sync_ns_prefix != NULL) { | |
| 524 dsync_serializer_encode_add(encoder, "sync_ns_prefix", | |
| 525 set->sync_ns_prefix); | |
| 526 } | |
| 527 | |
| 528 sync_type[0] = sync_type[1] = '\0'; | |
| 529 switch (set->sync_type) { | |
| 530 case DSYNC_BRAIN_SYNC_TYPE_UNKNOWN: | |
| 531 break; | |
| 532 case DSYNC_BRAIN_SYNC_TYPE_FULL: | |
| 533 sync_type[0] = 'f'; | |
| 534 break; | |
| 535 case DSYNC_BRAIN_SYNC_TYPE_CHANGED: | |
| 536 sync_type[0] = 'c'; | |
| 537 break; | |
| 538 case DSYNC_BRAIN_SYNC_TYPE_STATE: | |
| 539 sync_type[0] = 's'; | |
| 540 break; | |
| 541 } | |
| 542 i_assert(sync_type[0] != '\0'); | |
| 543 dsync_serializer_encode_add(encoder, "sync_type", sync_type); | |
| 544 if (set->guid_requests) | |
| 545 dsync_serializer_encode_add(encoder, "guid_requests", ""); | |
| 546 if (set->mails_have_guids) | |
| 547 dsync_serializer_encode_add(encoder, "mails_have_guids", ""); | |
| 548 | |
| 549 dsync_serializer_encode_finish(&encoder, str); | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
550 dsync_slave_stream_send_string(slave, str); |
| 14584 | 551 } |
| 552 | |
| 553 static enum dsync_slave_recv_ret | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
554 dsync_slave_stream_recv_handshake(struct dsync_slave *_slave, |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
555 const struct dsync_slave_settings **set_r) |
| 14584 | 556 { |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
557 struct dsync_slave_stream *slave = (struct dsync_slave_stream *)_slave; |
| 14584 | 558 struct dsync_deserializer_decoder *decoder; |
| 559 struct dsync_slave_settings *set; | |
| 560 const char *value; | |
| 561 pool_t pool = slave->ret_pool; | |
| 562 enum dsync_slave_recv_ret ret; | |
| 563 | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
564 ret = dsync_slave_stream_input_next(slave, ITEM_HANDSHAKE, &decoder); |
| 14584 | 565 if (ret != DSYNC_SLAVE_RECV_RET_OK) { |
| 566 if (ret != DSYNC_SLAVE_RECV_RET_TRYAGAIN) { | |
| 567 i_error("dsync(%s): Unexpected input in handshake", | |
| 568 slave->name); | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
569 dsync_slave_stream_stop(slave); |
| 14584 | 570 } |
| 571 return DSYNC_SLAVE_RECV_RET_TRYAGAIN; | |
| 572 } | |
| 573 | |
| 574 p_clear(pool); | |
| 575 set = p_new(pool, struct dsync_slave_settings, 1); | |
| 576 | |
| 577 if (dsync_deserializer_decode_try(decoder, "sync_ns_prefix", &value)) | |
| 578 set->sync_ns_prefix = p_strdup(pool, value); | |
| 579 if (dsync_deserializer_decode_try(decoder, "sync_type", &value)) { | |
| 580 switch (value[0]) { | |
| 581 case 'f': | |
| 582 set->sync_type = DSYNC_BRAIN_SYNC_TYPE_FULL; | |
| 583 break; | |
| 584 case 'c': | |
| 585 set->sync_type = DSYNC_BRAIN_SYNC_TYPE_CHANGED; | |
| 586 break; | |
| 587 case 's': | |
| 588 set->sync_type = DSYNC_BRAIN_SYNC_TYPE_STATE; | |
| 589 break; | |
| 590 default: | |
| 591 dsync_slave_input_error(slave, decoder, | |
| 592 "Unknown sync_type: %s", value); | |
| 593 return DSYNC_SLAVE_RECV_RET_TRYAGAIN; | |
| 594 } | |
| 595 } | |
| 596 if (dsync_deserializer_decode_try(decoder, "guid_requests", &value)) | |
| 597 set->guid_requests = TRUE; | |
| 598 if (dsync_deserializer_decode_try(decoder, "mails_have_guids", &value)) | |
| 599 set->mails_have_guids = TRUE; | |
| 600 | |
| 601 *set_r = set; | |
| 602 return DSYNC_SLAVE_RECV_RET_OK; | |
| 603 } | |
| 604 | |
| 605 static void | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
606 dsync_slave_stream_send_end_of_list(struct dsync_slave *_slave) |
| 14584 | 607 { |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
608 struct dsync_slave_stream *slave = (struct dsync_slave_stream *)_slave; |
| 14584 | 609 |
| 610 i_assert(slave->mail_output == NULL); | |
| 611 | |
|
14681
ca37d1577291
Added o_stream_nsend*() and related functions to make delayed error handling safer.
Timo Sirainen <tss@iki.fi>
parents:
14629
diff
changeset
|
612 o_stream_nsend_str(slave->output, END_OF_LIST_LINE"\n"); |
| 14584 | 613 } |
| 614 | |
| 615 static void | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
616 dsync_slave_stream_send_mailbox_state(struct dsync_slave *_slave, |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
617 const struct dsync_mailbox_state *state) |
| 14584 | 618 { |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
619 struct dsync_slave_stream *slave = (struct dsync_slave_stream *)_slave; |
| 14584 | 620 struct dsync_serializer_encoder *encoder; |
| 621 string_t *str = t_str_new(128); | |
| 622 | |
| 623 str_append_c(str, items[ITEM_MAILBOX_STATE].chr); | |
| 624 encoder = dsync_serializer_encode_begin(slave->serializers[ITEM_MAILBOX_STATE]); | |
| 625 dsync_serializer_encode_add(encoder, "mailbox_guid", | |
| 626 guid_128_to_string(state->mailbox_guid)); | |
| 627 dsync_serializer_encode_add(encoder, "last_uidvalidity", | |
| 628 dec2str(state->last_uidvalidity)); | |
| 629 dsync_serializer_encode_add(encoder, "last_common_uid", | |
| 630 dec2str(state->last_common_uid)); | |
| 631 dsync_serializer_encode_add(encoder, "last_common_modseq", | |
| 632 dec2str(state->last_common_modseq)); | |
| 633 | |
| 634 dsync_serializer_encode_finish(&encoder, str); | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
635 dsync_slave_stream_send_string(slave, str); |
| 14584 | 636 } |
| 637 | |
| 638 static enum dsync_slave_recv_ret | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
639 dsync_slave_stream_recv_mailbox_state(struct dsync_slave *_slave, |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
640 struct dsync_mailbox_state *state_r) |
| 14584 | 641 { |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
642 struct dsync_slave_stream *slave = (struct dsync_slave_stream *)_slave; |
| 14584 | 643 struct dsync_deserializer_decoder *decoder; |
| 644 const char *value; | |
| 645 enum dsync_slave_recv_ret ret; | |
| 646 | |
| 647 memset(state_r, 0, sizeof(*state_r)); | |
| 648 | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
649 ret = dsync_slave_stream_input_next(slave, ITEM_MAILBOX_STATE, &decoder); |
| 14584 | 650 if (ret != DSYNC_SLAVE_RECV_RET_OK) |
| 651 return ret; | |
| 652 | |
| 653 value = dsync_deserializer_decode_get(decoder, "mailbox_guid"); | |
| 654 if (guid_128_from_string(value, state_r->mailbox_guid) < 0) { | |
| 655 dsync_slave_input_error(slave, decoder, "Invalid mailbox_guid"); | |
| 656 return DSYNC_SLAVE_RECV_RET_TRYAGAIN; | |
| 657 } | |
| 658 value = dsync_deserializer_decode_get(decoder, "last_uidvalidity"); | |
| 659 if (str_to_uint32(value, &state_r->last_uidvalidity) < 0) { | |
| 660 dsync_slave_input_error(slave, decoder, "Invalid last_uidvalidity"); | |
| 661 return DSYNC_SLAVE_RECV_RET_TRYAGAIN; | |
| 662 } | |
| 663 value = dsync_deserializer_decode_get(decoder, "last_common_uid"); | |
| 664 if (str_to_uint32(value, &state_r->last_uidvalidity) < 0) { | |
| 665 dsync_slave_input_error(slave, decoder, "Invalid last_common_uid"); | |
| 666 return DSYNC_SLAVE_RECV_RET_TRYAGAIN; | |
| 667 } | |
| 668 value = dsync_deserializer_decode_get(decoder, "last_common_modseq"); | |
| 669 if (str_to_uint32(value, &state_r->last_uidvalidity) < 0) { | |
| 670 dsync_slave_input_error(slave, decoder, "Invalid last_common_modseq"); | |
| 671 return DSYNC_SLAVE_RECV_RET_TRYAGAIN; | |
| 672 } | |
| 673 return DSYNC_SLAVE_RECV_RET_OK; | |
| 674 } | |
| 675 | |
| 676 static void | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
677 dsync_slave_stream_send_mailbox_tree_node(struct dsync_slave *_slave, |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
678 const char *const *name, |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
679 const struct dsync_mailbox_node *node) |
| 14584 | 680 { |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
681 struct dsync_slave_stream *slave = (struct dsync_slave_stream *)_slave; |
| 14584 | 682 struct dsync_serializer_encoder *encoder; |
| 683 string_t *str, *namestr; | |
| 684 | |
| 685 i_assert(*name != NULL); | |
| 686 | |
| 687 str = t_str_new(128); | |
| 688 str_append_c(str, items[ITEM_MAILBOX_TREE_NODE].chr); | |
| 689 | |
| 690 /* convert all hierarchy separators to tabs. mailbox names really | |
| 691 aren't supposed to have any tabs, but escape them anyway if there | |
| 692 are. */ | |
| 693 namestr = t_str_new(128); | |
| 694 for (; *name != NULL; name++) { | |
| 695 str_tabescape_write(namestr, *name); | |
| 696 str_append_c(namestr, '\t'); | |
| 697 } | |
| 698 str_truncate(namestr, str_len(namestr)-1); | |
| 699 | |
| 700 encoder = dsync_serializer_encode_begin(slave->serializers[ITEM_MAILBOX_TREE_NODE]); | |
| 701 dsync_serializer_encode_add(encoder, "name", str_c(namestr)); | |
| 702 switch (node->existence) { | |
| 703 case DSYNC_MAILBOX_NODE_NONEXISTENT: | |
| 704 dsync_serializer_encode_add(encoder, "existence", "n"); | |
| 705 break; | |
| 706 case DSYNC_MAILBOX_NODE_EXISTS: | |
| 707 dsync_serializer_encode_add(encoder, "existence", "y"); | |
| 708 break; | |
| 709 case DSYNC_MAILBOX_NODE_DELETED: | |
| 710 dsync_serializer_encode_add(encoder, "existence", "d"); | |
| 711 break; | |
| 712 } | |
| 713 | |
| 714 if (!guid_128_is_empty(node->mailbox_guid)) { | |
| 715 dsync_serializer_encode_add(encoder, "mailbox_guid", | |
| 716 guid_128_to_string(node->mailbox_guid)); | |
| 717 } | |
| 718 if (node->uid_validity != 0) { | |
| 719 dsync_serializer_encode_add(encoder, "uid_validity", | |
| 720 dec2str(node->uid_validity)); | |
| 721 } | |
|
15035
0af20585964d
dsync: Rewritten syncing for mailbox renames.
Timo Sirainen <tss@iki.fi>
parents:
14691
diff
changeset
|
722 if (node->last_renamed_or_created != 0) { |
|
0af20585964d
dsync: Rewritten syncing for mailbox renames.
Timo Sirainen <tss@iki.fi>
parents:
14691
diff
changeset
|
723 dsync_serializer_encode_add(encoder, "last_renamed_or_created", |
|
0af20585964d
dsync: Rewritten syncing for mailbox renames.
Timo Sirainen <tss@iki.fi>
parents:
14691
diff
changeset
|
724 dec2str(node->last_renamed_or_created)); |
| 14584 | 725 } |
| 726 if (node->last_subscription_change != 0) { | |
| 727 dsync_serializer_encode_add(encoder, "last_subscription_change", | |
| 728 dec2str(node->last_subscription_change)); | |
| 729 } | |
| 730 if (node->subscribed) | |
| 731 dsync_serializer_encode_add(encoder, "subscribed", ""); | |
| 732 dsync_serializer_encode_finish(&encoder, str); | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
733 dsync_slave_stream_send_string(slave, str); |
| 14584 | 734 } |
| 735 | |
| 736 static enum dsync_slave_recv_ret | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
737 dsync_slave_stream_recv_mailbox_tree_node(struct dsync_slave *_slave, |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
738 const char *const **name_r, |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
739 const struct dsync_mailbox_node **node_r) |
| 14584 | 740 { |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
741 struct dsync_slave_stream *slave = (struct dsync_slave_stream *)_slave; |
| 14584 | 742 struct dsync_deserializer_decoder *decoder; |
| 743 struct dsync_mailbox_node *node; | |
| 744 const char *value; | |
| 745 enum dsync_slave_recv_ret ret; | |
| 746 | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
747 ret = dsync_slave_stream_input_next(slave, ITEM_MAILBOX_TREE_NODE, &decoder); |
| 14584 | 748 if (ret != DSYNC_SLAVE_RECV_RET_OK) |
| 749 return ret; | |
| 750 | |
| 751 p_clear(slave->ret_pool); | |
| 752 node = p_new(slave->ret_pool, struct dsync_mailbox_node, 1); | |
| 753 | |
| 754 value = dsync_deserializer_decode_get(decoder, "name"); | |
| 755 if (*value == '\0') { | |
| 756 dsync_slave_input_error(slave, decoder, "Empty name"); | |
| 757 return DSYNC_SLAVE_RECV_RET_TRYAGAIN; | |
| 758 } | |
| 759 *name_r = (void *)p_strsplit_tabescaped(slave->ret_pool, value); | |
| 760 | |
| 761 value = dsync_deserializer_decode_get(decoder, "existence"); | |
| 762 switch (*value) { | |
| 763 case 'n': | |
| 764 node->existence = DSYNC_MAILBOX_NODE_NONEXISTENT; | |
| 765 break; | |
| 766 case 'y': | |
| 767 node->existence = DSYNC_MAILBOX_NODE_EXISTS; | |
| 768 break; | |
| 769 case 'd': | |
| 770 node->existence = DSYNC_MAILBOX_NODE_DELETED; | |
| 771 break; | |
| 772 } | |
| 773 | |
| 774 if (dsync_deserializer_decode_try(decoder, "mailbox_guid", &value) && | |
| 775 guid_128_from_string(value, node->mailbox_guid) < 0) { | |
| 776 dsync_slave_input_error(slave, decoder, "Invalid mailbox_guid"); | |
| 777 return DSYNC_SLAVE_RECV_RET_TRYAGAIN; | |
| 778 } | |
| 779 if (dsync_deserializer_decode_try(decoder, "uid_validity", &value) && | |
| 780 str_to_uint32(value, &node->uid_validity) < 0) { | |
| 781 dsync_slave_input_error(slave, decoder, "Invalid uid_validity"); | |
| 782 return DSYNC_SLAVE_RECV_RET_TRYAGAIN; | |
| 783 } | |
|
15035
0af20585964d
dsync: Rewritten syncing for mailbox renames.
Timo Sirainen <tss@iki.fi>
parents:
14691
diff
changeset
|
784 if (dsync_deserializer_decode_try(decoder, "last_renamed_or_created", &value) && |
|
0af20585964d
dsync: Rewritten syncing for mailbox renames.
Timo Sirainen <tss@iki.fi>
parents:
14691
diff
changeset
|
785 str_to_time(value, &node->last_renamed_or_created) < 0) { |
|
0af20585964d
dsync: Rewritten syncing for mailbox renames.
Timo Sirainen <tss@iki.fi>
parents:
14691
diff
changeset
|
786 dsync_slave_input_error(slave, decoder, "Invalid last_renamed_or_created"); |
| 14584 | 787 return DSYNC_SLAVE_RECV_RET_TRYAGAIN; |
| 788 } | |
| 789 if (dsync_deserializer_decode_try(decoder, "last_subscription_change", &value) && | |
| 790 str_to_time(value, &node->last_subscription_change) < 0) { | |
| 791 dsync_slave_input_error(slave, decoder, "Invalid last_subscription_change"); | |
| 792 return DSYNC_SLAVE_RECV_RET_TRYAGAIN; | |
| 793 } | |
| 794 if (dsync_deserializer_decode_try(decoder, "subscribed", &value)) | |
| 795 node->subscribed = TRUE; | |
| 796 | |
| 797 *node_r = node; | |
| 798 return DSYNC_SLAVE_RECV_RET_OK; | |
| 799 } | |
| 800 | |
| 801 static void | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
802 dsync_slave_stream_send_mailbox_deletes(struct dsync_slave *_slave, |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
803 const struct dsync_mailbox_delete *deletes, |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
804 unsigned int count, char hierarchy_sep) |
| 14584 | 805 { |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
806 struct dsync_slave_stream *slave = (struct dsync_slave_stream *)_slave; |
| 14584 | 807 struct dsync_serializer_encoder *encoder; |
|
15035
0af20585964d
dsync: Rewritten syncing for mailbox renames.
Timo Sirainen <tss@iki.fi>
parents:
14691
diff
changeset
|
808 string_t *str, *substr; |
| 14584 | 809 char sep[2]; |
| 810 unsigned int i; | |
| 811 | |
| 812 str = t_str_new(128); | |
| 813 str_append_c(str, items[ITEM_MAILBOX_DELETE].chr); | |
| 814 | |
| 815 encoder = dsync_serializer_encode_begin(slave->serializers[ITEM_MAILBOX_DELETE]); | |
| 816 sep[0] = hierarchy_sep; sep[1] = '\0'; | |
| 817 dsync_serializer_encode_add(encoder, "hierarchy_sep", sep); | |
| 818 | |
|
15035
0af20585964d
dsync: Rewritten syncing for mailbox renames.
Timo Sirainen <tss@iki.fi>
parents:
14691
diff
changeset
|
819 substr = t_str_new(128); |
| 14584 | 820 for (i = 0; i < count; i++) { |
| 821 if (deletes[i].delete_mailbox) { | |
|
15035
0af20585964d
dsync: Rewritten syncing for mailbox renames.
Timo Sirainen <tss@iki.fi>
parents:
14691
diff
changeset
|
822 str_append(substr, guid_128_to_string(deletes[i].guid)); |
|
0af20585964d
dsync: Rewritten syncing for mailbox renames.
Timo Sirainen <tss@iki.fi>
parents:
14691
diff
changeset
|
823 str_printfa(substr, " %ld ", (long)deletes[i].timestamp); |
| 14584 | 824 } |
| 825 } | |
|
15035
0af20585964d
dsync: Rewritten syncing for mailbox renames.
Timo Sirainen <tss@iki.fi>
parents:
14691
diff
changeset
|
826 if (str_len(substr) > 0) { |
|
0af20585964d
dsync: Rewritten syncing for mailbox renames.
Timo Sirainen <tss@iki.fi>
parents:
14691
diff
changeset
|
827 str_truncate(substr, str_len(substr)-1); |
| 14584 | 828 dsync_serializer_encode_add(encoder, "mailboxes", |
|
15035
0af20585964d
dsync: Rewritten syncing for mailbox renames.
Timo Sirainen <tss@iki.fi>
parents:
14691
diff
changeset
|
829 str_c(substr)); |
| 14584 | 830 } |
| 831 | |
|
15035
0af20585964d
dsync: Rewritten syncing for mailbox renames.
Timo Sirainen <tss@iki.fi>
parents:
14691
diff
changeset
|
832 str_truncate(substr, 0); |
| 14584 | 833 for (i = 0; i < count; i++) { |
| 834 if (!deletes[i].delete_mailbox) { | |
|
15035
0af20585964d
dsync: Rewritten syncing for mailbox renames.
Timo Sirainen <tss@iki.fi>
parents:
14691
diff
changeset
|
835 str_append(substr, guid_128_to_string(deletes[i].guid)); |
|
0af20585964d
dsync: Rewritten syncing for mailbox renames.
Timo Sirainen <tss@iki.fi>
parents:
14691
diff
changeset
|
836 str_printfa(substr, " %ld ", (long)deletes[i].timestamp); |
| 14584 | 837 } |
| 838 } | |
|
15035
0af20585964d
dsync: Rewritten syncing for mailbox renames.
Timo Sirainen <tss@iki.fi>
parents:
14691
diff
changeset
|
839 if (str_len(substr) > 0) { |
|
0af20585964d
dsync: Rewritten syncing for mailbox renames.
Timo Sirainen <tss@iki.fi>
parents:
14691
diff
changeset
|
840 str_truncate(substr, str_len(substr)-1); |
|
0af20585964d
dsync: Rewritten syncing for mailbox renames.
Timo Sirainen <tss@iki.fi>
parents:
14691
diff
changeset
|
841 dsync_serializer_encode_add(encoder, "dirs", str_c(substr)); |
| 14584 | 842 } |
| 843 dsync_serializer_encode_finish(&encoder, str); | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
844 dsync_slave_stream_send_string(slave, str); |
| 14584 | 845 } |
| 846 | |
| 847 ARRAY_DEFINE_TYPE(dsync_mailbox_delete, struct dsync_mailbox_delete); | |
| 848 static int | |
| 849 decode_mailbox_deletes(ARRAY_TYPE(dsync_mailbox_delete) *deletes, | |
| 850 const char *value, bool delete_mailbox) | |
| 851 { | |
| 852 struct dsync_mailbox_delete *del; | |
|
15035
0af20585964d
dsync: Rewritten syncing for mailbox renames.
Timo Sirainen <tss@iki.fi>
parents:
14691
diff
changeset
|
853 const char *const *tmp; |
| 14584 | 854 unsigned int i; |
| 855 | |
|
15035
0af20585964d
dsync: Rewritten syncing for mailbox renames.
Timo Sirainen <tss@iki.fi>
parents:
14691
diff
changeset
|
856 tmp = t_strsplit(value, " "); |
|
0af20585964d
dsync: Rewritten syncing for mailbox renames.
Timo Sirainen <tss@iki.fi>
parents:
14691
diff
changeset
|
857 for (i = 0; tmp[i] != NULL; i += 2) { |
| 14584 | 858 del = array_append_space(deletes); |
| 859 del->delete_mailbox = delete_mailbox; | |
|
15035
0af20585964d
dsync: Rewritten syncing for mailbox renames.
Timo Sirainen <tss@iki.fi>
parents:
14691
diff
changeset
|
860 if (guid_128_from_string(tmp[i], del->guid) < 0) |
|
0af20585964d
dsync: Rewritten syncing for mailbox renames.
Timo Sirainen <tss@iki.fi>
parents:
14691
diff
changeset
|
861 return -1; |
|
0af20585964d
dsync: Rewritten syncing for mailbox renames.
Timo Sirainen <tss@iki.fi>
parents:
14691
diff
changeset
|
862 if (tmp[i+1] == NULL || |
|
0af20585964d
dsync: Rewritten syncing for mailbox renames.
Timo Sirainen <tss@iki.fi>
parents:
14691
diff
changeset
|
863 str_to_time(tmp[i+1], &del->timestamp) < 0) |
| 14584 | 864 return -1; |
| 865 } | |
| 866 return 0; | |
| 867 } | |
| 868 | |
| 869 static enum dsync_slave_recv_ret | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
870 dsync_slave_stream_recv_mailbox_deletes(struct dsync_slave *_slave, |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
871 const struct dsync_mailbox_delete **deletes_r, |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
872 unsigned int *count_r, char *hierarchy_sep_r) |
| 14584 | 873 { |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
874 struct dsync_slave_stream *slave = (struct dsync_slave_stream *)_slave; |
| 14584 | 875 struct dsync_deserializer_decoder *decoder; |
| 876 ARRAY_TYPE(dsync_mailbox_delete) deletes; | |
| 877 const char *value; | |
| 878 enum dsync_slave_recv_ret ret; | |
| 879 | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
880 ret = dsync_slave_stream_input_next(slave, ITEM_MAILBOX_DELETE, &decoder); |
| 14584 | 881 if (ret != DSYNC_SLAVE_RECV_RET_OK) |
| 882 return ret; | |
| 883 | |
| 884 p_clear(slave->ret_pool); | |
| 885 p_array_init(&deletes, slave->ret_pool, 16); | |
| 886 | |
| 887 value = dsync_deserializer_decode_get(decoder, "hierarchy_sep"); | |
| 888 if (strlen(value) != 1) { | |
| 889 dsync_slave_input_error(slave, decoder, "Invalid hierarchy_sep"); | |
| 890 return DSYNC_SLAVE_RECV_RET_TRYAGAIN; | |
| 891 } | |
| 892 *hierarchy_sep_r = value[0]; | |
| 893 | |
| 894 if (dsync_deserializer_decode_try(decoder, "mailboxes", &value) && | |
| 895 decode_mailbox_deletes(&deletes, value, TRUE) < 0) { | |
| 896 dsync_slave_input_error(slave, decoder, "Invalid mailboxes"); | |
| 897 return DSYNC_SLAVE_RECV_RET_TRYAGAIN; | |
| 898 } | |
| 899 if (dsync_deserializer_decode_try(decoder, "dirs", &value) && | |
| 900 decode_mailbox_deletes(&deletes, value, FALSE) < 0) { | |
| 901 dsync_slave_input_error(slave, decoder, "Invalid dirs"); | |
| 902 return DSYNC_SLAVE_RECV_RET_TRYAGAIN; | |
| 903 } | |
| 904 *deletes_r = array_get(&deletes, count_r); | |
| 905 return DSYNC_SLAVE_RECV_RET_OK; | |
| 906 } | |
| 907 | |
| 908 static const char * | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
909 get_cache_fields(struct dsync_slave_stream *slave, |
| 14584 | 910 const struct dsync_mailbox *dsync_box) |
| 911 { | |
| 912 struct dsync_serializer_encoder *encoder; | |
| 913 string_t *str; | |
| 914 const struct mailbox_cache_field *cache_fields; | |
| 915 unsigned int i, count; | |
| 916 char decision[3]; | |
| 917 | |
| 918 cache_fields = array_get(&dsync_box->cache_fields, &count); | |
| 919 if (count == 0) | |
| 920 return ""; | |
| 921 | |
| 922 str = t_str_new(128); | |
| 923 for (i = 0; i < count; i++) { | |
| 924 const struct mailbox_cache_field *field = &cache_fields[i]; | |
| 925 | |
| 926 encoder = dsync_serializer_encode_begin(slave->serializers[ITEM_MAILBOX_CACHE_FIELD]); | |
| 927 dsync_serializer_encode_add(encoder, "name", field->name); | |
| 928 | |
| 929 memset(decision, 0, sizeof(decision)); | |
| 930 switch (field->decision & ~MAIL_CACHE_DECISION_FORCED) { | |
| 931 case MAIL_CACHE_DECISION_NO: | |
| 932 decision[0] = 'n'; | |
| 933 break; | |
| 934 case MAIL_CACHE_DECISION_TEMP: | |
| 935 decision[0] = 't'; | |
| 936 break; | |
| 937 case MAIL_CACHE_DECISION_YES: | |
| 938 decision[0] = 'y'; | |
| 939 break; | |
| 940 } | |
| 941 i_assert(decision[0] != '\0'); | |
| 942 if ((field->decision & MAIL_CACHE_DECISION_FORCED) != 0) | |
| 943 decision[1] = 'F'; | |
| 944 dsync_serializer_encode_add(encoder, "decision", decision); | |
| 945 if (field->last_used != 0) { | |
| 946 dsync_serializer_encode_add(encoder, "last_used", | |
| 947 dec2str(field->last_used)); | |
| 948 } | |
| 949 dsync_serializer_encode_finish(&encoder, str); | |
| 950 } | |
| 951 if (i > 0) { | |
| 952 /* remove the trailing LF */ | |
| 953 str_truncate(str, str_len(str)-1); | |
| 954 } | |
| 955 return str_c(str); | |
| 956 } | |
| 957 | |
| 958 static void | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
959 dsync_slave_stream_send_mailbox(struct dsync_slave *_slave, |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
960 const struct dsync_mailbox *dsync_box) |
| 14584 | 961 { |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
962 struct dsync_slave_stream *slave = (struct dsync_slave_stream *)_slave; |
| 14584 | 963 struct dsync_serializer_encoder *encoder; |
| 964 string_t *str = t_str_new(128); | |
| 965 const char *value; | |
| 966 | |
| 967 str_append_c(str, items[ITEM_MAILBOX].chr); | |
| 968 encoder = dsync_serializer_encode_begin(slave->serializers[ITEM_MAILBOX]); | |
| 969 dsync_serializer_encode_add(encoder, "mailbox_guid", | |
| 970 guid_128_to_string(dsync_box->mailbox_guid)); | |
| 971 | |
| 972 if (dsync_box->mailbox_lost) | |
| 973 dsync_serializer_encode_add(encoder, "mailbox_lost", ""); | |
| 974 dsync_serializer_encode_add(encoder, "uid_validity", | |
| 975 dec2str(dsync_box->uid_validity)); | |
| 976 dsync_serializer_encode_add(encoder, "uid_next", | |
| 977 dec2str(dsync_box->uid_next)); | |
| 978 dsync_serializer_encode_add(encoder, "messages_count", | |
| 979 dec2str(dsync_box->messages_count)); | |
| 980 dsync_serializer_encode_add(encoder, "first_recent_uid", | |
| 981 dec2str(dsync_box->first_recent_uid)); | |
| 982 dsync_serializer_encode_add(encoder, "highest_modseq", | |
| 983 dec2str(dsync_box->highest_modseq)); | |
| 984 | |
| 985 value = get_cache_fields(slave, dsync_box); | |
| 986 if (value != NULL) | |
| 987 dsync_serializer_encode_add(encoder, "cache_fields", value); | |
| 988 | |
| 989 dsync_serializer_encode_finish(&encoder, str); | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
990 dsync_slave_stream_send_string(slave, str); |
| 14584 | 991 } |
| 992 | |
| 993 static int | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
994 parse_cache_field(struct dsync_slave_stream *slave, struct dsync_mailbox *box, |
| 14584 | 995 const char *value) |
| 996 { | |
| 997 struct dsync_deserializer_decoder *decoder; | |
| 998 struct mailbox_cache_field field; | |
| 999 const char *error; | |
| 1000 int ret = 0; | |
| 1001 | |
| 1002 if (dsync_deserializer_decode_begin(slave->deserializers[ITEM_MAILBOX_CACHE_FIELD], | |
| 1003 value, &decoder, &error) < 0) { | |
| 1004 dsync_slave_input_error(slave, NULL, | |
| 1005 "cache_field: Invalid input: %s", error); | |
| 1006 return -1; | |
| 1007 } | |
| 1008 | |
| 1009 memset(&field, 0, sizeof(field)); | |
| 1010 value = dsync_deserializer_decode_get(decoder, "name"); | |
| 1011 field.name = p_strdup(slave->ret_pool, value); | |
| 1012 | |
| 1013 value = dsync_deserializer_decode_get(decoder, "decision"); | |
| 1014 switch (*value) { | |
| 1015 case 'n': | |
| 1016 field.decision = MAIL_CACHE_DECISION_NO; | |
| 1017 break; | |
| 1018 case 't': | |
| 1019 field.decision = MAIL_CACHE_DECISION_TEMP; | |
| 1020 break; | |
| 1021 case 'y': | |
| 1022 field.decision = MAIL_CACHE_DECISION_YES; | |
| 1023 break; | |
| 1024 default: | |
| 1025 dsync_slave_input_error(slave, decoder, "Invalid decision: %s", | |
| 1026 value); | |
| 1027 ret = -1; | |
| 1028 break; | |
| 1029 } | |
| 1030 if (value[1] == 'F') | |
| 1031 field.decision |= MAIL_CACHE_DECISION_FORCED; | |
| 1032 | |
| 1033 if (dsync_deserializer_decode_try(decoder, "last_used", &value) && | |
| 1034 str_to_time(value, &field.last_used) < 0) { | |
| 1035 dsync_slave_input_error(slave, decoder, "Invalid last_used"); | |
| 1036 ret = -1; | |
| 1037 } | |
| 1038 array_append(&box->cache_fields, &field, 1); | |
| 1039 | |
| 1040 dsync_deserializer_decode_finish(&decoder); | |
| 1041 return ret; | |
| 1042 } | |
| 1043 | |
| 1044 static enum dsync_slave_recv_ret | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1045 dsync_slave_stream_recv_mailbox(struct dsync_slave *_slave, |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1046 const struct dsync_mailbox **dsync_box_r) |
| 14584 | 1047 { |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1048 struct dsync_slave_stream *slave = (struct dsync_slave_stream *)_slave; |
| 14584 | 1049 pool_t pool = slave->ret_pool; |
| 1050 struct dsync_deserializer_decoder *decoder; | |
| 1051 struct dsync_mailbox *box; | |
| 1052 const char *value; | |
| 1053 enum dsync_slave_recv_ret ret; | |
| 1054 | |
| 1055 p_clear(pool); | |
| 1056 box = p_new(pool, struct dsync_mailbox, 1); | |
| 1057 | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1058 ret = dsync_slave_stream_input_next(slave, ITEM_MAILBOX, &decoder); |
| 14584 | 1059 if (ret != DSYNC_SLAVE_RECV_RET_OK) |
| 1060 return ret; | |
| 1061 | |
| 1062 value = dsync_deserializer_decode_get(decoder, "mailbox_guid"); | |
| 1063 if (guid_128_from_string(value, box->mailbox_guid) < 0) { | |
| 1064 dsync_slave_input_error(slave, decoder, "Invalid mailbox_guid"); | |
| 1065 return DSYNC_SLAVE_RECV_RET_TRYAGAIN; | |
| 1066 } | |
| 1067 | |
| 1068 if (dsync_deserializer_decode_try(decoder, "mailbox_lost", &value)) | |
| 1069 box->mailbox_lost = TRUE; | |
| 1070 value = dsync_deserializer_decode_get(decoder, "uid_validity"); | |
| 1071 if (str_to_uint32(value, &box->uid_validity) < 0) { | |
| 1072 dsync_slave_input_error(slave, decoder, "Invalid uid_validity"); | |
| 1073 return DSYNC_SLAVE_RECV_RET_TRYAGAIN; | |
| 1074 } | |
| 1075 value = dsync_deserializer_decode_get(decoder, "uid_next"); | |
| 1076 if (str_to_uint32(value, &box->uid_next) < 0) { | |
| 1077 dsync_slave_input_error(slave, decoder, "Invalid uid_next"); | |
| 1078 return DSYNC_SLAVE_RECV_RET_TRYAGAIN; | |
| 1079 } | |
| 1080 value = dsync_deserializer_decode_get(decoder, "messages_count"); | |
| 1081 if (str_to_uint32(value, &box->messages_count) < 0) { | |
| 1082 dsync_slave_input_error(slave, decoder, "Invalid messages_count"); | |
| 1083 return DSYNC_SLAVE_RECV_RET_TRYAGAIN; | |
| 1084 } | |
| 1085 value = dsync_deserializer_decode_get(decoder, "first_recent_uid"); | |
| 1086 if (str_to_uint32(value, &box->first_recent_uid) < 0) { | |
| 1087 dsync_slave_input_error(slave, decoder, "Invalid first_recent_uid"); | |
| 1088 return DSYNC_SLAVE_RECV_RET_TRYAGAIN; | |
| 1089 } | |
| 1090 value = dsync_deserializer_decode_get(decoder, "highest_modseq"); | |
| 1091 if (str_to_uint64(value, &box->highest_modseq) < 0) { | |
| 1092 dsync_slave_input_error(slave, decoder, "Invalid highest_modseq"); | |
| 1093 return DSYNC_SLAVE_RECV_RET_TRYAGAIN; | |
| 1094 } | |
| 1095 | |
| 1096 p_array_init(&box->cache_fields, pool, 32); | |
| 1097 if (dsync_deserializer_decode_try(decoder, "cache_fields", &value)) { | |
| 1098 const char *const *fields = t_strsplit(value, "\n"); | |
| 1099 for (; *fields != NULL; fields++) { | |
| 1100 if (parse_cache_field(slave, box, *fields) < 0) | |
| 1101 return DSYNC_SLAVE_RECV_RET_TRYAGAIN; | |
| 1102 } | |
| 1103 } | |
| 1104 | |
| 1105 *dsync_box_r = box; | |
| 1106 return DSYNC_SLAVE_RECV_RET_OK; | |
| 1107 } | |
| 1108 | |
| 1109 static void | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1110 dsync_slave_stream_send_change(struct dsync_slave *_slave, |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1111 const struct dsync_mail_change *change) |
| 14584 | 1112 { |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1113 struct dsync_slave_stream *slave = (struct dsync_slave_stream *)_slave; |
| 14584 | 1114 struct dsync_serializer_encoder *encoder; |
| 1115 string_t *str = t_str_new(128); | |
| 1116 char type[2]; | |
| 1117 | |
| 1118 str_append_c(str, items[ITEM_MAIL_CHANGE].chr); | |
| 1119 encoder = dsync_serializer_encode_begin(slave->serializers[ITEM_MAIL_CHANGE]); | |
| 1120 | |
| 1121 type[0] = type[1] = '\0'; | |
| 1122 switch (change->type) { | |
| 1123 case DSYNC_MAIL_CHANGE_TYPE_SAVE: | |
| 1124 type[0] = 's'; | |
| 1125 break; | |
| 1126 case DSYNC_MAIL_CHANGE_TYPE_EXPUNGE: | |
| 1127 type[0] = 'e'; | |
| 1128 break; | |
| 1129 case DSYNC_MAIL_CHANGE_TYPE_FLAG_CHANGE: | |
| 1130 type[0] = 'f'; | |
| 1131 break; | |
| 1132 } | |
| 1133 i_assert(type[0] != '\0'); | |
| 1134 dsync_serializer_encode_add(encoder, "type", type); | |
| 1135 dsync_serializer_encode_add(encoder, "uid", dec2str(change->uid)); | |
| 1136 if (change->guid != NULL) | |
| 1137 dsync_serializer_encode_add(encoder, "guid", change->guid); | |
| 1138 if (change->hdr_hash != NULL) { | |
| 1139 dsync_serializer_encode_add(encoder, "hdr_hash", | |
| 1140 change->hdr_hash); | |
| 1141 } | |
| 1142 if (change->modseq != 0) { | |
| 1143 dsync_serializer_encode_add(encoder, "modseq", | |
| 1144 dec2str(change->modseq)); | |
| 1145 } | |
| 1146 if (change->save_timestamp != 0) { | |
| 1147 dsync_serializer_encode_add(encoder, "save_timestamp", | |
| 1148 dec2str(change->save_timestamp)); | |
| 1149 } | |
| 1150 if (change->add_flags != 0) { | |
| 1151 dsync_serializer_encode_add(encoder, "add_flags", | |
| 1152 t_strdup_printf("%x", change->add_flags)); | |
| 1153 } | |
| 1154 if (change->remove_flags != 0) { | |
| 1155 dsync_serializer_encode_add(encoder, "remove_flags", | |
| 1156 t_strdup_printf("%x", change->remove_flags)); | |
| 1157 } | |
| 1158 if (change->final_flags != 0) { | |
| 1159 dsync_serializer_encode_add(encoder, "final_flags", | |
| 1160 t_strdup_printf("%x", change->final_flags)); | |
| 1161 } | |
| 1162 if (change->keywords_reset) | |
| 1163 dsync_serializer_encode_add(encoder, "keywords_reset", ""); | |
| 1164 | |
| 1165 if (array_is_created(&change->keyword_changes) && | |
| 1166 array_count(&change->keyword_changes) > 0) { | |
| 1167 string_t *kw_str = t_str_new(128); | |
| 1168 const char *const *changes; | |
| 1169 unsigned int i, count; | |
| 1170 | |
| 1171 changes = array_get(&change->keyword_changes, &count); | |
| 1172 str_tabescape_write(kw_str, changes[0]); | |
| 1173 for (i = 1; i < count; i++) { | |
| 1174 str_append_c(kw_str, '\t'); | |
| 1175 str_tabescape_write(kw_str, changes[i]); | |
| 1176 } | |
| 1177 dsync_serializer_encode_add(encoder, "keyword_changes", | |
| 1178 str_c(kw_str)); | |
| 1179 } | |
| 1180 | |
| 1181 dsync_serializer_encode_finish(&encoder, str); | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1182 dsync_slave_stream_send_string(slave, str); |
| 14584 | 1183 } |
| 1184 | |
| 1185 static enum dsync_slave_recv_ret | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1186 dsync_slave_stream_recv_change(struct dsync_slave *_slave, |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1187 const struct dsync_mail_change **change_r) |
| 14584 | 1188 { |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1189 struct dsync_slave_stream *slave = (struct dsync_slave_stream *)_slave; |
| 14584 | 1190 pool_t pool = slave->ret_pool; |
| 1191 struct dsync_deserializer_decoder *decoder; | |
| 1192 struct dsync_mail_change *change; | |
| 1193 const char *value; | |
| 1194 enum dsync_slave_recv_ret ret; | |
| 1195 | |
| 1196 p_clear(pool); | |
| 1197 change = p_new(pool, struct dsync_mail_change, 1); | |
| 1198 | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1199 ret = dsync_slave_stream_input_next(slave, ITEM_MAIL_CHANGE, &decoder); |
| 14584 | 1200 if (ret != DSYNC_SLAVE_RECV_RET_OK) |
| 1201 return ret; | |
| 1202 | |
| 1203 value = dsync_deserializer_decode_get(decoder, "type"); | |
| 1204 switch (*value) { | |
| 1205 case 's': | |
| 1206 change->type = DSYNC_MAIL_CHANGE_TYPE_SAVE; | |
| 1207 break; | |
| 1208 case 'e': | |
| 1209 change->type = DSYNC_MAIL_CHANGE_TYPE_EXPUNGE; | |
| 1210 break; | |
| 1211 case 'f': | |
| 1212 change->type = DSYNC_MAIL_CHANGE_TYPE_FLAG_CHANGE; | |
| 1213 break; | |
| 1214 default: | |
| 1215 dsync_slave_input_error(slave, decoder, | |
| 1216 "Invalid type: %s", value); | |
| 1217 return DSYNC_SLAVE_RECV_RET_TRYAGAIN; | |
| 1218 } | |
| 1219 | |
| 1220 value = dsync_deserializer_decode_get(decoder, "uid"); | |
| 1221 if (str_to_uint32(value, &change->uid) < 0) { | |
| 1222 dsync_slave_input_error(slave, decoder, "Invalid uid"); | |
| 1223 return DSYNC_SLAVE_RECV_RET_TRYAGAIN; | |
| 1224 } | |
| 1225 | |
| 1226 if (dsync_deserializer_decode_try(decoder, "guid", &value)) | |
| 1227 change->guid = p_strdup(pool, value); | |
| 1228 if (dsync_deserializer_decode_try(decoder, "hdr_hash", &value)) | |
| 1229 change->hdr_hash = p_strdup(pool, value); | |
| 1230 if (dsync_deserializer_decode_try(decoder, "modseq", &value) && | |
| 1231 str_to_uint64(value, &change->modseq) < 0) { | |
| 1232 dsync_slave_input_error(slave, decoder, "Invalid modseq"); | |
| 1233 return DSYNC_SLAVE_RECV_RET_TRYAGAIN; | |
| 1234 } | |
| 1235 if (dsync_deserializer_decode_try(decoder, "save_timestamp", &value) && | |
| 1236 str_to_time(value, &change->save_timestamp) < 0) { | |
| 1237 dsync_slave_input_error(slave, decoder, "Invalid save_timestamp"); | |
| 1238 return DSYNC_SLAVE_RECV_RET_TRYAGAIN; | |
| 1239 } | |
| 1240 | |
| 1241 if (dsync_deserializer_decode_try(decoder, "add_flags", &value)) | |
| 1242 change->add_flags = strtoul(value, NULL, 16); | |
| 1243 if (dsync_deserializer_decode_try(decoder, "remove_flags", &value)) | |
| 1244 change->remove_flags = strtoul(value, NULL, 16); | |
| 1245 if (dsync_deserializer_decode_try(decoder, "final_flags", &value)) | |
| 1246 change->final_flags = strtoul(value, NULL, 16); | |
| 1247 if (dsync_deserializer_decode_try(decoder, "keywords_reset", &value)) | |
| 1248 change->keywords_reset = TRUE; | |
| 1249 | |
| 1250 if (dsync_deserializer_decode_try(decoder, "keyword_changes", &value) && | |
| 1251 *value != '\0') { | |
| 1252 const char *const *changes = t_strsplit_tab(value); | |
| 1253 unsigned int i, count = str_array_length(changes); | |
| 1254 | |
| 1255 p_array_init(&change->keyword_changes, pool, count); | |
| 1256 for (i = 0; i < count; i++) { | |
| 1257 value = p_strdup(pool, changes[i]); | |
| 1258 array_append(&change->keyword_changes, &value, 1); | |
| 1259 } | |
| 1260 } | |
| 1261 | |
| 1262 *change_r = change; | |
| 1263 return DSYNC_SLAVE_RECV_RET_OK; | |
| 1264 } | |
| 1265 | |
| 1266 static void | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1267 dsync_slave_stream_send_mail_request(struct dsync_slave *_slave, |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1268 const struct dsync_mail_request *request) |
| 14584 | 1269 { |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1270 struct dsync_slave_stream *slave = (struct dsync_slave_stream *)_slave; |
| 14584 | 1271 struct dsync_serializer_encoder *encoder; |
| 1272 string_t *str = t_str_new(128); | |
| 1273 | |
| 1274 str_append_c(str, items[ITEM_MAIL_REQUEST].chr); | |
| 1275 encoder = dsync_serializer_encode_begin(slave->serializers[ITEM_MAIL_REQUEST]); | |
| 1276 if (request->guid != NULL) | |
| 1277 dsync_serializer_encode_add(encoder, "guid", request->guid); | |
| 1278 if (request->uid != 0) { | |
| 1279 dsync_serializer_encode_add(encoder, "uid", | |
| 1280 dec2str(request->uid)); | |
| 1281 } | |
| 1282 dsync_serializer_encode_finish(&encoder, str); | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1283 dsync_slave_stream_send_string(slave, str); |
| 14584 | 1284 } |
| 1285 | |
| 1286 static enum dsync_slave_recv_ret | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1287 dsync_slave_stream_recv_mail_request(struct dsync_slave *_slave, |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1288 const struct dsync_mail_request **request_r) |
| 14584 | 1289 { |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1290 struct dsync_slave_stream *slave = (struct dsync_slave_stream *)_slave; |
| 14584 | 1291 struct dsync_deserializer_decoder *decoder; |
| 1292 struct dsync_mail_request *request; | |
| 1293 const char *value; | |
| 1294 enum dsync_slave_recv_ret ret; | |
| 1295 | |
| 1296 p_clear(slave->ret_pool); | |
| 1297 request = p_new(slave->ret_pool, struct dsync_mail_request, 1); | |
| 1298 | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1299 ret = dsync_slave_stream_input_next(slave, ITEM_MAIL_REQUEST, &decoder); |
| 14584 | 1300 if (ret != DSYNC_SLAVE_RECV_RET_OK) |
| 1301 return ret; | |
| 1302 | |
| 1303 if (dsync_deserializer_decode_try(decoder, "guid", &value)) | |
| 1304 request->guid = p_strdup(slave->ret_pool, value); | |
| 1305 if (dsync_deserializer_decode_try(decoder, "uid", &value) && | |
| 1306 str_to_uint32(value, &request->uid) < 0) { | |
| 1307 dsync_slave_input_error(slave, decoder, "Invalid uid"); | |
| 1308 return DSYNC_SLAVE_RECV_RET_TRYAGAIN; | |
| 1309 } | |
| 1310 | |
| 1311 *request_r = request; | |
| 1312 return DSYNC_SLAVE_RECV_RET_OK; | |
| 1313 } | |
| 1314 | |
| 1315 static void | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1316 dsync_slave_stream_send_mail(struct dsync_slave *_slave, |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1317 const struct dsync_mail *mail) |
| 14584 | 1318 { |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1319 struct dsync_slave_stream *slave = (struct dsync_slave_stream *)_slave; |
| 14584 | 1320 struct dsync_serializer_encoder *encoder; |
| 1321 string_t *str = t_str_new(128); | |
| 1322 | |
| 1323 i_assert(slave->mail_output == NULL); | |
| 1324 | |
| 1325 str_append_c(str, items[ITEM_MAIL].chr); | |
| 1326 encoder = dsync_serializer_encode_begin(slave->serializers[ITEM_MAIL]); | |
| 1327 if (mail->guid != NULL) | |
| 1328 dsync_serializer_encode_add(encoder, "guid", mail->guid); | |
| 1329 if (mail->uid != 0) | |
| 1330 dsync_serializer_encode_add(encoder, "uid", dec2str(mail->uid)); | |
| 1331 if (mail->pop3_uidl != NULL) { | |
| 1332 dsync_serializer_encode_add(encoder, "pop3_uidl", | |
| 1333 mail->pop3_uidl); | |
| 1334 } | |
| 1335 if (mail->pop3_order > 0) { | |
| 1336 dsync_serializer_encode_add(encoder, "pop3_order", | |
| 1337 dec2str(mail->pop3_order)); | |
| 1338 } | |
| 1339 if (mail->received_date > 0) { | |
| 1340 dsync_serializer_encode_add(encoder, "received_date", | |
| 1341 dec2str(mail->received_date)); | |
| 1342 } | |
| 1343 if (mail->input != NULL) | |
| 1344 dsync_serializer_encode_add(encoder, "stream", ""); | |
| 1345 | |
| 1346 dsync_serializer_encode_finish(&encoder, str); | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1347 dsync_slave_stream_send_string(slave, str); |
| 14584 | 1348 |
| 1349 if (mail->input != NULL) { | |
| 1350 slave->mail_output_last = '\0'; | |
| 1351 slave->mail_output = mail->input; | |
| 1352 i_stream_ref(slave->mail_output); | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1353 (void)dsync_slave_stream_send_mail_stream(slave); |
| 14584 | 1354 } |
| 1355 } | |
| 1356 | |
| 1357 static int seekable_fd_callback(const char **path_r, void *context) | |
| 1358 { | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1359 struct dsync_slave_stream *slave = context; |
| 14584 | 1360 string_t *path; |
| 1361 int fd; | |
| 1362 | |
| 1363 path = t_str_new(128); | |
| 1364 str_append(path, slave->temp_path_prefix); | |
| 1365 fd = safe_mkstemp(path, 0600, (uid_t)-1, (gid_t)-1); | |
| 1366 if (fd == -1) { | |
| 1367 i_error("safe_mkstemp(%s) failed: %m", str_c(path)); | |
| 1368 return -1; | |
| 1369 } | |
| 1370 | |
| 1371 /* we just want the fd, unlink it */ | |
| 1372 if (unlink(str_c(path)) < 0) { | |
| 1373 /* shouldn't happen.. */ | |
| 1374 i_error("unlink(%s) failed: %m", str_c(path)); | |
|
14691
3945a3646c67
Changed i_close_fd() API to set the fd to -1 after closing.
Timo Sirainen <tss@iki.fi>
parents:
14687
diff
changeset
|
1375 i_close_fd(&fd); |
| 14584 | 1376 return -1; |
| 1377 } | |
| 1378 | |
| 1379 *path_r = str_c(path); | |
| 1380 return fd; | |
| 1381 } | |
| 1382 | |
| 1383 static enum dsync_slave_recv_ret | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1384 dsync_slave_stream_recv_mail(struct dsync_slave *_slave, |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1385 struct dsync_mail **mail_r) |
| 14584 | 1386 { |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1387 struct dsync_slave_stream *slave = (struct dsync_slave_stream *)_slave; |
| 14584 | 1388 pool_t pool = slave->ret_pool; |
| 1389 struct dsync_deserializer_decoder *decoder; | |
| 1390 struct dsync_mail *mail; | |
| 1391 struct istream *inputs[2]; | |
| 1392 const char *value; | |
| 1393 enum dsync_slave_recv_ret ret; | |
| 1394 | |
| 1395 if (slave->mail_input != NULL) { | |
| 1396 /* wait until the mail's stream has been read */ | |
| 1397 return DSYNC_SLAVE_RECV_RET_TRYAGAIN; | |
| 1398 } | |
| 1399 if (slave->cur_mail != NULL) { | |
| 1400 /* finished reading the stream, return the mail now */ | |
| 1401 *mail_r = slave->cur_mail; | |
| 1402 slave->cur_mail = NULL; | |
| 1403 return DSYNC_SLAVE_RECV_RET_OK; | |
| 1404 } | |
| 1405 | |
| 1406 p_clear(pool); | |
| 1407 mail = p_new(pool, struct dsync_mail, 1); | |
| 1408 | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1409 ret = dsync_slave_stream_input_next(slave, ITEM_MAIL, &decoder); |
| 14584 | 1410 if (ret != DSYNC_SLAVE_RECV_RET_OK) |
| 1411 return ret; | |
| 1412 | |
| 1413 if (dsync_deserializer_decode_try(decoder, "guid", &value)) | |
| 1414 mail->guid = p_strdup(pool, value); | |
| 1415 if (dsync_deserializer_decode_try(decoder, "uid", &value) && | |
| 1416 str_to_uint32(value, &mail->uid) < 0) { | |
| 1417 dsync_slave_input_error(slave, decoder, "Invalid uid"); | |
| 1418 return DSYNC_SLAVE_RECV_RET_TRYAGAIN; | |
| 1419 } | |
| 1420 if (dsync_deserializer_decode_try(decoder, "pop3_uidl", &value)) | |
| 1421 mail->pop3_uidl = p_strdup(pool, value); | |
| 1422 if (dsync_deserializer_decode_try(decoder, "pop3_order", &value) && | |
| 1423 str_to_uint(value, &mail->pop3_order) < 0) { | |
| 1424 dsync_slave_input_error(slave, decoder, "Invalid pop3_order"); | |
| 1425 return DSYNC_SLAVE_RECV_RET_TRYAGAIN; | |
| 1426 } | |
| 1427 if (dsync_deserializer_decode_try(decoder, "received_date", &value) && | |
| 1428 str_to_time(value, &mail->received_date) < 0) { | |
| 1429 dsync_slave_input_error(slave, decoder, "Invalid received_date"); | |
| 1430 return DSYNC_SLAVE_RECV_RET_TRYAGAIN; | |
| 1431 } | |
| 1432 if (dsync_deserializer_decode_try(decoder, "stream", &value)) { | |
| 1433 inputs[0] = i_stream_create_dot(slave->input, FALSE); | |
| 1434 inputs[1] = NULL; | |
| 1435 mail->input = i_stream_create_seekable(inputs, | |
| 1436 MAIL_READ_FULL_BLOCK_SIZE, seekable_fd_callback, slave); | |
| 1437 i_stream_unref(&inputs[0]); | |
| 1438 | |
| 1439 slave->mail_input = mail->input; | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1440 if (dsync_slave_stream_read_mail_stream(slave) <= 0) { |
| 14584 | 1441 slave->cur_mail = mail; |
| 1442 return DSYNC_SLAVE_RECV_RET_TRYAGAIN; | |
| 1443 } | |
| 1444 /* already finished reading the stream */ | |
| 1445 i_assert(slave->mail_input == NULL); | |
| 1446 } | |
| 1447 | |
| 1448 *mail_r = mail; | |
| 1449 return DSYNC_SLAVE_RECV_RET_OK; | |
| 1450 } | |
| 1451 | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1452 static void dsync_slave_stream_flush(struct dsync_slave *_slave) |
| 14584 | 1453 { |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1454 struct dsync_slave_stream *slave = (struct dsync_slave_stream *)_slave; |
| 14584 | 1455 |
| 1456 o_stream_uncork(slave->output); | |
| 1457 o_stream_cork(slave->output); | |
| 1458 } | |
| 1459 | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1460 static bool dsync_slave_stream_is_send_queue_full(struct dsync_slave *_slave) |
| 14584 | 1461 { |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1462 struct dsync_slave_stream *slave = (struct dsync_slave_stream *)_slave; |
| 14584 | 1463 size_t bytes; |
| 1464 | |
| 1465 if (slave->mail_output != NULL) | |
| 1466 return TRUE; | |
| 1467 | |
| 1468 bytes = o_stream_get_buffer_used_size(slave->output); | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1469 if (bytes < DSYNC_SLAVE_STREAM_OUTBUF_THROTTLE_SIZE) |
| 14584 | 1470 return FALSE; |
| 1471 | |
| 1472 o_stream_set_flush_pending(slave->output, TRUE); | |
| 1473 return TRUE; | |
| 1474 } | |
| 1475 | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1476 static bool dsync_slave_stream_has_pending_data(struct dsync_slave *_slave) |
| 14584 | 1477 { |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1478 struct dsync_slave_stream *slave = (struct dsync_slave_stream *)_slave; |
| 14584 | 1479 |
| 1480 return slave->has_pending_data; | |
| 1481 } | |
| 1482 | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1483 static const struct dsync_slave_vfuncs dsync_slave_stream_vfuncs = { |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1484 dsync_slave_stream_deinit, |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1485 dsync_slave_stream_send_handshake, |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1486 dsync_slave_stream_recv_handshake, |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1487 dsync_slave_stream_send_end_of_list, |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1488 dsync_slave_stream_send_mailbox_state, |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1489 dsync_slave_stream_recv_mailbox_state, |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1490 dsync_slave_stream_send_mailbox_tree_node, |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1491 dsync_slave_stream_recv_mailbox_tree_node, |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1492 dsync_slave_stream_send_mailbox_deletes, |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1493 dsync_slave_stream_recv_mailbox_deletes, |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1494 dsync_slave_stream_send_mailbox, |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1495 dsync_slave_stream_recv_mailbox, |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1496 dsync_slave_stream_send_change, |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1497 dsync_slave_stream_recv_change, |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1498 dsync_slave_stream_send_mail_request, |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1499 dsync_slave_stream_recv_mail_request, |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1500 dsync_slave_stream_send_mail, |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1501 dsync_slave_stream_recv_mail, |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1502 dsync_slave_stream_flush, |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1503 dsync_slave_stream_is_send_queue_full, |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1504 dsync_slave_stream_has_pending_data |
| 14584 | 1505 }; |
| 1506 | |
| 1507 struct dsync_slave * | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1508 dsync_slave_init_stream(int fd_in, int fd_out, const char *name, |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1509 const char *temp_path_prefix) |
| 14584 | 1510 { |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1511 struct dsync_slave_stream *slave; |
| 14584 | 1512 |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1513 slave = i_new(struct dsync_slave_stream, 1); |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1514 slave->slave.v = dsync_slave_stream_vfuncs; |
| 14584 | 1515 slave->fd_in = fd_in; |
| 1516 slave->fd_out = fd_out; | |
| 1517 slave->name = i_strdup(name); | |
| 1518 slave->temp_path_prefix = i_strdup(temp_path_prefix); | |
|
15036
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1519 slave->ret_pool = pool_alloconly_create("slave stream data", 2048); |
|
5943cace4e05
dsync: Renamed "io" slave to "stream".
Timo Sirainen <tss@iki.fi>
parents:
15035
diff
changeset
|
1520 dsync_slave_stream_init(slave); |
| 14584 | 1521 return &slave->slave; |
| 1522 } |