Commit 756619bf authored by Roger Dingledine's avatar Roger Dingledine
Browse files

refactor around connection_edge_send_command() 


svn:r539
parent be874358

src/or/circuit.c

+2 −4
Original line number Diff line number Diff line
@@ -543,10 +543,8 @@ void circuit_about_to_close_connection(connection_t *conn) { 
    log_fn(LOG_ERR,"edge conn not in circuit's list?");

    assert(0); /* should never get here */

send_end:

    if(connection_edge_send_command(conn, circ, RELAY_COMMAND_END) < 0) {

      log_fn(LOG_DEBUG,"sending end failed. Closing.");

      circuit_close(circ);

    }

    connection_edge_send_command(conn, circ, RELAY_COMMAND_END,

                                 NULL, 0, conn->cpath_layer);

    return;

  }

src/or/command.c

+4 −16
Original line number Diff line number Diff line
@@ -122,7 +122,6 @@ static void command_process_create_cell(cell_t *cell, connection_t *conn) { 


static void command_process_created_cell(cell_t *cell, connection_t *conn) {

  circuit_t *circ;

  cell_t newcell;



  circ = circuit_get_by_aci_conn(cell->aci, conn);
@@ -152,21 +151,9 @@ static void command_process_created_cell(cell_t *cell, connection_t *conn) { 
      return;

    }

  } else { /* pack it into an extended relay cell, and send it. */

    memset(&newcell, 0, sizeof(cell_t));

    newcell.command = CELL_RELAY;

    newcell.aci = circ->p_aci;

    SET_CELL_RELAY_COMMAND(newcell, RELAY_COMMAND_EXTENDED);

    SET_CELL_STREAM_ID(newcell, ZERO_STREAM);



    newcell.length = RELAY_HEADER_SIZE + cell->length;

    memcpy(newcell.payload+RELAY_HEADER_SIZE, cell->payload, DH_KEY_LEN);



    log_fn(LOG_INFO,"Converting created cell to extended relay cell, sending.");

    if(circuit_deliver_relay_cell(&newcell, circ, CELL_DIRECTION_IN, NULL) < 0) {

      log_fn(LOG_WARNING,"failed to deliver extended cell. Closing.");

      circuit_close(circ);

      return;

    }

    connection_edge_send_command(NULL, circ, RELAY_COMMAND_EXTENDED,

                                 cell->payload, DH_KEY_LEN, NULL);

  }

}
@@ -225,7 +212,8 @@ static void command_process_destroy_cell(cell_t *cell, connection_t *conn) { 
  } else { /* the destroy came from ahead */

    circ->n_conn = NULL;

    log_fn(LOG_DEBUG, "Delivering 'truncated' back.");

    connection_edge_send_command(NULL, circ, RELAY_COMMAND_TRUNCATED);

    connection_edge_send_command(NULL, circ, RELAY_COMMAND_TRUNCATED,

                                 NULL, 0, NULL);

  }

}

src/or/connection_edge.c

+54 −77
Original line number Diff line number Diff line
@@ -28,21 +28,8 @@ int connection_edge_process_inbuf(connection_t *conn) { 
/*ENDCLOSE*/  conn->marked_for_close = 1;



    /* XXX Factor out common logic here and in circuit_about_to_close NM */

    circ = circuit_get_by_conn(conn);

    if (!circ)

      return -1;



    memset(&cell, 0, sizeof(cell_t));

    cell.command = CELL_RELAY;

    cell.length = RELAY_HEADER_SIZE;

    SET_CELL_RELAY_COMMAND(cell, RELAY_COMMAND_END);

    SET_CELL_STREAM_ID(cell, conn->stream_id);

    cell.aci = circ->n_aci;



    if (circuit_deliver_relay_cell(&cell, circ, CELL_DIRECTION(conn->type), conn->cpath_layer) < 0) {

      log_fn(LOG_WARNING,"(fd %d) circuit_deliver_relay_cell failed. Closing.", conn->s);

      circuit_close(circ);

    }

    connection_edge_send_command(conn, circuit_get_by_conn(conn), RELAY_COMMAND_END,

                                 NULL, 0, conn->cpath_layer);

    return 0;

#else 

    /* eof reached, kill it. */
@@ -67,15 +54,20 @@ int connection_edge_process_inbuf(connection_t *conn) { 
  return 0;

}



int connection_edge_send_command(connection_t *fromconn, circuit_t *circ, int relay_command) {

void connection_edge_send_command(connection_t *fromconn, circuit_t *circ, int relay_command,

                                  void *payload, int payload_len, crypt_path_t *cpath_layer) {

  cell_t cell;

  int cell_direction;

  int is_control_cell=0;



  if(!circ) {

    log_fn(LOG_WARNING,"no circ. Closing.");

    return -1;

    return;

  }



  if(!fromconn || relay_command == RELAY_COMMAND_BEGIN) /* XXX more */

    is_control_cell = 1;



  memset(&cell, 0, sizeof(cell_t));

  if(fromconn && fromconn->type == CONN_TYPE_AP) {

    cell.aci = circ->n_aci;
@@ -88,20 +80,22 @@ int connection_edge_send_command(connection_t *fromconn, circuit_t *circ, int re 


  cell.command = CELL_RELAY;

  SET_CELL_RELAY_COMMAND(cell, relay_command);

  if(fromconn)

    SET_CELL_STREAM_ID(cell, fromconn->stream_id);

  else

  if(is_control_cell)

    SET_CELL_STREAM_ID(cell, ZERO_STREAM);

  else

    SET_CELL_STREAM_ID(cell, fromconn->stream_id);



  cell.length = RELAY_HEADER_SIZE;

  log_fn(LOG_INFO,"delivering %d cell %s.", relay_command, cell_direction == CELL_DIRECTION_OUT ? "forward" : "backward");

  cell.length = RELAY_HEADER_SIZE + payload_len;

  if(payload_len) {

    memcpy(cell.payload+RELAY_HEADER_SIZE,payload,payload_len);

  }

  log_fn(LOG_INFO,"delivering %d cell %s.", relay_command,

         cell_direction == CELL_DIRECTION_OUT ? "forward" : "backward");



  if(circuit_deliver_relay_cell(&cell, circ, cell_direction, fromconn ? fromconn->cpath_layer : NULL) < 0) {

  if(circuit_deliver_relay_cell(&cell, circ, cell_direction, cpath_layer) < 0) {

    log_fn(LOG_WARNING,"circuit_deliver_relay_cell failed. Closing.");

    circuit_close(circ);

    return 0;

  }

  return 0;

}



/* an incoming relay cell has arrived. return -1 if you want to tear down the
@@ -217,7 +211,9 @@ int connection_edge_process_relay_cell(cell_t *cell, circuit_t *circ, connection 
        circ->n_conn = NULL;

      }

      log_fn(LOG_DEBUG, "Processed 'truncate', replying.");

      return connection_edge_send_command(NULL, circ, RELAY_COMMAND_TRUNCATED);

      connection_edge_send_command(NULL, circ, RELAY_COMMAND_TRUNCATED,

                                   NULL, 0, NULL);

      return 0;

    case RELAY_COMMAND_TRUNCATED:

      if(edge_type == EDGE_EXIT) {

        log_fn(LOG_WARNING,"'truncated' unsupported at exit. Dropping.");
@@ -292,9 +288,10 @@ int connection_edge_finished_flushing(connection_t *conn) { 
      connection_watch_events(conn, POLLIN); /* stop writing, continue reading */

      if(connection_wants_to_flush(conn)) /* in case there are any queued relay cells */

        connection_start_writing(conn);

      return

        connection_edge_send_command(conn, circuit_get_by_conn(conn), RELAY_COMMAND_CONNECTED) || /* deliver a 'connected' relay cell back through the circuit. */

        connection_process_inbuf(conn); /* in case the server has written anything */

      /* deliver a 'connected' relay cell back through the circuit. */

      connection_edge_send_command(conn, circuit_get_by_conn(conn), RELAY_COMMAND_CONNECTED,

                                   NULL, 0, conn->cpath_layer);

      return connection_process_inbuf(conn); /* in case the server has written anything */

    case AP_CONN_STATE_OPEN:

    case EXIT_CONN_STATE_OPEN:

      connection_stop_writing(conn);
@@ -316,8 +313,8 @@ uint64_t stats_n_data_cells_received = 0; 
uint64_t stats_n_data_bytes_received = 0;



int connection_package_raw_inbuf(connection_t *conn) {

  int amount_to_process;

  cell_t cell;

  int amount_to_process, length;

  char payload[CELL_PAYLOAD_SIZE];

  circuit_t *circ;

 

  assert(conn);
@@ -345,49 +342,31 @@ repeat_connection_package_raw_inbuf: 
  if(!amount_to_process)

    return 0;

 

  /* Initialize the cell with 0's */

  memset(&cell, 0, sizeof(cell_t));

 

  if(amount_to_process > CELL_PAYLOAD_SIZE - RELAY_HEADER_SIZE) {

    cell.length = CELL_PAYLOAD_SIZE - RELAY_HEADER_SIZE;

    length = CELL_PAYLOAD_SIZE - RELAY_HEADER_SIZE;

  } else {

    cell.length = amount_to_process;

    length = amount_to_process;

  }

  stats_n_data_bytes_packaged += cell.length;

  stats_n_data_bytes_packaged += length;

  stats_n_data_cells_packaged += 1;

 

  connection_fetch_from_buf(cell.payload+RELAY_HEADER_SIZE, cell.length, conn);

  connection_fetch_from_buf(payload, length, conn);



  log_fn(LOG_DEBUG,"(%d) Packaging %d bytes (%d waiting).",conn->s,cell.length,

  log_fn(LOG_DEBUG,"(%d) Packaging %d bytes (%d waiting).",conn->s,length,

         (int)buf_datalen(conn->inbuf));

 

  cell.command = CELL_RELAY;

  SET_CELL_RELAY_COMMAND(cell, RELAY_COMMAND_DATA);

  SET_CELL_STREAM_ID(cell, conn->stream_id);

  cell.length += RELAY_HEADER_SIZE;

  connection_edge_send_command(conn, circ, RELAY_COMMAND_DATA,

                               payload, length, conn->cpath_layer);



  if(conn->type == CONN_TYPE_EXIT) {

    cell.aci = circ->p_aci;

    if(circuit_deliver_relay_cell(&cell, circ, CELL_DIRECTION_IN, NULL) < 0) {

      log_fn(LOG_WARNING,"circuit_deliver_relay_cell (backward) failed. Closing.");

      circuit_close(circ);

      return 0;

    }

    assert(circ->package_window > 0);

    circ->package_window--;

  } else { /* send it forward. we're an AP */

  } else { /* we're an AP */

    assert(conn->type == CONN_TYPE_AP);

    cell.aci = circ->n_aci;

    if(circuit_deliver_relay_cell(&cell, circ, CELL_DIRECTION_OUT, conn->cpath_layer) < 0) {

      log_fn(LOG_WARNING,"circuit_deliver_relay_cell (forward) failed. Closing.");

      circuit_close(circ);

      return 0;

    }

    assert(conn->cpath_layer->package_window > 0);

    conn->cpath_layer->package_window--;

  }

 

  assert(conn->package_window > 0);

  if(--conn->package_window <= 0) { /* is it 0 after decrement? */

    connection_stop_reading(conn);

    log_fn(LOG_DEBUG,"conn->package_window reached 0.");
@@ -493,27 +472,23 @@ static int connection_ap_handshake_process_socks(connection_t *conn) { 
/* deliver the destaddr:destport in a relay cell */

static int connection_ap_handshake_send_begin(connection_t *ap_conn, circuit_t *circ,

                                              char *destaddr, uint16_t destport) {

  cell_t cell;

  memset(&cell, 0, sizeof(cell_t));

  char payload[CELL_PAYLOAD_SIZE];

  int payload_len;



  cell.command = CELL_RELAY;

  cell.aci = circ->n_aci;

  SET_CELL_RELAY_COMMAND(cell, RELAY_COMMAND_BEGIN);

  if(crypto_pseudo_rand(STREAM_ID_SIZE, ap_conn->stream_id) < 0)

    return -1;

  /* FIXME check for collisions */

  SET_CELL_STREAM_ID(cell, ZERO_STREAM);



  memcpy(cell.payload+RELAY_HEADER_SIZE, ap_conn->stream_id, STREAM_ID_SIZE);

  cell.length = 

    snprintf(cell.payload+RELAY_HEADER_SIZE+STREAM_ID_SIZE, CELL_PAYLOAD_SIZE-RELAY_HEADER_SIZE-STREAM_ID_SIZE,

             "%s:%d", destaddr, destport) + 

    1 + STREAM_ID_SIZE + RELAY_HEADER_SIZE;

  log_fn(LOG_DEBUG,"Sending relay cell (id %d) to begin stream %d.", *(int *)(cell.payload+1),*(int *)ap_conn->stream_id);

  if(circuit_deliver_relay_cell(&cell, circ, CELL_DIRECTION_OUT, ap_conn->cpath_layer) < 0) {

    log_fn(LOG_WARNING,"failed to deliver begin cell. Closing.");

    return -1;

  }

  memcpy(payload, ap_conn->stream_id, STREAM_ID_SIZE);

  payload_len = STREAM_ID_SIZE + 1 +

    snprintf(payload+STREAM_ID_SIZE,CELL_PAYLOAD_SIZE-RELAY_HEADER_SIZE-STREAM_ID_SIZE,

             "%s:%d", destaddr, destport);



  log_fn(LOG_DEBUG,"Sending relay cell to begin stream %d.",*(int *)ap_conn->stream_id);



  connection_edge_send_command(ap_conn, circ, RELAY_COMMAND_BEGIN,

                               payload, payload_len, ap_conn->cpath_layer);



  ap_conn->package_window = STREAMWINDOW_START;

  ap_conn->deliver_window = STREAMWINDOW_START;

  ap_conn->state = AP_CONN_STATE_OPEN;
@@ -640,7 +615,9 @@ int connection_exit_connect(connection_t *conn) { 
  connection_watch_events(conn, POLLIN);



  /* also, deliver a 'connected' cell back through the circuit. */

  return connection_edge_send_command(conn, circuit_get_by_conn(conn), RELAY_COMMAND_CONNECTED);

  connection_edge_send_command(conn, circuit_get_by_conn(conn), RELAY_COMMAND_CONNECTED,

                               NULL, 0, conn->cpath_layer);

  return 0;

}



/*

src/or/main.c

+7 −7
Original line number Diff line number Diff line
@@ -676,12 +676,12 @@ static void dumpstats(void) { /* dump stats to stdout */ 
    circuit_dump_by_conn(conn); /* dump info about all the circuits using this conn */

    printf("\n");

  }

  printf("Cells processed: %10lud padding\n"

         "                 %10lud create\n"

         "                 %10lud created\n"

         "                 %10lud relay\n"

         "                        (%10lud relayed)\n"

         "                        (%10lud delivered)\n"

  printf("Cells processed: %10lu padding\n"

         "                 %10lu create\n"

         "                 %10lu created\n"

         "                 %10lu relay\n"

         "                        (%10lu relayed)\n"

         "                        (%10lu delivered)\n"

         "                 %10lud destroy\n",

         stats_n_padding_cells_processed,

         stats_n_create_cells_processed,
@@ -695,7 +695,7 @@ static void dumpstats(void) { /* dump stats to stdout */ 
           100*(((double)stats_n_data_bytes_packaged) / 

                (stats_n_data_cells_packaged*(CELL_PAYLOAD_SIZE-RELAY_HEADER_SIZE))) );

  if (stats_n_data_cells_packaged)

    printf("Average incomoing cell fullness: %2.3f%%\n",

    printf("Average incoming cell fullness: %2.3f%%\n",

           100*(((double)stats_n_data_bytes_received) / 

                (stats_n_data_cells_received*(CELL_PAYLOAD_SIZE-RELAY_HEADER_SIZE))) );

src/or/or.h

+3 −1
Original line number Diff line number Diff line
@@ -575,7 +575,9 @@ void assert_connection_ok(connection_t *conn, time_t now); 
/********************************* connection_edge.c ***************************/



int connection_edge_process_inbuf(connection_t *conn);

int connection_edge_send_command(connection_t *fromconn, circuit_t *circ, int relay_command);

void connection_edge_send_command(connection_t *fromconn, circuit_t *circ, int relay_command,

                                  void *payload, int payload_len, crypt_path_t *cpath_layer);



int connection_edge_process_relay_cell(cell_t *cell, circuit_t *circ, connection_t *conn,

                                       int edge_type, crypt_path_t *layer_hint);

int connection_edge_finished_flushing(connection_t *conn);