Write a c program too shutdown window operating system in TURBO C.

1. Write a c program too shutdown window operating system   in TURBO C.

void main(void)
{
system("shutdown -s");
}

Save the above .Let file name is close.c and compile and execute the above program. Now close the turbo c compiler and open the directory in window you have saved the close.c (default directory c:\tc\bin) and double click its exe file (close.exe).After some time your window will shutdown.

Inheritance

Inheritance- intro

---

The following topics are covered in this section:

• Introduction
• Access Specifiers

---

Inheritance

Inheritance means getting something from the parent. In C++ also, inheritance means the same. But who is the parent?

Remember that classes and objects are a key feature in C++. When we talk of inheritance in C++, we refer to classes. We will have the parent class and the derived class. The derived class inherits all properties of the parent class. The parent class is also known as the base class. All classes that arise from the base class are known as derived classes. These derived classes inherit all non-private parts of the base class (i.e. there are a few things that cannot be inherited from the base class. This is discussed later).

We have discussed earlier about a general class called ‘bacteria’. We also referred to two other classes called Ecoli and TB. Now, bacteria will form the base class while ecoli and TB will be derived from the bacteria class. In this way they will inherit all the general properties of a bacteria. In addition they will have their own special features (in our case they would have a special member function to describe the unique way in which they move).

You might wonder as to whether the child inherits everything from the parent? The derived class inherits everything that is NOT PRIVATE in the parent class. Remember we used ‘private’ and ‘public’ to restrict access to class members. Now when you declare any member as ‘private’, that member cannot be inherited by any of the children (in other words, private members are not inheritable). Only the ‘public’ members are inheritable.

When any data is made private in a class, it can be accessed ONLY by member functions of that class. A derived class CANNOT access the private members of its base class.
It might seem as if the concept of data encapsulation would be lost if a derived class can access only it’s parent’s public members (because the aim of classes is to restrict access to data and hence we make them public. But if we can’t inherit the private data, what’s the use of inheritance?). C++ provides us with a third access specifier called ‘protected’.

The three access specifiers for class members are:

• private
• public
• protected

If you declare class members as ‘protected’, then any class derived from the parent can access the protected members but no one from outside can make use of the protected members. In a way protected members are similar to private class members (because both cannot be accessed from outside the class). But both are different because protected members can be accessed by derived classes whereas private members cannot be accessed by derived classes. The use of protected access specifier is very important in inheritance.

Let's take a look at the syntax for making a derived class.
Create the base class as you normally would. Then when you want to create the derived class, use the following syntax:
class d1 : public b1
{
//body of d1;
};
where d1 is the name of the derived class and b1 is the name of the base class.

Let’s consider a different example for inheritance (instead of bacteria and biology). Consider cars: there are different types of cars in the world. Broadly we could divide them into two categories: normal cars and racing cars. Both of these categories belong to the same family of cars (since all cars will have some properties in common). Though they are common in certain respects they will have their own properties as well. Thus these two categories of cars can be derived from the general class of cars. Again within racing cars we have different manufacturers (and each manufacturer might make use of different specifications). For instance a ‘Ferrari’ and a ‘McLaren’ are not one and the same (even though both are racing cars). Thus let’s model a general class called ‘car’ (which will refer to racing cars). We will provide this class with only two properties: color and speed. From this class, we shall derive two classes called ‘Ferrari’ and ‘McLaren’.

From the above figure, it can be said that, “an object of type Ferrari is a RacingCar”. This is referred to as “is-a” relationship. The various types of relationships are:

is a

has a

is implemented in terms of

Remember: Every Ferrari is a car but not every car is a Ferrari.

When designing relationships between classes, ideally, whatever the parent can do the child should be able to do (this is the ‘is-a’ relationship).

// Program to demonstrate inheritance

#include <iostream.h>
class car
{protected:
    int speed;
char color[20];
public:
car( )
{
cout<<"\nCreating a Car";
}
~car( )
{
cout<<"\nDestroying Car";
}
void input( )
{
cout<<"\n\nEnter the colour of your car : ";
cin>>color;
cout<<"\nEnter the top speed : ";
cin>>speed;
}
};
class ferrari : public car
{private:
    int f;
public:
ferrari( )
{
cout<<"\nCreating a Ferrari";
}
~ferrari( )
{
cout<<"\nDestroying the Ferrari";
}
};
class mclaren : public car
{
private:
    int m;
public:
mclaren( )
{
cout<<"\nCreating a McLaren";
}
~mclaren( )
{
cout<<"\nDestroying the McLaren";
}
};

int main( )
{ferrari mine;
mine.input( );
return 0;
} Protected data will be inherited by the derived classes. Both the member data (speed and color) of the base class ‘car’ are protected. Thus all classes derived from ‘car’ will also have the property of ‘speed’ and ‘color’.
You might be wondering as to how the constructors and destructors will execute and in what order?
The output would be:
Creating a Car
Creating a Ferrari
Enter the colour of your car : red
Enter the top speed : 150
Destroying the Ferrari
Destroying Car

As can be seen, constructors execute from the top to bottom while the destructors execute in the reverse order. It’s like you will first construct a car and then label it as a Ferrari and while destroying you would remove the label Ferrari first and then dismantle the car.

Remember: The constructor of the base class and also the destructor will be invoked.

---

More on Inheritance (Base-Class Access specifier)
So far we have used the following syntax for inheritance:
class derived-name: public base-name
{
//body of class;
};

where derived-name is the name of the derived class and base-name is the name of the base class.
We have already dealt with access specifiers as used for class members. The type of access specifier used determines how the members of a class are accessed (i.e. whether they can be accessed from outside, or whether their access is restricted to class members or whether they can be accessed by derived classes). The 3 types of access specifiers are:

• private
• protected
• public

These 3 access specifiers can be used to determine how the derived class will access the properties derived from the base class. The general syntax for inheritance is thus as given below:

class name-of-derived-class : access-specifier name-of-base-class
{
//body of derived class;
};

We know that the derived class cannot access the private members of the base class. But what about the protected and public members of the base class? Do they become private members of the derived class? It is for clarifying this that we have to use an access-specifier to specify what we want the inherited members to become.

1. If you use the access specifier ‘public’:
   All the public members of the base class become public members of the derived class. The protected members become protected members of the derived class.
2. When you use ‘private’ as the access specifier:
   All public members of base class become private members of derived class.
   All protected members of base class also become private members of derived class.
3. When the base class is accessed as ‘protected’:
   All the public and protected members of base class become protected members of derived class.

TCP/IP Socket programing in c with Linux

TCP/IP socket programming

This is a quick guide/tutorial to learning socket programming in C language on a Linux system. "Linux" because the code snippets shown over here will work only on a Linux system and not on Windows. The windows api to socket programming is called winsock and we shall go through it in another tutorial.

Sockets are the fundamental "things" behind any kind of network communications done by your computer. For example when you type www.google.com in your web browser, it opens a socket and connects to google.com to fetch the page and show it to you. Same with any chat client like gtalk or skype. Any network communication goes through a socket.

Before you begin

This tutorial assumes that you have basic knowledge of C and pointers. You will need to have gcc compiler installed on your Linux system. An IDE along with gcc would be great. I would recommend geany as you can quickly edit and run single file programs in it without much configurations. On ubuntu you can do a sudo apt-get install geany on the terminal.

All along the tutorial there are code snippets to demonstrate some concepts. You can run those code snippets in geany rightaway and test the results to better understand the concepts.

Creating a socket

This first thing to do is create a socket. The socket() function does this.
Here is a code sample :

1	#include<stdio.h>
2	#include<sys/socket.h>

3
4	int main(int argc , char *argv[])

5	{
6	int socket_desc;

7	socket_desc = socket(AF_INET , SOCK_STREAM , 0);
8

9	if (socket_desc == -1)
10		{

11	printf("Could not create socket");
12	}

13
14	return 0;

15

}

Function socket() creates a socket and returns a socket descriptor which can be used in other network commands. The above code will create a socket of :

Address Family : AF_INET (this is IP version 4)
Type : SOCK_STREAM (this means connection oriented TCP protocol)
Protocol : 0 [ or IPPROTO_IP This is IP protocol]

Ok , so you have created a socket successfully. But what next ? Next we shall try to connect to some server using this socket. We can connect to www.google.com

Note

Apart from SOCK_STREAM type of sockets there is another type called SOCK_DGRAM which indicates the UDP protocol. This type of socket is non-connection socket. In this tutorial we shall stick to SOCK_STREAM or TCP sockets.

Connect to a Server

We connect to a remote server on a certain port number. So we need 2 things , IP address and port number to connect to.

To connect to a remote server we need to do a couple of things. First is create a sockaddr_in structure with proper values filled in. Lets create one for ourselves :

1	struct sockaddr_in server;

Have a look at the structure

1	// IPv4 AF_INET sockets:
2	struct sockaddr_in {

3	short            sin_family;   // e.g. AF_INET, AF_INET6
4	unsigned short   sin_port;     // e.g. htons(3490)

5	struct in_addr   sin_addr;     // see struct in_addr, below
6	char             sin_zero[8];  // zero this if you want to

7	};
8

9	struct in_addr {
10		unsigned long s_addr;          // load with inet_pton()

11	};
12

13	struct sockaddr {
14	unsigned short    sa_family;    // address family, AF_xxx

15	char              sa_data[14];  // 14 bytes of protocol address
16	};

The sockaddr_in has a member called sin_addr of type in_addr which has a s_addr which is nothing but a long. It contains the IP address in long format.

Function inet_addr is a very handy function to convert an IP address to a long format. This is how you do it :

1	server.sin_addr.s_addr = inet_addr("74.125.235.20");

So you need to know the IP address of the remote server you are connecting to. Here we used the ip address of google.com as a sample. A little later on we shall see how to find out the ip address of a given domain name.

The last thing needed is the connect function. It needs a socket and a sockaddr structure to connect to. Here is a code sample.

1	#include<stdio.h>
2	#include<sys/socket.h>

3	#include<arpa/inet.h> //inet_addr
4

5	int main(int argc , char *argv[])
6	{

7	int socket_desc;
8	struct sockaddr_in server;

9
10		//Create socket

11	socket_desc = socket(AF_INET , SOCK_STREAM , 0);
12	if (socket_desc == -1)

13	{
14	printf("Could not create socket");

15	}
16

17	server.sin_addr.s_addr = inet_addr("74.125.235.20");
18	server.sin_family = AF_INET;

19	server.sin_port = htons( 80 );
20

21	//Connect to remote server
22	if (connect(socket_desc , (struct sockaddr *)&server , sizeof(server)) < 0)

23	{
24	puts("connect error");

25	return 1;
26	}

27
28	puts("Connected");

29	return 0;
30	}

It cannot be any simpler. It creates a socket and then connects. If you run the program it should show Connected.
Try connecting to a port different from port 80 and you should not be able to connect which indicates that the port is not open for connection.

OK , so we are now connected. Lets do the next thing , sending some data to the remote server.

Quick Note

The concept of "connections" apply to SOCK_STREAM/TCP type of sockets. Connection means a reliable "stream" of data such that there can be multiple such streams each having communication of its own. Think of this as a pipe which is not interfered by other data.

Other sockets like UDP , ICMP , ARP dont have a concept of "connection". These are non-connection based communication. Which means you keep sending or receiving packets from anybody and everybody.

Sending Data

Function send will simply send data. It needs the socket descriptor , the data to send and its size.
Here is a very simple example of sending some data to google.com ip :

1	#include<stdio.h>
2	#include<string.h>    //strlen

3	#include<sys/socket.h>
4	#include<arpa/inet.h> //inet_addr

5
6	int main(int argc , char *argv[])

7	{
8	int socket_desc;

9	struct sockaddr_in server;
10		char *message;

11
12	//Create socket

13	socket_desc = socket(AF_INET , SOCK_STREAM , 0);
14	if (socket_desc == -1)

15	{
16	printf("Could not create socket");

17	}
18

19	server.sin_addr.s_addr = inet_addr("74.125.235.20");
20	server.sin_family = AF_INET;

21	server.sin_port = htons( 80 );
22

23	//Connect to remote server
24	if (connect(socket_desc , (struct sockaddr *)&server , sizeof(server)) < 0)

25	{
26	puts("connect error");

27	return 1;
28	}

29
30	puts("Connected\n");

31
32	//Send some data

33	message = "GET / HTTP/1.1\r\n\r\n";
34	if( send(socket_desc , message , strlen(message) , 0) < 0)

35	{
36	puts("Send failed");

37	return 1;
38	}

39	puts("Data Send\n");
40

41	return 0;
42	}

In the above example , we first connect to an ip address and then send the string message "GET / HTTP/1.1\r\n\r\n" to it.
The message is actually a http command to fetch the mainpage of a website.

Now that we have send some data , its time to receive a reply from the server. So lets do it.

Note

When sending data to a socket you are basically writing data to that socket. This is similar to writing data to a file. Hence you can also use the write function to send data to a socket. Later in this tutorial we shall use write function to send data.

Receiving Data

Function recv is used to receive data on a socket. In the following example we shall send the same message as the last example and receive a reply from the server.

1	#include<stdio.h>
2	#include<string.h>    //strlen

3	#include<sys/socket.h>
4	#include<arpa/inet.h> //inet_addr

5
6	int main(int argc , char *argv[])

7	{
8	int socket_desc;

9	struct sockaddr_in server;
10		char *message , server_reply[2000];

11
12	//Create socket

13	socket_desc = socket(AF_INET , SOCK_STREAM , 0);
14	if (socket_desc == -1)

15	{
16	printf("Could not create socket");

17	}
18

19	server.sin_addr.s_addr = inet_addr("74.125.235.20");
20	server.sin_family = AF_INET;

21	server.sin_port = htons( 80 );
22

23	//Connect to remote server
24	if (connect(socket_desc , (struct sockaddr *)&server , sizeof(server)) < 0)

25	{
26	puts("connect error");

27	return 1;
28	}

29
30	puts("Connected\n");

31
32	//Send some data

33	message = "GET / HTTP/1.1\r\n\r\n";
34	if( send(socket_desc , message , strlen(message) , 0) < 0)

35	{
36	puts("Send failed");

37	return 1;
38	}

39	puts("Data Send\n");
40

41	//Receive a reply from the server
42	if( recv(socket_desc, server_reply , 2000 , 0) < 0)

43	{
44	puts("recv failed");

45	}
46	puts("Reply received\n");

47	puts(server_reply);
48

49	return 0;
50	}

Here is the output of the above code :

Connected

Data Send

Reply received

HTTP/1.1 302 Found

Location: http://www.google.co.in/

Cache-Control: private

Content-Type: text/html; charset=UTF-8

Set-Cookie: PREF=ID=0edd21a16f0db219:FF=0:TM=1324644706:LM=1324644706:S=z6hDC9cZfGEowv_o; expires=Sun, 22-Dec-2013 12:51:46 GMT; path=/; domain=.google.com

Date: Fri, 23 Dec 2011 12:51:46 GMT

Server: gws

Content-Length: 221

X-XSS-Protection: 1; mode=block

X-Frame-Options: SAMEORIGIN

<HTML><HEAD><meta http-equiv="content-type" content="text/html;charset=utf-8">

<TITLE>302 Moved</TITLE></HEAD><BODY>

<H1>302 Moved</H1>

The document has moved

<A HREF="http://www.google.co.in/">here</A>.

</BODY></HTML>

We can see what reply was send by the server. It looks something like Html, well IT IS html. Google.com replied with the content of the page we requested. Quite simple!

Note

When receiving data on a socket , we are basically reading the data on the socket. This is similar to reading data from a file. So we can also use the read function to read data on a socket. For example :

1	read(socket_desc, server_reply , 2000);

Now that we have received our reply, its time to close the socket.

Close socket

Function close is used to close the socket. Need to include the unistd.h header file for this.

1	close(socket_desc);

Thats it.

Lets Revise

So in the above example we learned how to :
1. Create a socket
2. Connect to remote server
3. Send some data
4. Receive a reply

Its useful to know that your web browser also does the same thing when you open www.google.com
This kind of socket activity represents a CLIENT. A client is a system that connects to a remote system to fetch or retrieve data.

The other kind of socket activity is called a SERVER. A server is a system that uses sockets to receive incoming connections and provide them with data. It is just the opposite of Client. So www.google.com is a server and your web browser is a client. Or more technically www.google.com is a HTTP Server and your web browser is an HTTP client.

Now its time to do some server tasks using sockets. But before we move ahead there are a few side topics that should be covered just incase you need them.

Get IP address of a hostname/domain

When connecting to a remote host , it is necessary to have its IP address. Function gethostbyname is used for this purpose. It takes the domain name as the parameter and returns a structure of type hostent. This structure has the ip information. It is present in netdb.h. Lets have a look at this structure

1	/* Description of data base entry for a single host.  */
2	struct hostent

3	{
4	char *h_name;         /* Official name of host.  */

5	char **h_aliases;     /* Alias list.  */
6	int h_addrtype;       /* Host address type.  */

7	int h_length;         /* Length of address.  */
8	char **h_addr_list;       /* List of addresses from name server.  */

9

};

The h_addr_list has the IP addresses. So now lets have some code to use them.

1	#include<stdio.h> //printf
2	#include<string.h> //strcpy

3	#include<sys/socket.h>
4	#include<netdb.h> //hostent

5	#include<arpa/inet.h>
6

7	int main(int argc , char *argv[])
8	{

9	char *hostname = "www.google.com";
10		char ip[100];

11	struct hostent *he;
12	struct in_addr **addr_list;

13	int i;
14

15	if ( (he = gethostbyname( hostname ) ) == NULL)
16	{

17	//gethostbyname failed
18	herror("gethostbyname");

19	return 1;
20	}

21
22	//Cast the h_addr_list to in_addr , since h_addr_list also has the ip address in long format only

23	addr_list = (struct in_addr **) he->h_addr_list;
24

25	for(i = 0; addr_list[i] != NULL; i++)
26	{

27	//Return the first one;
28	strcpy(ip , inet_ntoa(*addr_list[i]) );

29	}
30

31	printf("%s resolved to : %s" , hostname , ip);
32	return 0;

33

}

Output of the code would look like :

www.google.com resolved to : 74.125.235.20

So the above code can be used to find the ip address of any domain name. Then the ip address can be used to make a connection using a socket.

Function inet_ntoa will convert an IP address in long format to dotted format. This is just the opposite of inet_addr.

So far we have see some important structures that are used. Lets revise them :

1. sockaddr_in - Connection information. Used by connect , send , recv etc.
2. in_addr - Ip address in long format
3. sockaddr
4. hostent - The ip addresses of a hostname. Used by gethostbyname

In the next part we shall look into creating servers using socket. Servers are the opposite of clients, that instead of connecting out to others, they wait for incoming connections.

Server Concepts

OK now onto server things. Servers basically do the following :

1. Open a socket
2. Bind to a address(and port).
3. Listen for incoming connections.
4. Accept connections
5. Read/Send

We have already learnt how to open a socket. So the next thing would be to bind it.

Bind a socket

Function bind can be used to bind a socket to a particular address and port. It needs a sockaddr_in structure similar to connect function.

Lets see a code example :

1	#include<stdio.h>
2	#include<sys/socket.h>

3	#include<arpa/inet.h> //inet_addr
4

5	int main(int argc , char *argv[])
6	{

7	int socket_desc;
8	struct sockaddr_in server;

9
10		//Create socket

11	socket_desc = socket(AF_INET , SOCK_STREAM , 0);
12	if (socket_desc == -1)

13	{
14	printf("Could not create socket");

15	}
16

17	//Prepare the sockaddr_in structure
18	server.sin_family = AF_INET;

19	server.sin_addr.s_addr = INADDR_ANY;
20	server.sin_port = htons( 8888 );

21
22	//Bind

23	if( bind(socket_desc,(struct sockaddr *)&server , sizeof(server)) < 0)
24	{

25	puts("bind failed");
26	}

27	puts("bind done");
28

29	return 0;
30	}

Now that bind is done, its time to make the socket listen to connections. We bind a socket to a particular IP address and a certain port number. By doing this we ensure that all incoming data which is directed towards this port number is received by this application.

This makes it obvious that you cannot have 2 sockets bound to the same port.

Listen for connections

After binding a socket to a port the next thing we need to do is listen for connections. For this we need to put the socket in listening mode. Function listen is used to put the socket in listening mode. Just add the following line after bind.

1	//Listen
2	listen(socket_desc , 3);

Thats all. Now comes the main part of accepting new connections.

Accept connection

Function accept is used for this. Here is the code

1	#include<stdio.h>
2	#include<sys/socket.h>

3	#include<arpa/inet.h> //inet_addr
4

5	int main(int argc , char *argv[])
6	{

7	int socket_desc , new_socket , c;
8	struct sockaddr_in server , client;

9
10		//Create socket

11	socket_desc = socket(AF_INET , SOCK_STREAM , 0);
12	if (socket_desc == -1)

13	{
14	printf("Could not create socket");

15	}
16

17	//Prepare the sockaddr_in structure
18	server.sin_family = AF_INET;

19	server.sin_addr.s_addr = INADDR_ANY;
20	server.sin_port = htons( 8888 );

21
22	//Bind

23	if( bind(socket_desc,(struct sockaddr *)&server , sizeof(server)) < 0)
24	{

25	puts("bind failed");
26	}

27	puts("bind done");
28

29	//Listen
30	listen(socket_desc , 3);

31
32	//Accept and incoming connection

33	puts("Waiting for incoming connections...");
34	c = sizeof(struct sockaddr_in);

35	new_socket = accept(socket_desc, (struct sockaddr *)&client, (socklen_t*)&c);
36	if (new_socket<0)

37	{
38	perror("accept failed");

39	}
40

41	puts("Connection accepted");
42

43	return 0;
44	}

Output

Run the program. It should show

bind done

Waiting for incoming connections...

So now this program is waiting for incoming connections on port 8888. Dont close this program , keep it running.
Now a client can connect to it on this port. We shall use the telnet client for testing this. Open a terminal and type

$ telnet localhost 8888

On the terminal you shall get

Trying 127.0.0.1...

Connected to localhost.

Escape character is '^]'.

Connection closed by foreign host.

And the server output will show

bind done

Waiting for incoming connections...

Connection accepted

So we can see that the client connected to the server. Try the above process till you get it perfect.

Note

You can get the ip address of client and the port of connection by using the sockaddr_in structure passed to accept function. It is very simple :

1	char *client_ip = inet_ntoa(client.sin_addr);
2	int client_port = ntohs(client.sin_port);

We accepted an incoming connection but closed it immediately. This was not very productive. There are lots of things that can be done after an incoming connection is established. Afterall the connection was established for the purpose of communication. So lets reply to the client.

We can simply use the write function to write something to the socket of the incoming connection and the client should see it. Here is an example :

1	#include<stdio.h>
2	#include<string.h>    //strlen

3	#include<sys/socket.h>
4	#include<arpa/inet.h> //inet_addr

5	#include<unistd.h>    //write
6

7	int main(int argc , char *argv[])
8	{

9	int socket_desc , new_socket , c;
10		struct sockaddr_in server , client;

11	char *message;
12

13	//Create socket
14	socket_desc = socket(AF_INET , SOCK_STREAM , 0);

15	if (socket_desc == -1)
16	{

17	printf("Could not create socket");
18	}

19
20	//Prepare the sockaddr_in structure

21	server.sin_family = AF_INET;
22	server.sin_addr.s_addr = INADDR_ANY;

23	server.sin_port = htons( 8888 );
24

25	//Bind
26	if( bind(socket_desc,(struct sockaddr *)&server , sizeof(server)) < 0)

27	{
28	puts("bind failed");

29	return 1;
30	}

31	puts("bind done");
32

33	//Listen
34	listen(socket_desc , 3);

35
36	//Accept and incoming connection

37	puts("Waiting for incoming connections...");
38	c = sizeof(struct sockaddr_in);

39	new_socket = accept(socket_desc, (struct sockaddr *)&client, (socklen_t*)&c);
40	if (new_socket<0)

41	{
42	perror("accept failed");

43	return 1;
44	}

45
46	puts("Connection accepted");

47
48	//Reply to the client

49	message = "Hello Client , I have received your connection. But I have to go now, bye\n";
50	write(new_socket , message , strlen(message));

51
52	return 0;

53

}

Run the above code in 1 terminal. And connect to this server using telnet from another terminal and you should see this :

$ telnet localhost 8888

Trying 127.0.0.1...

Connected to localhost.

Escape character is '^]'.

Hello Client , I have received your connection. But I have to go now, bye

Connection closed by foreign host.

So the client(telnet) received a reply from server.

We can see that the connection is closed immediately after that simply because the server program ends after accepting and sending reply. A server like www.google.com is always up to accept incoming connections.

It means that a server is supposed to be running all the time. Afterall its a server meant to serve. So we need to keep our server RUNNING non-stop. The simplest way to do this is to put the accept in a loop so that it can receive incoming connections all the time.

Live Server

So a live server will be alive for all time. Lets code this up :

1	#include<stdio.h>
2	#include<string.h>    //strlen

3	#include<sys/socket.h>
4	#include<arpa/inet.h> //inet_addr

5	#include<unistd.h>    //write
6

7	int main(int argc , char *argv[])
8	{

9	int socket_desc , new_socket , c;
10		struct sockaddr_in server , client;

11	char *message;
12

13	//Create socket
14	socket_desc = socket(AF_INET , SOCK_STREAM , 0);

15	if (socket_desc == -1)
16	{

17	printf("Could not create socket");
18	}

19
20	//Prepare the sockaddr_in structure

21	server.sin_family = AF_INET;
22	server.sin_addr.s_addr = INADDR_ANY;

23	server.sin_port = htons( 8888 );
24

25	//Bind
26	if( bind(socket_desc,(struct sockaddr *)&server , sizeof(server)) < 0)

27	{
28	puts("bind failed");

29	return 1;
30	}

31	puts("bind done");
32

33	//Listen
34	listen(socket_desc , 3);

35
36	//Accept and incoming connection

37	puts("Waiting for incoming connections...");
38	c = sizeof(struct sockaddr_in);

39	while( (new_socket = accept(socket_desc, (struct sockaddr *)&client, (socklen_t*)&c)) )
40	{

41	puts("Connection accepted");
42

43	//Reply to the client
44	message = "Hello Client , I have received your connection. But I have to go now, bye\n";

45	write(new_socket , message , strlen(message));
46	}

47
48	if (new_socket<0)

49	{
50	perror("accept failed");

51	return 1;
52	}

53
54	return 0;

55

}

We havent done a lot there. Just the accept was put in a loop.

Now run the program in 1 terminal , and open 3 other terminals. From each of the 3 terminal do a telnet to the server port.

Each of the telnet terminal would show :

1	$ telnet localhost 8888
2	Trying 127.0.0.1...

3	Connected to localhost.
4	Escape character is '^]'.

5	Hello Client , I have received your connection. But I have to go now, bye

And the server terminal would show

bind done

Waiting for incoming connections...

Connection accepted

Connection accepted

Connection accepted

So now the server is running nonstop and the telnet terminals are also connected nonstop. Now close the server program.
All telnet terminals would show "Connection closed by foreign host."
Good so far. But still there is not effective communication between the server and the client.

The server program accepts connections in a loop and just send them a reply, after that it does nothing with them. Also it is not able to handle more than 1 connection at a time. So now its time to handle the connections , and handle multiple connections together.

Handling Connections

To handle every connection we need a separate handling code to run along with the main server accepting connections.
One way to achieve this is using threads. The main server program accepts a connection and creates a new thread to handle communication for the connection, and then the server goes back to accept more connections.

On Linux threading can be done with the pthread (posix threads) library. It would be good to read some small tutorial about it if you dont know anything about it. However the usage is not very complicated.

We shall now use threads to create handlers for each connection the server accepts. Lets do it pal.

1	#include<stdio.h>
2	#include<string.h>    //strlen

3	#include<stdlib.h>    //strlen
4	#include<sys/socket.h>

5	#include<arpa/inet.h> //inet_addr
6	#include<unistd.h>    //write

7
8	#include<pthread.h> //for threading , link with lpthread

9
10		void *connection_handler(void *);

11
12	int main(int argc , char *argv[])

13	{
14	int socket_desc , new_socket , c , *new_sock;

15	struct sockaddr_in server , client;
16	char *message;

17
18	//Create socket

19	socket_desc = socket(AF_INET , SOCK_STREAM , 0);
20	if (socket_desc == -1)

21	{
22	printf("Could not create socket");

23	}
24

25	//Prepare the sockaddr_in structure
26	server.sin_family = AF_INET;

27	server.sin_addr.s_addr = INADDR_ANY;
28	server.sin_port = htons( 8888 );

29
30	//Bind

31	if( bind(socket_desc,(struct sockaddr *)&server , sizeof(server)) < 0)
32	{

33	puts("bind failed");
34	return 1;

35	}
36	puts("bind done");

37
38	//Listen

39	listen(socket_desc , 3);
40

41	//Accept and incoming connection
42	puts("Waiting for incoming connections...");

43	c = sizeof(struct sockaddr_in);
44	while( (new_socket = accept(socket_desc, (struct sockaddr *)&client, (socklen_t*)&c)) )

45	{
46	puts("Connection accepted");

47
48	//Reply to the client

49	message = "Hello Client , I have received your connection. And now I will assign a handler for you\n";
50	write(new_socket , message , strlen(message));

51
52	pthread_t sniffer_thread;

53	new_sock = malloc(1);
54	*new_sock = new_socket;

55
56	if( pthread_create( &sniffer_thread , NULL ,  connection_handler , (void*) new_sock) < 0)

57	{
58	perror("could not create thread");

59	return 1;
60	}

61
62	//Now join the thread , so that we dont terminate before the thread

63	//pthread_join( sniffer_thread , NULL);
64	puts("Handler assigned");

65	}
66

67	if (new_socket<0)
68	{

69	perror("accept failed");
70	return 1;

71	}
72

73	return 0;
74	}

75
76	/*

77	* This will handle connection for each client
78	* */

79	void *connection_handler(void *socket_desc)
80	{

81	//Get the socket descriptor
82	int sock = *(int*)socket_desc;

83
84	char *message;

85
86	//Send some messages to the client

87	message = "Greetings! I am your connection handler\n";
88	write(sock , message , strlen(message));

89
90	message = "Its my duty to communicate with you";

91	write(sock , message , strlen(message));
92

93	//Free the socket pointer
94	free(socket_desc);

95
96	return 0;

97

}

Run the above server and open 3 terminals like before. Now the server will create a thread for each client connecting to it.

The telnet terminals would show :

$ telnet localhost 8888

Trying 127.0.0.1...

Connected to localhost.

Escape character is '^]'.

Hello Client , I have received your connection. And now I will assign a handler for you

Hello I am your connection handler

Its my duty to communicate with you

This one looks good , but the communication handler is also quite dumb. After the greeting it terminates. It should stay alive and keep communicating with the client.

One way to do this is by making the connection handler wait for some message from a client as long as the client is connected. If the client disconnects , the connection handler ends.

So the connection handler can be rewritten like this :

1	/*
2	* This will handle connection for each client

3	* */
4	void *connection_handler(void *socket_desc)

5	{
6	//Get the socket descriptor

7	int sock = *(int*)socket_desc;
8	int read_size;

9	char *message , client_message[2000];
10

11	//Send some messages to the client
12	message = "Greetings! I am your connection handler\n";

13	write(sock , message , strlen(message));
14

15	message = "Now type something and i shall repeat what you type \n";
16	write(sock , message , strlen(message));

17
18	//Receive a message from client

19	while( (read_size = recv(sock , client_message , 2000 , 0)) > 0 )
20	{

21	//Send the message back to client
22	write(sock , client_message , strlen(client_message));

23	}
24

25	if(read_size == 0)
26	{

27	puts("Client disconnected");
28	fflush(stdout);

29	}
30	else if(read_size == -1)

31	{
32	perror("recv failed");

33	}
34

35	//Free the socket pointer
36	free(socket_desc);

37
38	return 0;

39

}

The above connection handler takes some input from the client and replies back with the same. Simple! Here is how the telnet output might look

$ telnet localhost 8888

Trying 127.0.0.1...

Connected to localhost.

Escape character is '^]'.

Hello Client , I have received your connection. And now I will assign a handler for you

Greetings! I am your connection handler

Now type something and i shall repeat what you type

Hello

Hello

How are you

How are you

I am fine

I am fine

So now we have a server thats communicative. Thats useful now.

Linking the pthread library

When compiling programs that use the pthread library you need to link the library. This is done like this :

$ gcc program.c -lpthread

Conclusion

By now you must have learned the basics of socket programming in C. You can try out some experiments like writing a chat client or something similar.

If you think that the tutorial needs some addons or improvements or any of the code snippets above dont work then feel free to make a comment below so that it gets fixed.