From 18c11eb3bcbd042eba410c1f01659ea6ad0aa2df Mon Sep 17 00:00:00 2001 From: Nick Mathewson Date: Fri, 22 Jul 2005 21:12:10 +0000 Subject: [PATCH] Be consistent about preferring foo* to struct foo* svn:r4637 --- src/common/compat.c | 10 ++--- src/common/container.c | 8 ++-- src/common/container.h | 1 - src/or/circuitbuild.c | 4 +- src/or/circuitlist.c | 20 ++++----- src/or/config.c | 99 +++++++++++++++++++++--------------------- src/or/connection.c | 16 +++---- src/or/control.c | 6 +-- src/or/dirserv.c | 4 +- src/or/dns.c | 88 ++++++++++++++++++------------------- src/or/hibernate.c | 3 +- src/or/onion.c | 16 +++---- src/or/or.h | 59 ++++++++++++------------- src/or/rendservice.c | 2 +- src/or/routerlist.c | 2 +- src/or/test.c | 2 +- 16 files changed, 167 insertions(+), 173 deletions(-) diff --git a/src/common/compat.c b/src/common/compat.c index 4da5d0da6e..2f7d0399cb 100644 --- a/src/common/compat.c +++ b/src/common/compat.c @@ -733,14 +733,14 @@ get_uname(void) */ #if defined(USE_PTHREADS) -struct tor_pthread_data_t { +typedef struct tor_pthread_data_t { int (*func)(void *); void *data; -}; +} tor_pthread_data_t; static void * tor_pthread_helper_fn(void *_data) { - struct tor_pthread_data_t *data = _data; + tor_pthread_data_t *data = _data; int (*func)(void*); void *arg; func = data->func; @@ -771,8 +771,8 @@ spawn_func(int (*func)(void *), void *data) return 0; #elif defined(USE_PTHREADS) pthread_t thread; - struct tor_pthread_data_t *d; - d = tor_malloc(sizeof(struct tor_pthread_data_t)); + tor_pthread_data_t *d; + d = tor_malloc(sizeof(tor_pthread_data_t)); d->data = data; d->func = func; if (pthread_create(&thread,NULL,tor_pthread_helper_fn,d)) diff --git a/src/common/container.c b/src/common/container.c index b53710d4ff..a231afdc86 100644 --- a/src/common/container.c +++ b/src/common/container.c @@ -388,18 +388,18 @@ char *smartlist_join_strings2(smartlist_t *sl, const char *join, /* Splay-tree implementation of string-to-void* map */ -struct strmap_entry_t { +typedef struct strmap_entry_t { SPLAY_ENTRY(strmap_entry_t) node; char *key; void *val; -}; +} strmap_entry_t; struct strmap_t { SPLAY_HEAD(strmap_tree, strmap_entry_t) head; }; -static int compare_strmap_entries(struct strmap_entry_t *a, - struct strmap_entry_t *b) +static int compare_strmap_entries(strmap_entry_t *a, + strmap_entry_t *b) { return strcmp(a->key, b->key); } diff --git a/src/common/container.h b/src/common/container.h index 0b64a05e45..260177767a 100644 --- a/src/common/container.h +++ b/src/common/container.h @@ -72,7 +72,6 @@ char *smartlist_join_strings2(smartlist_t *sl, const char *join, /* Map from const char * to void*. Implemented with a splay tree. */ typedef struct strmap_t strmap_t; -typedef struct strmap_entry_t strmap_entry_t; typedef struct strmap_entry_t strmap_iter_t; strmap_t* strmap_new(void); void* strmap_set(strmap_t *map, const char *key, void *val); diff --git a/src/or/circuitbuild.c b/src/or/circuitbuild.c index 4811e5c112..0ae88c4c4c 100644 --- a/src/or/circuitbuild.c +++ b/src/or/circuitbuild.c @@ -86,7 +86,7 @@ get_unique_circ_id_by_conn(connection_t *conn) char * circuit_list_path(circuit_t *circ, int verbose) { - struct crypt_path_t *hop; + crypt_path_t *hop; smartlist_t *elements; const char *states[] = {"closed", "waiting for keys", "open"}; char buf[128]; @@ -156,7 +156,7 @@ circuit_log_path(int severity, circuit_t *circ) void circuit_rep_hist_note_result(circuit_t *circ) { - struct crypt_path_t *hop; + crypt_path_t *hop; char *prev_digest = NULL; routerinfo_t *router; hop = circ->cpath; diff --git a/src/or/circuitlist.c b/src/or/circuitlist.c index 29cb16a72a..c45d4f2b20 100644 --- a/src/or/circuitlist.c +++ b/src/or/circuitlist.c @@ -26,19 +26,19 @@ static void circuit_free_cpath_node(crypt_path_t *victim); /** A map from OR connection and circuit ID to circuit. (Lookup performance is * very important here, since we need to do it every time a cell arrives.) */ -struct orconn_circid_circuit_map_t { +typedef struct orconn_circid_circuit_map_t { RB_ENTRY(orconn_circid_circuit_map_t) node; connection_t *or_conn; uint16_t circ_id; circuit_t *circuit; -}; +} orconn_circid_circuit_map_t; /** Helper for RB tree: compare the OR connection and circuit ID for a and b, * and return less than, equal to, or greater than zero appropriately. */ static INLINE int -compare_orconn_circid_entries(struct orconn_circid_circuit_map_t *a, - struct orconn_circid_circuit_map_t *b) +compare_orconn_circid_entries(orconn_circid_circuit_map_t *a, + orconn_circid_circuit_map_t *b) { if (a->or_conn < b->or_conn) return -1; @@ -58,7 +58,7 @@ RB_GENERATE(orconn_circid_tree, orconn_circid_circuit_map_t, node, compare_orcon */ /* (We tried using splay trees, but round-robin turned out to make them * suck.) */ -struct orconn_circid_circuit_map_t *_last_circid_orconn_ent = NULL; +orconn_circid_circuit_map_t *_last_circid_orconn_ent = NULL; /** Set the p_conn or n_conn field of a circuit circ, along * with the corresponding circuit ID, and add the circuit as appropriate @@ -70,8 +70,8 @@ circuit_set_circid_orconn(circuit_t *circ, uint16_t id, { uint16_t old_id; connection_t *old_conn; - struct orconn_circid_circuit_map_t search; - struct orconn_circid_circuit_map_t *found; + orconn_circid_circuit_map_t search; + orconn_circid_circuit_map_t *found; tor_assert(!conn || conn->type == CONN_TYPE_OR); @@ -114,7 +114,7 @@ circuit_set_circid_orconn(circuit_t *circ, uint16_t id, if (found) { found->circuit = circ; } else { - found = tor_malloc_zero(sizeof(struct orconn_circid_circuit_map_t)); + found = tor_malloc_zero(sizeof(orconn_circid_circuit_map_t)); found->circ_id = id; found->or_conn = conn; found->circuit = circ; @@ -341,8 +341,8 @@ circuit_get_by_global_id(uint32_t id) circuit_t * circuit_get_by_circid_orconn(uint16_t circ_id, connection_t *conn) { - struct orconn_circid_circuit_map_t search; - struct orconn_circid_circuit_map_t *found; + orconn_circid_circuit_map_t search; + orconn_circid_circuit_map_t *found; tor_assert(conn->type == CONN_TYPE_OR); diff --git a/src/or/config.c b/src/or/config.c index e3b3b6cf48..e36a45a0f8 100644 --- a/src/or/config.c +++ b/src/or/config.c @@ -206,7 +206,7 @@ typedef struct { /** Largest allowed config line */ #define CONFIG_LINE_T_MAXLEN 4096 -static void config_line_append(struct config_line_t **lst, +static void config_line_append(config_line_t **lst, const char *key, const char *val); static void option_reset(config_format_t *fmt, or_options_t *options, config_var_t *var); @@ -221,19 +221,19 @@ static void config_register_addressmaps(or_options_t *options); static int parse_dir_server_line(const char *line, int validate_only); static int parse_redirect_line(smartlist_t *result, - struct config_line_t *line); + config_line_t *line); static int parse_log_severity_range(const char *range, int *min_out, int *max_out); static int convert_log_option(or_options_t *options, - struct config_line_t *level_opt, - struct config_line_t *file_opt, int isDaemon); + config_line_t *level_opt, + config_line_t *file_opt, int isDaemon); static int add_single_log_option(or_options_t *options, int minSeverity, int maxSeverity, const char *type, const char *fname); static int normalize_log_options(or_options_t *options); static int validate_data_directory(or_options_t *options); static int write_configuration_file(const char *fname, or_options_t *options); -static struct config_line_t *get_assigned_option(config_format_t *fmt, +static config_line_t *get_assigned_option(config_format_t *fmt, or_options_t *options, const char *key); static void config_init(config_format_t *fmt, or_options_t *options); @@ -325,7 +325,7 @@ safe_str(const char *address) int options_act(void) { - struct config_line_t *cl; + config_line_t *cl; or_options_t *options = get_options(); static int libevent_initialized = 0; @@ -474,11 +474,11 @@ expand_abbrev(config_format_t *fmt, const char *option, int command_line) } /** Helper: Read a list of configuration options from the command line. */ -static struct config_line_t * +static config_line_t * config_get_commandlines(int argc, char **argv) { - struct config_line_t *front = NULL; - struct config_line_t **new = &front; + config_line_t *front = NULL; + config_line_t **new = &front; char *s; int i = 1; @@ -495,7 +495,7 @@ config_get_commandlines(int argc, char **argv) continue; } - *new = tor_malloc_zero(sizeof(struct config_line_t)); + *new = tor_malloc_zero(sizeof(config_line_t)); s = argv[i]; while (*s == '-') @@ -516,13 +516,13 @@ config_get_commandlines(int argc, char **argv) /** Helper: allocate a new configuration option mapping 'key' to 'val', * append it to *lst. */ static void -config_line_append(struct config_line_t **lst, +config_line_append(config_line_t **lst, const char *key, const char *val) { - struct config_line_t *newline; + config_line_t *newline; - newline = tor_malloc(sizeof(struct config_line_t)); + newline = tor_malloc(sizeof(config_line_t)); newline->key = tor_strdup(key); newline->value = tor_strdup(val); newline->next = NULL; @@ -537,9 +537,9 @@ config_line_append(struct config_line_t **lst, * failed. Return 0 on success, -1 on failure. Warn and ignore any * misformatted lines. */ int -config_get_lines(char *string, struct config_line_t **result) +config_get_lines(char *string, config_line_t **result) { - struct config_line_t *list = NULL, **next; + config_line_t *list = NULL, **next; char *k, *v; next = &list; @@ -553,7 +553,7 @@ config_get_lines(char *string, struct config_line_t **result) /* This list can get long, so we keep a pointer to the end of it * rather than using config_line_append over and over and getting n^2 * performance. This is the only really long list. */ - *next = tor_malloc(sizeof(struct config_line_t)); + *next = tor_malloc(sizeof(config_line_t)); (*next)->key = tor_strdup(k); (*next)->value = tor_strdup(v); (*next)->next = NULL; @@ -569,9 +569,9 @@ config_get_lines(char *string, struct config_line_t **result) * Free all the configuration lines on the linked list front. */ void -config_free_lines(struct config_line_t *front) +config_free_lines(config_line_t *front) { - struct config_line_t *tmp; + config_line_t *tmp; while (front) { tmp = front; @@ -621,7 +621,7 @@ config_find_option(config_format_t *fmt, const char *key) */ static int config_assign_line(config_format_t *fmt, - or_options_t *options, struct config_line_t *c, int reset) + or_options_t *options, config_line_t *c, int reset) { int i, ok; config_var_t *var; @@ -708,7 +708,7 @@ config_assign_line(config_format_t *fmt, case CONFIG_TYPE_LINELIST: case CONFIG_TYPE_LINELIST_S: - config_line_append((struct config_line_t**)lvalue, c->key, c->value); + config_line_append((config_line_t**)lvalue, c->key, c->value); break; case CONFIG_TYPE_OBSOLETE: @@ -755,22 +755,21 @@ config_option_get_canonical_name(const char *key) return var->name; } - /** Return a canonicalized list of the options assigned for key. */ -struct config_line_t * +config_line_t * config_get_assigned_option(or_options_t *options, const char *key) { return get_assigned_option(&config_format, options, key); } -static struct config_line_t * +static config_line_t * get_assigned_option(config_format_t *fmt, or_options_t *options, const char *key) { config_var_t *var; const void *value; char buf[32]; - struct config_line_t *result; + config_line_t *result; tor_assert(options && key); CHECK(fmt, options); @@ -788,10 +787,10 @@ get_assigned_option(config_format_t *fmt, or_options_t *options, const char *key if (var->type == CONFIG_TYPE_LINELIST || var->type == CONFIG_TYPE_LINELIST_V) { /* Linelist requires special handling: we just copy and return it. */ - const struct config_line_t *next_in = *(const struct config_line_t**)value; - struct config_line_t **next_out = &result; + const config_line_t *next_in = *(const config_line_t**)value; + config_line_t **next_out = &result; while (next_in) { - *next_out = tor_malloc(sizeof(struct config_line_t)); + *next_out = tor_malloc(sizeof(config_line_t)); (*next_out)->key = tor_strdup(next_in->key); (*next_out)->value = tor_strdup(next_in->value); next_in = next_in->next; @@ -801,7 +800,7 @@ get_assigned_option(config_format_t *fmt, or_options_t *options, const char *key return result; } - result = tor_malloc_zero(sizeof(struct config_line_t)); + result = tor_malloc_zero(sizeof(config_line_t)); result->key = tor_strdup(var->name); switch (var->type) { @@ -866,9 +865,9 @@ get_assigned_option(config_format_t *fmt, or_options_t *options, const char *key */ static int config_assign(config_format_t *fmt, - or_options_t *options, struct config_line_t *list, int reset) + or_options_t *options, config_line_t *list, int reset) { - struct config_line_t *p; + config_line_t *p; CHECK(fmt, options); @@ -905,7 +904,7 @@ config_assign(config_format_t *fmt, * keys, -2 on bad values, -3 on bad transition. */ int -config_trial_assign(struct config_line_t *list, int reset) +config_trial_assign(config_line_t *list, int reset) { int r; or_options_t *trial_options = options_dup(&config_format, get_options()); @@ -934,7 +933,7 @@ config_trial_assign(struct config_line_t *list, int reset) static void option_reset(config_format_t *fmt, or_options_t *options, config_var_t *var) { - struct config_line_t *c; + config_line_t *c; void *lvalue; CHECK(fmt, options); @@ -964,8 +963,8 @@ option_reset(config_format_t *fmt, or_options_t *options, config_var_t *var) break; case CONFIG_TYPE_LINELIST: case CONFIG_TYPE_LINELIST_S: - config_free_lines(*(struct config_line_t **)lvalue); - *(struct config_line_t **)lvalue = NULL; + config_free_lines(*(config_line_t **)lvalue); + *(config_line_t **)lvalue = NULL; break; case CONFIG_TYPE_LINELIST_V: /* handled by linelist_s. */ @@ -974,7 +973,7 @@ option_reset(config_format_t *fmt, or_options_t *options, config_var_t *var) break; } if (var->initvalue) { - c = tor_malloc_zero(sizeof(struct config_line_t)); + c = tor_malloc_zero(sizeof(config_line_t)); c->key = tor_strdup(var->name); c->value = tor_strdup(var->initvalue); config_assign_line(fmt, options,c,0); @@ -1154,8 +1153,8 @@ options_free(config_format_t *fmt,or_options_t *options) break; case CONFIG_TYPE_LINELIST: case CONFIG_TYPE_LINELIST_V: - config_free_lines(*(struct config_line_t**)lvalue); - *(struct config_line_t**)lvalue = NULL; + config_free_lines(*(config_line_t**)lvalue); + *(config_line_t**)lvalue = NULL; break; case CONFIG_TYPE_CSV: if (*(smartlist_t**)lvalue) { @@ -1179,7 +1178,7 @@ static int option_is_same(config_format_t *fmt, or_options_t *o1, or_options_t *o2, const char *name) { - struct config_line_t *c1, *c2; + config_line_t *c1, *c2; int r = 1; CHECK(fmt, o1); CHECK(fmt, o2); @@ -1209,7 +1208,7 @@ options_dup(config_format_t *fmt, or_options_t *old) { or_options_t *newopts; int i; - struct config_line_t *line; + config_line_t *line; newopts = config_alloc(fmt); for (i=0; fmt->vars[i].name; ++i) { @@ -1258,7 +1257,7 @@ config_dump(config_format_t *fmt, or_options_t *options, int minimal) { smartlist_t *elements; or_options_t *defaults; - struct config_line_t *line; + config_line_t *line; char *result; int i; @@ -1334,7 +1333,7 @@ static int options_validate(or_options_t *options) { int result = 0; - struct config_line_t *cl; + config_line_t *cl; addr_policy_t *addr_policy=NULL; if (options->ORPort < 0 || options->ORPort > 65535) { @@ -1857,7 +1856,7 @@ int init_from_config(int argc, char **argv) { or_options_t *oldoptions, *newoptions; - struct config_line_t *cl; + config_line_t *cl; char *cf=NULL, *fname=NULL; int i, retval; int using_default_torrc; @@ -1995,7 +1994,7 @@ static void config_register_addressmaps(or_options_t *options) { smartlist_t *elts; - struct config_line_t *opt; + config_line_t *opt; char *from, *to; addressmap_clear_configured(); @@ -2081,8 +2080,8 @@ parse_log_severity_range(const char *range, int *min_out, int *max_out) * (LogFile/Syslog)] to a new-style option, and add the new option to * options->Logs. */ static int -convert_log_option(or_options_t *options, struct config_line_t *level_opt, - struct config_line_t *file_opt, int isDaemon) +convert_log_option(or_options_t *options, config_line_t *level_opt, + config_line_t *file_opt, int isDaemon) { int levelMin = -1, levelMax = -1; @@ -2120,7 +2119,7 @@ convert_log_option(or_options_t *options, struct config_line_t *level_opt, int config_init_logs(or_options_t *options, int validate_only) { - struct config_line_t *opt; + config_line_t *opt; int ok; smartlist_t *elts; @@ -2222,7 +2221,7 @@ normalize_log_options(or_options_t *options) { /* The order of options is: Level? (File Level?)+ */ - struct config_line_t *opt = options->OldLogOptions; + config_line_t *opt = options->OldLogOptions; /* Special case for if first option is LogLevel. */ if (opt && !strcasecmp(opt->key, "LogLevel")) { @@ -2280,7 +2279,7 @@ normalize_log_options(or_options_t *options) void config_append_default_exit_policy(addr_policy_t **policy) { - struct config_line_t tmp; + config_line_t tmp; addr_policy_t *ap; tmp.key = NULL; @@ -2306,7 +2305,7 @@ config_append_default_exit_policy(addr_policy_t **policy) * are malformed, else return 0. */ int -config_parse_addr_policy(struct config_line_t *cfg, +config_parse_addr_policy(config_line_t *cfg, addr_policy_t **dest) { addr_policy_t **nextp; @@ -2361,7 +2360,7 @@ addr_policy_free(addr_policy_t *p) * result and return 0. Else if they are valid, return 0. * Else return -1. */ static int -parse_redirect_line(smartlist_t *result, struct config_line_t *line) +parse_redirect_line(smartlist_t *result, config_line_t *line) { smartlist_t *elements = NULL; exit_redirect_t *r; diff --git a/src/or/connection.c b/src/or/connection.c index 4fd918e66e..8b9667bdbe 100644 --- a/src/or/connection.c +++ b/src/or/connection.c @@ -784,16 +784,16 @@ connection_connect(connection_t *conn, char *address, * or if the existing connections do not match those configured. */ static int -retry_listeners(int type, struct config_line_t *cfg, +retry_listeners(int type, config_line_t *cfg, int port_option, const char *default_addr, int force) { - struct smartlist_t *launch = smartlist_create(); + smartlist_t *launch = smartlist_create(); int free_launch_elts = 1; - struct config_line_t *c; + config_line_t *c; int n_conn, i; connection_t *conn; connection_t **carray; - struct config_line_t *line; + config_line_t *line; if (cfg && port_option) { for (c = cfg; c; c = c->next) { @@ -801,7 +801,7 @@ retry_listeners(int type, struct config_line_t *cfg, } free_launch_elts = 0; } else if (port_option) { - line = tor_malloc_zero(sizeof(struct config_line_t)); + line = tor_malloc_zero(sizeof(config_line_t)); line->key = tor_strdup(""); line->value = tor_strdup(default_addr); smartlist_add(launch, line); @@ -823,7 +823,7 @@ retry_listeners(int type, struct config_line_t *cfg, } /* Okay, so this is a listener. Is it configured? */ line = NULL; - SMARTLIST_FOREACH(launch, struct config_line_t *, wanted, + SMARTLIST_FOREACH(launch, config_line_t *, wanted, { char *addr; uint16_t port; @@ -852,7 +852,7 @@ retry_listeners(int type, struct config_line_t *cfg, /* Now open all the listeners that are configured but not opened. */ i = 0; - SMARTLIST_FOREACH(launch, struct config_line_t *, cfg, + SMARTLIST_FOREACH(launch, config_line_t *, cfg, { if (connection_create_listener(cfg->value, (uint16_t) port_option, type)<0) @@ -860,7 +860,7 @@ retry_listeners(int type, struct config_line_t *cfg, }); if (free_launch_elts) { - SMARTLIST_FOREACH(launch, struct config_line_t *, cfg, + SMARTLIST_FOREACH(launch, config_line_t *, cfg, config_free_lines(cfg)); } smartlist_free(launch); diff --git a/src/or/control.c b/src/or/control.c index dc3633fa99..efbadec57d 100644 --- a/src/or/control.c +++ b/src/or/control.c @@ -602,7 +602,7 @@ static int handle_control_setconf(connection_t *conn, uint32_t len, char *body) { int r; - struct config_line_t *lines=NULL; + config_line_t *lines=NULL; char *start = body; int v0 = STATE_IS_V0(conn->state); @@ -717,7 +717,7 @@ handle_control_getconf(connection_t *conn, uint32_t body_len, const char *body) smartlist_add(unrecognized, q); } } else { - struct config_line_t *answer = config_get_assigned_option(options,q); + config_line_t *answer = config_get_assigned_option(options,q); if (!v0 && !answer) { const char *name = config_option_get_canonical_name(q); size_t alen = strlen(name)+8; @@ -727,7 +727,7 @@ handle_control_getconf(connection_t *conn, uint32_t body_len, const char *body) } while (answer) { - struct config_line_t *next; + config_line_t *next; size_t alen = strlen(answer->key)+strlen(answer->value)+8; char *astr = tor_malloc(alen); if (v0) diff --git a/src/or/dirserv.c b/src/or/dirserv.c index aeb50e18d6..ba0df0a4de 100644 --- a/src/or/dirserv.c +++ b/src/or/dirserv.c @@ -96,7 +96,7 @@ dirserv_parse_fingerprint_file(const char *fname) char *nickname, *fingerprint; smartlist_t *fingerprint_list_new; int result; - struct config_line_t *front=NULL, *list; + config_line_t *front=NULL, *list; cf = read_file_to_str(fname, 0); if (!cf) { @@ -608,7 +608,7 @@ dirserv_dump_directory_to_string(char **dir_out, { smartlist_t *versions; - struct config_line_t *ln; + config_line_t *ln; versions = smartlist_create(); for (ln = get_options()->RecommendedVersions; ln; ln = ln->next) { smartlist_split_string(versions, ln->value, ",", diff --git a/src/or/dns.c b/src/or/dns.c index 41e7bb83be..91ba74d094 100644 --- a/src/or/dns.c +++ b/src/or/dns.c @@ -45,17 +45,17 @@ static int num_dnsworkers_busy=0; static time_t last_rotation_time=0; /** Linked list of connections waiting for a DNS answer. */ -struct pending_connection_t { - struct connection_t *conn; +typedef struct pending_connection_t { + connection_t *conn; struct pending_connection_t *next; -}; +} pending_connection_t; /** A DNS request: possibly completed, possibly pending; cached_resolve * structs are stored at the OR side in a splay tree, and as a linked * list from oldest to newest. */ -struct cached_resolve { - SPLAY_ENTRY(cached_resolve) node; +typedef struct cached_resolve_t { + SPLAY_ENTRY(cached_resolve_t) node; char address[MAX_ADDRESSLEN]; /**< The hostname to be resolved. */ uint32_t addr; /**< IPv4 addr for address. */ char state; /**< 0 is pending; 1 means answer is valid; 2 means resolve failed. */ @@ -63,13 +63,13 @@ struct cached_resolve { #define CACHE_STATE_VALID 1 #define CACHE_STATE_FAILED 2 uint32_t expire; /**< Remove items from cache after this time. */ - struct pending_connection_t *pending_connections; - struct cached_resolve *next; -}; + pending_connection_t *pending_connections; + struct cached_resolve_t *next; +} cached_resolve_t; static void purge_expired_resolves(uint32_t now); static int assign_to_dnsworker(connection_t *exitconn); -static void dns_purge_resolve(struct cached_resolve *resolve); +static void dns_purge_resolve(cached_resolve_t *resolve); static void dns_found_answer(char *address, uint32_t addr, char outcome); static int dnsworker_main(void *data); static int spawn_dnsworker(void); @@ -77,18 +77,18 @@ static void spawn_enough_dnsworkers(void); static void send_resolved_cell(connection_t *conn, uint8_t answer_type); /** Splay tree of cached_resolve objects. */ -static SPLAY_HEAD(cache_tree, cached_resolve) cache_root; +static SPLAY_HEAD(cache_tree, cached_resolve_t) cache_root; /** Function to compare hashed resolves on their addresses; used to * implement splay trees. */ -static int compare_cached_resolves(struct cached_resolve *a, - struct cached_resolve *b) { +static int compare_cached_resolves(cached_resolve_t *a, + cached_resolve_t *b) { /* make this smarter one day? */ return strncmp(a->address, b->address, MAX_ADDRESSLEN); } -SPLAY_PROTOTYPE(cache_tree, cached_resolve, node, compare_cached_resolves); -SPLAY_GENERATE(cache_tree, cached_resolve, node, compare_cached_resolves); +SPLAY_PROTOTYPE(cache_tree, cached_resolve_t, node, compare_cached_resolves); +SPLAY_GENERATE(cache_tree, cached_resolve_t, node, compare_cached_resolves); /** Initialize the DNS cache. */ static void @@ -108,10 +108,10 @@ dns_init(void) /** Helper: free storage held by an entry in the DNS cache. */ static void -_free_cached_resolve(struct cached_resolve *r) +_free_cached_resolve(cached_resolve_t *r) { while (r->pending_connections) { - struct pending_connection_t *victim = r->pending_connections; + pending_connection_t *victim = r->pending_connections; r->pending_connections = victim->next; tor_free(victim); } @@ -122,7 +122,7 @@ _free_cached_resolve(struct cached_resolve *r) void dns_free_all(void) { - struct cached_resolve *ptr, *next; + cached_resolve_t *ptr, *next; for (ptr = SPLAY_MIN(cache_tree, &cache_root); ptr != NULL; ptr = next) { next = SPLAY_NEXT(cache_tree, &cache_root, ptr); SPLAY_REMOVE(cache_tree, &cache_root, ptr); @@ -131,16 +131,16 @@ dns_free_all(void) } /** Linked list of resolved addresses, oldest to newest. */ -static struct cached_resolve *oldest_cached_resolve = NULL; -static struct cached_resolve *newest_cached_resolve = NULL; +static cached_resolve_t *oldest_cached_resolve = NULL; +static cached_resolve_t *newest_cached_resolve = NULL; /** Remove every cached_resolve whose expire time is before now * from the cache. */ static void purge_expired_resolves(uint32_t now) { - struct cached_resolve *resolve; - struct pending_connection_t *pend; + cached_resolve_t *resolve; + pending_connection_t *pend; connection_t *pendconn; /* this is fast because the linked list @@ -212,7 +212,7 @@ send_resolved_cell(connection_t *conn, uint8_t answer_type) /** Link r into the tree of address-to-result mappings, and add it to * the linked list of resolves-by-age. */ static void -insert_resolve(struct cached_resolve *r) +insert_resolve(cached_resolve_t *r) { /* add us to the linked list of resolves */ if (!oldest_cached_resolve) { @@ -238,9 +238,9 @@ insert_resolve(struct cached_resolve *r) int dns_resolve(connection_t *exitconn) { - struct cached_resolve *resolve; - struct cached_resolve search; - struct pending_connection_t *pending_connection; + cached_resolve_t *resolve; + cached_resolve_t search; + pending_connection_t *pending_connection; struct in_addr in; circuit_t *circ; uint32_t now = time(NULL); @@ -271,7 +271,7 @@ dns_resolve(connection_t *exitconn) case CACHE_STATE_PENDING: /* add us to the pending list */ pending_connection = tor_malloc_zero( - sizeof(struct pending_connection_t)); + sizeof(pending_connection_t)); pending_connection->conn = exitconn; pending_connection->next = resolve->pending_connections; resolve->pending_connections = pending_connection; @@ -301,13 +301,13 @@ dns_resolve(connection_t *exitconn) tor_assert(0); } /* not there, need to add it */ - resolve = tor_malloc_zero(sizeof(struct cached_resolve)); + resolve = tor_malloc_zero(sizeof(cached_resolve_t)); resolve->state = CACHE_STATE_PENDING; resolve->expire = now + MAX_DNS_ENTRY_AGE; strlcpy(resolve->address, exitconn->address, sizeof(resolve->address)); /* add us to the pending list */ - pending_connection = tor_malloc_zero(sizeof(struct pending_connection_t)); + pending_connection = tor_malloc_zero(sizeof(pending_connection_t)); pending_connection->conn = exitconn; resolve->pending_connections = pending_connection; exitconn->state = EXIT_CONN_STATE_RESOLVING; @@ -360,9 +360,9 @@ assign_to_dnsworker(connection_t *exitconn) void connection_dns_remove(connection_t *conn) { - struct pending_connection_t *pend, *victim; - struct cached_resolve search; - struct cached_resolve *resolve; + pending_connection_t *pend, *victim; + cached_resolve_t search; + cached_resolve_t *resolve; tor_assert(conn->type == CONN_TYPE_EXIT); tor_assert(conn->state == EXIT_CONN_STATE_RESOLVING); @@ -406,8 +406,8 @@ connection_dns_remove(connection_t *conn) void assert_connection_edge_not_dns_pending(connection_t *conn) { - struct pending_connection_t *pend; - struct cached_resolve *resolve; + pending_connection_t *pend; + cached_resolve_t *resolve; SPLAY_FOREACH(resolve, cache_tree, &cache_root) { for (pend = resolve->pending_connections; @@ -423,8 +423,8 @@ assert_connection_edge_not_dns_pending(connection_t *conn) void assert_all_pending_dns_resolves_ok(void) { - struct pending_connection_t *pend; - struct cached_resolve *resolve; + pending_connection_t *pend; + cached_resolve_t *resolve; SPLAY_FOREACH(resolve, cache_tree, &cache_root) { for (pend = resolve->pending_connections; @@ -444,9 +444,9 @@ assert_all_pending_dns_resolves_ok(void) void dns_cancel_pending_resolve(char *address) { - struct pending_connection_t *pend; - struct cached_resolve search; - struct cached_resolve *resolve; + pending_connection_t *pend; + cached_resolve_t search; + cached_resolve_t *resolve; connection_t *pendconn; circuit_t *circ; @@ -493,9 +493,9 @@ dns_cancel_pending_resolve(char *address) /** Remove resolve from the cache. */ static void -dns_purge_resolve(struct cached_resolve *resolve) +dns_purge_resolve(cached_resolve_t *resolve) { - struct cached_resolve *tmp; + cached_resolve_t *tmp; /* remove resolve from the linked list */ if (resolve == oldest_cached_resolve) { @@ -528,9 +528,9 @@ dns_purge_resolve(struct cached_resolve *resolve) static void dns_found_answer(char *address, uint32_t addr, char outcome) { - struct pending_connection_t *pend; - struct cached_resolve search; - struct cached_resolve *resolve; + pending_connection_t *pend; + cached_resolve_t search; + cached_resolve_t *resolve; connection_t *pendconn; circuit_t *circ; @@ -540,7 +540,7 @@ dns_found_answer(char *address, uint32_t addr, char outcome) if (!resolve) { log_fn(LOG_INFO,"Resolved unasked address '%s'; caching anyway.", safe_str(address)); - resolve = tor_malloc_zero(sizeof(struct cached_resolve)); + resolve = tor_malloc_zero(sizeof(cached_resolve_t)); resolve->state = (outcome == DNS_RESOLVE_SUCCEEDED) ? CACHE_STATE_VALID : CACHE_STATE_FAILED; resolve->addr = addr; diff --git a/src/or/hibernate.c b/src/or/hibernate.c index 0c5a112c1a..dcf299657b 100644 --- a/src/or/hibernate.c +++ b/src/or/hibernate.c @@ -100,8 +100,6 @@ static void accounting_set_wakeup_time(void); * Functions for bandwidth accounting. * ************/ - - /** Configure accounting start/end time settings based on * options->AccountingStart. Return 0 on success, -1 on failure. If * validate_only is true, do not change the current settings. */ @@ -886,3 +884,4 @@ accounting_getinfo_helper(const char *question, char **answer) } return 0; } + diff --git a/src/or/onion.c b/src/or/onion.c index 00d89c278e..d4aad3cfc9 100644 --- a/src/or/onion.c +++ b/src/or/onion.c @@ -13,18 +13,18 @@ const char onion_c_id[] = "$Id$"; #include "or.h" -struct onion_queue_t { +typedef struct onion_queue_t { circuit_t *circ; time_t when_added; struct onion_queue_t *next; -}; +} onion_queue_t; /** 5 seconds on the onion queue til we just send back a destroy */ #define ONIONQUEUE_WAIT_CUTOFF 5 /** Global (within this file) variables used by the next few functions */ -static struct onion_queue_t *ol_list=NULL; -static struct onion_queue_t *ol_tail=NULL; +static onion_queue_t *ol_list=NULL; +static onion_queue_t *ol_tail=NULL; /** Length of ol_list */ static int ol_length=0; @@ -34,10 +34,10 @@ static int ol_length=0; int onion_pending_add(circuit_t *circ) { - struct onion_queue_t *tmp; + onion_queue_t *tmp; time_t now = time(NULL); - tmp = tor_malloc_zero(sizeof(struct onion_queue_t)); + tmp = tor_malloc_zero(sizeof(onion_queue_t)); tmp->circ = circ; tmp->when_added = now; @@ -97,7 +97,7 @@ onion_next_task(void) void onion_pending_remove(circuit_t *circ) { - struct onion_queue_t *tmpo, *victim; + onion_queue_t *tmpo, *victim; if (!ol_list) return; /* nothing here. */ @@ -408,7 +408,7 @@ void clear_pending_onions(void) { while (ol_list) { - struct onion_queue_t *victim = ol_list; + onion_queue_t *victim = ol_list; ol_list = victim->next; tor_free(victim); } diff --git a/src/or/or.h b/src/or/or.h index a579a5967b..a34d3a7efd 100644 --- a/src/or/or.h +++ b/src/or/or.h @@ -782,7 +782,7 @@ typedef struct extend_info_t { /** Holds accounting information for a single step in the layered encryption * performed by a circuit. Used only at the client edge of a circuit. */ -struct crypt_path_t { +typedef struct crypt_path_t { uint32_t magic; /* crypto environments */ @@ -827,7 +827,7 @@ struct crypt_path_t { * at this step? */ int deliver_window; /**< How many bytes are we willing to deliver originating * at this step? */ -}; +} crypt_path_t; #define CPATH_KEY_MATERIAL_LEN (20*2+16*2) @@ -838,8 +838,6 @@ struct crypt_path_t { #define ONIONSKIN_REPLY_LEN (DH_KEY_LEN+DIGEST_LEN) #define REND_COOKIE_LEN DIGEST_LEN -typedef struct crypt_path_t crypt_path_t; - /** Information used to build a circuit. */ typedef struct { /** Intended length of the final circuit. */ @@ -853,7 +851,7 @@ typedef struct { /** Whether the last hop was picked with exiting in mind. */ int is_internal; /** The crypt_path_t to append after rendezvous: used for rendezvous. */ - struct crypt_path_t *pending_final_cpath; + crypt_path_t *pending_final_cpath; /** How many times has building a circuit for this task failed? */ int failure_count; /** At what time should we give up on this task? */ @@ -1015,6 +1013,12 @@ typedef struct exit_redirect_t { uint16_t port_dest; } exit_redirect_t; +typedef struct config_line_t { + char *key; + char *value; + struct config_line_t *next; +} config_line_t; + /** Configuration options for a Tor process */ typedef struct { uint32_t _magic; @@ -1026,10 +1030,10 @@ typedef struct { } command; const char *command_arg; /**< Argument for command-line option. */ - struct config_line_t *OldLogOptions; /**< List of configuration lines + config_line_t *OldLogOptions; /**< List of configuration lines * for logfiles, old style. */ - struct config_line_t *Logs; /**< New-style list of configuration lines + config_line_t *Logs; /**< New-style list of configuration lines * for logs */ char *DebugLogFile; /**< Where to send verbose log messages. */ @@ -1056,20 +1060,20 @@ typedef struct { smartlist_t *AllowUnverifiedNodes; /**< List of "entry", "middle", "exit" */ int _AllowUnverified; /**< Bitmask; derived from AllowUnverifiedNodes; */ - struct config_line_t *ExitPolicy; /**< Lists of exit policy components. */ - struct config_line_t *SocksPolicy; /**< Lists of socks policy components */ - struct config_line_t *DirPolicy; /**< Lists of dir policy components */ + config_line_t *ExitPolicy; /**< Lists of exit policy components. */ + config_line_t *SocksPolicy; /**< Lists of socks policy components */ + config_line_t *DirPolicy; /**< Lists of dir policy components */ /** Addresses to bind for listening for SOCKS connections. */ - struct config_line_t *SocksBindAddress; + config_line_t *SocksBindAddress; /** Addresses to bind for listening for OR connections. */ - struct config_line_t *ORBindAddress; + config_line_t *ORBindAddress; /** Addresses to bind for listening for directory connections. */ - struct config_line_t *DirBindAddress; + config_line_t *DirBindAddress; /** Local address to bind outbound sockets */ char *OutboundBindAddress; /** Directory server only: which versions of * Tor should we tell users to run? */ - struct config_line_t *RecommendedVersions; + config_line_t *RecommendedVersions; /** Whether dirservers refuse router descriptors with private IPs. */ int DirAllowPrivateAddresses; char *User; /**< Name of user to run Tor as. */ @@ -1095,7 +1099,7 @@ typedef struct { /** Should we try to reuse the same exit node for a given host */ smartlist_t *TrackHostExits; int TrackHostExitsExpire; /**< Number of seconds until we expire an addressmap */ - struct config_line_t *AddressMap; /**< List of address map directives. */ + config_line_t *AddressMap; /**< List of address map directives. */ int DirFetchPeriod; /**< How often do we fetch new directories? */ int DirPostPeriod; /**< How often do we post our server descriptor to the * authoritative directory servers? */ @@ -1120,7 +1124,7 @@ typedef struct { int NumCpus; /**< How many CPUs should we try to use? */ int RunTesting; /**< If true, create testing circuits to measure how well the * other ORs are running. */ - struct config_line_t *RendConfigLines; /**< List of configuration lines + config_line_t *RendConfigLines; /**< List of configuration lines * for rendezvous services. */ char *ContactInfo; /**< Contact info to be published in the directory */ @@ -1134,12 +1138,12 @@ typedef struct { uint16_t HttpsProxyPort; /**< Parsed port for https proxy, if any */ char *HttpsProxyAuthenticator; /**< username:password string, if any */ - struct config_line_t *DirServers; /**< List of configuration lines + config_line_t *DirServers; /**< List of configuration lines * for directory servers. */ char *MyFamily; /**< Declared family for this OR. */ - struct config_line_t *NodeFamilies; /**< List of config lines for + config_line_t *NodeFamilies; /**< List of config lines for * node families */ - struct config_line_t *RedirectExit; /**< List of config lines for simple + config_line_t *RedirectExit; /**< List of config lines for simple * addr/port redirection */ smartlist_t *RedirectExitList; /**< List of exit_redirect_t */ int _MonthlyAccountingStart; /**< Deprecated: day of month when accounting @@ -1321,32 +1325,26 @@ extern unsigned long stats_n_destroy_cells_processed; /********************************* config.c ***************************/ -struct config_line_t { - char *key; - char *value; - struct config_line_t *next; -}; - or_options_t *get_options(void); void set_options(or_options_t *new_val); int options_act(void); void config_free_all(void); const char *safe_str(const char *address); -int config_get_lines(char *string, struct config_line_t **result); -void config_free_lines(struct config_line_t *front); -int config_trial_assign(struct config_line_t *list, int reset); +int config_get_lines(char *string, config_line_t **result); +void config_free_lines(config_line_t *front); +int config_trial_assign(config_line_t *list, int reset); int resolve_my_address(or_options_t *options, uint32_t *addr); void options_init(or_options_t *options); int init_from_config(int argc, char **argv); int config_init_logs(or_options_t *options, int validate_only); -int config_parse_addr_policy(struct config_line_t *cfg, +int config_parse_addr_policy(config_line_t *cfg, addr_policy_t **dest); void config_append_default_exit_policy(addr_policy_t **policy); void addr_policy_free(addr_policy_t *p); int config_option_is_recognized(const char *key); const char *config_option_get_canonical_name(const char *key); -struct config_line_t *config_get_assigned_option(or_options_t *options, +config_line_t *config_get_assigned_option(or_options_t *options, const char *key); char *config_dump_options(or_options_t *options, int minimal); int save_current_config(void); @@ -1629,7 +1627,6 @@ int we_are_hibernating(void); void consider_hibernation(time_t now); int accounting_getinfo_helper(const char *question, char **answer); - /********************************* main.c ***************************/ int connection_add(connection_t *conn); diff --git a/src/or/rendservice.c b/src/or/rendservice.c index 0da27b2ded..b1b1dd4582 100644 --- a/src/or/rendservice.c +++ b/src/or/rendservice.c @@ -193,7 +193,7 @@ parse_port_config(const char *string) int rend_config_services(or_options_t *options, int validate_only) { - struct config_line_t *line; + config_line_t *line; rend_service_t *service = NULL; rend_service_port_config_t *portcfg; diff --git a/src/or/routerlist.c b/src/or/routerlist.c index 41975c4262..1669bcf355 100644 --- a/src/or/routerlist.c +++ b/src/or/routerlist.c @@ -279,7 +279,7 @@ void routerlist_add_family(smartlist_t *sl, routerinfo_t *router) { routerinfo_t *r; - struct config_line_t *cl; + config_line_t *cl; if (!router->declared_family) return; diff --git a/src/or/test.c b/src/or/test.c index 1199c8d5fc..64fdacd789 100644 --- a/src/or/test.c +++ b/src/or/test.c @@ -1030,7 +1030,7 @@ static void test_control_formats(void) { char *out; - const char *inp = + const char *inp = "..This is a test\r\nof the emergency \nbroadcast\r\n..system.\r\nZ.\r\n"; size_t sz;