nihilist/tor
1
0
Fork 0
mirror of https://gitlab.torproject.org/tpo/core/tor.git synced 2024-11-28 14:23:30 +01:00
Code Issues Packages Projects Releases Wiki Activity

s/cell_queue/incoming_queue/g in channel.c for consistency with outgoing_queue

Browse Source
This commit is contained in:
Andrea Shepard 2012-10-08 20:20:28 -07:00
parent 4686638743
commit ee4e88e4d9
No known key found for this signature in database
GPG Key ID: 80BF498218A1E61B
2 changed files with 34 additions and 34 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

66
src/or/channel.c
View File

@ -783,14 +783,14 @@ channel_force_free(channel_t *chan)
smartlist_free(chan->u.cell_chan.active_circuit_pqueue); smartlist_free(chan->u.cell_chan.active_circuit_pqueue);
/* We might still have a cell queue; kill it */ /* We might still have a cell queue; kill it */
if (chan->u.cell_chan.cell_queue) { if (chan->u.cell_chan.incoming_queue) {
SMARTLIST_FOREACH_BEGIN(chan->u.cell_chan.cell_queue, SMARTLIST_FOREACH_BEGIN(chan->u.cell_chan.incoming_queue,
cell_queue_entry_t *, q) { cell_queue_entry_t *, q) {
tor_free(q); tor_free(q);
} SMARTLIST_FOREACH_END(q); } SMARTLIST_FOREACH_END(q);
smartlist_free(chan->u.cell_chan.cell_queue); smartlist_free(chan->u.cell_chan.incoming_queue);
chan->u.cell_chan.cell_queue = NULL; chan->u.cell_chan.incoming_queue = NULL;
} }
/* Outgoing cell queue is similar, but we can have to free packed cells */ /* Outgoing cell queue is similar, but we can have to free packed cells */
@ -957,8 +957,8 @@ channel_set_cell_handlers(channel_t *chan,
chan->u.cell_chan.var_cell_handler = var_cell_handler; chan->u.cell_chan.var_cell_handler = var_cell_handler;
/* Re-run the queue if we have one and there's any reason to */ /* Re-run the queue if we have one and there's any reason to */
if (chan->u.cell_chan.cell_queue && if (chan->u.cell_chan.incoming_queue &&
(smartlist_len(chan->u.cell_chan.cell_queue) > 0) && (smartlist_len(chan->u.cell_chan.incoming_queue) > 0) &&
try_again && try_again &&
(chan->u.cell_chan.cell_handler || (chan->u.cell_chan.cell_handler ||
chan->u.cell_chan.var_cell_handler)) channel_process_cells(chan); chan->u.cell_chan.var_cell_handler)) channel_process_cells(chan);
@ -1633,8 +1633,8 @@ channel_change_state(channel_t *chan, channel_state_t to_state)
if (!(chan->is_listener) && if (!(chan->is_listener) &&
to_state == CHANNEL_STATE_OPEN) { to_state == CHANNEL_STATE_OPEN) {
/* Check for queued cells to process */ /* Check for queued cells to process */
if (chan->u.cell_chan.cell_queue && if (chan->u.cell_chan.incoming_queue &&
smartlist_len(chan->u.cell_chan.cell_queue) > 0) smartlist_len(chan->u.cell_chan.incoming_queue) > 0)
channel_process_cells(chan); channel_process_cells(chan);
if (chan->u.cell_chan.outgoing_queue && if (chan->u.cell_chan.outgoing_queue &&
smartlist_len(chan->u.cell_chan.outgoing_queue) > 0) smartlist_len(chan->u.cell_chan.outgoing_queue) > 0)
@ -1646,8 +1646,8 @@ channel_change_state(channel_t *chan, channel_state_t to_state)
tor_assert(!(chan->u.listener.incoming_list) || tor_assert(!(chan->u.listener.incoming_list) ||
smartlist_len(chan->u.listener.incoming_list) == 0); smartlist_len(chan->u.listener.incoming_list) == 0);
} else { } else {
tor_assert(!(chan->u.cell_chan.cell_queue) || tor_assert(!(chan->u.cell_chan.incoming_queue) ||
smartlist_len(chan->u.cell_chan.cell_queue) == 0); smartlist_len(chan->u.cell_chan.incoming_queue) == 0);
tor_assert(!(chan->u.cell_chan.outgoing_queue) || tor_assert(!(chan->u.cell_chan.outgoing_queue) ||
smartlist_len(chan->u.cell_chan.outgoing_queue) == 0); smartlist_len(chan->u.cell_chan.outgoing_queue) == 0);
} }
@ -1881,8 +1881,8 @@ channel_more_to_flush(channel_t *chan)
tor_assert(!(chan->is_listener)); tor_assert(!(chan->is_listener));
/* Check if we have any queued */ /* Check if we have any queued */
if (chan->u.cell_chan.cell_queue && if (chan->u.cell_chan.incoming_queue &&
smartlist_len(chan->u.cell_chan.cell_queue) > 0) return 1; smartlist_len(chan->u.cell_chan.incoming_queue) > 0) return 1;
/* Check if any circuits would like to queue some */ /* Check if any circuits would like to queue some */
if (chan->u.cell_chan.active_circuits) return 1; if (chan->u.cell_chan.active_circuits) return 1;
@ -2108,13 +2108,13 @@ channel_process_cells(channel_t *chan)
if (!(chan->u.cell_chan.cell_handler || if (!(chan->u.cell_chan.cell_handler ||
chan->u.cell_chan.var_cell_handler)) return; chan->u.cell_chan.var_cell_handler)) return;
/* Nothing we can do if we have no cells */ /* Nothing we can do if we have no cells */
if (!(chan->u.cell_chan.cell_queue)) return; if (!(chan->u.cell_chan.incoming_queue)) return;
/* /*
* Process cells until we're done or find one we have no current handler * Process cells until we're done or find one we have no current handler
* for. * for.
*/ */
SMARTLIST_FOREACH_BEGIN(chan->u.cell_chan.cell_queue, SMARTLIST_FOREACH_BEGIN(chan->u.cell_chan.incoming_queue,
cell_queue_entry_t *, q) { cell_queue_entry_t *, q) {
tor_assert(q); tor_assert(q);
tor_assert(q->type == CELL_QUEUE_FIXED || tor_assert(q->type == CELL_QUEUE_FIXED ||
@ -2128,7 +2128,7 @@ channel_process_cells(channel_t *chan)
"Processing incoming cell_t %p for channel %p", "Processing incoming cell_t %p for channel %p",
q->u.fixed.cell, chan); q->u.fixed.cell, chan);
chan->u.cell_chan.cell_handler(chan, q->u.fixed.cell); chan->u.cell_chan.cell_handler(chan, q->u.fixed.cell);
SMARTLIST_DEL_CURRENT(chan->u.cell_chan.cell_queue, q); SMARTLIST_DEL_CURRENT(chan->u.cell_chan.incoming_queue, q);
tor_free(q); tor_free(q);
} else if (q->type == CELL_QUEUE_VAR && } else if (q->type == CELL_QUEUE_VAR &&
chan->u.cell_chan.var_cell_handler) { chan->u.cell_chan.var_cell_handler) {
@ -2138,7 +2138,7 @@ channel_process_cells(channel_t *chan)
"Processing incoming var_cell_t %p for channel %p", "Processing incoming var_cell_t %p for channel %p",
q->u.var.var_cell, chan); q->u.var.var_cell, chan);
chan->u.cell_chan.var_cell_handler(chan, q->u.var.var_cell); chan->u.cell_chan.var_cell_handler(chan, q->u.var.var_cell);
SMARTLIST_DEL_CURRENT(chan->u.cell_chan.cell_queue, q); SMARTLIST_DEL_CURRENT(chan->u.cell_chan.incoming_queue, q);
tor_free(q); tor_free(q);
} else { } else {
/* Can't handle this one */ /* Can't handle this one */
@ -2147,9 +2147,9 @@ channel_process_cells(channel_t *chan)
} SMARTLIST_FOREACH_END(q); } SMARTLIST_FOREACH_END(q);
/* If the list is empty, free it */ /* If the list is empty, free it */
if (smartlist_len(chan->u.cell_chan.cell_queue) == 0 ) { if (smartlist_len(chan->u.cell_chan.incoming_queue) == 0 ) {
smartlist_free(chan->u.cell_chan.cell_queue); smartlist_free(chan->u.cell_chan.incoming_queue);
chan->u.cell_chan.cell_queue = NULL; chan->u.cell_chan.incoming_queue = NULL;
} }
} }
@ -2176,13 +2176,13 @@ channel_queue_cell(channel_t *chan, cell_t *cell)
/* Do we need to queue it, or can we just call the handler right away? */ /* Do we need to queue it, or can we just call the handler right away? */
if (!(chan->u.cell_chan.cell_handler)) need_to_queue = 1; if (!(chan->u.cell_chan.cell_handler)) need_to_queue = 1;
if (chan->u.cell_chan.cell_queue && if (chan->u.cell_chan.incoming_queue &&
(smartlist_len(chan->u.cell_chan.cell_queue) > 0)) (smartlist_len(chan->u.cell_chan.incoming_queue) > 0))
need_to_queue = 1; need_to_queue = 1;
/* If we need to queue and have no queue, create one */ /* If we need to queue and have no queue, create one */
if (need_to_queue && !(chan->u.cell_chan.cell_queue)) { if (need_to_queue && !(chan->u.cell_chan.incoming_queue)) {
chan->u.cell_chan.cell_queue = smartlist_new(); chan->u.cell_chan.incoming_queue = smartlist_new();
} }
/* Timestamp for receiving */ /* Timestamp for receiving */
@ -2200,14 +2200,14 @@ channel_queue_cell(channel_t *chan, cell_t *cell)
chan->u.cell_chan.cell_handler(chan, cell); chan->u.cell_chan.cell_handler(chan, cell);
} else { } else {
/* Otherwise queue it and then process the queue if possible. */ /* Otherwise queue it and then process the queue if possible. */
tor_assert(chan->u.cell_chan.cell_queue); tor_assert(chan->u.cell_chan.incoming_queue);
q = tor_malloc(sizeof(*q)); q = tor_malloc(sizeof(*q));
q->type = CELL_QUEUE_FIXED; q->type = CELL_QUEUE_FIXED;
q->u.fixed.cell = cell; q->u.fixed.cell = cell;
log_debug(LD_CHANNEL, log_debug(LD_CHANNEL,
"Queueing incoming cell_t %p for channel %p", "Queueing incoming cell_t %p for channel %p",
cell, chan); cell, chan);
smartlist_add(chan->u.cell_chan.cell_queue, q); smartlist_add(chan->u.cell_chan.incoming_queue, q);
if (chan->u.cell_chan.cell_handler || if (chan->u.cell_chan.cell_handler ||
chan->u.cell_chan.var_cell_handler) { chan->u.cell_chan.var_cell_handler) {
channel_process_cells(chan); channel_process_cells(chan);
@ -2238,13 +2238,13 @@ channel_queue_var_cell(channel_t *chan, var_cell_t *var_cell)
/* Do we need to queue it, or can we just call the handler right away? */ /* Do we need to queue it, or can we just call the handler right away? */
if (!(chan->u.cell_chan.var_cell_handler)) need_to_queue = 1; if (!(chan->u.cell_chan.var_cell_handler)) need_to_queue = 1;
if (chan->u.cell_chan.cell_queue && if (chan->u.cell_chan.incoming_queue &&
(smartlist_len(chan->u.cell_chan.cell_queue) > 0)) (smartlist_len(chan->u.cell_chan.incoming_queue) > 0))
need_to_queue = 1; need_to_queue = 1;
/* If we need to queue and have no queue, create one */ /* If we need to queue and have no queue, create one */
if (need_to_queue && !(chan->u.cell_chan.cell_queue)) { if (need_to_queue && !(chan->u.cell_chan.incoming_queue)) {
chan->u.cell_chan.cell_queue = smartlist_new(); chan->u.cell_chan.incoming_queue = smartlist_new();
} }
/* Timestamp for receiving */ /* Timestamp for receiving */
@ -2262,14 +2262,14 @@ channel_queue_var_cell(channel_t *chan, var_cell_t *var_cell)
chan->u.cell_chan.var_cell_handler(chan, var_cell); chan->u.cell_chan.var_cell_handler(chan, var_cell);
} else { } else {
/* Otherwise queue it and then process the queue if possible. */ /* Otherwise queue it and then process the queue if possible. */
tor_assert(chan->u.cell_chan.cell_queue); tor_assert(chan->u.cell_chan.incoming_queue);
q = tor_malloc(sizeof(*q)); q = tor_malloc(sizeof(*q));
q->type = CELL_QUEUE_VAR; q->type = CELL_QUEUE_VAR;
q->u.var.var_cell = var_cell; q->u.var.var_cell = var_cell;
log_debug(LD_CHANNEL, log_debug(LD_CHANNEL,
"Queueing incoming var_cell_t %p for channel %p", "Queueing incoming var_cell_t %p for channel %p",
var_cell, chan); var_cell, chan);
smartlist_add(chan->u.cell_chan.cell_queue, q); smartlist_add(chan->u.cell_chan.incoming_queue, q);
if (chan->u.cell_chan.cell_handler || if (chan->u.cell_chan.cell_handler ||
chan->u.cell_chan.var_cell_handler) { chan->u.cell_chan.var_cell_handler) {
channel_process_cells(chan); channel_process_cells(chan);
@ -2864,8 +2864,8 @@ channel_dump_statistics(channel_t *chan, int severity)
" * Cell-bearing channel " U64_FORMAT " has %d queued incoming cells" " * Cell-bearing channel " U64_FORMAT " has %d queued incoming cells"
" and %d queued outgoing cells", " and %d queued outgoing cells",
U64_PRINTF_ARG(chan->global_identifier), U64_PRINTF_ARG(chan->global_identifier),
(chan->u.cell_chan.cell_queue != NULL) ? (chan->u.cell_chan.incoming_queue != NULL) ?
smartlist_len(chan->u.cell_chan.cell_queue) : 0, smartlist_len(chan->u.cell_chan.incoming_queue) : 0,
(chan->u.cell_chan.outgoing_queue != NULL) ? (chan->u.cell_chan.outgoing_queue != NULL) ?
smartlist_len(chan->u.cell_chan.outgoing_queue) : 0); smartlist_len(chan->u.cell_chan.outgoing_queue) : 0);

2
src/or/channel.h
View File

@ -132,7 +132,7 @@ struct channel_s {
channel_t *next_with_same_id, *prev_with_same_id; channel_t *next_with_same_id, *prev_with_same_id;
/* List of incoming cells to handle */ /* List of incoming cells to handle */
smartlist_t *cell_queue; smartlist_t *incoming_queue;
/* List of queued outgoing cells */ /* List of queued outgoing cells */
smartlist_t *outgoing_queue; smartlist_t *outgoing_queue;