[Author Prev][Author Next][Thread Prev][Thread Next][Author Index][Thread Index]

[tor-commits] [tor/master] connection.h: new includes and struct declarations



commit 8b7eeea39d5a7365c7f834fc4015179c9200676f
Author: Nick Mathewson <nickm@xxxxxxxxxxxxxx>
Date:   Mon Dec 16 13:07:00 2019 -0500

    connection.h: new includes and struct declarations
    
    Using these frees us from several dependencies on include order.
---
 src/core/mainloop/.may_include |   2 +
 src/core/mainloop/connection.h | 200 +++++++++++++++++++++++------------------
 2 files changed, 116 insertions(+), 86 deletions(-)

diff --git a/src/core/mainloop/.may_include b/src/core/mainloop/.may_include
index 580e6d0a8..8e01cf910 100644
--- a/src/core/mainloop/.may_include
+++ b/src/core/mainloop/.may_include
@@ -16,7 +16,9 @@ lib/net/*.h
 lib/evloop/*.h
 lib/geoip/*.h
 lib/sandbox/*.h
+lib/smartlist_core/*.h
 lib/compress/*.h
+lib/log/*.h
 
 core/mainloop/*.h
 core/mainloop/*.inc
\ No newline at end of file
diff --git a/src/core/mainloop/connection.h b/src/core/mainloop/connection.h
index c93f1ef8e..56132beb3 100644
--- a/src/core/mainloop/connection.h
+++ b/src/core/mainloop/connection.h
@@ -12,7 +12,25 @@
 #ifndef TOR_CONNECTION_H
 #define TOR_CONNECTION_H
 
-listener_connection_t *TO_LISTENER_CONN(connection_t *);
+#include "lib/smartlist_core/smartlist_core.h"
+#include "lib/log/log.h"
+
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+
+struct listener_connection_t;
+struct connection_t;
+struct dir_connection_t;
+struct or_connection_t;
+struct edge_connection_t;
+struct entry_connection_t;
+struct control_connection_t;
+struct port_cfg_t;
+struct tor_addr_t;
+struct or_options_t;
+
+struct listener_connection_t *TO_LISTENER_CONN(struct connection_t *);
 
 struct buf_t;
 
@@ -56,7 +74,7 @@ struct buf_t;
 
 #define CONN_TYPE_MAX_ 19
 /* !!!! If _CONN_TYPE_MAX is ever over 31, we must grow the type field in
- * connection_t. */
+ * struct connection_t. */
 
 /* Proxy client handshake states */
 /* We use a proxy but we haven't even connected to it yet. */
@@ -88,34 +106,36 @@ struct buf_t;
  */
 typedef struct
 {
-  connection_t *old_conn; /* Old listener connection to be replaced */
-  const port_cfg_t *new_port; /* New port configuration */
+  struct connection_t *old_conn; /* Old listener connection to be replaced */
+  const struct port_cfg_t *new_port; /* New port configuration */
 } listener_replacement_t;
 
 const char *conn_type_to_string(int type);
 const char *conn_state_to_string(int type, int state);
 int conn_listener_type_supports_af_unix(int type);
 
-dir_connection_t *dir_connection_new(int socket_family);
-or_connection_t *or_connection_new(int type, int socket_family);
-edge_connection_t *edge_connection_new(int type, int socket_family);
-entry_connection_t *entry_connection_new(int type, int socket_family);
-control_connection_t *control_connection_new(int socket_family);
-listener_connection_t *listener_connection_new(int type, int socket_family);
-connection_t *connection_new(int type, int socket_family);
-int connection_init_accepted_conn(connection_t *conn,
-                                  const listener_connection_t *listener);
-void connection_link_connections(connection_t *conn_a, connection_t *conn_b);
-MOCK_DECL(void,connection_free_,(connection_t *conn));
+struct dir_connection_t *dir_connection_new(int socket_family);
+struct or_connection_t *or_connection_new(int type, int socket_family);
+struct edge_connection_t *edge_connection_new(int type, int socket_family);
+struct entry_connection_t *entry_connection_new(int type, int socket_family);
+struct control_connection_t *control_connection_new(int socket_family);
+struct listener_connection_t *listener_connection_new(int type,
+                                                      int socket_family);
+struct connection_t *connection_new(int type, int socket_family);
+int connection_init_accepted_conn(struct connection_t *conn,
+                                const struct listener_connection_t *listener);
+void connection_link_connections(struct connection_t *conn_a,
+                                 struct connection_t *conn_b);
+MOCK_DECL(void,connection_free_,(struct connection_t *conn));
 #define connection_free(conn) \
-  FREE_AND_NULL(connection_t, connection_free_, (conn))
+  FREE_AND_NULL(struct connection_t, connection_free_, (conn))
 void connection_free_all(void);
-void connection_about_to_close_connection(connection_t *conn);
-void connection_close_immediate(connection_t *conn);
-void connection_mark_for_close_(connection_t *conn,
+void connection_about_to_close_connection(struct connection_t *conn);
+void connection_close_immediate(struct connection_t *conn);
+void connection_mark_for_close_(struct connection_t *conn,
                                 int line, const char *file);
 MOCK_DECL(void, connection_mark_for_close_internal_,
-          (connection_t *conn, int line, const char *file));
+          (struct connection_t *conn, int line, const char *file));
 
 #define connection_mark_for_close(c) \
   connection_mark_for_close_((c), __LINE__, SHORT_FILE__)
@@ -130,11 +150,11 @@ MOCK_DECL(void, connection_mark_for_close_internal_,
  * connection_or_notify_error()), or you actually are the
  * connection_or_close_for_error() or connection_or_close_normally function.
  * For all other cases, use connection_mark_and_flush() instead, which
- * checks for or_connection_t properly, instead.  See below.
+ * checks for struct or_connection_t properly, instead.  See below.
  */
 #define connection_mark_and_flush_internal_(c,line,file)                \
   do {                                                                  \
-    connection_t *tmp_conn__ = (c);                                     \
+    struct connection_t *tmp_conn__ = (c);                              \
     connection_mark_for_close_internal_(tmp_conn__, (line), (file));    \
     tmp_conn__->hold_open_until_flushed = 1;                            \
   } while (0)
@@ -147,7 +167,7 @@ MOCK_DECL(void, connection_mark_for_close_internal_,
  */
 #define connection_mark_and_flush_(c,line,file)                           \
   do {                                                                    \
-    connection_t *tmp_conn_ = (c);                                        \
+    struct connection_t *tmp_conn_ = (c);                                 \
     if (tmp_conn_->type == CONN_TYPE_OR) {                                \
       log_warn(LD_CHANNEL | LD_BUG,                                       \
                "Something tried to close (and flush) an or_connection_t"  \
@@ -164,13 +184,13 @@ MOCK_DECL(void, connection_mark_for_close_internal_,
 
 void connection_expire_held_open(void);
 
-int connection_connect(connection_t *conn, const char *address,
-                       const tor_addr_t *addr,
+int connection_connect(struct connection_t *conn, const char *address,
+                       const struct tor_addr_t *addr,
                        uint16_t port, int *socket_error);
 
 #ifdef HAVE_SYS_UN_H
 
-int connection_connect_unix(connection_t *conn, const char *socket_path,
+int connection_connect_unix(struct connection_t *conn, const char *socket_path,
                             int *socket_error);
 
 #endif /* defined(HAVE_SYS_UN_H) */
@@ -183,78 +203,86 @@ int connection_connect_unix(connection_t *conn, const char *socket_path,
     username and password fields. */
 #define MAX_SOCKS5_AUTH_SIZE_TOTAL 2*MAX_SOCKS5_AUTH_FIELD_SIZE
 
-int connection_proxy_connect(connection_t *conn, int type);
-int connection_read_proxy_handshake(connection_t *conn);
-void log_failed_proxy_connection(connection_t *conn);
-int get_proxy_addrport(tor_addr_t *addr, uint16_t *port, int *proxy_type,
-                       int *is_pt_out, const connection_t *conn);
+int connection_proxy_connect(struct connection_t *conn, int type);
+int connection_read_proxy_handshake(struct connection_t *conn);
+void log_failed_proxy_connection(struct connection_t *conn);
+int get_proxy_addrport(struct tor_addr_t *addr, uint16_t *port,
+                       int *proxy_type,
+                       int *is_pt_out, const struct connection_t *conn);
 
-int retry_all_listeners(smartlist_t *new_conns,
+int retry_all_listeners(struct smartlist_t *new_conns,
                         int close_all_noncontrol);
 
 void connection_mark_all_noncontrol_listeners(void);
 void connection_mark_all_noncontrol_connections(void);
 
-ssize_t connection_bucket_write_limit(connection_t *conn, time_t now);
-int global_write_bucket_low(connection_t *conn, size_t attempt, int priority);
+ssize_t connection_bucket_write_limit(struct connection_t *conn, time_t now);
+int global_write_bucket_low(struct connection_t *conn,
+                            size_t attempt, int priority);
 void connection_bucket_init(void);
-void connection_bucket_adjust(const or_options_t *options);
+void connection_bucket_adjust(const struct or_options_t *options);
 void connection_bucket_refill_all(time_t now,
                                   uint32_t now_ts);
-void connection_read_bw_exhausted(connection_t *conn, bool is_global_bw);
-void connection_write_bw_exhausted(connection_t *conn, bool is_global_bw);
-void connection_consider_empty_read_buckets(connection_t *conn);
-void connection_consider_empty_write_buckets(connection_t *conn);
-
-int connection_handle_read(connection_t *conn);
-
-int connection_buf_get_bytes(char *string, size_t len, connection_t *conn);
-int connection_buf_get_line(connection_t *conn, char *data,
-                                   size_t *data_len);
-int connection_fetch_from_buf_http(connection_t *conn,
+void connection_read_bw_exhausted(struct connection_t *conn,
+                                  bool is_global_bw);
+void connection_write_bw_exhausted(struct connection_t *conn,
+                                   bool is_global_bw);
+void connection_consider_empty_read_buckets(struct connection_t *conn);
+void connection_consider_empty_write_buckets(struct connection_t *conn);
+
+int connection_handle_read(struct connection_t *conn);
+
+int connection_buf_get_bytes(char *string, size_t len,
+                             struct connection_t *conn);
+int connection_buf_get_line(struct connection_t *conn, char *data,
+                            size_t *data_len);
+int connection_fetch_from_buf_http(struct connection_t *conn,
                                char **headers_out, size_t max_headerlen,
                                char **body_out, size_t *body_used,
                                size_t max_bodylen, int force_complete);
 
-int connection_wants_to_flush(connection_t *conn);
-int connection_outbuf_too_full(connection_t *conn);
-int connection_handle_write(connection_t *conn, int force);
-int connection_flush(connection_t *conn);
+int connection_wants_to_flush(struct connection_t *conn);
+int connection_outbuf_too_full(struct connection_t *conn);
+int connection_handle_write(struct connection_t *conn, int force);
+int connection_flush(struct connection_t *conn);
 
 MOCK_DECL(void, connection_write_to_buf_impl_,
-          (const char *string, size_t len, connection_t *conn, int zlib));
+          (const char *string, size_t len, struct connection_t *conn,
+           int zlib));
 /* DOCDOC connection_write_to_buf */
 static void connection_buf_add(const char *string, size_t len,
-                                    connection_t *conn);
+                                    struct connection_t *conn);
 void connection_dir_buf_add(const char *string, size_t len,
-                            dir_connection_t *dir_conn, int done);
+                            struct dir_connection_t *dir_conn, int done);
 static inline void
-connection_buf_add(const char *string, size_t len, connection_t *conn)
+connection_buf_add(const char *string, size_t len, struct connection_t *conn)
 {
   connection_write_to_buf_impl_(string, len, conn, 0);
 }
 void connection_buf_add_compress(const char *string, size_t len,
-                                 dir_connection_t *conn, int done);
-void connection_buf_add_buf(connection_t *conn, struct buf_t *buf);
-
-size_t connection_get_inbuf_len(connection_t *conn);
-size_t connection_get_outbuf_len(connection_t *conn);
-connection_t *connection_get_by_global_id(uint64_t id);
-
-connection_t *connection_get_by_type(int type);
-MOCK_DECL(connection_t *,connection_get_by_type_nonlinked,(int type));
-MOCK_DECL(connection_t *,connection_get_by_type_addr_port_purpose,(int type,
-                                                  const tor_addr_t *addr,
-                                                  uint16_t port, int purpose));
-connection_t *connection_get_by_type_state(int type, int state);
-connection_t *connection_get_by_type_state_rendquery(int type, int state,
+                                 struct dir_connection_t *conn, int done);
+void connection_buf_add_buf(struct connection_t *conn, struct buf_t *buf);
+
+size_t connection_get_inbuf_len(struct connection_t *conn);
+size_t connection_get_outbuf_len(struct connection_t *conn);
+struct connection_t *connection_get_by_global_id(uint64_t id);
+
+struct connection_t *connection_get_by_type(int type);
+MOCK_DECL(struct connection_t *,connection_get_by_type_nonlinked,(int type));
+MOCK_DECL(struct connection_t *,connection_get_by_type_addr_port_purpose,
+                                               (int type,
+                                                const struct tor_addr_t *addr,
+                                                uint16_t port, int purpose));
+struct connection_t *connection_get_by_type_state(int type, int state);
+struct connection_t *connection_get_by_type_state_rendquery(
+                                                     int type, int state,
                                                      const char *rendquery);
-smartlist_t *connection_list_by_type_state(int type, int state);
-smartlist_t *connection_list_by_type_purpose(int type, int purpose);
-smartlist_t *connection_dir_list_by_purpose_and_resource(
+struct smartlist_t *connection_list_by_type_state(int type, int state);
+struct smartlist_t *connection_list_by_type_purpose(int type, int purpose);
+struct smartlist_t *connection_dir_list_by_purpose_and_resource(
                                                   int purpose,
                                                   const char *resource);
-smartlist_t *connection_dir_list_by_purpose_resource_and_state(
+struct smartlist_t *connection_dir_list_by_purpose_resource_and_state(
                                                   int purpose,
                                                   const char *resource,
                                                   int state);
@@ -273,7 +301,7 @@ connection_dir_count_by_purpose_and_resource(
                                              int purpose,
                                              const char *resource)
 {
-  smartlist_t *conns = connection_dir_list_by_purpose_and_resource(
+  struct smartlist_t *conns = connection_dir_list_by_purpose_and_resource(
                                                                    purpose,
                                                                    resource);
   CONN_LEN_AND_FREE_TEMPLATE(conns);
@@ -287,7 +315,7 @@ connection_dir_count_by_purpose_resource_and_state(
                                                    const char *resource,
                                                    int state)
 {
-  smartlist_t *conns =
+  struct smartlist_t *conns =
     connection_dir_list_by_purpose_resource_and_state(
                                                       purpose,
                                                       resource,
@@ -297,26 +325,26 @@ connection_dir_count_by_purpose_resource_and_state(
 
 #undef CONN_LEN_AND_FREE_TEMPLATE
 
-int any_other_active_or_conns(const or_connection_t *this_conn);
+int any_other_active_or_conns(const struct or_connection_t *this_conn);
 
 /* || 0 is for -Wparentheses-equality (-Wall?) appeasement under clang */
 #define connection_speaks_cells(conn) (((conn)->type == CONN_TYPE_OR) || 0)
-int connection_is_listener(connection_t *conn);
-int connection_state_is_open(connection_t *conn);
-int connection_state_is_connecting(connection_t *conn);
+int connection_is_listener(struct connection_t *conn);
+int connection_state_is_open(struct connection_t *conn);
+int connection_state_is_connecting(struct connection_t *conn);
 
 char *alloc_http_authenticator(const char *authenticator);
 
-void assert_connection_ok(connection_t *conn, time_t now);
-int connection_or_nonopen_was_started_here(or_connection_t *conn);
+void assert_connection_ok(struct connection_t *conn, time_t now);
+int connection_or_nonopen_was_started_here(struct or_connection_t *conn);
 void connection_dump_buffer_mem_stats(int severity);
 
 MOCK_DECL(void, clock_skew_warning,
-          (const connection_t *conn, long apparent_skew, int trusted,
+          (const struct connection_t *conn, long apparent_skew, int trusted,
            log_domain_mask_t domain, const char *received,
            const char *source));
 
-int connection_is_moribund(connection_t *conn);
+int connection_is_moribund(struct connection_t *conn);
 void connection_check_oos(int n_socks, int failed);
 
 /** Execute the statement <b>stmt</b>, which may log events concerning the
@@ -338,18 +366,18 @@ void connection_check_oos(int n_socks, int failed);
   STMT_END
 
 #ifdef CONNECTION_PRIVATE
-STATIC void connection_free_minimal(connection_t *conn);
+STATIC void connection_free_minimal(struct connection_t *conn);
 
 /* Used only by connection.c and test*.c */
 MOCK_DECL(STATIC int,connection_connect_sockaddr,
-                                            (connection_t *conn,
+                                            (struct connection_t *conn,
                                              const struct sockaddr *sa,
                                              socklen_t sa_len,
                                              const struct sockaddr *bindaddr,
                                              socklen_t bindaddr_len,
                                              int *socket_error));
-MOCK_DECL(STATIC void, kill_conn_list_for_oos, (smartlist_t *conns));
-MOCK_DECL(STATIC smartlist_t *, pick_oos_victims, (int n));
+MOCK_DECL(STATIC void, kill_conn_list_for_oos, (struct smartlist_t *conns));
+MOCK_DECL(STATIC struct smartlist_t *, pick_oos_victims, (int n));
 
 #endif /* defined(CONNECTION_PRIVATE) */
 



_______________________________________________
tor-commits mailing list
tor-commits@xxxxxxxxxxxxxxxxxxxx
https://lists.torproject.org/cgi-bin/mailman/listinfo/tor-commits