[Author Prev][Author Next][Thread Prev][Thread Next][Author Index][Thread Index]

[tor-commits] [obfsproxy/master] Merge remote-tracking branch 'zwol/port-fixes'



commit c37354b1e0adcb6d16929613e3bd4a509d487d2d
Merge: 3fb0f0e 7f03b8e
Author: Nick Mathewson <nickm@xxxxxxxxxxxxxx>
Date:   Thu Jul 14 12:28:12 2011 -0400

    Merge remote-tracking branch 'zwol/port-fixes'
    
    Conflicts:
    	src/network.c
    	src/network.h
    	src/protocol.c
    	src/protocols/dummy.c
    	src/protocols/obfs2.c
    	src/socks.c
    	src/socks.h
    	src/util.c

 Makefile.am                 |   34 +++---
 configure.ac                |   49 ++++-----
 m4/winsock.m4               |   56 ++++++++++
 src/crypt.c                 |  220 ++++++++++++++++++++++++++++++++++++++
 src/crypt.h                 |   64 +++++++++++
 src/main.c                  |    7 +-
 src/network.c               |   27 +++--
 src/network.h               |   19 ++--
 src/protocol.c              |   25 +++--
 src/protocol.h              |   35 +++---
 src/protocols/dummy.c       |   54 ++++------
 src/protocols/dummy.h       |    1 -
 src/protocols/obfs2.c       |   84 ++++++---------
 src/protocols/obfs2.h       |   11 +-
 src/protocols/obfs2_crypt.c |  245 -------------------------------------------
 src/protocols/obfs2_crypt.h |   61 -----------
 src/sha256.c                |   89 ++++------------
 src/sha256.h                |   18 +++
 src/socks.c                 |  102 ++++++++----------
 src/socks.h                 |   24 ++---
 src/test/tinytest.c         |   10 +-
 src/test/unittest.c         |    3 +-
 src/test/unittest_crypt.c   |   19 +---
 src/test/unittest_obfs2.c   |  133 ++++++++++++-----------
 src/test/unittest_socks.c   |   16 ++--
 src/util.c                  |  154 ++++++++++------------------
 src/util.h                  |   83 +++++---------
 27 files changed, 772 insertions(+), 871 deletions(-)

diff --cc src/crypt.c
index 0000000,43f6dfb..6be9726
mode 000000,100644..100644
--- a/src/crypt.c
+++ b/src/crypt.c
@@@ -1,0 -1,178 +1,220 @@@
+ /* Copyright 2011 Nick Mathewson, George Kadianakis
+    See LICENSE for other credits and copying information
+ */
+ 
+ #define CRYPT_PRIVATE
+ #include "crypt.h"
+ 
+ #include <assert.h>
+ #include <fcntl.h>
+ #include <stdlib.h>
+ #include <string.h>
+ #include <unistd.h>
+ 
+ #include <openssl/opensslv.h>
+ #include <openssl/err.h>
+ #include <openssl/rand.h>
+ 
+ #if OPENSSL_VERSION_NUMBER >= 0x0090800f
+ #define USE_OPENSSL_RANDPOLL 1
+ #define USE_OPENSSL_SHA256 1
+ #include <openssl/sha.h>
+ #else
+ #include "sha256.h"
+ #endif
+ 
++/**
++   Initializes the obfs2 crypto subsystem.
++*/
+ int
+ initialize_crypto(void)
+ {
+   ERR_load_crypto_strings();
+ 
+ #ifdef USE_OPENSSL_RANDPOLL
+   return RAND_poll() == 1 ? 0 : -1;
+ #else
+   /* XXX Or maybe fall back to the arc4random implementation in libevent2? */
+   {
+     char buf[32];
+     int fd, n;
+     fd = open("/dev/urandom", O_RDONLY);
+     if (fd == -1) {
+       perror("open");
+       return -1;
+     }
+     n = read(fd, buf, sizeof(buf));
+     if (n != sizeof(buf)) {
+       close(fd);
+       return -1;
+     }
+     RAND_seed(buf, sizeof(buf));
+     close(fd);
+     return 0;
+   }
+ #endif
+ }
+ 
++/**
++   Cleans up the obfs2 crypto subsystem.
++*/
+ void
+ cleanup_crypto(void)
+ {
+   ERR_free_strings();
+ }
+ 
+ /* =====
+    Digests
+    ===== */
+ 
+ #ifdef USE_OPENSSL_SHA256
+ struct digest_t {
+   SHA256_CTX ctx;
+ };
++
++/**
++   Returns a new SHA256 digest container, or NULL on failure.
++*/
+ digest_t *
+ digest_new(void)
+ {
+   digest_t *d = malloc(sizeof(digest_t));
++  if (!d)
++    return NULL;
+   SHA256_Init(&d->ctx);
+   return d;
+ }
++
++/**
++   Updates the contents of the SHA256 container 'd' with the first
++   'len' bytes of 'buf'.
++*/ 
+ void
+ digest_update(digest_t *d, const uchar *buf, size_t len)
+ {
+   SHA256_Update(&d->ctx, buf, len);
+ }
++
++/**
++   Returns the digest stored in 'd' into 'buf' of length 'len'.
++*/
+ size_t
+ digest_getdigest(digest_t *d, uchar *buf, size_t len)
+ {
+   uchar tmp[SHA256_LENGTH];
+   int n = 32;
+   SHA256_Final(tmp, &d->ctx);
+   if (len < 32)
+     n = len;
+   memcpy(buf, tmp, n);
+   memset(tmp, 0, sizeof(tmp));
+   return n;
+ }
+ #else
+ struct digest_t {
+   sha256_state ctx;
+ };
+ digest_t *
+ digest_new(void)
+ {
+   digest_t *d = malloc(sizeof(digest_t));
++  if (!d)
++    return NULL;
+   sha256_init(&d->ctx);
+   return d;
+ }
+ void
+ digest_update(digest_t *d, const uchar *buf, size_t len)
+ {
+   sha256_process(&d->ctx, buf, len);
+ }
+ size_t
+ digest_getdigest(digest_t *d, uchar *buf, size_t len)
+ {
+   uchar tmp[SHA256_LENGTH];
+   int n = 32;
+   sha256_done(&d->ctx, tmp);
+   if (len < 32)
+     n = len;
+   memcpy(buf, tmp, n);
+   memset(tmp, 0, sizeof(tmp));
+   return n;
+ }
+ #endif
+ 
+ void
+ digest_free(digest_t *d)
+ {
+   memset(d, 0, sizeof(digest_t));
+   free(d);
+ }
+ 
+ /* =====
+    Stream crypto
+    ===== */
+ 
++/**
++   Initializes the AES cipher with 'key'.
++*/ 
+ crypt_t *
+ crypt_new(const uchar *key, size_t keylen)
+ {
+   crypt_t *k;
+   if (keylen < AES_BLOCK_SIZE)
+     return NULL;
+ 
+   k = calloc(1, sizeof(crypt_t));
+   if (k == NULL)
+     return NULL;
+ 
+   AES_set_encrypt_key(key, 128, &k->key);
+ 
+   return k;
+ }
++
++/**
++   Sets the IV of 'key' to 'iv'.
++*/
+ void
+ crypt_set_iv(crypt_t *key, const uchar *iv, size_t ivlen)
+ {
+   assert(ivlen == sizeof(key->ivec));
+   memcpy(key->ivec, iv, ivlen);
+ }
++
++/*
++  In-place encrypts 'buf' with 'key'.
++*/
+ void
+ stream_crypt(crypt_t *key, uchar *buf, size_t len)
+ {
+   AES_ctr128_encrypt(buf, buf, /* XXX make sure this is okay to do. */
+                      len,
+                      &key->key, key->ivec, key->ecount_buf,
+                      &key->pos);
+ }
++
++/**
++   Deallocates memory space of 'key'.
++*/
+ void
+ crypt_free(crypt_t *key)
+ {
+   memset(key, 0, sizeof(key));
+   free(key);
+ }
+ 
+ /* =====
+    PRNG
+    ===== */
+ 
++/**
++   Fills 'buf' with 'buflen' random bytes and returns 0 on success.
++   Returns -1 on failure.
++*/
+ int
+ random_bytes(uchar *buf, size_t buflen)
+ {
+   return RAND_bytes(buf, buflen) == 1 ? 0 : -1;
+ }
diff --cc src/main.c
index ee2a802,8788067..48d0d37
--- a/src/main.c
+++ b/src/main.c
@@@ -402,12 -358,11 +398,11 @@@ main(int argc, const char **argv
  
    log_info("Exiting.");
  
-   if (close_obfsproxy_logfile() < 0)
-     printf("Failed closing logfile!\n");
+   close_obfsproxy_logfile();
  
 +  free_all_listeners(); /* free all listeners in our listener dll */
 +
    /* We are exiting. Clean everything. */
 -  for (h=0;h<n_listeners;h++)
 -    listener_free(listeners[h]);
    free(protocol_options);
    free(n_options_array);
    free(protocols);
diff --cc src/network.c
index 6d1d211,081af6e..ea06bc2
--- a/src/network.c
+++ b/src/network.c
@@@ -4,13 -4,13 +4,14 @@@
  
  #define NETWORK_PRIVATE
  #include "network.h"
+ 
  #include "util.h"
++#include "main.h"
  #include "socks.h"
  #include "protocol.h"
- #include "socks.h"
- #include "main.h"
  
  #include <assert.h>
+ #include <errno.h>
  #include <stdlib.h>
  #include <string.h>
  
@@@ -18,14 -20,10 +21,14 @@@
  #include <event2/util.h>
  
  #ifdef _WIN32
- #include <WS2tcpip.h>
+ #include <ws2tcpip.h>  /* socklen_t */
  #endif
  
 +/** Doubly linked list holding all our listeners. */
 +static dll_t listener_list = DLL_INIT();
 +
  struct listener_t {
 +  dll_node_t dll_node;
    struct evconnlistener *listener;
    protocol_params_t *proto_params;
  };
@@@ -55,50 -43,10 +58,50 @@@ static void input_event_cb(struct buffe
  static void output_event_cb(struct bufferevent *bev, short what, void *arg);
  
  /**
 -   This function sets up the protocol defined by 'options' and
 -   attempts to bind a new listener for it.
 +   Puts obfsproxy's networking subsystem on "closing time" mode. This
 +   means that we stop accepting new connections and we shutdown when
 +   the last connection is closed.
 +
 +   If 'barbaric' is set, we forcefully close all open connections and
 +   finish shutdown.
 +   
 +   (Only called by signal handlers)
 +*/
 +void
 +start_shutdown(int barbaric)
 +{
 +  if (!shutting_down)
 +    shutting_down=1;
 +
 +  if (!n_connections) {
 +    finish_shutdown();
 +    return;
 +  }
 +
 +  if (barbaric) {
 +    if (n_connections)
 +      close_all_connections();
 +    return;
 +  }
 +}  
 +
 +/**
 +   Closes all open connections.
 +*/ 
 +static void
 +close_all_connections(void)
 +{
 +  /** Traverse the dll and close all connections */
 +  while (conn_list.head) {
 +    conn_t *conn = UPCAST(conn_t, dll_node, conn_list.head);
 +    conn_free(conn); /* removes it */
 +  }
 +  assert(!n_connections);
 +}
 +/**
 +   This function spawns a listener according to the 'proto_params'.
  
-    Returns the listener on success and NULL on fail.
+    Returns the listener on success, NULL on fail.
  */
  listener_t *
  listener_new(struct event_base *base,
diff --cc src/network.h
index dc6b583,7bc4811..ad54686
--- a/src/network.h
+++ b/src/network.h
@@@ -45,13 -33,13 +33,20 @@@ typedef struct listener_t listener_t
  listener_t *listener_new(struct event_base *base,
                           struct protocol_params_t *params);
  void listener_free(listener_t *listener);
 +void free_all_listeners(void);
 +
 +void start_shutdown(int barbaric);
  
  #ifdef NETWORK_PRIVATE
++
++#include "util.h"
++
+ struct bufferevent;
+ struct socks_state_t;
+ struct protocol_t;
+ 
  typedef struct conn_t {
 +  dll_node_t dll_node;
    struct socks_state_t *socks_state;
    struct protocol_t *proto; /* ASN Do we like this here? We probably don't.
                                 But it's so convenient!! So convenient! */
diff --cc src/protocol.c
index 0845c11,557a5cc..282db10
--- a/src/protocol.c
+++ b/src/protocol.c
@@@ -40,8 -38,9 +38,9 @@@ set_up_protocol(int n_options, char **o
  }
  
  /**
 -   This function creates a protocol object.
 -   It's called once per connection.
 -   It creates a new protocol_t structure and fills it's vtable etc.
 +   This function is called once per connection and creates a protocol
 +   object to be used during the session.
++
     Return a 'protocol_t' if successful, NULL otherwise.
  */
  struct protocol_t *
diff --cc src/protocols/dummy.c
index eaf921c,7a32b47..3b31e12
--- a/src/protocols/dummy.c
+++ b/src/protocols/dummy.c
@@@ -54,20 -49,15 +50,18 @@@ dummy_init(int n_options, char **option
    vtable->send = dummy_send;
    vtable->recv = dummy_recv;
  
 -  return 1;
 +  return 0;
  }
  
 +/**
 +   Helper: Parses 'options' and fills 'params'.
 +*/ 
  static int
- parse_and_set_options(int n_options, char **options, 
+ parse_and_set_options(int n_options, char **options,
                        struct protocol_params_t *params)
  {
-   struct sockaddr_storage ss_listen;
-   int sl_listen;
    const char* defport;
-   
+ 
    if (n_options != 3)
      return -1;
  
@@@ -91,18 -82,10 +86,13 @@@
      log_warn("addr");
      return -1;
    }
-   assert(sl_listen <= sizeof(struct sockaddr_storage));
-   struct sockaddr *sa_listen=NULL;
-   sa_listen = (struct sockaddr *)&ss_listen;
-   memcpy(&params->on_address, sa_listen, sl_listen);
-   params->on_address_len = sl_listen;
-   
-   return 0;
+ 
+   return 1;
  }
  
 +/**
 +   Prints dummy protocol usage information.
 +*/
  static void
  usage(void)
  {
@@@ -115,13 -98,8 +105,13 @@@
           "Example:\n"
           "\tobfsproxy dummy socks 127.0.0.1:5000\n");
  }
-     
+ 
 +/*
 +  This is called everytime we get a connection for the dummy
 +  protocol.
-   
+ 
 +  It sets up the protocol vtable in 'proto_struct'.
 +*/
  void *
  dummy_new(struct protocol_t *proto_struct,
            struct protocol_params_t *params)
diff --cc src/protocols/obfs2.c
index f9beee5,c2169a1..27e9272
--- a/src/protocols/obfs2.c
+++ b/src/protocols/obfs2.c
@@@ -58,18 -55,13 +55,16 @@@ obfs2_init(int n_options, char **option
      return -1;
    }
  
 -  return 1;
 +  return 0;
  }
  
 +/**
 +   Helper: Parses 'options' and fills 'params'.
 +*/
  int
- parse_and_set_options(int n_options, char **options, 
+ parse_and_set_options(int n_options, char **options,
                        struct protocol_params_t *params)
  {
-   struct sockaddr_storage ss_listen;
-   int sl_listen;
    int got_dest=0;
    int got_ss=0;
    const char* defport;
@@@ -192,8 -174,8 +177,8 @@@ set_up_vtable(void
    vtable->handshake = obfs2_send_initial_message;
    vtable->send = obfs2_send;
    vtable->recv = obfs2_recv;
-   
+ 
 -  return 1;
 +  return 0;
  }
  
  /** Return true iff the OBFUSCATE_SEED_LENGTH-byte seed in 'seed' is nonzero */
diff --cc src/socks.c
index f175a8e,e6d72fd..e89812f
--- a/src/socks.c
+++ b/src/socks.c
@@@ -50,16 -40,8 +40,13 @@@
  */
  
  
- static enum socks_ret socks5_do_negotiation(struct evbuffer *dest,
-                                     unsigned int neg_was_success);
- 
  typedef unsigned char uchar;
  
 +/**
 +   Creates a new SOCKS state.
 +
 +   Returns a 'socks_state_t' on success, NULL on fail.
 +*/
  socks_state_t *
  socks_state_new(void)
  {
@@@ -123,17 -102,19 +110,16 @@@ socks_errno_to_reply(socks_state_t *sta
  #undef ERR
  
  /**
 -   Takes a command request from 'source', it evaluates it and if it's
 -   legit it parses it into 'parsereq'.
 -
 -   It returns '1' if everything went fine.
 -   It returns '0' if we need more data from the client.
 -   It returns '-1' if we didn't like something.
 -   It returns '-2' if the client asked for something else than CONNECT.
 -   If that's the case we should send a reply back to the client
 -   telling him that we don't support it.
 -
 -   Disclaimer: This is just a temporary documentation.
 -
 -   Client Request (Client -> Server)
 +   Takes a SOCKS5 command request from 'source', it evaluates it and
 +   if it's legit it parses it into 'parsereq'.
 +   
 +   It returns SOCKS_GOOD if everything went fine.
 +   It returns SOCKS_INCOMPLETE if we need more data from the client.
 +   It returns SOCKS_BROKEN if we didn't like something.
 +   It returns SOCKS_CMD_NOT_CONNECT if the client asked for something
 +   else other than CONNECT.  If that's the case we should send a reply
 +   back to the client telling him that we don't support it.
 +   
-    Client Request (Client -> Server)
  */
  enum socks_ret
  socks5_handle_request(struct evbuffer *source, struct parsereq *parsereq)
@@@ -292,8 -274,35 +280,33 @@@ socks5_send_reply(struct evbuffer *repl
  }
  
  /**
+    This function sends a method negotiation reply to 'dest'.
+    If 'neg_was_success' is true send a positive response,
+    otherwise send a negative one.
+    It returns -1 if no suitable negotiation methods were found,
+    or if there was an error during replying.
+ 
+    Method Negotiation Reply (Server -> Client):
+    | version | method selected |
+        1b           1b
+ */
+ static enum socks_ret
+ socks5_do_negotiation(struct evbuffer *dest, unsigned int neg_was_success)
+ {
+   uchar reply[2];
+   reply[0] = SOCKS5_VERSION;
+ 
+   reply[1] = neg_was_success ? SOCKS5_METHOD_NOAUTH : SOCKS5_METHOD_FAIL;
+ 
+   if (evbuffer_add(dest, reply, 2) == -1 || !neg_was_success)
+     return SOCKS_BROKEN;
+   else
+     return SOCKS_GOOD;
+ }
+ 
+ /**
     This function handles the initial SOCKS5 packet in 'source' sent by
 -   the client, which negotiates the version and method of SOCKS.  If
 +   the client which negotiates the version and method of SOCKS.  If
     the packet is actually valid, we reply to 'dest'.
  
     Method Negotiation Packet (Client -> Server):
@@@ -338,39 -347,7 +351,16 @@@ socks5_handle_negotiation(struct evbuff
    return socks5_do_negotiation(dest,found_noauth);
  }
  
 -/* rename to socks4_handle_request or something. */
 +/**
-    This function sends a method negotiation reply to 'dest'.
-    If 'neg_was_success' is true send a positive response,
-    otherwise send a negative one.
-    It returns -1 if no suitable negotiation methods were found,
-    or if there was an error during replying.
- 
-    Method Negotiation Reply (Server -> Client):
-    | version | method selected |
-        1b           1b
- */
- static enum socks_ret
- socks5_do_negotiation(struct evbuffer *dest, unsigned int neg_was_success)
- {
-   uchar reply[2];
-   reply[0] = SOCKS5_VERSION;
- 
-   reply[1] = neg_was_success ? SOCKS5_METHOD_NOAUTH : SOCKS5_METHOD_FAIL;
- 
-   if (evbuffer_add(dest, reply, 2) == -1 || !neg_was_success)
-     return SOCKS_BROKEN;
-   else
-     return SOCKS_GOOD;
- }
- 
- /**
 +   Takes a SOCKS4/SOCKS4a command request from 'source', it evaluates
 +   it and if it's legit it parses it into 'parsereq'.
 +   
 +   It returns SOCKS_GOOD if everything went fine.
 +   It returns SOCKS_INCOMPLETE if we need more data from the client.
 +   It returns SOCKS_BROKEN if we didn't like something.
 +*/   
++
++/* XXXX rename to socks4_handle_request or something. */
  enum socks_ret
  socks4_read_request(struct evbuffer *source, socks_state_t *state)
  {
diff --cc src/socks.h
index 6ae69e9,ef7b953..e2c20b5
--- a/src/socks.h
+++ b/src/socks.h
@@@ -43,11 -39,11 +39,10 @@@ int socks_state_get_address(const socks
                              const char **addr_out,
                              int *port_out);
  int socks_state_set_address(socks_state_t *state, const struct sockaddr *sa);
 -int socks_send_reply(socks_state_t *state, struct evbuffer *dest, int error);
 -int socks5_send_reply(struct evbuffer *reply_dest,
 -                      socks_state_t *state, int status);
 -
 +void socks_send_reply(socks_state_t *state, struct evbuffer *dest, int error);
- void socks5_send_reply(struct evbuffer *reply_dest, 
++void socks5_send_reply(struct evbuffer *reply_dest,
 +                       socks_state_t *state, int status);
  
- 
  #define SOCKS5_SUCCESS            0x00
  #define SOCKS5_FAILED_GENERAL     0x01
  #define SOCKS5_FAILED_NOTALLOWED  0x02
@@@ -106,11 -102,16 +101,14 @@@ struct socks_state_t 
  
  enum socks_ret socks5_handle_negotiation(struct evbuffer *source,
                                struct evbuffer *dest, socks_state_t *state);
 -int socks5_send_reply(struct evbuffer *reply_dest, socks_state_t *state,
 -                      int status);
 -enum socks_ret socks5_handle_request(struct evbuffer *source,
 -                                     struct parsereq *parsereq);
 +enum socks_ret socks5_handle_request(struct evbuffer *source, struct parsereq *parsereq);
 +
- enum socks_ret socks4_read_request(struct evbuffer *source, socks_state_t *state);
- void socks4_send_reply(struct evbuffer *dest, 
+ 
+ enum socks_ret socks4_read_request(struct evbuffer *source,
+                                    socks_state_t *state);
 -int socks4_send_reply(struct evbuffer *dest,
 -                      socks_state_t *state, int status);
++void socks4_send_reply(struct evbuffer *dest,
 +                       socks_state_t *state, int status);
- #endif
  
- #endif
+ #endif /* SOCKS_PRIVATE */
+ 
+ #endif /* socks.h */
diff --cc src/test/unittest_obfs2.c
index 27395df,a7c8112..0b2054b
--- a/src/test/unittest_obfs2.c
+++ b/src/test/unittest_obfs2.c
@@@ -31,10 -30,10 +30,10 @@@ test_proto_option_parsing(void *data
    log_set_method(LOG_METHOD_NULL, NULL);
  
    tt_assert(set_up_protocol(n_options, options,
 -                            proto_params) == 1);
 +                            proto_params) == 0);
  
    /** two --dest. */
-   char *options2[] = {"obfs2", "--dest=127.0.0.1:5555", "--dest=a", 
+   char *options2[] = {"obfs2", "--dest=127.0.0.1:5555", "--dest=a",
                        "server", "127.0.0.1:5552"};
    n_options = 5;
  
diff --cc src/util.c
index 4517f95,d54c67f..cab4bf1
--- a/src/util.c
+++ b/src/util.c
@@@ -159,120 -134,8 +145,120 @@@ obfs_vsnprintf(char *str, size_t size, 
    return r;
  }
  
 +/************************ Doubly Linked List (DLL) ******************/
 +
 +/**
 +   Insert 'new_node' after 'node' in the doubly linked list 'list'.
 +*/
 +static void
 +dll_insert_after(dll_t *list, dll_node_t *node, dll_node_t *new_node)
 +{
 +  assert(node);
 +  assert(new_node);
 +
 +  if (!list)
 +    return;
 +
 +  new_node->prev = node;
 +  new_node->next = node->next;
 +  if (!node->next)
 +    list->tail = new_node;
 +  else
 +    node->next->prev = new_node;
 +  node->next = new_node;
 +}
 +
 +/**
 +   Insert 'new_node' before 'node' in the doubly linked list 'list'.
 +*/ 
 +static void
 +dll_insert_before(dll_t *list, dll_node_t *node, dll_node_t *new_node)
 +{
 +  assert(node);
 +  assert(new_node);
 +
 +  if (!list)
 +    return;
 +
 +  new_node->prev = node->prev;
 +  new_node->next = node;
 +  if (!node->prev)
 +    list->head = new_node;
 +  else
 +    node->prev->next = new_node;
 +  node->prev = new_node;
 +}
 +
 +/** Initialize <b>list</b> as an empty list. */
 +void
 +dll_init(dll_t *list)
 +{
 +  list->head = list->tail = NULL;
 +}
 +  
 +/**
 +   Insert 'node' in the beginning of the doubly linked 'list'.
 +*/ 
 +static void
 +dll_insert_beginning(dll_t *list, dll_node_t *node)
 +{
 +  assert(node);
 +
 +  if (!list)
 +    return;
 +
 +  if (!list->head) {
 +    list->head = node;
 +    list->tail = node;
 +    node->prev = NULL;
 +    node->next = NULL;
 +  } else {
 +    dll_insert_before(list, list->head, node);
 +  }
 +}
 +  
 +/** 
 +    Appends 'data' to the end of the doubly linked 'list'.
 +    Returns 1 on success, -1 on fail.
 +*/
 +int
 +dll_append(dll_t *list, dll_node_t *node)
 +{
 +  assert(list);
 +  assert(node);
 +
 +  if (!list->tail)
 +    dll_insert_beginning(list, node);
 +  else
 +    dll_insert_after(list, list->tail, node);
 +
 +  return 1;
 +}
 +
 +/**
 +   Removes 'node' from the doubly linked list 'list'.
 +   It frees the list node, but leaves its data intact.
 +*/ 
 +void
 +dll_remove(dll_t *list, dll_node_t *node)
 +{
 +  assert(node);
 +
 +  if (!list)
 +    return;
 +
 +  if (!node->prev)
 +    list->head = node->next;
 +  else
 +    node->prev->next = node->next;
 +  if (!node->next)
 +    list->tail = node->prev;
 +  else
 +    node->next->prev = node->prev;
 +}
 +
  /************************ Logging Subsystem *************************/
- /** The code of this section was to a great extend shamelessly copied
+ /** The code of this section was to a great extent shamelessly copied
      off tor. It's basicaly a stripped down version of tor's logging
      system. Thank you tor. */
  
@@@ -331,27 -200,8 +323,8 @@@ sev_is_valid(int severity
  }
  
  /**
-    Sets the global logging 'method' and also sets and open the logfile
-    'filename' in case we want to log into a file.
-    It returns 0 on success and -1 on fail.
- */
- int
- log_set_method(int method, const char *filename)
- {
-   
-   logging_method = method;
-   if (method == LOG_METHOD_FILE) {
-     if (open_and_set_obfsproxy_logfile(filename) < 0)
-       return -1;
-     if (write_logfile_prologue(logging_logfile) < 0)
-       return -1;
-   }    
-   return 0;
- }
- 
- /**
     Helper: Opens 'filename' and sets it as the obfsproxy logfile.
 -   On success it returns 1, on fail it returns -1.
 +   On success it returns 0, on fail it returns -1.
  */
  static int
  open_and_set_obfsproxy_logfile(const char *filename)
@@@ -381,17 -228,14 +351,16 @@@ close_obfsproxy_logfile(void
  }
  
  /**
 -   Writes a small prologue in the logfile 'fd' to separate log
 -   instances.
 +   Writes a small prologue in the logfile 'fd' that mentions the
 +   obfsproxy version and helps separate log instances.
 +
 +   Returns 0 on success, -1 on failure.
  */
  static int
- write_logfile_prologue(int logfile) {
-   char buf[256];
-   if (compose_logfile_prologue(buf, sizeof(buf)) < 0)
-     return -1;
-   if (write(logfile, buf, strlen(buf)) < 0)
+ write_logfile_prologue(int logfile)
+ {
+   static const char prologue[] = "\nBrand new obfsproxy log:\n";
+   if (write(logfile, prologue, strlen(prologue)) != strlen(prologue))
      return -1;
    return 0;
  }
diff --cc src/util.h
index 7e73cee,f52f335..ff9df22
--- a/src/util.h
+++ b/src/util.h
@@@ -50,60 -35,8 +35,36 @@@ int obfs_snprintf(char *str, size_t siz
                    const char *format, ...)
    __attribute__((format(printf, 3, 4)));
  
 +/***** Doubly Linked List stuff. *****/
 +
 +#define OFFSETOF(container_type, element) \
 +  (((char*)&((container_type*)0)->element) - ((char*) ((container_type*)0)))
 +
 +#define UPCAST(container_type, element, ptr) \
 +  (container_type*) (                                                   \
 +         ((char*)ptr) - OFFSETOF(container_type, element)   \
 +                    )
 +
 +
 +/** A doubly linked list node.
 +    [algorithms ripped off Wikipedia (Doubly_linked_list) ] */
 +typedef struct dll_node_t {
 +  struct dll_node_t *next, *prev;
 +} dll_node_t;
 +
 +/** A doubly linked list. */
 +typedef struct dll_t {
 +  struct dll_node_t *head;
 +  struct dll_node_t *tail;
 +} dll_t;
 +
 +void dll_init(dll_t *list);
 +int dll_append(dll_t *list, dll_node_t *node);
 +void dll_remove(dll_t *list, dll_node_t *node);
 +#define DLL_INIT() { NULL, NULL }
 +
  /***** Logging subsystem stuff. *****/
  
- void log_fn(int severity, const char *format, ...)
-   __attribute__((format(printf, 2, 3)));
- int log_set_method(int method, const char *filename);
- int log_set_min_severity(const char* sev_string);
- int close_obfsproxy_logfile(void);
- 
- #ifdef __GNUC__
- #define log_info(args...) log_fn(LOG_SEV_INFO, args)
- #define log_warn(args...) log_fn(LOG_SEV_WARN, args)
- #define log_debug(args...) log_fn(LOG_SEV_DEBUG, args)
- #elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
- #define log_info(...) log_fn(LOG_SEV_INFO, __VA_ARGS__)
- #define log_warn(...) log_fn(LOG_SEV_WARN, __VA_ARGS__)
- #define log_debug(...) log_fn(LOG_SEV_DEBUG, __VA_ARGS__)
- #else
- #define NEED_LOG_WRAPPERS
- void log_info(const char *format, ...)
-   __attribute__((format(printf, 1, 2)));
- void log_warn(const char *format, ...)
-   __attribute__((format(printf, 1, 2)));
- void log_debug(const char *format, ...)
-   __attribute__((format(printf, 1, 2)));
- #endif
- 
  /** Logging methods */
  
  /** Spit log messages on stdout. */

_______________________________________________
tor-commits mailing list
tor-commits@xxxxxxxxxxxxxxxxxxxx
https://lists.torproject.org/cgi-bin/mailman/listinfo/tor-commits