/* BEGIN_FILE_HDR ******************************************************************************** * NOTICE * This software is the property of HiRain Technologies. Any information * contained in this doc should not be reproduced, or used, or disclosed * without the written authorization from HiRain Technologies. ******************************************************************************** * File Name : UT.c ******************************************************************************** * Project/Product : AUTOSAR 4.2 * Title : Testability Protocol and Service Primitives * Author : mingqing.tang ******************************************************************************** * Description : The core file of Testability Protocol and Service Primitives. * ******************************************************************************** * Limitations : only used for AUTOSAR 4.2 version * ******************************************************************************** * ******************************************************************************** * Revision History: * * Version Date Initials CR# Descriptions * --------- ---------- ------------- ---------- --------------- * 01.00.00 13/06/2018 mingqing.tang N/A Original * 01.00.01 30/07/2018 mingqing.tang N/A Add ICMP primitive * 01.00.02 03/07/2019 mingqing.tang N/A Add the callout * 01.00.03 25/07/2019 mingqing.tang N/A Add ConfigSocket * 01.00.04 19/08/2019 qiang.yang N/A Modify configuration parameters and UDP bugs * 01.00.05 22/08/2019 qiang.yang N/A Fix TC8 Test bug * 01.00.06 02/09/2019 mingqing.tang N/A Update primitive format to V1.2 ******************************************************************************** * END_FILE_HDR*/ /******************************************************************************* * Includes *******************************************************************************/ #include "UT.h" #include "UT_Cfg.h" #include "UT_Callout.h" /******************************************************************************* * Macro *******************************************************************************/ #define UT_UNUSED(dummy) ((void)(dummy)) #define UT_MIN(a, b) ((a) < (b)? (a): (b)) #define UT_STATE_UNINIT (0) #define UT_STATE_WAIT (1) #define UT_STATE_IDLE (2) #define UT_STATE_ACTIVE (3) #define UT_SET_STATE(ctx, sta) ((ctx)->State = (sta)) #define UT_SET_WAIT(ctx) UT_SET_STATE(ctx, UT_STATE_WAIT) #define UT_SET_IDLE(ctx) UT_SET_STATE(ctx, UT_STATE_IDLE) #define UT_SET_ACTIVE(ctx) UT_SET_STATE(ctx, UT_STATE_ACTIVE) #define UT_IS_STATE(ctx, sta) (((ctx)->State) == (sta)) #define UT_IS_WAIT(ctx) UT_IS_STATE(ctx, UT_STATE_WAIT) #define UT_IS_IDLE(ctx) UT_IS_STATE(ctx, UT_STATE_IDLE) #define UT_IS_ACTIVE(ctx) UT_IS_STATE(ctx, UT_STATE_ACTIVE) #define UT_IS_USABLE(ctx) (UT_IS_ACTIVE(ctx) || UT_IS_IDLE(ctx)) #define UT_INSTANCE_IDLE (0) #define UT_INSTANCE_ALLOCATED (1) #define UT_INSTANCE_TXONLY (2) #define UT_INSTANCE_RXONLY (3) #define UT_INSTANCE_SET_STATE(instance, sta) ((instance)->State = (sta)) #define UT_INSTANCE_SET_IDLE(instance) UT_INSTANCE_SET_STATE(instance, UT_INSTANCE_IDLE) #define UT_INSTANCE_SET_ALLOCATED(instance) UT_INSTANCE_SET_STATE(instance, UT_INSTANCE_ALLOCATED) #define UT_INSTANCE_SET_TXONLY(instance) UT_INSTANCE_SET_STATE(instance, UT_INSTANCE_TXONLY) #define UT_INSTANCE_SET_RXONLY(instance) UT_INSTANCE_SET_STATE(instance, UT_INSTANCE_RXONLY) #define UT_INSTANCE_IS_STATE(instance, sta) ((instance)->State == (sta)) #define UT_INSTANCE_IS_IDLE(instance) UT_INSTANCE_IS_STATE(instance, UT_INSTANCE_IDLE) #define UT_INSTANCE_IS_ALLOCATED(instance) UT_INSTANCE_IS_STATE(instance, UT_INSTANCE_ALLOCATED) #define UT_INSTANCE_IS_TXONLY(instance) UT_INSTANCE_IS_STATE(instance, UT_INSTANCE_TXONLY) #define UT_INSTANCE_IS_RXONLY(instance) UT_INSTANCE_IS_STATE(instance, UT_INSTANCE_RXONLY) #define UT_TEST_INSTANCE_MAX (UT_TEST_LISTEN_INSTANCE_MAX + UT_TEST_CONNECT_INSTANCE_MAX) #define UT_IS_VALID_CONNECT_INSTANCE(id) ((id) < UT_TEST_CONNECT_INSTANCE_MAX) #define UT_IS_VALID_LISTEN_INSTANCE(id) ((id) < UT_TEST_LISTEN_INSTANCE_MAX) #define UT_IS_TCP_INSTANCE(ctx, id) (UT_GET_CONNECT_INSTANCE(ctx, id)->Protocol == TCPIP_IPPROTO_TCP) #define UT_GET_CONNECT_INSTANCE(ctx, id) (&((ctx)->ConnectInstancePtr[id])) #define UT_GET_LISTEN_INSTANCE(ctx, id) (&((ctx)->ListenInstancePtr[id])) #if (CPU_BYTE_ORDER == LOW_BYTE_FIRST) #define UT_HTONS(d) ((uint16)((((d) & 0x00ffUL) << 8) \ | (((d) & 0xff00UL) >> 8))) #define UT_HTONL(d) ((uint32)((((d) & 0x000000ffUL) << 24) \ | (((d) & 0x0000ff00UL) << 8) \ | (((d) & 0x00ff0000UL) >> 8) \ | (((d) & 0xff000000UL) >> 24))) #else #define UT_HTONS(d) (d) #define UT_HTONL(d) (d) #endif /*CPU_BYTE_ORDER == LOW_BYTE_FIRST*/ #define UT_NTOHS(d) UT_HTONS(d) #define UT_NTOHL(d) UT_HTONL(d) #define UT_MESSAGE_SERVICE_ID_VALUE UT_HTONS(UT_MESSAGE_SERVICE_ID) #define UT_CIDR_TO_NETMASK(cidr) ((uint32)((0xFFFFFFFFul) << (32 - (cidr)))) #define UT_GET_RESPONSE_DATA_PTR(ctx, off) (&((ctx)->ResponsePtr[(off) + UT_MESSAGE_HEADER_LEN])) #define UT_SET_RESPONSE_LEN(ctx, len) ((ctx)->ResponseLen = (len)) #define UT_GROUP_EXTENDED_MAX (0xFF) #define UT_PRIMITIVE_EXTENDED_MAX (0xFF) #define UT_PRIMITIVE_EXTENDED_NUM (UT_GROUP_EXTENDED_NUM \ + UT_GENERAL_EXTENDED_NUM \ + UT_UDP_EXTENDED_NUM \ + UT_TCP_EXTENDED_NUM) #if (UT_GROUP_EXTENDED_NUM > 0) #define UT_IS_VALID_GROUP(id) (((id) < UT_GROUP_MAX) \ || ((UT_GROUP_EXTENDED_MAX - (id)) < UT_GROUP_EXTENDED_NUM)) #define UT_GET_GROUP_HANDLER(id) ((id) < UT_GROUP_MAX) \ ? (&UT_ServiceGroups[id])\ : (&UT_ExtendedServiceGroups[UT_GROUP_EXTENDED_MAX - (id)]) #else #define UT_IS_VALID_GROUP(id) ((id) < UT_GROUP_MAX) #define UT_GET_GROUP_HANDLER(id) (&UT_ServiceGroups[id]) #endif #define UT_IS_VALID_PRIMITIVE(h, id) ((id) < (h)->PrimitiveNum) #define UT_IS_VALID_EXTENDED_PRIMITIVE(h, id) ((UT_PRIMITIVE_EXTENDED_MAX - (id)) < (h)->ExtendedPrimitiveNum) #define UT_CALL_PRIMITIVE(h, id, ctx, par, len) ((h)->PrimitivesPtr[id].Processor(ctx, par, len)) #define UT_CALL_EXTENDED_PRIMITIVE(h, i, c, p, l) ((h)->ExtendedPrimitivesPtr[UT_PRIMITIVE_EXTENDED_MAX - (id)].Processor(c, p, l)) #define UT_FILL_RESPONSE_HEADER(header, gid, pid) do{\ (header)->GroupId = (gid) & UT_MESSAGE_GROUP_ID_MASK;\ (header)->PrimitiveId = (pid);\ } while (0) #if (UT_IPV6_SUPPORTED == STD_ON) #define UT_COPY_SOCKADDR(des, src) do{\ (des)->domain = (src)->domain;\ (des)->port = (src)->port;\ (des)->addr[0] = (src)->addr[0];\ if ((src)->domain == TCPIP_AF_INET6)\ {\ (des)->addr[1] = (src)->addr[1];\ (des)->addr[2] = (src)->addr[2];\ (des)->addr[3] = (src)->addr[3];\ }\ } while (0) #define UT_IS_VALID_IPADDR_LEN(len) ((UT_IPADDRV4_LEN == len) || (UT_IPADDRV6_LEN == len)) #else #define UT_COPY_SOCKADDR(des, src) do{\ (des)->domain = (src)->domain;\ (des)->port = (src)->port;\ (des)->addr[0] = (src)->addr[0];\ } while (0) #define UT_IS_VALID_IPADDR_LEN(len) (UT_IPADDRV4_LEN == len) #endif #define UT__MakeSocketId(id, param) UT__MakeUINT16(id, param) #define UT__MakeVariableLength(length, param) UT__MakeUINT16(length, param) /******************************************************************************* * Types Declaration *******************************************************************************/ typedef struct { uint16 SocketId; uint16 Param; } UT_SocketIdAndU16HeaderType; /****************************************************************************** * Local Function Declaration ******************************************************************************/ STATIC FUNC(Std_ReturnType, UT_CODE) UT__DefalutPrimitiveProcessor ( P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) TestCtxPtr, P2VAR(uint8, AUTOMATIC, AUTOMATIC) ParamPtr, uint16 ParamLength ); STATIC FUNC(Std_ReturnType, UT_CODE) UT__GeneralGetVersionProcessor ( P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) TestCtxPtr, P2VAR(uint8, AUTOMATIC, AUTOMATIC) ParamPtr, uint16 ParamLength ); STATIC FUNC(Std_ReturnType, UT_CODE) UT__GeneralStartTestProcessor ( P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) TestCtxPtr, P2VAR(uint8, AUTOMATIC, AUTOMATIC) ParamPtr, uint16 ParamLength ); STATIC FUNC(Std_ReturnType, UT_CODE) UT__GeneralStopTestProcessor ( P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) TestCtxPtr, P2VAR(uint8, AUTOMATIC, AUTOMATIC) ParamPtr, uint16 ParamLength ); STATIC FUNC(Std_ReturnType, UT_CODE) UT__ReceiveAndForwardProcessor ( P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) TestCtxPtr, P2VAR(uint8, AUTOMATIC, AUTOMATIC) ParamPtr, uint16 ParamLength ); STATIC FUNC(Std_ReturnType, UT_CODE) UT__UdpCloseSocketProcessor ( P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) TestCtxPtr, P2VAR(uint8, AUTOMATIC, AUTOMATIC) ParamPtr, uint16 ParamLength ); STATIC FUNC(Std_ReturnType, UT_CODE) UT__UdpCreateAndBindProcessor ( P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) TestCtxPtr, P2VAR(uint8, AUTOMATIC, AUTOMATIC) ParamPtr, uint16 ParamLength ); STATIC FUNC(Std_ReturnType, UT_CODE) UT__UdpSendDataProcessor ( P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) TestCtxPtr, P2VAR(uint8, AUTOMATIC, AUTOMATIC) ParamPtr, uint16 ParamLength ); STATIC FUNC(Std_ReturnType, UT_CODE) UT__UdpConfigureSocketProcessor ( P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) TestCtxPtr, P2VAR(uint8, AUTOMATIC, AUTOMATIC) ParamPtr, uint16 ParamLength ); STATIC FUNC(Std_ReturnType, UT_CODE) UT__TcpCloseSocketProcessor ( P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) TestCtxPtr, P2VAR(uint8, AUTOMATIC, AUTOMATIC) ParamPtr, uint16 ParamLength ); STATIC FUNC(Std_ReturnType, UT_CODE) UT__TcpCreateAndBindProcessor ( P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) TestCtxPtr, P2VAR(uint8, AUTOMATIC, AUTOMATIC) ParamPtr, uint16 ParamLength ); STATIC FUNC(Std_ReturnType, UT_CODE) UT__TcpSendDataProcessor ( P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) TestCtxPtr, P2VAR(uint8, AUTOMATIC, AUTOMATIC) ParamPtr, uint16 ParamLength ); STATIC FUNC(Std_ReturnType, UT_CODE) UT__TcpListenAndAcceptProcessor ( P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) TestCtxPtr, P2VAR(uint8, AUTOMATIC, AUTOMATIC) ParamPtr, uint16 ParamLength ); STATIC FUNC(Std_ReturnType, UT_CODE) UT__TcpConnectProcessor ( P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) TestCtxPtr, P2VAR(uint8, AUTOMATIC, AUTOMATIC) ParamPtr, uint16 ParamLength ); STATIC FUNC(Std_ReturnType, UT_CODE) UT__TcpConfigureSocketProcessor ( P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) TestCtxPtr, P2VAR(uint8, AUTOMATIC, AUTOMATIC) ParamPtr, uint16 ParamLength ); #if (UT_ICMP_SUPPORTED == STD_ON) STATIC FUNC(Std_ReturnType, UT_CODE) UT__IcmpEchoRequestProcessor ( P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) TestCtxPtr, P2VAR(uint8, AUTOMATIC, AUTOMATIC) ParamPtr, uint16 ParamLength ); #endif /****************************************************************************** * Local Data Define ******************************************************************************/ /*force 4-bytes alignment*/ STATIC VAR(uint32, AUTOMATIC) UT_TestResponse[((UT_RESPONSE_LENGTH_MAX + UT_MESSAGE_HEADER_LEN) >> 2) + 1]; STATIC VAR(UT_TestInstanceIdType, AUTOMATIC) UT_TestInstances[UT_TEST_INSTANCE_MAX]; STATIC VAR(UT_ConnectInstanceType, AUTOMATIC) UT_ConnectInstances[UT_TEST_CONNECT_INSTANCE_MAX]; STATIC VAR(UT_ListenInstanceType, AUTOMATIC) UT_ListenInstances[UT_TEST_LISTEN_INSTANCE_MAX]; STATIC VAR(UT_LocalIpAddrType, AUTOMATIC) UT_LocalAddresses[UT_LOCALADDR_MAX]; STATIC VAR(UT_TestContextType, AUTOMATIC) UT_TestContext; STATIC VAR(UT_MessageHeaderType, AUTOMATIC) UT_TcpAcceptedEventHeader = { /*ServiceId*/ UT_MESSAGE_SERVICE_ID_VALUE, /*GroupId*/ UT_MESSAGE_GROUP_EVB_MASK | UT_GROUP_TCP, /*PrimitiveId*/ UT_TCP_LISTEN_AND_ACCEPT, /*Length*/ 0, /*do NOT care*/ 0, /*do NOT care*/ 0, /*ProtocolVer*/ UT_MESSAGE_PROTOCOL_VERSION, /*InterfaceVer*/ UT_MESSAGE_INTERFACE_VERSION, /*TypeId*/ UT_MESSAGE_TYPE_EVENT, /*ResultId*/ UT_RESULT_E_OK }; STATIC VAR(UT_MessageHeaderType, AUTOMATIC) UT_TcpRxAndForwardEventHeader = { /*ServiceId*/ UT_MESSAGE_SERVICE_ID_VALUE, /*GroupId*/ UT_MESSAGE_GROUP_EVB_MASK | UT_GROUP_TCP, /*PrimitiveId*/ UT_TCP_RECEIVE_AND_FORWARD, /*Length*/ 0, /*do NOT care*/ 0, /*do NOT care*/ 0, /*ProtocolVer*/ UT_MESSAGE_PROTOCOL_VERSION, /*InterfaceVer*/ UT_MESSAGE_INTERFACE_VERSION, /*TypeId*/ UT_MESSAGE_TYPE_EVENT, /*ResultId*/ UT_RESULT_E_OK }; STATIC VAR(UT_MessageHeaderType, AUTOMATIC) UT_UdpRxAndForwardEventHeader = { /*ServiceId*/ UT_MESSAGE_SERVICE_ID_VALUE, /*GroupId*/ UT_MESSAGE_GROUP_EVB_MASK | UT_GROUP_UDP, /*PrimitiveId*/ UT_TCP_RECEIVE_AND_FORWARD, /*Length*/ 0, /*do NOT care*/ 0, /*do NOT care*/ 0, /*ProtocolVer*/ UT_MESSAGE_PROTOCOL_VERSION, /*InterfaceVer*/ UT_MESSAGE_INTERFACE_VERSION, /*TypeId*/ UT_MESSAGE_TYPE_EVENT, /*ResultId*/ UT_RESULT_E_OK }; STATIC VAR(UT_MessageHeaderType, AUTOMATIC) UT_ResponseMessageHeader = { /*ServiceId*/ UT_MESSAGE_SERVICE_ID_VALUE, /*GroupId*/ 0, /*PrimitiveId*/ 0, /*Length*/ 0, /*do NOT care*/ 0, /*do NOT care*/ 0, /*ProtocolVer*/ UT_MESSAGE_PROTOCOL_VERSION, /*InterfaceVer*/ UT_MESSAGE_INTERFACE_VERSION, /*TypeId*/ UT_MESSAGE_TYPE_RESPONSE, /*ResultId*/ UT_RESULT_E_OK }; STATIC VAR(UT_ServicePrimitiveType, AUTOMATIC) UT_GeneralPrimitives[UT_GENERAL_PRIMITIVE_MAX] = { {UT__DefalutPrimitiveProcessor}, {UT__GeneralGetVersionProcessor}, {UT__GeneralStartTestProcessor}, {UT__GeneralStopTestProcessor}, }; STATIC VAR(UT_ServicePrimitiveType, AUTOMATIC) UT_UdpPrimitives[UT_UDP_PRIMITIVE_MAX] = { {UT__UdpCloseSocketProcessor}, {UT__UdpCreateAndBindProcessor}, {UT__UdpSendDataProcessor}, {UT__ReceiveAndForwardProcessor}, {UT__DefalutPrimitiveProcessor}, {UT__DefalutPrimitiveProcessor}, {UT__UdpConfigureSocketProcessor}, {UT__DefalutPrimitiveProcessor}, }; STATIC VAR(UT_ServicePrimitiveType, AUTOMATIC) UT_TcpPrimitives[UT_TCP_PRIMITIVE_MAX] = { {UT__TcpCloseSocketProcessor}, {UT__TcpCreateAndBindProcessor}, {UT__TcpSendDataProcessor}, {UT__ReceiveAndForwardProcessor}, {UT__TcpListenAndAcceptProcessor}, {UT__TcpConnectProcessor}, {UT__TcpConfigureSocketProcessor}, {UT__DefalutPrimitiveProcessor}, }; STATIC VAR(UT_ServicePrimitiveType, AUTOMATIC) UT_IcmpPrimitives[UT_ICMP_PRIMITIVE_MAX] = { #if (UT_ICMP_SUPPORTED == STD_ON) {UT__IcmpEchoRequestProcessor}, #else {UT__DefalutPrimitiveProcessor}, #endif }; STATIC VAR(UT_ServiceGroupHandlerType, AUTOMATIC) UT_ServiceGroups[UT_GROUP_MAX] = { { UT_GENERAL_PRIMITIVE_MAX, UT_GENERAL_EXTENDED_NUM, UT_GeneralPrimitives, UT_GENERAL_EXTENDED_PRIMITVIES }, { UT_UDP_PRIMITIVE_MAX, UT_UDP_EXTENDED_NUM, UT_UdpPrimitives, UT_UDP_EXTENDED_PRIMITVIES }, { UT_TCP_PRIMITIVE_MAX, UT_TCP_EXTENDED_NUM, UT_TcpPrimitives, UT_TCP_EXTENDED_PRIMITVIES }, { UT_ICMP_PRIMITIVE_MAX, UT_ICMP_EXTENDED_NUM, UT_IcmpPrimitives, UT_ICMP_EXTENDED_PRIMITVIES }, }; /****************************************************************************** * Local Function Define ******************************************************************************/ STATIC FUNC(void, UT_CODE) UT__CopyData ( P2VAR(uint8, AUTOMATIC, AUTOMATIC) DestPtr, P2CONST(uint8, AUTOMATIC, AUTOMATIC) SrcPtr, uint16 Length ) { uint16 i; for (i = 0; i < Length; i++) { DestPtr[i] = SrcPtr[i]; } } STATIC FUNC(Std_ReturnType, UT_CODE) UT__IsAnyIpAddr ( P2CONST(UT_SockAddrType, AUTOMATIC, AUTOMATIC) IpAddrPtr ) { Std_ReturnType ret = E_NOT_OK; if (IpAddrPtr->addr[0] == TCPIP_IPADDR_ANY) { #if (UT_IPV6_SUPPORTED == STD_ON) if ((TCPIP_AF_INET == IpAddrPtr->domain) /*IPv6*/ || ((TCPIP_IPADDR_ANY == IpAddrPtr->addr[1]) && (TCPIP_IPADDR_ANY == IpAddrPtr->addr[2]) && (TCPIP_IPADDR_ANY == IpAddrPtr->addr[3]))) #endif { ret = E_OK; } } return ret; } STATIC FUNC(Std_ReturnType, UT_CODE) UT__IsBroadcastIpAddr ( P2VAR(UT_LocalIpAddrType, AUTOMATIC, AUTOMATIC) LocalIpAddrPtr, P2VAR(UT_SockAddrType, AUTOMATIC, AUTOMATIC) IpAddrPtr ) { Std_ReturnType ret = E_NOT_OK; uint32 netmask = UT_CIDR_TO_NETMASK(LocalIpAddrPtr->Netmask); uint32 subnet = ~netmask; if ((IpAddrPtr->addr[0] & netmask) == (LocalIpAddrPtr->LocalAddr.addr[0] & netmask) && ((IpAddrPtr->addr[0] & subnet) == subnet)) { ret = E_OK; } return ret; } STATIC FUNC(Std_ReturnType, UT_CODE) UT__FindLocalIpAddrId ( P2CONST(UT_TestContextType, AUTOMATIC, AUTOMATIC) TestCtxPtr, P2CONST(UT_SockAddrType, AUTOMATIC, AUTOMATIC) IpAddrPtr, P2VAR(TcpIp_LocalAddrIdType, AUTOMATIC, AUTOMATIC) LocalAddrIdPtr ) { TcpIp_LocalAddrIdType i; Std_ReturnType ret = E_NOT_OK; if (UT__IsAnyIpAddr(IpAddrPtr) == E_OK) { *LocalAddrIdPtr = TCPIP_LOCALADDRID_ANY; ret = E_OK; } else { /*unicast, broadcast or multicast address*/ for (i = 0; i < UT_LOCALADDR_MAX; i++) { if ((TCPIP_IPADDR_STATE_ASSIGNED == TestCtxPtr->LocalIpAddr[i].State) && (TestCtxPtr->LocalIpAddr[i].LocalAddr.domain == IpAddrPtr->domain) && (TestCtxPtr->LocalIpAddr[i].LocalAddr.addr[0] == IpAddrPtr->addr[0])) { #if (UT_IPV6_SUPPORTED == STD_ON) if ((TCPIP_AF_INET == IpAddrPtr->domain) /*IPv6*/ || ((TestCtxPtr->LocalIpAddr[i].LocalAddr.addr[1] == IpAddrPtr->addr[1]) && (TestCtxPtr->LocalIpAddr[i].LocalAddr.addr[2] == IpAddrPtr->addr[2]) && (TestCtxPtr->LocalIpAddr[i].LocalAddr.addr[3] == IpAddrPtr->addr[3]))) #endif { *LocalAddrIdPtr = i; ret = E_OK; break; } } } } return ret; } STATIC FUNC(uint16, UT_CODE) UT__MakeUINT16 ( P2VAR(uint16, AUTOMATIC, AUTOMATIC) DataPtr, P2CONST(uint8, AUTOMATIC, AUTOMATIC) ParamPtr ) { uint16 data; UT__CopyData((P2VAR(uint8, AUTOMATIC, AUTOMATIC))&data, ParamPtr, sizeof(uint16)); *DataPtr = UT_NTOHS(data); return sizeof(uint16); } STATIC FUNC(uint16, UT_CODE) UT__MakeUINT32 ( P2VAR(uint32, AUTOMATIC, AUTOMATIC) DataPtr, P2CONST(uint8, AUTOMATIC, AUTOMATIC) ParamPtr ) { uint32 data; UT__CopyData((P2VAR(uint8, AUTOMATIC, AUTOMATIC))&data, ParamPtr, sizeof(uint32)); *DataPtr = UT_NTOHL(data); return sizeof(uint32); } STATIC FUNC(uint16, UT_CODE) UT__MakeSocketIdAndU16Header ( P2VAR(UT_SocketIdAndU16HeaderType, AUTOMATIC, AUTOMATIC) HeaderPtr, P2CONST(uint8, AUTOMATIC, AUTOMATIC) ParamPtr ) { UT__CopyData((P2VAR(uint8, AUTOMATIC, AUTOMATIC))HeaderPtr, ParamPtr, sizeof(UT_SocketIdAndU16HeaderType)); HeaderPtr->SocketId = UT_NTOHS(HeaderPtr->SocketId); HeaderPtr->Param = UT_NTOHS(HeaderPtr->Param); return sizeof(UT_SocketIdAndU16HeaderType); } STATIC FUNC(uint16, UT_CODE) UT__MakeIpAddressAndPort ( P2VAR(UT_SockAddrType, AUTOMATIC, AUTOMATIC) IpAddrPtr, P2CONST(uint8, AUTOMATIC, AUTOMATIC) ParamPtr, uint16 ParamLen ) { uint16 len; uint16 port; uint16 consumed; /** * Parameters: * localPort uint16 (0xFFFF is ANY) * localAddr ipxaddr -> uint16 + uint8[] * */ consumed = UT__MakeUINT16(&port, ParamPtr); consumed += UT__MakeVariableLength(&len, &ParamPtr[consumed]); if (UT_IS_VALID_IPADDR_LEN(len) && (ParamLen >= (len + consumed))) { IpAddrPtr->port = (port == 0xFFFFu)? TCPIP_PORT_ANY: port; consumed += UT__MakeUINT32(IpAddrPtr->addr, &ParamPtr[consumed]); #if (UT_IPV6_SUPPORTED == STD_ON) if (UT_IPADDRV6_LEN == len) { consumed += UT__MakeUINT32(&IpAddrPtr->addr[1], &ParamPtr[consumed]); consumed += UT__MakeUINT32(&IpAddrPtr->addr[2], &ParamPtr[consumed]); consumed += UT__MakeUINT32(&IpAddrPtr->addr[3], &ParamPtr[consumed]); IpAddrPtr->domain = TCPIP_AF_INET6; } else #endif { IpAddrPtr->domain = TCPIP_AF_INET; } } else { consumed = 0; } return consumed; } STATIC FUNC(void, UT_CODE) UT__ReleaseListenInstance ( P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) TestCtxPtr, UT_TestInstanceIdType InstanceId ) { P2VAR(UT_ListenInstanceType, AUTOMATIC, AUTOMATIC) instance; instance = &TestCtxPtr->ListenInstancePtr[InstanceId]; instance->SocketId = 0; instance->LocalAddrId = 0; instance->LocalPort = TCPIP_PORT_ANY; instance->MaxConnections = 0; instance->Connections = 0; UT_INSTANCE_SET_IDLE(instance); } STATIC FUNC(UT_TestInstanceIdType, UT_CODE) UT__FindListenInstance ( P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) TestCtxPtr, TcpIp_SocketIdType SocketId ) { P2VAR(UT_ListenInstanceType, AUTOMATIC, AUTOMATIC) instance; UT_TestInstanceIdType i; UT_TestInstanceIdType ret = UT_TEST_LISTEN_INSTANCE_MAX; instance = TestCtxPtr->ListenInstancePtr; for (i = 0; i < UT_TEST_LISTEN_INSTANCE_MAX; i++) { if (!UT_INSTANCE_IS_IDLE(&instance[i]) && (SocketId == instance[i].SocketId)) { ret = i; break; } } return ret; } STATIC FUNC(Std_ReturnType, UT_CODE) UT__AllocListenInstance ( P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) TestCtxPtr, TcpIp_SocketIdType SocketId, TcpIp_LocalAddrIdType LocalAddrId, uint16 LocalPort, uint16 MaxConn ) { P2VAR(UT_ListenInstanceType, AUTOMATIC, AUTOMATIC) instance; uint16 i; Std_ReturnType ret = UT_RESULT_E_UCS; instance = TestCtxPtr->ListenInstancePtr; for (i = 0; i < UT_TEST_CONNECT_INSTANCE_MAX; i++) { if (UT_INSTANCE_IS_IDLE(instance)) { UT_INSTANCE_SET_ALLOCATED(instance); instance[i].SocketId = SocketId; instance[i].Connections = 0; instance[i].MaxConnections = MaxConn; instance[i].LocalAddrId = LocalAddrId; instance[i].LocalPort = LocalPort; ret = UT_RESULT_E_OK; break; } } return ret; } STATIC FUNC(UT_TestInstanceIdType, UT_CODE) UT__FindConnectInstance ( P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) TestCtxPtr, TcpIp_SocketIdType SocketId ) { P2VAR(UT_ConnectInstanceType, AUTOMATIC, AUTOMATIC) instance; UT_TestInstanceIdType i; UT_TestInstanceIdType ret = UT_TEST_CONNECT_INSTANCE_MAX; instance = TestCtxPtr->ConnectInstancePtr; for (i = 0; i < UT_TEST_CONNECT_INSTANCE_MAX; i++) { if (!UT_INSTANCE_IS_IDLE(&instance[i]) && (SocketId == instance[i].SocketId)) { ret = i; break; } } return ret; } STATIC FUNC(Std_ReturnType, UT_CODE) UT__AllocConnectInstance ( P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) TestCtxPtr, UT_TestInstanceIdType ListenId, TcpIp_ProtocolType Protocol, TcpIp_SocketIdType SocketId, TcpIp_LocalAddrIdType LocalAddrId, uint16 LocalPort ) { P2VAR(UT_ConnectInstanceType, AUTOMATIC, AUTOMATIC) instance; uint16 i; Std_ReturnType ret = UT_RESULT_E_UCS; instance = TestCtxPtr->ConnectInstancePtr; for (i = 0; i < UT_TEST_CONNECT_INSTANCE_MAX; i++) { if (UT_INSTANCE_IS_IDLE(&instance[i])) { UT_INSTANCE_SET_ALLOCATED(&instance[i]); instance[i].SocketId = SocketId; instance[i].Protocol = Protocol; instance[i].ListenId = ListenId; instance[i].LocalAddrId = LocalAddrId; instance[i].LocalPort = LocalPort; ret = UT_RESULT_E_OK; break; } } return ret; } STATIC FUNC(void, UT_CODE) UT__ReleaseConnectInstance ( P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) TestCtxPtr, UT_TestInstanceIdType InstanceId ) { P2VAR(UT_ConnectInstanceType, AUTOMATIC, AUTOMATIC) instance; instance = &TestCtxPtr->ConnectInstancePtr[InstanceId]; instance->Protocol = 0; instance->SocketId = 0; instance->LocalAddrId = 0; instance->LocalPort = TCPIP_PORT_ANY; instance->RemainLen = 0; instance->ReceivedLen = 0; instance->ConsumedLen = 0; instance->MaxFwd = 0; instance->SendDataLen = 0; instance->SendDataPtr = NULL_PTR; UT_INSTANCE_SET_IDLE(instance); } STATIC FUNC(Std_ReturnType, UT_CODE) UT__CreateAndBindSocket ( P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) TestCtxPtr, TcpIp_ProtocolType Protocol, P2VAR(uint8, AUTOMATIC, AUTOMATIC) ParamPtr, uint16 ParamLength ) { UT_SockAddrType address; TcpIp_LocalAddrIdType localAddrId = TCPIP_LOCALADDRID_ANY; TcpIp_SocketIdType socketId; Std_ReturnType ret; uint8 isBind; P2VAR(uint16, AUTOMATIC, AUTOMATIC) retSocketId; /** * doBind bool * localPort uint16 * localAddr ipxaddr -> uint16 + uint8[] */ isBind = (ParamPtr[0] == 0)? FALSE: TRUE; if (UT__MakeIpAddressAndPort(&address, &ParamPtr[1], ParamLength - 1) == 0) { ret = UT_RESULT_E_INV; } else if (UT_GetSocket(address.domain, Protocol, &socketId) != E_OK) { ret = UT_RESULT_E_UCS; } else if ((TRUE == isBind) && ((UT__FindLocalIpAddrId(TestCtxPtr, &address, &localAddrId) != E_OK) || (TcpIp_Bind(socketId, localAddrId, &(address.port)) != E_OK))) { TcpIp_Close(socketId, FALSE); ret = UT_RESULT_E_UBS; } else if (UT__AllocConnectInstance(TestCtxPtr, UT_TEST_LISTEN_INSTANCE_MAX, Protocol, socketId, localAddrId, address.port) != E_OK) { TcpIp_Close(socketId, FALSE); ret = UT_RESULT_E_NOT_OK; } else { retSocketId = (P2VAR(uint16, AUTOMATIC, AUTOMATIC))UT_GET_RESPONSE_DATA_PTR(TestCtxPtr, 0); retSocketId[0] = UT_HTONS(socketId); UT_SET_RESPONSE_LEN(TestCtxPtr, UT_CREATEANDBIND_RESPONSE_LEN); ret = UT_RESULT_E_OK; } return ret; } #if (UT_CONFIG_SOCKET_SUPPORTED == STD_ON) STATIC FUNC(Std_ReturnType, UT_CODE) UT__CheckConfigParamLength ( uint16 ParamId, uint16 ParamLength ) { Std_ReturnType ret = UT_RESULT_E_NOT_OK; STATIC uint16 paramLengthList[UT_CONFIGSOCKET_PARAM_ID_MAX] = { 1, 1, 1, 0, 1, 2, 1, 1 }; if ((ParamId < UT_CONFIGSOCKET_PARAM_ID_MAX) && (ParamLength > 0)) { if ((paramLengthList[ParamId] == 0) || (paramLengthList[ParamId] == ParamLength)) { ret = UT_RESULT_E_OK; } } return ret; } STATIC FUNC(Std_ReturnType, UT_CODE) UT__ConfigureSocket ( P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) TestCtxPtr, P2VAR(uint8, AUTOMATIC, AUTOMATIC) ParamPtr, uint16 ParamLength ) { Std_ReturnType ret; UT_TestInstanceIdType instance; UT_SocketIdAndU16HeaderType baseHeader; uint16 consumed = 0; uint16 length = 0; /** * socketId uint16 * paramId uint16 * paramVal vint8 -> uint16 + uint8[] */ consumed = UT__MakeSocketIdAndU16Header(&baseHeader, ParamPtr); consumed += UT__MakeVariableLength(&length, &ParamPtr[consumed]); instance = UT__FindConnectInstance(TestCtxPtr, baseHeader.SocketId); if (!UT_IS_VALID_CONNECT_INSTANCE(instance)) { ret = UT_RESULT_E_ISD; } else if ((UT__CheckConfigParamLength(baseHeader.Param, length) != UT_RESULT_E_OK) || (length != (ParamLength - consumed))) { ret = UT_RESULT_E_INV; } else { ret = UT_ConfigureSocket(baseHeader.SocketId, baseHeader.Param, length, &ParamPtr[consumed]); } return ret; } #endif FUNC(void, UT_CODE) UT__ClearTestContext ( P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) TestCtxPtr ) { P2VAR(UT_ListenInstanceType, AUTOMATIC, AUTOMATIC) listen; P2VAR(UT_ConnectInstanceType, AUTOMATIC, AUTOMATIC) connect; UT_TestInstanceIdType i; TcpIp_SocketIdType socketId; for (i = 0; i < UT_TEST_LISTEN_INSTANCE_MAX; i++) { listen = UT_GET_LISTEN_INSTANCE(TestCtxPtr, i); if (UT_INSTANCE_IS_ALLOCATED(listen)) { socketId = listen->SocketId; UT__ReleaseListenInstance(TestCtxPtr, i); (void)TcpIp_Close(socketId, FALSE); } } for (i = 0; i < UT_TEST_CONNECT_INSTANCE_MAX; i++) { connect = UT_GET_CONNECT_INSTANCE(TestCtxPtr, i); if (!UT_INSTANCE_IS_IDLE(connect)) { socketId = connect->SocketId; UT__ReleaseConnectInstance(TestCtxPtr, i); (void)TcpIp_Close(socketId, TRUE); } } } //================================================================== STATIC FUNC(Std_ReturnType, UT_CODE) UT__DefalutPrimitiveProcessor ( P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) TestCtxPtr, P2VAR(uint8, AUTOMATIC, AUTOMATIC) ParamPtr, uint16 ParamLength ) { UT_UNUSED(TestCtxPtr); UT_UNUSED(ParamPtr); UT_UNUSED(ParamLength); return UT_RESULT_E_NOT_OK; } STATIC FUNC(Std_ReturnType, UT_CODE) UT__GeneralGetVersionProcessor ( P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) TestCtxPtr, P2VAR(uint8, AUTOMATIC, AUTOMATIC) ParamPtr, uint16 ParamLength ) { P2VAR(uint16, AUTOMATIC, AUTOMATIC) version; UT_UNUSED(ParamPtr); UT_UNUSED(ParamLength); version = (P2VAR(uint16, AUTOMATIC, AUTOMATIC))UT_GET_RESPONSE_DATA_PTR(TestCtxPtr, 0); version[0] = UT_HTONS(UT_SPEC_MAJOR_VERSION); version[1] = UT_HTONS(UT_SPEC_MINOR_VERSION); version[2] = UT_HTONS(UT_SPEC_PATCH_VERSION); UT_SET_RESPONSE_LEN(TestCtxPtr, UT_GENERAL_GETVERSION_RESPONSE_LEN); return UT_RESULT_E_OK; } STATIC FUNC(Std_ReturnType, UT_CODE) UT__GeneralStartTestProcessor ( P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) TestCtxPtr, P2VAR(uint8, AUTOMATIC, AUTOMATIC) ParamPtr, uint16 ParamLength ) { uint8 ret = UT_RESULT_E_NOT_OK; UT_UNUSED(ParamPtr); if ((ParamLength == 0) && UT_IS_IDLE(TestCtxPtr)) { UT_SET_ACTIVE(TestCtxPtr); ret = UT_RESULT_E_OK; } return ret; } STATIC FUNC(Std_ReturnType, UT_CODE) UT__GeneralStopTestProcessor ( P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) TestCtxPtr, P2VAR(uint8, AUTOMATIC, AUTOMATIC) ParamPtr, uint16 ParamLength ) { Std_ReturnType ret = UT_RESULT_E_NOT_OK; UT_UNUSED(ParamPtr); UT_UNUSED(ParamLength); if (UT_IS_ACTIVE(TestCtxPtr)) { UT_SET_IDLE(TestCtxPtr); UT__ClearTestContext(TestCtxPtr); ret = UT_RESULT_E_OK; } return ret; } STATIC FUNC(uint16, UT_CODE) UT__SetReceiveAndForward ( P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) TestCtxPtr, UT_TestInstanceIdType instanceId, uint16 MaxFwd, uint16 MaxLen ) { P2VAR(UT_ConnectInstanceType, AUTOMATIC, AUTOMATIC) instance; uint16 receivedLen; instance = &TestCtxPtr->ConnectInstancePtr[instanceId]; instance->MaxFwd = MaxFwd; instance->RemainLen = (MaxLen < 0xFFFF)? MaxLen: 0xFFFFFFFFUL; receivedLen = instance->ReceivedLen; instance->ReceivedLen = 0; return receivedLen; } STATIC FUNC(Std_ReturnType, UT_CODE) UT__ReceiveAndForwardProcessor ( P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) TestCtxPtr, P2VAR(uint8, AUTOMATIC, AUTOMATIC) ParamPtr, uint16 ParamLength ) { P2VAR(uint16, AUTOMATIC, AUTOMATIC) dropCnt; Std_ReturnType ret = UT_RESULT_E_INV; UT_TestInstanceIdType instanceId; uint16 socketId; uint16 maxFwd; uint16 consumed = 0; uint16 maxLen; uint16 receivedLen; do { if (!UT_IS_ACTIVE(TestCtxPtr)) { break; } if (ParamLength != UT_RECEIVEANDFORWARD_PARAM_LEN) { break; } /** * socketId uint16 * maxFwd uint16 * maxLen uint16 (0xFFFF: Limitless) */ consumed = UT__MakeSocketId(&socketId, ParamPtr); instanceId = UT__FindConnectInstance(TestCtxPtr, socketId); if (!UT_IS_VALID_CONNECT_INSTANCE(instanceId)) { ret = UT_RESULT_E_ISD; break; } if(UT_INSTANCE_IS_TXONLY(&TestCtxPtr->ConnectInstancePtr[instanceId])) { ret = UT_RESULT_E_TCP_COC; break; } consumed += UT__MakeUINT16(&maxFwd, &ParamPtr[consumed]); consumed += UT__MakeUINT16(&maxLen, &ParamPtr[consumed]); receivedLen = UT__SetReceiveAndForward(TestCtxPtr, instanceId, maxFwd, maxLen); if ((receivedLen > 0) && UT_IS_TCP_INSTANCE(TestCtxPtr, instanceId)) { ret = TcpIp_TcpReceived(socketId, receivedLen); if (ret != E_OK) { break; } } dropCnt = (P2VAR(uint16, AUTOMATIC, AUTOMATIC))UT_GET_RESPONSE_DATA_PTR(TestCtxPtr, 0); dropCnt[0] = UT_HTONS(receivedLen); UT_SET_RESPONSE_LEN(TestCtxPtr, UT_CREATEANDBIND_RESPONSE_LEN); ret = UT_RESULT_E_OK; } while (0); return ret; } //====================================================================================== STATIC FUNC(Std_ReturnType, UT_CODE) UT__UdpCloseSocketProcessor ( P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) TestCtxPtr, P2VAR(uint8, AUTOMATIC, AUTOMATIC) ParamPtr, uint16 ParamLength ) { Std_ReturnType ret = UT_RESULT_E_INV; UT_TestInstanceIdType instanceId; uint16 socketId; if (UT_IS_ACTIVE(TestCtxPtr) && (UT_UDP_CLOSESOCKET_PARAM_LEN == ParamLength)) { /** * socketId uint16 */ (void)UT__MakeSocketId(&socketId, ParamPtr); instanceId = UT__FindConnectInstance(TestCtxPtr, socketId); if (UT_IS_VALID_CONNECT_INSTANCE(instanceId)) { UT__ReleaseConnectInstance(TestCtxPtr, instanceId); ret = TcpIp_Close(socketId, FALSE); } else { ret = UT_RESULT_E_ISD; } } return ret; } STATIC FUNC(Std_ReturnType, UT_CODE) UT__UdpCreateAndBindProcessor ( P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) TestCtxPtr, P2VAR(uint8, AUTOMATIC, AUTOMATIC) ParamPtr, uint16 ParamLength ) { Std_ReturnType ret = UT_RESULT_E_INV; if (UT_IS_ACTIVE(TestCtxPtr) && ((UT_CREATEANDBIND_IPV4_PARAM_LEN == ParamLength) || (UT_CREATEANDBIND_IPV6_PARAM_LEN == ParamLength))) { ret = UT__CreateAndBindSocket(TestCtxPtr, TCPIP_IPPROTO_UDP, ParamPtr, ParamLength); } return ret; } STATIC FUNC(Std_ReturnType, UT_CODE) UT__UdpSendDataProcessor ( P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) TestCtxPtr, P2VAR(uint8, AUTOMATIC, AUTOMATIC) ParamPtr, uint16 ParamLength ) { P2CONST(uint8, AUTOMATIC, AUTOMATIC) data; UT_SocketIdAndU16HeaderType baseHeader; UT_SockAddrType address; UT_TestInstanceIdType instanceId; Std_ReturnType ret = UT_RESULT_E_INV; uint16 consumed = 0; uint16 dataLen; do { if (!UT_IS_ACTIVE(TestCtxPtr)) { break; } if (ParamLength < UT_UDP_SENDDATA_PARAM_LEN_MIN) { break; } /** * socketId uint16 * totalLen uint16 * destPort uint16 * destAddr ipxaddr -> uint16 + uint8[] * data vint8 -> uint16 + uint8[] */ /*get socketId and totalLen*/ consumed = UT__MakeSocketIdAndU16Header(&baseHeader, ParamPtr); instanceId = UT__FindConnectInstance(TestCtxPtr, baseHeader.SocketId); if (!UT_IS_VALID_CONNECT_INSTANCE(instanceId)) { ret = UT_RESULT_E_ISD; break; } /*get remote address*/ dataLen = UT__MakeIpAddressAndPort(&address, &ParamPtr[consumed], ParamLength - consumed); if (dataLen == 0) { ret = UT_RESULT_E_INV; break; } consumed += dataLen; /*get length of data*/ consumed += UT__MakeVariableLength(&dataLen, &ParamPtr[consumed]); if (dataLen != (ParamLength - consumed)) { ret = UT_RESULT_E_NOT_OK; break; } if ((dataLen > 0) && (baseHeader.Param > dataLen)) { TestCtxPtr->ConnectInstancePtr[instanceId].SendDataLen = dataLen; TestCtxPtr->ConnectInstancePtr[instanceId].SendDataPtr = &ParamPtr[consumed]; data = NULL_PTR; dataLen = baseHeader.Param; } else { data = &ParamPtr[consumed]; } if (TcpIp_UdpTransmit(baseHeader.SocketId, data, (P2CONST(TcpIp_SockAddrType, AUTOMATIC, AUTOMATIC))&address, dataLen) != E_OK) { ret = UT_RESULT_E_NOT_OK; } else { ret = UT_RESULT_E_OK; } } while (0); return ret; } STATIC FUNC(Std_ReturnType, UT_CODE) UT__UdpConfigureSocketProcessor ( P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) TestCtxPtr, P2VAR(uint8, AUTOMATIC, AUTOMATIC) ParamPtr, uint16 ParamLength ) { Std_ReturnType ret = UT_RESULT_E_INV; #if (UT_CONFIG_SOCKET_SUPPORTED == STD_ON) if (UT_IS_ACTIVE(TestCtxPtr) && (ParamLength >= UT_CONFIGSOCKET_PARAM_LEN_MIN)) { ret = UT__ConfigureSocket(TestCtxPtr, ParamPtr, ParamLength); } #endif return ret; } //======================================================================================= STATIC FUNC(Std_ReturnType, UT_CODE) UT__TcpCloseSocketProcessor ( P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) TestCtxPtr, P2VAR(uint8, AUTOMATIC, AUTOMATIC) ParamPtr, uint16 ParamLength ) { Std_ReturnType ret = UT_RESULT_E_INV; UT_TestInstanceIdType instanceId; P2VAR(UT_ConnectInstanceType, AUTOMATIC, AUTOMATIC) instancePtr; uint16 socketId; uint16 consumed; uint8 isAbort; if (UT_IS_ACTIVE(TestCtxPtr) && (UT_TCP_CLOSESOCKET_PARAM_LEN == ParamLength)) { /** * socketId uint16 * abort uint8 */ consumed = UT__MakeSocketId(&socketId, ParamPtr); instanceId = UT__FindConnectInstance(TestCtxPtr, socketId); if (UT_IS_VALID_CONNECT_INSTANCE(instanceId)) { instancePtr = UT_GET_CONNECT_INSTANCE(TestCtxPtr, instanceId); if (!UT_INSTANCE_IS_TXONLY(instancePtr)) { UT_INSTANCE_SET_RXONLY(instancePtr); } isAbort = (ParamPtr[consumed] == 0)? FALSE: TRUE; ret = TcpIp_Close(socketId, isAbort); if (ret != E_OK) { UT__ReleaseConnectInstance(TestCtxPtr, instanceId); ret = UT_RESULT_E_NOT_OK; } else if (UT_INSTANCE_IS_TXONLY(instancePtr)) { UT__ReleaseConnectInstance(TestCtxPtr, instanceId); } else { /* do nothing */ } } else { instanceId = UT__FindListenInstance(TestCtxPtr, socketId); if (UT_IS_VALID_LISTEN_INSTANCE(instanceId)) { UT__ReleaseListenInstance(TestCtxPtr, instanceId); ret = TcpIp_Close(socketId, FALSE); if (ret != E_OK) { ret = UT_RESULT_E_NOT_OK; } } else { ret = UT_RESULT_E_ISD; } } } return ret; } STATIC FUNC(Std_ReturnType, UT_CODE) UT__TcpCreateAndBindProcessor ( P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) TestCtxPtr, P2VAR(uint8, AUTOMATIC, AUTOMATIC) ParamPtr, uint16 ParamLength ) { Std_ReturnType ret = UT_RESULT_E_INV; if (UT_IS_ACTIVE(TestCtxPtr) && ((UT_CREATEANDBIND_IPV4_PARAM_LEN == ParamLength) || (UT_CREATEANDBIND_IPV6_PARAM_LEN == ParamLength))) { ret = UT__CreateAndBindSocket(TestCtxPtr, TCPIP_IPPROTO_TCP, ParamPtr, ParamLength); } return ret; } STATIC FUNC(Std_ReturnType, UT_CODE) UT__TcpSendDataProcessor ( P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) TestCtxPtr, P2VAR(uint8, AUTOMATIC, AUTOMATIC) ParamPtr, uint16 ParamLength ) { P2CONST(uint8, AUTOMATIC, AUTOMATIC) data; UT_SocketIdAndU16HeaderType baseHeader; UT_TestInstanceIdType instanceId; Std_ReturnType ret = UT_RESULT_E_INV; uint8 flags; uint16 consumed = 0; uint16 dataLen; do { if (!UT_IS_ACTIVE(TestCtxPtr)) { break; } if (ParamLength < UT_TCP_SENDDATA_PARAM_LEN_MIN) { break; } /** * socketId uint16 * totalLen uint16 * flags uint8 * data vint8 -> uint16 + uint8[] */ /*get socketId and totalLen*/ consumed = UT__MakeSocketIdAndU16Header(&baseHeader, ParamPtr); instanceId = UT__FindConnectInstance(TestCtxPtr, baseHeader.SocketId); if (!UT_IS_VALID_CONNECT_INSTANCE(instanceId)) { ret = UT_RESULT_E_ISD; break; } if (UT_INSTANCE_IS_RXONLY(UT_GET_CONNECT_INSTANCE(TestCtxPtr, instanceId))) { ret = UT_RESULT_E_ISD; break; } /*get flags*/ flags = ParamPtr[consumed]; consumed += 1; /*get length of data*/ consumed += UT__MakeVariableLength(&dataLen, &ParamPtr[consumed]); if ((0 == dataLen) || (dataLen != (ParamLength - consumed))) { ret = UT_RESULT_E_INV; break; } if (baseHeader.Param > dataLen) { TestCtxPtr->ConnectInstancePtr[instanceId].SendDataLen = dataLen; TestCtxPtr->ConnectInstancePtr[instanceId].SendDataPtr = &ParamPtr[consumed]; data = NULL_PTR; dataLen = baseHeader.Param; } else { data = &ParamPtr[consumed]; } if (TcpIp_TcpTransmit(baseHeader.SocketId, data, dataLen, TRUE) != E_OK) { ret = UT_RESULT_E_NOT_OK; } else { ret = UT_RESULT_E_OK; } } while (0); return ret; } STATIC FUNC(Std_ReturnType, UT_CODE) UT__TcpListenAndAcceptProcessor ( P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) TestCtxPtr, P2VAR(uint8, AUTOMATIC, AUTOMATIC) ParamPtr, uint16 ParamLength ) { P2CONST(UT_ConnectInstanceType, AUTOMATIC, AUTOMATIC) connectInstance; UT_SocketIdAndU16HeaderType baseHeader; UT_TestInstanceIdType instanceId; Std_ReturnType ret = UT_RESULT_E_INV; do { if (!UT_IS_ACTIVE(TestCtxPtr)) { break; } if (UT_TCP_LISTENANDACCEPT_PARAM_LEN != ParamLength) { break; } /** * socketId uint16 * maxCon uint16 */ /*get socketId and maxCon*/ (void)UT__MakeSocketIdAndU16Header(&baseHeader, ParamPtr); instanceId = UT__FindConnectInstance(TestCtxPtr, baseHeader.SocketId); if (!UT_IS_VALID_CONNECT_INSTANCE(instanceId)) { ret = UT_RESULT_E_ISD; break; } ret = TcpIp_TcpListen(baseHeader.SocketId, baseHeader.Param); if (ret != E_OK) { ret = UT_RESULT_E_UCS; break; } connectInstance = UT_GET_CONNECT_INSTANCE(TestCtxPtr, instanceId); ret = UT__AllocListenInstance(TestCtxPtr, baseHeader.SocketId, connectInstance->LocalAddrId, connectInstance->LocalPort, baseHeader.Param); if (ret != UT_RESULT_E_OK) { ret = UT_RESULT_E_UCS; break; } UT__ReleaseConnectInstance(TestCtxPtr, instanceId); } while (0); return ret; } STATIC FUNC(Std_ReturnType, UT_CODE) UT__TcpConnectProcessor ( P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) TestCtxPtr, P2VAR(uint8, AUTOMATIC, AUTOMATIC) ParamPtr, uint16 ParamLength ) { UT_SockAddrType address; uint16 socketId; uint16 consumed; UT_TestInstanceIdType instanceId; Std_ReturnType ret = UT_RESULT_E_INV; do { if (!UT_IS_ACTIVE(TestCtxPtr)) { break; } if ((UT_TCP_CONNECT_IPV4_PARAM_LEN != ParamLength) && (UT_TCP_CONNECT_IPV6_PARAM_LEN != ParamLength)) { break; } /** * socketId uint16 * destPort uint16 * destAddr ipxaddr -> uint16 + uint8[] */ /*get socketId*/ consumed = UT__MakeSocketId(&socketId, ParamPtr); instanceId = UT__FindConnectInstance(TestCtxPtr, socketId); if (!UT_IS_VALID_CONNECT_INSTANCE(instanceId)) { ret = UT_RESULT_E_ISD; break; } consumed = UT__MakeIpAddressAndPort(&address, &ParamPtr[consumed], ParamLength - consumed); if (0 == consumed) { ret = UT_RESULT_E_INV; break; } if (TcpIp_TcpConnect(socketId, (P2CONST(TcpIp_SockAddrType, AUTOMATIC, AUTOMATIC))&address)) { ret = UT_RESULT_E_NOT_OK; } else { ret = UT_RESULT_E_OK; } } while (0); return ret; } STATIC FUNC(Std_ReturnType, UT_CODE) UT__TcpConfigureSocketProcessor ( P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) TestCtxPtr, P2VAR(uint8, AUTOMATIC, AUTOMATIC) ParamPtr, uint16 ParamLength ) { Std_ReturnType ret = UT_RESULT_E_INV; #if (UT_CONFIG_SOCKET_SUPPORTED == STD_ON) if (UT_IS_ACTIVE(TestCtxPtr) && (ParamLength >= UT_CONFIGSOCKET_PARAM_LEN_MIN)) { ret = UT__ConfigureSocket(TestCtxPtr, ParamPtr, ParamLength); } #endif return ret; } //================================================================= #if (UT_ICMP_SUPPORTED == STD_ON) STATIC FUNC(Std_ReturnType, UT_CODE) UT__IcmpEchoRequestProcessor ( P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) TestCtxPtr, P2VAR(uint8, AUTOMATIC, AUTOMATIC) ParamPtr, uint16 ParamLength ) { P2VAR(uint8, AUTOMATIC, AUTOMATIC) data; UT_SockAddrType address; uint16 consumed; uint16 dataLen; uint16 length; uint16 ipLen; Std_ReturnType ret = UT_RESULT_E_INV; do { if (!UT_IS_ACTIVE(TestCtxPtr)) { break; } if (ParamLength < UT_ICMP_ECHOREQUEST_PARAM_LEN_MIN) { break; } /** * ifName(Opt) text -> uint16 + BOM + uint8[] + '\0' * destAddr ipxaddr -> uint16 + uint8[] * data vint8 -> uint16 + uint8[] */ /*get ifName*/ consumed = UT__MakeVariableLength(&length, ParamPtr); if (length > 0) { /*the ifName parameter is NOT supported, so consume all bytes of it.*/ consumed += length; } if ((consumed < length) /*the ifName is too long.*/ || (consumed > (ParamLength - UT_IPADDRV4_PARAM_LEN))) { break; } /*get ipxaddr*/ consumed -= 2; /*There is a ipaddr without a port*/ length = UT__MakeIpAddressAndPort(&address, &ParamPtr[consumed], ParamLength - consumed); if (0 == length) { break; } address.port = TCPIP_PORT_ANY; /*clean invalid PORT*/ consumed += length; if (consumed > (ParamLength - 2)) { break; } /*get data*/ consumed += UT__MakeVariableLength(&dataLen, &ParamPtr[consumed]); if (dataLen != (ParamLength - consumed)) { break; } data = (dataLen > 0)? &ParamPtr[consumed]: NULL_PTR; ret = TcpIp_IcmpTransmit(TestCtxPtr->LocalAddrId, (P2CONST(TcpIp_SockAddrType, AUTOMATIC, AUTOMATIC))&address, 0, UT_ICMP_ECHOREQUEST_TYPE, 0, dataLen, data); if (ret != E_OK) { ret = UT_RESULT_E_NOT_OK; } } while (0); return ret; } #endif //================================================================= STATIC FUNC(Std_ReturnType, UT_CODE) UT__ParseMessageHeader ( P2VAR(UT_MessageHeaderType, AUTOMATIC, AUTOMATIC) HeaderPtr, P2VAR(uint8, AUTOMATIC, AUTOMATIC) MessagePtr, uint16 MessageLength ) { Std_ReturnType ret = UT_RESULT_E_INV; uint32 length; UT__CopyData((P2VAR(uint8, AUTOMATIC, AUTOMATIC))HeaderPtr, MessagePtr, UT_MESSAGE_HEADER_LEN); if ((UT_MESSAGE_SERVICE_ID_VALUE == HeaderPtr->ServiceId) && ((HeaderPtr->GroupId & UT_MESSAGE_GROUP_EVB_MASK) == 0) && (UT_MESSAGE_PROTOCOL_VERSION == HeaderPtr->ProtocolVer) && (UT_MESSAGE_INTERFACE_VERSION == HeaderPtr->InterfaceVer) && (UT_MESSAGE_TYPE_REQUEST == HeaderPtr->TypeId)) { length = UT_NTOHL(HeaderPtr->Length); if ((length >= UT_MESSAGE_NODATA_LEN) && ((length - UT_MESSAGE_NODATA_LEN) == (MessageLength - UT_MESSAGE_HEADER_LEN))) { HeaderPtr->Length = length; ret = UT_RESULT_E_OK; } } return ret; } STATIC FUNC(void, UT_CODE) UT__ReportResult ( P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) TestCtxPtr, P2VAR(UT_MessageHeaderType, AUTOMATIC, AUTOMATIC) HeaderPtr, P2CONST(UT_SockAddrType, AUTOMATIC, AUTOMATIC) RemoteAddrPtr, Std_ReturnType ResultId ) { uint16 length; P2CONST(TcpIp_SockAddrType, AUTOMATIC, AUTOMATIC) remoteAddr = (P2CONST(TcpIp_SockAddrType, AUTOMATIC, AUTOMATIC))RemoteAddrPtr; if (UT_RESULT_E_OK == ResultId) { length = TestCtxPtr->ResponseLen + UT_MESSAGE_NODATA_LEN; HeaderPtr->Length = UT_HTONL(length); HeaderPtr->ResultId = UT_RESULT_E_OK; length = UT_MESSAGE_HEADER_LEN + TestCtxPtr->ResponseLen; TestCtxPtr->ResponseLen = 0; } else { HeaderPtr->Length = UT_HTONL(UT_MESSAGE_NODATA_LEN); HeaderPtr->ResultId = (uint8)ResultId; length = UT_MESSAGE_HEADER_LEN; } /*fill message header of response*/ UT__CopyData(TestCtxPtr->ResponsePtr, (P2CONST(uint8, AUTOMATIC, AUTOMATIC))HeaderPtr, UT_MESSAGE_HEADER_LEN); (void)TcpIp_UdpTransmit(TestCtxPtr->SocketId, TestCtxPtr->ResponsePtr, remoteAddr, length); } STATIC FUNC(void, UT_CODE) UT__HandleCtrlMessage ( P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) TestCtxPtr, P2CONST(UT_SockAddrType, AUTOMATIC, AUTOMATIC) RemoteAddrPtr, P2VAR(uint8, AUTOMATIC, AUTOMATIC) MessagePtr, uint16 MessageLength ) { P2VAR(uint8, AUTOMATIC, AUTOMATIC) param; P2CONST(UT_ServiceGroupHandlerType, AUTOMATIC, AUTOMATIC) handler; uint16 paramLen; UT_MessageHeaderType header; Std_ReturnType ret; ret = UT__ParseMessageHeader(&header, MessagePtr, MessageLength); if (UT_RESULT_E_OK == ret) { if (UT_IS_VALID_GROUP(header.GroupId)) { handler = UT_GET_GROUP_HANDLER(header.GroupId); param = &MessagePtr[UT_MESSAGE_HEADER_LEN-1]; paramLen = MessageLength - UT_MESSAGE_HEADER_LEN; if (UT_IS_VALID_PRIMITIVE(handler, header.PrimitiveId)) { ret = UT_CALL_PRIMITIVE(handler, header.PrimitiveId, TestCtxPtr, param, paramLen); } #if (UT_PRIMITIVE_EXTENDED_NUM > 0) else if (UT_IS_VALID_EXTENDED_PRIMITIVE(handler, header.PrimitiveId)) { ret = UT_CALL_EXTENDED_PRIMITIVE(handler, header.PrimitiveId, TestCtxPtr, param, paramLen); } #endif else { ret = UT_RESULT_E_NTF; } } else { ret = UT_RESULT_E_NTF; } } if (UT_RESULT_E_OK == ret) { UT_COPY_SOCKADDR(&TestCtxPtr->RemoteAddr, RemoteAddrPtr); } UT_FILL_RESPONSE_HEADER(&UT_ResponseMessageHeader, header.GroupId, header.PrimitiveId); UT__ReportResult(TestCtxPtr, &UT_ResponseMessageHeader, RemoteAddrPtr, ret); } FUNC(uint16, UT_CODE) UT__FillIpAddress ( P2VAR(uint8, AUTOMATIC, AUTOMATIC) ResponsePtr, P2CONST(UT_SockAddrType, AUTOMATIC, AUTOMATIC) AddrPtr ) { UT_SockAddrType addr = {0}; uint16 ipLen; UT_COPY_SOCKADDR(&addr, AddrPtr); addr.addr[0] = UT_HTONL(addr.addr[0]); #if (UT_IPV6_SUPPORTED == STD_ON) if (TCPIP_AF_INET6 == addr.domain) { addr.addr[1] = UT_HTONL(addr.addr[1]); addr.addr[2] = UT_HTONL(addr.addr[2]); addr.addr[3] = UT_HTONL(addr.addr[3]); } #endif ipLen = (addr.domain == TCPIP_AF_INET)? UT_IPADDRV4_LEN: UT_IPADDRV6_LEN; (*(P2VAR(uint16, AUTOMATIC, AUTOMATIC))ResponsePtr) = UT_HTONS(ipLen); UT__CopyData(&ResponsePtr[UT_IPADDR_LEN_PARAM_LEN], (P2VAR(uint8, AUTOMATIC, AUTOMATIC))addr.addr, ipLen); return ipLen + UT_IPADDR_LEN_PARAM_LEN; } FUNC(void, UT_CODE) UT__FillAccpetedEventMessage ( P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) TestCtxPtr, TcpIp_SocketIdType SocketId, TcpIp_SocketIdType SocketIdConnected, P2CONST(TcpIp_SockAddrType, AUTOMATIC, AUTOMATIC) RemoteAddrPtr ) { P2VAR(uint16, AUTOMATIC, AUTOMATIC) tmp; P2VAR(UT_SockAddrType, AUTOMATIC, AUTOMATIC) address; uint16 ipLen; /** * listenSocketId uint16 * newSocketId uint16 * port uint16 * address ipxaddr -> uint16 + uint8[] */ tmp = (P2VAR(uint16, AUTOMATIC, AUTOMATIC))UT_GET_RESPONSE_DATA_PTR(TestCtxPtr, 0); /*listenSocketId*/ tmp[0] = UT_HTONS(SocketId); /*newSocketId*/ tmp[1] = UT_HTONS(SocketIdConnected); /*port*/ address = (P2VAR(UT_SockAddrType, AUTOMATIC, AUTOMATIC))RemoteAddrPtr; tmp[2] = UT_HTONS(address->port); /*address*/ ipLen = UT__FillIpAddress(UT_GET_RESPONSE_DATA_PTR(TestCtxPtr, 6), address); UT_SET_RESPONSE_LEN(TestCtxPtr, ipLen + 6); } FUNC(void, UT_CODE) UT__ForwardTcpData ( P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) TestCtxPtr, uint16 FullLength, uint16 ForwardLength, P2CONST(uint8, AUTOMATIC, AUTOMATIC) DataPtr ) { P2VAR(uint16, AUTOMATIC, AUTOMATIC) length; P2VAR(uint8, AUTOMATIC, AUTOMATIC) data; /** * fullLen uint16 * payload vint8 -> uint16 + uint8[] */ length = (P2VAR(uint16, AUTOMATIC, AUTOMATIC))UT_GET_RESPONSE_DATA_PTR(TestCtxPtr, 0); /*fullLen*/ length[0] = UT_HTONS(FullLength); /*payload*/ length[1] = UT_HTONS(ForwardLength); data = (P2VAR(uint8, AUTOMATIC, AUTOMATIC))UT_GET_RESPONSE_DATA_PTR(TestCtxPtr, 4); UT__CopyData(data, DataPtr, ForwardLength); UT_SET_RESPONSE_LEN(TestCtxPtr, ForwardLength + 4); UT__ReportResult(TestCtxPtr, &UT_TcpRxAndForwardEventHeader, &TestCtxPtr->RemoteAddr, UT_RESULT_E_OK); } FUNC(void, UT_CODE) UT__ForwardUdpData ( P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) TestCtxPtr, P2CONST(UT_SockAddrType, AUTOMATIC, AUTOMATIC) SrcAddrPtr, uint16 FullLength, uint16 ForwardLength, P2VAR(uint8, AUTOMATIC, AUTOMATIC) DataPtr ) { P2VAR(uint16, AUTOMATIC, AUTOMATIC) length; uint16 offset; /** * fullLen uint16 * srcPort uint16 * srcAddr ipxaddr -> uint16 + uint8[] * payload vint8 -> uint16 + uint8[] */ length = (P2VAR(uint16, AUTOMATIC, AUTOMATIC))UT_GET_RESPONSE_DATA_PTR(TestCtxPtr, 0); /*fullLen*/ length[0] = UT_HTONS(FullLength); /*srcPort*/ length[1] = UT_HTONS(SrcAddrPtr->port); /*srcAddr*/ offset = 4; offset += UT__FillIpAddress(UT_GET_RESPONSE_DATA_PTR(TestCtxPtr, 4), SrcAddrPtr); /*payload*/ length[offset >> 1] = UT_HTONS(ForwardLength); UT__CopyData(UT_GET_RESPONSE_DATA_PTR(TestCtxPtr, offset + 2), DataPtr, ForwardLength); UT_SET_RESPONSE_LEN(TestCtxPtr, ForwardLength + offset + 2); UT__ReportResult(TestCtxPtr, &UT_UdpRxAndForwardEventHeader, &TestCtxPtr->RemoteAddr, UT_RESULT_E_OK); } FUNC(void, UT_CODE) UT__ForwardRxData ( P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) TestCtxPtr, TcpIp_SocketIdType SocketId, P2CONST(UT_SockAddrType, AUTOMATIC, AUTOMATIC) RemoteAddrPtr, P2VAR(uint8, AUTOMATIC, AUTOMATIC) DataPtr, uint16 DataLength ) { P2VAR(UT_ConnectInstanceType, AUTOMATIC, AUTOMATIC) instance; UT_TestInstanceIdType instanceId; uint16 consumed; uint16 forwarded; uint16 received; instanceId = UT__FindConnectInstance(TestCtxPtr, SocketId); if (UT_IS_VALID_CONNECT_INSTANCE(instanceId)) { instance = UT_GET_CONNECT_INSTANCE(TestCtxPtr, instanceId); if (instance->RemainLen > 0) { consumed = UT_MIN(instance->RemainLen, DataLength); forwarded = UT_MIN(instance->MaxFwd, consumed); received = DataLength - consumed; instance->RemainLen -= consumed; if (0 == instance->RemainLen) { instance->ReceivedLen = received; } if (UT_IS_TCP_INSTANCE(TestCtxPtr, instanceId)) { UT__ForwardTcpData(TestCtxPtr, DataLength, forwarded, DataPtr); TcpIp_TcpReceived(SocketId, consumed); } else { UT__ForwardUdpData(TestCtxPtr, RemoteAddrPtr, DataLength, forwarded, DataPtr); } } else { instance->ReceivedLen += DataLength; } } } /****************************************************************************** * Global Function Define ******************************************************************************/ FUNC(void, UT_CODE) UT_RxIndication ( TcpIp_SocketIdType SocketId, P2CONST(TcpIp_SockAddrType, AUTOMATIC, AUTOMATIC) RemoteAddrPtr, P2VAR(uint8, AUTOMATIC, AUTOMATIC) DataPtr, uint16 DataLength ) { P2CONST(UT_SockAddrType, AUTOMATIC, AUTOMATIC) remoteAddr = (P2CONST(UT_SockAddrType, AUTOMATIC, AUTOMATIC))RemoteAddrPtr; P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) ctx = &UT_TestContext; if (!UT_IS_USABLE(ctx) || (0 == DataLength) || (NULL_PTR == DataPtr) || (NULL_PTR == RemoteAddrPtr)) { /*do nothing*/ } else if (ctx->SocketId == SocketId) { if (DataLength >= UT_MESSAGE_HEADER_LEN) { UT__HandleCtrlMessage(ctx, remoteAddr, DataPtr, DataLength); } } else { UT__ForwardRxData(ctx, SocketId, remoteAddr, DataPtr, DataLength); } } FUNC(BufReq_ReturnType, UT_CODE) UT_CopyTxData ( TcpIp_SocketIdType SocketId, P2VAR(uint8, AUTOMATIC, AUTOMATIC) BufferPtr, uint16 BufferLength ) { P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) ctx = &UT_TestContext; P2VAR(UT_ConnectInstanceType, AUTOMATIC, AUTOMATIC) instance; UT_TestInstanceIdType instanceId; BufReq_ReturnType ret = BUFREQ_E_NOT_OK; uint16 copyLen; instanceId = UT__FindConnectInstance(ctx, SocketId); if (UT_IS_VALID_CONNECT_INSTANCE(instanceId) && (BufferLength > 0)) { instance = UT_GET_CONNECT_INSTANCE(ctx, instanceId); while (BufferLength > 0) { copyLen = UT_MIN(BufferLength, instance->SendDataLen); UT__CopyData(BufferPtr, instance->SendDataPtr, copyLen); BufferLength -= copyLen; BufferPtr = &BufferPtr[copyLen]; } ret = BUFREQ_OK; } return ret; } FUNC(void, UT_CODE) UT_TxConfirmation ( TcpIp_SocketIdType SocketId, uint16 Length ) { UT_UNUSED(SocketId); UT_UNUSED(Length); } FUNC(Std_ReturnType, UT_CODE) UT_TcpAccepted ( TcpIp_SocketIdType SocketId, TcpIp_SocketIdType SocketIdConnected, P2CONST(TcpIp_SockAddrType, AUTOMATIC, AUTOMATIC) RemoteAddrPtr ) { P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) ctx = &UT_TestContext; P2VAR(UT_ListenInstanceType, AUTOMATIC, AUTOMATIC) listen; Std_ReturnType ret = E_NOT_OK; UT_TestInstanceIdType listenInstanceId; listenInstanceId = UT__FindListenInstance(ctx, SocketId); if (UT_IS_VALID_LISTEN_INSTANCE(listenInstanceId)) { listen = UT_GET_LISTEN_INSTANCE(ctx, listenInstanceId); if (listen->Connections < listen->MaxConnections) { listen->Connections++; ret = UT__AllocConnectInstance(ctx, listenInstanceId, TCPIP_IPPROTO_TCP, SocketIdConnected, listen->LocalAddrId, listen->LocalPort); if (ret != UT_RESULT_E_OK) { listen->Connections--; } } else { ret = UT_RESULT_E_UCS; } } if (E_OK == ret) { UT__FillAccpetedEventMessage(ctx, SocketId, SocketIdConnected, RemoteAddrPtr); } UT__ReportResult(ctx, &UT_TcpAcceptedEventHeader, &ctx->RemoteAddr, ret); return ret; } FUNC(void, UT_CODE) UT_TcpConnected ( TcpIp_SocketIdType SocketId ) { UT_UNUSED(SocketId); } FUNC(void, UT_CODE) UT_TcpIpEvent ( TcpIp_SocketIdType SocketId, TcpIp_EventType Event ) { P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) ctx = &UT_TestContext; P2VAR(UT_ConnectInstanceType, AUTOMATIC, AUTOMATIC) connect; P2VAR(UT_ListenInstanceType, AUTOMATIC, AUTOMATIC) listen; UT_TestInstanceIdType instanceId; switch (Event) { case TCPIP_TCP_RESET : case TCPIP_TCP_CLOSED : instanceId = UT__FindConnectInstance(ctx, SocketId); if (UT_IS_VALID_CONNECT_INSTANCE(instanceId)) { connect = UT_GET_CONNECT_INSTANCE(ctx, instanceId); if (UT_IS_VALID_LISTEN_INSTANCE(connect->ListenId)) { listen = UT_GET_LISTEN_INSTANCE(ctx, connect->ListenId); if (listen->Connections > 0) { listen->Connections--; } } UT__ReleaseConnectInstance(ctx, instanceId); } else { instanceId = UT__FindListenInstance(ctx, SocketId); if (UT_IS_VALID_LISTEN_INSTANCE(instanceId)) { UT__ReleaseListenInstance(ctx, instanceId); } } break; case TCPIP_TCP_FIN_RECEIVED : instanceId = UT__FindConnectInstance(ctx, SocketId); if (UT_IS_VALID_CONNECT_INSTANCE(instanceId)) { connect = UT_GET_CONNECT_INSTANCE(ctx, instanceId); if (UT_INSTANCE_IS_RXONLY(connect)) { UT__ReleaseConnectInstance(ctx, instanceId); } else { UT_INSTANCE_SET_TXONLY(connect); } } break; case TCPIP_UDP_CLOSED : if (UT_IS_IDLE(ctx) || UT_IS_ACTIVE(ctx)) { if (SocketId == ctx->SocketId) { if (UT_IS_ACTIVE(ctx)) { UT__ClearTestContext(ctx); } ctx->SocketId = 0; UT_SET_WAIT(ctx); } else { instanceId = UT__FindConnectInstance(ctx, SocketId); if (UT_IS_VALID_CONNECT_INSTANCE(instanceId)) { UT__ReleaseConnectInstance(ctx, instanceId); } } } break; } } FUNC(void, UT_CODE) UT_LocalIpAddrAssignmentChg ( TcpIp_LocalAddrIdType IpAddrId, TcpIp_IpAddrStateType State ) { P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) ctx = &UT_TestContext; UT_SockAddrType dummyAddr; if (ctx->LocalAddrId == IpAddrId) { ctx->LocalAddrState = State; } if (IpAddrId < UT_LOCALADDR_MAX) { if ((TCPIP_IPADDR_STATE_ASSIGNED == State) && (ctx->LocalIpAddr[IpAddrId].State != State)) { dummyAddr.domain = ctx->LocalIpAddr[IpAddrId].LocalAddr.domain; (void)TcpIp_GetIpAddr(IpAddrId, (P2VAR(TcpIp_SockAddrType, AUTOMATIC, AUTOMATIC))&(ctx->LocalIpAddr[IpAddrId].LocalAddr), &(ctx->LocalIpAddr[IpAddrId].Netmask), (P2VAR(TcpIp_SockAddrType, AUTOMATIC, AUTOMATIC))&dummyAddr); } ctx->LocalIpAddr[IpAddrId].State = State; } } FUNC(void, UT_CODE) UT_MainFunction ( void ) { P2VAR(UT_TestContextType, AUTOMATIC, AUTOMATIC) ctx = &UT_TestContext; TcpIp_SocketIdType socketId; Std_ReturnType ret; if (TCPIP_IPADDR_STATE_ASSIGNED == ctx->LocalAddrState) { if (UT_IS_WAIT(ctx)) { ret = UT_GetSocket(TCPIP_AF_INET, TCPIP_IPPROTO_UDP, &ctx->SocketId); if (ret != E_OK) { /*do nothing*/ } else if (TcpIp_Bind(ctx->SocketId, ctx->LocalAddrId, &ctx->LocalPort) == E_OK) { UT_SET_IDLE(ctx); } else { (void)TcpIp_Close(ctx->SocketId, FALSE); ctx->SocketId = 0; } } } else { if (UT_IS_USABLE(ctx)) { socketId = ctx->SocketId; UT__ClearTestContext(ctx); ctx->SocketId = 0; UT_SET_WAIT(ctx); (void)TcpIp_Close(socketId, FALSE); } } } FUNC(void, UT_CODE) UT_Init ( void ) { TcpIp_LocalAddrIdType i; UT_TestInstanceIdType id; for (i = 0; i < UT_LOCALADDR_MAX; i++) { UT_LocalAddresses[i].State = TCPIP_IPADDR_STATE_UNASSIGNED; UT_LocalAddresses[i].LocalAddr.domain = UT_GET_LOCALADDR_DOMAIN_CONFIG(i); } UT_TestContext.ConnectInstancePtr = UT_ConnectInstances; UT_TestContext.ListenInstancePtr = UT_ListenInstances; UT_TestContext.ResponsePtr = (P2VAR(uint8, AUTOMATIC, AUTOMATIC))UT_TestResponse; UT_TestContext.LocalIpAddr = UT_LocalAddresses; for (id = 0; id < UT_TEST_LISTEN_INSTANCE_MAX; id++) { UT__ReleaseListenInstance(&UT_TestContext, id); } for (id = 0; id < UT_TEST_CONNECT_INSTANCE_MAX; id++) { UT__ReleaseConnectInstance(&UT_TestContext, id); } UT_TestContext.LocalAddrId = UT_MESSAGE_LISTEN_LOCALADDRID; UT_TestContext.LocalPort = UT_MESSAGE_LISTEN_PORT; UT_TestContext.SocketId = 0; UT_TestContext.ResponseLen = 0; UT_SET_WAIT(&UT_TestContext); }