Server Fork

#include<sys/types.h>
#include<sys/socket.h>
#include<stdio.h>
#include<netinet/in.h>
#include<netinet/ip.h>
#include<string.h>
#include<fcntl.h>
#include<unistd.h>
#define MAX 512


void deservire_pb3(int c){
        printf("\n Problema 3. \n");
        char buffer[MAX];
        char buffer2[MAX];
        int i;
        recv(c,buffer, sizeof(buffer), MSG_WAITALL);
        for(int i=0;i<strlen(buffer);i++)
                buffer2[i]= buffer[strlen(buffer)-1-i];
        buffer2[strlen(buffer)]='\0';
        send(c,buffer2, sizeof(buffer2),0);
        close(c);

}

void deservire_pb4(int c){
        printf("\n Problema4. \n");
        char buffer[MAX];
        char buffer2[MAX];
        char bufferFinal[MAX];
        int i=0;
        int j=0;
        int k=0;
        recv(c, buffer, sizeof(buffer), MSG_WAITALL);
        recv(c, buffer2, sizeof(buffer2), MSG_WAITALL);
        int length1=strlen(buffer);
        int length2=strlen(buffer2);

        while(i<length1 && j<length2){
                if(buffer[i]< buffer2[j]){
                        bufferFinal[k]=buffer[i];
                        i=i+1;
                        k=k+1;
                }
                else{
                        bufferFinal[k]=buffer2[j];
 						j=j+1;
                        k=k+1;
                }
        }
        //printf("1. %s", bufferFinal);
        bufferFinal[k]='\0';
        while(i<length1 && j==length2){
                bufferFinal[k]=buffer[i];
                i=i+1;
                k=k+1;
        }
        //printf("2. %s", bufferFinal);
        while(j<length2 && i== length2){
                bufferFinal[k] =  buffer2[j];
                j=j+1;
                k=k+1;
        }
        //printf("3. %s", bufferFinal);

        bufferFinal[k]='\0';
        send(c, bufferFinal, sizeof(bufferFinal), 0);
        close(c);
}
// ================ PROBLEMA 5 =====================

void deservire_pb5(int c){
        printf("\n Problema 5.\n ");
        uint16_t buffer[MAX];
        uint16_t i=0;
        uint16_t numar;
        recv(c,&numar, sizeof(numar), MSG_WAITALL);
        numar= ntohs(numar);
        uint16_t copie = numar;
        while(numar>0){
                if(copie%numar == 0){
                        buffer[i]=numar;
                        i++;
                }
                numar--;
        }

        i=htons(i);
        send(c, &i, sizeof(i),0);
        send(c,buffer, sizeof(buffer), 0);
        close(c);
}


// =========================== Problema 6 =========================
     uint16_t buffer[MAX];
        uint16_t i=0;
        uint16_t numar;
        recv(c,&numar, sizeof(numar), MSG_WAITALL);
        numar= ntohs(numar);
        uint16_t copie = numar;
        while(numar>0){
                if(copie%numar == 0){
                        buffer[i]=numar;
                        i++;
                }
                numar--;
        }

        i=htons(i);
        send(c, &i, sizeof(i),0);
        send(c,buffer, sizeof(buffer), 0);
        close(c);
}


// =========================== Problema 6 =========================
void deservire_pb6(int c){
        printf("\n Problema 6. \n");
        char ch[2];
        char buffer[MAX];
        uint16_t integers[MAX];

        recv(c, ch, sizeof(ch), MSG_WAITALL);
        recv(c,buffer, sizeof(buffer), MSG_WAITALL);

        uint16_t i=0;
        int j=0;
        for(j=0;j<strlen(buffer);j++)
                if(buffer[j] == ch[0]){
                        integers[i]=j;
                        i++;
                }
        i= htons(i);
        send(c, &i, sizeof(i), 0);
        send(c, integers, sizeof(integers), 0);
        close(0);
}
// ======================== Problema 7 =======================
void deservire_pb7(int c){
        uint16_t i,l;
        char s[MAX];
        char res[MAX];


        recv(c, &i, sizeof(i), MSG_WAITALL);
        recv(c, &l, sizeof(l), MSG_WAITALL);
        i=ntohs(i);
        l=ntohs(l);

        recv(c, s, sizeof(s), MSG_WAITALL);

        int j=0;
        int k=0;
        for(j=i; j<l+i;j++){
                res[k]=s[j];
                k++;
        }
        res[k]='\0';
        send(c, res, sizeof(res), 0);
        close(0);
}
int  main(){
        int s;
        struct sockaddr_in server, client;
        int c,l;

        s = socket(AF_INET, SOCK_STREAM,0);
        if(s<=0){
                printf("Eroare la crearea socketului server.\n");
                return 1;
        }

        memset(&server, 0, sizeof(server));
        server.sin_port=htons(1359);
        server.sin_family=AF_INET;
        server.sin_addr.s_addr=INADDR_ANY;

        if(bind(s,(struct sockaddr *) &server, sizeof(server))<0){
                printf("Eroare la bind.\n");
                return 1;
        }
        listen (s,5);

        l=sizeof(client);
        memset(&client,0,sizeof(client));
		 while(1){
                char buffer[MAX];

                uint16_t nrProblema;
                c= accept(s, (struct sockaddr * ) &client, &l );
                printf("S-a conectat un client. \n");
                recv(c, &nrProblema, sizeof(nrProblema), MSG_WAITALL);
                nrProblema= ntohs(nrProblema);
                if(fork() == 0){
                        if(nrProblema==3){
                                deservire_pb3(c);
                                return 0;
                        }
                        if(nrProblema==4){
                                deservire_pb4(c);
                                return 0;
                        }
                        if(nrProblema == 5){

                                deservire_pb5(c);
                                return 0;
                        }
                        if(nrProblema == 6){
                                deservire_pb6(c);
                                return 0;
                        }
						   if(nrProblema == 7){
                                deservire_pb7(c);
                                return 0;
                        }
                }
        }
        close(s);
}