/test/unit/unit_socket.c

https://github.com/cloud-hot/picotcp · C · 497 lines · 376 code · 62 blank · 59 comment · 70 complexity · 0943909418fea62c24198a309e513f6e MD5 · raw file

  1. START_TEST (test_socket)
  2. {
  3. int ret = 0;
  4. uint16_t port_be = 0, porta, proto, port_got;
  5. char buf[] = "test";
  6. struct pico_socket *sk_tcp, *sk_udp, *s, *sl, *sa;
  7. struct pico_device *dev;
  8. struct pico_ip4 inaddr_dst, inaddr_link, inaddr_incorrect, inaddr_uni, inaddr_null, netmask, orig, inaddr_got;
  9. int getnodelay = -1;
  10. int nodelay = -1;
  11. uint32_t getsocket_buffer = 0;
  12. uint32_t socket_buffer = 0;
  13. pico_stack_init();
  14. printf("START SOCKET TEST\n");
  15. pico_string_to_ipv4("224.7.7.7", &inaddr_dst.addr);
  16. pico_string_to_ipv4("10.40.0.2", &inaddr_link.addr);
  17. pico_string_to_ipv4("224.8.8.8", &inaddr_incorrect.addr);
  18. pico_string_to_ipv4("0.0.0.0", &inaddr_null.addr);
  19. pico_string_to_ipv4("10.40.0.3", &inaddr_uni.addr);
  20. dev = pico_null_create("dummy");
  21. netmask.addr = long_be(0xFFFF0000);
  22. ret = pico_ipv4_link_add(dev, inaddr_link, netmask);
  23. fail_if(ret < 0, "socket> error adding link");
  24. /* socket_open passing wrong parameters */
  25. s = pico_socket_open(PICO_PROTO_IPV4, 99, NULL);
  26. fail_if(s != NULL, "Error got socket wrong parameters");
  27. s = pico_socket_open(PICO_PROTO_IPV4, -109, NULL);
  28. fail_if(s != NULL, "Error got socket");
  29. s = pico_socket_open(99, PICO_PROTO_UDP, NULL);
  30. fail_if(s != NULL, "Error got socket");
  31. s = pico_socket_open(-99, PICO_PROTO_UDP, NULL);
  32. fail_if(s != NULL, "Error got socket");
  33. sk_tcp = pico_socket_open(PICO_PROTO_IPV4, PICO_PROTO_TCP, NULL);
  34. fail_if(sk_tcp == NULL, "socket> tcp socket open failed");
  35. port_be = short_be(5555);
  36. /* socket_bind passing wrong parameters */
  37. ret = pico_socket_bind(NULL, &inaddr_link, &port_be);
  38. fail_if(ret == 0, "socket> tcp socket bound wrong parameter");
  39. ret = pico_socket_bind(sk_tcp, NULL, &port_be);
  40. fail_if(ret == 0, "socket> tcp socket bound wrong parameter");
  41. ret = pico_socket_bind(sk_tcp, &inaddr_link, NULL);
  42. fail_if(ret == 0, "socket> tcp socket bound wrong parameter");
  43. /* socket_getname passing wrong parameters */
  44. ret = pico_socket_getname(NULL, &inaddr_link, &port_be, &proto);
  45. fail_if(ret == 0, "socket> tcp socket getname with wrong parameter");
  46. ret = pico_socket_getname(sk_tcp, NULL, &port_be, &proto);
  47. fail_if(ret == 0, "socket> tcp socket getname with wrong parameter");
  48. ret = pico_socket_getname(sk_tcp, &inaddr_link, NULL, &proto);
  49. fail_if(ret == 0, "socket> tcp socket getname with wrong parameter");
  50. ret = pico_socket_getname(sk_tcp, &inaddr_link, &port_be, NULL);
  51. fail_if(ret == 0, "socket> tcp socket getname with wrong parameter");
  52. /* socket_bind passing correct parameters */
  53. ret = pico_socket_bind(sk_tcp, &inaddr_link, &port_be);
  54. fail_if(ret < 0, "socket> tcp socket bind failed");
  55. sk_udp = pico_socket_open(PICO_PROTO_IPV4, PICO_PROTO_UDP, NULL);
  56. fail_if(sk_udp == NULL, "socket> udp socket open failed");
  57. port_be = short_be(5555);
  58. ret = pico_socket_bind(sk_udp, &inaddr_link, &port_be);
  59. fail_if(ret < 0, "socket> udp socket bind failed");
  60. ret = pico_socket_getname(sk_udp, &inaddr_got, &port_got, &proto);
  61. fail_if(ret < 0, "socket> udp socket getname failed");
  62. fail_if(inaddr_got.addr != inaddr_link.addr, "Getname: Address is different");
  63. fail_if(port_be != port_got, "Getname: Port is different");
  64. fail_if(proto != PICO_PROTO_IPV4, "Getname: proto is wrong");
  65. /* socket_close passing wrong parameter */
  66. ret = pico_socket_close(NULL);
  67. fail_if(ret == 0, "Error socket close with wrong parameters");
  68. /* socket_connect passing wrong parameters */
  69. ret = pico_socket_connect(sk_udp, NULL, port_be);
  70. fail_if(ret == 0, "Error socket connect with wrong parameters");
  71. ret = pico_socket_connect(NULL, &inaddr_dst, port_be);
  72. fail_if(ret == 0, "Error socket connect with wrong parameters");
  73. /* socket_connect passing correct parameters */
  74. ret = pico_socket_connect(sk_udp, &inaddr_dst, port_be);
  75. fail_if(ret < 0, "Error socket connect");
  76. ret = pico_socket_connect(sk_tcp, &inaddr_dst, port_be);
  77. fail_if(ret < 0, "Error socket connect");
  78. /* testing listening socket */
  79. sl = pico_socket_open(PICO_PROTO_IPV4, PICO_PROTO_TCP, NULL);
  80. fail_if(sl == NULL, "socket> tcp socket open failed");
  81. port_be = short_be(6666);
  82. ret = pico_socket_bind(sl, &inaddr_link, &port_be);
  83. fail_if(ret < 0, "socket> tcp socket bind failed");
  84. /* socket_listen passing wrong parameters */
  85. ret = pico_socket_listen(sl, 0);
  86. fail_if(ret == 0, "Error socket tcp socket listen done, wrong parameter");
  87. ret = pico_socket_listen(NULL, 10);
  88. fail_if(ret == 0, "Error socket tcp socket listen done, wrong parameter");
  89. /* socket_listen passing correct parameters */
  90. ret = pico_socket_listen(sl, 10);
  91. fail_if(ret < 0, "socket> tcp socket listen failed: %s", strerror(pico_err));
  92. /* socket_accept passing wrong parameters */
  93. sa = pico_socket_accept(sl, &orig, NULL);
  94. fail_if(sa != NULL, "Error socket tcp socket accept wrong argument");
  95. sa = pico_socket_accept(sl, NULL, &porta);
  96. fail_if(sa != NULL, "Error socket tcp socket accept wrong argument");
  97. /* socket_accept passing correct parameters */
  98. sa = pico_socket_accept(sl, &orig, &porta);
  99. fail_if(sa == NULL && pico_err != PICO_ERR_EAGAIN, "socket> tcp socket accept failed: %s", strerror(pico_err));
  100. ret = pico_socket_close(sl);
  101. fail_if(ret < 0, "socket> tcp socket close failed: %s\n", strerror(pico_err));
  102. /* testing socket read/write */
  103. /* socket_write passing wrong parameters */
  104. ret = pico_socket_write(NULL, (void *)buf, sizeof(buf));
  105. fail_if(ret == 0, "Error socket write succeeded, wrong argument\n");
  106. ret = pico_socket_write(sk_tcp, NULL, sizeof(buf));
  107. fail_if(ret == 0, "Error socket write succeeded, wrong argument\n");
  108. ret = pico_socket_write(sk_tcp, (void *)buf, 0);
  109. fail_if(ret > 0, "Error socket write succeeded, wrong argument\n");
  110. /* socket_write passing correct parameters */
  111. ret = pico_socket_write(sk_tcp, (void *)buf, sizeof(buf));
  112. fail_if(ret < 0, "socket> tcp socket write failed: %s\n", strerror(pico_err));
  113. /* socket_read passing wrong parameters */
  114. ret = pico_socket_read(NULL, (void *)buf, sizeof(buf));
  115. fail_if(ret == 0, "Error socket read succeeded, wrong argument\n");
  116. ret = pico_socket_read(sk_tcp, NULL, sizeof(buf));
  117. fail_if(ret == 0, "Error socket read succeeded, wrong argument\n");
  118. ret = pico_socket_read(sk_tcp, (void *)buf, 0);
  119. fail_if(ret > 0, "Error socket read succeeded, wrong argument\n");
  120. /* socket_read passing correct parameters */
  121. ret = pico_socket_read(sk_tcp, (void *)buf, sizeof(buf));
  122. fail_if(ret < 0, "socket> tcp socket read failed, ret = %d: %s\n", ret, strerror(pico_err)); /* tcp_recv returns 0 when no frame !? */
  123. /* send/recv */
  124. /* socket_send passing wrong parameters */
  125. ret = pico_socket_send(NULL, (void *)buf, sizeof(buf));
  126. fail_if(ret == 0, "Error socket send succeeded, wrong argument\n");
  127. ret = pico_socket_send(sk_tcp, NULL, sizeof(buf));
  128. fail_if(ret == 0, "Error socket send succeeded, wrong argument\n");
  129. ret = pico_socket_send(sk_tcp, (void *)buf, 0);
  130. fail_if(ret > 0, "Error socket send succeeded, wrong argument\n");
  131. /* socket_write passing correct parameters */
  132. ret = pico_socket_send(sk_tcp, (void *)buf, sizeof(buf));
  133. fail_if(ret <= 0, "socket> tcp socket send failed: %s\n", strerror(pico_err));
  134. /* socket_recv passing wrong parameters */
  135. ret = pico_socket_recv(NULL, (void *)buf, sizeof(buf));
  136. fail_if(ret == 0, "Error socket recv succeeded, wrong argument\n");
  137. ret = pico_socket_recv(sk_tcp, NULL, sizeof(buf));
  138. fail_if(ret == 0, "Error socket recv succeeded, wrong argument\n");
  139. ret = pico_socket_recv(sk_tcp, (void *)buf, 0);
  140. fail_if(ret > 0, "Error socket recv succeeded, wrong argument\n");
  141. /* socket_recv passing correct parameters */
  142. ret = pico_socket_recv(sk_tcp, (void *)buf, sizeof(buf));
  143. fail_if(ret < 0, "socket> tcp socket recv failed, ret = %d: %s\n", ret, strerror(pico_err)); /* tcp_recv returns 0 when no frame !? */
  144. /* sendto/recvfrom */
  145. /* socket_sendto passing wrong parameters */
  146. ret = pico_socket_sendto(NULL, (void *)buf, sizeof(buf), &inaddr_dst, port_be);
  147. fail_if(ret >= 0, "Error socket sendto succeeded, wrong argument\n");
  148. ret = pico_socket_sendto(sk_tcp, NULL, sizeof(buf), &inaddr_dst, port_be);
  149. fail_if(ret >= 0, "Error socket sendto succeeded, wrong argument\n");
  150. ret = pico_socket_sendto(sk_tcp, (void *)buf, 0, &inaddr_dst, port_be);
  151. fail_if(ret > 0, "Error socket sendto succeeded, wrong argument\n");
  152. ret = pico_socket_sendto(sk_tcp, (void *)buf, sizeof(buf), NULL, port_be);
  153. fail_if(ret >= 0, "Error socket sendto succeeded, wrong argument\n");
  154. ret = pico_socket_sendto(sk_tcp, (void *)buf, sizeof(buf), &inaddr_dst, -120);
  155. fail_if(ret >= 0, "Error socket sendto succeeded, wrong argument\n");
  156. /* socket_write passing correct parameters */
  157. ret = pico_socket_sendto(sk_tcp, (void *)buf, sizeof(buf), &inaddr_dst, short_be(5555));
  158. fail_if(ret <= 0, "socket> udp socket sendto failed, ret = %d: %s\n", ret, strerror(pico_err));
  159. /* socket_recvfrom passing wrong parameters */
  160. ret = pico_socket_recvfrom(NULL, (void *)buf, sizeof(buf), &orig, &porta);
  161. fail_if(ret >= 0, "Error socket recvfrom succeeded, wrong argument\n");
  162. ret = pico_socket_recvfrom(sk_tcp, NULL, sizeof(buf), &orig, &porta);
  163. fail_if(ret >= 0, "Error socket recvfrom succeeded, wrong argument\n");
  164. ret = pico_socket_recvfrom(sk_tcp, (void *)buf, 0, &orig, &porta);
  165. fail_if(ret > 0, "Error socket recvfrom succeeded, wrong argument\n");
  166. ret = pico_socket_recvfrom(sk_tcp, (void *)buf, sizeof(buf), NULL, &porta);
  167. fail_if(ret > 0, "Error socket recvfrom succeeded, wrong argument\n");
  168. ret = pico_socket_recvfrom(sk_tcp, (void *)buf, sizeof(buf), &orig, NULL);
  169. fail_if(ret > 0, "Error socket recvfrom succeeded, wrong argument\n");
  170. /* socket_recvfrom passing correct parameters */
  171. ret = pico_socket_recvfrom(sk_tcp, (void *)buf, sizeof(buf), &orig, &porta);
  172. fail_if(ret != 0, "socket> tcp socket recvfrom failed, ret = %d: %s\n", ret, strerror(pico_err)); /* tcp_recv returns -1 when no frame !? */
  173. /* testing socket read/write */
  174. /* socket_write passing wrong parameters */
  175. ret = pico_socket_write(NULL, (void *)buf, sizeof(buf));
  176. fail_if(ret == 0, "Error socket write succeeded, wrong argument\n");
  177. ret = pico_socket_write(sk_udp, NULL, sizeof(buf));
  178. fail_if(ret == 0, "Error socket write succeeded, wrong argument\n");
  179. ret = pico_socket_write(sk_udp, (void *)buf, 0);
  180. fail_if(ret > 0, "Error socket write succeeded, wrong argument\n");
  181. /* socket_write passing correct parameters */
  182. ret = pico_socket_write(sk_udp, (void *)buf, sizeof(buf));
  183. fail_if(ret < 0, "socket> tcp socket write failed: %s\n", strerror(pico_err));
  184. /* socket_read passing wrong parameters */
  185. ret = pico_socket_read(NULL, (void *)buf, sizeof(buf));
  186. fail_if(ret == 0, "Error socket read succeeded, wrong argument\n");
  187. ret = pico_socket_read(sk_udp, NULL, sizeof(buf));
  188. fail_if(ret == 0, "Error socket read succeeded, wrong argument\n");
  189. ret = pico_socket_read(sk_udp, (void *)buf, 0);
  190. fail_if(ret > 0, "Error socket read succeeded, wrong argument\n");
  191. /* socket_read passing correct parameters */
  192. ret = pico_socket_read(sk_udp, (void *)buf, sizeof(buf));
  193. fail_if(ret != 0, "socket> udp socket read failed, ret = %d: %s\n", ret, strerror(pico_err));
  194. /* send/recv */
  195. /* socket_send passing wrong parameters */
  196. ret = pico_socket_send(NULL, (void *)buf, sizeof(buf));
  197. fail_if(ret == 0, "Error socket send succeeded, wrong argument\n");
  198. ret = pico_socket_send(sk_udp, NULL, sizeof(buf));
  199. fail_if(ret == 0, "Error socket send succeeded, wrong argument\n");
  200. ret = pico_socket_send(sk_udp, (void *)buf, 0);
  201. fail_if(ret > 0, "Error socket send succeeded, wrong argument\n");
  202. /* socket_write passing correct parameters */
  203. ret = pico_socket_send(sk_udp, (void *)buf, sizeof(buf));
  204. fail_if(ret <= 0, "socket> tcp socket send failed: %s\n", strerror(pico_err));
  205. /* socket_recv passing wrong parameters */
  206. ret = pico_socket_recv(NULL, (void *)buf, sizeof(buf));
  207. fail_if(ret == 0, "Error socket recv succeeded, wrong argument\n");
  208. ret = pico_socket_recv(sk_udp, NULL, sizeof(buf));
  209. fail_if(ret == 0, "Error socket recv succeeded, wrong argument\n");
  210. ret = pico_socket_recv(sk_udp, (void *)buf, 0);
  211. fail_if(ret > 0, "Error socket recv succeeded, wrong argument\n");
  212. /* socket_recv passing correct parameters */
  213. ret = pico_socket_recv(sk_udp, (void *)buf, sizeof(buf));
  214. fail_if(ret != 0, "socket> udp socket recv failed, ret = %d: %s\n", ret, strerror(pico_err));
  215. /* sendto/recvfrom */
  216. /* socket_sendto passing wrong parameters */
  217. ret = pico_socket_sendto(NULL, (void *)buf, sizeof(buf), &inaddr_dst, port_be);
  218. fail_if(ret >= 0, "Error socket sendto succeeded, wrong argument\n");
  219. ret = pico_socket_sendto(sk_udp, NULL, sizeof(buf), &inaddr_dst, port_be);
  220. fail_if(ret >= 0, "Error socket sendto succeeded, wrong argument\n");
  221. ret = pico_socket_sendto(sk_udp, (void *)buf, 0, &inaddr_dst, port_be);
  222. fail_if(ret > 0, "Error socket sendto succeeded, wrong argument\n");
  223. ret = pico_socket_sendto(sk_udp, (void *)buf, sizeof(buf), NULL, port_be);
  224. fail_if(ret >= 0, "Error socket sendto succeeded, wrong argument\n");
  225. ret = pico_socket_sendto(sk_udp, (void *)buf, sizeof(buf), &inaddr_dst, -120);
  226. fail_if(ret >= 0, "Error socket sendto succeeded, wrong argument\n");
  227. /* socket_write passing correct parameters */
  228. ret = pico_socket_sendto(sk_udp, (void *)buf, sizeof(buf), &inaddr_dst, short_be(5555));
  229. fail_if(ret <= 0, "socket> udp socket sendto failed, ret = %d: %s\n", ret, strerror(pico_err));
  230. /* socket_recvfrom passing wrong parameters */
  231. ret = pico_socket_recvfrom(NULL, (void *)buf, sizeof(buf), &orig, &porta);
  232. fail_if(ret >= 0, "Error socket recvfrom succeeded, wrong argument\n");
  233. ret = pico_socket_recvfrom(sk_udp, NULL, sizeof(buf), &orig, &porta);
  234. fail_if(ret >= 0, "Error socket recvfrom succeeded, wrong argument\n");
  235. /* socket_recvfrom passing correct parameters */
  236. ret = pico_socket_recvfrom(sk_udp, (void *)buf, 0, &orig, &porta);
  237. fail_if(ret != 0, "socket> udp socket recvfrom failed, ret = %d: %s\n", ret, strerror(pico_err));
  238. ret = pico_socket_recvfrom(sk_udp, (void *)buf, sizeof(buf), &orig, &porta);
  239. fail_if(ret != 0, "socket> udp socket recvfrom failed, ret = %d: %s\n", ret, strerror(pico_err));
  240. /* temporary fix, until Nagle problems are analyzed and fixed */
  241. {
  242. nodelay = 0;
  243. ret = pico_socket_setoption(sk_tcp, PICO_TCP_NODELAY, &nodelay);
  244. }
  245. /* setoption/getoption */
  246. ret = pico_socket_getoption(sk_tcp, PICO_TCP_NODELAY, &getnodelay);
  247. fail_if(ret < 0, "socket> socket_getoption: supported PICO_TCP_NODELAY failed (err = %s)\n", strerror(pico_err));
  248. fail_if(getnodelay != 0, "socket> socket_setoption: default PICO_TCP_NODELAY != 0 (nagle disabled by default)\n");
  249. nodelay = 1;
  250. ret = pico_socket_setoption(sk_tcp, PICO_TCP_NODELAY, &nodelay);
  251. fail_if(ret < 0, "socket> socket_setoption: supported PICO_TCP_NODELAY failed\n");
  252. ret = pico_socket_getoption(sk_tcp, PICO_TCP_NODELAY, &getnodelay);
  253. fail_if(ret < 0, "socket> socket_getoption: supported PICO_TCP_NODELAY failed\n");
  254. fail_if(getnodelay == 0, "socket> socket_setoption: PICO_TCP_NODELAY is off (expected: on!)\n");
  255. nodelay = 0;
  256. ret = pico_socket_setoption(sk_tcp, PICO_TCP_NODELAY, &nodelay);
  257. fail_if(ret < 0, "socket> socket_setoption: supported PICO_TCP_NODELAY failed\n");
  258. ret = pico_socket_getoption(sk_tcp, PICO_TCP_NODELAY, &getnodelay);
  259. fail_if(ret < 0, "socket> socket_getoption: supported PICO_TCP_NODELAY failed\n");
  260. fail_if(getnodelay != 0, "socket> socket_setoption: PICO_TCP_NODELAY is on (expected: off!)\n");
  261. /* Set/get recv buffer (TCP) */
  262. ret = pico_socket_getoption(sk_tcp, PICO_SOCKET_OPT_RCVBUF, &getsocket_buffer);
  263. fail_if(ret < 0, "socket> socket_getoption: supported PICO_SOCKET_OPT_RCVBUF failed\n");
  264. fail_if(getsocket_buffer != PICO_DEFAULT_SOCKETQ,
  265. "socket> socket_setoption: default PICO_SOCKET_OPT_SNDBUF != DEFAULT\n");
  266. socket_buffer = PICO_DEFAULT_SOCKETQ;
  267. ret = pico_socket_setoption(sk_tcp, PICO_SOCKET_OPT_RCVBUF, &socket_buffer);
  268. fail_if(ret < 0, "socket> socket_setoption: supported PICO_SOCKET_OPT_RCVBUF failed\n");
  269. ret = pico_socket_getoption(sk_tcp, PICO_SOCKET_OPT_RCVBUF, &getsocket_buffer);
  270. fail_if(ret < 0, "socket> socket_getoption: supported PICO_SOCKET_OPT_RCVBUF failed\n");
  271. fail_if(getsocket_buffer != socket_buffer, "UDP socket> socket_setoption: PICO_SOCKET_OPT_RCVBUF is != than expected\n");
  272. socket_buffer = 2 * PICO_DEFAULT_SOCKETQ;
  273. ret = pico_socket_setoption(sk_tcp, PICO_SOCKET_OPT_RCVBUF, &socket_buffer);
  274. fail_if(ret < 0, "socket> socket_setoption: supported PICO_SOCKET_OPT_RCVBUF failed\n");
  275. ret = pico_socket_getoption(sk_tcp, PICO_SOCKET_OPT_RCVBUF, &getsocket_buffer);
  276. fail_if(ret < 0, "socket> socket_getoption: supported PICO_SOCKET_OPT_RCVBUF failed\n");
  277. fail_if(getsocket_buffer != socket_buffer, "UDP socket> socket_setoption: PICO_SOCKET_OPT_RCVBUF is != than expected\n");
  278. /* Set/get send buffer (TCP) */
  279. ret = pico_socket_getoption(sk_tcp, PICO_SOCKET_OPT_SNDBUF, &getsocket_buffer);
  280. fail_if(ret < 0, "socket> socket_getoption: supported PICO_SOCKET_OPT_SNDBUF failed\n");
  281. fail_if(getsocket_buffer != PICO_DEFAULT_SOCKETQ,
  282. "socket> socket_setoption: default PICO_SOCKET_OPT_SNDBUF != DEFAULT got: %d exp: %d\n", getsocket_buffer, PICO_DEFAULT_SOCKETQ);
  283. socket_buffer = PICO_DEFAULT_SOCKETQ;
  284. ret = pico_socket_setoption(sk_tcp, PICO_SOCKET_OPT_SNDBUF, &socket_buffer);
  285. fail_if(ret < 0, "socket> socket_setoption: supported PICO_SOCKET_OPT_SNDBUF failed\n");
  286. ret = pico_socket_getoption(sk_tcp, PICO_SOCKET_OPT_SNDBUF, &getsocket_buffer);
  287. fail_if(ret < 0, "socket> socket_getoption: supported PICO_SOCKET_OPT_SNDBUF failed\n");
  288. fail_if(getsocket_buffer != socket_buffer, "UDP socket> socket_setoption: PICO_SOCKET_OPT_SNDBUF is != than expected\n");
  289. socket_buffer = 2 * PICO_DEFAULT_SOCKETQ;
  290. ret = pico_socket_setoption(sk_tcp, PICO_SOCKET_OPT_SNDBUF, &socket_buffer);
  291. fail_if(ret < 0, "socket> socket_setoption: supported PICO_SOCKET_OPT_SNDBUF failed\n");
  292. ret = pico_socket_getoption(sk_tcp, PICO_SOCKET_OPT_SNDBUF, &getsocket_buffer);
  293. fail_if(ret < 0, "socket> socket_getoption: supported PICO_SOCKET_OPT_SNDBUF failed\n");
  294. fail_if(getsocket_buffer != socket_buffer, "UDP socket> socket_setoption: PICO_SOCKET_OPT_SNDBUF is != than expected\n");
  295. /* Set/get recv buffer (UDP) */
  296. ret = pico_socket_getoption(sk_udp, PICO_SOCKET_OPT_RCVBUF, &getsocket_buffer);
  297. fail_if(ret < 0, "socket> socket_getoption: supported PICO_SOCKET_OPT_RCVBUF failed\n");
  298. fail_if(getsocket_buffer != PICO_DEFAULT_SOCKETQ,
  299. "socket> socket_setoption: default PICO_SOCKET_OPT_SNDBUF != DEFAULT\n");
  300. socket_buffer = PICO_DEFAULT_SOCKETQ;
  301. ret = pico_socket_setoption(sk_udp, PICO_SOCKET_OPT_RCVBUF, &socket_buffer);
  302. fail_if(ret < 0, "socket> socket_setoption: supported PICO_SOCKET_OPT_RCVBUF failed\n");
  303. ret = pico_socket_getoption(sk_udp, PICO_SOCKET_OPT_RCVBUF, &getsocket_buffer);
  304. fail_if(ret < 0, "socket> socket_getoption: supported PICO_SOCKET_OPT_RCVBUF failed\n");
  305. fail_if(getsocket_buffer != socket_buffer, "UDP socket> socket_setoption: PICO_SOCKET_OPT_RCVBUF is != than expected\n");
  306. socket_buffer = 2 * PICO_DEFAULT_SOCKETQ;
  307. ret = pico_socket_setoption(sk_udp, PICO_SOCKET_OPT_RCVBUF, &socket_buffer);
  308. fail_if(ret < 0, "socket> socket_setoption: supported PICO_SOCKET_OPT_RCVBUF failed\n");
  309. ret = pico_socket_getoption(sk_udp, PICO_SOCKET_OPT_RCVBUF, &getsocket_buffer);
  310. fail_if(ret < 0, "socket> socket_getoption: supported PICO_SOCKET_OPT_RCVBUF failed\n");
  311. fail_if(getsocket_buffer != socket_buffer, "UDP socket> socket_setoption: PICO_SOCKET_OPT_RCVBUF is != than expected\n");
  312. /* Set/get send buffer (UDP) */
  313. ret = pico_socket_getoption(sk_udp, PICO_SOCKET_OPT_SNDBUF, &getsocket_buffer);
  314. fail_if(ret < 0, "socket> socket_getoption: supported PICO_SOCKET_OPT_SNDBUF failed\n");
  315. fail_if(getsocket_buffer != PICO_DEFAULT_SOCKETQ,
  316. "socket> socket_setoption: default PICO_SOCKET_OPT_SNDBUF != DEFAULT\n");
  317. socket_buffer = PICO_DEFAULT_SOCKETQ;
  318. ret = pico_socket_setoption(sk_udp, PICO_SOCKET_OPT_SNDBUF, &socket_buffer);
  319. fail_if(ret < 0, "socket> socket_setoption: supported PICO_SOCKET_OPT_SNDBUF failed\n");
  320. ret = pico_socket_getoption(sk_udp, PICO_SOCKET_OPT_SNDBUF, &getsocket_buffer);
  321. fail_if(ret < 0, "socket> socket_getoption: supported PICO_SOCKET_OPT_SNDBUF failed\n");
  322. fail_if(getsocket_buffer != socket_buffer, "UDP socket> socket_setoption: PICO_SOCKET_OPT_SNDBUF is != than expected\n");
  323. socket_buffer = 2 * PICO_DEFAULT_SOCKETQ;
  324. ret = pico_socket_setoption(sk_udp, PICO_SOCKET_OPT_SNDBUF, &socket_buffer);
  325. fail_if(ret < 0, "socket> socket_setoption: supported PICO_SOCKET_OPT_SNDBUF failed\n");
  326. ret = pico_socket_getoption(sk_udp, PICO_SOCKET_OPT_SNDBUF, &getsocket_buffer);
  327. fail_if(ret < 0, "socket> socket_getoption: supported PICO_SOCKET_OPT_SNDBUF failed\n");
  328. fail_if(getsocket_buffer != socket_buffer, "UDP socket> socket_setoption: PICO_SOCKET_OPT_SNDBUF is != than expected\n");
  329. /* Close sockets, eventually. */
  330. ret = pico_socket_close(sk_tcp);
  331. fail_if(ret < 0, "socket> tcp socket close failed: %s\n", strerror(pico_err));
  332. ret = pico_socket_close(sk_udp);
  333. fail_if(ret < 0, "socket> udp socket close failed: %s\n", strerror(pico_err));
  334. }
  335. END_TEST
  336. #ifdef PICO_SUPPORT_CRC_FAULTY_UNIT_TEST
  337. START_TEST (test_crc_check)
  338. {
  339. uint8_t buffer[64] = {
  340. 0x45, 0x00, 0x00, 0x40, /* start of IP hdr */
  341. 0x91, 0xc3, 0x40, 0x00,
  342. 0x40, 0x11, 0x24, 0xcf, /* last 2 bytes are CRC */
  343. 0xc0, 0xa8, 0x01, 0x66,
  344. 0xc0, 0xa8, 0x01, 0x64, /* end of IP hdr */
  345. 0x15, 0xb3, 0x1F, 0x90, /* start of UDP/TCP hdr */
  346. 0x00, 0x2c, 0x27, 0x22, /* end of UDP hdr */
  347. 0x00, 0x00, 0x00, 0x00,
  348. 0x00, 0x00, 0x00, 0x00,
  349. 0x00, 0x0b, 0x00, 0x00,
  350. 0x00, 0x00, 0x00, 0x00,
  351. 0x00, 0x00, 0x00, 0x00,
  352. 0x00, 0x00, 0x00, 0x00, /* end of TCP hdr */
  353. 0x01, 0x23, 0x45, 0x67, /* start of data */
  354. 0x89, 0xab, 0xcd, 0xef,
  355. 0xc0, 0xca, 0xc0, 0x1a
  356. };
  357. struct pico_frame *f = NULL;
  358. struct pico_ipv4_hdr *hdr = (struct pico_ipv4_hdr *) buffer;
  359. struct pico_udp_hdr *udp_hdr = NULL;
  360. struct pico_tcp_hdr *tcp_hdr = NULL;
  361. uint32_t *f_usage_count = NULL;
  362. uint8_t *f_buffer = NULL;
  363. int ret = -1;
  364. printf("START CRC TEST\n");
  365. pico_stack_init();
  366. /* IPv4 CRC unit tests */
  367. /* Allocated memory will not be freed when pico_ipv4_crc_check fails */
  368. f = calloc(1, sizeof(struct pico_frame));
  369. f_usage_count = calloc(1, sizeof(uint32_t));
  370. f_buffer = calloc(1, sizeof(uint8_t));
  371. f->net_hdr = buffer;
  372. f->net_len = PICO_SIZE_IP4HDR;
  373. f->transport_hdr = buffer + PICO_SIZE_IP4HDR;
  374. f->transport_len = sizeof(buffer) - PICO_SIZE_IP4HDR;
  375. f->usage_count = f_usage_count;
  376. f->buffer = f_buffer;
  377. *(f->usage_count) = 512;
  378. hdr->crc = 0;
  379. printf(">>>>>>>>>>>>>>>>>>>>> CRC VALUE = %X\n", pico_checksum(hdr, PICO_SIZE_IP4HDR));
  380. hdr->crc = short_be(0x24CF); /* Make check pass */
  381. ret = pico_ipv4_crc_check(f);
  382. fail_if(ret == 0, "correct IPv4 checksum got rejected\n");
  383. hdr->crc = short_be(0x8899); /* Make check fail */
  384. ret = pico_ipv4_crc_check(f);
  385. fail_if(ret == 1, "incorrect IPv4 checksum got accepted\n");
  386. /* UDP CRC unit tests */
  387. /* Allocated memory will be freed when pico_transport_crc_check fails */
  388. f = calloc(1, sizeof(struct pico_frame));
  389. f_usage_count = calloc(1, sizeof(uint32_t));
  390. f_buffer = calloc(1, sizeof(uint8_t));
  391. f->net_hdr = buffer;
  392. f->transport_hdr = buffer + PICO_SIZE_IP4HDR;
  393. f->transport_len = sizeof(buffer) - PICO_SIZE_IP4HDR;
  394. f->usage_count = f_usage_count;
  395. f->buffer = f_buffer;
  396. *(f->usage_count) = 1;
  397. hdr->proto = 0x11; /* UDP */
  398. hdr->crc = short_be(0x24cf); /* Set IPv4 CRC correct */
  399. udp_hdr = (struct pico_udp_hdr *) f->transport_hdr;
  400. /* udp_hdr->crc = 0; */
  401. /* printf(">>>>>>>>>>>>>>>>>>>>> UDP CRC VALUE = %X\n", pico_udp_checksum_ipv4(f)); */
  402. ret = pico_transport_crc_check(f);
  403. fail_if(ret == 0, "correct UDP checksum got rejected\n");
  404. udp_hdr->crc = 0;
  405. ret = pico_transport_crc_check(f);
  406. fail_if(ret == 0, "UDP checksum of 0 did not get ignored\n");
  407. udp_hdr->crc = short_be(0x8899); /* Make check fail */
  408. ret = pico_transport_crc_check(f);
  409. fail_if(ret == 1, "incorrect UDP checksum got accepted\n");
  410. /* TCP CRC unit tests */
  411. /* Allocated memory will be freed when pico_transport_crc_check fails */
  412. f = calloc(1, sizeof(struct pico_frame));
  413. f_usage_count = calloc(1, sizeof(uint32_t));
  414. f_buffer = calloc(1, sizeof(uint8_t));
  415. f->net_hdr = buffer;
  416. f->transport_hdr = buffer + PICO_SIZE_IP4HDR;
  417. f->transport_len = sizeof(buffer) - PICO_SIZE_IP4HDR;
  418. f->usage_count = f_usage_count;
  419. f->buffer = f_buffer;
  420. *(f->usage_count) = 1;
  421. hdr->proto = 0x06; /* TCP */
  422. hdr->crc = short_be(0x24cf); /* Set IPv4 CRC correct */
  423. tcp_hdr = (struct pico_tcp_hdr *) f->transport_hdr;
  424. tcp_hdr->seq = long_be(0x002c2722); /* Set sequence number correct */
  425. /* tcp_hdr = 0; */
  426. /* printf(">>>>>>>>>>>>>>>>>>>>> TCP CRC VALUE = %X\n", pico_tcp_checksum_ipv4(f)); */
  427. tcp_hdr->crc = short_be(0x0016); /* Set correct TCP CRC */
  428. ret = pico_transport_crc_check(f);
  429. fail_if(ret == 0, "correct TCP checksum got rejected\n");
  430. tcp_hdr->crc = short_be(0x8899); /* Make check fail */
  431. ret = pico_transport_crc_check(f);
  432. fail_if(ret == 1, "incorrect TCP checksum got accepted\n");
  433. }
  434. END_TEST
  435. #endif