tor  0.4.2.1-alpha-dev
Macros | Typedefs | Enumerations | Functions
connection_edge.h File Reference
#include "lib/testsupport/testsupport.h"
#include "feature/hs/hs_service.h"

Go to the source code of this file.

Macros

#define EXIT_CONN_STATE_MIN_   1
 
#define EXIT_CONN_STATE_RESOLVING   1
 
#define EXIT_CONN_STATE_CONNECTING   2
 
#define EXIT_CONN_STATE_OPEN   3
 
#define EXIT_CONN_STATE_RESOLVEFAILED   4
 
#define EXIT_CONN_STATE_MAX_   4
 
#define AP_CONN_STATE_MIN_   5
 
#define AP_CONN_STATE_SOCKS_WAIT   5
 
#define AP_CONN_STATE_RENDDESC_WAIT   6
 
#define AP_CONN_STATE_CONTROLLER_WAIT   7
 
#define AP_CONN_STATE_CIRCUIT_WAIT   8
 
#define AP_CONN_STATE_CONNECT_WAIT   9
 
#define AP_CONN_STATE_RESOLVE_WAIT   10
 
#define AP_CONN_STATE_OPEN   11
 
#define AP_CONN_STATE_NATD_WAIT   12
 
#define AP_CONN_STATE_HTTP_CONNECT_WAIT   13
 
#define AP_CONN_STATE_MAX_   13
 
#define EXIT_PURPOSE_MIN_   1
 
#define EXIT_PURPOSE_CONNECT   1
 
#define EXIT_PURPOSE_RESOLVE   2
 
#define EXIT_PURPOSE_MAX_   2
 
#define AP_CONN_STATE_IS_UNATTACHED(s)   ((s) <= AP_CONN_STATE_CIRCUIT_WAIT || (s) == AP_CONN_STATE_NATD_WAIT)
 
#define connection_mark_unattached_ap(conn, endreason)   connection_mark_unattached_ap_((conn), (endreason), __LINE__, SHORT_FILE__)
 
#define connection_ap_mark_as_pending_circuit(c)   connection_ap_mark_as_pending_circuit_((c), __FILE__, __LINE__)
 
#define CONNECTION_AP_EXPECT_NONPENDING(c)
 
#define half_edge_free(he)   FREE_AND_NULL(half_edge_t, half_edge_free_, (he))
 
Begin-cell flags

These flags are used in RELAY_BEGIN cells to change the default behavior of the cell.

#define BEGIN_FLAG_IPV6_OK   (1u<<0)
 
#define BEGIN_FLAG_IPV4_NOT_OK   (1u<<1)
 
#define BEGIN_FLAG_IPV6_PREFERRED   (1u<<2)
 

Typedefs

typedef enum hostname_type_t hostname_type_t
 

Enumerations

enum  hostname_type_t {
  NORMAL_HOSTNAME, ONION_V2_HOSTNAME, ONION_V3_HOSTNAME, EXIT_HOSTNAME,
  BAD_HOSTNAME
}
 

Functions

edge_connection_tTO_EDGE_CONN (connection_t *)
 
entry_connection_tTO_ENTRY_CONN (connection_t *)
 
entry_connection_tEDGE_TO_ENTRY_CONN (edge_connection_t *)
 
 MOCK_DECL (void, connection_mark_unattached_ap_,(entry_connection_t *conn, int endreason, int line, const char *file))
 
int connection_edge_reached_eof (edge_connection_t *conn)
 
int connection_edge_process_inbuf (edge_connection_t *conn, int package_partial)
 
int connection_edge_destroy (circid_t circ_id, edge_connection_t *conn)
 
int connection_edge_end (edge_connection_t *conn, uint8_t reason)
 
int connection_edge_end_errno (edge_connection_t *conn)
 
void connection_edge_end_close (edge_connection_t *conn, uint8_t reason)
 
int connection_edge_flushed_some (edge_connection_t *conn)
 
int connection_edge_finished_flushing (edge_connection_t *conn)
 
int connection_edge_finished_connecting (edge_connection_t *conn)
 
void connection_ap_about_to_close (entry_connection_t *edge_conn)
 
void connection_exit_about_to_close (edge_connection_t *edge_conn)
 
 MOCK_DECL (int, connection_ap_handshake_send_begin,(entry_connection_t *ap_conn))
 
int connection_ap_handshake_send_resolve (entry_connection_t *ap_conn)
 
entry_connection_tconnection_ap_make_link (connection_t *partner, char *address, uint16_t port, const char *digest, int session_group, int isolation_flags, int use_begindir, int want_onehop)
 
void connection_ap_handshake_socks_reply (entry_connection_t *conn, char *reply, size_t replylen, int endreason)
 
 MOCK_DECL (void, connection_ap_handshake_socks_resolved,(entry_connection_t *conn, int answer_type, size_t answer_len, const uint8_t *answer, int ttl, time_t expires))
 
void connection_ap_handshake_socks_resolved_addr (entry_connection_t *conn, const tor_addr_t *answer, int ttl, time_t expires)
 
int connection_exit_begin_conn (cell_t *cell, circuit_t *circ)
 
int connection_exit_begin_resolve (cell_t *cell, or_circuit_t *circ)
 
void connection_exit_connect (edge_connection_t *conn)
 
int connection_edge_is_rendezvous_stream (const edge_connection_t *conn)
 
int connection_ap_can_use_exit (const entry_connection_t *conn, const node_t *exit)
 
void connection_ap_expire_beginning (void)
 
void connection_ap_rescan_and_attach_pending (void)
 
void connection_ap_attach_pending (int retry)
 
void connection_ap_mark_as_pending_circuit_ (entry_connection_t *entry_conn, const char *file, int line)
 
void connection_ap_mark_as_non_pending_circuit (entry_connection_t *entry_conn)
 
void connection_ap_mark_as_waiting_for_renddesc (entry_connection_t *entry_conn)
 
void connection_ap_fail_onehop (const char *failed_digest, cpath_build_state_t *build_state)
 
void circuit_discard_optional_exit_enclaves (extend_info_t *info)
 
int connection_ap_detach_retriable (entry_connection_t *conn, origin_circuit_t *circ, int reason)
 
int connection_ap_process_transparent (entry_connection_t *conn)
 
int address_is_invalid_destination (const char *address, int client)
 
 MOCK_DECL (int, connection_ap_rewrite_and_attach_if_allowed,(entry_connection_t *conn, origin_circuit_t *circ, crypt_path_t *cpath))
 
int connection_ap_handshake_rewrite_and_attach (entry_connection_t *conn, origin_circuit_t *circ, crypt_path_t *cpath)
 
hostname_type_t parse_extended_hostname (char *address)
 
int connection_edge_compatible_with_circuit (const entry_connection_t *conn, const origin_circuit_t *circ)
 
int connection_edge_update_circuit_isolation (const entry_connection_t *conn, origin_circuit_t *circ, int dry_run)
 
void circuit_clear_isolation (origin_circuit_t *circ)
 
streamid_t get_unique_stream_id_by_circ (origin_circuit_t *circ)
 
void connection_edge_free_all (void)
 
void connection_ap_warn_and_unmark_if_pending_circ (entry_connection_t *entry_conn, const char *where)
 
int connection_half_edge_is_valid_data (const smartlist_t *half_conns, streamid_t stream_id)
 
int connection_half_edge_is_valid_sendme (const smartlist_t *half_conns, streamid_t stream_id)
 
int connection_half_edge_is_valid_connected (const smartlist_t *half_conns, streamid_t stream_id)
 
int connection_half_edge_is_valid_end (smartlist_t *half_conns, streamid_t stream_id)
 
int connection_half_edge_is_valid_resolved (smartlist_t *half_conns, streamid_t stream_id)
 
size_t half_streams_get_total_allocation (void)
 
void half_edge_free_ (struct half_edge_t *he)
 

Detailed Description

Header file for connection_edge.c.

Definition in file connection_edge.h.

Macro Definition Documentation

◆ AP_CONN_STATE_CIRCUIT_WAIT

#define AP_CONN_STATE_CIRCUIT_WAIT   8

State for a SOCKS connection: waiting for a completed circuit.

Definition at line 45 of file connection_edge.h.

◆ AP_CONN_STATE_CONNECT_WAIT

#define AP_CONN_STATE_CONNECT_WAIT   9

State for a SOCKS connection: sent BEGIN, waiting for CONNECTED.

Definition at line 47 of file connection_edge.h.

◆ AP_CONN_STATE_CONTROLLER_WAIT

#define AP_CONN_STATE_CONTROLLER_WAIT   7

The controller will attach this connection to a circuit; it isn't our job to do so.

Definition at line 43 of file connection_edge.h.

◆ AP_CONN_STATE_HTTP_CONNECT_WAIT

#define AP_CONN_STATE_HTTP_CONNECT_WAIT   13

State for an HTTP tunnel: waiting for an HTTP CONNECT command.

Definition at line 56 of file connection_edge.h.

◆ AP_CONN_STATE_IS_UNATTACHED

#define AP_CONN_STATE_IS_UNATTACHED (   s)    ((s) <= AP_CONN_STATE_CIRCUIT_WAIT || (s) == AP_CONN_STATE_NATD_WAIT)

True iff the AP_CONN_STATE_* value s means that the corresponding edge connection is not attached to any circuit.

Definition at line 68 of file connection_edge.h.

◆ AP_CONN_STATE_NATD_WAIT

#define AP_CONN_STATE_NATD_WAIT   12

State for a transparent natd connection: waiting for original destination.

Definition at line 54 of file connection_edge.h.

◆ AP_CONN_STATE_OPEN

#define AP_CONN_STATE_OPEN   11

State for a SOCKS connection: ready to send and receive.

Definition at line 51 of file connection_edge.h.

◆ AP_CONN_STATE_RENDDESC_WAIT

#define AP_CONN_STATE_RENDDESC_WAIT   6

State for a SOCKS connection: got a y.onion URL; waiting to receive rendezvous descriptor.

Definition at line 40 of file connection_edge.h.

◆ AP_CONN_STATE_RESOLVE_WAIT

#define AP_CONN_STATE_RESOLVE_WAIT   10

State for a SOCKS connection: sent RESOLVE, waiting for RESOLVED.

Definition at line 49 of file connection_edge.h.

◆ AP_CONN_STATE_SOCKS_WAIT

#define AP_CONN_STATE_SOCKS_WAIT   5

State for a SOCKS connection: waiting for SOCKS request.

Definition at line 37 of file connection_edge.h.

◆ BEGIN_FLAG_IPV4_NOT_OK

#define BEGIN_FLAG_IPV4_NOT_OK   (1u<<1)

When this flag is set, the client DOES NOT support connecting to IPv4 addresses. (The sense of this flag is inverted from IPV6_OK, so that the old default behavior of Tor is equivalent to having all flags set to 0.)

Definition at line 214 of file connection_edge.h.

◆ BEGIN_FLAG_IPV6_OK

#define BEGIN_FLAG_IPV6_OK   (1u<<0)

When this flag is set, the client is willing to get connected to IPv6 addresses

Definition at line 209 of file connection_edge.h.

◆ BEGIN_FLAG_IPV6_PREFERRED

#define BEGIN_FLAG_IPV6_PREFERRED   (1u<<2)

When this flag is set, if we find both an IPv4 and an IPv6 address, we use the IPv6 address. Otherwise we use the IPv4 address.

Definition at line 217 of file connection_edge.h.

◆ CONNECTION_AP_EXPECT_NONPENDING

#define CONNECTION_AP_EXPECT_NONPENDING (   c)
Value:
do { \
log_warn(LD_BUG, "At %s:%d: %p was unexpectedly in circuit_wait.", \
__FILE__, __LINE__, (c)); \
connection_ap_mark_as_non_pending_circuit(c); \
} \
} while (0)
#define ENTRY_TO_CONN(c)
Definition: or.h:738
#define AP_CONN_STATE_CIRCUIT_WAIT
#define LD_BUG
Definition: log.h:84

Definition at line 133 of file connection_edge.h.

◆ EXIT_CONN_STATE_CONNECTING

#define EXIT_CONN_STATE_CONNECTING   2

State for an exit connection: waiting for connect() to finish.

Definition at line 27 of file connection_edge.h.

◆ EXIT_CONN_STATE_OPEN

#define EXIT_CONN_STATE_OPEN   3

State for an exit connection: open and ready to transmit data.

Definition at line 29 of file connection_edge.h.

◆ EXIT_CONN_STATE_RESOLVEFAILED

#define EXIT_CONN_STATE_RESOLVEFAILED   4

State for an exit connection: waiting to be removed.

Definition at line 31 of file connection_edge.h.

◆ EXIT_CONN_STATE_RESOLVING

#define EXIT_CONN_STATE_RESOLVING   1

State for an exit connection: waiting for response from DNS farm.

Definition at line 25 of file connection_edge.h.

◆ EXIT_PURPOSE_CONNECT

#define EXIT_PURPOSE_CONNECT   1

This exit stream wants to do an ordinary connect.

Definition at line 61 of file connection_edge.h.

◆ EXIT_PURPOSE_RESOLVE

#define EXIT_PURPOSE_RESOLVE   2

This exit stream wants to do a resolve (either normal or reverse).

Definition at line 63 of file connection_edge.h.

Typedef Documentation

◆ hostname_type_t

Possible return values for parse_extended_hostname.

Enumeration Type Documentation

◆ hostname_type_t

Possible return values for parse_extended_hostname.

Definition at line 159 of file connection_edge.h.

Function Documentation

◆ address_is_invalid_destination()

int address_is_invalid_destination ( const char *  address,
int  client 
)

Return 1 if address has funny characters in it like colons. Return 0 if it's fine, or if we're configured to allow it anyway. client should be true if we're using this address as a client; false if we're using it as a server.

Definition at line 1078 of file addressmap.c.

References tor_addr_parse().

Referenced by address_is_invalid_mapaddress_target(), and addressmap_register_auto().

◆ circuit_clear_isolation()

void circuit_clear_isolation ( origin_circuit_t circ)

Clear the isolation settings on circ.

This only works on an open circuit that has never had a stream attached to it, and whose isolation settings are hypothetical. (We set hypothetical isolation settings on circuits as we're launching them, so that we know whether they can handle more streams or whether we need to launch even more circuits. Once the circuit is open, if it turns out that we no longer have any streams to attach to it, we clear the isolation flags and data so that other streams can have a chance.)

Definition at line 4539 of file connection_edge.c.

References origin_circuit_t::isolation_any_streams_attached.

Referenced by circuit_try_clearing_isolation_state().

◆ circuit_discard_optional_exit_enclaves()

void circuit_discard_optional_exit_enclaves ( extend_info_t info)

A circuit failed to finish on its last hop info. If there are any streams waiting with this exit node in mind, but they don't absolutely require it, make them give up on it.

Definition at line 1448 of file connection_edge.c.

References AP_CONN_STATE_CIRCUIT_WAIT, CONN_TYPE_AP, and SMARTLIST_FOREACH_BEGIN.

◆ connection_ap_about_to_close()

void connection_ap_about_to_close ( entry_connection_t entry_conn)

Called when we're about to finally unlink and free an AP (client) connection: perform necessary accounting and cleanup

Definition at line 976 of file connection_edge.c.

References connection_edge_about_to_close(), ENTRY_TO_CONN, socks_request_t::has_finished, and entry_connection_t::socks_request.

Referenced by connection_about_to_close_connection().

◆ connection_ap_attach_pending()

void connection_ap_attach_pending ( int  retry)

Tell any AP streams that are listed as waiting for a new circuit to try again. If there is an available circuit for a stream, attach it. Otherwise, launch a new circuit.

If retry is false, only check the list if it contains at least one streams that we have not yet tried to attach to a circuit.

Definition at line 1239 of file connection_edge.c.

Referenced by circuit_try_attaching_streams().

◆ connection_ap_can_use_exit()

int connection_ap_can_use_exit ( const entry_connection_t conn,
const node_t exit_node 
)

Return 1 if router exit_node is likely to allow stream conn to exit from it, or 0 if it probably will not allow it. (We might be uncertain if conn's destination address has not yet been resolved.)

Definition at line 4245 of file connection_edge.c.

References entry_connection_t::chosen_exit_name, entry_connection_t::socks_request, and tor_assert().

Referenced by circuit_stream_is_being_handled().

◆ connection_ap_detach_retriable()

int connection_ap_detach_retriable ( entry_connection_t conn,
origin_circuit_t circ,
int  reason 
)

The AP connection conn has just failed while attaching or sending a BEGIN or resolving on circ, but another circuit might work. Detach the circuit, and either reattach it, launch a new circuit, tell the controller, or give up as appropriate.

Returns -1 on err, 1 on success, 0 on not-yet-sure.

Definition at line 1499 of file connection_edge.c.

References control_event_stream_status().

◆ connection_ap_expire_beginning()

void connection_ap_expire_beginning ( void  )

Find all general-purpose AP streams waiting for a response that sent their begin/resolve cell too long ago. Detach from their current circuit, and mark their current circuit as unsuitable for new streams. Then call connection_ap_handshake_attach_circuit() to attach to a new circuit (if available) or launch a new one.

For rendezvous streams, simply give up after SocksTimeout seconds (with no retry attempt).

Definition at line 1068 of file connection_edge.c.

References CONN_TYPE_AP, and SMARTLIST_FOREACH_BEGIN.

Referenced by second_elapsed_callback().

◆ connection_ap_fail_onehop()

void connection_ap_fail_onehop ( const char *  failed_digest,
cpath_build_state_t build_state 
)

Tell any AP streams that are waiting for a one-hop tunnel to failed_digest that they are going to fail.

Definition at line 1407 of file connection_edge.c.

References AP_CONN_STATE_CIRCUIT_WAIT, CONN_TYPE_AP, DIGEST_LEN, and SMARTLIST_FOREACH_BEGIN.

◆ connection_ap_handshake_rewrite_and_attach()

int connection_ap_handshake_rewrite_and_attach ( entry_connection_t conn,
origin_circuit_t circ,
crypt_path_t cpath 
)

Connection conn just finished its socks handshake, or the controller asked us to take care of it. If circ is defined, then that's where we'll want to attach it. Otherwise we have to figure it out ourselves.

First, parse whether it's a .exit address, remap it, and so on. Then if it's for a general circuit, try to attach it to a circuit (or launch one as needed), else if it's for a rendezvous circuit, fetch a rendezvous descriptor first (or attach/launch a circuit if the rendezvous descriptor is already here and fresh enough).

The stream will exit from the hop indicated by cpath, or from the last hop in circ's cpath if cpath is NULL.

Definition at line 1990 of file connection_edge.c.

References ENTRY_TO_CONN, and entry_connection_t::socks_request.

◆ connection_ap_handshake_send_resolve()

int connection_ap_handshake_send_resolve ( entry_connection_t ap_conn)

Write a relay resolve cell, using destaddr and destport from ap_conn's socks_request field, and send it down circ.

If ap_conn is broken, mark it for close and return -1. Else return 0.

Definition at line 3181 of file connection_edge.c.

References AP_CONN_STATE_CIRCUIT_WAIT, CIRCUIT_PURPOSE_C_GENERAL, socks_request_t::command, CONN_TYPE_AP, get_unique_stream_id_by_circ(), edge_connection_t::on_circuit, circuit_t::purpose, REVERSE_LOOKUP_NAME_BUF_LEN, entry_connection_t::socks_request, connection_t::state, edge_connection_t::stream_id, TO_CONN, TO_ORIGIN_CIRCUIT(), tor_assert(), and connection_t::type.

Referenced by connection_ap_handshake_attach_chosen_circuit().

◆ connection_ap_handshake_socks_reply()

void connection_ap_handshake_socks_reply ( entry_connection_t conn,
char *  reply,
size_t  replylen,
int  endreason 
)

Send a socks reply to stream conn, using the appropriate socks version, etc, and mark conn as completed with SOCKS handshaking.

If reply is defined, then write replylen bytes of it to conn and return, else reply based on endreason (one of END_STREAM_REASON_*). If reply is undefined, endreason can't be 0 or REASON_DONE. Send endreason to the controller, if appropriate.

Definition at line 3519 of file connection_edge.c.

◆ connection_ap_handshake_socks_resolved_addr()

void connection_ap_handshake_socks_resolved_addr ( entry_connection_t conn,
const tor_addr_t answer,
int  ttl,
time_t  expires 
)

As connection_ap_handshake_socks_resolved, but take a tor_addr_t to send as the answer.

Definition at line 3368 of file connection_edge.c.

References tor_addr_family(), and tor_addr_to_ipv4n().

◆ connection_ap_make_link()

entry_connection_t* connection_ap_make_link ( connection_t partner,
char *  address,
uint16_t  port,
const char *  digest,
int  session_group,
int  isolation_flags,
int  use_begindir,
int  want_onehop 
)

Make an AP connection_t linked to the connection_t partner. make a new linked connection pair, and attach one side to the conn, connection_add it, initialize it to circuit_wait, and call connection_ap_handshake_attach_circuit(conn) on it.

Return the newly created end of the linked connection pair, or -1 if error.

Definition at line 3271 of file connection_edge.c.

◆ connection_ap_mark_as_non_pending_circuit()

void connection_ap_mark_as_non_pending_circuit ( entry_connection_t entry_conn)

Mark entry_conn as no longer waiting for a circuit.

Definition at line 1365 of file connection_edge.c.

Referenced by connection_ap_mark_as_waiting_for_renddesc().

◆ connection_ap_mark_as_pending_circuit_()

void connection_ap_mark_as_pending_circuit_ ( entry_connection_t entry_conn,
const char *  fname,
int  lineno 
)

Mark entry_conn as needing to get attached to a circuit.

And entry_conn must be in AP_CONN_STATE_CIRCUIT_WAIT, should not already be pending a circuit. The circuit will get launched or the connection will get attached the next time we call connection_ap_attach_pending().

Definition at line 1321 of file connection_edge.c.

References AP_CONN_STATE_CIRCUIT_WAIT, ENTRY_TO_CONN, connection_t::magic, connection_t::marked_for_close, connection_t::state, and tor_assert().

◆ connection_ap_mark_as_waiting_for_renddesc()

void connection_ap_mark_as_waiting_for_renddesc ( entry_connection_t entry_conn)

Mark entry_conn as waiting for a rendezvous descriptor. This function will remove the entry connection from the waiting for a circuit list (pending_entry_connections).

This pattern is used across the code base because a connection in state AP_CONN_STATE_RENDDESC_WAIT must not be in the pending list.

Definition at line 1380 of file connection_edge.c.

References AP_CONN_STATE_RENDDESC_WAIT, connection_ap_mark_as_non_pending_circuit(), ENTRY_TO_CONN, and tor_assert().

◆ connection_ap_process_transparent()

int connection_ap_process_transparent ( entry_connection_t conn)

connection_init_accepted_conn() found a new trans AP conn. Get the original destination and send it to connection_ap_handshake_rewrite_and_attach().

Return -1 if an unexpected error with conn (and it should be marked for close), else return 0.

Definition at line 2712 of file connection_edge.c.

References socks_request_t::command, socks_request_t::has_finished, entry_connection_t::socks_request, and tor_assert().

◆ connection_ap_rescan_and_attach_pending()

void connection_ap_rescan_and_attach_pending ( void  )

As connection_ap_attach_pending, but first scans the entire connection array to see if any elements are missing.

Definition at line 1192 of file connection_edge.c.

◆ connection_edge_compatible_with_circuit()

int connection_edge_compatible_with_circuit ( const entry_connection_t conn,
const origin_circuit_t circ 
)

Return true iff none of the isolation flags and fields in conn should prevent it from being attached to circ.

Definition at line 4391 of file connection_edge.c.

References entry_port_cfg_t::isolation_flags, origin_circuit_t::isolation_flags_mixed, origin_circuit_t::isolation_values_set, entry_connection_t::original_dest_address, and entry_connection_t::socks_request.

Referenced by circuit_stream_is_being_handled().

◆ connection_edge_destroy()

int connection_edge_destroy ( circid_t  circ_id,
edge_connection_t conn 
)

This edge needs to be closed, because its circuit has closed. Mark it for close and return 0.

Definition at line 357 of file connection_edge.c.

References connection_t::marked_for_close.

◆ connection_edge_end()

int connection_edge_end ( edge_connection_t conn,
uint8_t  reason 
)

Send a relay end cell from stream conn down conn's circuit, and remember that we've done so. If this is not a client connection, set the relay end cell's reason for closing as reason.

Return -1 if this function has already been called on this conn, else return 0.

Definition at line 443 of file connection_edge.c.

References edge_connection_t::edge_has_sent_end, and RELAY_PAYLOAD_SIZE.

Referenced by connection_edge_end_close(), and inform_pending_connections().

◆ connection_edge_end_close()

void connection_edge_end_close ( edge_connection_t conn,
uint8_t  reason 
)

Send an END and mark for close the given edge connection conn using the given reason that has to be a stream reason.

Note: We don't unattached the AP connection (if applicable) because we don't want to flush the remaining data. This function aims at ending everything quickly regardless of the connection state.

This function can't fail and does nothing if conn is NULL.

Definition at line 4581 of file connection_edge.c.

References connection_edge_end().

◆ connection_edge_end_errno()

int connection_edge_end_errno ( edge_connection_t conn)

An error has just occurred on an operation on an edge connection conn. Extract the errno; convert it to an end reason, and send an appropriate relay end cell to the other end of the connection's circuit.

Definition at line 747 of file connection_edge.c.

References errno_to_stream_end_reason(), and tor_assert().

◆ connection_edge_finished_connecting()

int connection_edge_finished_connecting ( edge_connection_t edge_conn)

Connected handler for exit connections: start writing pending data, deliver 'CONNECTED' relay cells as appropriate, and check any pending data that may have been received.

Definition at line 900 of file connection_edge.c.

References CONN_TYPE_EXIT, EXIT_CONN_STATE_CONNECTING, connection_t::state, TO_CONN, tor_assert(), and connection_t::type.

Referenced by connection_finished_connecting().

◆ connection_edge_finished_flushing()

int connection_edge_finished_flushing ( edge_connection_t conn)

Connection conn has finished writing and has no bytes left on its outbuf.

If it's in state 'open', stop writing, consider responding with a sendme, and return. Otherwise, stop writing and return.

If conn is broken, mark it for close and return -1, else return 0.

Definition at line 788 of file connection_edge.c.

References AP_CONN_STATE_CIRCUIT_WAIT, AP_CONN_STATE_CONNECT_WAIT, AP_CONN_STATE_CONTROLLER_WAIT, AP_CONN_STATE_HTTP_CONNECT_WAIT, AP_CONN_STATE_NATD_WAIT, AP_CONN_STATE_OPEN, AP_CONN_STATE_RENDDESC_WAIT, AP_CONN_STATE_RESOLVE_WAIT, AP_CONN_STATE_SOCKS_WAIT, EXIT_CONN_STATE_OPEN, sendme_connection_edge_consider_sending(), connection_t::state, and tor_assert().

Referenced by connection_finished_flushing().

◆ connection_edge_flushed_some()

int connection_edge_flushed_some ( edge_connection_t conn)

We just wrote some data to conn; act appropriately.

(That is, if it's open, consider sending a stream-level sendme cell if we have just flushed enough.)

Definition at line 761 of file connection_edge.c.

References AP_CONN_STATE_OPEN, approx_time(), EXIT_CONN_STATE_OPEN, connection_t::linked, sendme_connection_edge_consider_sending(), and connection_t::state.

Referenced by connection_flushed_some().

◆ connection_edge_free_all()

void connection_edge_free_all ( void  )

Free all storage held in module-scoped variables for connection_edge.c

Definition at line 4593 of file connection_edge.c.

◆ connection_edge_is_rendezvous_stream()

int connection_edge_is_rendezvous_stream ( const edge_connection_t conn)

Return 1 if conn is a rendezvous stream, or 0 if it is a general stream.

Definition at line 4227 of file connection_edge.c.

References tor_assert().

Referenced by connection_exit_connect(), hs_client_note_connection_attempt_succeeded(), MOCK_IMPL(), and write_stream_target_to_buf().

◆ connection_edge_process_inbuf()

int connection_edge_process_inbuf ( edge_connection_t conn,
int  package_partial 
)

Handle new bytes on conn->inbuf based on state:

  • If it's waiting for socks info, try to read another step of the socks handshake out of conn->inbuf.
  • If it's waiting for the original destination, fetch it.
  • If it's open, then package more relay cells from the stream.
  • Else, leave the bytes on inbuf alone for now.

Mark and return -1 if there was an unexpected error with the conn, else return 0.

Definition at line 283 of file connection_edge.c.

References AP_CONN_STATE_SOCKS_WAIT, connection_ap_handshake_process_socks(), connection_t::state, and tor_assert().

Referenced by connection_process_inbuf().

◆ connection_edge_reached_eof()

int connection_edge_reached_eof ( edge_connection_t conn)

There was an EOF. Send an end and mark the connection for close.

Definition at line 249 of file connection_edge.c.

Referenced by connection_reached_eof().

◆ connection_edge_update_circuit_isolation()

int connection_edge_update_circuit_isolation ( const entry_connection_t conn,
origin_circuit_t circ,
int  dry_run 
)

If dry_run is false, update circ's isolation flags and fields to reflect having had conn attached to it, and return 0. Otherwise, if dry_run is true, then make no changes to circ, and return a bitfield of isolation flags that we would have to set in isolation_flags_mixed to add conn to circ, or -1 if circ has had no streams attached to it.

Definition at line 4461 of file connection_edge.c.

References entry_connection_t::original_dest_address, and entry_connection_t::socks_request.

◆ connection_exit_about_to_close()

void connection_exit_about_to_close ( edge_connection_t edge_conn)

Called when we're about to finally unlink and free an exit connection: perform necessary accounting and cleanup

Definition at line 1027 of file connection_edge.c.

References circuit_detach_stream(), circuit_get_by_edge_conn(), connection_dns_remove(), connection_edge_about_to_close(), EXIT_CONN_STATE_RESOLVING, connection_t::state, and TO_CONN.

◆ connection_exit_begin_conn()

int connection_exit_begin_conn ( cell_t cell,
circuit_t circ 
)

A relay 'begin' or 'begin_dir' cell has arrived, and either we are an exit hop for the circuit, or we are the origin and it is a rendezvous begin.

Launch a new exit connection and initialize things appropriately.

If it's a rendezvous stream, call connection_exit_connect() on it.

For general streams, call dns_resolve() on it first, and only call connection_exit_connect() if the dns answer is already known.

Note that we don't call connection_add() on the new stream! We wait for connection_exit_connect() to do that.

Return -(some circuit end reason) if we want to tear down circ. Else return 0.

Definition at line 3792 of file connection_edge.c.

References CIRCUIT_IS_ORIGIN, CIRCUIT_PURPOSE_S_REND_JOINED, origin_circuit_t::cpath, relay_header_t::length, cell_t::payload, crypt_path_t::prev, circuit_t::purpose, relay_header_unpack(), RELAY_PAYLOAD_SIZE, TO_OR_CIRCUIT(), TO_ORIGIN_CIRCUIT(), and tor_assert().

◆ connection_exit_begin_resolve()

int connection_exit_begin_resolve ( cell_t cell,
or_circuit_t circ 
)

Called when we receive a RELAY_COMMAND_RESOLVE cell 'cell' along the circuit circ; begin resolving the hostname, and (eventually) reply with a RESOLVED cell.

Definition at line 3985 of file connection_edge.c.

References connection_t::address, CONN_TYPE_EXIT, edge_connection_new(), relay_header_t::length, cell_t::payload, relay_header_unpack(), RELAY_PAYLOAD_SIZE, edge_connection_t::stream_id, relay_header_t::stream_id, and TO_CIRCUIT.

◆ connection_exit_connect()

void connection_exit_connect ( edge_connection_t edge_conn)

Connect to conn's specified addr and port. If it worked, conn has now been added to the connection_array.

Send back a connected cell. Include the resolved IP of the destination address, but only if it's a general exit stream. (Rendezvous streams must not reveal what IP they connected to.)

Definition at line 4055 of file connection_edge.c.

References connection_t::addr, connection_edge_is_rendezvous_stream(), my_exit_policy_rejects(), connection_t::port, and TO_CONN.

◆ connection_half_edge_is_valid_connected()

int connection_half_edge_is_valid_connected ( const smartlist_t half_conns,
streamid_t  stream_id 
)

Check if this stream_id is in a half-closed state. If so, check if it still has a connected cell pending, and decrement that window if so.

Return 1 if the connected window was not empty. Return 0 otherwise.

Definition at line 658 of file connection_edge.c.

References half_edge_t::connected_pending, and connection_half_edge_find_stream_id().

◆ connection_half_edge_is_valid_data()

int connection_half_edge_is_valid_data ( const smartlist_t half_conns,
streamid_t  stream_id 
)

Check if this stream_id is in a half-closed state. If so, check if it still has data cells pending, and decrement that window if so.

Return 1 if the data window was not empty. Return 0 otherwise.

Definition at line 632 of file connection_edge.c.

References connection_half_edge_find_stream_id(), and half_edge_t::data_pending.

◆ connection_half_edge_is_valid_end()

int connection_half_edge_is_valid_end ( smartlist_t half_conns,
streamid_t  stream_id 
)

Check if this stream_id is in a half-closed state. If so, remove it from the list. No other data should come after the END cell.

Return 1 if stream_id was in half-closed state. Return 0 otherwise.

Definition at line 709 of file connection_edge.c.

References connection_half_edge_compare_bsearch(), and smartlist_bsearch_idx().

Referenced by connection_half_edge_is_valid_resolved().

◆ connection_half_edge_is_valid_resolved()

int connection_half_edge_is_valid_resolved ( smartlist_t half_conns,
streamid_t  stream_id 
)

Streams that were used to send a RESOLVE cell are closed when they get the RESOLVED, without an end. So treat a RESOLVED just like an end, and remove from the list.

Definition at line 736 of file connection_edge.c.

References connection_half_edge_is_valid_end().

◆ connection_half_edge_is_valid_sendme()

int connection_half_edge_is_valid_sendme ( const smartlist_t half_conns,
streamid_t  stream_id 
)

Check if this stream_id is in a half-closed state. If so, check if it still has sendme cells pending, and decrement that window if so.

Return 1 if the sendme window was not empty. Return 0 otherwise.

Definition at line 684 of file connection_edge.c.

References connection_half_edge_find_stream_id(), and half_edge_t::sendmes_pending.

◆ get_unique_stream_id_by_circ()

streamid_t get_unique_stream_id_by_circ ( origin_circuit_t circ)

Iterate over the two bytes of stream_id until we get one that is not already in use; return it. Return 0 if can't get a unique stream_id.

Definition at line 2951 of file connection_edge.c.

References origin_circuit_t::next_stream_id.

Referenced by connection_ap_handshake_send_resolve(), and MOCK_IMPL().

◆ half_edge_free_()

void half_edge_free_ ( half_edge_t he)

Release space held by he

Definition at line 591 of file connection_edge.c.

References n_half_conns_allocated, and tor_free.

◆ half_streams_get_total_allocation()

size_t half_streams_get_total_allocation ( void  )

Return the number of bytes devoted to storing info on half-open streams.

Definition at line 601 of file connection_edge.c.

References n_half_conns_allocated.

◆ parse_extended_hostname()

hostname_type_t parse_extended_hostname ( char *  address)

If address is of the form "y.onion" with a well-formed handle y: Put a NUL after y, lower-case it, and return ONION_V2_HOSTNAME or ONION_V3_HOSTNAME depending on the HS version.

If address is of the form "x.y.onion" with a well-formed handle x: Drop "x.", put a NUL after y, lower-case it, and return ONION_V2_HOSTNAME or ONION_V3_HOSTNAME depending on the HS version.

If address is of the form "y.onion" with a badly-formed handle y: Return BAD_HOSTNAME and log a message.

If address is of the form "y.exit": Put a NUL after y and return EXIT_HOSTNAME.

Otherwise: Return NORMAL_HOSTNAME and change nothing.

Definition at line 4325 of file connection_edge.c.

◆ TO_EDGE_CONN()

edge_connection_t* TO_EDGE_CONN ( connection_t c)