i Have used thread concept to handle multiple connections. But It's not working for multiple clients. please help me

        // Server code
        #undef UNICODE

        #define WIN32_LEAN_AND_MEAN
        #define _WIN32_WINNT 0x501
        #include <windows.h>
        #include <winsock2.h>
        #include <ws2tcpip.h>
        #include <stdlib.h>
        #include <stdio.h>
        #include <pthread.h>
        // Need to link with Ws2_32.lib
        #pragma comment (lib, "Ws2_32.lib")
        // #pragma comment (lib, "Mswsock.lib")

        #define DEFAULT_BUFLEN 512
        #define DEFAULT_PORT "27015"
        void *connection_handler(void *);
        int __cdecl main(void) 
        {
            WSADATA wsaData;
            int iResult, *new_sock;

            SOCKET ListenSocket = INVALID_SOCKET;
            SOCKET ClientSocket = INVALID_SOCKET;

            struct addrinfo *result = NULL;
            struct addrinfo hints;

            int iSendResult;
            char recvbuf[DEFAULT_BUFLEN];
            int recvbuflen = DEFAULT_BUFLEN;

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

            ZeroMemory(&hints, sizeof(hints));
            hints.ai_family = AF_INET;
            hints.ai_socktype = SOCK_STREAM;
            hints.ai_protocol = IPPROTO_TCP;
            hints.ai_flags = AI_PASSIVE;

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

            // Create a SOCKET for connecting to server
            ListenSocket = socket(result->ai_family, result->ai_socktype, result->ai_protocol);
            if (ListenSocket == INVALID_SOCKET) {
                printf("socket failed with error: %ld\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 with error: %d\n", WSAGetLastError());
                freeaddrinfo(result);
                closesocket(ListenSocket);
                WSACleanup();
                return 1;
            }

            //freeaddrinfo(result);

                printf("starting\n");
                iResult = listen(ListenSocket, SOMAXCONN);
                if (iResult == SOCKET_ERROR) {
                    printf("listen failed with error: %d\n", WSAGetLastError());
                    closesocket(ListenSocket);
                    WSACleanup();
                    return 1;
                }

                // Accept a client socket
               while( ClientSocket = accept(ListenSocket, NULL, NULL)) {
                if (ClientSocket == INVALID_SOCKET) {
                    printf("accept failed with error: %d\n", WSAGetLastError());
                    closesocket(ListenSocket);
                    WSACleanup();
                    return 1;
                }

                puts("Connection accepted");

                pthread_t sniffer_thread;
                new_sock = (int*)malloc(1);
                *new_sock = ClientSocket;

                if( pthread_create( &sniffer_thread , NULL ,  connection_handler , (void*) new_sock) < 0)
                {
                    perror("could not create thread");
                    return 1;
                }

                //Now join the thread , so that we dont terminate before the thread
                //pthread_join( sniffer_thread , NULL);
                puts("Handler assigned");
            }

            if (ClientSocket < 0)
            {
                perror("accept failed");
                return 1;
            }

            return 0;
        }
        void *connection_handler(void *socket_desc)
        {
            //Get the socket descriptor
            int sock = *(int*)socket_desc;
            int read_size;
            const char *message ;
            char client_message[2000];

            //Send some messages to the client
            message = "Greetings! I am your connection handler\n";
            send(sock , message , strlen(message),0);

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

            //Receive a message from client
            while( (read_size = recv(sock , client_message , 2000 , 0)) > 0 )
            {
                //Send the message back to client
                send(sock , client_message , strlen(client_message),0);
            }

            if(read_size == 0)
            {
                puts("Client disconnected");
                fflush(stdout);
            }
            else if(read_size == -1)
            {
                perror("recv failed");
            }

            //Free the socket pointer
            free(socket_desc);

            return 0;
        }

    =======================================================================================================
        // Client code

        #define WIN32_LEAN_AND_MEAN
        #define _WIN32_WINNT 0x501
        #include <windows.h>
        #include <winsock2.h>
        #include <ws2tcpip.h>
        #include <stdlib.h>
        #include <stdio.h>
        #include <string>
        #include <iostream>
        using namespace std;
        // Need to link with Ws2_32.lib, Mswsock.lib, and Advapi32.lib
        #pragma comment (lib, "Ws2_32.lib")
        #pragma comment (lib, "Mswsock.lib")
        #pragma comment (lib, "AdvApi32.lib")

        #define DEFAULT_BUFLEN 512
        #define DEFAULT_PORT "27015"

        int __cdecl main(int argc, char **argv) 
        {
            WSADATA wsaData;
            SOCKET ConnectSocket = INVALID_SOCKET;
            struct addrinfo *result = NULL,
                            *ptr = NULL,
                            hints;
            //const char *sendbuf = "this is a test";
            char recvbuf[DEFAULT_BUFLEN];
            int iResult;
            int recvbuflen = DEFAULT_BUFLEN;

            // Validate the parameters
            if (argc != 2) {
                printf("usage: %s server-name\n", argv[0]);
                return 1;
            }

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

            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(argv[1], DEFAULT_PORT, &hints, &result);
            if ( iResult != 0 ) {
                printf("getaddrinfo failed with error: %d\n", iResult);
                WSACleanup();
                return 1;
            }

            // Attempt to connect to an address until one succeeds
            for(ptr=result; ptr != NULL ;ptr=ptr->ai_next) {

                // Create a SOCKET for connecting to server
                ConnectSocket = socket(ptr->ai_family, ptr->ai_socktype, 
                    ptr->ai_protocol);
                if (ConnectSocket == INVALID_SOCKET) {
                    printf("socket failed with error: %ld\n", WSAGetLastError());
                    WSACleanup();
                    return 1;
                }

                // Connect to server.
                iResult = connect( ConnectSocket, ptr->ai_addr, (int)ptr->ai_addrlen);
                if (iResult == SOCKET_ERROR) {
                    closesocket(ConnectSocket);
                    ConnectSocket = INVALID_SOCKET;
                    continue;
                }
                break;
            }

            while(true){
                printf("Enter message : \n");
                string temp = "";
                cin >> temp;
                strcpy(recvbuf, temp.c_str());

                //Send some data
                if( send(ConnectSocket , recvbuf , strlen(recvbuf) , 0) < 0)
                {
                    printf("Send failed");
                    return 1;
                }
               // printf("client reply :%s ", recvbuf);

                //Receive a reply from the server
                if( recv(ConnectSocket , recvbuf , 2000 , 0) < 0)
                {
                    printf("recv failed");
                    break;
                }

                printf("Server reply :%s \n", recvbuf);

            } 

            // cleanup
            closesocket(ConnectSocket);
            WSACleanup();

            return 0;
        }
Re: Handling multiple clients 80 80

First, asking us to analyze over 250 lines of code is just disrespectful. Please indicate what errors you are getting, and where they are coming from at the least.

Re: Handling multiple clients 80 80

Sorry I thought I have listed the problems.
1) My problem was that when I connect to client and keep on messaging and suppose a new client connects and exits. I am getting connection reset error from server.
2) suppose I want to send message from one client to another client how do I handle with threads. I need a model. I am already handling multiple Clients.
Thanks in advance :)

Be a part of the DaniWeb community

We're a friendly, industry-focused community of 1.19 million developers, IT pros, digital marketers, and technology enthusiasts learning and sharing knowledge.