1 files changed, 160 insertions, 33 deletions

diff --git a/src/or/or.h b/src/or/or.h
index 6ab44f29f7..0f4647fb21 100644
--- a/src/or/or.h
+++ b/src/or/or.h
@@ -16,8 +16,6 @@
 #include <sys/fcntl.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
-#include <sys/mman.h>
-#include <sys/stat.h>
 #include <sys/time.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
@@ -34,16 +32,24 @@
 #include "../common/config.h"
 #include "../common/key.h"
 #include "../common/log.h"
-#include "../common/onion.h"
 #include "../common/ss.h"
+#include "../common/version.h"
 
 #define MAXCONNECTIONS 200 /* upper bound on max connections.
 			      can be overridden by config file */
 
 #define MAX_BUF_SIZE (64*1024)
+#define DEFAULT_BANDWIDTH_OP 1
 
 #define ACI_TYPE_LOWER 0
 #define ACI_TYPE_HIGHER 1
+#define ACI_TYPE_BOTH 2
+
+/* bitvector of the roles that we might want to play. You can or (|) them together */
+#define ROLE_OR_LISTEN 1
+#define ROLE_OR_CONNECT_ALL 2
+#define ROLE_OP_LISTEN 4
+#define ROLE_AP_LISTEN 8
 
 #define CONN_TYPE_OP_LISTENER 1
 #define CONN_TYPE_OP 2
@@ -66,9 +72,9 @@
  * foo_CONN_STATE_bar_baz:
  * "I am acting as a bar, currently in stage baz of talking with a foo."
  */
-#define OR_CONN_STATE_OP_CONNECTING 0
+#define OR_CONN_STATE_OP_CONNECTING 0 /* an application proxy wants me to connect to this OR */
 #define OR_CONN_STATE_OP_SENDING_KEYS 1
-#define OR_CONN_STATE_CLIENT_CONNECTING 2
+#define OR_CONN_STATE_CLIENT_CONNECTING 2 /* I'm connecting to this OR as an OR */
 #define OR_CONN_STATE_CLIENT_SENDING_AUTH 3 /* sending address and info */
 #define OR_CONN_STATE_CLIENT_AUTH_WAIT 4 /* have sent address and info, waiting */
 #define OR_CONN_STATE_CLIENT_SENDING_NONCE 5 /* sending nonce, last piece of handshake */
@@ -90,12 +96,21 @@
 #define AP_CONN_STATE_OPEN 2
 
 #define CIRCUIT_STATE_OPEN_WAIT 0 /* receiving/processing the onion */
-#define CIRCUIT_STATE_OPEN 1 /* onion processed, ready to send data along the connection */
-#define CIRCUIT_STATE_CLOSE_WAIT1 2 /* sent two "destroy" signals, waiting for acks */
-#define CIRCUIT_STATE_CLOSE_WAIT2 3 /* received one ack, waiting for one more 
+#define CIRCUIT_STATE_OR_WAIT 1 /* I'm at the beginning of the path, my firsthop is still connecting */
+#define CIRCUIT_STATE_OPEN 2 /* onion processed, ready to send data along the connection */
+#define CIRCUIT_STATE_CLOSE_WAIT1 3 /* sent two "destroy" signals, waiting for acks */
+#define CIRCUIT_STATE_CLOSE_WAIT2 4 /* received one ack, waiting for one more 
 				       (or if just one was sent, waiting for that one */
 //#define CIRCUIT_STATE_CLOSE 4 /* both acks received, connection is dead */ /* NOT USED */
 
+/* available cipher functions */
+#define ONION_CIPHER_IDENTITY 0
+#define ONION_CIPHER_DES 1
+#define ONION_CIPHER_RC4 2
+
+/* default cipher function */
+#define ONION_DEFAULT_CIPHER ONION_CIPHER_DES
+
 typedef uint16_t aci_t;
 
 typedef struct
@@ -118,9 +133,7 @@ typedef struct
   size_t outbuflen;
   size_t outbuf_datalen;
 
-/* used by OP and App: */
-
-  uint16_t aci; /* anonymous connection identifier */
+//  uint16_t aci; /* anonymous connection identifier */
 
 /* used by OR and OP: */
 
@@ -142,10 +155,14 @@ typedef struct
   uint32_t addr; /* these two uniquely identify a router */
   uint16_t port;
 
-/* used by exit: */
+/* used by exit and ap: */
 
   ss_t ss; /* standard structure */
   int ss_received; /* size of ss, received so far */
+
+  char *dest_addr, *dest_port;
+  uint16_t dest_addr_len, dest_port_len;
+  uint16_t dest_addr_received, dest_port_received;
   
 /* used by OR, to keep state while connect()ing: Kludge. */
 
@@ -156,7 +173,7 @@ typedef struct
   uint32_t min;
   uint32_t max;
 
-  char *address; /* strdup into this, gets free_connection frees it */
+  char *address; /* strdup into this, because free_connection frees it */
   RSA *pkey; /* public RSA key for the other side */
 
   char nonce[8];
@@ -169,7 +186,9 @@ typedef struct
   char *address;
  
   uint32_t addr;
-  uint16_t port;
+  uint16_t or_port;
+  uint16_t op_port;
+  uint16_t ap_port;
  
   RSA *pkey; /* public RSA key */
  
@@ -187,6 +206,23 @@ typedef struct
   void *next;
 } routerinfo_t;
 
+typedef struct
+{ 
+  unsigned int forwf;
+  unsigned int backf;
+  char digest2[20]; /* second SHA output for onion_layer_t.keyseed */
+  char digest3[20]; /* third SHA output for onion_layer_t.keyseed */
+
+  /* IVs */
+  char f_iv[16];
+  char b_iv[16];
+
+  /* cipher contexts */
+  EVP_CIPHER_CTX f_ctx;
+  EVP_CIPHER_CTX b_ctx;
+  
+} crypt_path_t;
+
 /* per-anonymous-connection struct */
 typedef struct
 {
@@ -205,8 +241,8 @@ typedef struct
   unsigned char p_f; /* crypto functions */
   unsigned char n_f;
 
-  unsigned char p_key[128]; /* crypto keys */
-  unsigned char n_key[128];
+  unsigned char p_key[16]; /* crypto keys */
+  unsigned char n_key[16];
 
   unsigned char p_iv[16]; /* initialization vectors */
   unsigned char n_iv[16];
@@ -214,6 +250,9 @@ typedef struct
   EVP_CIPHER_CTX p_ctx; /* cipher context */
   EVP_CIPHER_CTX n_ctx;
 
+  crypt_path_t **cpath;
+  size_t cpathlen; 
+
   uint32_t expire; /* expiration time for the corresponding onion */
 
   int state;
@@ -225,6 +264,26 @@ typedef struct
   void *next;
 } circuit_t;
 
+typedef struct
+{ 
+  int zero:1;
+  int version:7;
+  int backf:4;
+  int forwf:4;
+  uint16_t port;
+  uint32_t addr;
+  time_t expire;
+  unsigned char keyseed[16];
+} onion_layer_t;
+
+typedef struct
+{ 
+  time_t expire;
+  char digest[20]; /* SHA digest of the onion */
+  void *prev;
+  void *next;
+} tracked_onion_t;
+
 
 
 
@@ -280,12 +339,14 @@ aci_t get_unique_aci_by_addr_port(uint32_t addr, uint16_t port, int aci_type);
 
 circuit_t *circuit_get_by_aci_conn(aci_t aci, connection_t *conn);
 circuit_t *circuit_get_by_conn(connection_t *conn);
+circuit_t *circuit_get_by_naddr_nport(uint32_t naddr, uint16_t nport);
 
 int circuit_deliver_data_cell(cell_t *cell, circuit_t *circ, connection_t *conn, int crypt_type);
 int circuit_crypt(circuit_t *circ, char *in, size_t inlen, char crypt_type);
 
 int circuit_init(circuit_t *circ, int aci_type);
 void circuit_free(circuit_t *circ);
+void circuit_free_cpath(crypt_path_t **cpath, size_t cpathlen);
 
 void circuit_close(circuit_t *circ);
 
@@ -316,8 +377,9 @@ int connection_create_listener(RSA *prkey, struct sockaddr_in *local, int type);
 int connection_handle_listener_read(connection_t *conn, int new_type, int new_state);
 
 /* start all connections that should be up but aren't */
-int retry_all_connections(routerinfo_t **router_array, int rarray_len,
+int retry_all_connections(int role, routerinfo_t **router_array, int rarray_len,
 		  RSA *prkey, uint16_t or_port, uint16_t op_port, uint16_t ap_port);
+connection_t *connection_connect_to_router_as_op(routerinfo_t *router, RSA *prkey, uint16_t local_or_port);
 
 int connection_read_to_buf(connection_t *conn);
 
@@ -331,27 +393,43 @@ int connection_encrypt_cell_header(cell_t *cellp, connection_t *conn);
 int connection_write_cell_to_buf(cell_t *cellp, connection_t *conn);
 
 int connection_process_inbuf(connection_t *conn);
+int connection_package_raw_inbuf(connection_t *conn);
 int connection_process_cell_from_inbuf(connection_t *conn);
 
 int connection_finished_flushing(connection_t *conn);
 
-/********************************* connection_or.c ***************************/
+/********************************* connection_ap.c ****************************/
 
-int connection_or_process_inbuf(connection_t *conn);
-int connection_or_finished_flushing(connection_t *conn);
+int connection_ap_process_inbuf(connection_t *conn);
 
-void conn_or_init_crypto(connection_t *conn);
+int ap_handshake_process_ss(connection_t *conn);
 
-int or_handshake_client_process_auth(connection_t *conn);
-int or_handshake_client_send_auth(connection_t *conn);
+int ap_handshake_create_onion(connection_t *conn);
 
-int or_handshake_server_process_auth(connection_t *conn);
-int or_handshake_server_process_nonce(connection_t *conn);
+int ap_handshake_establish_circuit(connection_t *conn, unsigned int *route, int routelen, char *onion,
+		                                   int onionlen, crypt_path_t **cpath);
 
-int connect_to_router(routerinfo_t *router, RSA *prkey, struct sockaddr_in *local);
+/* find the circ that's waiting on me, if any, and get it to send its onion */
+int ap_handshake_n_conn_open(connection_t *or_conn);
+
+int ap_handshake_send_onion(connection_t *ap_conn, connection_t *or_conn, circuit_t *circ);
+
+int connection_ap_process_data_cell(cell_t *cell, connection_t *conn);
+
+int connection_ap_finished_flushing(connection_t *conn);
+
+int connection_ap_create_listener(RSA *prkey, struct sockaddr_in *local);
+
+int connection_ap_handle_listener_read(connection_t *conn);
+
+/********************************* connection_exit.c ***************************/
+
+int connection_exit_process_inbuf(connection_t *conn);
+int connection_exit_package_inbuf(connection_t *conn);
+int connection_exit_process_data_cell(cell_t *cell, connection_t *conn);
+
+int connection_exit_finished_flushing(connection_t *conn);
 
-int connection_or_create_listener(RSA *prkey, struct sockaddr_in *local);
-int connection_or_handle_listener_read(connection_t *conn);
 
 /********************************* connection_op.c ***************************/
 
@@ -365,13 +443,27 @@ int connection_op_create_listener(RSA *prkey, struct sockaddr_in *local);
 
 int connection_op_handle_listener_read(connection_t *conn);
 
-/********************************* connection_exit.c ***************************/
+/********************************* connection_or.c ***************************/
 
-int connection_exit_process_inbuf(connection_t *conn);
-int connection_exit_package_inbuf(connection_t *conn);
-int connection_exit_process_data_cell(cell_t *cell, connection_t *conn);
+int connection_or_process_inbuf(connection_t *conn);
+int connection_or_finished_flushing(connection_t *conn);
 
-int connection_exit_finished_flushing(connection_t *conn);
+void conn_or_init_crypto(connection_t *conn);
+
+int or_handshake_op_send_keys(connection_t *conn);
+int or_handshake_op_finished_sending_keys(connection_t *conn);
+
+int or_handshake_client_process_auth(connection_t *conn);
+int or_handshake_client_send_auth(connection_t *conn);
+
+int or_handshake_server_process_auth(connection_t *conn);
+int or_handshake_server_process_nonce(connection_t *conn);
+
+connection_t *connect_to_router_as_or(routerinfo_t *router, RSA *prkey, struct sockaddr_in *local);
+connection_t *connection_or_connect_as_or(routerinfo_t *router, RSA *prkey, struct sockaddr_in *local);
+
+int connection_or_create_listener(RSA *prkey, struct sockaddr_in *local);
+int connection_or_handle_listener_read(connection_t *conn);
 
 /********************************* main.c ***************************/
 
@@ -384,6 +476,10 @@ connection_t *connection_get_by_addr_port(uint32_t addr, uint16_t port);
 connection_t *connection_get_by_type(int type);
 
 routerinfo_t *router_get_by_addr_port(uint32_t addr, uint16_t port);
+unsigned int *router_new_route(size_t *rlen);
+unsigned char *router_create_onion(unsigned int *route, size_t routelen, size_t *lenp, crypt_path_t **cpathp);
+routerinfo_t *router_get_first_in_route(unsigned int *route, size_t routelen);
+connection_t *connect_to_router_as_op(routerinfo_t *router);
 
 void connection_watch_events(connection_t *conn, short events);
 
@@ -404,6 +500,37 @@ int decide_aci_type(uint32_t local_addr, uint16_t local_port,
 
 int process_onion(circuit_t *circ, connection_t *conn);
 
+/* uses a weighted coin with weight cw to choose a route length */
+int chooselen(double cw);
+
+/* returns an array of pointers to routent that define a new route through the OR network
+ * int cw is the coin weight to use when choosing the route 
+ * order of routers is from last to first
+ */
+unsigned int *new_route(double cw, routerinfo_t **rarray, size_t rarray_len, size_t *rlen);
+
+/* creates a new onion from route, stores it and its length into bufp and lenp respectively */
+unsigned char *create_onion(routerinfo_t **rarray, size_t rarray_len, unsigned int *route, size_t routelen, size_t *lenp, crypt_path_t **cpathp);
+
+/* encrypts 128 bytes of the onion with the specified public key, the rest with 
+ * DES OFB with the key as defined in the outter layer */
+unsigned char *encrypt_onion(onion_layer_t *onion, uint32_t onionlen, RSA *pkey);
+
+/* decrypts the first 128 bytes using RSA and prkey, decrypts the rest with DES OFB with key1 */
+unsigned char *decrypt_onion(onion_layer_t *onion, uint32_t onionlen, RSA *prkey);
+
+/* delete first n bytes of the onion and pads the end with n bytes of random data */
+void pad_onion(unsigned char *onion, uint32_t onionlen, size_t n);
+
+/* create a new tracked_onion entry */
+tracked_onion_t *new_tracked_onion(unsigned char *onion, uint32_t onionlen, tracked_onion_t **tracked_onions, tracked_onion_t **last_tracked_onion);
+
+/* delete a tracked onion entry */
+void remove_tracked_onion(tracked_onion_t *to, tracked_onion_t **tracked_onions, tracked_onion_t **last_tracked_onion);
+
+/* find a tracked onion in the linked list of tracked onions */
+tracked_onion_t *id_tracked_onion(unsigned char *onion, uint32_t onionlen, tracked_onion_t *tracked_onions);
+
 /********************************* routers.c ***************************/
 
 routerinfo_t **getrouters(char *routerfile, size_t *listlenp);