├── .gitignore
├── Client
    ├── Header Files
    │   ├── Class_ClientNetworkInit.hpp
    │   ├── Class_Logger.hpp
    │   ├── Function_ClientNetworkCom.hpp
    │   ├── Function_GetAuthenticationData.hpp
    │   └── Function_RunCounter.hpp
    └── Program Codes
    │   ├── ChatClient.cpp
    │   └── RunMeOnlyOnce.cpp
├── LICENSE
├── README.md
├── Server
    ├── Header Files
    │   ├── Class_Logger.hpp
    │   ├── Class_NetworkInit.hpp
    │   ├── Function_Menu.hpp
    │   ├── Function_MessageParser.hpp
    │   ├── Function_NetworkCom.hpp
    │   ├── Function_RunCounter.hpp
    │   └── Library_IDManager.hpp
    └── Program Codes
    │   ├── ChatServer.cpp
    │   └── RunMeOnlyOnce.cpp
└── User Guide.pdf


/.gitignore:
--------------------------------------------------------------------------------
 1 | # Prerequisites
 2 | *.d
 3 | 
 4 | # Compiled Object files
 5 | *.slo
 6 | *.lo
 7 | *.o
 8 | *.obj
 9 | 
10 | # Precompiled Headers
11 | *.gch
12 | *.pch
13 | 
14 | # Compiled Dynamic libraries
15 | *.so
16 | *.dylib
17 | *.dll
18 | 
19 | # Fortran module files
20 | *.mod
21 | *.smod
22 | 
23 | # Compiled Static libraries
24 | *.lai
25 | *.la
26 | *.a
27 | *.lib
28 | 
29 | # Executables
30 | *.exe
31 | *.out
32 | *.app
33 | 


--------------------------------------------------------------------------------
/Client/Header Files/Class_ClientNetworkInit.hpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <winsock2.h>
  3 | #include <windows.h>
  4 | #include "Class_Logger.hpp"
  5 | using namespace std;
  6 | 
  7 | 
  8 | SOCKET ServerCom = INVALID_SOCKET;
  9 | int ClientAddressSize;
 10 | SOCKADDR_IN ClientAddress;
 11 | char lftxt[40] = "../Logs/ClientNetworkInitLogs";
 12 | logfile lf(lftxt);
 13 | 
 14 | class ClientNetworkInit
 15 | {
 16 | 	private:
 17 | 	    WSAData ClientNetworkData;
 18 | 	    char message[512];
 19 | 
 20 |     public:
 21 |         ClientNetworkInit(char sIP[],u_short sPORT)
 22 |         {
 23 |         	lf.writeLog(sIP);
 24 |             cout<<"Intializing Winsock API";
 25 | 			strcpy(lftxt,"Initializing Winsock API");
 26 | 			lf.writeLog(lftxt);
 27 | 			                                                                                                   
 28 | 		    for(int i=0;i<15;i++)                                                                                                                
 29 | 	   	    {
 30 | 			  cout<<".";
 31 | 			  Sleep(100);
 32 | 		    }
 33 | 		    if(!WSAStartup(MAKEWORD(2,1),(WSAData*)&ClientNetworkData))
 34 | 		    {
 35 | 		    	cout<<"done"<<endl;
 36 | 		    	strcpy(lftxt,"done");
 37 | 			    lf.writeLog(lftxt);
 38 | 			}
 39 | 			else
 40 | 			{
 41 | 				cout<<"Error starting Winsock API"<<endl;
 42 | 				strcpy(lftxt,"Error starting Winsock API");
 43 | 			    lf.writeLog(lftxt);
 44 | 			    
 45 | 			    cout<<"Shutting down the server"<<endl;
 46 | 			    strcpy(lftxt,"Error starting Winsock API");
 47 | 			    lf.writeLog(lftxt);
 48 | 				lf.~logfile();
 49 | 				
 50 | 				closesocket(ServerCom);
 51 | 	            WSACleanup();
 52 | 	            exit(0);
 53 | 			}
 54 |             
 55 |             ClientAddress.sin_addr.s_addr = inet_addr(sIP);
 56 | 		    ClientAddress.sin_port = htons(sPORT);
 57 | 		    ClientAddress.sin_family = AF_INET;
 58 | 		    
 59 | 		    ClientAddressSize = sizeof(ClientAddress);
 60 | 		    ServerCom = socket(AF_INET,SOCK_STREAM,0);
 61 | 		    
 62 | 		    if(ServerCom == INVALID_SOCKET)
 63 | 		    {
 64 | 		        cout<<"Error initialising socket"<<endl;
 65 | 		        strcpy(lftxt,"Error starting socket");
 66 | 			    lf.writeLog(lftxt);
 67 | 			    lf.~logfile();
 68 | 				closesocket(ServerCom);
 69 | 	            WSACleanup();
 70 | 	            exit(0);
 71 | 			}
 72 | 			else
 73 | 			{
 74 | 				cout<<"Socket Intialised"<<endl;
 75 | 				strcpy(lftxt,"Socket Intialised");
 76 | 			    lf.writeLog(lftxt);
 77 | 			}
 78 | 		}
 79 |         void ConnectServer()
 80 |         {
 81 |             int val;
 82 |             val = connect(ServerCom,(SOCKADDR*)&ClientAddress,ClientAddressSize); 
 83 |             if(!val)
 84 |             {
 85 |                cout<<"Connected to server"<<endl;
 86 |                strcpy(lftxt,"Connected to server");
 87 | 			   lf.writeLog(lftxt);
 88 | 			} 
 89 | 			   
 90 | 		    else
 91 | 		    {
 92 | 		     cout<<"Unable to connect to the server"<<endl;	
 93 | 		     strcpy(lftxt,"Unable to connect to the server");
 94 | 			 lf.writeLog(lftxt);
 95 | 			
 96 | 		     cout<<"Closing chat client"<<endl;
 97 | 		     strcpy(lftxt,"Closing chat client");
 98 | 			 lf.writeLog(lftxt);
 99 | 			 lf.~logfile();
100 | 			 
101 | 		     WSACleanup();
102 | 		     exit(0);
103 | 		    }
104 | 	    }
105 | };
106 | 


--------------------------------------------------------------------------------
/Client/Header Files/Class_Logger.hpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <fstream>
 3 | #include <string.h>
 4 | #include <ctime>
 5 | #include <algorithm>
 6 | #include <stdlib.h>
 7 | #include "Function_RunCounter.hpp"
 8 | using namespace std;
 9 | 
10 | class logfile
11 | {
12 | 	private:
13 | 		time_t now;
14 | 		char* time_now;
15 | 		fstream WriteLog;
16 | 	public:
17 | 	    logfile(char filename[])
18 | 		{
19 | 			char count[2];
20 | 			snprintf(count,sizeof(count),"%d",ReadRunCounter());
21 | 		   	now = time(0);
22 | 		   	time_now = ctime(&now);
23 | 		   	WriteLog.open(strcat(strcat(filename,count),".txt"),ios::out);
24 | 		   	WriteLog<<"Run Time : "<<time_now;
25 | 		   	WriteLog<<endl;
26 | 	    }
27 | 	    
28 | 	    void writeLog(char event[])
29 | 	    {
30 | 	    	WriteLog<<event;
31 | 	    	WriteLog<<endl;
32 | 		}
33 | 		
34 | 		~logfile()
35 | 		{
36 | 			WriteLog.close();
37 | 		}
38 | };
39 | 
40 | 


--------------------------------------------------------------------------------
/Client/Header Files/Function_ClientNetworkCom.hpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <string>
  3 | #include "Function_GetAuthenticationData.hpp"
  4 | using namespace std;
  5 | 
  6 | struct chatData
  7 | {
  8 | 	int myid;
  9 | 	int chatid;
 10 | };
 11 | 
 12 | void DataExt(char msg[],chatData& data)
 13 | {
 14 |    char tmp[3];
 15 |    char tmp0[3];
 16 |    
 17 |    for(int i=0;i<2;i++)
 18 |    {
 19 |        tmp[i] = msg[i];	
 20 |    }
 21 |    for(int i=0;i<2;i++)
 22 |    {
 23 |        tmp0[i] = msg[i+2];	
 24 |    }
 25 |    
 26 |    data.myid = atoi(tmp);
 27 |    data.chatid = atoi(tmp0);	
 28 | } 
 29 |  
 30 | void ClientNetworkComInit(char ip[],u_short port)
 31 | {
 32 | 	string cMessageRecv;
 33 | 	char cMessage[512] = " ";
 34 |     int cstate = 0;
 35 |     chatData data;
 36 |     
 37 |     do
 38 |     {
 39 |     	cstate = recv(ServerCom,cMessage,512,0);
 40 | 	}while(cstate <=0);
 41 | 	cMessageRecv = cMessage;
 42 | 	cout<<"Command: "<<cMessageRecv<<"(the id can be from 10-99 only)"<<endl;
 43 | 	cstate = 0;
 44 | 	strcpy(cMessage," ");
 45 | 	
 46 | 	GetAuthenticationData(cMessage);
 47 | 	cin.ignore();
 48 | 
 49 | 	do
 50 |     {
 51 |     	cstate = send(ServerCom,cMessage,512,0);
 52 | 	}while(cstate <=0);
 53 | 	cstate = 0;
 54 | 
 55 |     DataExt(cMessage,data);
 56 |     
 57 | 	system("cls");
 58 | 	
 59 | 	cout<<"\t\tChat Client v1.0_Alpha"<<endl;
 60 | 	cout<<"Connected to: "<<ip<<"@"<<port<<" Chat ID: "<<data.myid<<" Chatting with ID: "<<data.chatid<<endl;
 61 | 	cout<<"To quit chat type EXIT"<<endl<<endl;
 62 | }
 63 | 
 64 | //call this in a thread
 65 | void ClientNetworkComSend()
 66 | {
 67 | 	char MessageSend[512] = " ";
 68 | 	int mstate = 0;
 69 | 	
 70 | 	while(strcmp(MessageSend,"EXIT"))
 71 | 	{
 72 | 	    cin.getline(MessageSend,512);
 73 | 	 do
 74 | 	 {
 75 | 		mstate = send(ServerCom,MessageSend,512,0);
 76 | 	 }while(mstate<=0);
 77 |     }
 78 |     exit(0);
 79 | }
 80 | 
 81 | // call this is separate thread
 82 | void ClientNetworkComRecv()
 83 | {
 84 | 	string cMessageRecv;
 85 | 	char cMessageRcv[512] = "";
 86 | 	int flag = 0;
 87 | 
 88 | 	while(strcmp(cMessageRcv,"EXIT"))
 89 | 	{
 90 | 		do
 91 | 		{
 92 | 			flag = recv(ServerCom,cMessageRcv,512,0);
 93 | 		}while(flag<=0);
 94 | 		
 95 | 		cMessageRecv = cMessageRcv;
 96 | 		cout<<"\t\t\t\t\t\t"<<cMessageRecv<<endl;
 97 | 	}
 98 | 	exit(0);	
 99 | }
100 | 


--------------------------------------------------------------------------------
/Client/Header Files/Function_GetAuthenticationData.hpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <string>
 3 | using namespace std;
 4 | 
 5 | void GetAuthenticationData(char msg[]);
 6 | 
 7 | void GetAuthenticationData(char msg[])
 8 | {
 9 | 	string myid;
10 | 	string chatid;
11 | 	
12 | 	cout<<"Enter your ID: ";
13 | 	cin>>myid;
14 | 	
15 | 	cout<<"Enter the ID with whom you want to chat: ";
16 | 	cin>>chatid;
17 | 		
18 | 	myid = myid + chatid;
19 | 	
20 | 	strcpy(msg,myid.c_str());  
21 | 	
22 | }
23 | 


--------------------------------------------------------------------------------
/Client/Header Files/Function_RunCounter.hpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <fstream>
 3 | using namespace std;
 4 | 
 5 | int ReadRunCounter();
 6 | void WriteRunCounter();
 7 | 
 8 | int ReadRunCounter()
 9 | {
10 | 	int counter;
11 | 	fstream file;
12 | 	file.open("../Logs/RunCounter.txt",ios::in);
13 | 	
14 | 	file>>counter;
15 | 	file.close();
16 | 	return counter;
17 | }
18 | 
19 | void WriteRunCounter()
20 | {
21 | 	int tempcount = ReadRunCounter();
22 | 	tempcount++;
23 | 	
24 | 	fstream fileWrite;
25 | 	fileWrite.open("../Logs/RunCounter.txt",ios::out);
26 | 	
27 | 	fileWrite<<tempcount;
28 | 	fileWrite.close();
29 | }
30 | 


--------------------------------------------------------------------------------
/Client/Program Codes/ChatClient.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <thread>
 3 | #include "../Header files/Class_ClientNetworkInit.hpp"
 4 | #include "../Header files/Function_ClientNetworkCom.hpp"
 5 | using namespace std;
 6 | 
 7 | main()
 8 | {
 9 | 	WriteRunCounter();             //updates the counter which counts the number of times this program is run
10 |     char ip[15];                   //variable to store the ip address
11 |     u_short port;
12 |     thread recv;
13 |     
14 |     cout<<"\t\tChat Client v1.0_Alpha <====> Client"<<endl;
15 |     
16 | 	cout<<"Enter the ip address of the server: ";
17 |     cin>>ip;
18 |     
19 |     cout<<"Enter the port of the server: ";
20 |     cin>>port;
21 |     
22 |     ClientNetworkInit cli(ip,port);         //construct the ClientNetworkInit object
23 |     cli.ConnectServer();                    //connect to the specified server
24 |     
25 |     ClientNetworkComInit(ip,port);         //setup to enter your id and the id of the user you want to chat with
26 |      
27 | 	recv = thread(ClientNetworkComRecv);    //start the reciever on  a separate thread
28 |     recv.detach();
29 |     
30 |     ClientNetworkComSend();                //run the sender in the main thread
31 | }
32 | 


--------------------------------------------------------------------------------
/Client/Program Codes/RunMeOnlyOnce.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <fstream>
 3 | using namespace std;
 4 | 
 5 | main()
 6 | {
 7 | 	fstream file;
 8 | 	file.open("../Logs/RunCounter.txt",ios::out);
 9 | 	int val = 0 ;
10 | 	
11 | 	file<<val;
12 | 	
13 | 	file.close();
14 | 	cout<<"Counter set, dont run this again"<<endl;
15 | }
16 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2017 Vedant Paranjape
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Chat-Server-and-Client
 2 | 
 3 | **INSTRUCTIONS ON FIRST RUN**
 4 | 
 5 | **Download the compiled programs and create a blank folder each in the server and client folder, move the downloaded programs to the newly created folder, i mean the server program into the the empty folder in server folder and do the same for the client program.**
 6 | 
 7 | **There is also a executable named "RunMeOnlyOnce.exe"(32 bit or 64 bit). Download the 32 bit or 64 bit version which ever suits you.
 8 | But remember that this executable must be present in subfolder under server and client folder, where the client and server programs are stored.**
 9 | 
10 | **INTRODUCTION**
11 | 
12 | Instant messengers have become a daily part of our life. We cannot imagine a life without Whatsapp, Telegram, Hike, etc. I was always curious about their working, so I spent some time and learnt about their theory of implementation. Equipped with the right knowledge I have created a very basic implementation of instant messengers.
13 | Though this is very basic, probably it might seem like app of MS-DOS era. But the functionality present in it is very similar to the current IM app, it can connect to a client through a server and send messages to other client. 
14 |  
15 | **USER’S GUIDE**
16 | 
17 | Let me first of all explain the contents of the project folder.
18 | 
19 | **Folder Client**:
20 |         
21 |          Header Files
22 |          Logs
23 |          Program Code
24 |          Release
25 |         
26 | **Folder Server**:
27 |         
28 |          Header Files
29 |          Logs
30 |          Program Code
31 |          Release
32 |         
33 | In the folder header files, all the custom made header files(.hpp) are used. In the logs folder all the program run logs are stored, so one can see the logs to find the error behind the crash of the program. In the program code folder, the final .cpp files are stored.
34 | the compiled programs are stored in folder release, both **32 bit** and **64 bit** versions are stored in it.
35 | 
36 | **Before using the program, I would like to elaborate the conditions under which it can run.**
37 | 1.	Running servers and client, all on the same machine.
38 | 2.	Running server and clients on different machines on same LAN network.
39 | 3.  The machine should be windows preferably above windows 7.
40 | 
41 | **Please note that this cannot work on PCs connected through the internet, but only on a LAN network.**
42 | For case 1: we use the local ip that is **127.0.0.1**
43 | For case 2: we use the local ip of the machine on the LAN netwotk, eg:- **192.168.0.89**, etc.
44 | 
45 | I am running the program on my local machine, so I will set my server’s ip address to 127.0.0.1, and connect the client to server at ip **127.0.0.1** . server port used in **444**, any available port can be used.
46 | Remember one thing, when one runs the program for the first time on their PC, run the program “RunMeOnlyOnce”. Don’t run it again, it is to be run only once during first use. Please use the **32 bit or 64 bit** version, whatever your PC supports.
47 | 
48 | **Server application**:
49 | Now there are 4 options. **Type 1 to start server, 2 to show information about the creator of the program that is me. 3 for help and 4 to quit the program.** 
50 | On selecting option 1, i.e. starting the server, there is a prompt to enter the server’s ip address and port, through which it can be accessed by the clients. In this case I am running it on 127.0.0.1 , as I have server and client n  the same machine.
51 | On pressing enter the server boots up, one can see the progress. Press any key to continue.
52 | Now the server is running, one can see the clients connected, their **ID’s** and the clients that have disconnected.
53 | One can see that a message is displayed when a client is connected, when the client will send the server its **ID** and the **ID** of the other client to chat with.
54 | The clients id and the id of client with which it wants to chat is shown. When a client disconnects a message is shown.
55 | To shutdown the server, type **quit** directly in the terminal, and press enter.
56 | 
57 | **Client Application**:
58 | For this to work, first of all the server must be running, start the server, following the instructions above.
59 | Enter the ip address of the chat server and the port on which it is accessible, and then press enter. After that you will get the prompt to enter your ID and the ID with whom you want to chat.
60 | Please note that the ID selected must be a number between 10-99, selecting any other number will result in undefined behaviour, and also make sure that the same ID is not used by any other client. I used 12 as my ID and I want to chat with client having ID 45.
61 | Use any number between 10-99 and the enter it and press enter.
62 | Now the client is setup and you can simply chat with another client, your messages are shown on left side and the other clients messages are shown on right side. If you want to stop the chat and exit type **EXIT**.
63 | For more detailed instructions and screenshots see the user's guide.
64 | 


--------------------------------------------------------------------------------
/Server/Header Files/Class_Logger.hpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <fstream>
 3 | #include <string.h>
 4 | #include <ctime>
 5 | #include <stdlib.h>
 6 | #include "Function_RunCounter.hpp"
 7 | using namespace std;
 8 | 
 9 | class logfile
10 | {
11 | 	private:
12 | 		time_t now;               //required variables to get the current time
13 | 		char* time_now;
14 | 		fstream WriteLog;         //declaration of fstream object to write logs to a file
15 | 	public:
16 | 	    logfile(char filename[])   //class constructors
17 | 		{
18 | 			char count[3];
19 | 			snprintf(count,sizeof(count),"%d",ReadRunCounter());    //convert runcount to char
20 | 		   	now = time(0);
21 | 		   	time_now = ctime(&now);
22 | 		   	WriteLog.open(strcat(strcat(filename,count),".txt"),ios::out);  //open file to write log
23 | 		   	WriteLog<<"Run Time : "<<time_now;  // write to file
24 | 		   	WriteLog<<endl;
25 | 	    }
26 | 	    
27 | 	    void writeLog(char event[])   //function to write event logs to the file
28 | 	    {
29 | 	    	WriteLog<<event;
30 | 	    	WriteLog<<endl;
31 | 		}
32 | 		
33 | 		~logfile()      //desctructor
34 | 		{
35 | 			WriteLog.close();
36 | 		}
37 | };
38 | 
39 | 


--------------------------------------------------------------------------------
/Server/Header Files/Class_NetworkInit.hpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <winsock2.h>
  3 | #include <windows.h>
  4 | #include <process.h>
  5 | #include <thread>
  6 | #include <fstream>
  7 | #include <string>
  8 | #include <memory>
  9 | #include "Function_NetworkCom.hpp"
 10 | using namespace std;
 11 | 
 12 | ////////////////////////////////// Variables //////   
 13 | int ClientStore = 0;                            //
 14 | char lftxtnio[40] = "../Logs/NetworkInitLogs"; // 
 15 | char lftxtni[50];                             //
 16 | logfile lfni(lftxtnio);                      //        
 17 | //////////////////////////////////////////////
 18 | 
 19 | ///////////////////////////////////////// Class NetworkInit ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 20 | class NetworkInit 
 21 | {
 22 | private:
 23 | 	//declarations of winsock library objects necessary for the sockets parts to run
 24 | 	WSAData NetworkData;
 25 |     SOCKET ListenSocket;
 26 |     SOCKADDR_IN Address;
 27 |     int AddressSize; 
 28 |     
 29 | public:
 30 | 	NetworkInit(); // default constructor
 31 | 	
 32 |     NetworkInit(char IP[],u_short PORT) // argumented constructor
 33 | 	{  
 34 | 		lfni.writeLog(IP); // write server ip to log file
 35 | //---------------------------------------Initailize Winsock API----------------------------------------------------------------------------------------------------------------------------
 36 | 		//process to start the winsock api
 37 | 		
 38 | 		strcpy(lftxtni,"Intializing Winsock API"); 
 39 | 		lfni.writeLog(lftxtni);
 40 | 		cout<<"Intializing Winsock API";                                                                           
 41 | 		for(int i=0;i<17;i++)                                                                                                                
 42 | 		{
 43 | 			cout<<".";
 44 | 			Sleep(100);
 45 | 		}
 46 | 		if(!WSAStartup(MAKEWORD(2,1),(WSAData*)&NetworkData))
 47 | 		{
 48 | 			cout<<"done"<<endl;
 49 | 			strcpy(lftxtni,"done");
 50 | 		    lfni.writeLog(lftxtni);
 51 | 		}
 52 | 		else
 53 | 		{
 54 | 			cout<<"Error starting Winsock API"<<endl;
 55 | 			strcpy(lftxtni,"Error starting Winsock API");
 56 | 		    lfni.writeLog(lftxtni);
 57 | 		    
 58 | 			cout<<"Shutting down the server"<<endl;
 59 | 			strcpy(lftxtni,"Shutting down the server");
 60 | 		    lfni.writeLog(lftxtni);
 61 | 		    lfni.~logfile();
 62 | 		    
 63 | 			closesocket(ListenSocket);
 64 | 			for(int i=0;i<10;i++)
 65 | 			{
 66 | 		    closesocket(ClientConn[i]);
 67 | 		    }
 68 | 	        WSACleanup();
 69 | 	        exit(0);
 70 | 		}
 71 | //-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 72 | 
 73 | 		Address.sin_addr.s_addr = inet_addr(IP);
 74 | 		Address.sin_port = htons(PORT);
 75 | 		Address.sin_family = AF_INET;
 76 | 		
 77 | //---------------------------------------Binding Listening Socket--------------------------------------------------------------------------------------------------------------------------		
 78 | 		//process of binding the socket
 79 | 		
 80 | 		cout<<"Binding socket";
 81 | 		strcpy(lftxtni,"Binding socket");
 82 | 		lfni.writeLog(lftxtni);
 83 | 		for(int i=0;i<26;i++)
 84 | 		{
 85 | 			cout<<".";
 86 | 			Sleep(50);
 87 | 		}
 88 | 		ListenSocket = socket(AF_INET,SOCK_STREAM,0);
 89 | 		if(!bind(ListenSocket,(SOCKADDR*)&Address,sizeof(Address)))
 90 | 		{
 91 | 			cout<<"done"<<endl;
 92 | 			strcpy(lftxtni,"done");
 93 | 		    lfni.writeLog(lftxtni);
 94 | 		}
 95 | 		else
 96 | 		{
 97 | 			cout<<"Error Binding the port"<<endl;
 98 | 			strcpy(lftxtni,"Error Binding the port");
 99 | 		    lfni.writeLog(lftxtni);
100 | 		    
101 | 			cout<<"Shutting down the server"<<endl;
102 | 			strcpy(lftxtni,"Shutting down the server");
103 | 		    lfni.writeLog(lftxtni); // write to log file
104 | 		    lfni.~logfile();
105 | 		    
106 | 		   	closesocket(ListenSocket);
107 | 		   for(int i=0;i<10;i++)
108 | 			{
109 | 		    closesocket(ClientConn[i]);
110 | 		    }
111 | 	        WSACleanup();
112 | 	        exit(0);
113 | 		}
114 | //-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
115 | 
116 | 
117 | //---------------------------------------Intialize listening socket------------------------------------------------------------------------------------------------------------------------		        
118 | 		//initialize the listening socket
119 | 		
120 | 		cout<<"Initializing listening socket";
121 | 		strcpy(lftxtni,"Initalizing listening socket");
122 | 		lfni.writeLog(lftxtni);
123 | 		
124 | 		for(int i=0;i<11;i++)
125 | 		{
126 | 			cout<<".";
127 | 			Sleep(100);
128 | 		}
129 | 		if(!listen(ListenSocket,SOMAXCONN))
130 | 		{
131 | 			cout<<"done"<<endl;
132 | 			strcpy(lftxtni,"done");
133 | 		    lfni.writeLog(lftxtni);
134 | 		}
135 | 		else
136 | 		{
137 | 			cout<<"Error in starting listening socket"<<endl;
138 |             strcpy(lftxtni,"Error in starting listening socket");
139 | 		    lfni.writeLog(lftxtni);
140 | 		    
141 | 			cout<<"Shutting down the server"<<endl;
142 | 			strcpy(lftxtni,"Shutting down the server");
143 | 		    lfni.writeLog(lftxtni);
144 | 		    lfni.~logfile();
145 | 			closesocket(ListenSocket);
146 | 		    for(int i=0;i<10;i++)
147 | 			{
148 | 		    closesocket(ClientConn[i]);
149 | 		    }
150 | 	        WSACleanup();
151 | 	        exit(0);
152 | 		}
153 | //-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------		
154 | 		
155 | 		AddressSize = sizeof(Address);
156 | 		for(int i=0;i<10;i++)
157 | 		{
158 | 			ClientConn[i] = INVALID_SOCKET;
159 | 			ClientConn[i] = socket(AF_INET,SOCK_STREAM,0);
160 | 			
161 | 			if(ClientConn[i] == INVALID_SOCKET)
162 | 		    {
163 | 		        cout<<"Error in initialising  listening socket "<<i<<endl;
164 | 				strcpy(lftxtni,"Error in initialising  listening socket ");
165 | 		        lfni.writeLog(lftxtni);	
166 | 		        lfni.~logfile();
167 | 		    }			
168 | 		    else
169 | 	     	{
170 | 		    	cout<<"Socket intialized "<<i<<endl;
171 | 		    }			
172 | 	    	Sleep(200);
173 | 		}
174 | 	    
175 | 	    system("pause");
176 | 	    system("cls");
177 | 	
178 | 	    cout<<"\t\tTCP Chat Server_______v1.0______Vedant Paranjape"<<endl<<endl; // display of server information
179 | 		cout<<"\t\t----------------------------------------"<<endl;	
180 | 		cout<<"\t\t IP Address :"<<IP<<endl;
181 | 		cout<<"\t\t Port Number:"<<PORT<<endl;
182 | 		cout<<"\t\t----------------------------------------"<<endl;
183 |     }
184 | //--------------------------------------------Intitalize all client handler sockets--------------------------------------------------------------------------------------------------------		
185 |   
186 | 	void AcceptConn()
187 | 	{
188 | 		for(;;)
189 | 		{
190 | 	  	    if((ClientConn[ClientStore] = accept(ListenSocket,(SOCKADDR*)&Address,&AddressSize)))
191 | 	  		    {
192 | 					cout<<"Client connected "<<endl;  
193 | 					send(ClientConn[ClientStore],"Enter your id and id of client with whom you want to chat",57,0); // send necessary instructions to the client
194 | 					CreateClientThread(ClientStore); // call function to create new client managing thread
195 | 					ClientStore++;		  	//increment the client counter
196 | 				}
197 |         }
198 |     }
199 |     
200 |     ~NetworkInit()
201 |     {
202 |     	// destructor -- shutdown the winsock api, delete the socket object
203 |     	for(int i=0;i<10;i++)
204 |     	{
205 |     		cout<<"Closing socket "<<i<<endl;
206 |     		closesocket(ClientConn[i]);
207 | 		}
208 | 		cout<<"Shutting down Winsock API"<<endl;
209 | 		strcpy(lftxtni,"Shutting down Winsock API");
210 | 		lfni.writeLog(lftxtni);
211 | 		lfni.~logfile();
212 | 		
213 | 		closesocket(ListenSocket);
214 | 		WSACleanup();
215 | 		exit(0);
216 | 	}
217 | };
218 | ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
219 | 


--------------------------------------------------------------------------------
/Server/Header Files/Function_Menu.hpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <process.h>
 3 | using namespace std;
 4 | 
 5 | int Menu();
 6 | int Menu()
 7 | {
 8 | 	int option; //define option variable
 9 | 	system("cls"); //clear the screen 
10 | 	cout<<"\t\tTCP Chat Server_______v1.0______Vedant Paranjape"<<endl<<endl;
11 | 	cout<<"\t\t\t<---::Menu::--->"<<endl;
12 | 	cout<<"\t\t\t _________________   "<<endl;
13 | 	cout<<"\t\t\t| 1. Start Server |  "<<endl;
14 | 	cout<<"\t\t\t| 2. About        |  "<<endl;
15 | 	cout<<"\t\t\t| 3. Help         |  "<<endl;
16 | 	cout<<"\t\t\t| 4. Quit         |  "<<endl;
17 | 	cout<<"\t\t\t|_________________|  "<<endl;
18 | 	cout<<"\t\t\tOption: ";
19 | 	cin>>option;  //take the input of option
20 | 	cin.ignore(); 
21 | 	
22 | 	return option;
23 | }
24 | 


--------------------------------------------------------------------------------
/Server/Header Files/Function_MessageParser.hpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <string>
 3 | #include <stdlib.h>
 4 | using namespace std;
 5 | 
 6 | struct AuthDataParsed
 7 | {
 8 | 	int ID;
 9 | 	int sID;
10 | }; 
11 | 
12 | void AuthDataParser(char RawMessage[],AuthDataParsed& msg);
13 | 
14 | void AuthDataParser(char RawMessage[],AuthDataParsed& msg)
15 | {
16 | 	char id[3] = "";
17 | 	char sid[3] = "";
18 | 	
19 | 	for(int i=0;i<2;i++)
20 | 	{
21 | 		id[i] = RawMessage[i];
22 | 	}
23 | 	
24 | 	for(int i=0;i<2;i++)
25 | 	{
26 | 		sid[i] = RawMessage[i+2];
27 | 	}
28 | 	
29 | 	msg.ID = atoi(id);
30 | 	msg.sID = atoi(sid);
31 | 	
32 | }
33 | 
34 | 
35 | 
36 | 
37 | 


--------------------------------------------------------------------------------
/Server/Header Files/Function_NetworkCom.hpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <string>
 3 | #include <stdlib.h>
 4 | #include <thread>
 5 | #include <winsock2.h>
 6 | #include <windows.h>
 7 | #include "Library_IDManager.hpp"
 8 | #include "Function_MessageParser.hpp"
 9 | #include "Class_Logger.hpp"
10 | using namespace std;
11 | 
12 | ////////// variables ////////////                      
13 | thread HandleClient[10]; 
14 | SOCKET ClientConn[10];
15 | char lftxt[20] = "../Logs/ChatLogs";
16 | logfile lf(lftxt);
17 | /////////////////////////////
18 | 
19 | ////////////////////////////////////////////////// Function NetworkCom //////////////////////////////////////////////////////////////////////////////////////////////////
20 | void NetworkCom(int loc);   
21 | 
22 | void NetworkCom(int loc)
23 | {
24 | 	int flag = 0;
25 |     char datatemp[512] = " ";
26 |     char msgtemp[512] = " ";
27 |     AuthDataParsed AuthData;
28 |     
29 | 	do
30 | 	{
31 | 		flag = recv(ClientConn[loc],datatemp,512,0);
32 | 	}while(flag<=0);
33 | 	flag = 0;
34 | 	
35 | 	AuthDataParser(datatemp,AuthData);
36 | 	IDStore(AuthData.ID,loc);
37 | 	
38 | 	cout<<">>"<<"ID # "<<AuthData.ID<<" sID # "<<AuthData.sID<<endl;
39 | 	
40 | 	while(ClientConn[loc] != INVALID_SOCKET)
41 | 	{  
42 | 	    flag = recv(ClientConn[loc],msgtemp,512,0);
43 | 	    if(flag > 0)
44 | 	    {
45 | 		   lf.writeLog(datatemp);
46 | 	       lf.writeLog(msgtemp);
47 | 	    }
48 | 	    flag = 0;
49 | 	    
50 | 		flag = send(ClientConn[ReturnLocation(AuthData.sID)],msgtemp,512,0);
51 | 		if(flag > 0)
52 | 		{
53 | 		   lf.writeLog(datatemp);
54 | 	       lf.writeLog(msgtemp);
55 | 	    }
56 | 	    flag = 0;
57 | 	    
58 | 		if(!strcmp(msgtemp,"EXIT"))
59 | 		{
60 | 			closesocket(ClientConn[loc]);
61 | 			cout<<"Client "<<AuthData.ID<<" has disconnected"<<endl;
62 | 			cout<<"Client "<<AuthData.sID<<" has disconnected"<<endl;
63 | 			break;
64 | 		}
65 | 	}
66 |     
67 | }
68 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
69 | 
70 | /////////////////////////////////////////////////// Function CreateClientThread ///////////////////////////////////////////////////////////////////////////////////////
71 | void CreateClientThread(int location);
72 | 
73 | void CreateClientThread(int location)
74 | {
75 |    	HandleClient[location] = thread(NetworkCom,location);
76 |    	HandleClient[location].detach();
77 | }
78 | ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
79 | 
80 | 
81 | 


--------------------------------------------------------------------------------
/Server/Header Files/Function_RunCounter.hpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <fstream>
 3 | using namespace std;
 4 | 
 5 | int ReadRunCounter();
 6 | void WriteRunCounter();
 7 | 
 8 | int ReadRunCounter()
 9 | {
10 | 	int counter;
11 | 	fstream file;
12 | 	file.open("../Logs/RunCounter.txt",ios::in);
13 | 
14 | 	file>>counter;
15 | 	file.close();
16 | 	return counter;
17 | }
18 | 
19 | void WriteRunCounter()
20 | {
21 | 	int tempcount = ReadRunCounter();
22 | 	tempcount++;
23 | 	
24 | 	fstream fileWrite;
25 | 	fileWrite.open("../Logs/RunCounter.txt",ios::out);
26 | 	
27 | 	fileWrite<<tempcount;
28 | 	
29 | 	fileWrite.close();
30 | }
31 | 
32 | 


--------------------------------------------------------------------------------
/Server/Header Files/Library_IDManager.hpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | //////////////////////
 5 | int ID_Array[10];  //
 6 | ////////////////////
 7 | 
 8 | /////////////////////////////////////////
 9 | void IDStore(int ID,int ArrayLoc);    //
10 | void IDStore(int ID,int ArrayLoc)    //
11 | {                                   //
12 | 	ID_Array[ArrayLoc] = ID;       // 
13 | }                                 //
14 | ///////////////////////////////////
15 | 
16 | ///////////////////////////////////////
17 | int IDReturn(int ArrayLoc);         //
18 | int IDReturn(int ArrayLoc)         //
19 | {                                 //
20 | 	return ID_Array[ArrayLoc];   //
21 | }                               //
22 | /////////////////////////////////
23 | 
24 | //////////////////////////////////////////////
25 | int ReturnLocation(int ID);                //
26 | int ReturnLocation(int ID)                //
27 | {                                        //
28 | 	int lo = 0;                         //
29 | 	                                   //
30 | 	for(int i=0;i<10;i++)             //
31 | 	{                                //
32 | 		if(ID_Array[i] == ID)       //
33 | 		{                          //
34 | 			lo = i;               //
35 | 		}                        //
36 | 		                        //
37 | 	}                          //
38 | 	return lo;                //	
39 | }                            //
40 | //////////////////////////////
41 | 


--------------------------------------------------------------------------------
/Server/Program Codes/ChatServer.cpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <process.h>
  3 | #include <conio.h>
  4 | #include "../Header Files/Function_Menu.hpp"
  5 | #include "../Header Files/Class_NetworkInit.hpp"
  6 | using namespace std;
  7 | 
  8 | void CommandHandle(NetworkInit& a);
  9 | 
 10 | void CommandHandle(NetworkInit& a)
 11 | {
 12 | 	char command[5];
 13 | 	
 14 | 	cin.ignore();
 15 | 	
 16 | 	while(1)
 17 | 	{
 18 | 		if(kbhit())
 19 | 		{
 20 | 			cin.getline(command,20);
 21 | 		}
 22 | 		
 23 | 		if(!strcmp(command,"quit"))
 24 | 		{
 25 | 			a.~NetworkInit();
 26 | 			break;
 27 | 		}
 28 | 	}
 29 | }
 30 | 
 31 | void RunServer();
 32 | 
 33 | void RunServer()
 34 | {
 35 | 	WriteRunCounter();
 36 | 	char IP[16];
 37 |     u_short PORT;
 38 |     thread CommandHandler;
 39 | 
 40 |     system("cls");
 41 | 	cout<<"\n\n\t\tEnter the server ip address: ";
 42 |   	cin>>IP;
 43 |     cout<<endl;
 44 |     			
 45 |     cout<<"\t\tEnter the server port: ";
 46 |     cin>>PORT;
 47 |     cout<<endl;
 48 |     			
 49 |     			
 50 |     NetworkInit com(IP,PORT);
 51 |     
 52 |     CommandHandler = thread(CommandHandle,ref(com));
 53 |     com.AcceptConn();
 54 | }
 55 | 
 56 | void about();
 57 | 
 58 | void about()
 59 | {
 60 | 	system("cls");
 61 | 	cout<<"Made By: Vedant Paranjape"<<endl;
 62 | 	cout<<"TCP Chat Server"<<endl;
 63 | 	cout<<"Version: 1.0(alpha)"<<endl;
 64 | 	cout<<"Made for class XII Computer Science project"<<endl;
 65 | 	system("pause");
 66 | }
 67 | 
 68 | void help();
 69 | 
 70 | void help()
 71 | {
 72 | 	system("cls");
 73 | 	cout<<"Press 1 to start server"<<endl;
 74 | 	cout<<"Then enter the ip address on which the server should be accessible...it should be your PC's local ip or 127.0.0.1 for localhost"<<endl;
 75 | 	cout<<"After that enter the port on which it should work"<<endl;
 76 | 	cout<<"Now the Server is setup and now clients can connect"<<endl;
 77 | 	cout<<"Check the documentation for more details..."<<endl;
 78 | 	system("pause");
 79 | }
 80 | main()
 81 | {
 82 | 	do
 83 | 	{
 84 | 		switch(Menu())
 85 | 		{
 86 | 			case 1:
 87 | 				RunServer();
 88 | 				break;
 89 | 				
 90 | 				case 2:
 91 | 					about();
 92 | 					break;
 93 | 					
 94 | 					case 3:
 95 | 						help();
 96 | 						break;
 97 | 						
 98 | 						case 4:
 99 | 							exit(0);
100 | 							break;
101 | 		}
102 | 	}while(1);
103 | }
104 | 


--------------------------------------------------------------------------------
/Server/Program Codes/RunMeOnlyOnce.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <fstream>
 3 | using namespace std;
 4 | 
 5 | main()
 6 | {
 7 | 	fstream file;
 8 | 	file.open("../Logs/RunCounter.txt",ios::out);
 9 | 	int val = 0 ;
10 | 	
11 | 	file<<val;
12 | 	
13 | 	file.close();
14 |         cout << " donot run this again";
15 | }
16 | 


--------------------------------------------------------------------------------
/User Guide.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/VedantParanjape/Chat-Server-and-Client/3f2be70386707e99073ae9c18d2f8b5d3b58a08e/User Guide.pdf


--------------------------------------------------------------------------------