hostlib/hostLib/libCommon/smCom/smComSocket_win32.c - a71ch-crypto-support - Git at Google

 /**
  * @file smComSocket_win32.c
  * @author NXP Semiconductors
  * @version 1.0
  * @par License
  *
  * Copyright 2016,2020 NXP
  * SPDX-License-Identifier: Apache-2.0
  *
  * @par Description
  *
  */

 #include <string.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <assert.h>
 #include <string.h>
 #include "sm_printf.h"

 #define WIN32_LEAN_AND_MEAN

 #include <windows.h>
 #include <winsock2.h>
 #include <ws2tcpip.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <assert.h>
 #include "nxLog_smCom.h"
 #include "nxEnsure.h"

 // Need to link with Ws2_32.lib, Mswsock.lib, and Advapi32.lib
 #pragma comment (lib, "Ws2_32.lib")
 #pragma comment (lib, "Mswsock.lib")
 #pragma comment (lib, "AdvApi32.lib")
 #define DEFAULT_PROTO SOCK_STREAM

 #define DBG_OUT CONSOLE

 #include "smCom.h"
 #include "smComSocket.h"

 // Enable define of LOG_SOCK to echo APDU cmd/rsp
 // #define LOG_SOCK

 // Enable define of CHECK_ON_ATR to enable check on returned ATR (don't enable this when using the Smart Card Server ...)
 // #define CHECK_ON_ATR

 #define REMOTE_JC_SHELL_HEADER_LEN          (4)
 #define REMOTE_JC_SHELL_MSG_TYPE_APDU_DATA  (0x01)

 #include "sm_apdu.h"
 #define MAX_BUF_SIZE                (MAX_APDU_BUF_LENGTH)

 typedef struct
 {
     int sockfd;
     char * ipString;
 } socket_Context_t;

 static U8 Header[2] = {0x01,0x00};
 static U8 sockapdu[MAX_BUF_SIZE];
 static U8 response[MAX_BUF_SIZE];
 static U8 * pCmd = (U8*) &sockapdu;
 static U8 * pRsp = (U8*) &response;

 static socket_Context_t sockCtx;
 static socket_Context_t* pSockCtx = (socket_Context_t *)&sockCtx;

 static U32 smComSocket_GetATR(U8 *pAtr, U16 *atrLen);

 U16 smComSocket_Close()
 {
     closesocket(pSockCtx->sockfd);
     return SW_OK;
 }

 U16 smComSocket_Open(void** conn_ctx, U8 *pIpAddrString, U16 portNo, U8 *pAtr, U16 *atrLen)
 {
     int retval;
     int nAtr = 0;
     char *server_name= (char*) pIpAddrString;
     int iResult;
     struct addrinfo *result = NULL,
         *ptr = NULL,
         hints;
     char service[128];
     WSADATA wsaData;
     U16 sw = SMCOM_OK;

     if ((retval = WSAStartup(0x202, &wsaData)) != 0)
     {
         sm_printf(DBG_OUT,"WSAStartup failed; error %d\n", retval);
         WSACleanup();
         return SMCOM_COM_FAILED;
     }
     else
     {
 #ifdef LOG_SOCK
         sm_printf(DBG_OUT, "WSAStartup: OK\n");
 #endif
     }

     ZeroMemory(&hints, sizeof(hints));
     hints.ai_family = AF_INET;
     hints.ai_socktype = SOCK_STREAM;
     hints.ai_protocol = IPPROTO_TCP;

     // Resolve the server address and port
     sprintf(service, "%d", portNo);
     iResult = getaddrinfo(server_name, service, &hints, &result);
     if (iResult != 0) {
         sm_printf(DBG_OUT, "getaddrinfo failed with error: %d\n", iResult);
         WSACleanup();
         return SMCOM_COM_FAILED;
     }

     // Attempt to connect to an address until one succeeds
     for (ptr = result; ptr != NULL; ptr = ptr->ai_next) {
         // Create a SOCKET for connecting to server
         pSockCtx->sockfd = socket(ptr->ai_family, ptr->ai_socktype,
             ptr->ai_protocol);
         if (pSockCtx->sockfd == INVALID_SOCKET) {
             sm_printf(DBG_OUT, "socket failed with error: %ld\n", WSAGetLastError());
             freeaddrinfo(result);
             WSACleanup();
             return SMCOM_COM_FAILED;
         }

         // Connect to server.
         iResult = connect(pSockCtx->sockfd, ptr->ai_addr, (int)ptr->ai_addrlen);
         if (iResult == SOCKET_ERROR) {
             closesocket(pSockCtx->sockfd);
             pSockCtx->sockfd = INVALID_SOCKET;
             continue;
         }
         break;
     }

     freeaddrinfo(result);

     if (pSockCtx->sockfd == INVALID_SOCKET) {
         sm_printf(DBG_OUT, "Unable to connect to server!\n");
         WSACleanup();
         return SMCOM_COM_FAILED;
     }

     smCom_Init(smComSocket_Transceive, smComSocket_TransceiveRaw);

     nAtr = smComSocket_GetATR(pAtr, atrLen);
 #ifdef CHECK_ON_ATR
     // Be aware that the smart card server (java app on PC) does not return the ATR value
     // Do not enable this code when using the smart card server
     if (nAtr == 0)
     {
         sw = SMCOM_NO_ATR;
     }
 #endif

     return sw;
 }

 #if defined(TGT_A70CU)
 U16 smComSocket_Init(U8 *pIpAddrString, U16 portNo, U8 *pAtr, U16 *pAtrLength, U16 maxAtrLength)
 {
    int retval;
    char *server_name= (char*) pIpAddrString;
    unsigned int addr;
    int socket_type = DEFAULT_PROTO;
    struct sockaddr_in server;
    struct hostent *hp;
    WSADATA wsaData;
    U16 rv = 1;

    ENSURE_OR_GO_EXIT(pIpAddrString != NULL);
    if ((retval = WSAStartup(0x202, &wsaData)) != 0)
    {
       sm_printf(DBG_OUT,"WSAStartup failed; error %d\n", retval);
       WSACleanup();
       return 1;
    }
    else
    {
 #ifdef LOG_SOCK
       sm_printf(DBG_OUT, "WSAStartup: OK\n");
 #endif
    }

    if (isalpha(server_name[0])) // server address is a name
    {
       hp = gethostbyname(server_name);
    }
    else
    {
       addr = inet_addr(server_name);
       hp = gethostbyaddr((char *)&addr, 4, AF_INET);
    }

    if (hp == NULL )
    {
       sm_printf(DBG_OUT, "Client: Cannot resolve address \"%s\": Error %d\n", server_name, WSAGetLastError());
       WSACleanup();
       return 1;
    }
    else
    {
 #ifdef LOG_SOCK
       printf("Client: gethostbyaddr() is OK.\n");
 #endif
    }

    memset(&server, 0, sizeof(server));
    memcpy(&(server.sin_addr), hp->h_addr, hp->h_length);

    server.sin_family = hp->h_addrtype;
    server.sin_port = htons(portNo);

    pSockCtx->sockfd = socket(AF_INET, socket_type, 0); /* Open a socket */
    if (pSockCtx->sockfd < 0)
    {
       sm_printf(DBG_OUT, "Client: Error Opening socket: Error %d\n", WSAGetLastError());
       WSACleanup();
       return 1;
    }
    else
    {
 #ifdef LOG_SOCK
       sm_printf(DBG_OUT, "Client: socket() is OK.\n");
 #endif
    }

    // Notice that nothing in this code is specific to whether we
    // are using UDP or TCP.
    // We achieve this by using a simple trick.
    //    When connect() is called on a datagram socket, it does not
    //    actually establish the connection as a stream (TCP) socket
    //    would. Instead, TCP/IP establishes the remote half of the
    //    (LocalIPAddress, LocalPort, RemoteIP, RemotePort) mapping.
    //    This enables us to use send() and recv() on datagram sockets,
    //    instead of recvfrom() and sendto()
    sm_printf(DBG_OUT, "Client: Client connecting to: %s.\n", hp->h_name);
    if (connect(pSockCtx->sockfd, (struct sockaddr*)&server, sizeof(server)) == SOCKET_ERROR)
    {
       sm_printf(DBG_OUT, "Client: connect() failed: %d\n", WSAGetLastError());
       WSACleanup();
       return 1;
    }

     smCom_Init(smComSocket_Transceive, smComSocket_TransceiveRaw);

     smComSocket_GetATR(pAtr, pAtrLength);

     rv = 0;
 exit:
     return rv;
 }
 #endif // TGT_A70CU

 /**
     Remote JC Terminal spec:
     Wait for card (MTY=0x00)
     The payload contains four bytes denoting the time in milliseconds the remote part will wait for card insertion.
     The bytes are sent in big endian format.

     The reply message contains the full ATR as payload.
     A reply message with 0 bytes length means that the terminal could not trigger an ATR (reason might be retrieved using MTY=3 or MTY=2.
 */
 static U32 smComSocket_GetATR(U8* pAtr, U16* atrLen)
 {
 #define MTY 0
 // #define NAD 0x21
 #define NAD 0x00

     int retval = 0;
 #if defined(LOG_SOCK) || defined(DBG_LOG_SOCK)
     int i;
 #endif
     U32 expectedLength = 0;
     U32 totalReceived = 0;
     U8 lengthReceived = 0;

     // wait 256 ms
     U8 ATRCmd[8] = {MTY, NAD, 0, 4, 0, 0, 1, 0};

 #ifdef LOG_SOCK
     sm_printf(CONSOLE, "   send: ATR\n");
     for (i=0; i < sizeof(ATRCmd); i++)
     {
        sm_printf(CONSOLE, "%02X", ATRCmd[i]);
     }
     sm_printf(CONSOLE, "\n");
 #endif

     ENSURE_OR_GO_EXIT(pAtr != NULL);
     ENSURE_OR_GO_EXIT(atrLen != NULL);

     retval = send(pSockCtx->sockfd, (const char*) ATRCmd, sizeof(ATRCmd), 0);
     if (retval < 0)
     {
        fprintf(stderr,"Client: send() failed: error %i.\n", retval);
        return 0;
     }

     expectedLength = REMOTE_JC_SHELL_HEADER_LEN; // remote JC shell header length

     while (totalReceived < expectedLength)
     {
         U32 maxCommLength;
         if (lengthReceived == 0)
         {
             maxCommLength = REMOTE_JC_SHELL_HEADER_LEN - totalReceived;
         }
         else
         {
             maxCommLength = expectedLength - totalReceived;
         }

         retval = recv(pSockCtx->sockfd, (char*) &pAtr[totalReceived], maxCommLength, 0);
         if (retval < 0)
         {
            fprintf(stderr,"Client: recv() failed: error %i.\n", retval);
            closesocket(pSockCtx->sockfd);
            retval = 0;
            goto exit;
         }
         else
         {
             totalReceived += retval;
         }
         if ((totalReceived >= REMOTE_JC_SHELL_HEADER_LEN) && (lengthReceived == 0))
         {
             expectedLength += ((pAtr[2]<<8) | (pAtr[3]));
             lengthReceived = 1;
         }
     }
     retval = totalReceived;

 #ifdef LOG_SOCK
     sm_printf(CONSOLE, "   full recv: ");
     for (i=0; i < retval; i++)
     {
        sm_printf(CONSOLE, "%02X", pAtr[i]);
     }
     sm_printf(CONSOLE, "\n");
 #endif

     retval -= 4; // Remove the 4 bytes of the Remote JC Terminal protocol
     memmove(pAtr, pAtr + 4, retval);

 #ifdef LOG_SOCK
     sm_printf(CONSOLE, "   recv: ");
     for (i=0; i < retval; i++)
     {
        sm_printf(CONSOLE, "%02X", pAtr[i]);
     }
     sm_printf(CONSOLE, "\n");
 #endif

     *atrLen = (U16) retval;
 exit:
     return retval;
 }

 U32 smComSocket_Transceive(void* conn_ctx, apdu_t * pApdu)
 {
     int retval;
 #if defined(LOG_SOCK)
     int i;
 #endif
     U32 txLen = 0;
     U32 expectedLength = 0;
     U32 totalReceived = 0;
     U8 lengthReceived = 0;
     U32 rv = SMCOM_SND_FAILED;

     ENSURE_OR_GO_EXIT(pApdu != NULL);

     pApdu->rxlen = 0;

     memset(sockapdu, 0x00, MAX_BUF_SIZE);
     memset(response, 0x00, MAX_BUF_SIZE);

     // remote JC Terminal header construction
     txLen = pApdu->buflen;
     memcpy(pCmd, Header, sizeof(Header));
     pCmd[2] = (txLen& 0xFF00)>>8;
     pCmd[3] = txLen & 0xFF;
     memcpy(&pCmd[4], pApdu->pBuf, pApdu->buflen);
     pApdu->buflen += 4; /* header & length */

 #ifdef LOG_SOCK
     sm_printf(CONSOLE, "   send: ");
     for (i=4; i < (int)(txLen+4); i++)
     {
        sm_printf(CONSOLE, "%02X", pCmd[i]);
     }
     sm_printf(CONSOLE, "\n");
 #endif

     retval = send(pSockCtx->sockfd, (const char*) pCmd, pApdu->buflen, 0);
     if (retval < 0)
     {
        fprintf(stderr,"Client: send() failed: error %i.\n", retval);
        return SMCOM_SND_FAILED;
     }

     expectedLength = REMOTE_JC_SHELL_HEADER_LEN; // remote JC shell header length

     while (totalReceived < expectedLength)
     {
         retval = recv(pSockCtx->sockfd, (char*) &pRsp[totalReceived], MAX_BUF_SIZE, 0);
         if (retval < 0)
         {
            fprintf(stderr,"Client: recv() failed: error %i.\n", retval);
            closesocket(pSockCtx->sockfd);
            rv = SMCOM_RCV_FAILED;
            goto exit;
         }
         else
         {
             totalReceived += retval;
         }
         if ((totalReceived >= REMOTE_JC_SHELL_HEADER_LEN) && (lengthReceived == 0))
         {
             expectedLength += ((pRsp[2]<<8) | (pRsp[3]));
             lengthReceived = 1;
         }
     }
     retval = totalReceived;

     retval -= 4; // Remove the 4 bytes of the Remote JC Terminal protocol
     memcpy(pApdu->pBuf, &pRsp[4], retval);

 #ifdef LOG_SOCK
     sm_printf(CONSOLE, "   recv: ");
     for (i=0; i < retval; i++)
     {
        sm_printf(CONSOLE, "%02X", pApdu->pBuf[i]);
     }
     sm_printf(CONSOLE, "\n");
 #endif

     pApdu->rxlen = (U16) retval;
     // reset offset for subsequent response parsing
     pApdu->offset = 0;
     rv = SMCOM_OK;
 exit:
     return rv;
 }

 U32 smComSocket_TransceiveRaw(void* conn_ctx, U8 * pTx, U16 txLen, U8 * pRx, U32 * pRxLen)
 {
     S32 retval;
     U32 answerReceived = 0;
     U32 len = 0;
 #if defined(LOG_SOCK) || defined(DBG_LOG_SOCK)
     int i;
 #endif
     U32 readOffset = 0;
     U8 headerParsed = 0;
     U8 correctHeader = 0;
     U32 rv = SMCOM_COM_FAILED;

     ENSURE_OR_GO_EXIT(pTx != NULL);
     ENSURE_OR_GO_EXIT(pRx != NULL);
     ENSURE_OR_GO_EXIT(pRxLen != NULL);

     memset(sockapdu, 0x00, MAX_BUF_SIZE);
     memset(response, 0x00, MAX_BUF_SIZE);

     memcpy(pCmd, Header, 2);
     pCmd[2] = (txLen & 0xFF00)>>8;
     pCmd[3] = (txLen & 0x00FF);
     memcpy(&pCmd[4], pTx, txLen);
     txLen += 4; /* header + len */

 #ifdef DBG_LOG_SOCK
     sm_printf(CONSOLE, "   full send: ");
     for (i=0; i < txLen; i++)
     {
         sm_printf(CONSOLE, "%02X", pCmd[i]);
     }
     sm_printf(CONSOLE, "\n");
 #endif

     retval = send(pSockCtx->sockfd, (const char*) pCmd, txLen, 0);
     if (retval < 0)
     {
         sm_printf(CONSOLE, "Client: send() failed: error %i.\n", retval);
         return SMCOM_SND_FAILED;
     }
     else
     {
 #ifdef DBG_LOG_SOCK
         sm_printf(CONSOLE, "Client: send() is OK.\n");
 #endif
     }

 #ifdef LOG_SOCK
     sm_printf(CONSOLE, "   send: ");
     for (i=4; i < txLen; i++)
     {
         sm_printf(CONSOLE, "%02X", pCmd[i]);
     }
     sm_printf(CONSOLE, "\n");
 #endif

     retval = REMOTE_JC_SHELL_HEADER_LEN; // receive at least the JCTerminal header

     while ((retval > 0) || (answerReceived == 0))
     {
         retval = recv(pSockCtx->sockfd, (char*) pRsp, MAX_BUF_SIZE, 0);

         if (retval < 0)
         {
            fprintf(stderr,"Client: recv() failed: error %i %x\n", retval, WSAGetLastError());

            closesocket(pSockCtx->sockfd);
            return SMCOM_RCV_FAILED;
         }
         else // data received
         {
             while (retval > 0) // parse all bytes
             {
                 if (headerParsed == 1) // header already parsed; get data
                 {
                     if (retval >= (S32) len)
                     {
                         if (correctHeader == 1)
                         {
                             memcpy(&pRx[0], &pRsp[readOffset], len);
                             answerReceived = 1;
                         }
                         else
                         {
                             // reset header parsed
                             readOffset += len;
                             headerParsed = 0;
                         }
                         retval -= len;

                         if (retval == 0) // no data left, reset readOffset
                         {
                             readOffset = 0;
                         }
                     }
                     else
                     {
                         // data too small according header => Error
                         fprintf(stderr,"Failed reading data %x %x\n", retval, len);
                         return SMCOM_RCV_FAILED;
                     }
                 }
                 else // parse header
                 {
                     len = ((pRsp[readOffset + 2]<<8) | (pRsp[readOffset + 3]));

                     if (pRsp[readOffset] == REMOTE_JC_SHELL_MSG_TYPE_APDU_DATA)
                     {
                         // type correct => copy the data
                         retval -= REMOTE_JC_SHELL_HEADER_LEN;
                         if (retval > 0) // data left to read
                         {
                             readOffset += REMOTE_JC_SHELL_HEADER_LEN;
                         }
                         correctHeader = 1;
                     }
                     else
                     {
                         // type incorrect => skip the data as well and try again if data are left
                         readOffset += REMOTE_JC_SHELL_HEADER_LEN;
                         retval -= REMOTE_JC_SHELL_HEADER_LEN;
                         correctHeader = 0;
                     }
                     headerParsed = 1;
                 }
             }
         }
     }

 #ifdef LOG_SOCK
     sm_printf(CONSOLE, "   recv: ");
     for (i=0; i < (int)len; i++)
     {
        sm_printf(CONSOLE, "%02X", pRx[i]);
     }
     sm_printf(CONSOLE, "\n");
 #endif

     *pRxLen = len;

     rv = SMCOM_OK;
 exit:
     return rv;
 }
	/**
	* @file smComSocket_win32.c
	* @author NXP Semiconductors
	* @version 1.0
	* @par License
	*
	* Copyright 2016,2020 NXP
	* SPDX-License-Identifier: Apache-2.0
	*
	* @par Description
	*
	*/

	#include <string.h>
	#include <stdint.h>
	#include <stdio.h>
	#include <assert.h>
	#include <string.h>
	#include "sm_printf.h"

	#define WIN32_LEAN_AND_MEAN

	#include <windows.h>
	#include <winsock2.h>
	#include <ws2tcpip.h>
	#include <stdlib.h>
	#include <stdio.h>
	#include <assert.h>
	#include "nxLog_smCom.h"
	#include "nxEnsure.h"

	// Need to link with Ws2_32.lib, Mswsock.lib, and Advapi32.lib
	#pragma comment (lib, "Ws2_32.lib")
	#pragma comment (lib, "Mswsock.lib")
	#pragma comment (lib, "AdvApi32.lib")
	#define DEFAULT_PROTO SOCK_STREAM

	#define DBG_OUT CONSOLE

	#include "smCom.h"
	#include "smComSocket.h"

	// Enable define of LOG_SOCK to echo APDU cmd/rsp
	// #define LOG_SOCK

	// Enable define of CHECK_ON_ATR to enable check on returned ATR (don't enable this when using the Smart Card Server ...)
	// #define CHECK_ON_ATR

	#define REMOTE_JC_SHELL_HEADER_LEN (4)
	#define REMOTE_JC_SHELL_MSG_TYPE_APDU_DATA (0x01)

	#include "sm_apdu.h"
	#define MAX_BUF_SIZE (MAX_APDU_BUF_LENGTH)

	typedef struct
	{
	int sockfd;
	char * ipString;
	} socket_Context_t;

	static U8 Header[2] = {0x01,0x00};
	static U8 sockapdu[MAX_BUF_SIZE];
	static U8 response[MAX_BUF_SIZE];
	static U8 * pCmd = (U8*) &sockapdu;
	static U8 * pRsp = (U8*) &response;

	static socket_Context_t sockCtx;
	static socket_Context_t* pSockCtx = (socket_Context_t *)&sockCtx;

	static U32 smComSocket_GetATR(U8 pAtr, U16 atrLen);

	U16 smComSocket_Close()
	{
	closesocket(pSockCtx->sockfd);
	return SW_OK;
	}

	U16 smComSocket_Open(void** conn_ctx, U8 pIpAddrString, U16 portNo, U8 pAtr, U16 *atrLen)
	{
	int retval;
	int nAtr = 0;
	char server_name= (char) pIpAddrString;
	int iResult;
	struct addrinfo *result = NULL,
	*ptr = NULL,
	hints;
	char service[128];
	WSADATA wsaData;
	U16 sw = SMCOM_OK;

	if ((retval = WSAStartup(0x202, &wsaData)) != 0)
	{
	sm_printf(DBG_OUT,"WSAStartup failed; error %d\n", retval);
	WSACleanup();
	return SMCOM_COM_FAILED;
	}
	else
	{
	#ifdef LOG_SOCK
	sm_printf(DBG_OUT, "WSAStartup: OK\n");
	#endif
	}

	ZeroMemory(&hints, sizeof(hints));
	hints.ai_family = AF_INET;
	hints.ai_socktype = SOCK_STREAM;
	hints.ai_protocol = IPPROTO_TCP;

	// Resolve the server address and port
	sprintf(service, "%d", portNo);
	iResult = getaddrinfo(server_name, service, &hints, &result);
	if (iResult != 0) {
	sm_printf(DBG_OUT, "getaddrinfo failed with error: %d\n", iResult);
	WSACleanup();
	return SMCOM_COM_FAILED;
	}

	// Attempt to connect to an address until one succeeds
	for (ptr = result; ptr != NULL; ptr = ptr->ai_next) {
	// Create a SOCKET for connecting to server
	pSockCtx->sockfd = socket(ptr->ai_family, ptr->ai_socktype,
	ptr->ai_protocol);
	if (pSockCtx->sockfd == INVALID_SOCKET) {
	sm_printf(DBG_OUT, "socket failed with error: %ld\n", WSAGetLastError());
	freeaddrinfo(result);
	WSACleanup();
	return SMCOM_COM_FAILED;
	}

	// Connect to server.
	iResult = connect(pSockCtx->sockfd, ptr->ai_addr, (int)ptr->ai_addrlen);
	if (iResult == SOCKET_ERROR) {
	closesocket(pSockCtx->sockfd);
	pSockCtx->sockfd = INVALID_SOCKET;
	continue;
	}
	break;
	}

	freeaddrinfo(result);

	if (pSockCtx->sockfd == INVALID_SOCKET) {
	sm_printf(DBG_OUT, "Unable to connect to server!\n");
	WSACleanup();
	return SMCOM_COM_FAILED;
	}

	smCom_Init(smComSocket_Transceive, smComSocket_TransceiveRaw);

	nAtr = smComSocket_GetATR(pAtr, atrLen);
	#ifdef CHECK_ON_ATR
	// Be aware that the smart card server (java app on PC) does not return the ATR value
	// Do not enable this code when using the smart card server
	if (nAtr == 0)
	{
	sw = SMCOM_NO_ATR;
	}
	#endif

	return sw;
	}

	#if defined(TGT_A70CU)
	U16 smComSocket_Init(U8 pIpAddrString, U16 portNo, U8 pAtr, U16 *pAtrLength, U16 maxAtrLength)
	{
	int retval;
	char server_name= (char) pIpAddrString;
	unsigned int addr;
	int socket_type = DEFAULT_PROTO;
	struct sockaddr_in server;
	struct hostent *hp;
	WSADATA wsaData;
	U16 rv = 1;

	ENSURE_OR_GO_EXIT(pIpAddrString != NULL);
	if ((retval = WSAStartup(0x202, &wsaData)) != 0)
	{
	sm_printf(DBG_OUT,"WSAStartup failed; error %d\n", retval);
	WSACleanup();
	return 1;
	}
	else
	{
	#ifdef LOG_SOCK
	sm_printf(DBG_OUT, "WSAStartup: OK\n");
	#endif
	}

	if (isalpha(server_name[0])) // server address is a name
	{
	hp = gethostbyname(server_name);
	}
	else
	{
	addr = inet_addr(server_name);
	hp = gethostbyaddr((char *)&addr, 4, AF_INET);
	}

	if (hp == NULL )
	{
	sm_printf(DBG_OUT, "Client: Cannot resolve address \"%s\": Error %d\n", server_name, WSAGetLastError());
	WSACleanup();
	return 1;
	}
	else
	{
	#ifdef LOG_SOCK
	printf("Client: gethostbyaddr() is OK.\n");
	#endif
	}

	memset(&server, 0, sizeof(server));
	memcpy(&(server.sin_addr), hp->h_addr, hp->h_length);

	server.sin_family = hp->h_addrtype;
	server.sin_port = htons(portNo);

	pSockCtx->sockfd = socket(AF_INET, socket_type, 0); /* Open a socket */
	if (pSockCtx->sockfd < 0)
	{
	sm_printf(DBG_OUT, "Client: Error Opening socket: Error %d\n", WSAGetLastError());
	WSACleanup();
	return 1;
	}
	else
	{
	#ifdef LOG_SOCK
	sm_printf(DBG_OUT, "Client: socket() is OK.\n");
	#endif
	}

	// Notice that nothing in this code is specific to whether we
	// are using UDP or TCP.
	// We achieve this by using a simple trick.
	// When connect() is called on a datagram socket, it does not
	// actually establish the connection as a stream (TCP) socket
	// would. Instead, TCP/IP establishes the remote half of the
	// (LocalIPAddress, LocalPort, RemoteIP, RemotePort) mapping.
	// This enables us to use send() and recv() on datagram sockets,
	// instead of recvfrom() and sendto()
	sm_printf(DBG_OUT, "Client: Client connecting to: %s.\n", hp->h_name);
	if (connect(pSockCtx->sockfd, (struct sockaddr*)&server, sizeof(server)) == SOCKET_ERROR)
	{
	sm_printf(DBG_OUT, "Client: connect() failed: %d\n", WSAGetLastError());
	WSACleanup();
	return 1;
	}

	smCom_Init(smComSocket_Transceive, smComSocket_TransceiveRaw);

	smComSocket_GetATR(pAtr, pAtrLength);

	rv = 0;
	exit:
	return rv;
	}
	#endif // TGT_A70CU

	/**
	Remote JC Terminal spec:
	Wait for card (MTY=0x00)
	The payload contains four bytes denoting the time in milliseconds the remote part will wait for card insertion.
	The bytes are sent in big endian format.

	The reply message contains the full ATR as payload.
	A reply message with 0 bytes length means that the terminal could not trigger an ATR (reason might be retrieved using MTY=3 or MTY=2.
	*/
	static U32 smComSocket_GetATR(U8* pAtr, U16* atrLen)
	{
	#define MTY 0
	// #define NAD 0x21
	#define NAD 0x00

	int retval = 0;
	#if defined(LOG_SOCK) \|\| defined(DBG_LOG_SOCK)
	int i;
	#endif
	U32 expectedLength = 0;
	U32 totalReceived = 0;
	U8 lengthReceived = 0;

	// wait 256 ms
	U8 ATRCmd[8] = {MTY, NAD, 0, 4, 0, 0, 1, 0};

	#ifdef LOG_SOCK
	sm_printf(CONSOLE, " send: ATR\n");
	for (i=0; i < sizeof(ATRCmd); i++)
	{
	sm_printf(CONSOLE, "%02X", ATRCmd[i]);
	}
	sm_printf(CONSOLE, "\n");
	#endif

	ENSURE_OR_GO_EXIT(pAtr != NULL);
	ENSURE_OR_GO_EXIT(atrLen != NULL);

	retval = send(pSockCtx->sockfd, (const char*) ATRCmd, sizeof(ATRCmd), 0);
	if (retval < 0)
	{
	fprintf(stderr,"Client: send() failed: error %i.\n", retval);
	return 0;
	}

	expectedLength = REMOTE_JC_SHELL_HEADER_LEN; // remote JC shell header length

	while (totalReceived < expectedLength)
	{
	U32 maxCommLength;
	if (lengthReceived == 0)
	{
	maxCommLength = REMOTE_JC_SHELL_HEADER_LEN - totalReceived;
	}
	else
	{
	maxCommLength = expectedLength - totalReceived;
	}

	retval = recv(pSockCtx->sockfd, (char*) &pAtr[totalReceived], maxCommLength, 0);
	if (retval < 0)
	{
	fprintf(stderr,"Client: recv() failed: error %i.\n", retval);
	closesocket(pSockCtx->sockfd);
	retval = 0;
	goto exit;
	}
	else
	{
	totalReceived += retval;
	}
	if ((totalReceived >= REMOTE_JC_SHELL_HEADER_LEN) && (lengthReceived == 0))
	{
	expectedLength += ((pAtr[2]<<8) \| (pAtr[3]));
	lengthReceived = 1;
	}
	}
	retval = totalReceived;

	#ifdef LOG_SOCK
	sm_printf(CONSOLE, " full recv: ");
	for (i=0; i < retval; i++)
	{
	sm_printf(CONSOLE, "%02X", pAtr[i]);
	}
	sm_printf(CONSOLE, "\n");
	#endif

	retval -= 4; // Remove the 4 bytes of the Remote JC Terminal protocol
	memmove(pAtr, pAtr + 4, retval);

	#ifdef LOG_SOCK
	sm_printf(CONSOLE, " recv: ");
	for (i=0; i < retval; i++)
	{
	sm_printf(CONSOLE, "%02X", pAtr[i]);
	}
	sm_printf(CONSOLE, "\n");
	#endif

	*atrLen = (U16) retval;
	exit:
	return retval;
	}

	U32 smComSocket_Transceive(void* conn_ctx, apdu_t * pApdu)
	{
	int retval;
	#if defined(LOG_SOCK)
	int i;
	#endif
	U32 txLen = 0;
	U32 expectedLength = 0;
	U32 totalReceived = 0;
	U8 lengthReceived = 0;
	U32 rv = SMCOM_SND_FAILED;

	ENSURE_OR_GO_EXIT(pApdu != NULL);

	pApdu->rxlen = 0;

	memset(sockapdu, 0x00, MAX_BUF_SIZE);
	memset(response, 0x00, MAX_BUF_SIZE);

	// remote JC Terminal header construction
	txLen = pApdu->buflen;
	memcpy(pCmd, Header, sizeof(Header));
	pCmd[2] = (txLen& 0xFF00)>>8;
	pCmd[3] = txLen & 0xFF;
	memcpy(&pCmd[4], pApdu->pBuf, pApdu->buflen);
	pApdu->buflen += 4; /* header & length */

	#ifdef LOG_SOCK
	sm_printf(CONSOLE, " send: ");
	for (i=4; i < (int)(txLen+4); i++)
	{
	sm_printf(CONSOLE, "%02X", pCmd[i]);
	}
	sm_printf(CONSOLE, "\n");
	#endif

	retval = send(pSockCtx->sockfd, (const char*) pCmd, pApdu->buflen, 0);
	if (retval < 0)
	{
	fprintf(stderr,"Client: send() failed: error %i.\n", retval);
	return SMCOM_SND_FAILED;
	}

	expectedLength = REMOTE_JC_SHELL_HEADER_LEN; // remote JC shell header length

	while (totalReceived < expectedLength)
	{
	retval = recv(pSockCtx->sockfd, (char*) &pRsp[totalReceived], MAX_BUF_SIZE, 0);
	if (retval < 0)
	{
	fprintf(stderr,"Client: recv() failed: error %i.\n", retval);
	closesocket(pSockCtx->sockfd);
	rv = SMCOM_RCV_FAILED;
	goto exit;
	}
	else
	{
	totalReceived += retval;
	}
	if ((totalReceived >= REMOTE_JC_SHELL_HEADER_LEN) && (lengthReceived == 0))
	{
	expectedLength += ((pRsp[2]<<8) \| (pRsp[3]));
	lengthReceived = 1;
	}
	}
	retval = totalReceived;

	retval -= 4; // Remove the 4 bytes of the Remote JC Terminal protocol
	memcpy(pApdu->pBuf, &pRsp[4], retval);

	#ifdef LOG_SOCK
	sm_printf(CONSOLE, " recv: ");
	for (i=0; i < retval; i++)
	{
	sm_printf(CONSOLE, "%02X", pApdu->pBuf[i]);
	}
	sm_printf(CONSOLE, "\n");
	#endif

	pApdu->rxlen = (U16) retval;
	// reset offset for subsequent response parsing
	pApdu->offset = 0;
	rv = SMCOM_OK;
	exit:
	return rv;
	}

	U32 smComSocket_TransceiveRaw(void* conn_ctx, U8 * pTx, U16 txLen, U8 * pRx, U32 * pRxLen)
	{
	S32 retval;
	U32 answerReceived = 0;
	U32 len = 0;
	#if defined(LOG_SOCK) \|\| defined(DBG_LOG_SOCK)
	int i;
	#endif
	U32 readOffset = 0;
	U8 headerParsed = 0;
	U8 correctHeader = 0;
	U32 rv = SMCOM_COM_FAILED;

	ENSURE_OR_GO_EXIT(pTx != NULL);
	ENSURE_OR_GO_EXIT(pRx != NULL);
	ENSURE_OR_GO_EXIT(pRxLen != NULL);

	memset(sockapdu, 0x00, MAX_BUF_SIZE);
	memset(response, 0x00, MAX_BUF_SIZE);

	memcpy(pCmd, Header, 2);
	pCmd[2] = (txLen & 0xFF00)>>8;
	pCmd[3] = (txLen & 0x00FF);
	memcpy(&pCmd[4], pTx, txLen);
	txLen += 4; /* header + len */

	#ifdef DBG_LOG_SOCK
	sm_printf(CONSOLE, " full send: ");
	for (i=0; i < txLen; i++)
	{
	sm_printf(CONSOLE, "%02X", pCmd[i]);
	}
	sm_printf(CONSOLE, "\n");
	#endif

	retval = send(pSockCtx->sockfd, (const char*) pCmd, txLen, 0);
	if (retval < 0)
	{
	sm_printf(CONSOLE, "Client: send() failed: error %i.\n", retval);
	return SMCOM_SND_FAILED;
	}
	else
	{
	#ifdef DBG_LOG_SOCK
	sm_printf(CONSOLE, "Client: send() is OK.\n");
	#endif
	}

	#ifdef LOG_SOCK
	sm_printf(CONSOLE, " send: ");
	for (i=4; i < txLen; i++)
	{
	sm_printf(CONSOLE, "%02X", pCmd[i]);
	}
	sm_printf(CONSOLE, "\n");
	#endif

	retval = REMOTE_JC_SHELL_HEADER_LEN; // receive at least the JCTerminal header

	while ((retval > 0) \|\| (answerReceived == 0))
	{
	retval = recv(pSockCtx->sockfd, (char*) pRsp, MAX_BUF_SIZE, 0);

	if (retval < 0)
	{
	fprintf(stderr,"Client: recv() failed: error %i %x\n", retval, WSAGetLastError());

	closesocket(pSockCtx->sockfd);
	return SMCOM_RCV_FAILED;
	}
	else // data received
	{
	while (retval > 0) // parse all bytes
	{
	if (headerParsed == 1) // header already parsed; get data
	{
	if (retval >= (S32) len)
	{
	if (correctHeader == 1)
	{
	memcpy(&pRx[0], &pRsp[readOffset], len);
	answerReceived = 1;
	}
	else
	{
	// reset header parsed
	readOffset += len;
	headerParsed = 0;
	}
	retval -= len;

	if (retval == 0) // no data left, reset readOffset
	{
	readOffset = 0;
	}
	}
	else
	{
	// data too small according header => Error
	fprintf(stderr,"Failed reading data %x %x\n", retval, len);
	return SMCOM_RCV_FAILED;
	}
	}
	else // parse header
	{
	len = ((pRsp[readOffset + 2]<<8) \| (pRsp[readOffset + 3]));

	if (pRsp[readOffset] == REMOTE_JC_SHELL_MSG_TYPE_APDU_DATA)
	{
	// type correct => copy the data
	retval -= REMOTE_JC_SHELL_HEADER_LEN;
	if (retval > 0) // data left to read
	{
	readOffset += REMOTE_JC_SHELL_HEADER_LEN;
	}
	correctHeader = 1;
	}
	else
	{
	// type incorrect => skip the data as well and try again if data are left
	readOffset += REMOTE_JC_SHELL_HEADER_LEN;
	retval -= REMOTE_JC_SHELL_HEADER_LEN;
	correctHeader = 0;
	}
	headerParsed = 1;
	}
	}
	}
	}

	#ifdef LOG_SOCK
	sm_printf(CONSOLE, " recv: ");
	for (i=0; i < (int)len; i++)
	{
	sm_printf(CONSOLE, "%02X", pRx[i]);
	}
	sm_printf(CONSOLE, "\n");
	#endif

	*pRxLen = len;

	rv = SMCOM_OK;
	exit:
	return rv;
	}