winsockcomm_1.cpp

wince下EVC编译通过的客户端程序

				_tmainClient(hDlg);
				return TRUE;
			}
			else
			{
			}
			break;
	}
    return FALSE;
}

BOOL GetLANinfo(HWND hDlg)
{
	ULONG uLong;
	DWORD dw;
	uLong=sizeof(gStrucAdpInfo);
	TCHAR strBuffer[100];

	if ((dw=GetAdaptersInfo(gStrucAdpInfo, &uLong))==ERROR_SUCCESS)
	{
		wsprintf(strBuffer, TEXT("%hs"), gStrucAdpInfo[0].IpAddressList.IpAddress.String);
		SetDlgItemText(hDlg, IDC_EDIT_IP, strBuffer);
	}
	else
	{
		return 0;
	}
	return 1;
}

//======================================================================================

void
Print(
    TCHAR *pFormat, 
...)
{
    va_list ArgList;
    TCHAR Buffer[256];
    va_start (ArgList, pFormat);

    (void)wvsprintf (Buffer, pFormat, ArgList);

    SendDlgItemMessage (gDemoDlg, ID_RCVTEXT, EM_REPLACESEL, 0, (LPARAM)Buffer);

/*
#ifndef UNDER_CE
    _putts(Buffer);
#else
    OutputDebugString(Buffer);
#endif
*/
    va_end(ArgList);
}

DWORD WINAPI ServerThread (PVOID pArg)
{
    SOCKET sock, SockServ;
//    char *szPort = DEFAULT_PORT;
    SOCKADDR_STORAGE ssRemoteAddr;
    int cbRemoteAddrSize, cbXfer, cbTotalRecvd;
    ADDRINFO Hints, *AddrInfo = NULL, *AI;
    char pBuf[BUFFER_SIZE];
    char szRemoteAddrString[128];
    HWND hDlg;

    hDlg = (HWND)pArg;
    sock = INVALID_SOCKET;
	
    //
    // Get a list of available addresses to serve on
    //

    memset(&Hints, 0, sizeof(Hints));
    Hints.ai_family = AF_UNSPEC;
    Hints.ai_socktype = SOCK_STREAM;
    Hints.ai_flags = AI_NUMERICHOST | AI_PASSIVE;

    if(getaddrinfo(gIPaddress, gPortNumber, &Hints, &AddrInfo))
    {
        Print(TEXT("ERROR: getaddrinfo failed with error %d\r\n"), WSAGetLastError());
        goto Cleanup;
    }

    //
    // Create a list of serving sockets, one for each address
    //
	AI = AddrInfo;
            SockServ = socket(AI->ai_family, AI->ai_socktype, AI->ai_protocol);
            if (SockServ != INVALID_SOCKET)
            {
                if (bind(SockServ, AI->ai_addr, AI->ai_addrlen) == SOCKET_ERROR)
                    closesocket(SockServ);
                else 
                {
//                    if(nSockType == SOCK_STREAM)
//                    {
                        if (listen(SockServ, SOMAXCONN) == SOCKET_ERROR)
                        {
                            closesocket(SockServ);
                        }
//                    }
                    Print( 
                        TEXT("Socket 0x%08x ready for connection with %hs family, %hs type, on port %hs\r\n"), 
                        SockServ, 
                        (AI->ai_family == AF_INET) ? "AF_INET" : ((AI->ai_family == AF_INET6) ? "AF_INET6" : "UNKNOWN"),
                        (AI->ai_socktype == SOCK_STREAM) ? "TCP" : ((AI->ai_socktype == SOCK_DGRAM) ? "UDP" : "UNKNOWN"),
                        gPortNumber);
                }
            }
    
    freeaddrinfo(AddrInfo);
    

    //
    // Wait for incomming data/connections
    //

                cbRemoteAddrSize = sizeof(ssRemoteAddr);
while (1)
{
               sock = accept(SockServ, (SOCKADDR*)&ssRemoteAddr, &cbRemoteAddrSize);
                if(sock == INVALID_SOCKET) 
                {
                    Print(TEXT("ERROR: accept() failed with error = %d\r\n"), WSAGetLastError());
                    goto Cleanup;
                }

                Print(TEXT("Accepted TCP connection from socket 0x%08x\r\n"), sock);


    //
    // Receive data from a client
    //
	TCHAR tchBuffer[100];
	char chBuffer[100];

	memset(chBuffer, 0, sizeof(chBuffer));

    cbTotalRecvd = 0;
    do
    {
        cbRemoteAddrSize = sizeof(ssRemoteAddr);
//        cbXfer = recvfrom(sock, pBuf + cbTotalRecvd, sizeof(pBuf) - cbTotalRecvd, 0,
        cbXfer = recvfrom(sock, chBuffer + cbTotalRecvd, sizeof(chBuffer) - cbTotalRecvd, 0,
            (SOCKADDR *)&ssRemoteAddr, &cbRemoteAddrSize);
//	wsprintf(tchBuffer, TEXT("cbXfer : %d"), cbXfer);
//	MessageBox(NULL, tchBuffer, TEXT(""), MB_OK);

        cbTotalRecvd += cbXfer;
    } while(cbXfer > 0 && cbTotalRecvd < sizeof(pBuf));

//	wsprintf(tchBuffer, TEXT("string : %hs"), pBuf);
//	MessageBox(NULL, tchBuffer, TEXT(""), MB_OK);




    if(cbXfer == SOCKET_ERROR)
    {
        Print(TEXT("ERROR: Couldn't receive the data! Error = %d\r\n"), WSAGetLastError());
//        goto Cleanup;
    }
    else if(cbXfer == 0)
    {
        Print(TEXT("ERROR: Didn't get all the expected data from the client!\r\n"));
//        goto Cleanup;
    }

//    if(nSockType == SOCK_STREAM)
//    {
        cbRemoteAddrSize = sizeof(ssRemoteAddr);
        getpeername(sock, (SOCKADDR *)&ssRemoteAddr, &cbRemoteAddrSize);
//    }
    
    if (getnameinfo((SOCKADDR *)&ssRemoteAddr, cbRemoteAddrSize,
        szRemoteAddrString, sizeof(szRemoteAddrString), NULL, 0, NI_NUMERICHOST) != 0)
        strcpy(szRemoteAddrString, "");

//    Print(TEXT("SUCCESS - Received %d bytes from client %hs\r\n"), cbTotalRecvd, szRemoteAddrString);
    Print(TEXT("Received from client(%hs) <---- %hs\r\n"), szRemoteAddrString, chBuffer);

    //
    // Echo the data back to the client
    //

    cbXfer = 0;
    cbXfer = sendto(sock, chBuffer, cbTotalRecvd, 0, (SOCKADDR *)&ssRemoteAddr, cbRemoteAddrSize);

    if(cbXfer != cbTotalRecvd)
        Print(TEXT("ERROR: Couldn't send the data! error = %d\r\n"), WSAGetLastError());
    else
        Print(TEXT("Send Echo to client ---->%hs\r\n"), chBuffer);
}
Cleanup:

    if(SockServ != INVALID_SOCKET)
        closesocket(SockServ);

    if(sock != INVALID_SOCKET)
    {
        shutdown(sock, SD_BOTH);
        closesocket(sock);
    }

    return 0;
} 

//============================================================================================


int _tmainClient(PVOID pArg)
{
    SOCKADDR_STORAGE ssRemoteAddr;
    int cbXfer, cbTotalRecvd, cbRemoteAddrSize;
    char szRemoteAddrString[128];
    char pRecvBuf[BUFFER_SIZE];

	char chBuffer[23], *pBuffer;
	UINT cntText;
	TCHAR tchBuffer[100];

    HWND hDlg;
    hDlg = (HWND)pArg;

    //
    // Send data to the server
    //
	cntText = GetDlgItemText(hDlg, ID_SENDTEXT, tchBuffer, sizeof(tchBuffer));
	pBuffer = ConvertUnicodeToAscii(tchBuffer, cntText);

//	wsprintf(tchBuffer, TEXT("cnt : %d, string : %hs, buffer size : %d"), cntText, pBuffer, sizeof(chBuffer));
//	MessageBox(NULL, tchBuffer, TEXT(""), MB_OK);

	memset(chBuffer, 0, sizeof(chBuffer));
	sprintf(chBuffer, "%s", pBuffer);

    cbXfer = 0;
    cbXfer = sendto(gsock, chBuffer, sizeof(chBuffer), 0, gAI->ai_addr, gAI->ai_addrlen);

    if(cbXfer != sizeof(chBuffer))
    {
        Print(TEXT("ERROR: Couldn't send the data! error = %d\r\n"), WSAGetLastError());
//        goto Cleanup;
    }

    if (getnameinfo(gAI->ai_addr, gAI->ai_addrlen,
        szRemoteAddrString, sizeof(szRemoteAddrString), NULL, 0, NI_NUMERICHOST) != 0)
        strcpy(szRemoteAddrString, "");
    
    Print(TEXT("Sent to server(%hs) ----> %hs\r\n"), szRemoteAddrString, chBuffer);

    //
    // Receive the echo'd data back from the server
    //

    cbTotalRecvd = 0;

	memset(chBuffer, 0, sizeof(chBuffer));

    do
    {
        cbRemoteAddrSize = sizeof(ssRemoteAddr);
//        cbXfer = recvfrom(gsock, pRecvBuf + cbTotalRecvd, sizeof(pRecvBuf) - cbTotalRecvd, 0, 
        cbXfer = recvfrom(gsock, chBuffer + cbTotalRecvd, sizeof(chBuffer) - cbTotalRecvd, 0, 
            (SOCKADDR *)&ssRemoteAddr, &cbRemoteAddrSize);
        cbTotalRecvd += cbXfer;
    } while(cbXfer > 0 && cbTotalRecvd < sizeof(pRecvBuf));

    if(cbXfer == SOCKET_ERROR)
    {
        Print(TEXT("ERROR: Couldn't receive the data! Error = %d\r\n"), WSAGetLastError());
        goto Cleanup;
    }
    else if(cbTotalRecvd != sizeof(pRecvBuf))
    {
        Print(TEXT("ERROR: Server didn't send back all the expected data!\r\n"));
        goto Cleanup;
    }

    memset(&ssRemoteAddr, 0, sizeof(ssRemoteAddr));
    cbRemoteAddrSize = sizeof(ssRemoteAddr);
    getpeername(gsock, (SOCKADDR *)&ssRemoteAddr, &cbRemoteAddrSize);

    if (getnameinfo((SOCKADDR *)&ssRemoteAddr, cbRemoteAddrSize,
        szRemoteAddrString, sizeof(szRemoteAddrString), NULL, 0, NI_NUMERICHOST) != 0)
        strcpy(szRemoteAddrString, "");

    Print(TEXT("Received Echo from server(%hs) <---- %hs\r\n"), szRemoteAddrString, chBuffer);

Cleanup:
/*
    if(gsock != INVALID_SOCKET)
    {
        shutdown(gsock, SD_BOTH);
        closesocket(gsock);
    }

    if(gAddrInfo)
        freeaddrinfo(gAddrInfo);
*/
    return 0;


} 

//=========================================================================
char * ConvertUnicodeToAscii(LPCWSTR p,int l)
{
 char *Out;
 int nChars;

 nChars=WideCharToMultiByte(CP_ACP,
         0,p,l,NULL,0,NULL,NULL);
 if(nChars!=0)
 {
  Out=(char *)malloc(nChars+1);
  if(Out!=NULL)
  {
   memset(Out,0,nChars+1);
   nChars=WideCharToMultiByte(CP_ACP,
           0,p,l,Out,nChars,NULL,NULL);
   if(nChars==0)
   {
    free(Out);
    Out=NULL;
   }
  }
 }
 else
  Out=NULL;

 if(Out==NULL)
 {
  Out=(char *)malloc(sizeof(char));
  *Out=0;
 }

 return Out;
}

DWORD WINAPI ClientStart (PVOID pArg)
{
    ADDRINFO Hints;
//    char *szPort = DEFAULT_PORT;
	HWND hDlg;

    hDlg = (HWND)pArg;

    memset(&Hints, 0, sizeof(Hints));
    Hints.ai_family = AF_UNSPEC;
    Hints.ai_socktype = SOCK_STREAM;

    if(getaddrinfo(gIPaddress, gPortNumber, &Hints, &gAddrInfo))
    {
        Print(TEXT("ERROR: Couldn't get resolve the server name/address!"));
    }

    //
    // Attempt to connect to each address until we find one that succeeds
    //
	gAI = gAddrInfo;
            gsock = socket(gAI->ai_family, gAI->ai_socktype, gAI->ai_protocol);
            if (gsock != INVALID_SOCKET)
            {
                if (gAI->ai_socktype == SOCK_STREAM)
                {
                    if(connect(gsock, gAI->ai_addr, gAI->ai_addrlen) == SOCKET_ERROR)
                    {
                        // Connect failed, let's close this socket and try again on the next address in the list
					    Print(TEXT("Connect to server failed\r\n"));
                        closesocket(gsock);
                    }
                }
                // connect() succeeded or we're a UDP socket
            }
			else 
				MessageBox(NULL, TEXT("connect failed"), TEXT(""), MB_OK);


	return 1;
}