C / C++ / MFC

int ReceiveHeader(SOCKET ClientSock, short iHeader[], int iLength)
{
	// Function to properly fill buffer

	short iHeaderBuffer[14];	// Buffer to hold the header data

	int iReceivedTotal		= 0;	// Total bytes received
	int iReceivedThisPass   = 0;	// Total bytes received in one recv
	int x					= 0;	// For the elements of the array
	int iThisX;						// For the elements of the array

	// Loop until the total bytes received is equal
	// to the total bytes we want; 2 bytes at a time
	while (iReceivedTotal < iLength)
	{
		iThisX = 0;

		for (short i = 0; i < (14 - (iReceivedTotal / 2)); i++)
		{
			iHeader[x] = iHeaderBuffer[i];

			x++;

			iThisX++;	// the number of elements we advance in this loop ONLY
		}
		
		iReceivedThisPass = recv(ClientSock, 
			                     szBuffer, 
								 (28 - iReceivedTotal),
							     0
							    );
		

		if (iReceivedThisPass != SOCKET_ERROR)
		{
			// If an odd number of bytes are sent then go back and 
			// resend because the array is short aligned
			//if ( sizeof(iHeader) % iReceivedThisPass != 0 )
			if ( 28 % iReceivedThisPass != 0 )
			{
				iReceivedThisPass = 0;

				x -= iThisX;

				continue;
			}

			iReceivedTotal += iReceivedThisPass;	// Increment total received

			// Make sure we are not advancing that which we are not receiving
			// eg. if x was 14 and we had received 12 bytes then we would want
			// to subtract 2; we divide iReceivedTotal by two because each
			// element of the array is two bytes
			x -= (14 - (iReceivedTotal / 2));
		}
		else
		{
			if (WSAGetLastError() != WSAEWOULDBLOCK)
				return -1;
		}
	}

	return iReceivedTotal;
}

int SendHeader(SOCKET ClientSock, short iHeader[], int iLength)
{
	// Function to properly fill buffer

	short iHeaderBuffer[14];	// Buffer to hold the header data

	int iSentTotal		= 0;	// Total bytes sent
	int iSentThisPass   = 0;	// Total bytes sent in one send
	int x				= 0;	// For the elements of the array
	int iThisX;					// For the elements of the array

	// Loop until the total bytes sent is equal
	// to the total bytes we want; send two bytes at
	// a time

	while (iSentTotal < iLength)
	{
		iThisX = 0;

		for (short i = 0; i < (14 - iSentTotal); i++)
		{
			iHeaderBuffer[i] = iHeader[x];

			x++;

			iThisX++;
		}
		
		iSentThisPass = send(ClientSock, 
			                 (char*) iHeaderBuffer 
						     (28 - iSentTotal),	
						     0
							);

		if (iSentThisPass != SOCKET_ERROR)
		{
			// If an odd number of bytes are sent then go back and 
			// resend because the array is short aligned
			if ( 28 % iSentThisPass != 0 )
			{
				iSentThisPass = 0;

				x -= iThisX;

				continue;
			}
			
			iSentTotal += iSentThisPass;		// Increment total received

			// Make sure we are not advancing that which we are not sending
			// eg. if x was 14 and we had send 12 bytes then we would want
			// to subtract 2; we divide iSentTotal by two because each
			// element of the array is two bytes
			x -= (14 - (iSentTotal / 2));
		}
		else 
		{
			if (WSAGetLastError() != WSAEWOULDBLOCK)
				return -1;
		}
	}
	
	return iSentTotal;
}

int SendHeader(SOCKET ClientSock, const short *piHeader, int iLength)
{
   int iSentTotal = 0;
   int iSentPass = 0;
   const int iLengthBytes = iLength*sizeof(short);
   const unsigned char *ptr = (const unsigned char*)piHeader;
   while(iSentTotal < iLengthBytes)
   {
      iSentPass = send(ClientSock, ptr, iLengthBytes-iSentTotal, 0);
      if(iSentPass != SOCKET_ERROR)
      {
         iSentTotal += iSentPass;
         ptr += iSentPass;
      }
      else
      {
         if(WSAGetLastError() != WSAEWOULDBLOCK)
            return -1;
      }
   }
   return iSentTotal;
}

int ReceiveHeader(SOCKET ClientSock, short *piHeader, int iLength)
{
   int iRecvTotal = 0;
   int iRecvPass = 0;
   const int iLengthBytes = iLength*sizeof(short);
   unsigned char *ptr = (const unsigned short*)piHeader;
   while(iRecvTotal < iLengthBytes)
   {
      iRecvPass = recv(ClientSock, ptr, iLengthBytes-iRecvTotal, 0);
      if(iRecvPass != SOCKET_ERROR)
      {
         iRecvTotal += iRecvPass;
         ptr += iRecvPass;
      }
      else
      {
         if(WSAGetLastError() != WSAEWOULDBLOCK)
            return -1;
      }
   }
   return iRecvTotal;
}