Changeset 1034 for pjproject/trunk/pjlib-util/src/pjlib-util/stun_session.c

Timestamp:

Mar 2, 2007 7:06:05 PM (17 years ago)

Author:

bennylp

Message:

Finishing up client-side STUN authentication, a simple STUN client, and simple STUN server

File:

• pjproject/trunk/pjlib-util/src/pjlib-util/stun_session.c (modified) (13 diffs)

pjproject/trunk/pjlib-util/src/pjlib-util/stun_session.c

@@ -38 +38 @@
 
     pj_stun_tx_data      pending_request_list;
+    pj_stun_tx_data      cached_response_list;
 };
 
@@ -104 +105 @@
     tdata = sess->pending_request_list.next;
     while (tdata != &sess->pending_request_list) {
-        pj_assert(sizeof(tdata->client_key)==sizeof(msg->hdr.tsx_id));
-        if (pj_memcmp(tdata->client_key, msg->hdr.tsx_id, 
+        pj_assert(sizeof(tdata->msg_key)==sizeof(msg->hdr.tsx_id));
+        if (tdata->msg_magic == msg->hdr.magic &&
+            pj_memcmp(tdata->msg_key, msg->hdr.tsx_id, 
                       sizeof(msg->hdr.tsx_id))==0)
         {
@@ -159 +161 @@
 
     /* copy the request's transaction ID as the transaction key. */
-    pj_assert(sizeof(tdata->client_key)==sizeof(tdata->msg->hdr.tsx_id));
-    pj_memcpy(tdata->client_key, tdata->msg->hdr.tsx_id,
+    pj_assert(sizeof(tdata->msg_key)==sizeof(tdata->msg->hdr.tsx_id));
+    tdata->msg_magic = tdata->msg->hdr.magic;
+    pj_memcpy(tdata->msg_key, tdata->msg->hdr.tsx_id,
               sizeof(tdata->msg->hdr.tsx_id));
 
@@ -175 +178 @@
         tdata->client_tsx = NULL;
     }
-
+    if (tdata->res_timer.id != PJ_FALSE) {
+        pj_timer_heap_cancel(tdata->sess->endpt->timer_heap, 
+                             &tdata->res_timer);
+        tdata->res_timer.id = PJ_FALSE;
+    }
     pj_pool_release(tdata->pool);
 }
@@ -187 +194 @@
     PJ_UNUSED_ARG(sess);
     destroy_tdata(tdata);
+}
+
+
+/* Timer callback to be called when it's time to destroy response cache */
+static void on_cache_timeout(pj_timer_heap_t *timer_heap,
+                             struct pj_timer_entry *entry)
+{
+    pj_stun_tx_data *tdata;
+
+    PJ_UNUSED_ARG(timer_heap);
+
+    entry->id = PJ_FALSE;
+    tdata = (pj_stun_tx_data*) entry->user_data;
+
+    PJ_LOG(5,(SNAME(tdata->sess), "Response cache deleted"));
+
+    pj_list_erase(tdata);
+    pj_stun_msg_destroy_tdata(tdata->sess, tdata);
 }
 
@@ -329 +354 @@
 
     pj_list_init(&sess->pending_request_list);
+    pj_list_init(&sess->cached_response_list);
 
     status = pj_mutex_create_recursive(pool, name, &sess->mutex);
@@ -500 +526 @@
 
     /* copy the request's transaction ID as the transaction key. */
-    pj_assert(sizeof(tdata->client_key)==sizeof(req->hdr.tsx_id));
-    pj_memcpy(tdata->client_key, req->hdr.tsx_id, sizeof(req->hdr.tsx_id));
+    pj_assert(sizeof(tdata->msg_key)==sizeof(req->hdr.tsx_id));
+    tdata->msg_magic = req->hdr.magic;
+    pj_memcpy(tdata->msg_key, req->hdr.tsx_id, sizeof(req->hdr.tsx_id));
 
     *p_tdata = tdata;
@@ -553 +580 @@
     PJ_ASSERT_RETURN(sess && addr_len && server && tdata, PJ_EINVAL);
 
+    tdata->options = options;
+
     /* Allocate packet */
     tdata->max_len = PJ_STUN_MAX_PKT_LEN;
@@ -612 +641 @@
 
     } else {
+        if ((options & PJ_STUN_CACHE_RESPONSE) && 
+            (PJ_STUN_IS_RESPONSE(tdata->msg->hdr.type) ||
+             PJ_STUN_IS_ERROR_RESPONSE(tdata->msg->hdr.type))) 
+        {
+            /* Requested to keep the response in the cache */
+            pj_time_val timeout;
+            
+            pj_memset(&tdata->res_timer, 0, sizeof(tdata->res_timer));
+            pj_timer_entry_init(&tdata->res_timer, PJ_TRUE, tdata, 
+                                &on_cache_timeout);
+
+            timeout.sec = sess->endpt->res_cache_msec / 1000;
+            timeout.msec = sess->endpt->res_cache_msec % 1000;
+
+            status = pj_timer_heap_schedule(sess->endpt->timer_heap, 
+                                            &tdata->res_timer,
+                                            &timeout);
+            if (status != PJ_SUCCESS) {
+                pj_stun_msg_destroy_tdata(sess, tdata);
+                pj_mutex_unlock(sess->mutex);
+                LOG_ERR_(sess, "Error scheduling response timer", status);
+                return status;
+            }
+
+            pj_list_push_back(&sess->cached_response_list, tdata);
+        }
+    
         /* Otherwise for non-request message, send directly to transport. */
         status = sess->cb.on_send_msg(sess, tdata->pkt, tdata->pkt_size,
@@ -620 +676 @@
         }
 
-        /* Destroy */
-        pj_stun_msg_destroy_tdata(sess, tdata);
+        /* Destroy only when response is not cached*/
+        if (tdata->res_timer.id == 0) {
+            pj_stun_msg_destroy_tdata(sess, tdata);
+        }
     }
 
@@ -640 +698 @@
     tdata = tsx_lookup(sess, msg);
     if (tdata == NULL) {
-        LOG_ERR_(sess, "STUN error finding transaction", PJ_ENOTFOUND);
-        return PJ_ENOTFOUND;
+        PJ_LOG(4,(SNAME(sess), 
+                  "Transaction not found, response silently discarded"));
+        return PJ_SUCCESS;
     }
 
@@ -708 +767 @@
                                        unsigned src_addr_len)
 {
+    pj_stun_tx_data *t;
     pj_status_t status;
+
+    /* First lookup response in response cache */
+    t = sess->cached_response_list.next;
+    while (t != &sess->cached_response_list) {
+        if (t->msg_magic == msg->hdr.magic &&
+            pj_memcmp(t->msg_key, msg->hdr.tsx_id, 
+                      sizeof(msg->hdr.tsx_id))==0)
+        {
+            break;
+        }
+        t = t->next;
+    }
+
+    if (t != &sess->cached_response_list) {
+        /* Found response in the cache */
+        unsigned options;
+
+        PJ_LOG(5,(SNAME(sess), 
+                 "Request retransmission, sending cached response"));
+
+        options = t->options;
+        options &= ~PJ_STUN_CACHE_RESPONSE;
+        pj_stun_session_send_msg(sess, options, src_addr, src_addr_len, t);
+        return PJ_SUCCESS;
+    }
 
     /* Distribute to handler, or respond with Bad Request */
@@ -726 +811 @@
     }
 
-    return status;    
+    return status;
 }