diff --git a/src/or/Makefile.am b/src/or/Makefile.am index 5b16ba35c5..c401ef79af 100644 --- a/src/or/Makefile.am +++ b/src/or/Makefile.am @@ -4,7 +4,7 @@ bin_PROGRAMS = or or_LDADD = -L../common -lor or_SOURCES = args.c buffers.c cell.c circuit.c command.c connection.c \ - connection_app.c connection_op.c connection_or.c config.c \ + connection_exit.c connection_op.c connection_or.c config.c \ main.c onion.c routers.c noinst_HEADERS = or.h diff --git a/src/or/buffers.c b/src/or/buffers.c index 6900ca300c..6e851f5e36 100644 --- a/src/or/buffers.c +++ b/src/or/buffers.c @@ -3,52 +3,35 @@ #include "or.h" -int buf_new(char **pbuf, size_t *pbuflen, size_t *pbuf_datalen) { +int buf_new(char **buf, size_t *buflen, size_t *buf_datalen) { - if (!pbuf || !pbuflen || !pbuf_datalen) /* invalid parameters */ - return -1; + assert(buf && buflen && buf_datalen); - *pbuf = (char *)malloc(MAX_BUF_SIZE); - if(!*pbuf) + *buf = (char *)malloc(MAX_BUF_SIZE); + if(!*buf) return -1; - memset(*pbuf,0,MAX_BUF_SIZE); - *pbuflen = MAX_BUF_SIZE; - *pbuf_datalen = 0; + memset(*buf,0,MAX_BUF_SIZE); + *buflen = MAX_BUF_SIZE; + *buf_datalen = 0; return 0; } -int buf_free(char *buf) { - +void buf_free(char *buf) { free(buf); - - return 0; } -int read_to_buf(int s, char **pbuf, size_t *pbuflen, size_t *pbuf_datalen, int *preached_eof) { +int read_to_buf(int s, char **buf, size_t *buflen, size_t *buf_datalen, int *reached_eof) { /* grab from s, put onto buf, return how many bytes read */ int read_result; - char *buf; - size_t buflen; - size_t buf_datalen; - if (!pbuf || !pbuflen || !pbuf_datalen || !preached_eof) /* invalid parameters */ - return -1 ; - - if(s<0) { - log(LOG_DEBUG,"read_to_buf() received negative socket %d.",s); - return -1; - } + assert(buf && *buf && buflen && buf_datalen && reached_eof && (s>=0)); /* this is the point where you would grow the buffer, if you want to */ - buf = *pbuf, buflen = *pbuflen, buf_datalen = *pbuf_datalen; - if (!buf) /* invalid parameter */ - return -1; - - read_result = read(s, buf+buf_datalen, buflen - buf_datalen); + read_result = read(s, *buf+*buf_datalen, *buflen - *buf_datalen); if (read_result < 0) { if(errno!=EAGAIN) { /* it's a real error */ return -1; @@ -56,46 +39,32 @@ int read_to_buf(int s, char **pbuf, size_t *pbuflen, size_t *pbuf_datalen, int * return 0; } else if (read_result == 0) { log(LOG_DEBUG,"read_to_buf(): Encountered eof"); - *preached_eof = 1; + *reached_eof = 1; return 0; } else { /* we read some bytes */ - *pbuf_datalen = buf_datalen + read_result; - log(LOG_DEBUG,"read_to_buf(): Read %d bytes. %d on inbuf.",read_result, *pbuf_datalen); + *buf_datalen += read_result; + log(LOG_DEBUG,"read_to_buf(): Read %d bytes. %d on inbuf.",read_result, *buf_datalen); return read_result; } } -int flush_buf(int s, char **pbuf, size_t *pbuflen, size_t *pbuf_datalen) { +int flush_buf(int s, char **buf, size_t *buflen, size_t *buf_datalen) { /* push from buf onto s * then memmove to front of buf * return -1 or how many bytes remain on the buf */ int write_result; - char *buf; - size_t buflen; - size_t buf_datalen; - if (!pbuf || !pbuflen || !pbuf_datalen) /* invalid parameters */ - return -1; + assert(buf && *buf && buflen && buf_datalen && (s>=0)); - if(s<0) { - log(LOG_DEBUG,"flush_buf() received negative socket %d.",s); - return -1; - } - - - if(*pbuf_datalen == 0) /* nothing to flush */ + if(*buf_datalen == 0) /* nothing to flush */ return 0; /* this is the point where you would grow the buffer, if you want to */ - buf = *pbuf, buflen = *pbuflen, buf_datalen = *pbuf_datalen; - if (!buf) /* invalid parameter */ - return -1; - - write_result = write(s, buf, buf_datalen); + write_result = write(s, buf, *buf_datalen); if (write_result < 0) { if(errno!=EAGAIN) { /* it's a real error */ return -1; @@ -103,72 +72,53 @@ int flush_buf(int s, char **pbuf, size_t *pbuflen, size_t *pbuf_datalen) { log(LOG_DEBUG,"flush_buf(): write() would block, returning."); return 0; } else { - *pbuf_datalen -= write_result; - memmove(buf, buf+write_result, *pbuf_datalen); - log(LOG_DEBUG,"flush_buf(): flushed %d bytes, %d remain.",write_result,*pbuf_datalen); - return *pbuf_datalen; + *buf_datalen -= write_result; + memmove(*buf, *buf+write_result, *buf_datalen); + log(LOG_DEBUG,"flush_buf(): flushed %d bytes, %d remain.",write_result,*buf_datalen); + return *buf_datalen; } } int write_to_buf(char *string, size_t string_len, - char **pbuf, size_t *pbuflen, size_t *pbuf_datalen) { + char **buf, size_t *buflen, size_t *buf_datalen) { /* append string to buf (growing as needed, return -1 if "too big") * return total number of bytes on the buf */ - char *buf; - size_t buflen; - size_t buf_datalen; - - if (!string || !pbuf || !pbuflen || !pbuf_datalen) /* invalid parameters */ - return -1; + assert(string && buf && *buf && buflen && buf_datalen); /* this is the point where you would grow the buffer, if you want to */ - buf = *pbuf, buflen = *pbuflen, buf_datalen = *pbuf_datalen; - if (!buf) /* invalid parameter */ - return -1; - - if (string_len + buf_datalen > buflen) { /* we're out of luck */ + if (string_len + *buf_datalen > *buflen) { /* we're out of luck */ log(LOG_DEBUG, "write_to_buf(): buflen too small. Time to implement growing dynamic bufs."); return -1; } - memcpy(buf+buf_datalen, string, string_len); - *pbuf_datalen += string_len; - log(LOG_DEBUG,"write_to_buf(): added %d bytes to buf (now %d total).",string_len, *pbuf_datalen); - return *pbuf_datalen; + memcpy(*buf+*buf_datalen, string, string_len); + *buf_datalen += string_len; + log(LOG_DEBUG,"write_to_buf(): added %d bytes to buf (now %d total).",string_len, *buf_datalen); + return *buf_datalen; } int fetch_from_buf(char *string, size_t string_len, - char **pbuf, size_t *pbuflen, size_t *pbuf_datalen) { + char **buf, size_t *buflen, size_t *buf_datalen) { /* if there is string_len bytes in buf, write them onto string, * then memmove buf back (that is, remove them from buf) */ - char *buf; - size_t buflen; - size_t buf_datalen; - - if (!string || !pbuf || !pbuflen || !pbuf_datalen) /* invalid parameters */ - return -1; + assert(string && buf && *buf && buflen && buf_datalen); /* this is the point where you would grow the buffer, if you want to */ - buf = *pbuf, buflen = *pbuflen, buf_datalen = *pbuf_datalen; - if (!buf) /* invalid parameter */ - return -1; - - if(string_len > buf_datalen) /* we want too much. sorry. */ + if(string_len > *buf_datalen) /* we want too much. sorry. */ return -1; - memcpy(string,buf,string_len); - *pbuf_datalen -= string_len; - memmove(buf, buf+string_len, *pbuf_datalen); - return *pbuf_datalen; - + memcpy(string,*buf,string_len); + *buf_datalen -= string_len; + memmove(*buf, *buf+string_len, *buf_datalen); + return *buf_datalen; } diff --git a/src/or/circuit.c b/src/or/circuit.c index b910fd3518..39ca49c862 100644 --- a/src/or/circuit.c +++ b/src/or/circuit.c @@ -242,9 +242,9 @@ int circuit_deliver_data_cell(cell_t *cell, circuit_t *circ, connection_t *conn, return -1; } - if(conn->type == CONN_TYPE_APP) { /* send payload directly */ - log(LOG_DEBUG,"circuit_deliver_data_cell(): Sending to application."); - if(connection_app_process_data_cell(cell, conn) < 0) { + if(conn->type == CONN_TYPE_EXIT) { /* send payload directly */ + log(LOG_DEBUG,"circuit_deliver_data_cell(): Sending to exit."); + if(connection_exit_process_data_cell(cell, conn) < 0) { return -1; } } else { /* send it as a cell */ diff --git a/src/or/command.c b/src/or/command.c index 2392a9bf20..fddf5cfea4 100644 --- a/src/or/command.c +++ b/src/or/command.c @@ -96,6 +96,9 @@ void command_process_create_cell(cell_t *cell, connection_t *conn) { /* i've disabled making connections through OPs, but it's definitely * possible here. I'm not sure if it would be a bug or a feature. -RD */ + /* note also that this will close circuits where the onion has the same + * router twice in a row in the path. i think that's ok. -RD + */ log(LOG_DEBUG,"command_process_create_cell(): Next router not connected. Closing."); circuit_close(circ); } @@ -132,15 +135,15 @@ void command_process_create_cell(cell_t *cell, connection_t *conn) { free((void *)cellbuf); return; - } else { /* this is destined for an app */ - log(LOG_DEBUG,"command_process_create_cell(): Creating new application connection."); - n_conn = connection_new(CONN_TYPE_APP); + } else { /* this is destined for an exit */ + log(LOG_DEBUG,"command_process_create_cell(): Creating new exit connection."); + n_conn = connection_new(CONN_TYPE_EXIT); if(!n_conn) { log(LOG_DEBUG,"command_process_create_cell(): connection_new failed. Closing."); circuit_close(circ); return; } - n_conn->state = APP_CONN_STATE_CONNECTING_WAIT; + n_conn->state = EXIT_CONN_STATE_CONNECTING_WAIT; n_conn->s = -1; /* not yet valid */ if(connection_add(n_conn) < 0) { /* no space, forget it */ log(LOG_DEBUG,"command_process_create_cell(): connection_add failed. Closing."); @@ -151,7 +154,6 @@ void command_process_create_cell(cell_t *cell, connection_t *conn) { circ->n_conn = n_conn; return; } - } void command_process_data_cell(cell_t *cell, connection_t *conn) { @@ -207,6 +209,5 @@ void command_process_destroy_cell(cell_t *cell, connection_t *conn) { if(cell->aci == circ->n_aci) /* the destroy came from ahead */ connection_send_destroy(circ->p_aci, circ->p_conn); circuit_free(circ); - } diff --git a/src/or/connection.c b/src/or/connection.c index 7411852ac5..643b1ebb84 100644 --- a/src/or/connection.c +++ b/src/or/connection.c @@ -3,6 +3,8 @@ /********* START VARIABLES **********/ +#if 0 +/* these are now out of date :( -RD */ char *conn_type_to_string[] = { "OP listener", /* 0 */ "OP", /* 1 */ @@ -26,12 +28,13 @@ char *conn_state_to_string[][10] = { "sending auth (as server)", /* 5 */ "waiting for nonce (as server)",/* 6 */ "open" }, /* 7 */ - { "connecting", /* app, 0 */ + { "connecting", /* exit, 0 */ "open", /* 1 */ "waiting for dest info", /* 2 */ "flushing buffer, then will close",/* 3 */ "close_wait" } /* 4 */ }; +#endif /********* END VARIABLES ************/ @@ -44,8 +47,9 @@ connection_t *connection_new(int type) { memset(conn,0,sizeof(connection_t)); /* zero it out to start */ conn->type = type; - buf_new(&conn->inbuf, &conn->inbuflen, &conn->inbuf_datalen); - buf_new(&conn->outbuf, &conn->outbuflen, &conn->outbuf_datalen); + if(buf_new(&conn->inbuf, &conn->inbuflen, &conn->inbuf_datalen) < 0 || + buf_new(&conn->outbuf, &conn->outbuflen, &conn->outbuf_datalen) < 0) + return NULL; return conn; } @@ -61,8 +65,8 @@ void connection_free(connection_t *conn) { /* FIXME should we do these for all connections, or just ORs, or what */ if(conn->type == CONN_TYPE_OR || conn->type == CONN_TYPE_OP) { -// EVP_CIPHER_CTX_cleanup(&conn->f_ctx); -// EVP_CIPHER_CTX_cleanup(&conn->b_ctx); + EVP_CIPHER_CTX_cleanup(&conn->f_ctx); + EVP_CIPHER_CTX_cleanup(&conn->b_ctx); } if(conn->s > 0) @@ -99,6 +103,8 @@ int connection_create_listener(RSA *prkey, struct sockaddr_in *local, int type) fcntl(s, F_SETFL, O_NONBLOCK); /* set s to non-blocking */ conn = connection_new(type); + if(!conn) + return -1; conn->s = s; if(connection_add(conn) < 0) { /* no space, forget it */ @@ -156,7 +162,7 @@ int connection_handle_listener_read(connection_t *conn, int new_type, int new_st } int retry_all_connections(routerinfo_t **router_array, int rarray_len, - RSA *prkey, uint16_t or_port, uint16_t op_port) { + RSA *prkey, uint16_t or_port, uint16_t op_port, uint16_t ap_port) { /* start all connections that should be up but aren't */ @@ -201,7 +207,6 @@ int retry_all_connections(routerinfo_t **router_array, int rarray_len, } return 0; - } int connection_read_to_buf(connection_t *conn) { @@ -226,11 +231,10 @@ int connection_write_to_buf(char *string, int len, connection_t *conn) { int connection_send_destroy(aci_t aci, connection_t *conn) { cell_t cell; - if(!conn) - return -1; + assert(conn); if(conn->type == CONN_TYPE_OP || - conn->type == CONN_TYPE_APP) { + conn->type == CONN_TYPE_EXIT) { log(LOG_DEBUG,"connection_send_destroy(): At an edge. Marking connection for close."); conn->marked_for_close = 1; return 0; @@ -290,8 +294,8 @@ int connection_process_inbuf(connection_t *conn) { return connection_op_process_inbuf(conn); case CONN_TYPE_OR: return connection_or_process_inbuf(conn); - case CONN_TYPE_APP: - return connection_app_process_inbuf(conn); + case CONN_TYPE_EXIT: + return connection_exit_process_inbuf(conn); default: log(LOG_DEBUG,"connection_process_inbuf() got unexpected conn->type."); return -1; @@ -309,8 +313,8 @@ int connection_finished_flushing(connection_t *conn) { return connection_op_finished_flushing(conn); case CONN_TYPE_OR: return connection_or_finished_flushing(conn); - case CONN_TYPE_APP: - return connection_app_finished_flushing(conn); + case CONN_TYPE_EXIT: + return connection_exit_finished_flushing(conn); default: log(LOG_DEBUG,"connection_finished_flushing() got unexpected conn->type."); return -1; diff --git a/src/or/connection_app.c b/src/or/connection_exit.c similarity index 53% rename from src/or/connection_app.c rename to src/or/connection_exit.c index 94276fd594..99a6760bcc 100644 --- a/src/or/connection_app.c +++ b/src/or/connection_exit.c @@ -1,39 +1,35 @@ #include "or.h" -connection_t *connection_app_new(void) { - return connection_new(CONN_TYPE_APP); -} +int connection_exit_process_inbuf(connection_t *conn) { -int connection_app_process_inbuf(connection_t *conn) { - - assert(conn && conn->type == CONN_TYPE_APP); + assert(conn && conn->type == CONN_TYPE_EXIT); if(conn->inbuf_reached_eof) { /* eof reached, kill it. */ - log(LOG_DEBUG,"connection_app_process_inbuf(): conn reached eof. Closing."); + log(LOG_DEBUG,"connection_exit_process_inbuf(): conn reached eof. Closing."); return -1; } - log(LOG_DEBUG,"connection_app_process_inbuf(): state %d.",conn->state); + log(LOG_DEBUG,"connection_exit_process_inbuf(): state %d.",conn->state); switch(conn->state) { - case APP_CONN_STATE_CONNECTING: - log(LOG_DEBUG,"connection_app_process_inbuf(): text from app server while in 'connecting' state. Leaving it on buffer."); + case EXIT_CONN_STATE_CONNECTING: + log(LOG_DEBUG,"connection_exit_process_inbuf(): text from server while in 'connecting' state. Leaving it on buffer."); return 0; - case APP_CONN_STATE_OPEN: - return connection_app_package_inbuf(conn); + case EXIT_CONN_STATE_OPEN: + return connection_exit_package_inbuf(conn); } return 0; } -int connection_app_package_inbuf(connection_t *conn) { +int connection_exit_package_inbuf(connection_t *conn) { int amount_to_process; cell_t cell; circuit_t *circ; - assert(conn && conn->type == CONN_TYPE_APP); + assert(conn && conn->type == CONN_TYPE_EXIT); amount_to_process = conn->inbuf_datalen; @@ -46,40 +42,40 @@ int connection_app_package_inbuf(connection_t *conn) { cell.length = amount_to_process; } - if(connection_fetch_from_buf(cell.payload,cell.length,conn) < 0) { + if(connection_fetch_from_buf(cell.payload, cell.length, conn) < 0) { return -1; } circ = circuit_get_by_conn(conn); if(!circ) { - log(LOG_DEBUG,"connection_app_package_inbuf(): conn has no circuits!"); + log(LOG_DEBUG,"connection_exit_package_inbuf(): conn has no circuits!"); return -1; } - log(LOG_DEBUG,"connection_app_package_inbuf(): Packaging %d bytes.",cell.length); + log(LOG_DEBUG,"connection_exit_package_inbuf(): Packaging %d bytes.",cell.length); cell.aci = circ->p_aci; cell.command = CELL_DATA; if(circuit_deliver_data_cell(&cell, circ, circ->p_conn, 'e') < 0) { - log(LOG_DEBUG,"connection_app_package_inbuf(): circuit_deliver_data_cell (backward) failed. Closing."); + log(LOG_DEBUG,"connection_exit_package_inbuf(): circuit_deliver_data_cell (backward) failed. Closing."); circuit_close(circ); return 0; } if(amount_to_process > CELL_PAYLOAD_SIZE) - return(connection_app_package_inbuf(conn)); + return(connection_exit_package_inbuf(conn)); return 0; } -int connection_app_finished_flushing(connection_t *conn) { +int connection_exit_finished_flushing(connection_t *conn) { int e, len=sizeof(e); - assert(conn && conn->type == CONN_TYPE_APP); + assert(conn && conn->type == CONN_TYPE_EXIT); switch(conn->state) { - case APP_CONN_STATE_CONNECTING: + case EXIT_CONN_STATE_CONNECTING: if (getsockopt(conn->s, SOL_SOCKET, SO_ERROR, &e, &len) < 0) { /* not yet */ if(errno != EINPROGRESS){ /* yuck. kill it. */ - log(LOG_DEBUG,"connection_app_finished_flushing(): in-progress connect failed. Removing."); + log(LOG_DEBUG,"connection_exit_finished_flushing(): in-progress connect failed. Removing."); return -1; } else { return 0; /* no change, see if next time is better */ @@ -87,76 +83,76 @@ int connection_app_finished_flushing(connection_t *conn) { } /* the connect has finished. */ - log(LOG_DEBUG,"connection_app_finished_flushing() : Connection to %s:%u established.", + log(LOG_DEBUG,"connection_exit_finished_flushing() : Connection to %s:%u established.", conn->address,ntohs(conn->port)); - conn->state = APP_CONN_STATE_OPEN; + conn->state = EXIT_CONN_STATE_OPEN; connection_watch_events(conn, POLLIN); return 0; - case APP_CONN_STATE_OPEN: + case EXIT_CONN_STATE_OPEN: /* FIXME down the road, we'll clear out circuits that are pending to close */ connection_watch_events(conn, POLLIN); return 0; default: - log(LOG_DEBUG,"Bug: connection_app_finished_flushing() called in unexpected state."); + log(LOG_DEBUG,"Bug: connection_exit_finished_flushing() called in unexpected state."); return 0; } return 0; } -int connection_app_process_data_cell(cell_t *cell, connection_t *conn) { +int connection_exit_process_data_cell(cell_t *cell, connection_t *conn) { struct hostent *rent; struct sockaddr_in dest_addr; int s; /* an outgoing data cell has arrived */ - assert(conn && conn->type == CONN_TYPE_APP); + assert(conn && conn->type == CONN_TYPE_EXIT); switch(conn->state) { - case APP_CONN_STATE_CONNECTING_WAIT: - log(LOG_DEBUG,"connection_app_process_cell(): state is connecting_wait. cell length %d.", cell->length); + case EXIT_CONN_STATE_CONNECTING_WAIT: + log(LOG_DEBUG,"connection_exit_process_cell(): state is connecting_wait. cell length %d.", cell->length); if(!conn->ss_received) { /* this cell contains the ss */ if(cell->length != sizeof(ss_t)) { - log(LOG_DEBUG,"connection_app_process_cell(): Supposed to contain SS but wrong size. Closing."); + log(LOG_DEBUG,"connection_exit_process_cell(): Supposed to contain SS but wrong size. Closing."); return -1; } memcpy(&conn->ss, cell->payload, cell->length); if(conn->ss.addr_fmt != SS_ADDR_FMT_ASCII_HOST_PORT) { /* unrecognized address format */ - log(LOG_DEBUG,"connection_app_process_cell(): SS has unrecognized address format. Closing."); + log(LOG_DEBUG,"connection_exit_process_cell(): SS has unrecognized address format. Closing."); return -1; } conn->ss_received = 1; - log(LOG_DEBUG,"connection_app_process_cell(): SS received."); + log(LOG_DEBUG,"connection_exit_process_cell(): SS received."); } else if (!conn->addr) { /* this cell contains the dest addr */ if(!memchr(cell->payload,0,cell->length)) { - log(LOG_DEBUG,"connection_app_process_cell(): dest_addr cell has no \\0. Closing."); + log(LOG_DEBUG,"connection_exit_process_cell(): dest_addr cell has no \\0. Closing."); return -1; } conn->address = strdup(cell->payload); rent = gethostbyname(cell->payload); if (!rent) { - log(LOG_ERR,"connection_app_process_cell(): Could not resolve dest addr %s.",cell->payload); + log(LOG_ERR,"connection_exit_process_cell(): Could not resolve dest addr %s.",cell->payload); return -1; } memcpy(&conn->addr, rent->h_addr,rent->h_length); - log(LOG_DEBUG,"connection_app_process_cell(): addr %s resolves to %d.",cell->payload,conn->addr); + log(LOG_DEBUG,"connection_exit_process_cell(): addr %s resolves to %d.",cell->payload,conn->addr); } else if (!conn->port) { /* this cell contains the dest port */ if(!memchr(cell->payload,'\0',cell->length)) { - log(LOG_DEBUG,"connection_app_process_cell(): dest_port cell has no \\0. Closing."); + log(LOG_DEBUG,"connection_exit_process_cell(): dest_port cell has no \\0. Closing."); return -1; } conn->port = atoi(cell->payload); if(!conn->port) { /* bad port */ - log(LOG_DEBUG,"connection_app_process_cell(): dest_port cell isn't a valid number. Closing."); + log(LOG_DEBUG,"connection_exit_process_cell(): dest_port cell isn't a valid number. Closing."); return -1; } /* all the necessary info is here. Start the connect() */ s=socket(PF_INET,SOCK_STREAM,IPPROTO_TCP); if (s < 0) { - log(LOG_ERR,"connection_app_process_cell(): Error creating network socket."); + log(LOG_ERR,"connection_exit_process_cell(): Error creating network socket."); return -1; } fcntl(s, F_SETFL, O_NONBLOCK); /* set s to non-blocking */ @@ -166,47 +162,45 @@ int connection_app_process_data_cell(cell_t *cell, connection_t *conn) { dest_addr.sin_port = conn->port; memcpy((void *)&dest_addr.sin_addr, &conn->addr, sizeof(uint32_t)); - log(LOG_DEBUG,"connection_app_process_cell(): Connecting to %s:%u.",conn->address,ntohs(conn->port)); + log(LOG_DEBUG,"connection_exit_process_cell(): Connecting to %s:%u.",conn->address,ntohs(conn->port)); if(connect(s,(struct sockaddr *)&dest_addr,sizeof(dest_addr)) < 0){ if(errno != EINPROGRESS){ /* yuck. kill it. */ - log(LOG_DEBUG,"connection_app_process_cell(): Connect failed."); + log(LOG_DEBUG,"connection_exit_process_cell(): Connect failed."); return -1; } else { /* it's in progress. set state appropriately and return. */ conn->s = s; connection_set_poll_socket(conn); - conn->state = APP_CONN_STATE_CONNECTING; + conn->state = EXIT_CONN_STATE_CONNECTING; /* i think only pollout is needed, but i'm curious if pollin ever gets caught -RD */ - log(LOG_DEBUG,"connection_app_process_cell(): connect in progress, socket %d.",s); + log(LOG_DEBUG,"connection_exit_process_cell(): connect in progress, socket %d.",s); connection_watch_events(conn, POLLOUT | POLLIN); return 0; } } /* it succeeded. we're connected. */ - log(LOG_DEBUG,"connection_app_process_cell(): Connection to %s:%u established.",conn->address,ntohs(conn->port)); + log(LOG_DEBUG,"connection_exit_process_cell(): Connection to %s:%u established.",conn->address,ntohs(conn->port)); conn->s = s; connection_set_poll_socket(conn); - conn->state = APP_CONN_STATE_OPEN; + conn->state = EXIT_CONN_STATE_OPEN; connection_watch_events(conn, POLLIN); } else { /* i'm not sure what this would be */ - log(LOG_DEBUG,"connection_app_process_cell(): in connecting_wait, not sure why."); + log(LOG_DEBUG,"connection_exit_process_cell(): in connecting_wait, not sure why."); } return 0; - case APP_CONN_STATE_CONNECTING: - log(LOG_DEBUG,"connection_app_process_cell(): Data receiving while connecting. Queueing."); + case EXIT_CONN_STATE_CONNECTING: + log(LOG_DEBUG,"connection_exit_process_cell(): Data receiving while connecting. Queueing."); /* FIXME kludge. shouldn't call write_to_buf directly. */ return write_to_buf(cell->payload, cell->length, &conn->outbuf, &conn->outbuflen, &conn->outbuf_datalen); - case APP_CONN_STATE_OPEN: + case EXIT_CONN_STATE_OPEN: return connection_write_to_buf(cell->payload, cell->length, conn); } return 0; } - - diff --git a/src/or/connection_op.c b/src/or/connection_op.c index 03d36dbe6b..8ac5ceb4b2 100644 --- a/src/or/connection_op.c +++ b/src/or/connection_op.c @@ -1,14 +1,6 @@ #include "or.h" -connection_t *connection_op_new(void) { - return connection_new(CONN_TYPE_OP); -} - -connection_t *connection_op_listener_new(void) { - return connection_new(CONN_TYPE_OP_LISTENER); -} - int connection_op_process_inbuf(connection_t *conn) { assert(conn && conn->type == CONN_TYPE_OP); diff --git a/src/or/connection_or.c b/src/or/connection_or.c index 813cc89752..37abc8b7a4 100644 --- a/src/or/connection_or.c +++ b/src/or/connection_or.c @@ -33,7 +33,6 @@ int connection_or_process_inbuf(connection_t *conn) { } return 0; - } int connection_or_finished_flushing(connection_t *conn) { @@ -89,14 +88,6 @@ int connection_or_finished_flushing(connection_t *conn) { /*********************/ -connection_t *connection_or_new(void) { - return connection_new(CONN_TYPE_OR); -} - -connection_t *connection_or_new_listener(void) { - return connection_new(CONN_TYPE_OR_LISTENER); -} - void conn_or_init_crypto(connection_t *conn) { int x; @@ -132,15 +123,14 @@ int connect_to_router(routerinfo_t *router, RSA *prkey, struct sockaddr_in *loca struct sockaddr_in router_addr; int s; - if ((!router) || (!prkey) || (!local)) - return -1; + assert(router && prkey && local); if(router->addr == local->sin_addr.s_addr && router->port == local->sin_port) { /* this is me! don't connect to me. */ return 0; } - conn = connection_or_new(); + conn = connection_new(CONN_TYPE_OR); /* set up conn so it's got all the data we need to remember */ conn->addr = router->addr, conn->port = router->port; diff --git a/src/or/main.c b/src/or/main.c index 85f91ab301..2cac0819c7 100644 --- a/src/or/main.c +++ b/src/or/main.c @@ -73,7 +73,6 @@ void connection_set_poll_socket(connection_t *conn) { } int connection_remove(connection_t *conn) { - int current_index; assert(conn); @@ -103,7 +102,6 @@ int connection_remove(connection_t *conn) { } connection_t *connection_get_by_addr_port(uint32_t addr, uint16_t port) { - int i; connection_t *conn; @@ -115,11 +113,9 @@ connection_t *connection_get_by_addr_port(uint32_t addr, uint16_t port) { } return NULL; - } connection_t *connection_get_by_type(int type) { - int i; connection_t *conn; @@ -130,7 +126,6 @@ connection_t *connection_get_by_type(int type) { } return NULL; - } routerinfo_t *router_get_by_addr_port(uint32_t addr, uint16_t port) { @@ -159,7 +154,6 @@ void connection_watch_events(connection_t *conn, short events) { } void check_conn_read(int i) { - int retval; connection_t *conn; @@ -174,7 +168,7 @@ void check_conn_read(int i) { } else if (conn->type == CONN_TYPE_OR_LISTENER) { retval = connection_or_handle_listener_read(conn); } else { - /* else it's an OP, OR, or app */ + /* else it's an OP, OR, or exit */ retval = connection_read_to_buf(conn); if (retval >= 0) { /* all still well */ retval = connection_process_inbuf(conn); @@ -195,7 +189,6 @@ void check_conn_read(int i) { } void check_conn_write(int i) { - int retval; connection_t *conn; @@ -209,7 +202,7 @@ void check_conn_write(int i) { log(LOG_DEBUG,"check_conn_write(): Got a listener socket. Can't happen!"); retval = -1; } else { - /* else it's an OP, OR, or app */ + /* else it's an OP, OR, or exit */ retval = connection_flush_buf(conn); /* conns in CONNECTING state will fall through... */ if(retval == 0) { /* it's done flushing */ retval = connection_finished_flushing(conn); /* ...and get handled here. */ @@ -245,26 +238,7 @@ void check_conn_marked(int i) { } } -#if 0 -void check_conn_hup(int i) { - connection_t *conn; - - if(poll_array[i].revents & POLLHUP) { /* they've hung up */ - conn = connection_array[i]; - log(LOG_DEBUG,"check_conn_hup(): socket %d has hung up.",conn->s); - connection_remove(conn); - connection_free(conn); - - if(i