Be consistent about preferring foo* to struct foo*

svn:r4637

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))

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);
 }

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);

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;

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 <b>circ</b>, 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);
 

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 *<b>lst</b>. */
 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 <b>front</b>.
  */
 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)
  *  <b>result</b> 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;

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);

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)

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, ",",

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 <b>address</b>. */
   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 <b>expire</b> time is before <b>now</b>
  * 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 <b>r</b> 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 <b>resolve</b> 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;

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
  * <b>validate_only</b> is true, do not change the current settings. */
@@ -886,3 +884,4 @@ accounting_getinfo_helper(const char *question, char **answer)
   }
   return 0;
 }
+

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);
   }

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);

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;
 

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;

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;