concurrent_thread.c.txt

tcpip programing in unix using sockets. networking program

///* ---------------Homework2 Problem-2---------------------------------- */
/* Submitted by  :Hetalben Patel (SJSU ID: 005828017)---------------------*/
/* Program Title :concurrentthread.c (UDP)- -------------------------------------*/
/* Problem-1     :Write the multithread concurrent server program that receives request from  
                  client and send requesed byte to client. */


#include "server.h"

pthread_mutex_t mlock;
pthread_mutex_t mlock = PTHREAD_MUTEX_INITIALIZER;

typedef struct thread {
   int sockfd;
   int ntowrite;
   struct sockaddr_in address;
} thread_t;


int main(int argc, char **argv)
{
        int sockfd,  read_data;
        pthread_t tid;
        socklen_t clilen, len;
        struct sockaddr_in cliaddr, servaddr;
        thread_t *thread_arg;
        char mesg[MAXLINE] ;
        void* doit(void *);
        void sig_int(int);

        if (argc != 1) {
                printf("Usage: ./a.out  <No of children to fork> \n ");
                exit(0);
        }


        /* Creating a Socket;*/
        if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0){
                perror("socket");
                exit(0);
        }

        /* Initializing the sockaddr_in servaddr structure to zero*/
        bzero(&servaddr, sizeof(servaddr));
        servaddr.sin_family = AF_INET;
        servaddr.sin_port = htons(SERV_PORT);
        servaddr.sin_addr.s_addr = htonl(INADDR_ANY);

        if (bind(sockfd, (struct sockaddr *) &servaddr, sizeof(servaddr)) < 0){
                perror("bind");
                exit(0);
        }


        signal(SIGINT, sig_int);

        for(;;){

                len = clilen;
                if((read_data = recvfrom(sockfd, mesg, MAXLINE, 0,(struct sockaddr *) &cliaddr, &len)) < 0){
                        perror("Receive error ");
                        close(sockfd);
                        exit(0);
                }
                thread_arg = malloc(sizeof(*thread_arg));
                thread_arg->sockfd = sockfd;
                thread_arg->ntowrite = atol(mesg);
                thread_arg->address = cliaddr;
                pthread_create(&tid, NULL, &doit, (void *) thread_arg);
        }

}



void* doit(void *arg)
{
        int towrite, end_data;
        thread_t *func_arg = (thread_t *)arg;
        int ntowrite = func_arg->ntowrite;
        int sockfd = func_arg->sockfd;
        struct sockaddr_in cliaddr= func_arg->address;
        int n, n1, n2, send_data;
        char buf[SENDBUF];


        memset(buf, 1, sizeof(buf));
        if ((n = pthread_detach(pthread_self())) < 0){
                        n = errno;
                        perror("pthread detach error \n");
                        return(NULL);
        }

        if(ntowrite <= 0){
                printf(" Bytes to be written Invalid \n");
        }


        while( ntowrite > 0){
                towrite = ( ntowrite < sizeof(buf)) ? ntowrite : sizeof(buf);
                printf("Value being written into the buffer %d\n ", towrite);
                if( (n1 = pthread_mutex_lock(&mlock))< 0){
                        errno = n1;
                        perror("Thread lock error");
                        return(NULL);
                }

                if ((send_data = sendto(sockfd, buf, towrite, 0, (struct sockaddr *) &cliaddr,
                                        sizeof(cliaddr))) < 0){
                        perror("write error");
                        close(sockfd);
                        exit(0);
                }
                if ((n2 =  pthread_mutex_unlock(&mlock)) <  0){
                        errno = n2;
                        perror("Thread unlock error");
                        return(NULL);
                }

                ntowrite -= towrite;
                printf("Value of ntowrite is : %d  \n", ntowrite);
        }
        if (end_data >= 1000000){
                char buf_1[SENDBUF];
                memset(buf_1, 0x0, sizeof(buf_1));
                sleep(1);
                if((send_data = sendto(sockfd, buf_1, sizeof(buf_1), 0, (struct sockaddr *)&cliaddr, sizeof(cliaddr))) < 0){
                        perror("write error in END BYTE");
                        close(sockfd);
                        exit(0);
                }
        }

        fflush(NULL);
        free(func_arg);
        return(NULL);
}

void sig_int(int signo)
{
        exit(0);
}