#define APP_PORT 0x1983 // We define a port that we are going to use.

// Here is a structure contains the port we'll use,
// the protocol type and the IP address we'll communicate with.
SOCKADDR_IN sockaddr;

// This is our socket, it is the handle to the IO address to read/write packets
SOCKET sock;

WSADATA data;

// First we see if there is a winsock ver 2.2 installed on the computer,
we initizalize the sockets DLL for out app.
if (WSAStartup(MAKEWORD(2, 2), &data) != 0) return(0);

// Here we create our socket, which will be a UDP socket (SOCK_DGRAM).
sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (!sock)
{
 // Creation failed!
}
//Now we'll set the sockaddr variables:
sockaddr.sin_family = AF_INET; // Must be AF_INET
// If this is the Server:
 sockaddr.sin_addr.s_addr = INADDR_ANY; // Means we will "answer" to all addresses.
// Or if this is the client, set IP of the server to connect to.
 sockaddr.sin_addr.s_addr = inet_addr("127.0.0.1"); // IP to communicate with.

// The following sets our communication port.
// 'htons()' reverses the bytes (0x1020 would become 0x2010).
// This metod is called Big Endian and it was first used on Unix systems, you
// have to call it because all systems work that way
sockaddr.sin_port = htons(APP_PORT);

// A server need to bind the socket to itself in order to receive all the packets
// it gets from a port

int ret = bind(sock, (SOCKADDR *)&sockaddr, sizeof(SOCKADDR));
if (ret)
{
 // Bind failed!
}

// That's it, now let's send a message...
char buffer[256];
strcpy(buffer, "HELLO!!!");
int len = sizeof(SOCKADDR);
sendto(sock, buffer, strlen(buffer), 0, (SOCKADDR *)&sockaddr, sizeof(SOCKADDR));
// Notice we use sendto() and NOT send(), because we use UDP!

// Easy huh?? Let's receive a packet..

SOCKADDR from;
char inbuffer[256];
int len = sizeof(SOCKADDR);
memset(inbuffer, '\0', 256);
recvfrom(sock, inbuffer, sizeof(inbuffer)-1, 0, &from, &len);
MessageBox(NULL, inbuffer, "Incoming Data", MB_OK);
// In the from structure we can see who sent the packet...

closesocket(sock);
WSACleanup();

OK, that's it for setting up a sever/client and send/receive packets... Now after you know to received and sent packets, let's go on, Have you ever heard of blocking sockets?? Well, think you call recvfrom() and there is no packet to receive, so the system will wait until it receives a packet and JUST then it will get back to your app...This is called the blocking sockets. Now, there are non-blocking sockets. You'll find yourself waiting in a loop 'till you receive the proper return value from a non-blocking socket. So it's a big headache and usually not helpful much. Now let's move to another kind of blocking sockets, but with something better, which is called Select(). You tell your system to tell you when a socket arrives and then you receive a message that tells your app that you can receive the packet, get it? Then if the system tells you that a message arrived you'll just pick it up and you won't have to block your application because there must be a packet to receive! And this makes the Select function so good that you don't need to wait, Windows will message you.
Let's see how to use the WSAAsyncSelect()

// We define a message which will be used by the system to tell that a network // event occured (in this tutorials - only receiving messages) #define WM_SOCKETREAD (WM_APP + 100) // Call WSAAsyncSelect() after you are done setting the server/client variables... WSAAsyncSelect(sock, g_hWnd, WM_SOCKETREAD, FD_READ); // This function parameters are the sock we use (to receive the packets from). // The window that will receive the messages that tell a network event // occured (packet arrived in our case). // It will send the message to the passed window. // Let's say we created a normal window... // So it must has a WindowProcedure(which will get the message). LRESULT CALLBACK WindProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) { switch(msg) { case WM_SOCKETREAD: { // Here we receive the packet like we did before. SOCKADDR from; char inbuffer[256]; int len = sizeof(SOCKADDR); memset(inbuffer, '\0', 256); recvfrom(sock, inbuffer, sizeof(inbuffer)-1, 0, &from, &len); }break; case .... break; case .... break; } return(DefWindowProc(hWnd, msg, wParam, lParam)); }

Kewl function huh?? You'll be using it a lot if you set a timer and see if there is a message in the queue waiting for us to read it! I'm going to take some nap I hope you understand all this UDP stuff and espcially the WSAAsyncSelect() because you'll use it in TCP too :) Farewell
BTW-Download the source code you'll see how all the code works TOGETHER!