main.c 10.6 KB
Newer Older
Roger Dingledine's avatar
Roger Dingledine committed
1
2
3
4
5
6
7
8

#include "or.h"

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

/* valid command-line options */
static char *args = "hf:e:n:l:";

Roger Dingledine's avatar
Roger Dingledine committed
9
int loglevel = LOG_DEBUG; /* global variable */
Roger Dingledine's avatar
Roger Dingledine committed
10

11
//int global_role = ROLE_AP_LISTEN;
12
13
14
int global_role = ROLE_OR_LISTEN | ROLE_OR_CONNECT_ALL | ROLE_OP_LISTEN | ROLE_AP_LISTEN;
/* FIXME defaulting to all roles for now. should make it a config option though */

Roger Dingledine's avatar
Roger Dingledine committed
15
16
17
18
19
/* valid config file options */
config_opt_t options[] =
{
  {"RouterFile", CONFIG_TYPE_STRING, {0}, 0},
  {"PrivateKeyFile", CONFIG_TYPE_STRING, {0}, 0},
20
21
22
23
  {"APPort", CONFIG_TYPE_INT, {0}, 0},
  {"OPPort", CONFIG_TYPE_INT, {0}, 0},
  {"ORPort", CONFIG_TYPE_INT, {0}, 0},
  {"CoinWeight", CONFIG_TYPE_DOUBLE, {0}, 0},
Roger Dingledine's avatar
Roger Dingledine committed
24
25
26
27
28
  {"MaxConn", CONFIG_TYPE_INT, {0}, 0},
  {"TrafficShaping", CONFIG_TYPE_INT, {0}, 0},
  {0}
};
enum opts {
29
  RouterFile=0, PrivateKeyFile, APPort, OPPort, ORPort, CoinWeight, MaxConn, TrafficShaping
Roger Dingledine's avatar
Roger Dingledine committed
30
31
};

Roger Dingledine's avatar
Roger Dingledine committed
32
static connection_t *connection_array[MAXCONNECTIONS] =
Roger Dingledine's avatar
Roger Dingledine committed
33
34
        { NULL };

Roger Dingledine's avatar
Roger Dingledine committed
35
static struct pollfd poll_array[MAXCONNECTIONS] =
Roger Dingledine's avatar
Roger Dingledine committed
36
37
        { [0 ... MAXCONNECTIONS-1] = { -1, 0, 0 } };

Roger Dingledine's avatar
Roger Dingledine committed
38
static int nfds=0; /* number of connections currently active */
Roger Dingledine's avatar
Roger Dingledine committed
39
40

/* private key */
Roger Dingledine's avatar
Roger Dingledine committed
41
static RSA *prkey = NULL;
Roger Dingledine's avatar
Roger Dingledine committed
42
43

/* router array */
Roger Dingledine's avatar
Roger Dingledine committed
44
45
static routerinfo_t **router_array = NULL;
static int rarray_len = 0;
Roger Dingledine's avatar
Roger Dingledine committed
46
47
48

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

Roger Dingledine's avatar
Roger Dingledine committed
49
50
51
52
53
54
55
56
/****************************************************************************
*
* This section contains accessors and other methods on the connection_array
* and poll_array variables (which are global within this file and unavailable
* outside it).
*
****************************************************************************/

Roger Dingledine's avatar
Roger Dingledine committed
57
58
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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
int connection_add(connection_t *conn) {

  if(nfds >= MAXCONNECTIONS-2) { /* 2, for some breathing room. should count the fenceposts. */
    /* FIXME should use the 'max connections' option */
    log(LOG_DEBUG,"connection_add(): failing because nfds is too high.");
    return -1;
  }

  conn->poll_index = nfds;
  connection_set_poll_socket(conn);
  connection_array[nfds] = conn;

  /* zero these out here, because otherwise we'll inherit values from the previously freed one */
  poll_array[nfds].events = 0;
  poll_array[nfds].revents = 0;

  nfds++;

  log(LOG_DEBUG,"connection_add(): new conn type %d, socket %d, nfds %d.",conn->type, conn->s, nfds);

  return 0;

}

void connection_set_poll_socket(connection_t *conn) {
  poll_array[conn->poll_index].fd = conn->s;
}

int connection_remove(connection_t *conn) {
  int current_index;

  assert(conn);
  assert(nfds>0);

  circuit_about_to_close_connection(conn); /* flush and send destroys for all circuits on this conn */

  current_index = conn->poll_index;
  if(current_index == nfds-1) { /* this is the end */
//    connection_free(conn);
    nfds--;
    log(LOG_DEBUG,"connection_remove(): nfds now %d.",nfds);  
    return 0;
  } 

  /* we replace this one with the one at the end, then free it */
  nfds--;
  poll_array[current_index].fd = poll_array[nfds].fd; 
  poll_array[current_index].events = poll_array[nfds].events;
  poll_array[current_index].revents = poll_array[nfds].revents;
  connection_array[current_index] = connection_array[nfds];
  connection_array[current_index]->poll_index = current_index;

  log(LOG_DEBUG,"connection_remove(): nfds now %d.",nfds);

  return 0;  
}

connection_t *connection_get_by_addr_port(uint32_t addr, uint16_t port) {
  int i;
  connection_t *conn;

  for(i=0;i<nfds;i++) {
    conn = connection_array[i];
    assert(conn);
    if(conn->addr == addr && conn->port == port)
       return conn;
  }

  return NULL;
}

connection_t *connection_get_by_type(int type) {
  int i;
  connection_t *conn;

  for(i=0;i<nfds;i++) {
    conn = connection_array[i];
    if(conn->type == type)
       return conn;
  }

  return NULL;
}

Roger Dingledine's avatar
Roger Dingledine committed
141
142
143
144
145
146
147
148



/* the next 4 functions should move to routers.c once we get it
 * cleaned up more. The router_array and rarray_len variables should
 * move there too.
 */

Roger Dingledine's avatar
Roger Dingledine committed
149
150
151
152
routerinfo_t *router_get_by_addr_port(uint32_t addr, uint16_t port) {
  int i;
  routerinfo_t *router;

Roger Dingledine's avatar
Roger Dingledine committed
153
  assert(router_array);
Roger Dingledine's avatar
Roger Dingledine committed
154

Roger Dingledine's avatar
Roger Dingledine committed
155
  for(i=0;i<rarray_len;i++) {
Roger Dingledine's avatar
Roger Dingledine committed
156
    router = router_array[i];
157
    if ((router->addr == addr) && (router->or_port == port))
Roger Dingledine's avatar
Roger Dingledine committed
158
159
160
161
162
163
      return router;
  }

  return NULL;
}

164
165
166
167
168
169
170
171
172
173
174
175
176
177
routerinfo_t *router_get_first_in_route(unsigned int *route, size_t routelen) {
  return router_array[route[routelen-1]];
}

/* a wrapper around new_route. put all these in routers.c perhaps? */
unsigned int *router_new_route(size_t *rlen) {
  return new_route(options[CoinWeight].r.d, router_array,rarray_len, rlen);
}

/* a wrapper around create_onion */
unsigned char *router_create_onion(unsigned int *route, size_t routelen, size_t *lenp, crypt_path_t **cpathp) {
  return create_onion(router_array,rarray_len,route,routelen,lenp,cpathp);
}

Roger Dingledine's avatar
Roger Dingledine committed
178
179
180
181




182
183
184
185
connection_t *connect_to_router_as_op(routerinfo_t *router) {
  return connection_connect_to_router_as_op(router, prkey, options[ORPort].r.i);
}

Roger Dingledine's avatar
Roger Dingledine committed
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
void connection_watch_events(connection_t *conn, short events) {

  assert(conn && conn->poll_index < nfds);

  poll_array[conn->poll_index].events = events;
}

void check_conn_read(int i) {
  int retval;
  connection_t *conn;

  if(poll_array[i].revents & POLLIN) { /* something to read */

    conn = connection_array[i];
    assert(conn);
    log(LOG_DEBUG,"check_conn_read(): socket %d has something to read.",conn->s);

    if (conn->type == CONN_TYPE_OP_LISTENER) {
      retval = connection_op_handle_listener_read(conn);
    } else if (conn->type == CONN_TYPE_OR_LISTENER) {
      retval = connection_or_handle_listener_read(conn);
207
208
    } else if (conn->type == CONN_TYPE_AP_LISTENER) {
      retval = connection_ap_handle_listener_read(conn);
Roger Dingledine's avatar
Roger Dingledine committed
209
    } else {
210
      /* else it's an OP, OR, or exit */
Roger Dingledine's avatar
Roger Dingledine committed
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
      retval = connection_read_to_buf(conn);
      if (retval >= 0) { /* all still well */
        retval = connection_process_inbuf(conn);
	log(LOG_DEBUG,"check_conn_read(): connection_process_inbuf returned %d.",retval);
      }
    }
  
    if(retval < 0) { /* this connection is broken. remove it */
      log(LOG_DEBUG,"check_conn_read(): Connection broken, removing."); 
      connection_remove(conn);
      connection_free(conn);
      if(i<nfds) { /* we just replaced the one at i with a new one.
                      process it too. */
        check_conn_read(i);
      }
    }
  }
}

void check_conn_write(int i) {
  int retval;
  connection_t *conn;

  if(poll_array[i].revents & POLLOUT) { /* something to write */

    conn = connection_array[i];
    log(LOG_DEBUG,"check_conn_write(): socket %d wants to write.",conn->s);

    if(conn->type == CONN_TYPE_OP_LISTENER ||
       conn->type == CONN_TYPE_OR_LISTENER) {
      log(LOG_DEBUG,"check_conn_write(): Got a listener socket. Can't happen!");
      retval = -1;
    } else {
244
      /* else it's an OP, OR, or exit */
Roger Dingledine's avatar
Roger Dingledine committed
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
      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. */
      }
    }

    if(retval < 0) { /* this connection is broken. remove it. */
      log(LOG_DEBUG,"check_conn_write(): Connection broken, removing.");
      connection_remove(conn);
      connection_free(conn);
      if(i<nfds) { /* we just replaced the one at i with a new one.
                      process it too. */
        check_conn_read(i);
      }
    }
  }
}

void check_conn_marked(int i) {
  connection_t *conn;

  conn = connection_array[i];
  assert(conn);
  if(conn->marked_for_close) {
    log(LOG_DEBUG,"check_conn_marked(): Cleaning up connection.");
270
271
272
273
    if(conn->s >= 0) { /* might be an incomplete exit connection */
      /* FIXME there's got to be a better way to check for this -- and make other checks? */
      connection_flush_buf(conn); /* flush it first */
    }
Roger Dingledine's avatar
Roger Dingledine committed
274
275
276
277
    connection_remove(conn);
    connection_free(conn);
    if(i<nfds) { /* we just replaced the one at i with a new one.
                    process it too. */
Roger Dingledine's avatar
Roger Dingledine committed
278
      check_conn_marked(i);
Roger Dingledine's avatar
Roger Dingledine committed
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
    }
  }
}

int do_main_loop(void) {
  int i;

  /* load the routers file */
  router_array = getrouters(options[RouterFile].r.str,&rarray_len);
  if (!router_array)
  {
    log(LOG_ERR,"Error loading router list.");
    exit(1);
  }

  /* load the private key */
  prkey = load_prkey(options[PrivateKeyFile].r.str);
  if (!prkey)
  {
    log(LOG_ERR,"Error loading private key.");
    exit(1);
  }
  log(LOG_DEBUG,"core : Loaded private key of size %u bytes.",RSA_size(prkey));

303
304
305
306
307
  /* start-up the necessary connections based on global_role. This is where we
   * try to connect to all the other ORs, and start the listeners */
  retry_all_connections(global_role, router_array, rarray_len, prkey, 
		        options[ORPort].r.i,options[OPPort].r.i,
			options[APPort].r.i);
Roger Dingledine's avatar
Roger Dingledine committed
308
309
310
311
312
313

  for(;;) {
    poll(poll_array, nfds, -1); /* poll until we have an event */

    /* do all the reads first, so we can detect closed sockets */
    for(i=0;i<nfds;i++)
314
      check_conn_read(i); /* this also blows away broken connections */
Roger Dingledine's avatar
Roger Dingledine committed
315
316
317
318
319
320
321
322
323
324
325

    /* then do the writes */
    for(i=0;i<nfds;i++)
      check_conn_write(i);

    /* any of the conns need to be closed now? */
    for(i=0;i<nfds;i++)
      check_conn_marked(i); 
  }
}

326
void catch () {
Roger Dingledine's avatar
Roger Dingledine committed
327
328
329
330
331
332
333
  errno = 0; /* netcat does this. it looks fun. */

  log(LOG_DEBUG,"Catching ^c, exiting cleanly.");
   
  exit(0);
}

334
int main(int argc, char *argv[]) {
Roger Dingledine's avatar
Roger Dingledine committed
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
  int retval = 0;

  char *conf_filename = NULL; /* configuration file */
  signal (SIGINT, catch); /* to catch ^c so we can exit cleanly */

  /* get command-line arguments */
  retval = getargs(argc,argv,args,&conf_filename,&loglevel);
  if (retval == -1)
  {
    log(LOG_ERR,"Error processing command-line arguments.");
    exit(1);
  }

  /* load config file */
  retval = getconfig(conf_filename,options);
  if (retval == -1)
  {
    log(LOG_ERR,"Error loading configuration file.");
    exit(1);
  }
  else if (options[RouterFile].err != 1)
  { 
    log(LOG_ERR,"RouterFile option required, but not found.");
    exit(1);
  }
  else if (options[PrivateKeyFile].err != 1)
  { 
    log(LOG_ERR,"PrivateKeyFile option required but not found.");
    exit(1);
  }
365
366
367
  else if (options[CoinWeight].err != 1)
  {
    log(LOG_ERR,"Error reading the CoinWeight option.");
Roger Dingledine's avatar
Roger Dingledine committed
368
369
    exit(1);
  }
370
  else if (options[APPort].err != 1)
Roger Dingledine's avatar
Roger Dingledine committed
371
  { 
372
    log(LOG_ERR,"APPort option required but not found.");
Roger Dingledine's avatar
Roger Dingledine committed
373
374
    exit(1);
  }
375
  else if (options[OPPort].err != 1)
Roger Dingledine's avatar
Roger Dingledine committed
376
  { 
377
    log(LOG_ERR,"OPPort option required but not found.");
Roger Dingledine's avatar
Roger Dingledine committed
378
379
    exit(1);
  }
380
  else if (options[ORPort].err != 1)
Roger Dingledine's avatar
Roger Dingledine committed
381
  { 
382
383
    log(LOG_ERR,"ORPort option required but not found.");
    exit(1);
Roger Dingledine's avatar
Roger Dingledine committed
384
  }
385
  else if (options[MaxConn].err != 1)
Roger Dingledine's avatar
Roger Dingledine committed
386
  { 
387
388
    log(LOG_ERR,"MaxConn option required but not found.");
    exit(1);
Roger Dingledine's avatar
Roger Dingledine committed
389
390
391
392
393
394
395
396
397
  }

  ERR_load_crypto_strings();
  retval = do_main_loop();
  ERR_free_strings();

  return retval;
}