pal_socket_test.c

00001 /*
00002 * Copyright (c) 2016 ARM Limited. All rights reserved.
00003 * SPDX-License-Identifier: Apache-2.0
00004 * Licensed under the Apache License, Version 2.0 (the License); you may
00005 * not use this file except in compliance with the License.
00006 * You may obtain a copy of the License at
00007 *
00008 * http://www.apache.org/licenses/LICENSE-2.0
00009 *
00010 * Unless required by applicable law or agreed to in writing, software
00011 * distributed under the License is distributed on an AS IS BASIS, WITHOUT
00012 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00013 * See the License for the specific language governing permissions and
00014 * limitations under the License.
00015 */
00016 
00017 #include "pal.h"
00018 #include "pal_network.h"
00019 #include "pal_plat_network.h"
00020 #include "unity.h"
00021 #include "unity_fixture.h"
00022 #include "pal_test_utils.h"
00023 #include "pal_socket_test_utils.h"
00024 #include "string.h"
00025 
00026 
00027 
00028 TEST_GROUP(pal_socket);
00029 
00030 //sometimes you may want to get at local data in a module.
00031 //for example: If you plan to pass by reference, this could be useful
00032 //however, it should often be avoided
00033 //extern int Counter;
00034 
00035 #define PAL_NET_SUPPORT_LWIP 1
00036 #define PAL_NET_TEST_SERVER_NAME "e109180-lin.kfn.arm.com"
00037 #define PAL_NET_TEST_SERVER_IP   {10,45,48,190}
00038 #define PAL_NET_TEST_SERVER_IP_STRING   "10.45.48.190"
00039 #define PAL_NET_TEST_SERVER_HTTP_PORT 8686
00040 #define PAL_NET_TEST_SERVER_UDP_PORT 8383
00041 #define PAL_NET_TEST_INCOMING_PORT 8000
00042 
00043 void * g_networkInterface = NULL;
00044 
00045 
00046 static uint32_t s_callbackcounter = 0;
00047 
00048 void socketCallback()
00049 {
00050     s_callbackcounter++;
00051 }
00052 
00053 TEST_SETUP(pal_socket)
00054 {
00055     uint32_t index = 0;
00056     palStatus_t status = PAL_SUCCESS;
00057     static void * interfaceCTX = NULL;
00058     //This is run before EACH TEST
00059     if (!interfaceCTX)
00060     {
00061         status = pal_init();
00062         if (PAL_SUCCESS == status)
00063         {
00064             interfaceCTX = palTestGetNetWorkInterfaceContext();
00065             pal_registerNetworkInterface(interfaceCTX , &index);
00066             g_networkInterface = interfaceCTX;
00067         }
00068     }
00069 }
00070 
00071 TEST_TEAR_DOWN(pal_socket)
00072 {
00073 }
00074 
00075 #define PAL_TEST_BUFFER_SIZE 50
00076 
00077 TEST(pal_socket, socketUDPCreationOptionsTest)
00078 {
00079     palStatus_t result = PAL_SUCCESS;
00080     palSocket_t sock = 0;
00081     palSocket_t sock2 = 0;
00082     palSocket_t sock3 = 0;
00083     palSocket_t sock5 = 0;
00084     uint32_t numInterface = 0;
00085     palNetInterfaceInfo_t  interfaceInfo;
00086     uint32_t interfaceIndex = 0;
00087     uint32_t sockOptVal = 5000;
00088     uint32_t sockOptLen = sizeof(sockOptVal);
00089 
00090     TEST_PRINTF("start socket test\r\n");
00091 
00092     memset(&interfaceInfo,0,sizeof(interfaceInfo));
00093     // check that re-addignt he network interface returns the same index
00094     pal_registerNetworkInterface(g_networkInterface, &interfaceIndex);
00095     TEST_ASSERT_EQUAL(interfaceIndex, 0);
00096     pal_registerNetworkInterface(g_networkInterface, &interfaceIndex);
00097     TEST_ASSERT_EQUAL(interfaceIndex, 0);
00098 
00099     TEST_PRINTF("create sockets\r\n");
00100 
00101 
00102     //blocking
00103     result = pal_socket(PAL_AF_INET, PAL_SOCK_DGRAM, false, interfaceIndex, &sock);
00104     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00105     result = pal_socket(PAL_AF_INET, PAL_SOCK_DGRAM, false, interfaceIndex, &sock2);
00106     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00107     //non-blocking
00108     result = pal_socket(PAL_AF_INET, PAL_SOCK_DGRAM, true, interfaceIndex, &sock5);
00109     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00110 
00111     result = pal_asynchronousSocket(PAL_AF_INET, PAL_SOCK_STREAM, false, interfaceIndex, socketCallback, &sock3);
00112     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00113 
00114 
00115     result = pal_getNumberOfNetInterfaces(&numInterface);
00116     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00117     TEST_ASSERT_EQUAL(numInterface, 1);
00118 
00119     result = pal_getNetInterfaceInfo(0, &interfaceInfo);
00120     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00121     TEST_PRINTF("interface addr: %d %d %d %d \r\n", interfaceInfo.address.addressData[2], interfaceInfo.address.addressData[3], interfaceInfo.address.addressData[4], interfaceInfo.address.addressData[5]);
00122 
00123     
00124     result = pal_setSocketOptions(sock, PAL_SO_RCVTIMEO, &sockOptVal, sockOptLen);
00125     TEST_ASSERT_EQUAL(result, PAL_SUCCESS); 
00126 
00127     TEST_PRINTF("close sockets\r\n");
00128     
00129     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00130     result = pal_close(&sock);
00131     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00132     result = pal_close(&sock2);
00133     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00134     result = pal_close(&sock5);
00135     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00136     result = pal_close(&sock3);
00137     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00138 
00139     TEST_PRINTF("end\r\n");
00140  
00141 }
00142 
00143 
00144 TEST(pal_socket, basicTCPclinetSendRecieve)
00145 {
00146 
00147 
00148     palStatus_t result = PAL_SUCCESS;
00149     palSocket_t sock = 0;
00150     palSocketAddress_t address = { 0 };
00151     const char* message = "GET / HTTP/1.0\r\n\r\n";
00152     size_t sent = 0;
00153     char buffer[100] = { 0 };
00154     size_t read = 0;
00155     palSocketLength_t addrlen = 0;
00156 
00157     result = pal_socket(PAL_AF_INET, PAL_SOCK_STREAM, false, 0, &sock);
00158     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00159 
00160     result = pal_getAddressInfo(PAL_NET_TEST_SERVER_NAME, &address, &addrlen);
00161     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00162 
00163     result = pal_setSockAddrPort(&address, PAL_NET_TEST_SERVER_HTTP_PORT);
00164     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00165 
00166     result = pal_connect(sock, &address, 16);
00167     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00168     
00169     result = pal_send(sock, message, 45, &sent);
00170     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00171 
00172     result = pal_recv(sock, buffer, 99, &read);
00173     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00174     TEST_PRINTF(buffer);
00175 
00176     TEST_ASSERT(read >= 4);
00177     TEST_ASSERT(buffer[0] == 'H' && buffer[1] == 'T'&& buffer[2] == 'T' && buffer[3] == 'P');
00178     pal_close(&sock);
00179 
00180     TEST_PRINTF("test Done");
00181 
00182 }
00183 
00184 TEST(pal_socket, basicUDPclinetSendRecieve)
00185 {
00186 
00187     palStatus_t result = PAL_SUCCESS;
00188     palSocket_t sock = 0;
00189     palSocketAddress_t address = { 0 };
00190     palSocketAddress_t address2 = { 0 };
00191     uint8_t buffer[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
00192     size_t sent = 0;
00193     size_t read = 0;
00194     palSocketLength_t addrlen = 0;
00195 
00196     result = pal_socket(PAL_AF_INET, PAL_SOCK_DGRAM, false, 0, &sock);
00197     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00198 
00199     result = pal_getAddressInfo(PAL_NET_TEST_SERVER_NAME, &address, &addrlen);
00200     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00201     result = pal_setSockAddrPort(&address, PAL_NET_TEST_SERVER_UDP_PORT);
00202     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00203 
00204     TEST_PRINTF("udp send \r\n");
00205     result = pal_sendTo(sock, buffer, 10, &address, 16, &sent);
00206     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00207     TEST_ASSERT_EQUAL(sent, 10);
00208     result = pal_plat_receiveFrom(sock, buffer, 10, &address2, &addrlen, &read);
00209     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00210     TEST_ASSERT_EQUAL(read, 10);
00211     TEST_PRINTF("udp done \r\n");
00212     pal_close(&sock);
00213 }
00214 
00215 
00216 TEST(pal_socket, basicSocketScenario3)
00217 {
00218     palStatus_t result = PAL_SUCCESS;
00219     palSocket_t sock = 0;
00220     palSocketAddress_t address = { 0 };
00221     const char* message = "GET / HTTP/1.0\r\nHost:10.45.48.68:8000\r\n\r\n";
00222     size_t sent = 0;
00223     char buffer[100] = { 0 };
00224     size_t read = 0;
00225     s_callbackcounter = 0;
00226     palSocketLength_t addrlen = 0;
00227 
00228     result = pal_asynchronousSocket(PAL_AF_INET, PAL_SOCK_STREAM, false, 0, socketCallback, &sock);
00229     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00230 
00231     result = pal_getAddressInfo(PAL_NET_TEST_SERVER_NAME, &address, &addrlen);
00232     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00233 
00234     result = pal_setSockAddrPort(&address, PAL_NET_TEST_SERVER_HTTP_PORT);
00235     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00236 
00237     result = pal_connect(sock, &address, 16);
00238     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00239 
00240     result = pal_send(sock, message, 45, &sent);
00241     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00242 
00243     result = pal_recv(sock, buffer, 99, &read);
00244     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00245     TEST_PRINTF(buffer);
00246 
00247     TEST_ASSERT(read >= 4);
00248     TEST_ASSERT(buffer[0] == 'H' && buffer[1] == 'T'&& buffer[2] == 'T' && buffer[3] == 'P');
00249     TEST_ASSERT(s_callbackcounter > 0);
00250     TEST_PRINTF("callback counter %d \r\n", s_callbackcounter);
00251     pal_close(&sock);
00252 
00253     TEST_PRINTF("test Done");
00254 }
00255 
00256 TEST(pal_socket, basicSocketScenario4)
00257 {
00258     palStatus_t result = PAL_SUCCESS;
00259     palSocket_t sock = 0;
00260     palSocket_t sock2 = 0;
00261     palSocketAddress_t address = { 0 };
00262     const char* message = "GET / HTTP/1.0\r\n\r\n";
00263     size_t sent = 0;
00264     char buffer[100] = { 0 };
00265     size_t read = 0;
00266     palSocketLength_t addlen = 0;
00267     uint32_t numSockets = 0;
00268     palSocket_t socketsToCheck[PAL_NET_SOCKET_SELECT_MAX_SOCKETS] = { 0 };
00269     pal_timeVal_t tv = {0};
00270     uint8_t palSocketStatus[PAL_NET_SOCKET_SELECT_MAX_SOCKETS] = { 0 };
00271 
00272     result = pal_socket(PAL_AF_INET, PAL_SOCK_STREAM, false, 0, &sock);
00273     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00274 
00275     result = pal_socket(PAL_AF_INET, PAL_SOCK_STREAM, false, 0, &sock2);
00276     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00277 
00278     result = pal_getAddressInfo("www.w3.org", &address, &addlen);
00279     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00280     TEST_PRINTF("addr lookup: %d %d %d %d \r\n", address.addressData[2], address.addressData[3], address.addressData[4], address.addressData[5]);
00281 
00282     result = pal_setSockAddrPort(&address, 80);
00283     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00284 
00285     result = pal_connect(sock, &address, 16);
00286     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00287 
00288     result = pal_send(sock, message, 45, &sent);
00289     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00290 
00291     socketsToCheck[0] = sock;
00292     socketsToCheck[1] = sock2;
00293     tv.pal_tv_sec = 5;
00294     tv.pal_tv_usec = 1000;
00295     
00296     result = pal_plat_socketMiniSelect(socketsToCheck, 2, &tv, palSocketStatus, &numSockets);
00297     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00298     //TEST_ASSERT_EQUAL(numSockets, 1);
00299     //TEST_ASSERT(palSocketStatus[0] >= 0);
00300     
00301     result = pal_recv(sock, buffer, 99, &read);
00302     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00303     TEST_PRINTF(buffer);
00304 
00305     TEST_ASSERT(read >= 4);
00306     TEST_ASSERT(buffer[0] == 'H' && buffer[1] == 'T'&& buffer[2] == 'T' && buffer[3] == 'P');
00307 
00308     socketsToCheck[0] = sock2;
00309     socketsToCheck[1] = 0;
00310     tv.pal_tv_sec = 0;
00311     tv.pal_tv_usec = 20000;
00312     result = pal_plat_socketMiniSelect(socketsToCheck, 1, &tv, palSocketStatus, &numSockets);
00313     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00314     TEST_ASSERT_EQUAL(numSockets, 0);
00315     TEST_ASSERT(palSocketStatus[0] == 0);
00316     
00317     pal_close(&sock);
00318     pal_close(&sock2);
00319 
00320     TEST_PRINTF("test Done");
00321 
00322 }
00323 
00324 TEST(pal_socket, basicSocketScenario5)
00325 {
00326     palStatus_t result = PAL_SUCCESS;
00327     palSocket_t sock = 0;
00328     palSocket_t sock2 = 0;
00329     palSocket_t sock3 = 0;
00330 
00331     palSocketAddress_t address2 = { 0 };
00332 
00333     char buffer[100] = { 0 };
00334     const char* messageOut = "HTTP/1.0 200 OK";
00335     size_t sent = 0;
00336     size_t read = 0;
00337     palSocketLength_t addrlen = 16;
00338     palNetInterfaceInfo_t  interfaceInfo;
00339 
00340     memset(&interfaceInfo,0,sizeof(interfaceInfo));
00341 
00342 
00343     result = pal_socket(PAL_AF_INET, PAL_SOCK_STREAM_SERVER, false, 0, &sock);
00344     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00345 
00346     result = pal_socket(PAL_AF_INET, PAL_SOCK_STREAM, false, 0, &sock2);
00347     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00348     
00349     result = pal_getNetInterfaceInfo(0, &interfaceInfo);
00350     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00351 
00352     result = pal_setSockAddrPort(&(interfaceInfo.address), PAL_NET_TEST_INCOMING_PORT);
00353     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00354     
00355     result = pal_bind(sock, &(interfaceInfo.address), interfaceInfo.addressSize);
00356     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00357 
00358     result = pal_listen(sock, 10);
00359     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00360 
00361     TEST_PRINTF("waiting for connection:\r\n");
00362     result = pal_accept(sock, &address2, &addrlen, &sock2);
00363     TEST_PRINTF("after accept:\r\n");
00364     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00365 
00366 
00367     result = pal_recv(sock2, buffer, 99, &read);
00368     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00369     TEST_PRINTF(buffer);
00370 
00371     result = pal_send(sock2, messageOut, 15, &sent);
00372     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00373 
00374 
00375     result = pal_socket(PAL_AF_INET, PAL_SOCK_STREAM, false, 0, &sock3);
00376     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00377 
00378 
00379 
00380     pal_close(&sock2);
00381     pal_close(&sock3);
00382     pal_close(&sock);
00383     
00384     TEST_PRINTF("test Done");
00385 }
00386 
00387 
00388 TEST(pal_socket, tProvUDPTest)
00389 {
00390 
00391     palStatus_t result = PAL_SUCCESS;
00392     palSocket_t sock = 0;
00393     palSocketAddress_t address = { 0 };
00394     palSocketAddress_t address2 = { 0 };
00395     char buffer[100] = { 0 };
00396     const char* messageOut = "HTTP/1.0 200 OK";
00397     size_t sent = 0;
00398     size_t read = 0;
00399     palSocketLength_t addrlen = 16;
00400     palSocketLength_t addrlen2 = 16;
00401     int timeout = 10000;
00402     result = pal_socket(PAL_AF_INET, PAL_SOCK_DGRAM, false, 0, &sock);
00403     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00404 
00405     result = pal_getAddressInfo(PAL_NET_TEST_SERVER_IP_STRING, &address, &addrlen);
00406     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00407 
00408     result = pal_setSockAddrPort(&address, PAL_NET_TEST_SERVER_UDP_PORT);
00409     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00410 
00411     result = pal_setSocketOptions(sock, PAL_SO_SNDTIMEO, &timeout, sizeof(timeout));
00412     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00413 
00414     result = pal_sendTo(sock, messageOut, 16, &address, addrlen, &sent);
00415     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00416     TEST_ASSERT_EQUAL(sent, 16);
00417 
00418     result = pal_receiveFrom(sock, buffer, 100, NULL, NULL, &read);
00419     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00420     TEST_ASSERT_EQUAL(read, 16);
00421 
00422     timeout = 1;
00423     result = pal_setSocketOptions(sock, PAL_SO_RCVTIMEO, &timeout, sizeof(timeout));
00424     TEST_ASSERT_EQUAL(result, PAL_SUCCESS);
00425 
00426     result = pal_receiveFrom(sock, buffer, 100, &address2, &addrlen2, &read); //  should get timeout
00427     TEST_ASSERT_EQUAL(result, PAL_ERR_SOCKET_WOULD_BLOCK);
00428 }