tor
master
|
Header file for connection.c. More...
#include "buffers.h"
Go to the source code of this file.
Macros | |
#define | connection_free(conn) FREE_AND_NULL(connection_t, connection_free_, (conn)) |
#define | connection_mark_for_close(c) connection_mark_for_close_((c), __LINE__, SHORT_FILE__) |
#define | connection_mark_for_close_internal(c) connection_mark_for_close_internal_((c), __LINE__, SHORT_FILE__) |
#define | connection_mark_and_flush_internal_(c, line, file) |
#define | connection_mark_and_flush_internal(c) connection_mark_and_flush_internal_((c), __LINE__, SHORT_FILE__) |
#define | connection_mark_and_flush_(c, line, file) |
#define | connection_mark_and_flush(c) connection_mark_and_flush_((c), __LINE__, SHORT_FILE__) |
#define | MAX_SOCKS5_AUTH_FIELD_SIZE 255 |
#define | MAX_SOCKS5_AUTH_SIZE_TOTAL 2*MAX_SOCKS5_AUTH_FIELD_SIZE |
#define | CONN_LEN_AND_FREE_TEMPLATE(sl) |
#define | connection_speaks_cells(conn) (((conn)->type == CONN_TYPE_OR) || 0) |
Functions | |
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)) | |
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, int line, const char *file) |
MOCK_DECL (void, connection_mark_for_close_internal_,(connection_t *conn, int line, const char *file)) | |
void | connection_expire_held_open (void) |
int | connection_connect (connection_t *conn, const char *address, const tor_addr_t *addr, uint16_t port, int *socket_error) |
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, const connection_t *conn) |
int | retry_all_listeners (smartlist_t *replaced_conns, 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) |
void | connection_bucket_init (void) |
void | connection_bucket_adjust (const 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, 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) |
MOCK_DECL (void, connection_write_to_buf_impl_,(const char *string, size_t len, connection_t *conn, int zlib)) | |
void | connection_buf_add_buf (connection_t *conn, buf_t *buf) |
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_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, 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 (int purpose, const char *resource) |
smartlist_t * | connection_dir_list_by_purpose_resource_and_state (int purpose, const char *resource, int state) |
int | any_other_active_or_conns (const or_connection_t *this_conn) |
int | connection_is_listener (connection_t *conn) |
int | connection_state_is_open (connection_t *conn) |
int | connection_state_is_connecting (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 | connection_dump_buffer_mem_stats (int severity) |
MOCK_DECL (void, clock_skew_warning,(const connection_t *conn, long apparent_skew, int trusted, log_domain_mask_t domain, const char *received, const char *source)) | |
void | connection_check_oos (int n_socks, int failed) |
Header file for connection.c.
#define CONN_LEN_AND_FREE_TEMPLATE | ( | sl | ) |
#define connection_mark_and_flush_ | ( | c, | |
line, | |||
file | |||
) |
Mark 'c' for close, but try to hold it open until all the data is written.
#define connection_mark_and_flush_internal_ | ( | c, | |
line, | |||
file | |||
) |
Mark 'c' for close, but try to hold it open until all the data is written. Use the _internal versions of connection_mark_for_close; this should be called when you either are sure that if this is an or_connection_t the controlling channel has been notified (e.g. with 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.
#define MAX_SOCKS5_AUTH_FIELD_SIZE 255 |
Maximum size of information that we can fit into SOCKS5 username or password fields.
#define MAX_SOCKS5_AUTH_SIZE_TOTAL 2*MAX_SOCKS5_AUTH_FIELD_SIZE |
Total maximum size of information that we can fit into SOCKS5 username and password fields.
char* alloc_http_authenticator | ( | const char * | authenticator | ) |
Allocates a base64'ed authenticator for use in http or https auth, based on the input string authenticator. Returns it if success, else returns NULL.
int any_other_active_or_conns | ( | const or_connection_t * | this_conn | ) |
Return 1 if there are any active OR connections apart from this_conn.
We use this to guess if we should tell the controller that we didn't manage to connect to any of our bridges.
void assert_connection_ok | ( | connection_t * | conn, |
time_t | now | ||
) |
Verify that connection conn has all of its invariants correct. Trigger an assert if anything is invalid.
int conn_listener_type_supports_af_unix | ( | int | type | ) |
Return true iff the provided connection listener type supports AF_UNIX sockets.
const char* conn_state_to_string | ( | int | type, |
int | state | ||
) |
Return the human-readable name for the connection state state for the connection type type
const char* conn_type_to_string | ( | int | type | ) |
Return the human-readable name for the connection type type
void connection_about_to_close_connection | ( | connection_t * | conn | ) |
Called when we're about to finally unlink and free a connection: perform necessary accounting and cleanup
void connection_bucket_adjust | ( | const or_options_t * | options | ) |
Update the global connection bucket settings to a new value.
void connection_bucket_init | ( | void | ) |
Initialize the global buckets to the values configured in the options
ssize_t connection_bucket_write_limit | ( | connection_t * | conn, |
time_t | now | ||
) |
How many bytes at most can we write onto this connection?
void connection_buf_add_buf | ( | connection_t * | conn, |
buf_t * | buf | ||
) |
Add all bytes from buf to conn's outbuf, draining them from buf. (If the connection is marked and will soon be closed, nothing is drained.)
int connection_buf_get_bytes | ( | char * | string, |
size_t | len, | ||
connection_t * | conn | ||
) |
A pass-through to fetch_from_buf.
int connection_buf_get_line | ( | connection_t * | conn, |
char * | data, | ||
size_t * | data_len | ||
) |
As buf_get_line(), but read from a connection's input buffer.
void connection_check_oos | ( | int | n_socks, |
int | failed | ||
) |
Out-of-Sockets handler; n_socks is the current number of open sockets, and failed is non-zero if a socket exhaustion related error immediately preceded this call. This is where to do circuit-killing heuristics as needed.
void connection_close_immediate | ( | connection_t * | conn | ) |
Close the underlying socket for conn, so we don't try to flush it. Must be used in conjunction with (right before) connection_mark_for_close().
int connection_connect | ( | connection_t * | conn, |
const char * | address, | ||
const tor_addr_t * | addr, | ||
uint16_t | port, | ||
int * | socket_error | ||
) |
Take conn, make a nonblocking socket; try to connect to addr:port (port arrives in host order). If fail, return -1 and if applicable put your best guess about errno into *socket_error. Else assign s to conn->s: if connected return 1, if EAGAIN return 0.
addr:port can be different to conn->addr:conn->port if connecting through a proxy.
address is used to make the logs useful.
On success, add conn to the list of polled connections.
void connection_consider_empty_read_buckets | ( | connection_t * | conn | ) |
If we have exhausted our global buckets, or the buckets for conn, stop reading.
void connection_consider_empty_write_buckets | ( | connection_t * | conn | ) |
If we have exhausted our global buckets, or the buckets for conn, stop writing.
smartlist_t* connection_dir_list_by_purpose_and_resource | ( | int | purpose, |
const char * | resource | ||
) |
Return a list of directory connections that are fetching the item described by purpose/resource. If there are none, return an empty list. This list must be freed using smartlist_free, but the pointers in it must not be freed. Note that this list should not be cached, as the pointers in it can be freed if their connections close.
smartlist_t* connection_dir_list_by_purpose_resource_and_state | ( | int | purpose, |
const char * | resource, | ||
int | state | ||
) |
Return a list of directory connections that are fetching the item described by purpose/resource/state. If there are none, return an empty list. This list must be freed using smartlist_free, but the pointers in it must not be freed. Note that this list should not be cached, as the pointers in it can be freed if their connections close.
void connection_dump_buffer_mem_stats | ( | int | severity | ) |
Log how many bytes are used by buffers of different kinds and sizes.
void connection_expire_held_open | ( | void | ) |
Find each connection that has hold_open_until_flushed set to 1 but hasn't written in the past 15 seconds, and set hold_open_until_flushed to 0. This means it will get cleaned up in the next loop through close_if_marked() in main.c.
int connection_fetch_from_buf_http | ( | connection_t * | conn, |
char ** | headers_out, | ||
size_t | max_headerlen, | ||
char ** | body_out, | ||
size_t * | body_used, | ||
size_t | max_bodylen, | ||
int | force_complete | ||
) |
As fetch_from_buf_http, but fetches from a connection's input buffer_t as appropriate.
int connection_flush | ( | connection_t * | conn | ) |
Try to flush data that's waiting for a write on conn. Return -1 on failure, 0 on success.
Don't use this function for regular writing; the buffers system should be good enough at scheduling writes there. Instead, this function is for cases when we're about to exit or something and we want to report it right away.
void connection_free_all | ( | void | ) |
Call connection_free_minimal() on every connection in our array, and release all storage held by connection.c.
Don't do the checks in connection_free(), because they will fail.
connection_t* connection_get_by_global_id | ( | uint64_t | id | ) |
Return the stream with id id if it is not already marked for close.
connection_t* connection_get_by_type | ( | int | type | ) |
Return a connection of type type that is not marked for close.
connection_t* connection_get_by_type_state | ( | int | type, |
int | state | ||
) |
Return a connection of type type that is in state state, and that is not marked for close.
connection_t* connection_get_by_type_state_rendquery | ( | int | type, |
int | state, | ||
const char * | rendquery | ||
) |
Return a connection of type type that has rendquery equal to rendquery, and that is not marked for close. If state is non-zero, conn must be of that state too.
int connection_init_accepted_conn | ( | connection_t * | conn, |
const listener_connection_t * | listener | ||
) |
Initialize states for newly accepted connection conn.
If conn is an OR, start the TLS handshake.
If conn is a transparent AP, get its original destination and place it in circuit_wait.
The listener parameter is only used for AP connections.
int connection_is_listener | ( | connection_t * | conn | ) |
Return 1 if conn is a listener conn, else return 0.
void connection_link_connections | ( | connection_t * | conn_a, |
connection_t * | conn_b | ||
) |
Create a link between conn_a and conn_b.
void connection_mark_all_noncontrol_connections | ( | void | ) |
Mark every external connection not used for controllers for close.
void connection_mark_all_noncontrol_listeners | ( | void | ) |
Mark every listener of type other than CONTROL_LISTENER to be closed.
void connection_mark_for_close_ | ( | connection_t * | conn, |
int | line, | ||
const char * | file | ||
) |
Mark conn to be closed next time we loop through conn_close_if_marked() in main.c.
connection_t* connection_new | ( | int | type, |
int | socket_family | ||
) |
Allocate, initialize, and return a new connection_t subtype of type to make or receive connections of address family socket_family. The type should be one of the CONN_TYPE_* constants.
int connection_or_nonopen_was_started_here | ( | or_connection_t * | conn | ) |
Return 1 if we initiated this connection, or 0 if it started out as an incoming connection.
int connection_outbuf_too_full | ( | connection_t * | conn | ) |
Are there too many bytes on edge connection conn's outbuf to send back a relay-level sendme yet? Return 1 if so, 0 if not. Used by connection_edge_consider_sending_sendme().
int connection_proxy_connect | ( | connection_t * | conn, |
int | type | ||
) |
Write a proxy request of type (socks4, socks5, https) to conn for conn->addr:conn->port, authenticating with the auth details given in the configuration (if available). SOCKS 5 and HTTP CONNECT proxies support authentication.
Returns -1 if conn->addr is incompatible with the proxy protocol, and 0 otherwise.
Use connection_read_proxy_handshake() to complete the handshake.
void connection_read_bw_exhausted | ( | connection_t * | conn, |
bool | is_global_bw | ||
) |
Mark conn as needing to stop reading because bandwidth has been exhausted. If is_global_bw, it is closing because global bandwidth limit has been exhausted. Otherwise, it is closing because its own bandwidth limit has been exhausted.
int connection_read_proxy_handshake | ( | connection_t * | conn | ) |
Call this from connection_*_process_inbuf() to advance the proxy handshake.
No matter what proxy protocol is used, if this function returns 1, the handshake is complete, and the data remaining on inbuf may contain the start of the communication with the requested server.
Returns 0 if the current buffer contains an incomplete response, and -1 on error.
int connection_state_is_connecting | ( | connection_t * | conn | ) |
Return 1 if conn is in 'connecting' state, else return 0.
int connection_state_is_open | ( | connection_t * | conn | ) |
Return 1 if conn is in state "open" and is not marked for close, else return 0.
int connection_wants_to_flush | ( | connection_t * | conn | ) |
Return conn->outbuf_flushlen: how many bytes conn wants to flush from its outbuf.
void connection_write_bw_exhausted | ( | connection_t * | conn, |
bool | is_global_bw | ||
) |
Mark conn as needing to stop reading because write bandwidth has been exhausted. If is_global_bw, it is closing because global bandwidth limit has been exhausted. Otherwise, it is closing because its own bandwidth limit has been exhausted.
control_connection_t* control_connection_new | ( | int | socket_family | ) |
Allocate and return a new control_connection_t, initialized as by connection_init().
dir_connection_t* dir_connection_new | ( | int | socket_family | ) |
Allocate and return a new dir_connection_t, initialized as by connection_init().
edge_connection_t* edge_connection_new | ( | int | type, |
int | socket_family | ||
) |
Allocate and return a new edge_connection_t, initialized as by connection_init().
entry_connection_t* entry_connection_new | ( | int | type, |
int | socket_family | ||
) |
Allocate and return a new entry_connection_t, initialized as by connection_init().
Allocate space to store the socks_request.
int get_proxy_addrport | ( | tor_addr_t * | addr, |
uint16_t * | port, | ||
int * | proxy_type, | ||
const connection_t * | conn | ||
) |
Fills addr and port with the details of the global proxy server we are using. conn contains the connection we are using the proxy for.
Return 0 on success, -1 on failure.
int global_write_bucket_low | ( | connection_t * | conn, |
size_t | attempt, | ||
int | priority | ||
) |
Return 1 if the global write buckets are low enough that we shouldn't send attempt bytes of low-priority directory stuff out to conn. Else return 0.
Priority was 1 for v1 requests (directories and running-routers), and 2 for v2 requests and later (statuses and descriptors).
There are a lot of parameters we could use here:
listener_connection_t* listener_connection_new | ( | int | type, |
int | socket_family | ||
) |
Allocate and return a new listener_connection_t, initialized as by connection_init().
void log_failed_proxy_connection | ( | connection_t * | conn | ) |
Log a failed connection to a proxy server. conn is the connection we use the proxy server for.
or_connection_t* or_connection_new | ( | int | type, |
int | socket_family | ||
) |
Allocate and return a new or_connection_t, initialized as by connection_init().
Initialize active_circuit_pqueue.
Set active_circuit_pqueue_last_recalibrated to current cell_ewma tick.
int retry_all_listeners | ( | smartlist_t * | replaced_conns, |
smartlist_t * | new_conns, | ||
int | close_all_noncontrol | ||
) |
Launch listeners for each port you should have open. Only launch listeners who are not already open, and only close listeners we no longer want.
Add all old conns that should be closed to replaced_conns. Add all new connections to new_conns.
If close_all_noncontrol is true, then we only open control listeners, and we close all other listeners.