commit af4b8896f0c0b8cb3bdc48132bdf4671383bd8e1
parent c3350753b0e3a256ccbd6eeb5924f7089b7a77f1
Author: Oswald Buddenhagen <ossi@users.sf.net>
Date: Sun, 2 Apr 2017 15:42:18 +0200
use typedefs for structs more
makes the code more compact (and consistent, as typedefs were already
used in some places).
Diffstat:
6 files changed, 149 insertions(+), 149 deletions(-)
diff --git a/src/common.h b/src/common.h
@@ -146,11 +146,11 @@ char *expand_strdup( const char *s );
int map_name( const char *arg, char **result, int reserve, const char *in, const char *out );
#define DEFINE_ARRAY_TYPE(T) \
- typedef struct T##_array { \
+ typedef struct { \
T *data; \
int size; \
} ATTR_PACKED(T *) T##_array_t; \
- typedef struct T##_array_alloc { \
+ typedef struct { \
T##_array_t array; \
int alloc; \
} ATTR_PACKED(T *) T##_array_alloc_t; \
diff --git a/src/config.h b/src/config.h
@@ -25,7 +25,7 @@
#include "common.h"
-typedef struct conffile {
+typedef struct {
const char *file;
FILE *fp;
char *buf;
diff --git a/src/drv_imap.c b/src/drv_imap.c
@@ -61,14 +61,14 @@ typedef struct imap_server_conf {
char failed;
} imap_server_conf_t;
-typedef struct imap_store_conf {
+typedef struct {
store_conf_t gen;
imap_server_conf_t *server;
char delimiter;
char use_namespace;
} imap_store_conf_t;
-typedef struct imap_message {
+typedef struct {
message_t gen;
/* int seq; will be needed when expunges are tracked */
} imap_message_t;
@@ -84,17 +84,17 @@ typedef struct _list {
#define MAX_LIST_DEPTH 5
-struct imap_store;
+typedef struct imap_store imap_store_t;
-typedef struct parse_list_state {
+typedef struct {
list_t *head, **stack[MAX_LIST_DEPTH];
- int (*callback)( struct imap_store *ctx, list_t *list, char *cmd );
+ int (*callback)( imap_store_t *ctx, list_t *list, char *cmd );
int level, need_bytes;
} parse_list_state_t;
-struct imap_cmd;
+typedef struct imap_cmd imap_cmd_t;
-typedef struct imap_store {
+struct imap_store {
store_t gen;
const char *label; /* foreign */
const char *prefix;
@@ -112,8 +112,8 @@ typedef struct imap_store {
parse_list_state_t parse_list_sts;
/* command queue */
int nexttag, num_in_progress;
- struct imap_cmd *pending, **pending_append;
- struct imap_cmd *in_progress, **in_progress_append;
+ imap_cmd_t *pending, **pending_append;
+ imap_cmd_t *in_progress, **in_progress_append;
int buffer_mem; /* memory currently occupied by buffers in the queue */
/* Used during sequential operations like connect */
@@ -132,7 +132,7 @@ typedef struct imap_store {
#endif
conn_t conn; /* this is BIG, so put it last */
-} imap_store_t;
+};
struct imap_cmd {
struct imap_cmd *next;
@@ -142,8 +142,8 @@ struct imap_cmd {
struct {
/* Will be called on each continuation request until it resets this pointer.
* Needs to invoke bad_callback and return -1 on error, otherwise return 0. */
- int (*cont)( imap_store_t *ctx, struct imap_cmd *cmd, const char *prompt );
- void (*done)( imap_store_t *ctx, struct imap_cmd *cmd, int response );
+ int (*cont)( imap_store_t *ctx, imap_cmd_t *cmd, const char *prompt );
+ void (*done)( imap_store_t *ctx, imap_cmd_t *cmd, int response );
char *data;
int data_len;
int uid; /* to identify fetch responses */
@@ -154,40 +154,40 @@ struct imap_cmd {
} param;
};
-struct imap_cmd_simple {
- struct imap_cmd gen;
+typedef struct {
+ imap_cmd_t gen;
void (*callback)( int sts, void *aux );
void *callback_aux;
-};
+} imap_cmd_simple_t;
-struct imap_cmd_fetch_msg {
- struct imap_cmd_simple gen;
+typedef struct {
+ imap_cmd_simple_t gen;
msg_data_t *msg_data;
-};
+} imap_cmd_fetch_msg_t;
-struct imap_cmd_out_uid {
- struct imap_cmd gen;
+typedef struct {
+ imap_cmd_t gen;
void (*callback)( int sts, int uid, void *aux );
void *callback_aux;
int out_uid;
-};
+} imap_cmd_out_uid_t;
-struct imap_cmd_find_new {
- struct imap_cmd_simple gen;
+typedef struct {
+ imap_cmd_simple_t gen;
int uid;
-};
+} imap_cmd_find_new_t;
-struct imap_cmd_refcounted_state {
+typedef struct {
void (*callback)( int sts, void *aux );
void *callback_aux;
int ref_count;
int ret_val;
-};
+} imap_cmd_refcounted_state_t;
-struct imap_cmd_refcounted {
- struct imap_cmd gen;
- struct imap_cmd_refcounted_state *state;
-};
+typedef struct {
+ imap_cmd_t gen;
+ imap_cmd_refcounted_state_t *state;
+} imap_cmd_refcounted_t;
#define CAP(cap) (ctx->caps & (1 << (cap)))
@@ -238,26 +238,26 @@ static const char *Flags[] = {
"Deleted",
};
-static struct imap_cmd *
+static imap_cmd_t *
new_imap_cmd( int size )
{
- struct imap_cmd *cmd = nfmalloc( size );
+ imap_cmd_t *cmd = nfmalloc( size );
memset( &cmd->param, 0, sizeof(cmd->param) );
return cmd;
}
#define INIT_IMAP_CMD(type, cmdp, cb, aux) \
- cmdp = (struct type *)new_imap_cmd( sizeof(*cmdp) ); \
+ cmdp = (type *)new_imap_cmd( sizeof(*cmdp) ); \
cmdp->callback = cb; \
cmdp->callback_aux = aux;
#define INIT_IMAP_CMD_X(type, cmdp, cb, aux) \
- cmdp = (struct type *)new_imap_cmd( sizeof(*cmdp) ); \
+ cmdp = (type *)new_imap_cmd( sizeof(*cmdp) ); \
cmdp->gen.callback = cb; \
cmdp->gen.callback_aux = aux;
static void
-done_imap_cmd( imap_store_t *ctx, struct imap_cmd *cmd, int response )
+done_imap_cmd( imap_store_t *ctx, imap_cmd_t *cmd, int response )
{
cmd->param.done( ctx, cmd, response );
if (cmd->param.data) {
@@ -269,7 +269,7 @@ done_imap_cmd( imap_store_t *ctx, struct imap_cmd *cmd, int response )
}
static void
-send_imap_cmd( imap_store_t *ctx, struct imap_cmd *cmd )
+send_imap_cmd( imap_store_t *ctx, imap_cmd_t *cmd )
{
int bufl, litplus, iovcnt = 1;
const char *buffmt;
@@ -331,14 +331,14 @@ send_imap_cmd( imap_store_t *ctx, struct imap_cmd *cmd )
}
static int
-cmd_sendable( imap_store_t *ctx, struct imap_cmd *cmd )
+cmd_sendable( imap_store_t *ctx, imap_cmd_t *cmd )
{
- struct imap_cmd *cmdp;
+ imap_cmd_t *cmdp;
return !ctx->conn.write_buf &&
!(ctx->in_progress &&
- (cmdp = (struct imap_cmd *)((char *)ctx->in_progress_append -
- offsetof(struct imap_cmd, next)), 1) &&
+ (cmdp = (imap_cmd_t *)((char *)ctx->in_progress_append -
+ offsetof(imap_cmd_t, next)), 1) &&
(cmdp->param.cont || cmdp->param.data)) &&
!(cmd->param.to_trash && ctx->trashnc == TrashChecking) &&
ctx->num_in_progress < ((imap_store_conf_t *)ctx->gen.conf)->server->max_in_progress;
@@ -347,7 +347,7 @@ cmd_sendable( imap_store_t *ctx, struct imap_cmd *cmd )
static void
flush_imap_cmds( imap_store_t *ctx )
{
- struct imap_cmd *cmd;
+ imap_cmd_t *cmd;
if ((cmd = ctx->pending) && cmd_sendable( ctx, cmd )) {
if (!(ctx->pending = cmd->next))
@@ -359,7 +359,7 @@ flush_imap_cmds( imap_store_t *ctx )
static void
cancel_pending_imap_cmds( imap_store_t *ctx )
{
- struct imap_cmd *cmd;
+ imap_cmd_t *cmd;
while ((cmd = ctx->pending)) {
if (!(ctx->pending = cmd->next))
@@ -371,7 +371,7 @@ cancel_pending_imap_cmds( imap_store_t *ctx )
static void
cancel_sent_imap_cmds( imap_store_t *ctx )
{
- struct imap_cmd *cmd;
+ imap_cmd_t *cmd;
socket_expect_read( &ctx->conn, 0 );
while ((cmd = ctx->in_progress)) {
@@ -382,7 +382,7 @@ cancel_sent_imap_cmds( imap_store_t *ctx )
}
static void
-submit_imap_cmd( imap_store_t *ctx, struct imap_cmd *cmd )
+submit_imap_cmd( imap_store_t *ctx, imap_cmd_t *cmd )
{
assert( ctx );
assert( ctx->gen.bad_callback );
@@ -480,8 +480,8 @@ imap_vprintf( const char *fmt, va_list ap )
}
static void
-imap_exec( imap_store_t *ctx, struct imap_cmd *cmdp,
- void (*done)( imap_store_t *ctx, struct imap_cmd *cmd, int response ),
+imap_exec( imap_store_t *ctx, imap_cmd_t *cmdp,
+ void (*done)( imap_store_t *ctx, imap_cmd_t *cmd, int response ),
const char *fmt, ... )
{
va_list ap;
@@ -507,9 +507,9 @@ transform_box_response( int *response )
static void
imap_done_simple_box( imap_store_t *ctx ATTR_UNUSED,
- struct imap_cmd *cmd, int response )
+ imap_cmd_t *cmd, int response )
{
- struct imap_cmd_simple *cmdp = (struct imap_cmd_simple *)cmd;
+ imap_cmd_simple_t *cmdp = (imap_cmd_simple_t *)cmd;
transform_box_response( &response );
cmdp->callback( response, cmdp->callback_aux );
@@ -527,18 +527,18 @@ transform_msg_response( int *response )
static void
imap_done_simple_msg( imap_store_t *ctx ATTR_UNUSED,
- struct imap_cmd *cmd, int response )
+ imap_cmd_t *cmd, int response )
{
- struct imap_cmd_simple *cmdp = (struct imap_cmd_simple *)cmd;
+ imap_cmd_simple_t *cmdp = (imap_cmd_simple_t *)cmd;
transform_msg_response( &response );
cmdp->callback( response, cmdp->callback_aux );
}
-static struct imap_cmd_refcounted_state *
+static imap_cmd_refcounted_state_t *
imap_refcounted_new_state( void (*cb)( int, void * ), void *aux )
{
- struct imap_cmd_refcounted_state *sts = nfmalloc( sizeof(*sts) );
+ imap_cmd_refcounted_state_t *sts = nfmalloc( sizeof(*sts) );
sts->callback = cb;
sts->callback_aux = aux;
sts->ref_count = 1; /* so forced sync does not cause an early exit */
@@ -546,17 +546,17 @@ imap_refcounted_new_state( void (*cb)( int, void * ), void *aux )
return sts;
}
-static struct imap_cmd *
-imap_refcounted_new_cmd( struct imap_cmd_refcounted_state *sts )
+static imap_cmd_t *
+imap_refcounted_new_cmd( imap_cmd_refcounted_state_t *sts )
{
- struct imap_cmd_refcounted *cmd = (struct imap_cmd_refcounted *)new_imap_cmd( sizeof(*cmd) );
+ imap_cmd_refcounted_t *cmd = (imap_cmd_refcounted_t *)new_imap_cmd( sizeof(*cmd) );
cmd->state = sts;
sts->ref_count++;
return &cmd->gen;
}
static void
-imap_refcounted_done( struct imap_cmd_refcounted_state *sts )
+imap_refcounted_done( imap_cmd_refcounted_state_t *sts )
{
if (!--sts->ref_count) {
sts->callback( sts->ret_val, sts->callback_aux );
@@ -565,9 +565,9 @@ imap_refcounted_done( struct imap_cmd_refcounted_state *sts )
}
static void
-imap_refcounted_done_box( imap_store_t *ctx ATTR_UNUSED, struct imap_cmd *cmd, int response )
+imap_refcounted_done_box( imap_store_t *ctx ATTR_UNUSED, imap_cmd_t *cmd, int response )
{
- struct imap_cmd_refcounted_state *sts = ((struct imap_cmd_refcounted *)cmd)->state;
+ imap_cmd_refcounted_state_t *sts = ((imap_cmd_refcounted_t *)cmd)->state;
switch (response) {
case RESP_CANCEL:
@@ -914,7 +914,7 @@ parse_fetch_rsp( imap_store_t *ctx, list_t *list, char *s ATTR_UNUSED )
char *body = 0, *tuid = 0, *msgid = 0;
imap_message_t *cur;
msg_data_t *msgdata;
- struct imap_cmd *cmdp;
+ imap_cmd_t *cmdp;
int uid = 0, mask = 0, status = 0, size = 0;
uint i;
time_t date = 0;
@@ -1041,7 +1041,7 @@ parse_fetch_rsp( imap_store_t *ctx, list_t *list, char *s ATTR_UNUSED )
free_list( list );
return LIST_BAD;
gotuid:
- msgdata = ((struct imap_cmd_fetch_msg *)cmdp)->msg_data;
+ msgdata = ((imap_cmd_fetch_msg_t *)cmdp)->msg_data;
msgdata->data = body;
msgdata->len = size;
msgdata->date = date;
@@ -1095,7 +1095,7 @@ parse_capability( imap_store_t *ctx, char *cmd )
}
static int
-parse_response_code( imap_store_t *ctx, struct imap_cmd *cmd, char *s )
+parse_response_code( imap_store_t *ctx, imap_cmd_t *cmd, char *s )
{
char *arg, *earg, *p;
@@ -1134,7 +1134,7 @@ parse_response_code( imap_store_t *ctx, struct imap_cmd *cmd, char *s )
if (!(arg = next_arg( &s )) ||
(ctx->gen.uidvalidity = strtoll( arg, &earg, 10 ), *earg) ||
!(arg = next_arg( &s )) ||
- !(((struct imap_cmd_out_uid *)cmd)->out_uid = atoi( arg )))
+ !(((imap_cmd_out_uid_t *)cmd)->out_uid = atoi( arg )))
{
error( "IMAP error: malformed APPENDUID status\n" );
return RESP_CANCEL;
@@ -1253,19 +1253,19 @@ prepare_trash( char **buf, const imap_store_t *ctx )
return prepare_name( buf, ctx, ctx->prefix, ctx->gen.conf->trash );
}
-struct imap_cmd_trycreate {
- struct imap_cmd gen;
- struct imap_cmd *orig_cmd;
-};
+typedef struct {
+ imap_cmd_t gen;
+ imap_cmd_t *orig_cmd;
+} imap_cmd_trycreate_t;
static void imap_open_store_greeted( imap_store_t * );
-static void get_cmd_result_p2( imap_store_t *, struct imap_cmd *, int );
+static void get_cmd_result_p2( imap_store_t *, imap_cmd_t *, int );
static void
imap_socket_read( void *aux )
{
imap_store_t *ctx = (imap_store_t *)aux;
- struct imap_cmd *cmdp, **pcmdp;
+ imap_cmd_t *cmdp, **pcmdp;
char *cmd, *arg, *arg1, *p;
int resp, resp2, tag;
conn_iovec_t iov[2];
@@ -1364,8 +1364,8 @@ imap_socket_read( void *aux )
socket_expect_read( &ctx->conn, 0 );
/* There can be any number of commands in flight, but only the last
* one can require a continuation, as it enforces a round-trip. */
- cmdp = (struct imap_cmd *)((char *)ctx->in_progress_append -
- offsetof(struct imap_cmd, next));
+ cmdp = (imap_cmd_t *)((char *)ctx->in_progress_append -
+ offsetof(imap_cmd_t, next));
if (cmdp->param.data) {
if (cmdp->param.to_trash)
ctx->trashnc = TrashKnown; /* Can't get NO [TRYCREATE] any more. */
@@ -1416,8 +1416,8 @@ imap_socket_read( void *aux )
} else {
if (!strcmp( "NO", arg )) {
if (cmdp->param.create && cmd && starts_with( cmd, -1, "[TRYCREATE]", 11 )) { /* APPEND or UID COPY */
- struct imap_cmd_trycreate *cmd2 =
- (struct imap_cmd_trycreate *)new_imap_cmd( sizeof(*cmd2) );
+ imap_cmd_trycreate_t *cmd2 =
+ (imap_cmd_trycreate_t *)new_imap_cmd( sizeof(*cmd2) );
cmd2->orig_cmd = cmdp;
cmd2->gen.param.high_prio = 1;
p = strchr( cmdp->cmd, '"' );
@@ -1459,10 +1459,10 @@ imap_socket_read( void *aux )
}
static void
-get_cmd_result_p2( imap_store_t *ctx, struct imap_cmd *cmd, int response )
+get_cmd_result_p2( imap_store_t *ctx, imap_cmd_t *cmd, int response )
{
- struct imap_cmd_trycreate *cmdp = (struct imap_cmd_trycreate *)cmd;
- struct imap_cmd *ocmd = cmdp->orig_cmd;
+ imap_cmd_trycreate_t *cmdp = (imap_cmd_trycreate_t *)cmd;
+ imap_cmd_t *ocmd = cmdp->orig_cmd;
if (response != RESP_OK) {
done_imap_cmd( ctx, ocmd, response );
@@ -1550,7 +1550,7 @@ imap_free_store( store_t *gctx )
/******************* imap_cleanup *******************/
-static void imap_cleanup_p2( imap_store_t *, struct imap_cmd *, int );
+static void imap_cleanup_p2( imap_store_t *, imap_cmd_t *, int );
static void
imap_cleanup( void )
@@ -1571,7 +1571,7 @@ imap_cleanup( void )
static void
imap_cleanup_p2( imap_store_t *ctx,
- struct imap_cmd *cmd ATTR_UNUSED, int response )
+ imap_cmd_t *cmd ATTR_UNUSED, int response )
{
if (response == RESP_NO)
imap_cancel_store( &ctx->gen );
@@ -1585,21 +1585,21 @@ static void imap_open_store_connected( int, void * );
#ifdef HAVE_LIBSSL
static void imap_open_store_tlsstarted1( int, void * );
#endif
-static void imap_open_store_p2( imap_store_t *, struct imap_cmd *, int );
+static void imap_open_store_p2( imap_store_t *, imap_cmd_t *, int );
static void imap_open_store_authenticate( imap_store_t * );
#ifdef HAVE_LIBSSL
-static void imap_open_store_authenticate_p2( imap_store_t *, struct imap_cmd *, int );
+static void imap_open_store_authenticate_p2( imap_store_t *, imap_cmd_t *, int );
static void imap_open_store_tlsstarted2( int, void * );
-static void imap_open_store_authenticate_p3( imap_store_t *, struct imap_cmd *, int );
+static void imap_open_store_authenticate_p3( imap_store_t *, imap_cmd_t *, int );
#endif
static void imap_open_store_authenticate2( imap_store_t * );
-static void imap_open_store_authenticate2_p2( imap_store_t *, struct imap_cmd *, int );
+static void imap_open_store_authenticate2_p2( imap_store_t *, imap_cmd_t *, int );
static void imap_open_store_compress( imap_store_t * );
#ifdef HAVE_LIBZ
-static void imap_open_store_compress_p2( imap_store_t *, struct imap_cmd *, int );
+static void imap_open_store_compress_p2( imap_store_t *, imap_cmd_t *, int );
#endif
static void imap_open_store_namespace( imap_store_t * );
-static void imap_open_store_namespace_p2( imap_store_t *, struct imap_cmd *, int );
+static void imap_open_store_namespace_p2( imap_store_t *, imap_cmd_t *, int );
static void imap_open_store_namespace2( imap_store_t * );
static void imap_open_store_finalize( imap_store_t * );
#ifdef HAVE_LIBSSL
@@ -1710,7 +1710,7 @@ imap_open_store_greeted( imap_store_t *ctx )
}
static void
-imap_open_store_p2( imap_store_t *ctx, struct imap_cmd *cmd ATTR_UNUSED, int response )
+imap_open_store_p2( imap_store_t *ctx, imap_cmd_t *cmd ATTR_UNUSED, int response )
{
if (response == RESP_NO)
imap_open_store_bail( ctx, FAIL_FINAL );
@@ -1754,7 +1754,7 @@ imap_open_store_authenticate( imap_store_t *ctx )
#ifdef HAVE_LIBSSL
static void
-imap_open_store_authenticate_p2( imap_store_t *ctx, struct imap_cmd *cmd ATTR_UNUSED, int response )
+imap_open_store_authenticate_p2( imap_store_t *ctx, imap_cmd_t *cmd ATTR_UNUSED, int response )
{
if (response == RESP_NO)
imap_open_store_bail( ctx, FAIL_FINAL );
@@ -1774,7 +1774,7 @@ imap_open_store_tlsstarted2( int ok, void *aux )
}
static void
-imap_open_store_authenticate_p3( imap_store_t *ctx, struct imap_cmd *cmd ATTR_UNUSED, int response )
+imap_open_store_authenticate_p3( imap_store_t *ctx, imap_cmd_t *cmd ATTR_UNUSED, int response )
{
if (response == RESP_NO)
imap_open_store_bail( ctx, FAIL_FINAL );
@@ -1945,7 +1945,7 @@ encode_sasl_data( const char *out, uint out_len, char **enc, uint *enc_len )
}
static int
-do_sasl_auth( imap_store_t *ctx, struct imap_cmd *cmdp ATTR_UNUSED, const char *prompt )
+do_sasl_auth( imap_store_t *ctx, imap_cmd_t *cmdp ATTR_UNUSED, const char *prompt )
{
int rc, ret, iovcnt = 0;
uint in_len, out_len, enc_len;
@@ -1998,7 +1998,7 @@ do_sasl_auth( imap_store_t *ctx, struct imap_cmd *cmdp ATTR_UNUSED, const char *
}
static void
-done_sasl_auth( imap_store_t *ctx, struct imap_cmd *cmd ATTR_UNUSED, int response )
+done_sasl_auth( imap_store_t *ctx, imap_cmd_t *cmd ATTR_UNUSED, int response )
{
if (response == RESP_OK && ctx->sasl_cont) {
sasl_interact_t *interact = NULL;
@@ -2063,7 +2063,7 @@ imap_open_store_authenticate2( imap_store_t *ctx )
char *enc = NULL;
const char *gotmech = NULL, *out = NULL;
sasl_interact_t *interact = NULL;
- struct imap_cmd *cmd;
+ imap_cmd_t *cmd;
static int sasl_inited;
if (!sasl_inited) {
@@ -2143,7 +2143,7 @@ imap_open_store_authenticate2( imap_store_t *ctx )
}
static void
-imap_open_store_authenticate2_p2( imap_store_t *ctx, struct imap_cmd *cmd ATTR_UNUSED, int response )
+imap_open_store_authenticate2_p2( imap_store_t *ctx, imap_cmd_t *cmd ATTR_UNUSED, int response )
{
if (response == RESP_NO)
imap_open_store_bail( ctx, FAIL_FINAL );
@@ -2165,7 +2165,7 @@ imap_open_store_compress( imap_store_t *ctx )
#ifdef HAVE_LIBZ
static void
-imap_open_store_compress_p2( imap_store_t *ctx, struct imap_cmd *cmd ATTR_UNUSED, int response )
+imap_open_store_compress_p2( imap_store_t *ctx, imap_cmd_t *cmd ATTR_UNUSED, int response )
{
if (response == RESP_NO) {
/* We already reported an error, but it's not fatal to us. */
@@ -2197,7 +2197,7 @@ imap_open_store_namespace( imap_store_t *ctx )
}
static void
-imap_open_store_namespace_p2( imap_store_t *ctx, struct imap_cmd *cmd ATTR_UNUSED, int response )
+imap_open_store_namespace_p2( imap_store_t *ctx, imap_cmd_t *cmd ATTR_UNUSED, int response )
{
if (response == RESP_NO) {
imap_open_store_bail( ctx, FAIL_FINAL );
@@ -2274,7 +2274,7 @@ imap_open_box( store_t *gctx,
void (*cb)( int sts, void *aux ), void *aux )
{
imap_store_t *ctx = (imap_store_t *)gctx;
- struct imap_cmd_simple *cmd;
+ imap_cmd_simple_t *cmd;
char *buf;
if (prepare_box( &buf, ctx ) < 0) {
@@ -2284,7 +2284,7 @@ imap_open_box( store_t *gctx,
ctx->gen.uidnext = 0;
- INIT_IMAP_CMD(imap_cmd_simple, cmd, cb, aux)
+ INIT_IMAP_CMD(imap_cmd_simple_t, cmd, cb, aux)
cmd->gen.param.failok = 1;
imap_exec( ctx, &cmd->gen, imap_done_simple_box,
"SELECT \"%\\s\"", buf );
@@ -2298,7 +2298,7 @@ imap_create_box( store_t *gctx,
void (*cb)( int sts, void *aux ), void *aux )
{
imap_store_t *ctx = (imap_store_t *)gctx;
- struct imap_cmd_simple *cmd;
+ imap_cmd_simple_t *cmd;
char *buf;
if (prepare_box( &buf, ctx ) < 0) {
@@ -2306,7 +2306,7 @@ imap_create_box( store_t *gctx,
return;
}
- INIT_IMAP_CMD(imap_cmd_simple, cmd, cb, aux)
+ INIT_IMAP_CMD(imap_cmd_simple_t, cmd, cb, aux)
imap_exec( ctx, &cmd->gen, imap_done_simple_box,
"CREATE \"%\\s\"", buf );
free( buf );
@@ -2320,24 +2320,24 @@ imap_confirm_box_empty( store_t *gctx )
return gctx->count ? DRV_BOX_BAD : DRV_OK;
}
-static void imap_delete_box_p2( imap_store_t *, struct imap_cmd *, int );
+static void imap_delete_box_p2( imap_store_t *, imap_cmd_t *, int );
static void
imap_delete_box( store_t *gctx,
void (*cb)( int sts, void *aux ), void *aux )
{
imap_store_t *ctx = (imap_store_t *)gctx;
- struct imap_cmd_simple *cmd;
+ imap_cmd_simple_t *cmd;
- INIT_IMAP_CMD(imap_cmd_simple, cmd, cb, aux)
+ INIT_IMAP_CMD(imap_cmd_simple_t, cmd, cb, aux)
imap_exec( ctx, &cmd->gen, imap_delete_box_p2, "CLOSE" );
}
static void
-imap_delete_box_p2( imap_store_t *ctx, struct imap_cmd *gcmd, int response )
+imap_delete_box_p2( imap_store_t *ctx, imap_cmd_t *gcmd, int response )
{
- struct imap_cmd_simple *cmdp = (struct imap_cmd_simple *)gcmd;
- struct imap_cmd_simple *cmd;
+ imap_cmd_simple_t *cmdp = (imap_cmd_simple_t *)gcmd;
+ imap_cmd_simple_t *cmd;
char *buf;
if (response != RESP_OK) {
@@ -2349,7 +2349,7 @@ imap_delete_box_p2( imap_store_t *ctx, struct imap_cmd *gcmd, int response )
imap_done_simple_box( ctx, &cmdp->gen, RESP_NO );
return;
}
- INIT_IMAP_CMD(imap_cmd_simple, cmd, cmdp->callback, cmdp->callback_aux)
+ INIT_IMAP_CMD(imap_cmd_simple_t, cmd, cmdp->callback, cmdp->callback_aux)
imap_exec( ctx, &cmd->gen, imap_done_simple_box,
"DELETE \"%\\s\"", buf );
free( buf );
@@ -2370,7 +2370,7 @@ imap_prepare_load_box( store_t *gctx, int opts )
}
enum { WantSize = 1, WantTuids = 2, WantMsgids = 4 };
-typedef struct imap_range {
+typedef struct {
int first, last, flags;
} imap_range_t;
@@ -2396,7 +2396,7 @@ imap_set_range( imap_range_t *ranges, int *nranges, int low_flags, int high_flag
ranges[r].flags |= (ranges[r].last <= maxlow) ? low_flags : high_flags;
}
-static void imap_submit_load( imap_store_t *, const char *, int, struct imap_cmd_refcounted_state * );
+static void imap_submit_load( imap_store_t *, const char *, int, imap_cmd_refcounted_state_t * );
static void
imap_load_box( store_t *gctx, int minuid, int maxuid, int newuid, int seenuid, int_array_t excs,
@@ -2410,7 +2410,7 @@ imap_load_box( store_t *gctx, int minuid, int maxuid, int newuid, int seenuid, i
free( excs.data );
cb( DRV_OK, aux );
} else {
- struct imap_cmd_refcounted_state *sts = imap_refcounted_new_state( cb, aux );
+ imap_cmd_refcounted_state_t *sts = imap_refcounted_new_state( cb, aux );
for (i = 0; i < excs.size; ) {
for (bl = 0; i < excs.size && bl < 960; i++) {
@@ -2450,7 +2450,7 @@ imap_load_box( store_t *gctx, int minuid, int maxuid, int newuid, int seenuid, i
}
static void
-imap_submit_load( imap_store_t *ctx, const char *buf, int flags, struct imap_cmd_refcounted_state *sts )
+imap_submit_load( imap_store_t *ctx, const char *buf, int flags, imap_cmd_refcounted_state_t *sts )
{
imap_exec( ctx, imap_refcounted_new_cmd( sts ), imap_refcounted_done_box,
"UID FETCH %s (UID%s%s%s%s%s%s%s)", buf,
@@ -2465,15 +2465,15 @@ imap_submit_load( imap_store_t *ctx, const char *buf, int flags, struct imap_cmd
/******************* imap_fetch_msg *******************/
-static void imap_fetch_msg_p2( imap_store_t *ctx, struct imap_cmd *gcmd, int response );
+static void imap_fetch_msg_p2( imap_store_t *, imap_cmd_t *, int );
static void
imap_fetch_msg( store_t *ctx, message_t *msg, msg_data_t *data,
void (*cb)( int sts, void *aux ), void *aux )
{
- struct imap_cmd_fetch_msg *cmd;
+ imap_cmd_fetch_msg_t *cmd;
- INIT_IMAP_CMD_X(imap_cmd_fetch_msg, cmd, cb, aux)
+ INIT_IMAP_CMD_X(imap_cmd_fetch_msg_t, cmd, cb, aux)
cmd->gen.gen.param.uid = msg->uid;
cmd->msg_data = data;
data->data = 0;
@@ -2484,9 +2484,9 @@ imap_fetch_msg( store_t *ctx, message_t *msg, msg_data_t *data,
}
static void
-imap_fetch_msg_p2( imap_store_t *ctx, struct imap_cmd *gcmd, int response )
+imap_fetch_msg_p2( imap_store_t *ctx, imap_cmd_t *gcmd, int response )
{
- struct imap_cmd_fetch_msg *cmd = (struct imap_cmd_fetch_msg *)gcmd;
+ imap_cmd_fetch_msg_t *cmd = (imap_cmd_fetch_msg_t *)gcmd;
if (response == RESP_OK && !cmd->msg_data->data) {
/* The FETCH succeeded, but there is no message with this UID. */
@@ -2497,7 +2497,7 @@ imap_fetch_msg_p2( imap_store_t *ctx, struct imap_cmd *gcmd, int response )
/******************* imap_set_msg_flags *******************/
-static void imap_set_flags_p2( imap_store_t *, struct imap_cmd *, int );
+static void imap_set_flags_p2( imap_store_t *, imap_cmd_t *, int );
static int
imap_make_flags( int flags, char *buf )
@@ -2519,7 +2519,7 @@ imap_make_flags( int flags, char *buf )
static void
imap_flags_helper( imap_store_t *ctx, int uid, char what, int flags,
- struct imap_cmd_refcounted_state *sts )
+ imap_cmd_refcounted_state_t *sts )
{
char buf[256];
@@ -2542,7 +2542,7 @@ imap_set_msg_flags( store_t *gctx, message_t *msg, int uid, int add, int del,
msg->flags &= ~del;
}
if (add || del) {
- struct imap_cmd_refcounted_state *sts = imap_refcounted_new_state( cb, aux );
+ imap_cmd_refcounted_state_t *sts = imap_refcounted_new_state( cb, aux );
if (add)
imap_flags_helper( ctx, uid, '+', add, sts );
if (del)
@@ -2554,9 +2554,9 @@ imap_set_msg_flags( store_t *gctx, message_t *msg, int uid, int add, int del,
}
static void
-imap_set_flags_p2( imap_store_t *ctx ATTR_UNUSED, struct imap_cmd *cmd, int response )
+imap_set_flags_p2( imap_store_t *ctx ATTR_UNUSED, imap_cmd_t *cmd, int response )
{
- struct imap_cmd_refcounted_state *sts = ((struct imap_cmd_refcounted *)cmd)->state;
+ imap_cmd_refcounted_state_t *sts = ((imap_cmd_refcounted_t *)cmd)->state;
switch (response) {
case RESP_CANCEL:
sts->ret_val = DRV_CANCELED;
@@ -2578,7 +2578,7 @@ imap_close_box( store_t *gctx,
imap_store_t *ctx = (imap_store_t *)gctx;
if (ctx->gen.conf->trash && CAP(UIDPLUS)) {
- struct imap_cmd_refcounted_state *sts = imap_refcounted_new_state( cb, aux );
+ imap_cmd_refcounted_state_t *sts = imap_refcounted_new_state( cb, aux );
message_t *msg, *fmsg, *nmsg;
int bl;
char buf[1000];
@@ -2604,8 +2604,8 @@ imap_close_box( store_t *gctx,
} else {
/* This is inherently racy: it may cause messages which other clients
* marked as deleted to be expunged without being trashed. */
- struct imap_cmd_simple *cmd;
- INIT_IMAP_CMD(imap_cmd_simple, cmd, cb, aux)
+ imap_cmd_simple_t *cmd;
+ INIT_IMAP_CMD(imap_cmd_simple_t, cmd, cb, aux)
imap_exec( ctx, &cmd->gen, imap_done_simple_box, "CLOSE" );
}
}
@@ -2617,10 +2617,10 @@ imap_trash_msg( store_t *gctx, message_t *msg,
void (*cb)( int sts, void *aux ), void *aux )
{
imap_store_t *ctx = (imap_store_t *)gctx;
- struct imap_cmd_simple *cmd;
+ imap_cmd_simple_t *cmd;
char *buf;
- INIT_IMAP_CMD(imap_cmd_simple, cmd, cb, aux)
+ INIT_IMAP_CMD(imap_cmd_simple_t, cmd, cb, aux)
cmd->gen.param.create = 1;
cmd->gen.param.to_trash = 1;
if (prepare_trash( &buf, ctx ) < 0) {
@@ -2634,7 +2634,7 @@ imap_trash_msg( store_t *gctx, message_t *msg,
/******************* imap_store_msg *******************/
-static void imap_store_msg_p2( imap_store_t *, struct imap_cmd *, int );
+static void imap_store_msg_p2( imap_store_t *, imap_cmd_t *, int );
static size_t
my_strftime( char *s, size_t max, const char *fmt, const struct tm *tm )
@@ -2647,7 +2647,7 @@ imap_store_msg( store_t *gctx, msg_data_t *data, int to_trash,
void (*cb)( int sts, int uid, void *aux ), void *aux )
{
imap_store_t *ctx = (imap_store_t *)gctx;
- struct imap_cmd_out_uid *cmd;
+ imap_cmd_out_uid_t *cmd;
char *buf;
int d;
char flagstr[128], datestr[64];
@@ -2659,7 +2659,7 @@ imap_store_msg( store_t *gctx, msg_data_t *data, int to_trash,
}
flagstr[d] = 0;
- INIT_IMAP_CMD(imap_cmd_out_uid, cmd, cb, aux)
+ INIT_IMAP_CMD(imap_cmd_out_uid_t, cmd, cb, aux)
ctx->buffer_mem += data->len;
cmd->gen.param.data_len = data->len;
cmd->gen.param.data = data->data;
@@ -2691,9 +2691,9 @@ imap_store_msg( store_t *gctx, msg_data_t *data, int to_trash,
}
static void
-imap_store_msg_p2( imap_store_t *ctx ATTR_UNUSED, struct imap_cmd *cmd, int response )
+imap_store_msg_p2( imap_store_t *ctx ATTR_UNUSED, imap_cmd_t *cmd, int response )
{
- struct imap_cmd_out_uid *cmdp = (struct imap_cmd_out_uid *)cmd;
+ imap_cmd_out_uid_t *cmdp = (imap_cmd_out_uid_t *)cmd;
transform_msg_response( &response );
cmdp->callback( response, cmdp->out_uid, cmdp->callback_aux );
@@ -2701,31 +2701,31 @@ imap_store_msg_p2( imap_store_t *ctx ATTR_UNUSED, struct imap_cmd *cmd, int resp
/******************* imap_find_new_msgs *******************/
-static void imap_find_new_msgs_p2( imap_store_t *, struct imap_cmd *, int );
+static void imap_find_new_msgs_p2( imap_store_t *, imap_cmd_t *, int );
static void
imap_find_new_msgs( store_t *gctx, int newuid,
void (*cb)( int sts, void *aux ), void *aux )
{
imap_store_t *ctx = (imap_store_t *)gctx;
- struct imap_cmd_find_new *cmd;
+ imap_cmd_find_new_t *cmd;
- INIT_IMAP_CMD_X(imap_cmd_find_new, cmd, cb, aux)
+ INIT_IMAP_CMD_X(imap_cmd_find_new_t, cmd, cb, aux)
cmd->uid = newuid;
imap_exec( (imap_store_t *)ctx, &cmd->gen.gen, imap_find_new_msgs_p2, "CHECK" );
}
static void
-imap_find_new_msgs_p2( imap_store_t *ctx, struct imap_cmd *gcmd, int response )
+imap_find_new_msgs_p2( imap_store_t *ctx, imap_cmd_t *gcmd, int response )
{
- struct imap_cmd_find_new *cmdp = (struct imap_cmd_find_new *)gcmd;
- struct imap_cmd_simple *cmd;
+ imap_cmd_find_new_t *cmdp = (imap_cmd_find_new_t *)gcmd;
+ imap_cmd_simple_t *cmd;
if (response != RESP_OK) {
imap_done_simple_box( ctx, gcmd, response );
return;
}
- INIT_IMAP_CMD(imap_cmd_simple, cmd, cmdp->gen.callback, cmdp->gen.callback_aux)
+ INIT_IMAP_CMD(imap_cmd_simple_t, cmd, cmdp->gen.callback, cmdp->gen.callback_aux)
imap_exec( (imap_store_t *)ctx, &cmd->gen, imap_done_simple_box,
"UID FETCH %d:" stringify(INT_MAX) " (UID BODY.PEEK[HEADER.FIELDS (X-TUID)])", cmdp->uid );
}
@@ -2737,7 +2737,7 @@ imap_list_store( store_t *gctx, int flags,
void (*cb)( int sts, void *aux ), void *aux )
{
imap_store_t *ctx = (imap_store_t *)gctx;
- struct imap_cmd_refcounted_state *sts = imap_refcounted_new_state( cb, aux );
+ imap_cmd_refcounted_state_t *sts = imap_refcounted_new_state( cb, aux );
if ((flags & (LIST_PATH | LIST_PATH_MAYBE)) && (!(flags & LIST_INBOX) || !is_inbox( ctx, ctx->prefix, -1 )))
imap_exec( ctx, imap_refcounted_new_cmd( sts ), imap_refcounted_done_box,
diff --git a/src/drv_maildir.c b/src/drv_maildir.c
@@ -50,7 +50,7 @@
#define SUB_MAILDIRPP 2
#define SUB_LEGACY 3
-typedef struct maildir_store_conf {
+typedef struct {
store_conf_t gen;
char *inbox;
#ifdef USE_DB
@@ -62,12 +62,12 @@ typedef struct maildir_store_conf {
char *info_prefix, *info_stop; /* precalculated from info_delimiter */
} maildir_store_conf_t;
-typedef struct maildir_message {
+typedef struct {
message_t gen;
char *base;
} maildir_message_t;
-typedef struct maildir_store {
+typedef struct {
store_t gen;
int uvfd, uvok, nuid, is_inbox, fresh[3];
int minuid, maxuid, newuid, seenuid;
diff --git a/src/socket.h b/src/socket.h
@@ -43,7 +43,7 @@ enum {
};
#endif
-typedef struct server_conf {
+typedef struct {
char *tunnel;
char *host;
int port;
@@ -147,7 +147,7 @@ void socket_expect_read( conn_t *sock, int expect );
int socket_read( conn_t *sock, char *buf, int len ); /* never waits */
char *socket_read_line( conn_t *sock ); /* don't free return value; never waits */
typedef enum { KeepOwn = 0, GiveOwn } ownership_t;
-typedef struct conn_iovec {
+typedef struct {
char *buf;
int len;
ownership_t takeOwn;
diff --git a/src/tst_timers.c b/src/tst_timers.c
@@ -29,16 +29,16 @@
int DFlags;
const char *Home;
-struct tst {
+typedef struct {
int id;
int first, other, morph_at, morph_to;
time_t start;
wakeup_t timer;
wakeup_t morph_timer;
-};
+} tst_t;
static void
-timer_start( struct tst *timer, int to )
+timer_start( tst_t *timer, int to )
{
printf( "starting timer %d, should expire after %d\n", timer->id, to );
time( &timer->start );
@@ -48,7 +48,7 @@ timer_start( struct tst *timer, int to )
static void
timed_out( void *aux )
{
- struct tst *timer = (struct tst *)aux;
+ tst_t *timer = (tst_t *)aux;
printf( "timer %d expired after %d, repeat %d\n",
timer->id, (int)(time( 0 ) - timer->start), timer->other );
@@ -64,7 +64,7 @@ timed_out( void *aux )
static void
morph_timed_out( void *aux )
{
- struct tst *timer = (struct tst *)aux;
+ tst_t *timer = (tst_t *)aux;
printf( "morphing timer %d after %d\n",
timer->id, (int)(time( 0 ) - timer->start) );
@@ -80,7 +80,7 @@ main( int argc, char **argv )
for (i = 1; i < argc; i++) {
char *val = argv[i];
- struct tst *timer = nfmalloc( sizeof(*timer) );
+ tst_t *timer = nfmalloc( sizeof(*timer) );
init_wakeup( &timer->timer, timed_out, timer );
init_wakeup( &timer->morph_timer, morph_timed_out, timer );
timer->id = ++nextid;
