The Tor Browser: media/mtransport/third_party/nICEr/upstream.diff@97036ab72558 (annotated)

media/mtransport/third_party/nICEr/upstream.diff@97036ab72558 (annotated)

media/mtransport/third_party/nICEr/upstream.diff

Tue, 06 Jan 2015 21:39:09 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Tue, 06 Jan 2015 21:39:09 +0100
branch: TOR_BUG_9701
changeset 8: 97036ab72558
permissions: -rw-r--r--

Conditionally force memory storage according to privacy.thirdparty.isolate;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

 diff -U10 -r /Users/ekr/dev/mtransport-import-references/nICEr/src/ice/ice_candidate.c src/ice/ice_candidate.c
 --- /Users/ekr/dev/mtransport-import-references/nICEr/src/ice/ice_candidate.c	2012-09-16 16:26:08.000000000 -0700
 +++ src/ice/ice_candidate.c	2012-10-06 08:30:22.000000000 -0700
@@ -54,36 +54,38 @@
  #include "stun_client_ctx.h"
  #include "stun_server_ctx.h"
  #include "turn_client_ctx.h"
  #include "ice_ctx.h"
  #include "ice_candidate.h"
  #include "ice_reg.h"
  #include "ice_util.h"
  #include "nr_socket_turn.h"
 +static int next_automatic_preference = 224;
 +
  static int nr_ice_get_foundation(nr_ice_ctx *ctx,nr_ice_candidate *cand);
  static int nr_ice_srvrflx_start_stun(nr_ice_candidate *cand, NR_async_cb ready_cb, void *cb_arg);
 -static void nr_ice_srvrflx_stun_finished_cb(int sock, int how, void *cb_arg);
 +static void nr_ice_srvrflx_stun_finished_cb(NR_SOCKET sock, int how, void *cb_arg);
  #ifdef USE_TURN
  static int nr_ice_start_relay_turn(nr_ice_candidate *cand, NR_async_cb ready_cb, void *cb_arg);
 -static void nr_ice_turn_allocated_cb(int sock, int how, void *cb_arg);
 +static void nr_ice_turn_allocated_cb(NR_SOCKET sock, int how, void *cb_arg);
  #endif /* USE_TURN */
  char *nr_ice_candidate_type_names[]={0,"host","srflx","prflx","relay",0};
  int nr_ice_candidate_create(nr_ice_ctx *ctx,char *label,nr_ice_component *comp,nr_ice_socket *isock, nr_socket *osock, nr_ice_candidate_type ctype, nr_ice_stun_server *stun_server, UCHAR component_id, nr_ice_candidate **candp)
    {
      nr_ice_candidate *cand=0;
      nr_ice_candidate *tmp=0;
      int r,_status;
 -
 +
      if(!(cand=RCALLOC(sizeof(nr_ice_candidate))))
        ABORT(R_NO_MEMORY);
      if(!(cand->label=r_strdup(label)))
        ABORT(R_NO_MEMORY);
      cand->state=NR_ICE_CAND_STATE_CREATED;
      cand->ctx=ctx;
      cand->isock=isock;
      cand->osock=osock;
      cand->type=ctype;
      cand->stun_server=stun_server;
@@ -189,21 +191,21 @@
      if(cand->delay_timer)
        NR_async_timer_cancel(cand->delay_timer);
      RFREE(cand->foundation);
      RFREE(cand->label);
      RFREE(cand);
      return(0);
    }
 -void nr_ice_candidate_destroy_cb(int s, int h, void *cb_arg)
 +void nr_ice_candidate_destroy_cb(NR_SOCKET s, int h, void *cb_arg)
    {
      nr_ice_candidate *cand=cb_arg;
      nr_ice_candidate_destroy(&cand);
    }
  /* This algorithm is not super-fast, but I don't think we need a hash
     table just yet and it produces a small foundation string */
  static int nr_ice_get_foundation(nr_ice_ctx *ctx,nr_ice_candidate *cand)
    {
      nr_ice_foundation *foundation;
@@ -276,22 +278,38 @@
          break;
        default:
          ABORT(R_INTERNAL);
      }
      if(type_preference > 126)
        r_log(LOG_ICE,LOG_ERR,"Illegal type preference %d",type_preference);
      if(r=NR_reg_get2_uchar(NR_ICE_REG_PREF_INTERFACE_PRFX,cand->base.ifname,
 -      &interface_preference))
 -      ABORT(r);
 +      &interface_preference)) {
 +      if (r==R_NOT_FOUND) {
 +        if (next_automatic_preference == 1) {
 +          r_log(LOG_ICE,LOG_DEBUG,"Out of preference values. Can't assign one for interface %s",cand->base.ifname);
 +          ABORT(R_NOT_FOUND);
 +        }
 +        r_log(LOG_ICE,LOG_DEBUG,"Automatically assigning preference for interface %s->%d",cand->base.ifname,
 +          next_automatic_preference);
 +        if (r=NR_reg_set2_uchar(NR_ICE_REG_PREF_INTERFACE_PRFX,cand->base.ifname,next_automatic_preference)){
 +          ABORT(r);
 +        }
 +        interface_preference=next_automatic_preference;
 +        next_automatic_preference--;
 +      }
 +      else {
 +        ABORT(r);
 +      }
 +    }
      cand->priority=
        (type_preference << 24) |
        (interface_preference << 16) |
        (stun_priority << 8) |
        (256 - cand->component_id);
      /* S 4.1.2 */
      assert(cand->priority>=1&&cand->priority<=2147483647);
@@ -306,21 +324,22 @@
      cand->done_cb=ready_cb;
      cand->cb_arg=cb_arg;
      switch(cand->type){
        case HOST:
          if(r=nr_socket_getaddr(cand->isock->sock,&cand->addr))
            ABORT(r);
          cand->osock=cand->isock->sock;
          cand->state=NR_ICE_CAND_STATE_INITIALIZED;
 -        ready_cb(0,0,cb_arg);
 +        // Post this so that it doesn't happen in-line
 +        NR_ASYNC_SCHEDULE(ready_cb,cb_arg);
          break;
  #ifdef USE_TURN
        case RELAYED:
          if(r=nr_ice_start_relay_turn(cand,ready_cb,cb_arg))
            ABORT(r);
          ABORT(R_WOULDBLOCK);
          break;
  #endif /* USE_TURN */
        case SERVER_REFLEXIVE:
          /* Need to start stun */
@@ -333,21 +352,21 @@
          ABORT(R_INTERNAL);
      }
      _status=0;
    abort:
      if(_status && _status!=R_WOULDBLOCK)
        cand->state=NR_ICE_CAND_STATE_FAILED;
      return(_status);
    }
 -static void nr_ice_srvrflx_start_stun_timer_cb(int s, int how, void *cb_arg)
 +static void nr_ice_srvrflx_start_stun_timer_cb(NR_SOCKET s, int how, void *cb_arg)
    {
      nr_ice_candidate *cand=cb_arg;
      int r,_status;
      cand->delay_timer=0;
  /* TODO: if the response is a BINDING-ERROR-RESPONSE, then restart
   * TODO: using NR_STUN_CLIENT_MODE_BINDING_REQUEST because the
   * TODO: server may not have understood the 0.96-style request */
      if(r=nr_stun_client_start(cand->u.srvrflx.stun, NR_STUN_CLIENT_MODE_BINDING_REQUEST_STUND_0_96, nr_ice_srvrflx_stun_finished_cb, cand))
@@ -387,21 +406,21 @@
      _status=0;
    abort:
      if(_status){
        cand->state=NR_ICE_CAND_STATE_FAILED;
      }
      return(_status);
    }
  #ifdef USE_TURN
 -static void nr_ice_start_relay_turn_timer_cb(int s, int how, void *cb_arg)
 +static void nr_ice_start_relay_turn_timer_cb(NR_SOCKET s, int how, void *cb_arg)
    {
      nr_ice_candidate *cand=cb_arg;
      int r,_status;
      int i;
      cand->delay_timer=0;
      if(r=nr_turn_client_allocate(cand->u.relayed.turn, cand->u.relayed.server->username, cand->u.relayed.server->password, cand->u.relayed.server->bandwidth_kbps, cand->u.relayed.server->lifetime_secs, nr_ice_turn_allocated_cb, cand))
        ABORT(r);
@@ -443,21 +462,21 @@
      _status=0;
    abort:
      if(_status){
        cand->state=NR_ICE_CAND_STATE_FAILED;
      }
      return(_status);
    }
  #endif /* USE_TURN */
 -static void nr_ice_srvrflx_stun_finished_cb(int sock, int how, void *cb_arg)
 +static void nr_ice_srvrflx_stun_finished_cb(NR_SOCKET sock, int how, void *cb_arg)
    {
      int _status;
      nr_ice_candidate *cand=cb_arg;
      /* Deregister to suppress duplicates */
      if(cand->u.srvrflx.stun_handle){ /* This test because we might have failed before CB registered */
        nr_ice_socket_deregister(cand->isock,cand->u.srvrflx.stun_handle);
        cand->u.srvrflx.stun_handle=0;
      }
@@ -481,40 +500,40 @@
      }
      _status = 0;
    abort:
      if(_status){
        cand->state=NR_ICE_CAND_STATE_FAILED;
        cand->done_cb(0,0,cand->cb_arg);
      }
    }
  #ifdef USE_TURN
 -static void nr_ice_turn_allocated_cb(int s, int how, void *cb_arg)
 +static void nr_ice_turn_allocated_cb(NR_SOCKET s, int how, void *cb_arg)
    {
      int r,_status;
      nr_ice_candidate *cand=cb_arg;
      nr_turn_client_ctx *turn=cand->u.relayed.turn;
      int i;
      char *label;
      /* Deregister to suppress duplicates */
      if(cand->u.relayed.turn_handle){ /* This test because we might have failed before CB registered */
        nr_ice_socket_deregister(cand->isock,cand->u.relayed.turn_handle);
        cand->u.relayed.turn_handle=0;
      }
      switch(turn->state){
      /* OK, we should have a mapped address */
      case NR_TURN_CLIENT_STATE_ALLOCATED:
          /* switch candidate from TURN mode to STUN mode */
 -        if(r=nr_concat_strings(&label,"turn-relay(",cand->base.as_string,"|",turn->relay_addr.as_string,")",0))
 +        if(r=nr_concat_strings(&label,"turn-relay(",cand->base.as_string,"|",turn->relay_addr.as_string,")",NULL))
            ABORT(r);
          r_log(LOG_ICE,LOG_DEBUG,"ICE(%s): Switching from TURN (%s) to RELAY (%s)",cand->u.relayed.turn->label,cand->label,label);
          /* Copy out mapped address and relay address */
          nr_transport_addr_copy(&turn->relay_addr, &cand->u.relayed.turn->stun_ctx[NR_TURN_CLIENT_PHASE_ALLOCATE_REQUEST2]->results.allocate_response2.relay_addr);
          nr_transport_addr_copy(&cand->addr, &turn->relay_addr);
          r_log(LOG_ICE,LOG_DEBUG,"ICE-CANDIDATE(%s): base=%s, candidate=%s", cand->label, cand->base.as_string, cand->addr.as_string);
 diff -U10 -r /Users/ekr/dev/mtransport-import-references/nICEr/src/ice/ice_candidate.h src/ice/ice_candidate.h
 --- /Users/ekr/dev/mtransport-import-references/nICEr/src/ice/ice_candidate.h	2012-09-16 16:26:08.000000000 -0700
 +++ src/ice/ice_candidate.h	2012-10-06 08:30:22.000000000 -0700
@@ -41,21 +41,22 @@
  typedef enum {HOST=1, SERVER_REFLEXIVE, PEER_REFLEXIVE, RELAYED} nr_ice_candidate_type;
  struct nr_ice_candidate_ {
    char *label;
    int state;
  #define NR_ICE_CAND_STATE_CREATED          1
  #define NR_ICE_CAND_STATE_INITIALIZING     2
  #define NR_ICE_CAND_STATE_INITIALIZED      3
  #define NR_ICE_CAND_STATE_FAILED           4
 -#define NR_ICE_CAND_PEER_CANDIDATE         10
 +#define NR_ICE_CAND_PEER_CANDIDATE_UNPAIRED 9
 +#define NR_ICE_CAND_PEER_CANDIDATE_PAIRED   10
    struct nr_ice_ctx_ *ctx;
    nr_ice_socket *isock;               /* The socket to read from
                                           (it contains all other candidates
                                           on this socket) */
    nr_socket *osock;                   /* The socket to write to */
    nr_ice_media_stream *stream;        /* The media stream this is associated with */
    nr_ice_component *component;        /* The component this is associated with */
    nr_ice_candidate_type type;         /* The type of the candidate (S 4.1.1) */
    UCHAR component_id;                 /* The component id (S 4.1.2.1) */
    nr_transport_addr addr;             /* The advertised address;
@@ -89,21 +90,21 @@
    TAILQ_ENTRY(nr_ice_candidate_) entry_comp;
  };
  extern char *nr_ice_candidate_type_names[];
  int nr_ice_candidate_create(struct nr_ice_ctx_ *ctx,char *label, nr_ice_component *component, nr_ice_socket *isock, nr_socket *osock, nr_ice_candidate_type ctype, nr_ice_stun_server *stun_server, UCHAR component_id, nr_ice_candidate **candp);
  int nr_ice_candidate_initialize(nr_ice_candidate *cand, NR_async_cb ready_cb, void *cb_arg);
  int nr_ice_candidate_process_stun(nr_ice_candidate *cand, UCHAR *msg, int len, nr_transport_addr *faddr);
  int nr_ice_candidate_destroy(nr_ice_candidate **candp);
 -void nr_ice_candidate_destroy_cb(int s, int h, void *cb_arg);
 +void nr_ice_candidate_destroy_cb(NR_SOCKET s, int h, void *cb_arg);
  int nr_ice_format_candidate_attribute(nr_ice_candidate *cand, char *attr, int maxlen);
  int nr_ice_peer_candidate_from_attribute(nr_ice_ctx *ctx,char *attr,nr_ice_media_stream *stream,nr_ice_candidate **candp);
  int nr_ice_peer_peer_rflx_candidate_create(nr_ice_ctx *ctx,char *label, nr_ice_component *comp,nr_transport_addr *addr, nr_ice_candidate **candp);
  int nr_ice_candidate_compute_priority(nr_ice_candidate *cand);
  #ifdef __cplusplus
  }
  #endif /* __cplusplus */
  #endif
 diff -U10 -r /Users/ekr/dev/mtransport-import-references/nICEr/src/ice/ice_candidate_pair.c src/ice/ice_candidate_pair.c
 --- /Users/ekr/dev/mtransport-import-references/nICEr/src/ice/ice_candidate_pair.c	2012-09-16 16:26:08.000000000 -0700
 +++ src/ice/ice_candidate_pair.c	2012-10-06 08:30:22.000000000 -0700
@@ -37,21 +37,21 @@
  #include <assert.h>
  #include <string.h>
  #include <nr_api.h>
  #include "ice_ctx.h"
  #include "ice_util.h"
  #include "ice_codeword.h"
  #include "stun.h"
  static char *nr_ice_cand_pair_states[]={"UNKNOWN","FROZEN","WAITING","IN_PROGRESS","FAILED","SUCCEEDED","CANCELLED"};
 -static void nr_ice_candidate_pair_restart_stun_controlled_cb(int s, int how, void *cb_arg);
 +static void nr_ice_candidate_pair_restart_stun_controlled_cb(NR_SOCKET s, int how, void *cb_arg);
  static void nr_ice_candidate_pair_compute_codeword(nr_ice_cand_pair *pair,
    nr_ice_candidate *lcand, nr_ice_candidate *rcand);
  int nr_ice_candidate_pair_create(nr_ice_peer_ctx *pctx, nr_ice_candidate *lcand,nr_ice_candidate *rcand,nr_ice_cand_pair **pairp)
    {
      nr_ice_cand_pair *pair=0;
      UINT8 o_priority, a_priority;
      char *lufrag,*rufrag;
      char *lpwd,*rpwd;
      char *l2ruser=0,*r2lpass=0;
@@ -61,21 +61,21 @@
      UINT8 t_priority;
      if(!(pair=RCALLOC(sizeof(nr_ice_cand_pair))))
        ABORT(R_NO_MEMORY);
      pair->pctx=pctx;
      nr_ice_candidate_pair_compute_codeword(pair,lcand,rcand);
      if(r=nr_concat_strings(&pair->as_string,pair->codeword,"|",lcand->addr.as_string,"|",
 -         rcand->addr.as_string,"(",lcand->label,"|",rcand->label,")",0))
 +        rcand->addr.as_string,"(",lcand->label,"|",rcand->label,")", NULL))
        ABORT(r);
      nr_ice_candidate_pair_set_state(pctx,pair,NR_ICE_PAIR_STATE_FROZEN);
      pair->local=lcand;
      pair->remote=rcand;
      /* Priority computation S 5.7.2 */
      if(pctx->ctx->flags & NR_ICE_CTX_FLAGS_OFFERER)
      {
        assert(!(pctx->ctx->flags & NR_ICE_CTX_FLAGS_ANSWERER));
@@ -87,21 +87,21 @@
        o_priority=rcand->priority;
        a_priority=lcand->priority;
      }
      pair->priority=(MIN(o_priority, a_priority))<<32 |
        (MAX(o_priority, a_priority))<<1 | (o_priority > a_priority?0:1);
      r_log(LOG_ICE,LOG_DEBUG,"ICE(%s): Pairing candidate %s (%x):%s (%x) priority=%llu (%llx) codeword=%s",pctx->ctx->label,lcand->addr.as_string,lcand->priority,rcand->addr.as_string,rcand->priority,pair->priority,pair->priority,pair->codeword);
      /* Foundation */
      if(r=nr_concat_strings(&pair->foundation,lcand->foundation,"|",
 -      rcand->foundation,0))
 +      rcand->foundation,NULL))
        ABORT(r);
      /* OK, now the STUN data */
      lufrag=lcand->stream->ufrag?lcand->stream->ufrag:pctx->ctx->ufrag;
      lpwd=lcand->stream->pwd?lcand->stream->pwd:pctx->ctx->pwd;
      rufrag=rcand->stream->ufrag?rcand->stream->ufrag:pctx->peer_ufrag;
      rpwd=rcand->stream->pwd?rcand->stream->pwd:pctx->peer_pwd;
@@ -110,39 +110,39 @@
      /* Make a bogus candidate to compute a theoretical peer reflexive
       * priority per S 7.1.1.1 */
      memcpy(&tmpcand, lcand, sizeof(tmpcand));
      tmpcand.type = PEER_REFLEXIVE;
      if (r=nr_ice_candidate_compute_priority(&tmpcand))
        ABORT(r);
      t_priority = tmpcand.priority;
      /* Our sending context */
 -    if(r=nr_concat_strings(&l2ruser,lufrag,":",rufrag,0))
 +    if(r=nr_concat_strings(&l2ruser,lufrag,":",rufrag,NULL))
        ABORT(r);
      if(r=nr_stun_client_ctx_create(pair->as_string,
        lcand->osock,
        &rcand->addr,RTO,&pair->stun_client))
        ABORT(r);
      if(!(pair->stun_client->params.ice_binding_request.username=r_strdup(l2ruser)))
        ABORT(R_NO_MEMORY);
      if(r=r_data_make(&pair->stun_client->params.ice_binding_request.password,(UCHAR *)lpwd,strlen(lpwd)))
        ABORT(r);
      pair->stun_client->params.ice_binding_request.priority=t_priority;
      pair->stun_client->params.ice_binding_request.control = pctx->controlling?
        NR_ICE_CONTROLLING:NR_ICE_CONTROLLED;
      pair->stun_client->params.ice_binding_request.tiebreaker=pctx->tiebreaker;
      /* Our receiving username/passwords. Stash these for later
         injection into the stun server ctx*/
 -    if(r=nr_concat_strings(&pair->r2l_user,rufrag,":",lufrag,0))
 +    if(r=nr_concat_strings(&pair->r2l_user,rufrag,":",lufrag,NULL))
        ABORT(r);
      if(!(r2lpass=r_strdup(rpwd)))
        ABORT(R_NO_MEMORY);
      INIT_DATA(pair->r2l_pwd,(UCHAR *)r2lpass,strlen(r2lpass));
      *pairp=pair;
      _status=0;
    abort:
      RFREE(l2ruser);
@@ -178,21 +178,21 @@
  int nr_ice_candidate_pair_unfreeze(nr_ice_peer_ctx *pctx, nr_ice_cand_pair *pair)
    {
      assert(pair->state==NR_ICE_PAIR_STATE_FROZEN);
      nr_ice_candidate_pair_set_state(pctx,pair,NR_ICE_PAIR_STATE_WAITING);
      return(0);
    }
 -static void nr_ice_candidate_pair_stun_cb(int s, int how, void *cb_arg)
 +static void nr_ice_candidate_pair_stun_cb(NR_SOCKET s, int how, void *cb_arg)
    {
      int r,_status;
      nr_ice_cand_pair *pair=cb_arg,*orig_pair;
      nr_ice_candidate *cand=0;
      nr_stun_message *sres;
      nr_transport_addr *request_src;
      nr_transport_addr *request_dst;
      nr_transport_addr *response_src;
      nr_transport_addr response_dst;
      nr_stun_message_attribute *attr;
@@ -457,32 +457,47 @@
    abort:
      return(_status);
   }
  int nr_ice_candidate_pair_set_state(nr_ice_peer_ctx *pctx, nr_ice_cand_pair *pair, int state)
    {
      int r,_status;
      r_log(LOG_ICE,LOG_DEBUG,"ICE-PEER(%s): setting pair %s to %s",
        pctx->label,pair->as_string,nr_ice_cand_pair_states[state]);
 -    pair->state=state;
 -    if(pctx->state!=NR_ICE_PAIR_STATE_WAITING){
 +    /* NOTE: This function used to reference pctx->state instead of
 +       pair->state and the assignment to pair->state was at the top
 +       of this function. Because pctx->state was never changed, this seems to have
 +       been a typo. The natural logic is "if the state changed
 +       decrement the counter" so this implies we should be checking
 +       the pair state rather than the pctx->state.
 +
 +       This didn't cause big problems because waiting_pairs was only
 +       used for pacing, so the pacing just was kind of broken.
 +
 +       This note is here as a reminder until we do more testing
 +       and make sure that in fact this was a typo.
 +    */
 +    if(pair->state!=NR_ICE_PAIR_STATE_WAITING){
        if(state==NR_ICE_PAIR_STATE_WAITING)
          pctx->waiting_pairs++;
      }
      else{
        if(state!=NR_ICE_PAIR_STATE_WAITING)
          pctx->waiting_pairs--;
        assert(pctx->waiting_pairs>=0);
      }
 +    pair->state=state;
 +
 +
      if(pair->state==NR_ICE_PAIR_STATE_FAILED){
        if(r=nr_ice_component_failed_pair(pair->remote->component, pair))
          ABORT(r);
      }
      _status=0;
    abort:
      return(_status);
    }
@@ -505,42 +520,42 @@
          break;
        }
        c1=TAILQ_NEXT(c1,entry);
      }
      if(!c1) TAILQ_INSERT_TAIL(head,pair,entry);
      return(0);
    }
 -void nr_ice_candidate_pair_restart_stun_nominated_cb(int s, int how, void *cb_arg)
 +void nr_ice_candidate_pair_restart_stun_nominated_cb(NR_SOCKET s, int how, void *cb_arg)
    {
      nr_ice_cand_pair *pair=cb_arg;
      int r,_status;
      r_log(LOG_ICE,LOG_DEBUG,"ICE-PEER(%s)/STREAM(%s):%d: Restarting pair %s as nominated",pair->pctx->label,pair->local->stream->label,pair->remote->component->component_id,pair->as_string);
      nr_stun_client_reset(pair->stun_client);
      pair->stun_client->params.ice_binding_request.control=NR_ICE_CONTROLLING;
      if(r=nr_stun_client_start(pair->stun_client,NR_ICE_CLIENT_MODE_USE_CANDIDATE,nr_ice_candidate_pair_stun_cb,pair))
        ABORT(r);
      if(r=nr_ice_ctx_remember_id(pair->pctx->ctx, pair->stun_client->request))
        ABORT(r);
      _status=0;
    abort:
      return;
    }
 -static void nr_ice_candidate_pair_restart_stun_controlled_cb(int s, int how, void *cb_arg)
 +static void nr_ice_candidate_pair_restart_stun_controlled_cb(NR_SOCKET s, int how, void *cb_arg)
    {
      nr_ice_cand_pair *pair=cb_arg;
      int r,_status;
      r_log(LOG_ICE,LOG_DEBUG,"ICE-PEER(%s)/STREAM(%s):%d: Restarting pair %s as CONTROLLED",pair->pctx->label,pair->local->stream->label,pair->remote->component->component_id,pair->as_string);
      nr_stun_client_reset(pair->stun_client);
      pair->stun_client->params.ice_binding_request.control=NR_ICE_CONTROLLED;
      if(r=nr_stun_client_start(pair->stun_client,NR_ICE_CLIENT_MODE_BINDING_REQUEST,nr_ice_candidate_pair_stun_cb,pair))
@@ -556,21 +571,21 @@
  static void nr_ice_candidate_pair_compute_codeword(nr_ice_cand_pair *pair,
    nr_ice_candidate *lcand, nr_ice_candidate *rcand)
    {
      int r,_status;
      char *as_string=0;
      if(r=nr_concat_strings(&as_string,lcand->addr.as_string,"|",
 -      rcand->addr.as_string,"(",lcand->label,"|",rcand->label,")",0))
 +      rcand->addr.as_string,"(",lcand->label,"|",rcand->label,")",NULL))
        ABORT(r);
      nr_ice_compute_codeword(as_string,strlen(as_string),pair->codeword);
      _status=0;
        abort:
      RFREE(as_string);
  return;
    }
 diff -U10 -r /Users/ekr/dev/mtransport-import-references/nICEr/src/ice/ice_candidate_pair.h src/ice/ice_candidate_pair.h
 --- /Users/ekr/dev/mtransport-import-references/nICEr/src/ice/ice_candidate_pair.h	2012-09-16 16:26:08.000000000 -0700
 +++ src/ice/ice_candidate_pair.h	2012-10-06 08:30:22.000000000 -0700
@@ -72,18 +72,18 @@
  int nr_ice_candidate_pair_create(nr_ice_peer_ctx *pctx, nr_ice_candidate *lcand,nr_ice_candidate *rcand,nr_ice_cand_pair **pairp);
  int nr_ice_candidate_pair_unfreeze(nr_ice_peer_ctx *pctx, nr_ice_cand_pair *pair);
  int nr_ice_candidate_pair_start(nr_ice_peer_ctx *pctx, nr_ice_cand_pair *pair);
  int nr_ice_candidate_pair_set_state(nr_ice_peer_ctx *pctx, nr_ice_cand_pair *pair, int state);
  int nr_ice_candidate_pair_dump_state(nr_ice_cand_pair *pair, FILE *out);
  int nr_ice_candidate_pair_cancel(nr_ice_peer_ctx *pctx,nr_ice_cand_pair *pair);
  int nr_ice_candidate_pair_select(nr_ice_cand_pair *pair);
  int nr_ice_candidate_pair_do_triggered_check(nr_ice_peer_ctx *pctx, nr_ice_cand_pair *pair);
  int nr_ice_candidate_pair_insert(nr_ice_cand_pair_head *head,nr_ice_cand_pair *pair);
 -void nr_ice_candidate_pair_restart_stun_nominated_cb(int s, int how, void *cb_arg);
 +void nr_ice_candidate_pair_restart_stun_nominated_cb(NR_SOCKET s, int how, void *cb_arg);
  int nr_ice_candidate_pair_destroy(nr_ice_cand_pair **pairp);
  #ifdef __cplusplus
  }
  #endif /* __cplusplus */
  #endif
 diff -U10 -r /Users/ekr/dev/mtransport-import-references/nICEr/src/ice/ice_component.c src/ice/ice_component.c
 --- /Users/ekr/dev/mtransport-import-references/nICEr/src/ice/ice_component.c	2012-09-16 16:26:08.000000000 -0700
 +++ src/ice/ice_component.c	2012-10-06 08:30:22.000000000 -0700
@@ -451,21 +451,21 @@
          if(r=nr_ice_peer_peer_rflx_candidate_create(comp->stream->pctx->ctx,"prflx",comp,&req->src_addr,&pcand)) {
            *error=(r==R_NO_MEMORY)?500:400;
            ABORT(r);
          }
          if(!nr_stun_message_has_attribute(sreq,NR_STUN_ATTR_PRIORITY,&attr)){
            r_log(LOG_ICE,LOG_ERR,"ICE-PEER(%s): Rejecting stun request without priority",comp->stream->pctx->label);
            *error=487;
            ABORT(R_BAD_DATA);
          }
          pcand->priority=attr->u.priority;
 -        pcand->state=NR_ICE_CAND_PEER_CANDIDATE;
 +        pcand->state=NR_ICE_CAND_PEER_CANDIDATE_PAIRED;;
          TAILQ_INSERT_TAIL(&comp->candidates,pcand,entry_comp);
          if(r=nr_ice_candidate_pair_create(comp->stream->pctx,cand,pcand,
               &pair)) {
            *error=(r==R_NO_MEMORY)?500:400;
            ABORT(r);
          }
          nr_ice_candidate_pair_set_state(pair->pctx,pair,NR_ICE_PAIR_STATE_FROZEN);
          if(r=nr_ice_candidate_pair_insert(&comp->stream->check_list,pair)) {
@@ -563,30 +563,38 @@
            break;
        }
        /* PAIR with each peer*/
        if(TAILQ_EMPTY(&pcomp->candidates)) {
            /* can happen if our peer proposes no (or all bogus) candidates */
            goto next_cand;
        }
        pcand=TAILQ_FIRST(&pcomp->candidates);
        while(pcand){
 -        nr_ice_compute_codeword(pcand->label,strlen(pcand->label),codeword);
 -        r_log(LOG_ICE,LOG_DEBUG,"Examining peer candidate %s:%s",codeword,pcand->label);
 -
 -        if(r=nr_ice_candidate_pair_create(pctx,lcand,pcand,&pair))
 -          ABORT(r);
 -
 -        if(r=nr_ice_candidate_pair_insert(&pcomp->stream->check_list,
 -          pair))
 -          ABORT(r);
 +        /* Only pair peer candidates which have not yet been paired.
 +           This allows "trickle ICE". (Not yet standardized, but
 +           part of WebRTC).
 +
 +           TODO(ekr@rtfm.com): Add refernece to the spec when there
 +           is one.
 +         */
 +        if (pcand->state = NR_ICE_CAND_PEER_CANDIDATE_UNPAIRED) {
 +          nr_ice_compute_codeword(pcand->label,strlen(pcand->label),codeword);
 +          r_log(LOG_ICE,LOG_DEBUG,"Examining peer candidate %s:%s",codeword,pcand->label);
 +
 +          if(r=nr_ice_candidate_pair_create(pctx,lcand,pcand,&pair))
 +            ABORT(r);
 +          if(r=nr_ice_candidate_pair_insert(&pcomp->stream->check_list,
 +              pair))
 +            ABORT(r);
 +        }
          pcand=TAILQ_NEXT(pcand,entry_comp);
        }
        if(!pair)
          ABORT(R_INTERNAL);
        /* Add the stun username/password pair from the last pair (any
           would do) to the stun contexts */
        isock=STAILQ_FIRST(&lcomp->sockets);
        while(isock){
@@ -594,20 +602,28 @@
             pair->r2l_user,&pair->r2l_pwd,nr_ice_component_stun_server_cb,pcomp))
            ABORT(r);
          isock=STAILQ_NEXT(isock,entry);
        }
      next_cand:
        lcand=TAILQ_NEXT(lcand,entry_comp);
      }
 +    /* Mark all peer candidates as paired */
 +    pcand=TAILQ_FIRST(&pcomp->candidates);
 +    while(pcand){
 +      pcand->state = NR_ICE_CAND_PEER_CANDIDATE_PAIRED;
 +
 +      pcand=TAILQ_NEXT(pcand,entry_comp);
 +    }
 +
      _status=0;
    abort:
      return(_status);
    }
  int nr_ice_component_nominated_pair(nr_ice_component *comp, nr_ice_cand_pair *pair)
    {
      int r,_status;
      int fire_cb=0;
      nr_ice_cand_pair *p2;
@@ -616,32 +632,32 @@
        fire_cb=1;
      /* Are we changing what the nominated pair is? */
      if(comp->nominated){
        if(comp->nominated->priority > pair->priority)
          return(0);
        r_log(LOG_ICE,LOG_DEBUG,"ICE-PEER(%s)/STREAM(%s)/comp(%d): replacing pair %s with pair %s",comp->stream->pctx->label,comp->stream->label,comp->component_id,comp->nominated->as_string,pair->as_string);
      }
      /* Set the new nominated pair */
 -    r_log(LOG_ICE,LOG_DEBUG,"ICE-PEER(%s)/STREAM(%s)/comp(%d): nominated pair is %s (0x%x)",comp->stream->pctx->label,comp->stream->label,comp->component_id,pair->as_string,(int)pair);
 +    r_log(LOG_ICE,LOG_DEBUG,"ICE-PEER(%s)/STREAM(%s)/comp(%d): nominated pair is %s (0x%p)",comp->stream->pctx->label,comp->stream->label,comp->component_id,pair->as_string,pair);
      comp->state=NR_ICE_COMPONENT_NOMINATED;
      comp->nominated=pair;
      comp->active=pair;
 -    r_log(LOG_ICE,LOG_DEBUG,"ICE-PEER(%s)/STREAM(%s)/comp(%d): cancelling all pairs but %s (0x%x)",comp->stream->pctx->label,comp->stream->label,comp->component_id,pair->as_string,(int)pair);
 +    r_log(LOG_ICE,LOG_DEBUG,"ICE-PEER(%s)/STREAM(%s)/comp(%d): cancelling all pairs but %s (0x%p)",comp->stream->pctx->label,comp->stream->label,comp->component_id,pair->as_string,pair);
      /* OK, we need to cancel off everything on this component */
      p2=TAILQ_FIRST(&comp->stream->check_list);
      while(p2){
        if((p2 != pair) && (p2->remote->component->component_id == comp->component_id)){
 -        r_log(LOG_ICE,LOG_DEBUG,"ICE-PEER(%s)/STREAM(%s)/comp(%d): cancelling pair %s (0x%x)",comp->stream->pctx->label,comp->stream->label,comp->component_id,p2->as_string,(int)p2);
 +        r_log(LOG_ICE,LOG_DEBUG,"ICE-PEER(%s)/STREAM(%s)/comp(%d): cancelling pair %s (0x%p)",comp->stream->pctx->label,comp->stream->label,comp->component_id,p2->as_string,p2);
          if(r=nr_ice_candidate_pair_cancel(pair->pctx,p2))
            ABORT(r);
        }
        p2=TAILQ_NEXT(p2,entry);
      }
      r_log(LOG_ICE,LOG_DEBUG,"ICE-PEER(%s)/STREAM(%s)/comp(%d): cancelling done",comp->stream->pctx->label,comp->stream->label,comp->component_id);
      if(r=nr_ice_media_stream_component_nominated(comp->stream,comp))
@@ -734,21 +750,21 @@
          ABORT(r);
      }
      _status=0;
    abort:
      RFREE(pairs);
      return(_status);
    }
 -static void nr_ice_component_keepalive_cb(int s, int how, void *cb_arg)
 +static void nr_ice_component_keepalive_cb(NR_SOCKET s, int how, void *cb_arg)
    {
      nr_ice_component *comp=cb_arg;
      UINT4 keepalive_timeout;
      assert(comp->keepalive_ctx);
      if(NR_reg_get_uint4(NR_ICE_REG_KEEPALIVE_TIMER,&keepalive_timeout)){
        keepalive_timeout=15000; /* Default */
      }
 diff -U10 -r /Users/ekr/dev/mtransport-import-references/nICEr/src/ice/ice_ctx.c src/ice/ice_ctx.c
 --- /Users/ekr/dev/mtransport-import-references/nICEr/src/ice/ice_ctx.c	2012-09-16 16:26:08.000000000 -0700
 +++ src/ice/ice_ctx.c	2012-10-06 08:30:22.000000000 -0700
@@ -56,21 +56,21 @@
  #include "util.h"
  int LOG_ICE = 0;
  static int nr_ice_random_string(char *str, int len);
  static int nr_ice_fetch_stun_servers(int ct, nr_ice_stun_server **out);
  #ifdef USE_TURN
  static int nr_ice_fetch_turn_servers(int ct, nr_ice_turn_server **out);
  #endif /* USE_TURN */
 -static void nr_ice_ctx_destroy_cb(int s, int how, void *cb_arg);
 +static void nr_ice_ctx_destroy_cb(NR_SOCKET s, int how, void *cb_arg);
  int nr_ice_fetch_stun_servers(int ct, nr_ice_stun_server **out)
    {
      int r,_status;
      nr_ice_stun_server *servers = 0;
      int i;
      NR_registry child;
      char *addr=0;
      UINT2 port;
      in_addr_t addr_int;
@@ -271,21 +271,21 @@
      *ctxp=ctx;
      _status=0;
    abort:
      if(_status)
        nr_ice_ctx_destroy_cb(0,0,ctx);
      return(_status);
    }
 -static void nr_ice_ctx_destroy_cb(int s, int how, void *cb_arg)
 +static void nr_ice_ctx_destroy_cb(NR_SOCKET s, int how, void *cb_arg)
    {
      nr_ice_ctx *ctx=cb_arg;
      nr_ice_foundation *f1,*f2;
      nr_ice_media_stream *s1,*s2;
      int i;
      nr_ice_stun_id *id1,*id2;
      RFREE(ctx->label);
      RFREE(ctx->stun_servers);
@@ -323,21 +323,21 @@
      if(!ctxp || !*ctxp)
        return(0);
      NR_ASYNC_SCHEDULE(nr_ice_ctx_destroy_cb,*ctxp);
      *ctxp=0;
      return(0);
    }
 -void nr_ice_initialize_finished_cb(int s, int h, void *cb_arg)
 +void nr_ice_initialize_finished_cb(NR_SOCKET s, int h, void *cb_arg)
    {
      nr_ice_ctx *ctx=cb_arg;
  /*    r_log(LOG_ICE,LOG_DEBUG,"ICE(%s): Candidate %s %s",ctx->label,
        cand->label, cand->state==NR_ICE_CAND_STATE_INITIALIZED?"INITIALIZED":"FAILED");
  */
      ctx->uninitialized_candidates--;
      if(ctx->uninitialized_candidates==0){
        r_log(LOG_ICE,LOG_DEBUG,"ICE(%s): All candidates initialized",ctx->label);
@@ -368,21 +368,22 @@
      stream=STAILQ_FIRST(&ctx->streams);
      while(stream){
        if(r=nr_ice_media_stream_initialize(ctx,stream))
          ABORT(r);
        stream=STAILQ_NEXT(stream,entry);
      }
      if(ctx->uninitialized_candidates)
        ABORT(R_WOULDBLOCK);
 -
 +
 +
      _status=0;
    abort:
      return(_status);
    }
  int nr_ice_add_media_stream(nr_ice_ctx *ctx,char *label,int components, nr_ice_media_stream **streamp)
    {
      int r,_status;
      if(r=nr_ice_media_stream_create(ctx,label,components,streamp))
 diff -U10 -r /Users/ekr/dev/mtransport-import-references/nICEr/src/ice/ice_ctx.h src/ice/ice_ctx.h
 --- /Users/ekr/dev/mtransport-import-references/nICEr/src/ice/ice_ctx.h	2012-09-16 16:26:08.000000000 -0700
 +++ src/ice/ice_ctx.h	2012-10-06 08:30:22.000000000 -0700
@@ -92,23 +92,23 @@
    UCHAR id[12];
    STAILQ_ENTRY(nr_ice_stun_id_) entry;
  } nr_ice_stun_id;
  typedef STAILQ_HEAD(nr_ice_stun_id_head_,nr_ice_stun_id_) nr_ice_stun_id_head;
  struct nr_ice_ctx_ {
    UINT4 flags;
    int state;
 -#define NR_ICE_STATE_CREATED      1
 -#define NR_ICE_STATE_INITIALIZING 2
 -#define NR_ICE_STATE_INITIALIZED  3
 +#define NR_ICE_STATE_CREATED          1
 +#define NR_ICE_STATE_INITIALIZING     2
 +#define NR_ICE_STATE_INITIALIZED      3
    char *label;
    char *ufrag;
    char *pwd;
    UINT4 Ta;
    nr_ice_stun_server *stun_servers;           /* The list of stun servers */
    int stun_server_ct;
    nr_ice_turn_server *turn_servers;           /* The list of turn servers */
@@ -133,21 +133,21 @@
  int nr_ice_ctx_create(char *label, UINT4 flags, nr_ice_ctx **ctxp);
  #define NR_ICE_CTX_FLAGS_OFFERER                           1
  #define NR_ICE_CTX_FLAGS_ANSWERER                          (1<<1)
  #define NR_ICE_CTX_FLAGS_AGGRESSIVE_NOMINATION             (1<<2)
  #define NR_ICE_CTX_FLAGS_LITE                              (1<<3)
  int nr_ice_ctx_destroy(nr_ice_ctx **ctxp);
  int nr_ice_initialize(nr_ice_ctx *ctx, NR_async_cb done_cb, void *cb_arg);
  int nr_ice_add_candidate(nr_ice_ctx *ctx, nr_ice_candidate *cand);
 -void nr_ice_initialize_finished_cb(int s, int h, void *cb_arg);
 +void nr_ice_initialize_finished_cb(NR_SOCKET s, int h, void *cb_arg);
  int nr_ice_add_media_stream(nr_ice_ctx *ctx,char *label,int components, nr_ice_media_stream **streamp);
  int nr_ice_get_global_attributes(nr_ice_ctx *ctx,char ***attrsp, int *attrctp);
  int nr_ice_ctx_deliver_packet(nr_ice_ctx *ctx, nr_ice_component *comp, nr_transport_addr *source_addr, UCHAR *data, int len);
  int nr_ice_ctx_is_known_id(nr_ice_ctx *ctx, UCHAR id[12]);
  int nr_ice_ctx_remember_id(nr_ice_ctx *ctx, nr_stun_message *msg);
  int nr_ice_ctx_finalize(nr_ice_ctx *ctx, nr_ice_peer_ctx *pctx);
  extern int LOG_ICE;
  #ifdef __cplusplus
 diff -U10 -r /Users/ekr/dev/mtransport-import-references/nICEr/src/ice/ice_media_stream.c src/ice/ice_media_stream.c
 --- /Users/ekr/dev/mtransport-import-references/nICEr/src/ice/ice_media_stream.c	2012-09-16 16:26:08.000000000 -0700
 +++ src/ice/ice_media_stream.c	2012-10-06 08:30:22.000000000 -0700
@@ -35,21 +35,21 @@
  static char *RCSSTRING __UNUSED__="$Id: ice_media_stream.c,v 1.2 2008/04/28 17:59:01 ekr Exp $";
  #include <string.h>
  #include <assert.h>
  #include <nr_api.h>
  #include <r_assoc.h>
  #include <async_timer.h>
  #include "ice_ctx.h"
  static char *nr_ice_media_stream_states[]={"INVALID",
 -  "FROZEN","ACTIVE","COMPLETED","FAILED"
 +  "UNPAIRED","FROZEN","ACTIVE","COMPLETED","FAILED"
  };
  int nr_ice_media_stream_set_state(nr_ice_media_stream *str, int state);
  int nr_ice_media_stream_create(nr_ice_ctx *ctx,char *label,int components, nr_ice_media_stream **streamp)
    {
      int r,_status;
      nr_ice_media_stream *stream=0;
      nr_ice_component *comp=0;
      int i;
@@ -66,29 +66,29 @@
      for(i=0;i<components;i++){
        /* component-id must be > 0, so increment by 1 */
        if(r=nr_ice_component_create(stream, i+1, &comp))
          ABORT(r);
      }
      TAILQ_INIT(&stream->check_list);
      stream->component_ct=components;
 -
 +    stream->ice_state = NR_ICE_MEDIA_STREAM_UNPAIRED;
      *streamp=stream;
      _status=0;
    abort:
      if(_status){
        nr_ice_media_stream_destroy(&stream);
      }
 -    return(_status);
 +    return(_status);
    }
  int nr_ice_media_stream_destroy(nr_ice_media_stream **streamp)
    {
      nr_ice_media_stream *stream;
      nr_ice_component *c1,*c2;
      nr_ice_cand_pair *p1,*p2;
      if(!streamp || !*streamp)
        return(0);
@@ -200,85 +200,148 @@
        if(attrs){
          for(index=0;index<attrct;index++){
            RFREE(attrs[index]);
          }
          RFREE(attrs);
        }
      }
      return(_status);
    }
 +
 +/* Get a default candidate per 4.1.4 */
 +int nr_ice_media_stream_get_default_candidate(nr_ice_media_stream *stream, int component, nr_ice_candidate **candp)
 +  {
 +    int _status;
 +    nr_ice_component *comp;
 +    nr_ice_candidate *cand;
 +    nr_ice_candidate *best_cand = NULL;
 +
 +    comp=STAILQ_FIRST(&stream->components);
 +    while(comp){
 +      if (comp->component_id == component)
 +        break;
 +
 +      comp=STAILQ_NEXT(comp,entry);
 +    }
 +
 +    if (!comp)
 +      ABORT(R_NOT_FOUND);
 +
 +    /* We have the component. Now find the "best" candidate, making
 +       use of the fact that more "reliable" candidate types have
 +       higher numbers. So, we sort by type and then priority within
 +       type
 +    */
 +    cand=TAILQ_FIRST(&comp->candidates);
 +    while(cand){
 +      if (!best_cand) {
 +        best_cand = cand;
 +      }
 +      else {
 +        if (best_cand->type < cand->type) {
 +          best_cand = cand;
 +        } else if (best_cand->type == cand->type) {
 +          if (best_cand->priority < cand->priority)
 +            best_cand = cand;
 +        }
 +      }
 +
 +      cand=TAILQ_NEXT(cand,entry_comp);
 +    }
 +
 +    /* No candidates */
 +    if (!best_cand)
 +      ABORT(R_NOT_FOUND);
 +
 +    *candp = best_cand;
 +
 +    _status=0;
 +  abort:
 +    return(_status);
 +  }
 +
 +
  int nr_ice_media_stream_pair_candidates(nr_ice_peer_ctx *pctx,nr_ice_media_stream *lstream,nr_ice_media_stream *pstream)
    {
      int r,_status;
      nr_ice_component *pcomp,*lcomp;
      pcomp=STAILQ_FIRST(&pstream->components);
      lcomp=STAILQ_FIRST(&lstream->components);
      while(pcomp){
        if(r=nr_ice_component_pair_candidates(pctx,lcomp,pcomp))
          ABORT(r);
 -
 +
        lcomp=STAILQ_NEXT(lcomp,entry);
        pcomp=STAILQ_NEXT(pcomp,entry);
      };
 +    if (pstream->ice_state == NR_ICE_MEDIA_STREAM_UNPAIRED) {
 +      r_log(LOG_ICE,LOG_DEBUG,"ICE-PEER(%s): unfreezing stream %s",pstream->pctx->label,pstream->label);
 +      pstream->ice_state = NR_ICE_MEDIA_STREAM_CHECKS_FROZEN;
 +    }
 +
      _status=0;
    abort:
      return(_status);
    }
  /* S 5.8 -- run the highest priority WAITING pair or if not available
     FROZEN pair */
 -static void nr_ice_media_stream_check_timer_cb(int s, int h, void *cb_arg)
 +static void nr_ice_media_stream_check_timer_cb(NR_SOCKET s, int h, void *cb_arg)
    {
      int r,_status;
      nr_ice_media_stream *stream=cb_arg;
      nr_ice_cand_pair *pair;
      int timer_val;
      assert(stream->pctx->active_streams!=0);
      timer_val=stream->pctx->ctx->Ta*stream->pctx->active_streams;
 +    if (stream->ice_state == NR_ICE_MEDIA_STREAM_CHECKS_COMPLETED) {
 +      r_log(LOG_ICE,LOG_DEBUG,"ICE-PEER(%s): bogus state for stream %s",stream->pctx->label,stream->label);
 +    }
      assert(stream->ice_state != NR_ICE_MEDIA_STREAM_CHECKS_COMPLETED);
      r_log(LOG_ICE,LOG_DEBUG,"ICE-PEER(%s): check timer expired for media stream %s",stream->pctx->label,stream->label);
      stream->timer=0;
 -
      /* Find the highest priority WAITING check and move it to RUNNING */
      pair=TAILQ_FIRST(&stream->check_list);
      while(pair){
        if(pair->state==NR_ICE_PAIR_STATE_WAITING)
          break;
        pair=TAILQ_NEXT(pair,entry);
      }
      /* Hmmm... No WAITING. Let's look for FROZEN */
      if(!pair){
        pair=TAILQ_FIRST(&stream->check_list);
 -
 +
        while(pair){
          if(pair->state==NR_ICE_PAIR_STATE_FROZEN){
            if(r=nr_ice_candidate_pair_unfreeze(stream->pctx,pair))
              ABORT(r);
            break;
          }
          pair=TAILQ_NEXT(pair,entry);
        }
      }
      if(pair){
        nr_ice_candidate_pair_start(pair->pctx,pair); /* Ignore failures */
        NR_ASYNC_TIMER_SET(timer_val,nr_ice_media_stream_check_timer_cb,cb_arg,&stream->timer);
      }
 +    /* TODO(ekr@rtfm.com): Report on the special case where there are no checks to
 +       run at all */
      _status=0;
    abort:
      return;
    }
  /* Start checks for this media stream (aka check list) */
  int nr_ice_media_stream_start_checks(nr_ice_peer_ctx *pctx, nr_ice_media_stream *stream)
    {
      assert(stream->ice_state==NR_ICE_MEDIA_STREAM_CHECKS_FROZEN);
@@ -476,21 +539,23 @@
      /* All done... */
      r_log(LOG_ICE,LOG_INFO,"ICE-PEER(%s)/ICE-STREAM(%s): all components have nominated candidate pairs",stream->pctx->label,stream->label);
      nr_ice_media_stream_set_state(stream,NR_ICE_MEDIA_STREAM_CHECKS_COMPLETED);
      /* Cancel our timer */
      if(stream->timer){
        NR_async_timer_cancel(stream->timer);
        stream->timer=0;
      }
 -    stream->pctx->handler->vtbl->stream_ready(stream->pctx->handler->obj,stream->local_stream);
 +    if (stream->pctx->handler) {
 +      stream->pctx->handler->vtbl->stream_ready(stream->pctx->handler->obj,stream->local_stream);
 +    }
      /* Now tell the peer_ctx that we're done */
      if(r=nr_ice_peer_ctx_stream_done(stream->pctx,stream))
        ABORT(r);
    done:
      _status=0;
    abort:
      return(_status);
    }
@@ -515,21 +580,23 @@
        p2=TAILQ_NEXT(p2,entry);
      }
      /* Cancel our timer */
      if(stream->timer){
        NR_async_timer_cancel(stream->timer);
        stream->timer=0;
      }
 -    stream->pctx->handler->vtbl->stream_failed(stream->pctx->handler->obj,stream->local_stream);
 +    if (stream->pctx->handler) {
 +      stream->pctx->handler->vtbl->stream_failed(stream->pctx->handler->obj,stream->local_stream);
 +    }
      /* Now tell the peer_ctx that we're done */
      if(r=nr_ice_peer_ctx_stream_done(stream->pctx,stream))
        ABORT(r);
      _status=0;
    abort:
      return(_status);
    }
 diff -U10 -r /Users/ekr/dev/mtransport-import-references/nICEr/src/ice/ice_media_stream.h src/ice/ice_media_stream.h
 --- /Users/ekr/dev/mtransport-import-references/nICEr/src/ice/ice_media_stream.h	2012-09-16 16:26:08.000000000 -0700
 +++ src/ice/ice_media_stream.h	2012-10-06 08:30:22.000000000 -0700
@@ -45,40 +45,43 @@
    struct nr_ice_peer_ctx_ *pctx;
    struct nr_ice_media_stream_ *local_stream; /* used when this is a peer */
    int component_ct;
    nr_ice_component_head components;
    char *ufrag;    /* ICE username */
    char *pwd;    /* ICE password */
    int ice_state;
 -#define NR_ICE_MEDIA_STREAM_CHECKS_FROZEN      1
 -#define NR_ICE_MEDIA_STREAM_CHECKS_ACTIVE      2
 -#define NR_ICE_MEDIA_STREAM_CHECKS_COMPLETED   3
 -#define NR_ICE_MEDIA_STREAM_CHECKS_FAILED      4
 +
 +#define NR_ICE_MEDIA_STREAM_UNPAIRED           1
 +#define NR_ICE_MEDIA_STREAM_CHECKS_FROZEN      2
 +#define NR_ICE_MEDIA_STREAM_CHECKS_ACTIVE      3
 +#define NR_ICE_MEDIA_STREAM_CHECKS_COMPLETED   4
 +#define NR_ICE_MEDIA_STREAM_CHECKS_FAILED      5
    nr_ice_cand_pair_head check_list;
    void *timer;  /* Check list periodic timer */
  //  nr_ice_cand_pair_head valid_list;
 -
 +
    STAILQ_ENTRY(nr_ice_media_stream_) entry;
  };
  typedef STAILQ_HEAD(nr_ice_media_stream_head_,nr_ice_media_stream_) nr_ice_media_stream_head;
  int nr_ice_media_stream_create(struct nr_ice_ctx_ *ctx,char *label, int components, nr_ice_media_stream **streamp);
  int nr_ice_media_stream_destroy(nr_ice_media_stream **streamp);
  int nr_ice_media_stream_finalize(nr_ice_media_stream *lstr,nr_ice_media_stream *rstr);
  int nr_ice_media_stream_initialize(struct nr_ice_ctx_ *ctx, nr_ice_media_stream *stream);
  int nr_ice_media_stream_get_attributes(nr_ice_media_stream *stream, char ***attrsp,int *attrctp);
 +int nr_ice_media_stream_get_default_candidate(nr_ice_media_stream *stream, int component, nr_ice_candidate **candp);
  int nr_ice_media_stream_pair_candidates(nr_ice_peer_ctx *pctx,nr_ice_media_stream *lstream,nr_ice_media_stream *pstream);
  int nr_ice_media_stream_start_checks(nr_ice_peer_ctx *pctx, nr_ice_media_stream *stream);
  int nr_ice_media_stream_unfreeze_pairs(nr_ice_peer_ctx *pctx, nr_ice_media_stream *stream);
  int nr_ice_media_stream_unfreeze_pairs_foundation(nr_ice_media_stream *stream, char *foundation);
  int nr_ice_media_stream_dump_state(nr_ice_peer_ctx *pctx, nr_ice_media_stream *stream,FILE *out);
  int nr_ice_media_stream_component_nominated(nr_ice_media_stream *stream,nr_ice_component *component);
  int nr_ice_media_stream_component_failed(nr_ice_media_stream *stream,nr_ice_component *component);
  int nr_ice_media_stream_set_state(nr_ice_media_stream *str, int state);
  int nr_ice_media_stream_get_best_candidate(nr_ice_media_stream *str, int component, nr_ice_candidate **candp);
  int nr_ice_media_stream_send(nr_ice_peer_ctx *pctx,nr_ice_media_stream *str, int component, UCHAR *data, int len);
 diff -U10 -r /Users/ekr/dev/mtransport-import-references/nICEr/src/ice/ice_parser.c src/ice/ice_parser.c
 --- /Users/ekr/dev/mtransport-import-references/nICEr/src/ice/ice_parser.c	2012-09-16 16:26:08.000000000 -0700
 +++ src/ice/ice_parser.c	2012-10-06 08:30:22.000000000 -0700
@@ -35,20 +35,21 @@
  static char *RCSSTRING __UNUSED__="$Id: ice_parser.c,v 1.2 2008/04/28 17:59:01 ekr Exp $";
  #include <csi_platform.h>
  #include <sys/types.h>
  #ifdef WIN32
  #include <winsock2.h>
  #else
  #include <sys/socket.h>
  #include <netinet/in.h>
  #include <arpa/inet.h>
 +#include <strings.h>
  #endif
  #include <string.h>
  #include <assert.h>
  #include <ctype.h>
  #include "nr_api.h"
  #include "ice_ctx.h"
  #include "ice_candidate.h"
  #include "ice_reg.h"
  static void
@@ -125,21 +126,21 @@
      char *rel_addr=0;
      if(!(cand=RCALLOC(sizeof(nr_ice_candidate))))
          ABORT(R_NO_MEMORY);
      if(!(cand->label=r_strdup(orig)))
          ABORT(R_NO_MEMORY);
      cand->ctx=ctx;
      cand->isock=0;
 -    cand->state=NR_ICE_CAND_PEER_CANDIDATE;
 +    cand->state=NR_ICE_CAND_PEER_CANDIDATE_UNPAIRED;
      cand->stream=stream;
      skip_whitespace(&str);
      /* Candidate attr */
      if (strncasecmp(str, "candidate:", 10))
          ABORT(R_BAD_DATA);
      fast_forward(&str, 10);
      if (*str == '\0')
          ABORT(R_BAD_DATA);
@@ -311,26 +312,31 @@
          /* it's expected to be at EOD at this point */
          break;
      default:
          ABORT(R_INTERNAL);
          break;
      }
      skip_whitespace(&str);
 -    assert(strlen(str) == 0);
 -
 +    /* This used to be an assert, but we don't want to exit on invalid
 +       remote data */
 +    if (strlen(str) != 0) {
 +      ABORT(R_BAD_DATA);
 +    }
 +
      *candp=cand;
      _status=0;
    abort:
 +    /* TODO(ekr@rtfm.com): Fix memory leak if we have a parse error */
      if (_status)
          r_log(LOG_ICE,LOG_WARNING,"ICE(%s): Error parsing attribute: %s",ctx->label,orig);
      RFREE(connection_address);
      RFREE(rel_addr);
      return(_status);
  }
  int
 diff -U10 -r /Users/ekr/dev/mtransport-import-references/nICEr/src/ice/ice_peer_ctx.c src/ice/ice_peer_ctx.c
 --- /Users/ekr/dev/mtransport-import-references/nICEr/src/ice/ice_peer_ctx.c	2012-09-16 16:26:08.000000000 -0700
 +++ src/ice/ice_peer_ctx.c	2012-10-06 08:30:22.000000000 -0700
@@ -35,33 +35,35 @@
  static char *RCSSTRING __UNUSED__="$Id: ice_peer_ctx.c,v 1.2 2008/04/28 17:59:01 ekr Exp $";
  #include <string.h>
  #include <assert.h>
  #include <nr_api.h>
  #include "ice_ctx.h"
  #include "ice_peer_ctx.h"
  #include "nr_crypto.h"
  #include "async_timer.h"
 -static void nr_ice_peer_ctx_destroy_cb(int s, int how, void *cb_arg);
 +static void nr_ice_peer_ctx_destroy_cb(NR_SOCKET s, int how, void *cb_arg);
 +static int nr_ice_peer_ctx_parse_stream_attributes_int(nr_ice_peer_ctx *pctx, nr_ice_media_stream *stream, nr_ice_media_stream *pstream, char **attrs, int attr_ct);
 +static int nr_ice_ctx_parse_candidate(nr_ice_peer_ctx *pctx, nr_ice_media_stream *pstream, char *candidate);
  int nr_ice_peer_ctx_create(nr_ice_ctx *ctx, nr_ice_handler *handler,char *label, nr_ice_peer_ctx **pctxp)
    {
      int r,_status;
      nr_ice_peer_ctx *pctx=0;
      if(!(pctx=RCALLOC(sizeof(nr_ice_peer_ctx))))
        ABORT(R_NO_MEMORY);
      if(!(pctx->label=r_strdup(label)))
        ABORT(R_NO_MEMORY);
 -
 +
      pctx->ctx=ctx;
      pctx->handler=handler;
      /* Decide controlling vs. controlled */
      if(ctx->flags & NR_ICE_CTX_FLAGS_LITE){
        if(pctx->peer_lite){
          r_log(LOG_ICE,LOG_ERR,"Both sides are ICE-Lite");
          ABORT(R_BAD_DATA);
        }
@@ -88,85 +90,177 @@
        nr_ice_peer_ctx_destroy_cb(0,0,pctx);
      }
      return(_status);
    }
  int nr_ice_peer_ctx_parse_stream_attributes(nr_ice_peer_ctx *pctx, nr_ice_media_stream *stream, char **attrs, int attr_ct)
    {
      nr_ice_media_stream *pstream=0;
 -    nr_ice_candidate *cand=0;
      nr_ice_component *comp,*comp2;
      int r,_status;
 -    int i,j;
 -    /* Note: use component_ct from our own stream since components other
 -       than this offered by the other side are unusable */
 +    /*
 +      Note: use component_ct from our own stream since components other
 +      than this offered by the other side are unusable */
      if(r=nr_ice_media_stream_create(pctx->ctx,stream->label,stream->component_ct,&pstream))
        ABORT(r);
 -
 -    /* Match up the local and remote components */
 +
 +    /* Match up the local and remote components */
      comp=STAILQ_FIRST(&stream->components);
      comp2=STAILQ_FIRST(&pstream->components);
      while(comp){
        comp2->local_component=comp;
        comp=STAILQ_NEXT(comp,entry);
        comp2=STAILQ_NEXT(comp2,entry);
      }
 -
 -    pstream->ice_state=NR_ICE_MEDIA_STREAM_CHECKS_FROZEN;
      pstream->local_stream=stream;
      pstream->pctx=pctx;
 +    if (r=nr_ice_peer_ctx_parse_stream_attributes_int(pctx,stream,pstream,attrs,attr_ct))
 +      ABORT(r);
 +
 +
 +    STAILQ_INSERT_TAIL(&pctx->peer_streams,pstream,entry);
 +
 +    _status=0;
 +  abort:
 +    return(_status);
 +  }
 +
 +static int nr_ice_peer_ctx_parse_stream_attributes_int(nr_ice_peer_ctx *pctx, nr_ice_media_stream *stream, nr_ice_media_stream *pstream, char **attrs, int attr_ct)
 +  {
 +    int r;
 +    int i;
 +
      for(i=0;i<attr_ct;i++){
        if(!strncmp(attrs[i],"ice-",4)){
 -        if(r=nr_ice_peer_ctx_parse_media_stream_attribute(pctx,pstream,attrs[i]))
 +        if(r=nr_ice_peer_ctx_parse_media_stream_attribute(pctx,pstream,attrs[i])) {
 +          r_log(LOG_ICE,LOG_ERR,"ICE(%s): peer (%s) specified bogus ICE attribute",pctx->ctx->label,pctx->label);
            continue;
 -        continue;
 +        }
        }
 -
 -      if(r=nr_ice_peer_candidate_from_attribute(pctx->ctx,attrs[i],pstream,&cand))
 -        continue;
 -      if(cand->component_id-1>=pstream->component_ct){
 -        r_log(LOG_ICE,LOG_ERR,"ICE(%s): peer (%s) specified too many components",pctx->ctx->label,pctx->label);
 -        continue;
 +      else if (!strncmp(attrs[i],"candidate",9)){
 +        if(r=nr_ice_ctx_parse_candidate(pctx,pstream,attrs[i])) {
 +          r_log(LOG_ICE,LOG_ERR,"ICE(%s): peer (%s) specified bogus candidate",pctx->ctx->label,pctx->label);
 +          continue;
 +        }
 +      }
 +      else {
 +        r_log(LOG_ICE,LOG_ERR,"ICE(%s): peer (%s) specified bogus attribute",pctx->ctx->label,pctx->label);
        }
 +    }
 -      /* Not the fastest way to find a component, but it's what we got */
 -      j=1;
 -      for(comp=STAILQ_FIRST(&pstream->components);comp;comp=STAILQ_NEXT(comp,entry)){
 -        if(j==cand->component_id)
 -          break;
 +    /* Doesn't fail because we just skip errors */
 +    return(0);
 +  }
 -        j++;
 -      }
 -
 -      if(!comp){
 -        r_log(LOG_ICE,LOG_ERR,"Peer answered with more components than we offered");
 -        ABORT(R_BAD_DATA);
 -      }
 -
 -      cand->component=comp;
 +static int nr_ice_ctx_parse_candidate(nr_ice_peer_ctx *pctx, nr_ice_media_stream *pstream, char *candidate)
 +  {
 +    nr_ice_candidate *cand=0;
 +    nr_ice_component *comp;
 +    int j;
 +    int r, _status;
 -      TAILQ_INSERT_TAIL(&comp->candidates,cand,entry_comp);
 +    if(r=nr_ice_peer_candidate_from_attribute(pctx->ctx,candidate,pstream,&cand))
 +      ABORT(r);
 +    if(cand->component_id-1>=pstream->component_ct){
 +      r_log(LOG_ICE,LOG_ERR,"ICE(%s): peer (%s) specified too many components",pctx->ctx->label,pctx->label);
 +      ABORT(R_BAD_DATA);
      }
 -    STAILQ_INSERT_TAIL(&pctx->peer_streams,pstream,entry);
 +    /* Not the fastest way to find a component, but it's what we got */
 +    j=1;
 +    for(comp=STAILQ_FIRST(&pstream->components);comp;comp=STAILQ_NEXT(comp,entry)){
 +      if(j==cand->component_id)
 +        break;
 +
 +      j++;
 +    }
 +
 +    if(!comp){
 +      r_log(LOG_ICE,LOG_ERR,"Peer answered with more components than we offered");
 +      ABORT(R_BAD_DATA);
 +    }
 +
 +    cand->component=comp;
 +
 +    TAILQ_INSERT_TAIL(&comp->candidates,cand,entry_comp);
      _status=0;
 -  abort:
 + abort:
 +    if (_status) {
 +      nr_ice_candidate_destroy(&cand);
 +    }
      return(_status);
    }
 +
 +
 +int nr_ice_peer_ctx_parse_trickle_candidate(nr_ice_peer_ctx *pctx, nr_ice_media_stream *stream, char *candidate)
 +  {
 +    /* First need to find the stream. Because we don't have forward pointers,
 +       iterate through all the peer streams to find one that matches us */
 +    nr_ice_media_stream *pstream;
 +    int r,_status;
 +    int needs_pairing = 0;
 +
 +    pstream=STAILQ_FIRST(&pctx->peer_streams);
 +    while(pstream) {
 +      if (pstream->local_stream == stream)
 +        break;
 +
 +      pstream = STAILQ_NEXT(pstream, entry);
 +    }
 +    if (!pstream) {
 +      r_log(LOG_ICE,LOG_ERR,"ICE(%s): peer (%s) has no stream matching stream %s",pctx->ctx->label,pctx->label,stream->label);
 +      ABORT(R_NOT_FOUND);
 +    }
 +
 +    switch(pstream->ice_state) {
 +      case NR_ICE_MEDIA_STREAM_UNPAIRED:
 +        break;
 +      case NR_ICE_MEDIA_STREAM_CHECKS_FROZEN:
 +      case NR_ICE_MEDIA_STREAM_CHECKS_ACTIVE:
 +        needs_pairing = 1;
 +        break;
 +      default:
 +        r_log(LOG_ICE,LOG_ERR,"ICE(%s): peer (%s), stream(%s) tried to trickle ICE in inappropriate state %d",pctx->ctx->label,pctx->label,stream->label,pstream->ice_state);
 +        ABORT(R_ALREADY);
 +        break;
 +    }
 +
 +    if(r=nr_ice_ctx_parse_candidate(pctx,pstream,candidate)){
 +      ABORT(r);
 +    }
 +
 +    /* If ICE is running (i.e., we are in FROZEN or ACTIVE states)
 +       then we need to pair this new candidate. For now we
 +       just re-pair the stream which is inefficient but still
 +       fine because we suppress duplicate pairing */
 +    if (needs_pairing) {
 +      if(r=nr_ice_media_stream_pair_candidates(pctx, stream, pstream)) {
 +        r_log(LOG_ICE,LOG_ERR,"ICE(%s): peer (%s), stream(%s) failed to pair trickle ICE candidates",pctx->ctx->label,pctx->label,stream->label);
 +        ABORT(r);
 +      }
 +    }
 +
 +    _status =0;
 + abort:
 +    return(_status);
 +
 +  }
 +
 +
  int nr_ice_peer_ctx_pair_candidates(nr_ice_peer_ctx *pctx)
    {
      nr_ice_media_stream *stream;
      int r,_status;
      if(STAILQ_EMPTY(&pctx->peer_streams)) {
          r_log(LOG_ICE,LOG_ERR,"ICE(%s): peer (%s) received no media stream attribributes",pctx->ctx->label,pctx->label);
          ABORT(R_FAILED);
      }
@@ -177,21 +271,21 @@
          ABORT(r);
        stream=STAILQ_NEXT(stream,entry);
      }
      _status=0;
    abort:
      return(_status);
    }
 -static void nr_ice_peer_ctx_destroy_cb(int s, int how, void *cb_arg)
 +static void nr_ice_peer_ctx_destroy_cb(NR_SOCKET s, int how, void *cb_arg)
    {
      nr_ice_peer_ctx *pctx=cb_arg;
      nr_ice_media_stream *str1,*str2;
      RFREE(pctx->label);
      RFREE(pctx->peer_ufrag);
      RFREE(pctx->peer_pwd);
      STAILQ_FOREACH_SAFE(str1, &pctx->peer_streams, entry, str2){
        STAILQ_REMOVE(&pctx->peer_streams,str1,nr_ice_media_stream_,entry);
@@ -199,44 +293,79 @@
      }
      RFREE(pctx);
    }
  int nr_ice_peer_ctx_destroy(nr_ice_peer_ctx **pctxp)
    {
      if(!pctxp || !*pctxp)
        return(0);
 -
 +
 +    /* Stop calling the handler */
 +    (*pctxp)->handler = 0;
 +
      NR_ASYNC_SCHEDULE(nr_ice_peer_ctx_destroy_cb,*pctxp);
      *pctxp=0;
      return(0);
    }
 +
  /* Start the checks for the first media stream (S 5.7)
     The rest remain FROZEN */
  int nr_ice_peer_ctx_start_checks(nr_ice_peer_ctx *pctx)
    {
 +    return nr_ice_peer_ctx_start_checks2(pctx, 0);
 +  }
 +
 +/* Start checks for some media stream.
 +
 +   If allow_non_first == 0, then we only look at the first stream,
 +   which is 5245-complaint.
 +
 +   If allow_non_first == 1 then we find the first non-empty stream
 +   This is not compliant with RFC 5245 but is necessary to make trickle ICE
 +   work plausibly
 +*/
 +int nr_ice_peer_ctx_start_checks2(nr_ice_peer_ctx *pctx, int allow_non_first)
 +  {
      int r,_status;
      nr_ice_media_stream *stream;
      stream=STAILQ_FIRST(&pctx->peer_streams);
      if(!stream)
        ABORT(R_FAILED);
 +    while (stream) {
 +      if(!TAILQ_EMPTY(&stream->check_list))
 +        break;
 +
 +      if(!allow_non_first){
 +        r_log(LOG_ICE,LOG_ERR,"ICE(%s): peer (%s) first stream has empty check list",pctx->ctx->label,pctx->label);
 +        ABORT(R_FAILED);
 +      }
 +
 +      stream=STAILQ_NEXT(stream, entry);
 +    }
 +
 +    if (!stream) {
 +      r_log(LOG_ICE,LOG_ERR,"ICE(%s): peer (%s) no streams with non-empty check lists",pctx->ctx->label,pctx->label);
 +      ABORT(R_NOT_FOUND);
 +    }
 +
      if (stream->ice_state == NR_ICE_MEDIA_STREAM_CHECKS_FROZEN) {
 -        if(r=nr_ice_media_stream_unfreeze_pairs(pctx,stream))
 -          ABORT(r);
 -        if(r=nr_ice_media_stream_start_checks(pctx,stream))
 -          ABORT(r);
 +      if(r=nr_ice_media_stream_unfreeze_pairs(pctx,stream))
 +        ABORT(r);
 +      if(r=nr_ice_media_stream_start_checks(pctx,stream))
 +        ABORT(r);
      }
      _status=0;
    abort:
      return(_status);
    }
  #ifndef NDEBUG
  int nr_ice_peer_ctx_dump_state(nr_ice_peer_ctx *pctx,FILE *out)
    {
@@ -253,26 +382,28 @@
        stream=STAILQ_NEXT(stream,entry);
      }
      fprintf(out,"==========================================\n");
      _status=0;
    abort:
      return(_status);
    }
  #endif
 -static void nr_ice_peer_ctx_fire_done(int s, int how, void *cb_arg)
 +static void nr_ice_peer_ctx_fire_done(NR_SOCKET s, int how, void *cb_arg)
    {
      nr_ice_peer_ctx *pctx=cb_arg;
      /* Fire the handler callback to say we're done */
 -    pctx->handler->vtbl->ice_completed(pctx->handler->obj, pctx);
 +    if (pctx->handler) {
 +      pctx->handler->vtbl->ice_completed(pctx->handler->obj, pctx);
 +    }
    }
  /* OK, a stream just went ready. Examine all the streams to see if we're
     maybe miraculously done */
  int nr_ice_peer_ctx_stream_done(nr_ice_peer_ctx *pctx, nr_ice_media_stream *stream)
    {
      int _status;
      nr_ice_media_stream *str;
      int failed=0;
@@ -365,21 +496,24 @@
          NR_TRANSPORT_ADDR_CMP_MODE_ALL))
          break;
        cand=TAILQ_NEXT(cand,entry_comp);
      }
      if(!cand)
        ABORT(R_REJECTED);
      /* OK, there's a match. Call the handler */
 -    r_log(LOG_ICE,LOG_DEBUG,"ICE-PEER(%s): Delivering data", pctx->label);
 -    pctx->handler->vtbl->msg_recvd(pctx->handler->obj,
 -      pctx,comp->stream,comp->component_id,data,len);
 +    if (pctx->handler) {
 +      r_log(LOG_ICE,LOG_DEBUG,"ICE-PEER(%s): Delivering data", pctx->label);
 +
 +      pctx->handler->vtbl->msg_recvd(pctx->handler->obj,
 +        pctx,comp->stream,comp->component_id,data,len);
 +    }
      _status=0;
    abort:
      return(_status);
    }
 diff -U10 -r /Users/ekr/dev/mtransport-import-references/nICEr/src/ice/ice_peer_ctx.h src/ice/ice_peer_ctx.h
 --- /Users/ekr/dev/mtransport-import-references/nICEr/src/ice/ice_peer_ctx.h	2012-09-16 16:26:08.000000000 -0700
 +++ src/ice/ice_peer_ctx.h	2012-10-06 08:30:22.000000000 -0700
@@ -33,23 +33,21 @@
  #ifndef _ice_peer_ctx_h
  #define _ice_peer_ctx_h
  #ifdef __cplusplus
  using namespace std;
  extern "C" {
  #endif /* __cplusplus */
  struct nr_ice_peer_ctx_ {
 -  int state;
    char *label;
 -
    nr_ice_ctx *ctx;
    nr_ice_handler *handler;
    UCHAR controlling; /* 1 for controlling, 0 for controlled */
    UINT8 tiebreaker;
    char *peer_ufrag;
    char *peer_pwd;
    int peer_lite;
    int peer_ice_mismatch;
@@ -59,23 +57,26 @@
    int waiting_pairs;
    STAILQ_ENTRY(nr_ice_peer_ctx_) entry;
  };
  typedef STAILQ_HEAD(nr_ice_peer_ctx_head_, nr_ice_peer_ctx_) nr_ice_peer_ctx_head;
  int nr_ice_peer_ctx_create(nr_ice_ctx *ctx, nr_ice_handler *handler,char *label, nr_ice_peer_ctx **pctxp);
  int nr_ice_peer_ctx_destroy(nr_ice_peer_ctx **pctxp);
  int nr_ice_peer_ctx_parse_stream_attributes(nr_ice_peer_ctx *pctx, nr_ice_media_stream *stream, char **attrs, int attr_ct);
 +int nr_ice_peer_ctx_parse_trickle_candidate(nr_ice_peer_ctx *pctx, nr_ice_media_stream *stream, char *cand);
 +
  int nr_ice_peer_ctx_pair_candidates(nr_ice_peer_ctx *pctx);
  int nr_ice_peer_ctx_parse_global_attributes(nr_ice_peer_ctx *pctx, char **attrs, int attr_ct);
  int nr_ice_peer_ctx_start_checks(nr_ice_peer_ctx *pctx);
 +int nr_ice_peer_ctx_start_checks2(nr_ice_peer_ctx *pctx, int allow_non_first);
  int nr_ice_peer_ctx_dump_state(nr_ice_peer_ctx *pctx,FILE *out);
  int nr_ice_peer_ctx_log_state(nr_ice_peer_ctx *pctx);
  int nr_ice_peer_ctx_stream_done(nr_ice_peer_ctx *pctx, nr_ice_media_stream *stream);
  int nr_ice_peer_ctx_find_component(nr_ice_peer_ctx *pctx, nr_ice_media_stream *str, int component_id, nr_ice_component **compp);
  int nr_ice_peer_ctx_deliver_packet_maybe(nr_ice_peer_ctx *pctx, nr_ice_component *comp, nr_transport_addr *source_addr, UCHAR *data, int len);
  #ifdef __cplusplus
  }
  #endif /* __cplusplus */
  #endif
 diff -U10 -r /Users/ekr/dev/mtransport-import-references/nICEr/src/ice/ice_socket.c src/ice/ice_socket.c
 --- /Users/ekr/dev/mtransport-import-references/nICEr/src/ice/ice_socket.c	2012-09-16 16:26:08.000000000 -0700
 +++ src/ice/ice_socket.c	2012-10-06 08:30:22.000000000 -0700
@@ -216,28 +216,34 @@
        RFREE(s1);
      }
      RFREE(isock);
      return(0);
    }
  int nr_ice_socket_close(nr_ice_socket *isock)
    {
 +#ifdef NR_SOCKET_IS_VOID_PTR
 +    NR_SOCKET fd=NULL;
 +    NR_SOCKET no_socket = NULL;
 +#else
      NR_SOCKET fd=-1;
 +    NR_SOCKET no_socket = -1;
 +#endif
      if (!isock||!isock->sock)
        return(0);
      nr_socket_getfd(isock->sock,&fd);
      assert(isock->sock!=0);
 -    if(fd!=-1){
 +    if(fd != no_socket){
        NR_ASYNC_CANCEL(fd,NR_ASYNC_WAIT_READ);
        NR_ASYNC_CANCEL(fd,NR_ASYNC_WAIT_WRITE);
        nr_socket_destroy(&isock->sock);
      }
      return(0);
    }
  int nr_ice_socket_register_stun_client(nr_ice_socket *sock, nr_stun_client_ctx *srv,void **handle)
    {
 diff -U10 -r /Users/ekr/dev/mtransport-import-references/nICEr/src/net/nr_socket.h src/net/nr_socket.h
 --- /Users/ekr/dev/mtransport-import-references/nICEr/src/net/nr_socket.h	2012-09-16 16:26:09.000000000 -0700
 +++ src/net/nr_socket.h	2012-10-06 08:30:22.000000000 -0700
@@ -38,21 +38,23 @@
  #include <sys/types.h>
  #ifdef WIN32
  #include <winsock2.h>
  #include <ws2tcpip.h>
  #else
  #include <sys/socket.h>
  #endif
  #include "transport_addr.h"
 -#ifdef WIN32
 +#ifdef __cplusplus
 +#define restrict
 +#elif defined(WIN32)
  #define restrict __restrict
  #endif
  typedef struct nr_socket_vtbl_ {
    int (*destroy)(void **obj);
    int (*ssendto)(void *obj,const void *msg, size_t len, int flags,
      nr_transport_addr *addr);
    int (*srecvfrom)(void *obj,void * restrict buf, size_t maxlen, size_t *len, int flags,
      nr_transport_addr *addr);
    int (*getfd)(void *obj, NR_SOCKET *fd);
 diff -U10 -r /Users/ekr/dev/mtransport-import-references/nICEr/src/net/transport_addr_reg.c src/net/transport_addr_reg.c
 --- /Users/ekr/dev/mtransport-import-references/nICEr/src/net/transport_addr_reg.c	2012-09-16 16:26:09.000000000 -0700
 +++ src/net/transport_addr_reg.c	2012-10-06 08:30:22.000000000 -0700
@@ -29,25 +29,27 @@
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
  static char *RCSSTRING __UNUSED__="$Id: transport_addr_reg.c,v 1.2 2008/04/28 17:59:03 ekr Exp $";
  #include <csi_platform.h>
  #include <stdio.h>
 +#include <string.h>
  #include <memory.h>
  #include <sys/types.h>
  #ifdef WIN32
  #include <winsock2.h>
  #else
 +#include <strings.h>
  #include <unistd.h>
  #include <sys/socket.h>
  #include <netinet/in.h>
  #include <arpa/inet.h>
  #endif
  #include <assert.h>
  #include "nr_api.h"
  #include "transport_addr.h"
  #include "transport_addr_reg.h"
@@ -83,20 +85,22 @@
      if ((r=NR_reg_get2_uint2(prefix, "port", &port))) {
          if (r != R_NOT_FOUND)
              ABORT(r);
          port = 0;
      }
      if ((r=NR_reg_alloc2_string(prefix, "protocol", &protocol))) {
          if (r != R_NOT_FOUND)
              ABORT(r);
 +        p = IPPROTO_UDP;
 +
          protocol = 0;
      }
      else {
          if (!strcasecmp("tcp", protocol))
              p = IPPROTO_TCP;
          else if (!strcasecmp("udp", protocol))
              p = IPPROTO_UDP;
          else
              ABORT(R_BAD_DATA);
      }
 diff -U10 -r /Users/ekr/dev/mtransport-import-references/nICEr/src/stun/addrs.c src/stun/addrs.c
 --- /Users/ekr/dev/mtransport-import-references/nICEr/src/stun/addrs.c	2012-09-16 16:26:10.000000000 -0700
 +++ src/stun/addrs.c	2012-10-06 09:42:43.000000000 -0700
@@ -46,20 +46,22 @@
  #include <sys/sysctl.h>
  #include <sys/param.h>
  #include <sys/socket.h>
  #include <sys/syslog.h>
  #include <net/if.h>
  #ifndef LINUX
  #include <net/if_var.h>
  #include <net/if_dl.h>
  #include <net/if_types.h>
  #include <sys/sockio.h>
 +#else
 +#include <linux/if.h>
  #endif
  #include <net/route.h>
  /* IP */
  #include <netinet/in.h>
  #ifdef LINUX
  #include "sys/ioctl.h"
  #else
  #include <netinet/in_var.h>
  #endif
@@ -105,20 +107,23 @@
   * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   * SUCH DAMAGE.
   */
  #include <err.h>
  static void stun_rt_xaddrs(caddr_t, caddr_t, struct rt_addrinfo *);
  static int stun_grab_addrs(char *name, int addrcount,
                 struct ifa_msghdr *ifam,
                 nr_transport_addr addrs[], int maxaddrs, int *count);
 +static int
 +nr_stun_is_duplicate_addr(nr_transport_addr addrs[], int count, nr_transport_addr *addr);
 +
  /*
   * Expand the compacted form of addresses as returned via the
   * configuration read via sysctl().
   */
  #define ROUNDUP(a) \
      ((a) > 0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long))
  #define ADVANCE(x, n) (x += ROUNDUP((n)->sa_len))
  static void
@@ -135,21 +140,21 @@
              continue;
          rtinfo->rti_info[i] = sa = (struct sockaddr *)cp;
          ADVANCE(cp, sa);
      }
  }
  static int
  stun_grab_addrs(char *name, int addrcount, struct ifa_msghdr *ifam, nr_transport_addr addrs[], int maxaddrs, int *count)
  {
      int r,_status;
 -    NR_SOCKET s = -1;
 +    int s = -1;
      struct ifreq ifr;
      struct rt_addrinfo info;
      struct sockaddr_in *sin;
      ifr.ifr_addr.sa_family = AF_INET;
      strncpy(ifr.ifr_name, name, sizeof ifr.ifr_name);
      if ((s = socket(ifr.ifr_addr.sa_family, SOCK_DGRAM, 0)) < 0) {
        r_log(NR_LOG_STUN, LOG_WARNING, "unable to obtain addresses from socket");
        ABORT(R_FAILED);
@@ -180,21 +185,20 @@
          addrcount--;
          if (*count >= maxaddrs) {
              r_log(NR_LOG_STUN, LOG_WARNING, "Address list truncated at %d out of entries", maxaddrs, maxaddrs+addrcount);
              break;
          }
          ifam = (struct ifa_msghdr *)((char *)ifam + ifam->ifam_msglen);
      }
 -
      _status = 0;
    abort:
      if (s != -1) close(s);
      return _status;
  }
  static int
  stun_get_mib_addrs(nr_transport_addr addrs[], int maxaddrs, int *count)
  {
      int _status;
@@ -551,44 +555,48 @@
  #else
  static int
  stun_get_siocgifconf_addrs(nr_transport_addr addrs[], int maxaddrs, int *count)
  {
     struct ifconf ifc;
     int _status;
     int s = socket( AF_INET, SOCK_DGRAM, 0 );
     int len = 100 * sizeof(struct ifreq);
     int r;
 +   int e;
 +   char *ptr;
 +   int tl;
 +   int n;
 +   struct ifreq ifr2;
     char buf[ len ];
     ifc.ifc_len = len;
     ifc.ifc_buf = buf;
 -   int e = ioctl(s,SIOCGIFCONF,&ifc);
 -   char *ptr = buf;
 -   int tl = ifc.ifc_len;
 -   int n=0;
 +   e = ioctl(s,SIOCGIFCONF,&ifc);
 +   ptr = buf;
 +   tl = ifc.ifc_len;
 +   n=0;
     while ( (tl > 0) && ( n < maxaddrs) )
     {
        struct ifreq* ifr = (struct ifreq *)ptr;
  #ifdef LINUX
 -      int si = sizeof(ifr->ifr_name) + sizeof(ifr->ifr_addr);
 +      int si = sizeof(struct ifreq);
  #else
        int si = sizeof(ifr->ifr_name) + MAX(ifr->ifr_addr.sa_len, sizeof(ifr->ifr_addr));
  #endif
        tl -= si;
        ptr += si;
 -      struct ifreq ifr2;
        ifr2 = *ifr;
        e = ioctl(s,SIOCGIFADDR,&ifr2);
        if ( e == -1 )
        {
            continue;
        }
        //r_log(NR_LOG_STUN, LOG_ERR, "ioctl addr e = %d",e);
@@ -603,21 +611,21 @@
     close(s);
     *count = n;
      _status = 0;
      return _status;
  }
  #endif
 -int
 +static int
  nr_stun_is_duplicate_addr(nr_transport_addr addrs[], int count, nr_transport_addr *addr)
  {
      int i;
      int different;
      for (i = 0; i < count; ++i) {
          different = nr_transport_addr_cmp(&addrs[i], addr, NR_TRANSPORT_ADDR_CMP_MODE_ALL);
          if (!different)
              return 1;  /* duplicate */
      }
 diff -U10 -r /Users/ekr/dev/mtransport-import-references/nICEr/src/stun/nr_socket_turn.c src/stun/nr_socket_turn.c
 --- /Users/ekr/dev/mtransport-import-references/nICEr/src/stun/nr_socket_turn.c	2012-09-16 16:26:10.000000000 -0700
 +++ src/stun/nr_socket_turn.c	2012-10-06 08:30:22.000000000 -0700
@@ -246,17 +246,19 @@
      default:
          assert(0);
          break;
      }
      return R_FAILED;
    }
  static int nr_socket_turn_close(void *obj)
    {
 +#ifndef NDEBUG
      nr_socket_turn *sturn=obj;
      assert(sturn->magic_cookie == nr_socket_turn_magic_cookie);
 +#endif
      return 0;
    }
  #endif /* USE_TURN */
 diff -U10 -r /Users/ekr/dev/mtransport-import-references/nICEr/src/stun/stun_client_ctx.c src/stun/stun_client_ctx.c
 --- /Users/ekr/dev/mtransport-import-references/nICEr/src/stun/stun_client_ctx.c	2012-09-16 16:26:10.000000000 -0700
 +++ src/stun/stun_client_ctx.c	2012-10-06 08:30:22.000000000 -0700
@@ -38,21 +38,22 @@
  #include <string.h>
  #include <nr_api.h>
  #include "stun.h"
  #include "async_timer.h"
  #include "registry.h"
  #include "stun_reg.h"
  #include "r_time.h"
  static int nr_stun_client_send_request(nr_stun_client_ctx *ctx);
 -static void nr_stun_client_timer_expired_cb(int a, int b, void *cb_arg);
 +static void nr_stun_client_timer_expired_cb(NR_SOCKET s, int b, void *cb_arg);
 +static int nr_stun_client_get_password(void *arg, nr_stun_message *msg, Data **password);
  int nr_stun_client_ctx_create(char *label, nr_socket *sock, nr_transport_addr *peer, UINT4 RTO, nr_stun_client_ctx **ctxp)
    {
      nr_stun_client_ctx *ctx=0;
      int r,_status;
      if ((r=nr_stun_startup()))
        ABORT(r);
      if(!(ctx=RCALLOC(sizeof(nr_stun_client_ctx))))
@@ -185,21 +186,21 @@
      ctx->finished_cb   = 0;
      ctx->cb_arg        = 0;
      ctx->request_ct    = 0;
      ctx->timeout_ms    = 0;
      ctx->state = NR_STUN_CLIENT_STATE_INITTED;
      return 0;
  }
 -static void nr_stun_client_timer_expired_cb(int a, int b, void *cb_arg)
 +static void nr_stun_client_timer_expired_cb(NR_SOCKET s, int b, void *cb_arg)
    {
      int _status;
      nr_stun_client_ctx *ctx=cb_arg;
      struct timeval now;
      INT8 ms_waited;
      /* Prevent this timer from being cancelled later */
      ctx->timer_handle=0;
      /* Shouldn't happen */
@@ -387,21 +388,21 @@
      }
      _status=0;
    abort:
      if (_status) {
        ctx->state=NR_STUN_CLIENT_STATE_FAILED;
      }
      return(_status);
    }
 -int nr_stun_client_get_password(void *arg, nr_stun_message *msg, Data **password)
 +static int nr_stun_client_get_password(void *arg, nr_stun_message *msg, Data **password)
  {
      *password = (Data*)arg;
      if (!arg)
          return(R_NOT_FOUND);
      return(0);
  }
  int nr_stun_client_process_response(nr_stun_client_ctx *ctx, UCHAR *msg, int len, nr_transport_addr *peer_addr)
    {
      int r,_status;
 diff -U10 -r /Users/ekr/dev/mtransport-import-references/nICEr/src/stun/stun_codec.c src/stun/stun_codec.c
 --- /Users/ekr/dev/mtransport-import-references/nICEr/src/stun/stun_codec.c	2012-09-16 16:26:10.000000000 -0700
 +++ src/stun/stun_codec.c	2012-10-06 08:30:22.000000000 -0700
@@ -73,20 +73,22 @@
  static int nr_stun_decode_htonll(UCHAR *buf, int buflen, int *offset, UINT8 *data);
  static int nr_stun_decode(int length, UCHAR *buf, int buflen, int *offset, UCHAR *data);
  static int nr_stun_attr_string_illegal(nr_stun_attr_info *attr_info, int len, void *data, int max_bytes, int max_chars);
  static int nr_stun_attr_error_code_illegal(nr_stun_attr_info *attr_info, int attrlen, void *data);
  static int nr_stun_attr_nonce_illegal(nr_stun_attr_info *attr_info, int attrlen, void *data);
  static int nr_stun_attr_realm_illegal(nr_stun_attr_info *attr_info, int attrlen, void *data);
  static int nr_stun_attr_server_illegal(nr_stun_attr_info *attr_info, int attrlen, void *data);
  static int nr_stun_attr_username_illegal(nr_stun_attr_info *attr_info, int attrlen, void *data);
 +static int
 +nr_stun_attr_codec_fingerprint_decode(nr_stun_attr_info *attr_info, int attrlen, UCHAR *buf, int offset, int buflen, void *data);
  int
  nr_stun_encode_htons(UINT2 data, int buflen, UCHAR *buf, int *offset)
  {
     UINT2 d = htons(data);
     if (*offset + sizeof(d) >= buflen) {
        r_log(NR_LOG_STUN, LOG_WARNING, "Attempted buffer overrun: %d + %d >= %d", *offset, sizeof(d), buflen);
        return R_BAD_DATA;
@@ -632,21 +634,21 @@
      }
      fingerprint->checksum = checksum ^ 0x5354554e;
      r_log(NR_LOG_STUN, LOG_DEBUG, "Computed FINGERPRINT %08x", fingerprint->checksum);
      fingerprint->valid = 1;
      return nr_stun_attr_codec_UINT4.encode(attr_info, &fingerprint->checksum, offset, buflen, buf, attrlen);
  }
 -int
 +static int
  nr_stun_attr_codec_fingerprint_decode(nr_stun_attr_info *attr_info, int attrlen, UCHAR *buf, int offset, int buflen, void *data)
  {
      int r,_status;
      nr_stun_attr_fingerprint *fingerprint = data;
      nr_stun_message_header *header = (nr_stun_message_header*)buf;
      int length;
      UINT4 checksum;
      if ((r=nr_stun_attr_codec_UINT4.decode(attr_info, attrlen, buf, offset, buflen, &fingerprint->checksum)))
          ABORT(r);
 diff -U10 -r /Users/ekr/dev/mtransport-import-references/nICEr/src/stun/stun_proc.c src/stun/stun_proc.c
 --- /Users/ekr/dev/mtransport-import-references/nICEr/src/stun/stun_proc.c	2012-09-16 16:26:10.000000000 -0700
 +++ src/stun/stun_proc.c	2012-10-06 08:30:22.000000000 -0700
@@ -43,20 +43,22 @@
  #include <time.h>
  #else   /* UNIX */
  #include <string.h>
  #endif  /* end UNIX */
  #include <assert.h>
  #include "stun.h"
  #include "stun_reg.h"
  #include "registry.h"
 +static int
 +nr_stun_add_realm_and_nonce(int new_nonce, nr_stun_server_client *clnt, nr_stun_message *res);
  /* draft-ietf-behave-rfc3489bis-10.txt S 7.3 */
  int
  nr_stun_receive_message(nr_stun_message *req, nr_stun_message *msg)
  {
      int _status;
      nr_stun_message_attribute *attr;
  #ifdef USE_RFC_3489_BACKWARDS_COMPATIBLE
      /* if this message was generated by an RFC 3489 impementation,
@@ -371,21 +373,21 @@
          /* nothing to check in this case */
          break;
  #endif /* USE_STUND_0_96 */
      }
     _status=0;
   abort:
       return _status;
  }
 -int
 +static int
  nr_stun_add_realm_and_nonce(int new_nonce, nr_stun_server_client *clnt, nr_stun_message *res)
  {
      int r,_status;
      char *realm = 0;
      char *nonce;
      UINT2 size;
      if ((r=NR_reg_alloc_string(NR_STUN_REG_PREF_SERVER_REALM, &realm)))
          ABORT(r);
 diff -U10 -r /Users/ekr/dev/mtransport-import-references/nICEr/src/stun/stun_server_ctx.c src/stun/stun_server_ctx.c
 --- /Users/ekr/dev/mtransport-import-references/nICEr/src/stun/stun_server_ctx.c	2012-09-16 16:26:10.000000000 -0700
 +++ src/stun/stun_server_ctx.c	2012-10-06 08:30:22.000000000 -0700
@@ -114,21 +114,21 @@
      STAILQ_INSERT_TAIL(&ctx->clients,clnt,entry);
      _status=0;
    abort:
      if(_status){
        nr_stun_server_destroy_client(clnt);
      }
      return(_status);
    }
 -int nr_stun_server_get_password(void *arg, nr_stun_message *msg, Data **password)
 +static int nr_stun_server_get_password(void *arg, nr_stun_message *msg, Data **password)
    {
      int _status;
      nr_stun_server_ctx *ctx = (nr_stun_server_ctx*)arg;
      nr_stun_server_client *clnt = 0;
      nr_stun_message_attribute *username_attribute;
      if ((nr_stun_get_message_client(ctx, msg, &clnt))) {
          if (! nr_stun_message_has_attribute(msg, NR_STUN_ATTR_USERNAME, &username_attribute)) {
             r_log(NR_LOG_STUN,LOG_NOTICE,"STUN-SERVER(%s): Missing Username",ctx->label);
             ABORT(R_NOT_FOUND);
 diff -U10 -r /Users/ekr/dev/mtransport-import-references/nICEr/src/stun/stun_util.c src/stun/stun_util.c
 --- /Users/ekr/dev/mtransport-import-references/nICEr/src/stun/stun_util.c	2012-09-16 16:26:10.000000000 -0700
 +++ src/stun/stun_util.c	2012-10-06 08:30:22.000000000 -0700
@@ -94,21 +94,20 @@
      _status = 0;
    abort:
      return _status;
  }
  int
  nr_stun_find_local_addresses(nr_transport_addr addrs[], int maxaddrs, int *count)
  {
      int r,_status;
      NR_registry *children = 0;
 -    int i;
      if ((r=NR_reg_get_child_count(NR_STUN_REG_PREF_ADDRESS_PRFX, (unsigned int*)count)))
          if (r == R_NOT_FOUND)
              *count = 0;
          else
              ABORT(r);
      if (*count == 0) {
          if ((r=nr_stun_get_addrs(addrs, maxaddrs, 1, count)))
              ABORT(r);
 diff -U10 -r /Users/ekr/dev/mtransport-import-references/nICEr/src/stun/turn_client_ctx.c src/stun/turn_client_ctx.c
 --- /Users/ekr/dev/mtransport-import-references/nICEr/src/stun/turn_client_ctx.c	2012-09-16 16:26:10.000000000 -0700
 +++ src/stun/turn_client_ctx.c	2012-10-06 08:30:22.000000000 -0700
@@ -55,21 +55,24 @@
  };
  static int TURN_PHASE_MODE[NUMBER_OF_STUN_CTX] = {
      NR_TURN_CLIENT_MODE_ALLOCATE_REQUEST1,
      NR_TURN_CLIENT_MODE_ALLOCATE_REQUEST2,
      NR_TURN_CLIENT_MODE_SET_ACTIVE_DEST_REQUEST
  };
  static int nr_turn_client_next_action(nr_turn_client_ctx *ctx, int stun_ctx_state);
 -static void nr_turn_client_cb(int s, int how, void *cb_arg);
 +static void nr_turn_client_cb(NR_SOCKET s, int how, void *cb_arg);
 +static int
 +nr_turn_client_prepare_start(nr_turn_client_ctx *ctx, char *username, Data *password, UINT4 bandwidth_kbps, UINT4 lifetime_secs, NR_async_cb finished_cb, void *cb_arg);
 +
  int
  nr_turn_client_next_action(nr_turn_client_ctx *ctx, int stun_ctx_state)
  {
      int r,_status;
      assert(ctx->phase >= -1 && ctx->phase < NUMBER_OF_STUN_CTX);
      switch (ctx->state) {
      //case NR_TURN_CLIENT_STATE_ALLOCATING:
@@ -147,21 +150,21 @@
               * because as a side effect this ctx may be operated on in the
               * callback */
              finished_cb(0,0,ctx->cb_arg);
          }
      }
      return(_status);
  }
  void
 -nr_turn_client_cb(int s, int how, void *cb_arg)
 +nr_turn_client_cb(NR_SOCKET s, int how, void *cb_arg)
  {
      int r,_status;
      nr_turn_client_ctx *ctx = (nr_turn_client_ctx*)cb_arg;
      nr_stun_client_ctx *stun_ctx = ctx->stun_ctx[ctx->phase];
      assert(ctx->phase >= 0);
      if ((r=nr_turn_client_next_action(ctx, stun_ctx->state)))
          ABORT(r);
@@ -234,21 +237,21 @@
      RFREE(ctx->username);
      r_data_destroy(&ctx->password);
      RFREE(ctx->label);
      RFREE(ctx);
      return(0);
  }
 -int
 +static int
  nr_turn_client_prepare_start(nr_turn_client_ctx *ctx, char *username, Data *password, UINT4 bandwidth_kbps, UINT4 lifetime_secs, NR_async_cb finished_cb, void *cb_arg)
  {
      int r,_status;
      nr_stun_client_allocate_request1_params          *allocate_request1 = 0;
      nr_stun_client_allocate_request2_params          *allocate_request2 = 0;
      nr_stun_client_allocate_response1_results        *allocate_response1 = 0;
  //    nr_stun_client_allocate_response2_results        *allocate_response2;
      if (ctx->state != NR_TURN_CLIENT_STATE_INITTED)
          ABORT(R_NOT_PERMITTED);
 diff -U10 -r /Users/ekr/dev/mtransport-import-references/nICEr/src/util/ice_util.c src/util/ice_util.c
 --- /Users/ekr/dev/mtransport-import-references/nICEr/src/util/ice_util.c	2012-09-16 16:26:10.000000000 -0700
 +++ src/util/ice_util.c	2012-10-06 08:30:22.000000000 -0700
@@ -31,20 +31,21 @@
  */
  #include <stdarg.h>
  static char *RCSSTRING __UNUSED__="$Id: ice_util.c,v 1.2 2008/04/28 17:59:05 ekr Exp $";
  #include <stdarg.h>
  #include <string.h>
  #include "nr_api.h"
 +#include "ice_util.h"
  int nr_concat_strings(char **outp,...)
    {
      va_list ap;
      char *s,*out=0;
      int len=0;
      int _status;
      va_start(ap,outp);
      while(s=va_arg(ap,char *)){
 diff -U10 -r /Users/ekr/dev/mtransport-import-references/nICEr/src/util/mbslen.c src/util/mbslen.c
 --- /Users/ekr/dev/mtransport-import-references/nICEr/src/util/mbslen.c	2012-09-16 16:26:10.000000000 -0700
 +++ src/util/mbslen.c	2012-10-06 08:31:01.000000000 -0700
@@ -56,21 +56,21 @@
  {
  #ifdef DARWIN
      static locale_t loc = 0;
      static int initialized = 0;
  #endif /* DARWIN */
  #ifdef WIN32
      char *my_locale=0;
      unsigned int i;
  #endif  /* WIN32 */
      int _status;
 -    int nbytes;
 +    size_t nbytes;
      int nchars;
      mbstate_t mbs;
  #ifdef DARWIN
      if (! initialized) {
          initialized = 1;
          loc = newlocale(LC_CTYPE_MASK, "UTF-8", LC_GLOBAL_LOCALE);
      }
      if (loc == 0) {
@@ -102,25 +102,28 @@
      memset(&mbs, 0, sizeof(mbs));
      nchars = 0;
  #ifdef DARWIN
      while (*s != '\0' && (nbytes = mbrlen_l(s, strlen(s), &mbs, loc)) != 0)
  #else
      while (*s != '\0' && (nbytes = mbrlen(s, strlen(s), &mbs)) != 0)
  #endif /* DARWIN */
      {
 -        assert(nbytes >= 0);
 -        if (nbytes == (size_t)-1)   /* should never happen */
 +        if (nbytes == (size_t)-1)   /* should never happen */ {
 +	    assert(0);
              ABORT(R_INTERNAL);
 -        if (nbytes == (size_t)-2)   /* encoding error */
 +	}
 +        if (nbytes == (size_t)-2)   /* encoding error */ {
 +	    assert(0);
              ABORT(R_BAD_DATA);
 +	}
          s += nbytes;
          ++nchars;
      }
      *ncharsp = nchars;
      _status = 0;
    abort:
  #ifdef WIN32

The Tor Browser / annotate

media/mtransport/third_party/nICEr/upstream.diff@97036ab72558 (annotated)

media/mtransport/third_party/nICEr/upstream.diff