static int
imap_master_client_input_line(struct connection *conn, const char *line)
{
char *const *args;
pool_t pool;
int fd_client, ret;
if (!conn->version_received) {
if (connection_verify_version(conn, t_strsplit_tabescaped(line)) < 0)
return -1;
conn->version_received = TRUE;
return 1;
}
fd_client = i_stream_unix_get_read_fd(conn->input);
if (fd_client == -1) {
i_error("imap-master: IMAP client fd not received");
return -1;
}
if (imap_debug)
i_debug("imap-master: Client input: %s", line);
pool = pool_alloconly_create("imap master client cmd", 1024);
args = p_strsplit_tabescaped(pool, line);
ret = imap_master_client_input_args(conn, (void *)args, fd_client, pool);
pool_unref(&pool);
return ret;
}
int dsync_deserializer_decode_begin(struct dsync_deserializer *deserializer,
const char *input,
struct dsync_deserializer_decoder **decoder_r,
const char **error_r)
{
struct dsync_deserializer_decoder *decoder;
unsigned int i;
char **values;
pool_t pool;
*decoder_r = NULL;
pool = pool_alloconly_create("dsync deserializer decode", 1024);
decoder = p_new(pool, struct dsync_deserializer_decoder, 1);
decoder->pool = pool;
decoder->deserializer = deserializer;
values = p_strsplit_tabescaped(pool, input);
/* fix NULLs */
for (i = 0; values[i] != NULL; i++) {
if (values[i][0] == NULL_CHR) {
/* NULL? */
if (values[i][1] == '\0')
values[i] = NULL;
else
values[i] += 1;
}
}
decoder->values_count = i;
/* see if all required fields exist */
for (i = 0; i < deserializer->required_field_count; i++) {
unsigned int ridx = deserializer->required_field_indexes[i];
if (ridx >= decoder->values_count || values[ridx] == NULL) {
*error_r = t_strdup_printf("Missing required field %s",
deserializer->required_fields[i]);
pool_unref(&pool);
return -1;
}
}
decoder->values = (void *)values;
*decoder_r = decoder;
return 0;
}
int dsync_deserializer_init(const char *name, const char *const *required_fields,
const char *header_line,
struct dsync_deserializer **deserializer_r,
const char **error_r)
{
struct dsync_deserializer *deserializer;
const char **dup_required_fields;
unsigned int i, required_count;
pool_t pool;
*deserializer_r = NULL;
pool = pool_alloconly_create("dsync deserializer", 1024);
deserializer = p_new(pool, struct dsync_deserializer, 1);
deserializer->pool = pool;
deserializer->name = p_strdup(pool, name);
deserializer->keys = (void *)p_strsplit_tabescaped(pool, header_line);
deserializer->required_field_count = required_count =
required_fields == NULL ? 0 :
str_array_length(required_fields);
dup_required_fields = p_new(pool, const char *, required_count + 1);
deserializer->required_field_indexes =
p_new(pool, unsigned int, required_count + 1);
for (i = 0; i < required_count; i++) {
dup_required_fields[i] =
p_strdup(pool, required_fields[i]);
if (!field_find(deserializer->keys, required_fields[i],
&deserializer->required_field_indexes[i])) {
*error_r = t_strdup_printf(
"Header missing required field %s",
required_fields[i]);
pool_unref(&pool);
return -1;
}
}
deserializer->required_fields = dup_required_fields;
*deserializer_r = deserializer;
return 0;
}
static int
imap_hibernate_client_input_line(struct connection *conn, const char *line)
{
struct imap_hibernate_client *client =
(struct imap_hibernate_client *)conn;
int fd = -1, ret;
if (!conn->version_received) {
if (connection_verify_version(conn, t_strsplit_tabescaped(line)) < 0)
return -1;
conn->version_received = TRUE;
return 1;
}
if (client->imap_client == NULL) {
char *const *args;
pool_t pool;
fd = i_stream_unix_get_read_fd(conn->input);
if (fd == -1) {
i_error("IMAP client fd not received");
return -1;
}
pool = pool_alloconly_create("client cmd", 1024);
args = p_strsplit_tabescaped(pool, line);
ret = imap_hibernate_client_input_args(conn, (void *)args, fd, pool);
if (ret >= 0 && client->debug)
i_debug("Create client with input: %s", line);
pool_unref(&pool);
} else {
fd = i_stream_unix_get_read_fd(conn->input);
if (fd == -1) {
i_error("IMAP notify fd not received (input: %s)", line);
ret = -1;
} else if (line[0] != '\0') {
i_error("Expected empty notify fd line from client, but got: %s", line);
o_stream_send_str(conn->output,
"Expected empty notify fd line");
ret = -1;
} else {
imap_client_add_notify_fd(client->imap_client, fd);
ret = 1;
}
}
if (ret < 0) {
if (client->imap_client != NULL)
imap_client_destroy(&client->imap_client, NULL);
if (fd != -1)
i_close_fd(&fd);
return -1;
} else if (ret == 0) {
/* still need to read another fd */
i_stream_unix_set_read_fd(conn->input);
o_stream_send_str(conn->output, "+\n");
return 1;
} else {
/* finished - always disconnect the hibernate client
afterwards */
o_stream_send_str(conn->output, "+\n");
imap_client_create_finish(client->imap_client);
return -1;
}
}