[net][at] Modify AT Socket log information, fix at_freeaddrinfo() implement

Lawlieta · Lawlieta · commit 0d737de882bb · 2018-08-24T20:32:14.000+08:00
diff --git a/components/net/at/at_socket/at_socket.c b/components/net/at/at_socket/at_socket.c
@@ -36,10 +36,9 @@
 
 #ifdef DBG_SECTION_NAME
 #undef DBG_SECTION_NAME
-#define DBG_SECTION_NAME     "[AT_SOC] "
+#define DBG_SECTION_NAME     "AT_SOC"
 #endif
 
-
 #define HTONS_PORT(x) ((((x) & 0x00ffUL) << 8) | (((x) & 0xff00UL) >> 8))
 #define NIPQUAD(addr) \
         ((unsigned char *)&addr)[0], \
@@ -89,7 +88,7 @@ static size_t at_recvpkt_put(rt_slist_t *rlist, const char *ptr, size_t length)
     at_recv_pkt_t pkt;
 
     pkt = (at_recv_pkt_t) rt_calloc(1, sizeof(struct at_recv_pkt));
-    if (!pkt)
+    if (pkt == RT_NULL)
     {
         LOG_E("No memory for receive packet table!");
         return 0;
@@ -340,7 +339,7 @@ int at_socket(int domain, int type, int protocol)
 
     /* allocate and initialize a new AT socket */
     sock = alloc_socket();
-    if(!sock)
+    if(sock == RT_NULL)
     {
         LOG_E("Allocate a new AT socket failed!");
         return RT_NULL;
@@ -381,14 +380,16 @@ int at_closesocket(int socket)
     struct at_socket *sock;
     enum at_socket_state last_state;
 
-    if (!at_dev_ops)
+    if (at_dev_ops == RT_NULL)
     {
-        LOG_E("Please register AT device socket options first!");
         return -1;
     }
 
-    if ((sock = at_get_socket(socket)) == RT_NULL)
+    sock = at_get_socket(socket);
+    if (sock == RT_NULL)
+    {
         return -1;
+    }
 
     last_state = sock->state;
 
@@ -410,14 +411,16 @@ int at_shutdown(int socket, int how)
 {
     struct at_socket *sock;
 
-    if (!at_dev_ops)
+    if (at_dev_ops == RT_NULL)
     {
-        LOG_E("Please register AT device socket options first!");
         return -1;
     }
 
-    if ((sock = at_get_socket(socket)) == RT_NULL)
+    sock = at_get_socket(socket);
+    if (sock == RT_NULL)
+    {
         return -1;
+    }
 
     if (sock->state == AT_SOCKET_CONNECT)
     {
@@ -434,7 +437,9 @@ int at_bind(int socket, const struct sockaddr *name, socklen_t namelen)
 {
 
     if (at_get_socket(socket) == RT_NULL)
+    {
         return -1;
+    }
 
     return 0;
 }
@@ -470,7 +475,8 @@ static void at_recv_notice_cb(int socket, at_socket_evt_t event, const char *buf
     RT_ASSERT(bfsz);
     RT_ASSERT(event == AT_SOCKET_EVT_RECV);
 
-    if ((sock = at_get_socket(socket)) == RT_NULL)
+    sock = at_get_socket(socket);
+    if (sock == RT_NULL)
         return ;
 
     /* put receive buffer to receiver packet list */
@@ -506,14 +512,13 @@ int at_connect(int socket, const struct sockaddr *name, socklen_t namelen)
     char ipstr[16] = { 0 };
     int result = 0;
 
-    if (!at_dev_ops)
+    if (at_dev_ops == RT_NULL)
     {
-        LOG_E("Please register AT device socket options first!");
         return -1;
     }
 
     sock = at_get_socket(socket);
-    if (!sock)
+    if (sock == RT_NULL)
     {
         result = -1;
         goto __exit;
@@ -560,21 +565,19 @@ int at_recvfrom(int socket, void *mem, size_t len, int flags, struct sockaddr *f
     int result = 0;
     size_t recv_len = 0;
 
-    if (!mem || len == 0)
+    if (mem == RT_NULL || len == 0)
     {
         LOG_E("AT recvfrom input data or length error!");
-        result = -1;
-        goto __exit;
+        return -1;
     }
 
-    if (!at_dev_ops)
+    if (at_dev_ops == RT_NULL)
     {
-        LOG_E("Please register AT device socket options first!");
         return -1;
     }
 
     sock = at_get_socket(socket);
-    if (!sock)
+    if (sock == RT_NULL)
     {
         result = -1;
         goto __exit;
@@ -686,22 +689,21 @@ int at_sendto(int socket, const void *data, size_t size, int flags, const struct
     struct at_socket *sock;
     int len, result = 0;
 
-    if (!at_dev_ops)
+    if (at_dev_ops == RT_NULL)
     {
-        LOG_E("Please register AT device socket options first!");
         result = -1;
         goto __exit;
     }
 
-    if (!data || size == 0)
+    if (data == RT_NULL || size == 0)
     {
         LOG_E("AT sendto input data or size error!");
         result = -1;
         goto __exit;
     }
 
     sock = at_get_socket(socket);
-    if (!sock)
+    if (sock == RT_NULL)
     {
         result = -1;
         goto __exit;
@@ -780,14 +782,14 @@ int at_getsockopt(int socket, int level, int optname, void *optval, socklen_t *o
     struct at_socket *sock;
     int32_t timeout;
 
-    if (!optval || !optlen)
+    if (optval == RT_NULL || optlen == RT_NULL)
     {
         LOG_E("AT getsocketopt input option value or option length error!");
         return -1;
     }
 
     sock = at_get_socket(socket);
-    if (!sock)
+    if (sock == RT_NULL)
     {
         return -1;
     }
@@ -827,14 +829,14 @@ int at_setsockopt(int socket, int level, int optname, const void *optval, sockle
 {
     struct at_socket *sock;
 
-    if (!optval)
+    if (optval == RT_NULL)
     {
         LOG_E("AT setsockopt input option value error!");
         return -1;
     }
 
     sock = at_get_socket(socket);
-    if (!sock)
+    if (sock == RT_NULL)
     {
         return -1;
     }
@@ -923,15 +925,14 @@ struct hostent *at_gethostbyname(const char *name)
     static char s_hostname[DNS_MAX_NAME_LENGTH + 1];
     size_t idx = 0;
 
-    if (!name)
+    if (name == RT_NULL)
     {
         LOG_E("AT gethostbyname input name error!");
         return RT_NULL;
     }
 
-    if (!at_dev_ops)
+    if (at_dev_ops == RT_NULL)
     {
-        LOG_E("Please register AT device socket options first!");
         return RT_NULL;
     }
 
@@ -983,12 +984,13 @@ int at_getaddrinfo(const char *nodename, const char *servname,
     {
         return EAI_FAIL;
     }
-    if (!at_dev_ops)
+    *res = RT_NULL;
+
+    if (at_dev_ops == RT_NULL)
     {
-        LOG_E("Please register AT device socket options first!");
         return EAI_FAIL;
     }
-    *res = RT_NULL;
+
     if ((nodename == RT_NULL) && (servname == RT_NULL))
     {
         return EAI_NONAME;
@@ -1085,10 +1087,10 @@ int at_getaddrinfo(const char *nodename, const char *servname,
     struct sockaddr_in *sa4 = (struct sockaddr_in *) sa;
     /* set up sockaddr */
     sa4->sin_addr.s_addr = addr.u_addr.ip4.addr;
-    sa4->sin_family = AF_AT;
+    sa4->sin_family = AF_INET;
     sa4->sin_len = sizeof(struct sockaddr_in);
     sa4->sin_port = htons((u16_t )port_nr);
-    ai->ai_family = AF_AT;
+    ai->ai_family = AF_INET;
 
     /* set up addrinfo */
     if (hints != RT_NULL)
@@ -1114,9 +1116,13 @@ int at_getaddrinfo(const char *nodename, const char *servname,
 
 void at_freeaddrinfo(struct addrinfo *ai)
 {
-    if (ai != RT_NULL)
+    struct addrinfo *next;
+
+    while (ai != NULL)
     {
+        next = ai->ai_next;
         rt_free(ai);
+        ai = next;
     }
 }
 
diff --git a/components/net/at/at_socket/at_socket.h b/components/net/at/at_socket/at_socket.h
@@ -144,7 +144,7 @@ void at_scoket_device_register(const struct at_device_ops *ops);
 #ifndef RT_USING_SAL
 
 #define socket(domain, type, protocol)                      at_socket(domain, type, protocol)
-#define closescoket(socket)                                 at_closesocket(socket)
+#define closesocket(socket)                                 at_closesocket(socket)
 #define shutdown(socket, how)                               at_shutdown(socket, how)
 #define bind(socket, name, namelen)                         at_bind(socket, name, namelen)
 #define connect(socket, name, namelen)                      at_connect(socket, name, namelen)

Original file line number	Diff line number	Diff line change
`@@ -36,10 +36,9 @@`
`36`	`36`
`37`	`37`	`#ifdef DBG_SECTION_NAME`
`38`	`38`	`#undef DBG_SECTION_NAME`
`39`		`-#define DBG_SECTION_NAME "[AT_SOC] "`
	`39`	`+#define DBG_SECTION_NAME "AT_SOC"`
`40`	`40`	`#endif`
`41`	`41`
`42`		`-`
`43`	`42`	`#define HTONS_PORT(x) ((((x) & 0x00ffUL) << 8) \| (((x) & 0xff00UL) >> 8))`
`44`	`43`	`#define NIPQUAD(addr) \`
`45`	`44`	`((unsigned char *)&addr)[0], \`
`@@ -89,7 +88,7 @@ static size_t at_recvpkt_put(rt_slist_t rlist, const char ptr, size_t length)`
`89`	`88`	`at_recv_pkt_t pkt;`
`90`	`89`
`91`	`90`	`pkt = (at_recv_pkt_t) rt_calloc(1, sizeof(struct at_recv_pkt));`
`92`		`- if (!pkt)`
	`91`	`+ if (pkt == RT_NULL)`
`93`	`92`	`{`
`94`	`93`	`LOG_E("No memory for receive packet table!");`
`95`	`94`	`return 0;`
`@@ -340,7 +339,7 @@ int at_socket(int domain, int type, int protocol)`
`340`	`339`
`341`	`340`	`/* allocate and initialize a new AT socket */`
`342`	`341`	`sock = alloc_socket();`
`343`		`- if(!sock)`
	`342`	`+ if(sock == RT_NULL)`
`344`	`343`	`{`
`345`	`344`	`LOG_E("Allocate a new AT socket failed!");`
`346`	`345`	`return RT_NULL;`
`@@ -381,14 +380,16 @@ int at_closesocket(int socket)`
`381`	`380`	`struct at_socket *sock;`
`382`	`381`	`enum at_socket_state last_state;`
`383`	`382`
`384`		`- if (!at_dev_ops)`
	`383`	`+ if (at_dev_ops == RT_NULL)`
`385`	`384`	`{`
`386`		`- LOG_E("Please register AT device socket options first!");`
`387`	`385`	`return -1;`
`388`	`386`	`}`
`389`	`387`
`390`		`- if ((sock = at_get_socket(socket)) == RT_NULL)`
	`388`	`+ sock = at_get_socket(socket);`
	`389`	`+ if (sock == RT_NULL)`
	`390`	`+ {`
`391`	`391`	`return -1;`
	`392`	`+ }`
`392`	`393`
`393`	`394`	`last_state = sock->state;`
`394`	`395`
`@@ -410,14 +411,16 @@ int at_shutdown(int socket, int how)`
`410`	`411`	`{`
`411`	`412`	`struct at_socket *sock;`
`412`	`413`
`413`		`- if (!at_dev_ops)`
	`414`	`+ if (at_dev_ops == RT_NULL)`
`414`	`415`	`{`
`415`		`- LOG_E("Please register AT device socket options first!");`
`416`	`416`	`return -1;`
`417`	`417`	`}`
`418`	`418`
`419`		`- if ((sock = at_get_socket(socket)) == RT_NULL)`
	`419`	`+ sock = at_get_socket(socket);`
	`420`	`+ if (sock == RT_NULL)`
	`421`	`+ {`
`420`	`422`	`return -1;`
	`423`	`+ }`
`421`	`424`
`422`	`425`	`if (sock->state == AT_SOCKET_CONNECT)`
`423`	`426`	`{`
`@@ -434,7 +437,9 @@ int at_bind(int socket, const struct sockaddr *name, socklen_t namelen)`
`434`	`437`	`{`
`435`	`438`
`436`	`439`	`if (at_get_socket(socket) == RT_NULL)`
	`440`	`+ {`
`437`	`441`	`return -1;`
	`442`	`+ }`
`438`	`443`
`439`	`444`	`return 0;`
`440`	`445`	`}`
`@@ -470,7 +475,8 @@ static void at_recv_notice_cb(int socket, at_socket_evt_t event, const char *buf`
`470`	`475`	`RT_ASSERT(bfsz);`
`471`	`476`	`RT_ASSERT(event == AT_SOCKET_EVT_RECV);`
`472`	`477`
`473`		`- if ((sock = at_get_socket(socket)) == RT_NULL)`
	`478`	`+ sock = at_get_socket(socket);`
	`479`	`+ if (sock == RT_NULL)`
`474`	`480`	`return ;`
`475`	`481`
`476`	`482`	`/* put receive buffer to receiver packet list */`
`@@ -506,14 +512,13 @@ int at_connect(int socket, const struct sockaddr *name, socklen_t namelen)`
`506`	`512`	`char ipstr[16] = { 0 };`
`507`	`513`	`int result = 0;`
`508`	`514`
`509`		`- if (!at_dev_ops)`
	`515`	`+ if (at_dev_ops == RT_NULL)`
`510`	`516`	`{`
`511`		`- LOG_E("Please register AT device socket options first!");`
`512`	`517`	`return -1;`
`513`	`518`	`}`
`514`	`519`
`515`	`520`	`sock = at_get_socket(socket);`
`516`		`- if (!sock)`
	`521`	`+ if (sock == RT_NULL)`
`517`	`522`	`{`
`518`	`523`	`result = -1;`
`519`	`524`	`goto __exit;`
`@@ -560,21 +565,19 @@ int at_recvfrom(int socket, void mem, size_t len, int flags, struct sockaddr f`
`560`	`565`	`int result = 0;`
`561`	`566`	`size_t recv_len = 0;`
`562`	`567`
`563`		`- if (!mem \|\| len == 0)`
	`568`	`+ if (mem == RT_NULL \|\| len == 0)`
`564`	`569`	`{`
`565`	`570`	`LOG_E("AT recvfrom input data or length error!");`
`566`		`- result = -1;`
`567`		`- goto __exit;`
	`571`	`+ return -1;`
`568`	`572`	`}`
`569`	`573`
`570`		`- if (!at_dev_ops)`
	`574`	`+ if (at_dev_ops == RT_NULL)`
`571`	`575`	`{`
`572`		`- LOG_E("Please register AT device socket options first!");`
`573`	`576`	`return -1;`
`574`	`577`	`}`
`575`	`578`
`576`	`579`	`sock = at_get_socket(socket);`
`577`		`- if (!sock)`
	`580`	`+ if (sock == RT_NULL)`
`578`	`581`	`{`
`579`	`582`	`result = -1;`
`580`	`583`	`goto __exit;`
`@@ -686,22 +689,21 @@ int at_sendto(int socket, const void *data, size_t size, int flags, const struct`
`686`	`689`	`struct at_socket *sock;`
`687`	`690`	`int len, result = 0;`
`688`	`691`
`689`		`- if (!at_dev_ops)`
	`692`	`+ if (at_dev_ops == RT_NULL)`
`690`	`693`	`{`
`691`		`- LOG_E("Please register AT device socket options first!");`
`692`	`694`	`result = -1;`
`693`	`695`	`goto __exit;`
`694`	`696`	`}`
`695`	`697`
`696`		`- if (!data \|\| size == 0)`
	`698`	`+ if (data == RT_NULL \|\| size == 0)`
`697`	`699`	`{`
`698`	`700`	`LOG_E("AT sendto input data or size error!");`
`699`	`701`	`result = -1;`
`700`	`702`	`goto __exit;`
`701`	`703`	`}`
`702`	`704`
`703`	`705`	`sock = at_get_socket(socket);`
`704`		`- if (!sock)`
	`706`	`+ if (sock == RT_NULL)`
`705`	`707`	`{`
`706`	`708`	`result = -1;`
`707`	`709`	`goto __exit;`
`@@ -780,14 +782,14 @@ int at_getsockopt(int socket, int level, int optname, void optval, socklen_t o`
`780`	`782`	`struct at_socket *sock;`
`781`	`783`	`int32_t timeout;`
`782`	`784`
`783`		`- if (!optval \|\| !optlen)`
	`785`	`+ if (optval == RT_NULL \|\| optlen == RT_NULL)`
`784`	`786`	`{`
`785`	`787`	`LOG_E("AT getsocketopt input option value or option length error!");`
`786`	`788`	`return -1;`
`787`	`789`	`}`
`788`	`790`
`789`	`791`	`sock = at_get_socket(socket);`
`790`		`- if (!sock)`
	`792`	`+ if (sock == RT_NULL)`
`791`	`793`	`{`
`792`	`794`	`return -1;`
`793`	`795`	`}`
`@@ -827,14 +829,14 @@ int at_setsockopt(int socket, int level, int optname, const void *optval, sockle`
`827`	`829`	`{`
`828`	`830`	`struct at_socket *sock;`
`829`	`831`
`830`		`- if (!optval)`
	`832`	`+ if (optval == RT_NULL)`
`831`	`833`	`{`
`832`	`834`	`LOG_E("AT setsockopt input option value error!");`
`833`	`835`	`return -1;`
`834`	`836`	`}`
`835`	`837`
`836`	`838`	`sock = at_get_socket(socket);`
`837`		`- if (!sock)`
	`839`	`+ if (sock == RT_NULL)`
`838`	`840`	`{`
`839`	`841`	`return -1;`
`840`	`842`	`}`
`@@ -923,15 +925,14 @@ struct hostent at_gethostbyname(const char name)`
`923`	`925`	`static char s_hostname[DNS_MAX_NAME_LENGTH + 1];`
`924`	`926`	`size_t idx = 0;`
`925`	`927`
`926`		`- if (!name)`
	`928`	`+ if (name == RT_NULL)`
`927`	`929`	`{`
`928`	`930`	`LOG_E("AT gethostbyname input name error!");`
`929`	`931`	`return RT_NULL;`
`930`	`932`	`}`
`931`	`933`
`932`		`- if (!at_dev_ops)`
	`934`	`+ if (at_dev_ops == RT_NULL)`
`933`	`935`	`{`
`934`		`- LOG_E("Please register AT device socket options first!");`
`935`	`936`	`return RT_NULL;`
`936`	`937`	`}`
`937`	`938`
`@@ -983,12 +984,13 @@ int at_getaddrinfo(const char nodename, const char servname,`
`983`	`984`	`{`
`984`	`985`	`return EAI_FAIL;`
`985`	`986`	`}`
`986`		`- if (!at_dev_ops)`
	`987`	`+ *res = RT_NULL;`
	`988`	`+`
	`989`	`+ if (at_dev_ops == RT_NULL)`
`987`	`990`	`{`
`988`		`- LOG_E("Please register AT device socket options first!");`
`989`	`991`	`return EAI_FAIL;`
`990`	`992`	`}`
`991`		`- *res = RT_NULL;`
	`993`	`+`
`992`	`994`	`if ((nodename == RT_NULL) && (servname == RT_NULL))`
`993`	`995`	`{`
`994`	`996`	`return EAI_NONAME;`
`@@ -1085,10 +1087,10 @@ int at_getaddrinfo(const char nodename, const char servname,`
`1085`	`1087`	`struct sockaddr_in sa4 = (struct sockaddr_in ) sa;`
`1086`	`1088`	`/* set up sockaddr */`
`1087`	`1089`	`sa4->sin_addr.s_addr = addr.u_addr.ip4.addr;`
`1088`		`- sa4->sin_family = AF_AT;`
	`1090`	`+ sa4->sin_family = AF_INET;`
`1089`	`1091`	`sa4->sin_len = sizeof(struct sockaddr_in);`
`1090`	`1092`	`sa4->sin_port = htons((u16_t )port_nr);`
`1091`		`- ai->ai_family = AF_AT;`
	`1093`	`+ ai->ai_family = AF_INET;`
`1092`	`1094`
`1093`	`1095`	`/* set up addrinfo */`
`1094`	`1096`	`if (hints != RT_NULL)`
`@@ -1114,9 +1116,13 @@ int at_getaddrinfo(const char nodename, const char servname,`
`1114`	`1116`
`1115`	`1117`	`void at_freeaddrinfo(struct addrinfo *ai)`
`1116`	`1118`	`{`
`1117`		`- if (ai != RT_NULL)`
	`1119`	`+ struct addrinfo *next;`
	`1120`	`+`
	`1121`	`+ while (ai != NULL)`
`1118`	`1122`	`{`
	`1123`	`+ next = ai->ai_next;`
`1119`	`1124`	`rt_free(ai);`
	`1125`	`+ ai = next;`
`1120`	`1126`	`}`
`1121`	`1127`	`}`
`1122`	`1128`