Let’s create a C++ Win32 project using Visual C++ 2010 Expresss. Enter the following code to the main().

#include "stdafx.h"
#include <iostream>
#include <Windows.h>

int _tmain(int argc, _TCHAR* argv[])
{
	WCHAR szISOLang[5] = {0};
	WCHAR szISOCountry[5] = {0};
	int iLen = 0;

	::GetLocaleInfo(LOCALE_USER_DEFAULT,
					LOCALE_SISO639LANGNAME,
					szISOLang,
					sizeof(szISOLang) / sizeof(WCHAR));

	::GetLocaleInfo(LOCALE_USER_DEFAULT,
					LOCALE_SISO3166CTRYNAME,
					szISOCountry,
					sizeof(szISOCountry) / sizeof(WCHAR));

	std::wcout << szISOLang << "_" << szISOCountry << std::endl;

	return 0;
}

Compile and run the project. Try to change the regional and language setting of your system. You may observe the output as following:

The server will listen at a given IP & port number. whenever it receive message from its connected client, it then print out the message and bouce back the message to the client. On the other hand, the client will connect to the server and user will enter a message to send to the server. the client will print out the message that it receive from the server too. To stop the connection, the client will need to send a message “close” to the server.

1. Create a new visual C++ empty project using visual studio 2010 express edition. Name the project ClientExample.
2. Add a new visual C++ empty project to the same solution. Name it ServerExample.
3. Add a main.cpp file to both ClientExample & ServerExample project.

4. Enter the following code to main.cpp in the ClientExample project.

#define WIN32_LEAN_AND_MEAN

#include <WinSock2.h>
#include <WS2tcpip.h>
#include <iostream>
#include <string>

// link with Ws2_32.lib
#pragma comment(lib, "Ws2_32.lib")

#define DEFAULT_PORT "27015" 
#define DEFAULT_BUFFER_LENGTH	512

class Client {
public:
	Client(char* servername)
	{
		szServerName = servername;
		ConnectSocket = INVALID_SOCKET;
	}

	bool Start() {
		WSADATA wsaData;

		// Initialize Winsock
		int iResult = WSAStartup(MAKEWORD(2,2), &wsaData);
		if(iResult != 0)
		{
			printf("WSAStartup failed: %d\n", iResult);
			return false;
		}

		struct addrinfo	*result = NULL,
						*ptr = NULL,
						hints;

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

		// Resolve the server address and port
		iResult = getaddrinfo(szServerName, DEFAULT_PORT, &hints, &result);
		if (iResult != 0)
		{
			printf("getaddrinfo failed: %d\n", iResult);
			WSACleanup();
			return false;
		}

		ptr = result;

		// Create a SOCKET for connecting to server
		ConnectSocket = socket(ptr->ai_family, ptr->ai_socktype, ptr->ai_protocol);

		if (ConnectSocket == INVALID_SOCKET)
		{
			printf("Error at socket(): %d\n", WSAGetLastError());
			freeaddrinfo(result);
			WSACleanup();
			return false;
		}

		// Connect to server
		iResult = connect(ConnectSocket, ptr->ai_addr, (int)ptr->ai_addrlen);

		if (iResult == SOCKET_ERROR)
		{
			closesocket(ConnectSocket);
			ConnectSocket = INVALID_SOCKET;
		}

		freeaddrinfo(result);

		if (ConnectSocket == INVALID_SOCKET)
		{
			printf("Unable to connect to server!\n");
			WSACleanup();
			return false;
		}

		return true;
	};

	// Free the resouces
	void Stop() {
		int iResult = shutdown(ConnectSocket, SD_SEND);

		if (iResult == SOCKET_ERROR)
		{
			printf("shutdown failed: %d\n", WSAGetLastError());
		}

		closesocket(ConnectSocket);
		WSACleanup();
	};

	// Send message to server
	bool Send(char* szMsg)
	{
		
		int iResult = send(ConnectSocket, szMsg, strlen(szMsg), 0);

		if (iResult == SOCKET_ERROR)
		{
			printf("send failed: %d\n", WSAGetLastError());
			Stop();
			return false;
		}

		return true;
	};

	// Receive message from server
	bool Recv()
	{
		char recvbuf[DEFAULT_BUFFER_LENGTH];
		int iResult = recv(ConnectSocket, recvbuf, DEFAULT_BUFFER_LENGTH, 0);

		if (iResult > 0)
		{
			char msg[DEFAULT_BUFFER_LENGTH];
			memset(&msg, 0, sizeof(msg));
			strncpy(msg, recvbuf, iResult);

			printf("Received: %s\n", msg);

			return true;
		}


		return false;
	}

private:
	char* szServerName;
	SOCKET ConnectSocket;
};


int main(int argc, CHAR* argv[]) 
{
	std::string msg;

	Client client("127.0.0.1");

	if (!client.Start())
		return 1;

	while(true)
	{
		std::cout << "Send: ";
		std::getline(std::cin, msg);

		// Close the connection when user enter "close"
		if (msg.compare("close") == 0)
		{
			break;
		}

		client.Send((char*)msg.c_str());
		client.Recv();
	}

	client.Stop();

	getchar();
	return 0;
}

5. Enter the following code to main.cpp in the ServerExample project.

#define WIN32_LEAN_AND_MEAN

#include <WinSock2.h>
#include <WS2tcpip.h>
#include <stdio.h>
#include <stdlib.h>


// link with Ws2_32.lib
#pragma comment(lib, "Ws2_32.lib")

#define DEFAULT_PORT "27015"
#define DEFAULT_BUFFER_LENGTH	512

int main() {

	WSADATA wsaData;

	// Initialize Winsock
	int iResult = WSAStartup(MAKEWORD(2,2), &wsaData);
	if(iResult != 0)
	{
		printf("WSAStartup failed: %d\n", iResult);
		return 1;
	}

	struct addrinfo	*result = NULL,
					hints;

	ZeroMemory(&hints, sizeof(hints));
	hints.ai_family = AF_INET;		// Internet address family is unspecified so that either an IPv6 or IPv4 address can be returned
	hints.ai_socktype = SOCK_STREAM;	// Requests the socket type to be a stream socket for the TCP protocol
	hints.ai_protocol = IPPROTO_TCP;
	hints.ai_flags = AI_PASSIVE;

	// Resolve the local address and port to be used by the server
	iResult = getaddrinfo(NULL, DEFAULT_PORT, &hints, &result);
	if (iResult != 0)
	{
		printf("getaddrinfo failed: %d\n", iResult);
		WSACleanup();
		return 1;
	}

	SOCKET ListenSocket = INVALID_SOCKET;

	// Create a SOCKET for the server to listen for client connections
	ListenSocket = socket(result->ai_family, result->ai_socktype, result->ai_protocol);

	if (ListenSocket == INVALID_SOCKET)
	{
		printf("Error at socket(): %d\n", WSAGetLastError());
		freeaddrinfo(result);
		WSACleanup();
		return 1;
	}

	// Setup the TCP listening socket
	iResult = bind(ListenSocket, result->ai_addr, (int)result->ai_addrlen);

	if (iResult == SOCKET_ERROR)
	{
		printf("bind failed: %d", WSAGetLastError());
		freeaddrinfo(result);
		closesocket(ListenSocket);
		WSACleanup();
		return 1;
	}

	freeaddrinfo(result);

	// To listen on a socket
	if ( listen(ListenSocket, SOMAXCONN) == SOCKET_ERROR)
	{
		printf("listen failed: %d\n", WSAGetLastError());
		closesocket(ListenSocket);
		WSACleanup();
		return 1;
	}

	SOCKET ClientSocket;

	ClientSocket = INVALID_SOCKET;

	// Accept a client socket
	ClientSocket = accept(ListenSocket, NULL, NULL);

	if (ClientSocket == INVALID_SOCKET)
	{
		printf("accept failed: %d\n", WSAGetLastError());
		closesocket(ListenSocket);
		WSACleanup();
		return 1;
	}
	
	char recvbuf[DEFAULT_BUFFER_LENGTH];
	int iSendResult;

	// reveice until the client shutdown the connection
	do {
		iResult = recv(ClientSocket, recvbuf, DEFAULT_BUFFER_LENGTH, 0);
		if (iResult > 0)
		{
			char msg[DEFAULT_BUFFER_LENGTH];
			memset(&msg, 0, sizeof(msg));
			strncpy(msg, recvbuf, iResult);

			printf("Received: %s\n", msg);

			iSendResult = send(ClientSocket, recvbuf, iResult, 0);

			if (iSendResult == SOCKET_ERROR)
			{
				printf("send failed: %d\n", WSAGetLastError());
				closesocket(ClientSocket);
				WSACleanup();
				return 1;
			}

			printf("Bytes sent: %ld\n", iSendResult);
		}
		else if (iResult == 0)
			printf("Connection closed\n");
		else
		{
			printf("recv failed: %d\n", WSAGetLastError());
			closesocket(ClientSocket);
			WSACleanup();
			//return 1;
		}
	} while (iResult > 0);

	// Free the resouces
	closesocket(ListenSocket);
	WSACleanup();

	getchar();
	return 0;
}

6. Compile both projects. You may run both client and server application in 2 CMD windows. Enter a message in the client and it will send to the server.

7. Download sample source code: ClieServerExample.zip

1. Here are the openssl HMAC sample source code.
   
   Example #1: hmac_sample1.cpp

   #include <stdio.h>
   #include <string.h>
   #include <openssl/hmac.h>
   
   int main()
   {
       // The key to hash
       char key[] = "012345678";
   
       // The data that we're going to hash using HMAC
       char data[] = "hello world";
       
       unsigned char* digest;
       
       // Using sha1 hash engine here.
       // You may use other hash engines. e.g EVP_md5(), EVP_sha224, EVP_sha512, etc
       digest = HMAC(EVP_sha1(), key, strlen(key), (unsigned char*)data, strlen(data), NULL, NULL);    
   
       // Be careful of the length of string with the choosen hash engine. SHA1 needed 20 characters.
       // Change the length accordingly with your choosen hash engine
       char mdString[20];
       for(int i = 0; i < 20; i++)
            sprintf(&mdString[i*2], "%02x", (unsigned int)digest[i]);
   
       printf("HMAC digest: %s\n", mdString);
   
       return 0;
   }

   
   Example #2: hmac_sample2.cpp

   #include <stdio.h>
   #include <string.h>
   #include <openssl/hmac.h>
   
   int main() {
       // The secret key for hashing
       const char key[] = "012345678";
   
       // The data that we're going to hash
       char data[] = "hello world";
       
       // Be careful of the length of string with the choosen hash engine. SHA1 needed 20 characters.
       // Change the length accordingly with your choosen hash engine.     
       unsigned char* result;
       unsigned int len = 20;
   
       result = (unsigned char*)malloc(sizeof(char) * len);
   
       HMAC_CTX ctx;
       HMAC_CTX_init(&ctx);
   
       // Using sha1 hash engine here.
       // You may use other hash engines. e.g EVP_md5(), EVP_sha224, EVP_sha512, etc
       HMAC_Init_ex(&ctx, key, strlen(key), EVP_sha1(), NULL);
       HMAC_Update(&ctx, (unsigned char*)&data, strlen(data));
       HMAC_Final(&ctx, result, &len);
       HMAC_CTX_cleanup(&ctx);
   
       printf("HMAC digest: ");
   
       for (int i = 0; i != len; i++)
           printf("%02x", (unsigned int)result[i]);
   
       printf("\n");
   
       free(result);
   
       return 0;
   }

2. Let’s try to compile both sample cpp files and you should observe the following output screenshot.
   ~$ gcc hmac_sample1.cpp -o sample1 -lcrypto
   ~$ ./sample1
   HMAC digest: e19e220122b37b708bfb95aca2577905acabf0c0
   ~$ gcc hmac_sample2.cpp -o sample2 -lcrypto
   ~$ ./sample2
   HMAC digest: e19e220122b37b708bfb95aca2577905acabf0c0
   Note: -lcrypto will include the crypto library from openssl

1. Here are the openssl RIPEMD sample source code.
   
   Example #1: ripemd_sample1.cpp

   #include <stdio.h>
   #include <string.h>
   #include <openssl/ripemd.h>
   
   int main()
   {
       unsigned char digest[RIPEMD160_DIGEST_LENGTH];
       char string[] = "hello world";
       
       RIPEMD160((unsigned char*)&string, strlen(string), (unsigned char*)&digest);    
   
       char mdString[RIPEMD160_DIGEST_LENGTH*2+1];
   
       for(int i = 0; i < RIPEMD160_DIGEST_LENGTH; i++)
            sprintf(&mdString[i*2], "%02x", (unsigned int)digest[i]);
   
       printf("RIPEMD160 digest: %s\n", mdString);
   
       return 0;
   }

   
   Example #2: ripemd_sample2.cpp

   #include <stdio.h>
   #include <string.h>
   #include <openssl/ripemd.h>
   
   int main() {
       unsigned char digest[RIPEMD160_DIGEST_LENGTH];
       const char* string = "hello world";
   
       RIPEMD160_CTX ctx;
       RIPEMD160_Init(&ctx);
       RIPEMD160_Update(&ctx, string, strlen(string));
       RIPEMD160_Final(digest, &ctx);
   
       char mdString[RIPEMD160_DIGEST_LENGTH*2+1];
       for (int i = 0; i < RIPEMD160_DIGEST_LENGTH; i++)
           sprintf(&mdString[i*2], "%02x", (unsigned int)digest[i]);
   
       printf("RIPEMD160 digest: %s\n", mdString);
   
       return 0;
   }

2. Let’s try to compile both sample cpp files and you should observe the following output screenshot.
   ~$ gcc ripemd_sample1.cpp -o sample1 -lcrypto
   ~$ ./sample1
   RIPEMD160 digest: 98c615784ccb5fe5936fbc0cbe9dfdb408d92f0f
   ~$ gcc ripemd_sample2.cpp -o sample2 -lcrypto
   ~$ ./sample2
   RIPEMD160 digest: 98c615784ccb5fe5936fbc0cbe9dfdb408d92f0f
   Note: -lcrypto will include the crypto library from openssl

1. Here are the openssl SHA512 sample source code.
   
   Example #1: sha512_sample1.cpp

   #include <stdio.h>
   #include <string.h>
   #include <openssl/sha.h>
   
   int main()
   {
       unsigned char digest[SHA512_DIGEST_LENGTH];
       char string[] = "hello world";
       
       SHA512((unsigned char*)&string, strlen(string), (unsigned char*)&digest);    
   
       char mdString[SHA512_DIGEST_LENGTH*2+1];
   
       for(int i = 0; i < SHA512_DIGEST_LENGTH; i++)
            sprintf(&mdString[i*2], "%02x", (unsigned int)digest[i]);
   
       printf("SHA512 digest: %s\n", mdString);
   
       return 0;
   }

   
   Example #2: sha512_sample2.cpp

   #include <stdio.h>
   #include <string.h>
   #include <openssl/sha.h>
   
   int main() {
       unsigned char digest[SHA512_DIGEST_LENGTH];
       const char* string = "hello world"; 
   
       SHA512_CTX ctx;
       SHA512_Init(&ctx);
       SHA512_Update(&ctx, string, strlen(string));
       SHA512_Final(digest, &ctx);
   
       char mdString[SHA512_DIGEST_LENGTH*2+1];
       for (int i = 0; i < SHA512_DIGEST_LENGTH; i++)
           sprintf(&mdString[i*2], "%02x", (unsigned int)digest[i]);
   
       printf("SHA512 digest: %s\n", mdString);
   
   
       return 0;
   }

2. Let’s try to compile both sample cpp files and you should observe the following output screenshot.
   ~$ gcc sha512_sample1.cpp -o sample1 -lcrypto
   ~$ ./sample1
   SHA512 digest: 309ecc489c12d6eb4cc40f50c902f2b4d0ed77ee511a7c7a9bcd3ca86d4cd86f989dd35bc5ff499670da34255b45b0cfd830e81f605dcf7dc5542e93ae9cd76f
   ~$ gcc sha512_sample2.cpp -o sample2 -lcrypto
   ~$ ./sample2
   SHA512 digest: 309ecc489c12d6eb4cc40f50c902f2b4d0ed77ee511a7c7a9bcd3ca86d4cd86f989dd35bc5ff499670da34255b45b0cfd830e81f605dcf7dc5542e93ae9cd76f
   Note: -lcrypto will include the crypto library from openssl

1. Here are the openssl SHA384 sample source code.
   
   Example #1: sha384_sample1.cpp

   #include <stdio.h>
   #include <string.h>
   #include <openssl/sha.h>
   
   int main()
   {
       unsigned char digest[SHA384_DIGEST_LENGTH];
       char string[] = "hello world";
       
       SHA384((unsigned char*)&string, strlen(string), (unsigned char*)&digest);    
   
       char mdString[SHA384_DIGEST_LENGTH*2+1];
   
       for(int i = 0; i < SHA384_DIGEST_LENGTH; i++)
            sprintf(&mdString[i*2], "%02x", (unsigned int)digest[i]);
   
       printf("SHA384 digest: %s\n", mdString);
   
       return 0;
   }

   
   Example #2: sha384_sample2.cpp

   #include <stdio.h>
   #include <string.h>
   #include <openssl/sha.h>
   
   int main() {
       unsigned char digest[SHA512_DIGEST_LENGTH];
       const char* string = "hello world"; 
   
       SHA512_CTX ctx;
       SHA384_Init(&ctx);
       SHA384_Update(&ctx, string, strlen(string));
       SHA384_Final(digest, &ctx);
   
       char mdString[SHA384_DIGEST_LENGTH*2+1];
       for (int i = 0; i < SHA384_DIGEST_LENGTH; i++)
           sprintf(&mdString[i*2], "%02x", (unsigned int)digest[i]);
   
       printf("SHA384 digest: %s\n", mdString);
   
   
       return 0;
   }

2. Let’s try to compile both sample cpp files and you should observe the following output screenshot.
   ~$ gcc sha384_sample1.cpp -o sample1 -lcrypto
   ~$ ./sample1
   SHA384 digest: fdbd8e75a67f29f701a4e040385e2e23986303ea10239211af907fcbb83578b3e417cb71ce646efd0819dd8c088de1bd
   ~$ gcc sha384_sample2.cpp -o sample2 -lcrypto
   ~$ ./sample2
   SHA384 digest: fdbd8e75a67f29f701a4e040385e2e23986303ea10239211af907fcbb83578b3e417cb71ce646efd0819dd8c088de1bd
   Note: -lcrypto will include the crypto library from openssl

1. Here are the openssl SHA256 sample source code.
   
   Example #1: sha256_sample1.cpp

   #include <stdio.h>
   #include <string.h>
   #include <openssl/sha.h>
   
   int main()
   {
       unsigned char digest[SHA256_DIGEST_LENGTH];
       char string[] = "hello world";
       
       SHA256((unsigned char*)&string, strlen(string), (unsigned char*)&digest);    
   
       char mdString[SHA256_DIGEST_LENGTH*2+1];
   
       for(int i = 0; i < SHA256_DIGEST_LENGTH; i++)
            sprintf(&mdString[i*2], "%02x", (unsigned int)digest[i]);
   
       printf("SHA256 digest: %s\n", mdString);
   
       return 0;
   }

   
   Example #2: sha256_sample2.cpp

   #include <stdio.h>
   #include <string.h>
   #include <openssl/sha.h>
   
   int main() {
       unsigned char digest[SHA256_DIGEST_LENGTH];
       const char* string = "hello world"; 
   
       SHA256_CTX ctx;
       SHA256_Init(&ctx);
       SHA256_Update(&ctx, string, strlen(string));
       SHA256_Final(digest, &ctx);
   
       char mdString[SHA256_DIGEST_LENGTH*2+1];
       for (int i = 0; i < SHA256_DIGEST_LENGTH; i++)
           sprintf(&mdString[i*2], "%02x", (unsigned int)digest[i]);
   
       printf("SHA256 digest: %s\n", mdString);
   
   
       return 0;
   }

2. Let’s try to compile both sample cpp files and you should observe the following output screenshot.
   ~$ gcc sha256_sample1.cpp -o sample1 -lcrypto
   ~$ ./sample1
   SHA256 digest: b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9
   ~$ gcc sha256_sample2.cpp -o sample2 -lcrypto
   ~$ ./sample2
   SHA256 digest: b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9
   Note: -lcrypto will include the crypto library from openssl

1. Here are the openssl SHA224 sample source code.
   
   Example #1: sha224_sample1.cpp

   #include <stdio.h>
   #include <string.h>
   #include <openssl/sha.h>
   
   int main()
   {
       unsigned char digest[SHA224_DIGEST_LENGTH];
       char string[] = "hello world";
       
       SHA224((unsigned char*)&string, strlen(string), (unsigned char*)&digest);    
   
       char mdString[SHA224_DIGEST_LENGTH*2+1];
   
       for(int i = 0; i < SHA224_DIGEST_LENGTH; i++)
            sprintf(&mdString[i*2], "%02x", (unsigned int)digest[i]);
   
       printf("SHA224 digest: %s\n", mdString);
   
       return 0;
   }

   
   Example #2: sha224_sample2.cpp

   #include <stdio.h>
   #include <string.h>
   #include <openssl/sha.h>
   
   int main() {
       unsigned char digest[SHA224_DIGEST_LENGTH];
       const char* string = "hello world"; 
   
       SHA256_CTX ctx;
       SHA224_Init(&ctx);
       SHA224_Update(&ctx, string, strlen(string));
       SHA224_Final(digest, &ctx);
   
       char mdString[SHA224_DIGEST_LENGTH*2+1];
       for (int i = 0; i < SHA224_DIGEST_LENGTH; i++)
           sprintf(&mdString[i*2], "%02x", (unsigned int)digest[i]);
   
       printf("SHA224 digest: %s\n", mdString);
   
   
       return 0;
   }

2. Let’s try to compile both sample cpp files and you should observe the following output screenshot.
   ~$ gcc sha224_sample1.cpp -o sample1 -lcrypto
   ~$ ./sample1
   SHA224 digest: 2f05477fc24bb4faefd86517156dafdecec45b8ad3cf2522a563582b
   ~$ gcc sha224_sample2.cpp -o sample2 -lcrypto
   ~$ ./sample2
   SHA224 digest: 2f05477fc24bb4faefd86517156dafdecec45b8ad3cf2522a563582b
   Note: -lcrypto will include the crypto library from openssl