connection.c 23.4 KB
Newer Older
1
2
3
/* Copyright 2001,2002 Roger Dingledine, Matej Pfajfar. */
/* See LICENSE for licensing information */
/* $Id$ */
Roger Dingledine's avatar
Roger Dingledine committed
4
5
6
7
8

#include "or.h"

/********* START VARIABLES **********/

9
10
extern or_options_t options; /* command-line and config-file options */

Roger Dingledine's avatar
Roger Dingledine committed
11
char *conn_type_to_string[] = {
12
13
14
15
16
17
18
  "",            /* 0 */
  "OP listener", /* 1 */
  "OP",          /* 2 */
  "OR listener", /* 3 */
  "OR",          /* 4 */
  "Exit",        /* 5 */
  "App listener",/* 6 */
19
20
21
  "App",         /* 7 */
  "Dir listener",/* 8 */
  "Dir",         /* 9 */
Roger Dingledine's avatar
Roger Dingledine committed
22
23
};

24
char *conn_state_to_string[][15] = {
25
  { },         /* no type associated with 0 */
Roger Dingledine's avatar
Roger Dingledine committed
26
27
28
29
30
31
  { "ready" }, /* op listener, 0 */
  { "awaiting keys", /* op, 0 */
    "open",              /* 1 */
    "close",             /* 2 */
    "close_wait" },      /* 3 */
  { "ready" }, /* or listener, 0 */
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
  { "connecting (as OP)",       /* or, 0 */
    "sending keys (as OP)",         /* 1 */
    "connecting (as client)",       /* 2 */
    "sending auth (as client)",     /* 3 */
    "waiting for auth (as client)", /* 4 */
    "sending nonce (as client)",    /* 5 */
    "waiting for auth (as server)", /* 6 */
    "sending auth (as server)",     /* 7 */
    "waiting for nonce (as server)",/* 8 */
    "open" },                       /* 9 */
  { "waiting for dest info",     /* exit, 0 */
    "connecting",                      /* 1 */
    "open" },                          /* 2 */
  { "ready" }, /* app listener, 0 */
  { "awaiting dest info",         /* app, 0 */
    "waiting for OR connection",       /* 1 */
48
49
50
51
52
53
54
    "open" },                          /* 2 */
  { "ready" }, /* dir listener, 0 */
  { "connecting",                      /* 0 */
    "sending command",                 /* 1 */
    "reading",                         /* 2 */
    "awaiting command",                /* 3 */
    "writing" },                       /* 4 */
Roger Dingledine's avatar
Roger Dingledine committed
55
56
57
58
};

/********* END VARIABLES ************/

59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
/**************************************************************/

int tv_cmp(struct timeval *a, struct timeval *b) {
        if (a->tv_sec > b->tv_sec)
                return 1;
        if (a->tv_sec < b->tv_sec)
                return -1;
        if (a->tv_usec > b->tv_usec)
                return 1;
        if (a->tv_usec < b->tv_usec)
                return -1;
        return 0;
}

void tv_add(struct timeval *a, struct timeval *b) {
        a->tv_usec += b->tv_usec;
        a->tv_sec += b->tv_sec + (a->tv_usec / 1000000);
        a->tv_usec %= 1000000;
}

void tv_addms(struct timeval *a, long ms) {
        a->tv_usec += (ms * 1000) % 1000000;
        a->tv_sec += ((ms * 1000) / 1000000) + (a->tv_usec / 1000000);
        a->tv_usec %= 1000000;
}

/**************************************************************/

Roger Dingledine's avatar
Roger Dingledine committed
87
88
89
90
91
92
93
94
95
connection_t *connection_new(int type) {
  connection_t *conn;

  conn = (connection_t *)malloc(sizeof(connection_t));
  if(!conn)
    return NULL;
  memset(conn,0,sizeof(connection_t)); /* zero it out to start */

  conn->type = type;
96
97
98
  if(buf_new(&conn->inbuf, &conn->inbuflen, &conn->inbuf_datalen) < 0 ||
     buf_new(&conn->outbuf, &conn->outbuflen, &conn->outbuf_datalen) < 0)
    return NULL;
Roger Dingledine's avatar
Roger Dingledine committed
99

100
101
  conn->receiver_bucket = 10240; /* should be enough to do the handshake */
  conn->bandwidth = conn->receiver_bucket / 10; /* give it a default */
102
103
104
105
106
107
108
109
110
111
112
113
114
115
  
  if (connection_speaks_cells(conn)) {
    conn->f_crypto = crypto_new_cipher_env(CRYPTO_CIPHER_DES);
    if (!conn->f_crypto) {
      free((void *)conn);
      return NULL;
    }
    conn->b_crypto = crypto_new_cipher_env(CRYPTO_CIPHER_DES);
    if (!conn->b_crypto) {
      crypto_free_cipher_env(conn->f_crypto);
      free((void *)conn);
      return NULL;
    }
  }
Roger Dingledine's avatar
Roger Dingledine committed
116
117
118
119
120
121
122
123
124
125
  return conn;
}

void connection_free(connection_t *conn) {
  assert(conn);

  buf_free(conn->inbuf);
  buf_free(conn->outbuf);
  if(conn->address)
    free(conn->address);
126
127
  if(conn->dest_addr)
    free(conn->dest_addr);
Roger Dingledine's avatar
Roger Dingledine committed
128

129
  if(connection_speaks_cells(conn)) {
130
131
132
133
    if (conn->f_crypto)
      crypto_free_cipher_env(conn->f_crypto);
    if (conn->b_crypto)
      crypto_free_cipher_env(conn->b_crypto);
Roger Dingledine's avatar
Roger Dingledine committed
134
135
  }

136
137
138
139
140
  if (conn->pkey)
    crypto_free_pk_env(conn->pkey);
  if (conn->prkey)
    crypto_free_pk_env(conn->prkey);

141
142
  if(conn->s > 0) {
    log(LOG_INFO,"connection_free(): closing fd %d.",conn->s);
Roger Dingledine's avatar
Roger Dingledine committed
143
    close(conn->s);
144
  }
Roger Dingledine's avatar
Roger Dingledine committed
145
146
147
  free(conn);
}

148
int connection_create_listener(crypto_pk_env_t *prkey, struct sockaddr_in *local, int type) {
Roger Dingledine's avatar
Roger Dingledine committed
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
  connection_t *conn;
  int s;
  int one=1;

  s = socket(PF_INET,SOCK_STREAM,IPPROTO_TCP);
  if (s < 0)
  { 
    log(LOG_ERR,"connection_create_listener(): Socket creation failed.");
    return -1;
  }

  setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));

  if(bind(s,(struct sockaddr *)local,sizeof(*local)) < 0) {
    perror("bind ");
    log(LOG_ERR,"Could not bind to local port %u.",ntohs(local->sin_port));
    return -1;
  }

  /* start local server */
  if(listen(s,SOMAXCONN) < 0) {
    log(LOG_ERR,"Could not listen on local port %u.",ntohs(local->sin_port));
    return -1;
  }

  fcntl(s, F_SETFL, O_NONBLOCK); /* set s to non-blocking */

  conn = connection_new(type);
177
178
  if(!conn) {
    log(LOG_DEBUG,"connection_create_listener(): connection_new failed. Giving up.");
179
    return -1;
180
  }
Roger Dingledine's avatar
Roger Dingledine committed
181
182
183
  conn->s = s;

  if(connection_add(conn) < 0) { /* no space, forget it */
184
    log(LOG_DEBUG,"connection_create_listener(): connection_add failed. Giving up.");
Roger Dingledine's avatar
Roger Dingledine committed
185
186
187
188
189
190
    connection_free(conn);
    return -1;
  }

  /* remember things so you can tell the baby sockets */
  memcpy(&conn->local,local,sizeof(struct sockaddr_in));
191
192
  if(prkey)
    conn->prkey = crypto_pk_dup_key(prkey);
Roger Dingledine's avatar
Roger Dingledine committed
193
194
195
196

  log(LOG_DEBUG,"connection_create_listener(): Listening on local port %u.",ntohs(local->sin_port));

  conn->state = LISTENER_STATE_READY;
197
  connection_start_reading(conn);
Roger Dingledine's avatar
Roger Dingledine committed
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216

  return 0;
}

int connection_handle_listener_read(connection_t *conn, int new_type, int new_state) {

  int news; /* the new socket */
  connection_t *newconn;
  struct sockaddr_in remote; /* information about the remote peer when connecting to other routers */
  int remotelen = sizeof(struct sockaddr_in); /* length of the remote address */

  news = accept(conn->s,(struct sockaddr *)&remote,&remotelen);
  if (news == -1) { /* accept() error */
    if(errno==EAGAIN)
      return 0; /* he hung up before we could accept(). that's fine. */
    /* else there was a real error. */
    log(LOG_ERR,"connection_handle_listener_read(): accept() failed. Closing.");
    return -1;
  }
217
  log(LOG_INFO,"Connection accepted on socket %d (child of fd %d).",news, conn->s);
Roger Dingledine's avatar
Roger Dingledine committed
218

Roger Dingledine's avatar
Roger Dingledine committed
219
  fcntl(news, F_SETFL, O_NONBLOCK); /* set news to non-blocking */
220

Roger Dingledine's avatar
Roger Dingledine committed
221
222
223
  newconn = connection_new(new_type);
  newconn->s = news;

224
225
226
227
228
  if(!connection_speaks_cells(newconn)) {
    newconn->receiver_bucket = -1;
    newconn->bandwidth = -1;
  }

Roger Dingledine's avatar
Roger Dingledine committed
229
230
  /* learn things from parent, so we can perform auth */
  memcpy(&newconn->local,&conn->local,sizeof(struct sockaddr_in));
231
232
  if(conn->prkey)
    newconn->prkey = crypto_pk_dup_key(conn->prkey);
233
  newconn->address = strdup(inet_ntoa(remote.sin_addr)); /* remember the remote address */
Roger Dingledine's avatar
Roger Dingledine committed
234
235
236

  if(connection_add(newconn) < 0) { /* no space, forget it */
    connection_free(newconn);
237
    return 0; /* no need to tear down the parent */
Roger Dingledine's avatar
Roger Dingledine committed
238
239
240
241
  }

  log(LOG_DEBUG,"connection_handle_listener_read(): socket %d entered state %d.",newconn->s, new_state);
  newconn->state = new_state;
242
  connection_start_reading(newconn);
Roger Dingledine's avatar
Roger Dingledine committed
243
244
245
246

  return 0;
}

247
248
/* private function, to create the 'local' variable used below */
static int learn_local(struct sockaddr_in *local) {
Roger Dingledine's avatar
Roger Dingledine committed
249
250
251
252
253
254
255
256
257
  /* local host information */
  char localhostname[512];
  struct hostent *localhost;

  /* obtain local host information */
  if(gethostname(localhostname,512) < 0) {
    log(LOG_ERR,"Error obtaining local hostname.");
    return -1;
  }
258
  log(LOG_DEBUG,"learn_local: localhostname is '%s'.",localhostname);
Roger Dingledine's avatar
Roger Dingledine committed
259
260
261
262
263
  localhost = gethostbyname(localhostname);
  if (!localhost) {
    log(LOG_ERR,"Error obtaining local host info.");
    return -1;
  }
264
265
266
  memset((void *)local,0,sizeof(struct sockaddr_in));
  local->sin_family = AF_INET;
  memcpy((void *)&local->sin_addr,(void *)localhost->h_addr,sizeof(struct in_addr));
267
  log(LOG_DEBUG,"learn_local: chose address as '%s'.",inet_ntoa(local->sin_addr));
268
269
270
271

  return 0;
}

272
273
int retry_all_connections(int role, crypto_pk_env_t *prkey, uint16_t or_listenport,
  uint16_t op_listenport, uint16_t ap_listenport, uint16_t dir_listenport) {
274
275
276
277
278
279
280
281
282

  /* start all connections that should be up but aren't */

  struct sockaddr_in local; /* local address */

  if(learn_local(&local) < 0)
    return -1;

  local.sin_port = htons(or_listenport);
283

284
  if(role & ROLE_OR_CONNECT_ALL) {
285
    router_retry_connections(prkey, &local);
Roger Dingledine's avatar
Roger Dingledine committed
286
287
  }

288
289
290
291
  if(role & ROLE_OR_LISTEN) {
    if(!connection_get_by_type(CONN_TYPE_OR_LISTENER)) {
      connection_or_create_listener(prkey, &local);
    }
Roger Dingledine's avatar
Roger Dingledine committed
292
293
  }
      
294
295
296
297
298
299
300
301
302
303
304
305
  if(role & ROLE_OP_LISTEN) {
    local.sin_port = htons(op_listenport);
    if(!connection_get_by_type(CONN_TYPE_OP_LISTENER)) {
      connection_op_create_listener(prkey, &local);
    }
  }

  if(role & ROLE_AP_LISTEN) {
    local.sin_port = htons(ap_listenport);
    if(!connection_get_by_type(CONN_TYPE_AP_LISTENER)) {
      connection_ap_create_listener(NULL, &local); /* no need to tell it the private key. */
    }
Roger Dingledine's avatar
Roger Dingledine committed
306
  }
307
308
309
310
311
312
313

  if(role & ROLE_DIR_LISTEN) {
    local.sin_port = htons(dir_listenport);
    if(!connection_get_by_type(CONN_TYPE_DIR_LISTENER)) {
      connection_dir_create_listener(NULL, &local); /* no need to tell it the private key. */
    }
  }
Roger Dingledine's avatar
Roger Dingledine committed
314
315
316
317
 
  return 0;
}

318
connection_t *connection_connect_to_router_as_op(routerinfo_t *router, uint16_t local_or_port) {
319
320
321
322
323
  struct sockaddr_in local; /* local address */

  if(learn_local(&local) < 0)
    return NULL;
  local.sin_port = htons(local_or_port);
324
  return connection_or_connect_as_op(router, &local);
325
326
}

Roger Dingledine's avatar
Roger Dingledine committed
327
int connection_read_to_buf(connection_t *conn) {
328
329
  int read_result;

330
331
332
333
334
335
  if(connection_speaks_cells(conn)) {
    assert(conn->receiver_bucket >= 0);
  }
  if(!connection_speaks_cells(conn)) {
    assert(conn->receiver_bucket < 0);
  }
336
337
  read_result = read_to_buf(conn->s, conn->receiver_bucket, &conn->inbuf, &conn->inbuflen,
                            &conn->inbuf_datalen, &conn->inbuf_reached_eof);
338
339
//  log(LOG_DEBUG,"connection_read_to_buf(): read_to_buf returned %d.",read_result);
  if(read_result >= 0 && connection_speaks_cells(conn)) {
340
341
342
    conn->receiver_bucket -= read_result;
    if(conn->receiver_bucket <= 0) {

343
//      log(LOG_DEBUG,"connection_read_to_buf() stopping reading, receiver bucket full.");
344
345
346
347
348
349
350
351
352
353
354
      connection_stop_reading(conn);

      /* If we're not in 'open' state here, then we're never going to finish the
       * handshake, because we'll never increment the receiver_bucket. But we
       * can't check for that here, because the buf we just read might have enough
       * on it to finish the handshake. So we check for that in check_conn_read().
       */
    }
  }

  return read_result;
Roger Dingledine's avatar
Roger Dingledine committed
355
356
357
358
359
360
}

int connection_fetch_from_buf(char *string, int len, connection_t *conn) {
  return fetch_from_buf(string, len, &conn->inbuf, &conn->inbuflen, &conn->inbuf_datalen);
}

361
362
363
364
365
366
367
368
int connection_wants_to_flush(connection_t *conn) {
  return conn->outbuf_flushlen;
}

int connection_outbuf_too_full(connection_t *conn) {
  return (conn->outbuf_flushlen > 10*CELL_PAYLOAD_SIZE);
}

Roger Dingledine's avatar
Roger Dingledine committed
369
int connection_flush_buf(connection_t *conn) {
370
  return flush_buf(conn->s, &conn->outbuf, &conn->outbuflen, &conn->outbuf_flushlen, &conn->outbuf_datalen);
Roger Dingledine's avatar
Roger Dingledine committed
371
372
373
374
375
}

int connection_write_to_buf(char *string, int len, connection_t *conn) {
  if(!len)
    return 0;
376

377
  if( (!connection_speaks_cells(conn)) ||
378
379
380
381
      (!connection_state_is_open(conn)) ||
      (options.LinkPadding == 0) ) {
    /* connection types other than or and op, or or/op not in 'open' state, should flush immediately */
    /* also flush immediately if we're not doing LinkPadding, since otherwise it will never flush */
382
    connection_start_writing(conn);
383
384
385
    conn->outbuf_flushlen += len;
  }

Roger Dingledine's avatar
Roger Dingledine committed
386
387
388
  return write_to_buf(string, len, &conn->outbuf, &conn->outbuflen, &conn->outbuf_datalen);
}

389
390
391
int connection_receiver_bucket_should_increase(connection_t *conn) {
  assert(conn);

392
393
394
  if(!connection_speaks_cells(conn))
    return 0; /* edge connections don't use receiver_buckets */

395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
  if(conn->receiver_bucket > 10*conn->bandwidth)
    return 0;

  return 1;
}

void connection_increment_receiver_bucket (connection_t *conn) {
  assert(conn);

  if(connection_receiver_bucket_should_increase(conn)) {
    /* yes, the receiver_bucket can become overfull here. But not by much. */
    conn->receiver_bucket += conn->bandwidth*1.1;
    if(connection_state_is_open(conn)) {
      /* if we're in state 'open', then start reading again */
      connection_start_reading(conn);
    }
  }
}

414
415
416
417
418
419
420
421
422
int connection_speaks_cells(connection_t *conn) {
  assert(conn);

  if(conn->type == CONN_TYPE_OR || conn->type == CONN_TYPE_OP)
    return 1;

  return 0;
}

423
424
425
int connection_is_listener(connection_t *conn) {
  if(conn->type == CONN_TYPE_OP_LISTENER ||
     conn->type == CONN_TYPE_OR_LISTENER ||
426
427
     conn->type == CONN_TYPE_AP_LISTENER ||
     conn->type == CONN_TYPE_DIR_LISTENER)
428
429
430
431
    return 1;
  return 0;
}

432
433
434
435
436
437
438
439
440
441
442
443
444
445
int connection_state_is_open(connection_t *conn) {
  assert(conn);

  if((conn->type == CONN_TYPE_OR && conn->state == OR_CONN_STATE_OPEN) ||
     (conn->type == CONN_TYPE_OP && conn->state == OP_CONN_STATE_OPEN) ||
     (conn->type == CONN_TYPE_AP && conn->state == AP_CONN_STATE_OPEN) ||
     (conn->type == CONN_TYPE_EXIT && conn->state == EXIT_CONN_STATE_OPEN))
    return 1;

  return 0;
}

void connection_send_cell(connection_t *conn) {
  cell_t cell;
Roger Dingledine's avatar
Roger Dingledine committed
446
447
448
449
  int bytes_in_full_flushlen;

  /* this function only gets called if options.LinkPadding is 1 */
  assert(options.LinkPadding == 1);
450
451
452

  assert(conn);

453
  if(!connection_speaks_cells(conn)) {
454
455
456
457
458
459
460
461
462
463
464
465
466
    /* this conn doesn't speak cells. do nothing. */
    return;
  }

  if(!connection_state_is_open(conn)) {
    /* it's not in 'open' state, all data should already be waiting to be flushed */
    assert(conn->outbuf_datalen == conn->outbuf_flushlen);
    return;
  }

#if 0 /* use to send evenly spaced cells, but not padding */
  if(conn->outbuf_datalen - conn->outbuf_flushlen >= sizeof(cell_t)) {
    conn->outbuf_flushlen += sizeof(cell_t); /* instruct it to send a cell */
467
    connection_start_writing(conn);
468
469
470
  }
#endif

Roger Dingledine's avatar
Roger Dingledine committed
471
472
473
474
475
476
477
478
479
480
481
  connection_increment_send_timeval(conn); /* update when we'll send the next cell */

  bytes_in_full_flushlen = conn->bandwidth / 100; /* 10ms worth */
  if(bytes_in_full_flushlen < 10*sizeof(cell_t))
    bytes_in_full_flushlen = 10*sizeof(cell_t); /* but at least 10 cells worth */

  if(conn->outbuf_flushlen > bytes_in_full_flushlen - sizeof(cell_t)) {
    /* if we would exceed bytes_in_full_flushlen by adding a new cell */
    return;
  }

482
483
484
485
486
487
488
489
  if(conn->outbuf_datalen - conn->outbuf_flushlen < sizeof(cell_t)) {
    /* we need to queue a padding cell first */
    memset(&cell,0,sizeof(cell_t));
    cell.command = CELL_PADDING;
    connection_write_cell_to_buf(&cell, conn);
  }

  conn->outbuf_flushlen += sizeof(cell_t); /* instruct it to send a cell */
490
  connection_start_writing(conn);
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510

}

void connection_increment_send_timeval(connection_t *conn) {
  /* add "1000000 * sizeof(cell_t) / conn->bandwidth" microseconds to conn->send_timeval */
  /* FIXME should perhaps use ceil() of this. For now I simply add 1. */

  tv_addms(&conn->send_timeval, 1+1000 * sizeof(cell_t) / conn->bandwidth);
}

void connection_init_timeval(connection_t *conn) {

  assert(conn);

  if(gettimeofday(&conn->send_timeval,NULL) < 0)
    return;

  connection_increment_send_timeval(conn);
}

Roger Dingledine's avatar
Roger Dingledine committed
511
512
513
int connection_send_destroy(aci_t aci, connection_t *conn) {
  cell_t cell;

514
  assert(conn);
Roger Dingledine's avatar
Roger Dingledine committed
515

516
  if(!connection_speaks_cells(conn)) {
517
     log(LOG_INFO,"connection_send_destroy(): Aci %d: At an edge. Marking connection for close.", aci);
Roger Dingledine's avatar
Roger Dingledine committed
518
519
520
521
522
523
     conn->marked_for_close = 1;
     return 0;
  }

  cell.aci = aci;
  cell.command = CELL_DESTROY;
524
  log(LOG_INFO,"connection_send_destroy(): Sending destroy (aci %d).",aci);
Roger Dingledine's avatar
Roger Dingledine committed
525
  return connection_write_cell_to_buf(&cell, conn);
Roger Dingledine's avatar
Roger Dingledine committed
526
527
528
529
}

int connection_send_connected(aci_t aci, connection_t *conn) {
  cell_t cell;
Roger Dingledine's avatar
Roger Dingledine committed
530

Roger Dingledine's avatar
Roger Dingledine committed
531
532
533
534
535
536
537
538
539
540
541
542
  assert(conn);

  if(!connection_speaks_cells(conn)) {
    log(LOG_INFO,"connection_send_connected(): Aci %d: At entry point. Notifying proxy.", aci);
    connection_ap_send_connected(conn);
    return 0;
  }

  cell.aci = aci;
  cell.command = CELL_CONNECTED;
  log(LOG_INFO,"connection_send_connected(): passing back cell (aci %d).",aci);
  return connection_write_cell_to_buf(&cell, conn);
Roger Dingledine's avatar
Roger Dingledine committed
543
544
545
546
}

int connection_write_cell_to_buf(cell_t *cellp, connection_t *conn) {
 
547
  if(connection_encrypt_cell(cellp,conn)<0) {
Roger Dingledine's avatar
Roger Dingledine committed
548
549
550
551
552
553
    return -1;
  }

  return connection_write_to_buf((char *)cellp, sizeof(cell_t), conn);
}

554
555
int connection_encrypt_cell(cell_t *cellp, connection_t *conn) {
  cell_t newcell;
556
#if 0
Roger Dingledine's avatar
Roger Dingledine committed
557
558
559
560
561
562
563
564
565
  int x;
  char *px;

  printf("Sending: Cell header plaintext: ");
  px = (char *)cellp;
  for(x=0;x<8;x++) {
    printf("%u ",px[x]);
  } 
  printf("\n");
566
#endif
Roger Dingledine's avatar
Roger Dingledine committed
567

Roger Dingledine's avatar
Roger Dingledine committed
568
  if(crypto_cipher_encrypt(conn->f_crypto, (char *)cellp, sizeof(cell_t), (char *)&newcell)) {
569
    log(LOG_ERR,"Could not encrypt cell for connection %s:%u.",conn->address,conn->port);
Roger Dingledine's avatar
Roger Dingledine committed
570
571
    return -1;
  }
572
#if 0
Roger Dingledine's avatar
Roger Dingledine committed
573
  printf("Sending: Cell header crypttext: ");
574
  px = (char *)&newcell;
Roger Dingledine's avatar
Roger Dingledine committed
575
  for(x=0;x<8;x++) {
576
    printf("%u ",px[x]);
Roger Dingledine's avatar
Roger Dingledine committed
577
578
  }
  printf("\n");
579
#endif
Roger Dingledine's avatar
Roger Dingledine committed
580

581
  memcpy(cellp,&newcell,sizeof(cell_t));
Roger Dingledine's avatar
Roger Dingledine committed
582
583
584
585
586
587
588
589
590
591
592
593
  return 0;
}

int connection_process_inbuf(connection_t *conn) {

  assert(conn);

  switch(conn->type) {
    case CONN_TYPE_OP:
      return connection_op_process_inbuf(conn);
    case CONN_TYPE_OR:
      return connection_or_process_inbuf(conn);
594
595
    case CONN_TYPE_EXIT:
      return connection_exit_process_inbuf(conn);
596
597
    case CONN_TYPE_AP:
      return connection_ap_process_inbuf(conn);
598
599
    case CONN_TYPE_DIR:
      return connection_dir_process_inbuf(conn);
Roger Dingledine's avatar
Roger Dingledine committed
600
601
602
603
604
605
    default:
      log(LOG_DEBUG,"connection_process_inbuf() got unexpected conn->type.");
      return -1;
  }
}

606
607
608
609
610
611
int connection_package_raw_inbuf(connection_t *conn) {
  int amount_to_process;
  cell_t cell;
  circuit_t *circ;

  assert(conn);
612
613
  assert(!connection_speaks_cells(conn));
  /* this function should never get called if the receiver_window is 0 */
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643

  amount_to_process = conn->inbuf_datalen;

  if(!amount_to_process)
    return 0;

  if(amount_to_process > CELL_PAYLOAD_SIZE) {
    cell.length = CELL_PAYLOAD_SIZE;
  } else {
    cell.length = amount_to_process;
  }

  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_raw_package_inbuf(): conn has no circuits!");
    return -1;
  }

  log(LOG_DEBUG,"connection_raw_package_inbuf(): Packaging %d bytes.",cell.length);
  if(circ->n_conn == conn) { /* send it backward. we're an exit. */
    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_raw_package_inbuf(): circuit_deliver_data_cell (backward) failed. Closing.");
      circuit_close(circ);
      return 0;
    }
644
645
646
647
648
649
650
    assert(circ->n_receive_window > 0);
    if(--circ->n_receive_window <= 0) { /* is it 0 after decrement? */
      connection_stop_reading(circ->n_conn);
      log(LOG_DEBUG,"connection_raw_package_inbuf(): receive_window at exit reached 0.");
      return 0; /* don't process the inbuf any more */
    }
    log(LOG_DEBUG,"connection_raw_package_inbuf(): receive_window at exit is %d",circ->n_receive_window);
651
652
653
654
655
656
657
658
659
  } else { /* send it forward. we're an AP */
    cell.aci = circ->n_aci;
    cell.command = CELL_DATA;
    if(circuit_deliver_data_cell(&cell, circ, circ->n_conn, 'e') < 0) {
      /* yes, we use 'e' here, because the AP connection must *encrypt* its input. */
      log(LOG_DEBUG,"connection_raw_package_inbuf(): circuit_deliver_data_cell (forward) failed. Closing.");
      circuit_close(circ);
      return 0;
    }
660
661
662
663
664
665
666
    assert(circ->p_receive_window > 0);
    if(--circ->p_receive_window <= 0) { /* is it 0 after decrement? */
      connection_stop_reading(circ->p_conn);
      log(LOG_DEBUG,"connection_raw_package_inbuf(): receive_window at AP reached 0.");
      return 0; /* don't process the inbuf any more */
    }
    log(LOG_DEBUG,"connection_raw_package_inbuf(): receive_window at AP is %d",circ->p_receive_window);
667
668
  }
  if(amount_to_process > CELL_PAYLOAD_SIZE)
669
    log(LOG_DEBUG,"connection_raw_package_inbuf(): recursing.");
670
671
672
673
    return connection_package_raw_inbuf(conn);
  return 0;
}

674
675
676
677
678
679
680
681
682
int connection_consider_sending_sendme(connection_t *conn) {
  circuit_t *circ;
  cell_t sendme;

  if(connection_outbuf_too_full(conn))
    return 0;

  circ = circuit_get_by_conn(conn);
  if(!circ) {
Roger Dingledine's avatar
Roger Dingledine committed
683
684
685
    /* this can legitimately happen if the destroy has already arrived and torn down the circuit */
    log(LOG_DEBUG,"connection_consider_sending_sendme(): No circuit associated with conn. Skipping.");
    return 0;
686
687
688
689
690
691
  }
  sendme.command = CELL_SENDME;
  sendme.length = RECEIVE_WINDOW_INCREMENT;

  if(circ->n_conn == conn) { /* we're at an exit */
    if(circ->p_receive_window < RECEIVE_WINDOW_START-RECEIVE_WINDOW_INCREMENT) {
Roger Dingledine's avatar
Roger Dingledine committed
692
      log(LOG_DEBUG,"connection_consider_sending_sendme(): Outbuf %d, Queueing sendme back.", conn->outbuf_flushlen);
693
694
695
696
697
698
      circ->p_receive_window += RECEIVE_WINDOW_INCREMENT;
      sendme.aci = circ->p_aci;
      return connection_write_cell_to_buf(&sendme, circ->p_conn); /* (clobbers sendme) */
    }
  } else { /* we're at an AP */
    if(circ->n_receive_window < RECEIVE_WINDOW_START-RECEIVE_WINDOW_INCREMENT) {
Roger Dingledine's avatar
Roger Dingledine committed
699
      log(LOG_DEBUG,"connection_consider_sending_sendme(): Outbuf %d, Queueing sendme forward.", conn->outbuf_flushlen);
700
701
702
703
704
705
706
707
      circ->n_receive_window += RECEIVE_WINDOW_INCREMENT;
      sendme.aci = circ->n_aci;
      return connection_write_cell_to_buf(&sendme, circ->n_conn); /* (clobbers sendme) */
    }
  }
  return 0;
} 

Roger Dingledine's avatar
Roger Dingledine committed
708
709
710
711
int connection_finished_flushing(connection_t *conn) {

  assert(conn);

712
//  log(LOG_DEBUG,"connection_finished_flushing() entered. Socket %u.", conn->s);
Roger Dingledine's avatar
Roger Dingledine committed
713
714

  switch(conn->type) {
715
716
    case CONN_TYPE_AP:
      return connection_ap_finished_flushing(conn);
Roger Dingledine's avatar
Roger Dingledine committed
717
718
719
720
    case CONN_TYPE_OP:
      return connection_op_finished_flushing(conn);
    case CONN_TYPE_OR:
      return connection_or_finished_flushing(conn);
721
722
    case CONN_TYPE_EXIT:
      return connection_exit_finished_flushing(conn);
723
724
    case CONN_TYPE_DIR:
      return connection_dir_finished_flushing(conn);
Roger Dingledine's avatar
Roger Dingledine committed
725
726
727
728
729
730
731
732
733
734
735
736
    default:
      log(LOG_DEBUG,"connection_finished_flushing() got unexpected conn->type.");
      return -1;
  }
}

int connection_process_cell_from_inbuf(connection_t *conn) {
  /* check if there's a whole cell there.
   * if yes, pull it off, decrypt it, and process it.
   */
  char crypted[128];
  char outbuf[1024];
737
//  int x;
Roger Dingledine's avatar
Roger Dingledine committed
738
739
740
741
742
743
744
745
746
  cell_t *cellp;

  if(conn->inbuf_datalen < 128) /* entire response available? */
    return 0; /* not yet */

  if(connection_fetch_from_buf(crypted,128,conn) < 0) {
    return -1;
  }

747
#if 0
Roger Dingledine's avatar
Roger Dingledine committed
748
749
750
751
752
  printf("Cell header crypttext: ");
  for(x=0;x<8;x++) {
    printf("%u ",crypted[x]);
  }
  printf("\n");
753
#endif
Roger Dingledine's avatar
Roger Dingledine committed
754
  /* decrypt */
755
  if(crypto_cipher_decrypt(conn->b_crypto,crypted,sizeof(cell_t),(unsigned char *)outbuf)) {
Roger Dingledine's avatar
Roger Dingledine committed
756
757
758
    log(LOG_ERR,"connection_process_cell_from_inbuf(): Decryption failed, dropping.");
    return connection_process_inbuf(conn); /* process the remainder of the buffer */
  }
759
//  log(LOG_DEBUG,"connection_process_cell_from_inbuf(): Cell decrypted (%d bytes).",outlen);
760
#if 0
Roger Dingledine's avatar
Roger Dingledine committed
761
762
763
764
765
  printf("Cell header plaintext: ");
  for(x=0;x<8;x++) {
    printf("%u ",outbuf[x]);
  }
  printf("\n");
766
#endif
Roger Dingledine's avatar
Roger Dingledine committed
767
768

  /* copy the rest of the cell */
769
//  memcpy((char *)outbuf+8, (char *)crypted+8, sizeof(cell_t)-8);
Roger Dingledine's avatar
Roger Dingledine committed
770
  cellp = (cell_t *)outbuf;
771
//  log(LOG_DEBUG,"connection_process_cell_from_inbuf(): Decrypted cell is of type %u (ACI %u).",cellp->command,cellp->aci);
Roger Dingledine's avatar
Roger Dingledine committed
772
773
774
775
776
  command_process_cell(cellp, conn);

  return connection_process_inbuf(conn); /* process the remainder of the buffer */
}