directory.c 19.4 KB
Newer Older
Roger Dingledine's avatar
Roger Dingledine committed
1
/* Copyright 2001,2002,2003 Roger Dingledine. */
2
3
4
5
6
/* See LICENSE for licensing information */
/* $Id$ */

#include "or.h"

Roger Dingledine's avatar
Roger Dingledine committed
7
8
9
10
/**
 * \file directory.c
 * \brief Implement directory HTTP protocol.
 **/
11

12
13
static void directory_send_command(connection_t *conn, int purpose,
                                   const char *payload, int payload_len);
Roger Dingledine's avatar
Roger Dingledine committed
14
15
static int directory_handle_command(connection_t *conn);

16
17
18
19
/********* START VARIABLES **********/

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

Roger Dingledine's avatar
Roger Dingledine committed
20
/** URL for publishing rendezvous descriptors. */
21
char rend_publish_string[] = "/rendezvous/publish";
Roger Dingledine's avatar
Roger Dingledine committed
22
/** Prefix for downloading rendezvous descriptors. */
23
24
char rend_fetch_url[] = "/rendezvous/";

25
#define MAX_HEADERS_SIZE 10000
26
#define MAX_BODY_SIZE 500000
27
28
29

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

Roger Dingledine's avatar
Roger Dingledine committed
30
/** Launch a new connection to the directory server 'router' to upload
31
32
33
34
35
36
37
38
 * or download a service or rendezvous descriptor. 'purpose' determines what
 * kind of directory connection we're launching, and must be one of
 * DIR_PURPOSE_{FETCH|UPLOAD}_{DIR|RENDDESC}.
 *
 * When uploading, 'payload' and 'payload_len' determine the content
 * of the HTTP post.  When fetching a rendezvous descriptor, 'payload'
 * and 'payload_len' are the service ID we want to fetch.
 */
39
40
void directory_initiate_command(routerinfo_t *router, int purpose,
                                const char *payload, int payload_len) {
41
42
  connection_t *conn;

43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
  switch (purpose)
    {
    case DIR_PURPOSE_FETCH_DIR:
      log_fn(LOG_DEBUG,"initiating directory fetch");
      break;
    case DIR_PURPOSE_FETCH_RENDDESC:
      log_fn(LOG_DEBUG,"initiating hidden-service descriptor fetch");
      break;
    case DIR_PURPOSE_UPLOAD_DIR:
      log_fn(LOG_DEBUG,"initiating server descriptor upload");
      break;
    case DIR_PURPOSE_UPLOAD_RENDDESC:
      log_fn(LOG_DEBUG,"initiating hidden-service descriptor upload");
      break;
    default:
      log_fn(LOG_ERR, "Unrecognized directory connection purpose.");
      tor_assert(0);
    }
61

62
  if (!router) { /* i guess they didn't have one in mind for me to use */
Roger Dingledine's avatar
Roger Dingledine committed
63
    log_fn(LOG_WARN,"No running dirservers known. Not trying. (purpose %d)", purpose);
64
65
66
    return;
  }

67
68
69
  conn = connection_new(CONN_TYPE_DIR);

  /* set up conn so it's got all the data we need to remember */
Roger Dingledine's avatar
Roger Dingledine committed
70
71
  conn->addr = router->addr;
  conn->port = router->dir_port;
72
73
  conn->address = tor_strdup(router->address);
  conn->nickname = tor_strdup(router->nickname);
Roger Dingledine's avatar
Roger Dingledine committed
74
  tor_assert(router->identity_pkey);
75
  conn->identity_pkey = crypto_pk_dup_key(router->identity_pkey);
76

Roger Dingledine's avatar
Roger Dingledine committed
77
  conn->purpose = purpose;
78

79
80
81
  /* give it an initial state */
  conn->state = DIR_CONN_STATE_CONNECTING;

Roger Dingledine's avatar
Roger Dingledine committed
82
83
84
85
86
87
  if(purpose == DIR_PURPOSE_FETCH_DIR ||
     purpose == DIR_PURPOSE_UPLOAD_DIR) {
    /* then we want to connect directly */
    switch(connection_connect(conn, conn->address, conn->addr, conn->port)) {
      case -1:
        router_mark_as_down(conn->nickname); /* don't try him again */
88
        connection_free(conn);
Roger Dingledine's avatar
Roger Dingledine committed
89
90
91
92
93
        return;
      case 1:
        conn->state = DIR_CONN_STATE_CLIENT_SENDING; /* start flushing conn */
        /* fall through */
      case 0:
94
95
96
        /* queue the command on the outbuf */
        directory_send_command(conn, purpose, payload, payload_len);

Roger Dingledine's avatar
Roger Dingledine committed
97
98
99
100
101
102
103
104
105
        connection_watch_events(conn, POLLIN | POLLOUT | POLLERR);
        /* writable indicates finish, readable indicates broken link,
           error indicates broken link in windowsland. */
    }
  } else { /* we want to connect via tor */
    /* make an AP connection
     *   populate it and add it at the right state
     * socketpair and hook up both sides
     */
106
107
108
109
110
111
    conn->s = connection_ap_make_bridge(conn->address, conn->port);
    if(conn->s < 0) {
      log_fn(LOG_WARN,"Making AP bridge to dirserver failed.");
      connection_mark_for_close(conn, 0);
      return;
    }
Roger Dingledine's avatar
Roger Dingledine committed
112

113
    conn->state = DIR_CONN_STATE_CLIENT_SENDING;
114
    connection_add(conn);
115
116
117
    /* queue the command on the outbuf */
    directory_send_command(conn, purpose, payload, payload_len);
    connection_watch_events(conn, POLLIN | POLLOUT | POLLERR);
118
119
120
  }
}

Roger Dingledine's avatar
Roger Dingledine committed
121
/** Queue an appropriate HTTP command on conn->outbuf.  The args
122
123
124
 * 'purpose', 'payload', and 'payload_len' are as in
 * directory_initiate_command.
 */
125
126
static void directory_send_command(connection_t *conn, int purpose,
                                   const char *payload, int payload_len) {
127
  char fetchstring[] = "GET / HTTP/1.0\r\n\r\n";
128
  char tmp[8192];
129

Roger Dingledine's avatar
Roger Dingledine committed
130
  tor_assert(conn && conn->type == CONN_TYPE_DIR);
131

Roger Dingledine's avatar
Roger Dingledine committed
132
133
  switch(purpose) {
    case DIR_PURPOSE_FETCH_DIR:
Roger Dingledine's avatar
Roger Dingledine committed
134
      tor_assert(payload == NULL);
135
      connection_write_to_buf(fetchstring, strlen(fetchstring), conn);
136
      break;
Roger Dingledine's avatar
Roger Dingledine committed
137
    case DIR_PURPOSE_UPLOAD_DIR:
Roger Dingledine's avatar
Roger Dingledine committed
138
      tor_assert(payload);
139
140
      snprintf(tmp, sizeof(tmp), "POST / HTTP/1.0\r\nContent-Length: %d\r\n\r\n",
               payload_len);
Roger Dingledine's avatar
Roger Dingledine committed
141
      connection_write_to_buf(tmp, strlen(tmp), conn);
142
      connection_write_to_buf(payload, payload_len, conn);
Roger Dingledine's avatar
Roger Dingledine committed
143
      break;
144
    case DIR_PURPOSE_FETCH_RENDDESC:
Roger Dingledine's avatar
Roger Dingledine committed
145
      tor_assert(payload);
146
147

      /* this must be true or we wouldn't be doing the lookup */
Roger Dingledine's avatar
Roger Dingledine committed
148
      tor_assert(payload_len <= REND_SERVICE_ID_LEN);
149
      /* This breaks the function abstraction. */
150
151
152
      memcpy(conn->rend_query, payload, payload_len);
      conn->rend_query[payload_len] = 0;

153
      snprintf(tmp, sizeof(tmp), "GET %s%s HTTP/1.0\r\n\r\n", rend_fetch_url, payload);
Roger Dingledine's avatar
Roger Dingledine committed
154
155
      connection_write_to_buf(tmp, strlen(tmp), conn);
      break;
156
    case DIR_PURPOSE_UPLOAD_RENDDESC:
Roger Dingledine's avatar
Roger Dingledine committed
157
      tor_assert(payload);
Roger Dingledine's avatar
Roger Dingledine committed
158
      snprintf(tmp, sizeof(tmp),
159
        "POST %s HTTP/1.0\r\nContent-Length: %d\r\n\r\n", rend_publish_string, payload_len);
160
      connection_write_to_buf(tmp, strlen(tmp), conn);
161
162
      /* could include nuls, need to write it separately */
      connection_write_to_buf(payload, payload_len, conn);
163
      break;
164
  }
Roger Dingledine's avatar
Roger Dingledine committed
165
166
}

Roger Dingledine's avatar
Roger Dingledine committed
167
/** Parse an HTTP request string 'headers' of the form "%s %s HTTP/1..."
Roger Dingledine's avatar
Roger Dingledine committed
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
 * If it's well-formed, point *url to the second %s,
 * null-terminate it (this modifies headers!) and return 0.
 * Otherwise, return -1.
 */
int parse_http_url(char *headers, char **url) {
  char *s, *tmp;

  s = (char *)eat_whitespace_no_nl(headers);
  if (!*s) return -1;
  s = (char *)find_whitespace(s); /* get past GET/POST */
  if (!*s) return -1;
  s = (char *)eat_whitespace_no_nl(s);
  if (!*s) return -1;
  tmp = s; /* this is it, assuming it's valid */
  s = (char *)find_whitespace(s);
  if (!*s) return -1;
  *s = 0;
  *url = tmp;
186
187
188
  return 0;
}

Roger Dingledine's avatar
Roger Dingledine committed
189
/** Parse an HTTP response string 'headers' of the form "HTTP/1.%d %d%s\r\n...".
190
191
192
193
194
195
196
 * If it's well-formed, assign *code, point *message to the first
 * non-space character after code if there is one and message is non-NULL
 * (else leave it alone), and return 0.
 * Otherwise, return -1.
 */
int parse_http_response(char *headers, int *code, char **message) {
  int n1, n2;
Roger Dingledine's avatar
Roger Dingledine committed
197
  tor_assert(headers && code);
198

199
  while(isspace((int)*headers)) headers++; /* tolerate leading whitespace */
200
201
202
203
204
205
206
207
208
209
210
211
212
213

  if(sscanf(headers, "HTTP/1.%d %d", &n1, &n2) < 2 ||
     (n1 != 0 && n1 != 1) ||
     (n2 < 100 || n2 >= 600)) {
    log_fn(LOG_WARN,"Failed to parse header '%s'",headers);
    return -1;
  }
  *code = n2;
  if(message) {
    /* XXX should set *message correctly */
  }
  return 0;
}

Roger Dingledine's avatar
Roger Dingledine committed
214
/** Read handler for directory connections.  (That's connections *to*
215
216
 * directory servers and connections *at* directory servers.)
 */
217
int connection_dir_process_inbuf(connection_t *conn) {
218
  char *body;
219
  char *headers;
220
  int body_len=0;
221
  int status_code;
222

Roger Dingledine's avatar
Roger Dingledine committed
223
  tor_assert(conn && conn->type == CONN_TYPE_DIR);
224

225
226
  /* Directory clients write, then read data until they receive EOF;
   * directory servers read data until they get an HTTP command, then
227
228
   * write their response (when it's finished flushing, they mark for
   * close).
229
   */
230
  if(conn->inbuf_reached_eof) {
Roger Dingledine's avatar
Roger Dingledine committed
231
    if(conn->state != DIR_CONN_STATE_CLIENT_READING) {
232
233
234
235
236
237
238
239
      log_fn(LOG_INFO,"conn reached eof, not reading. Closing.");
      connection_close_immediate(conn); /* it was an error; give up on flushing */
      connection_mark_for_close(conn,0);
      return -1;
    }

    switch(fetch_from_buf_http(conn->inbuf,
                               &headers, MAX_HEADERS_SIZE,
240
                               &body, &body_len, MAX_DIR_SIZE)) {
241
242
      case -1: /* overflow */
        log_fn(LOG_WARN,"'fetch' response too large. Failing.");
243
        connection_mark_for_close(conn,0);
244
245
246
247
248
249
250
251
252
253
        return -1;
      case 0:
        log_fn(LOG_INFO,"'fetch' response not all here, but we're at eof. Closing.");
        connection_mark_for_close(conn,0);
        return -1;
      /* case 1, fall through */
    }

    if(parse_http_response(headers, &status_code, NULL) < 0) {
      log_fn(LOG_WARN,"Unparseable headers. Closing.");
254
      free(body); free(headers);
255
256
257
258
      connection_mark_for_close(conn,0);
      return -1;
    }

Roger Dingledine's avatar
Roger Dingledine committed
259
    if(conn->purpose == DIR_PURPOSE_FETCH_DIR) {
260
      /* fetch/process the directory to learn about new routers. */
261
262
      log_fn(LOG_INFO,"Received directory (size %d):\n%s", body_len, body);
      if(status_code == 503 || body_len == 0) {
263
        log_fn(LOG_INFO,"Empty directory. Ignoring.");
264
        free(body); free(headers);
265
266
        connection_mark_for_close(conn,0);
        return 0;
267
268
269
270
      }
      if(status_code != 200) {
        log_fn(LOG_WARN,"Received http status code %d from dirserver. Failing.",
               status_code);
271
        free(body); free(headers);
272
        connection_mark_for_close(conn,0);
273
        return -1;
274
      }
275
      if(router_set_routerlist_from_directory(body, conn->identity_pkey) < 0){
276
277
278
279
        log_fn(LOG_INFO,"...but parsing failed. Ignoring.");
      } else {
        log_fn(LOG_INFO,"updated routers.");
      }
280
      directory_has_arrived(); /* do things we've been waiting to do */
281
282
    }

Roger Dingledine's avatar
Roger Dingledine committed
283
    if(conn->purpose == DIR_PURPOSE_UPLOAD_DIR) {
284
285
      switch(status_code) {
        case 200:
286
          log_fn(LOG_INFO,"eof (status 200) after uploading server descriptor: finished.");
287
288
          break;
        case 400:
289
          log_fn(LOG_WARN,"http status 400 (bad request) response from dirserver. Malformed server descriptor?");
290
291
          break;
        case 403:
292
          log_fn(LOG_WARN,"http status 403 (unapproved server) response from dirserver. Is your clock skewed? Have you mailed us your identity fingerprint? Are you using the right key? See README.");
293

Roger Dingledine's avatar
Roger Dingledine committed
294
295
296
          break;
        default:
          log_fn(LOG_WARN,"http status %d response unrecognized.", status_code);
297
298
          break;
      }
Roger Dingledine's avatar
cleanup    
Roger Dingledine committed
299
    }
Roger Dingledine's avatar
Roger Dingledine committed
300

301
302
303
304
305
306
    if(conn->purpose == DIR_PURPOSE_FETCH_RENDDESC) {
      log_fn(LOG_INFO,"Received rendezvous descriptor (size %d, status code %d)",
             body_len, status_code);
      switch(status_code) {
        case 200:
          if(rend_cache_store(body, body_len) < 0) {
307
308
309
            log_fn(LOG_WARN,"Failed to store rendezvous descriptor.");
            /* alice's ap_stream will notice when connection_mark_for_close
             * cleans it up */
310
311
          } else {
            /* success. notify pending connections about this. */
312
            rend_client_desc_fetched(conn->rend_query, 1);
313
            conn->purpose = DIR_PURPOSE_HAS_FETCHED_RENDDESC;
314
315
316
          }
          break;
        case 404:
317
318
          /* not there. pending connections will be notified when
           * connection_mark_for_close cleans it up. */
319
320
321
322
323
          break;
        case 400:
          log_fn(LOG_WARN,"http status 400 (bad request). Dirserver didn't like our rendezvous query?");
          break;
      }
Roger Dingledine's avatar
Roger Dingledine committed
324
325
    }

326
327
328
329
330
331
332
333
334
335
336
337
    if(conn->purpose == DIR_PURPOSE_UPLOAD_RENDDESC) {
      switch(status_code) {
        case 200:
          log_fn(LOG_INFO,"eof (status 200) after uploading rendezvous descriptor: finished.");
          break;
        case 400:
          log_fn(LOG_WARN,"http status 400 (bad request) response from dirserver. Malformed rendezvous descriptor?");
          break;
        default:
          log_fn(LOG_WARN,"http status %d response unrecognized.", status_code);
          break;
      }
Roger Dingledine's avatar
Roger Dingledine committed
338
    }
339
340
341
    free(body); free(headers);
    connection_mark_for_close(conn,0);
    return 0;
342
  } /* endif 'reached eof' */
343

344
  /* If we're on the dirserver side, look for a command. */
Roger Dingledine's avatar
Roger Dingledine committed
345
346
347
348
349
  if(conn->state == DIR_CONN_STATE_SERVER_COMMAND_WAIT) {
    if (directory_handle_command(conn) < 0) {
      connection_mark_for_close(conn,0);
      return -1;
    }
350
    return 0;
Roger Dingledine's avatar
Roger Dingledine committed
351
  }
352
353

  /* XXX for READ states, might want to make sure inbuf isn't too big */
354

355
  log_fn(LOG_DEBUG,"Got data, not eof. Leaving on inbuf.");
356
357
358
  return 0;
}

359
360
361
static char answer200[] = "HTTP/1.0 200 OK\r\n\r\n";
static char answer400[] = "HTTP/1.0 400 Bad request\r\n\r\n";
static char answer403[] = "HTTP/1.0 403 Unapproved server\r\n\r\n";
Roger Dingledine's avatar
Roger Dingledine committed
362
static char answer404[] = "HTTP/1.0 404 Not found\r\n\r\n";
363
364
static char answer503[] = "HTTP/1.0 503 Directory unavailable\r\n\r\n";

Roger Dingledine's avatar
Roger Dingledine committed
365
/** Helper function: called when a dirserver gets a complete HTTP GET
366
367
 * request.  Look for a request for a directory or for a rendezvous
 * service descriptor.  On finding one, write a response into
368
 * conn->outbuf.  If the request is unrecognized, send a 404.
369
 * Always return 0. */
370
static int directory_handle_command_get(connection_t *conn,
371
372
                                        char *headers, char *body,
                                        int body_len) {
Roger Dingledine's avatar
Roger Dingledine committed
373
  size_t dlen;
374
  const char *cp;
Roger Dingledine's avatar
Roger Dingledine committed
375
  char *url;
376
  char tmp[8192];
377

378
379
  log_fn(LOG_DEBUG,"Received GET command.");

Roger Dingledine's avatar
Roger Dingledine committed
380
  conn->state = DIR_CONN_STATE_SERVER_WRITING;
381

Roger Dingledine's avatar
Roger Dingledine committed
382
383
  if (parse_http_url(headers, &url) < 0) {
    connection_write_to_buf(answer400, strlen(answer400), conn);
384
    return 0;
385
386
  }

Roger Dingledine's avatar
Roger Dingledine committed
387
388
389
390
391
392
393
394
395
396
  if(!strcmp(url,"/")) { /* directory fetch */
    dlen = dirserv_get_directory(&cp);

    if(dlen == 0) {
      log_fn(LOG_WARN,"My directory is empty. Closing.");
      connection_write_to_buf(answer503, strlen(answer503), conn);
      return 0;
    }

    log_fn(LOG_DEBUG,"Dumping directory to client.");
397
    snprintf(tmp, sizeof(tmp), "HTTP/1.0 200 OK\r\nContent-Length: %d\r\nContent-Type: text/plain\r\n\r\n",
398
             (int)dlen);
399
    connection_write_to_buf(tmp, strlen(tmp), conn);
400
    connection_write_to_buf(cp, strlen(cp), conn);
Roger Dingledine's avatar
Roger Dingledine committed
401
402
403
    return 0;
  }

404
405
  if(!strncmp(url,rend_fetch_url,strlen(rend_fetch_url))) {
    /* rendezvous descriptor fetch */
406
407
    const char *descp;
    int desc_len;
Roger Dingledine's avatar
Roger Dingledine committed
408

409
    switch(rend_cache_lookup_desc(url+strlen(rend_fetch_url), &descp, &desc_len)) {
410
      case 1: /* valid */
411
        snprintf(tmp, sizeof(tmp), "HTTP/1.0 200 OK\r\nContent-Length: %d\r\nContent-Type: application/octet-stream\r\n\r\n",
412
413
414
                 desc_len); /* can't include descp here, because it's got nuls */
        connection_write_to_buf(tmp, strlen(tmp), conn);
        connection_write_to_buf(descp, desc_len, conn);
415
416
417
418
419
420
421
422
423
        break;
      case 0: /* well-formed but not present */
        connection_write_to_buf(answer404, strlen(answer404), conn);
        break;
      case -1: /* not well-formed */
        connection_write_to_buf(answer400, strlen(answer400), conn);
        break;
    }
    return 0;
Roger Dingledine's avatar
Roger Dingledine committed
424
425
426
427
  }

  /* we didn't recognize the url */
  connection_write_to_buf(answer404, strlen(answer404), conn);
428
429
430
  return 0;
}

Roger Dingledine's avatar
Roger Dingledine committed
431
/** Helper function: called when a dirserver gets a complete HTTP POST
432
433
434
435
 * request.  Look for an uploaded server descriptor or rendezvous
 * service descriptor.  On finding one, process it and write a
 * response into conn->outbuf.  If the request is unrecognized, send a
 * 404.  Always return 0. */
436
static int directory_handle_command_post(connection_t *conn,
437
438
                                         char *headers, char *body,
                                         int body_len) {
439
  const char *cp;
Roger Dingledine's avatar
Roger Dingledine committed
440
  char *url;
441
442

  log_fn(LOG_DEBUG,"Received POST command.");
Roger Dingledine's avatar
Roger Dingledine committed
443

444
  conn->state = DIR_CONN_STATE_SERVER_WRITING;
Roger Dingledine's avatar
Roger Dingledine committed
445
446
447
448
449

  if (parse_http_url(headers, &url) < 0) {
    connection_write_to_buf(answer400, strlen(answer400), conn);
    return 0;
  }
450
  log_fn(LOG_INFO,"url '%s' posted to us.", url);
Roger Dingledine's avatar
Roger Dingledine committed
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467

  if(!strcmp(url,"/")) { /* server descriptor post */
    cp = body;
    switch(dirserv_add_descriptor(&cp)) {
      case -1:
        /* malformed descriptor, or something wrong */
        connection_write_to_buf(answer400, strlen(answer400), conn);
        break;
      case 0:
        /* descriptor was well-formed but server has not been approved */
        connection_write_to_buf(answer403, strlen(answer403), conn);
        break;
      case 1:
        dirserv_get_directory(&cp); /* rebuild and write to disk */
        connection_write_to_buf(answer200, strlen(answer200), conn);
        break;
    }
468
    return 0;
Roger Dingledine's avatar
Roger Dingledine committed
469
470
  }

471
472
  if(!strncmp(url,rend_publish_string,strlen(rend_publish_string))) {
    /* rendezvous descriptor post */
Nick Mathewson's avatar
Nick Mathewson committed
473
    if(rend_cache_store(body, body_len) < 0)
474
475
476
      connection_write_to_buf(answer400, strlen(answer400), conn);
    else
      connection_write_to_buf(answer200, strlen(answer200), conn);
477
    return 0;
Roger Dingledine's avatar
Roger Dingledine committed
478
479
480
481
  }

  /* we didn't recognize the url */
  connection_write_to_buf(answer404, strlen(answer404), conn);
482
483
484
  return 0;
}

Roger Dingledine's avatar
Roger Dingledine committed
485
/** Called when a dirserver receives data on a directory connection;
486
487
488
489
 * looks for an HTTP request.  If the request is complete, remove it
 * from the inbuf, try to process it; otherwise, leave it on the
 * buffer.  Return a 0 on success, or -1 on error.
 */
490
491
static int directory_handle_command(connection_t *conn) {
  char *headers=NULL, *body=NULL;
492
  int body_len=0;
493
494
  int r;

Roger Dingledine's avatar
Roger Dingledine committed
495
  tor_assert(conn && conn->type == CONN_TYPE_DIR);
496

497
  switch(fetch_from_buf_http(conn->inbuf,
498
499
                             &headers, MAX_HEADERS_SIZE,
                             &body, &body_len, MAX_BODY_SIZE)) {
500
    case -1: /* overflow */
Roger Dingledine's avatar
Roger Dingledine committed
501
      log_fn(LOG_WARN,"input too large. Failing.");
502
503
504
505
506
      return -1;
    case 0:
      log_fn(LOG_DEBUG,"command not all here yet.");
      return 0;
    /* case 1, fall through */
507
508
  }

509
  log_fn(LOG_DEBUG,"headers '%s', body '%s'.", headers, body);
510

511
  if(!strncasecmp(headers,"GET",3))
512
    r = directory_handle_command_get(conn, headers, body, body_len);
513
  else if (!strncasecmp(headers,"POST",4))
514
    r = directory_handle_command_post(conn, headers, body, body_len);
515
516
517
  else {
    log_fn(LOG_WARN,"Got headers '%s' with unknown command. Closing.", headers);
    r = -1;
518
519
  }

520
521
  tor_free(headers); tor_free(body);
  return r;
522
523
}

Roger Dingledine's avatar
Roger Dingledine committed
524
/** Write handler for directory connections; called when all data has
525
 * been flushed.  Handle a completed connection: close the connection
526
527
 * or wait for a response as appropriate.
 */
528
529
530
int connection_dir_finished_flushing(connection_t *conn) {
  int e, len=sizeof(e);

Roger Dingledine's avatar
Roger Dingledine committed
531
  tor_assert(conn && conn->type == CONN_TYPE_DIR);
532
533

  switch(conn->state) {
Roger Dingledine's avatar
Roger Dingledine committed
534
    case DIR_CONN_STATE_CONNECTING:
535
      if (getsockopt(conn->s, SOL_SOCKET, SO_ERROR, (void*)&e, &len) < 0)  { /* not yet */
536
        if(!ERRNO_IS_CONN_EINPROGRESS(tor_socket_errno(conn->s))) {
537
          log_fn(LOG_DEBUG,"in-progress connect failed. Removing.");
538
          router_mark_as_down(conn->nickname); /* don't try him again */
539
          connection_mark_for_close(conn,0);
540
541
542
543
544
545
546
          return -1;
        } else {
          return 0; /* no change, see if next time is better */
        }
      }
      /* the connect has finished. */

547
      log_fn(LOG_INFO,"Dir connection to router %s:%u established.",
548
549
          conn->address,conn->port);

Roger Dingledine's avatar
Roger Dingledine committed
550
      conn->state = DIR_CONN_STATE_CLIENT_SENDING; /* start flushing conn */
551
      return 0;
Roger Dingledine's avatar
Roger Dingledine committed
552
553
554
555
    case DIR_CONN_STATE_CLIENT_SENDING:
      log_fn(LOG_DEBUG,"client finished sending command.");
      conn->state = DIR_CONN_STATE_CLIENT_READING;
      connection_stop_writing(conn);
556
      return 0;
557
    case DIR_CONN_STATE_SERVER_WRITING:
558
      log_fn(LOG_INFO,"Finished writing server response. Closing.");
559
560
      connection_mark_for_close(conn,0);
      return 0;
561
    default:
562
      log_fn(LOG_WARN,"BUG: called in unexpected state %d.", conn->state);
563
      return -1;
564
565
566
567
  }
  return 0;
}

568
569
570
571
572
573
574
/*
  Local Variables:
  mode:c
  indent-tabs-mode:nil
  c-basic-offset:2
  End:
*/