Changeset 217 for pjproject/trunk/pjlib-util/src/pjlib-util/stun_client.c

Timestamp:

Feb 22, 2006 10:10:42 PM (19 years ago)

Author:

bennylp

Message:

Started errno framework in pjlib-util

File:

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

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

@@ -18 +18 @@
  */
 #include <pjlib-util/stun.h>
+#include <pjlib-util/errno.h>
+#include <pj/os.h>
 #include <pj/pool.h>
-#include <pj/log.h>
+#include <pj/rand.h>
+#include <pj/sock_select.h>
 #include <pj/string.h>
-#include <pj/os.h>
-#include <pj/sock_select.h>
+
 
 enum { MAX_REQUEST = 3 };
 static int stun_timer[] = {1600, 1600, 1600 };
 
-#define THIS_FILE       "stunclient"
+#define THIS_FILE       "stun_client.c"
 #define LOG_ADDR(addr)  pj_inet_ntoa(addr.sin_addr), pj_ntohs(addr.sin_port)
 
@@ -38 +40 @@
 {
     pj_sockaddr_in srv_addr[2];
-    int i, j, rc, send_cnt = 0;
+    int i, j, send_cnt = 0;
     pj_pool_t *pool;
     struct {
@@ -49 +51 @@
     pj_size_t   out_msg_len;
     int wait_resp = 0;
-    int mapped_status = 0;
+    pj_status_t status;
 
     PJ_CHECK_STACK();
@@ -55 +57 @@
     /* Create pool. */
     pool = pj_pool_create(pf, "stun%p", 1024, 1024, NULL);
-    if (!pool) {
-        mapped_status = PJ_STUN_ERR_MEMORY; 
-        return -1;
-    }
+    if (!pool)
+        return PJ_ENOMEM;
+
 
     /* Allocate client records */
     rec = pj_pool_calloc(pool, sock_cnt, sizeof(*rec));
     if (!rec) {
-        mapped_status = PJ_STUN_ERR_MEMORY; 
+        status = PJ_ENOMEM;
         goto on_error;
     }
 
+
     /* Create the outgoing BIND REQUEST message template */
-    rc = pj_stun_create_bind_req( pool, &out_msg, &out_msg_len, 0, 0);
-    if (rc != 0) {
-        mapped_status = -1;
-        goto on_error;
-    }
+    status = pj_stun_create_bind_req( pool, &out_msg, &out_msg_len, 
+                                      pj_rand(), pj_rand());
+    if (status != PJ_SUCCESS)
+        goto on_error;
 
     /* Resolve servers. */
-    if (pj_sockaddr_in_init(&srv_addr[0], srv1, (pj_uint16_t)port1) != 0) {
-        mapped_status = PJ_STUN_ERR_RESOLVE; 
-        goto on_error;
-    }
-    if (pj_sockaddr_in_init(&srv_addr[1], srv2, (pj_uint16_t)port2) != 0) {
-        mapped_status = PJ_STUN_ERR_RESOLVE;
-        goto on_error;
-    }
+    status = pj_sockaddr_in_init(&srv_addr[0], srv1, (pj_uint16_t)port1);
+    if (status != PJ_SUCCESS)
+        goto on_error;
+
+    status = pj_sockaddr_in_init(&srv_addr[1], srv2, (pj_uint16_t)port2);
+    if (status != PJ_SUCCESS)
+        goto on_error;
 
     /* Init mapped addresses to zero */
@@ -93 +93 @@
         int select_rc;
 
-        PJ_LOG(4,(THIS_FILE, "STUN retransmit %d, wait_resp=%d", 
-                             send_cnt, wait_resp));
-
         PJ_FD_ZERO(&r);
 
         /* Send messages to servers that has not given us response. */
-        for (i=0; i<sock_cnt && mapped_status==0; ++i) {
-            for (j=0; j<2 && mapped_status==0; ++j) {
+        for (i=0; i<sock_cnt && status==PJ_SUCCESS; ++i) {
+            for (j=0; j<2 && status==PJ_SUCCESS; ++j) {
                 pj_stun_msg_hdr *msg_hdr = out_msg;
                 pj_ssize_t sent_len;
@@ -113 +110 @@
                 /* Send! */
                 sent_len = out_msg_len;
-                rc = pj_sock_sendto(sock[i], out_msg, &sent_len, 0,
-                                    (pj_sockaddr_t*)&srv_addr[j], 
-                                    sizeof(pj_sockaddr_in));
-                if (sent_len != (int)out_msg_len) {
-                    PJ_LOG(4,(THIS_FILE, 
-                              "Error sending STUN request to %s:%d",
-                              LOG_ADDR(srv_addr[j])));
-                    mapped_status = PJ_STUN_ERR_TRANSPORT; 
-                } else {
+                status = pj_sock_sendto(sock[i], out_msg, &sent_len, 0,
+                                        (pj_sockaddr_t*)&srv_addr[j], 
+                                        sizeof(pj_sockaddr_in));
+                if (status == PJ_SUCCESS)
                     ++wait_resp;
-                }
             }
         }
@@ -140 +131 @@
 
         for (pj_gettimeofday(&now), select_rc=1; 
-             mapped_status==0 && select_rc==1 && wait_resp>0 && PJ_TIME_VAL_LT(now, next_tx); 
+             status==PJ_SUCCESS && select_rc==1 && wait_resp>0 
+               && PJ_TIME_VAL_LT(now, next_tx); 
              pj_gettimeofday(&now)) 
         {
@@ -169 +161 @@
 
                 len = sizeof(recv_buf);
-                pj_sock_recvfrom( sock[i], recv_buf, 
-                                  &len, 0,
-                                  (pj_sockaddr_t*)&addr,
-                                  &addrlen);
+                status = pj_sock_recvfrom( sock[i], recv_buf, 
+                                           &len, 0,
+                                           (pj_sockaddr_t*)&addr,
+                                           &addrlen);
 
                 --wait_resp;
 
-                if (len < 1) {
-                    mapped_status = PJ_STUN_ERR_TRANSPORT; 
-                    continue;
-                }
-
-                if (pj_stun_parse_msg(recv_buf, len, &msg) != 0) {
-                    PJ_LOG(4,(THIS_FILE, 
-                                "Error parsing STUN response from %s:%d",
-                                LOG_ADDR(addr)));
-                    mapped_status = PJ_STUN_ERR_INVALID_MSG;
-                    continue;
-                }
+                if (status != PJ_SUCCESS)
+                    continue;
+
+                status = pj_stun_parse_msg(recv_buf, len, &msg);
+                if (status != PJ_SUCCESS) {
+                    continue;
+                }
+
 
                 sock_idx = pj_ntohl(msg.hdr->tsx[2]);
@@ -193 +181 @@
 
                 if (sock_idx<0 || sock_idx>=sock_cnt || srv_idx<0 || srv_idx>=2) {
-                    PJ_LOG(4,(THIS_FILE, 
-                                "Invalid transaction ID from %s:%d", 
-                                LOG_ADDR(addr)));
-                    mapped_status = PJ_STUN_ERR_INVALID_MSG;
+                    status = PJLIB_UTIL_ESTUNININDEX;
                     continue;
                 }
 
                 if (pj_ntohs(msg.hdr->type) != PJ_STUN_BINDING_RESPONSE) {
-                    PJ_LOG(4,(THIS_FILE, 
-                                "Non binding response %d from %s:%d", 
-                                pj_ntohs(msg.hdr->type), LOG_ADDR(addr)));
-                    mapped_status = PJ_STUN_ERR_INVALID_MSG;
+                    status = PJLIB_UTIL_ESTUNNOBINDRES;
                     continue;
                 }
 
                 if (pj_stun_msg_find_attr(&msg, PJ_STUN_ATTR_ERROR_CODE) != NULL) {
-                    PJ_LOG(4,(THIS_FILE, 
-                                "Got STUN error attribute from %s:%d",
-                                LOG_ADDR(addr)));
-                    mapped_status = PJ_STUN_ERR_INVALID_MSG;
+                    status = PJLIB_UTIL_ESTUNRECVERRATTR;
                     continue;
                 }
@@ -218 +197 @@
                 attr = (void*)pj_stun_msg_find_attr(&msg, PJ_STUN_ATTR_MAPPED_ADDR);
                 if (!attr) {
-                    PJ_LOG(4,(THIS_FILE,
-                                "No mapped address in response from %s:%d",
-                                LOG_ADDR(addr)));
-                    mapped_status = PJ_STUN_ERR_INVALID_MSG;
+                    status = PJLIB_UTIL_ESTUNNOMAP;
                     continue;
                 }
@@ -237 +213 @@
     }
 
-    for (i=0; i<sock_cnt && mapped_status==0; ++i) {
+    for (i=0; i<sock_cnt && status==PJ_SUCCESS; ++i) {
         if (rec[i].srv[0].mapped_addr == rec[i].srv[1].mapped_addr &&
             rec[i].srv[0].mapped_port == rec[i].srv[1].mapped_port)
@@ -246 +222 @@
 
             if (rec[i].srv[0].mapped_addr == 0 || rec[i].srv[0].mapped_port == 0) {
-                mapped_status = PJ_STUN_ERR_NO_RESPONSE;
+                status = PJLIB_UTIL_ESTUNNOTRESPOND;
                 break;
             }
         } else {
-            mapped_status = PJ_STUN_ERR_SYMETRIC;
+            status = PJLIB_UTIL_ESTUNSYMMETRIC;
             break;
         }
@@ -257 +233 @@
     pj_pool_release(pool);
 
-    return mapped_status;
+    return status;
 
 on_error:
     if (pool) pj_pool_release(pool);
-    return -1;
+    return status;
 }
 
-PJ_DEF(const char*) pj_stun_get_err_msg(pj_status_t status)
-{
-    switch (status) {
-    case 0:                         return "No error";
-    case -1:                        return "General error";
-    case PJ_STUN_ERR_MEMORY:        return "Memory allocation failed";
-    case PJ_STUN_ERR_RESOLVE:       return "Invalid IP or unable to resolve STUN server";
-    case PJ_STUN_ERR_TRANSPORT:     return "Unable to contact STUN server";
-    case PJ_STUN_ERR_INVALID_MSG:   return "Invalid response from STUN server";
-    case PJ_STUN_ERR_NO_RESPONSE:   return "No response from STUN server";
-    case PJ_STUN_ERR_SYMETRIC:      return "Different mappings are returned from servers";
-    }
-    return "Unknown error";
-}