problem closing socket

I can't close the socket of my server! It does everything as it should but this


I have this code for my client:

Code:

---

#include <sys/types.h>  /* required include files */
#include <sys/socket.h>
#include <netinet/in.h>  /* bind in internet domain */
#include <netdb.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>


#define SOCKET_ERROR        -1
#define STRGLEN 100  /* message string length */
const int APORT = 1234;  /* chosen port number */



// FUNCTIONS


/*        Function send_file
                send the content of one file to the server        */
void send_file(int s, char* namefile){
        FILE* p;
        int i;
        char ch;
        char length[100],text[1000];

        p=fopen(namefile,"r");
        i=0;
        ch = getc(p);  /* read 1st character in file */
        while( ch != EOF){ /* keep going until end of file */
                text[i]=ch;
                ch = getc(p);  /* read next character in in-file */
                i++;
        }
        fclose(p);
        text[i]='\0';
        sprintf(length, "%d", i);
        send(s, length, strlen(length), 0);
        send(s, text, i, 0);
}

 
/*        Function main        */
main(int argc, char *argv[]){  /* argv[1] is server hostname argv[2] is port */
        char string[STRGLEN];  /* message string */
        register int s;  /* created socket (index to unix descriptor table) */
        struct hostent *hp;  /* pointer to host structure */
        struct sockaddr_in sin;  /* socket structure */
        float number;
        int i;  /* loop counter */
        int selection;        /* menu choice */
        int num, server_port;
        char c;
       
       
        /*  look up the network address of server hostname */
        hp = gethostbyname(argv[1]);
        if( hp==0 ){ 
                fprintf(stderr, "unknown host %s\n", argv[1]);
                exit(1);
        }
       
        /* create socket in the Internet domain(AF_INET) that will
        be connection oriented SOCK_STREAM. (connectionless is
        SOCK_DGRAM) 3rd argument indicated default TCP/IP protocol */
        if( (s = socket(AF_INET, SOCK_STREAM, 0)) <0 ){
                perror("client: socket");
                exit(1);
        }
       
        /* Create the address we will be connecting to We use port
        1234 but put it into network byte order.
        Also we use bcopy to copy the network number */
        sin.sin_family = AF_INET;

        server_port=atoi(argv[2]);
        sin.sin_port = htons(server_port);
        bcopy(hp->h_addr, &sin.sin_addr, hp->h_length);
       
        /* Try to connect to the address.
        For this to succeed, the server must already have bound
        this address, and must have issued a listen() request. */
        if(connect(s, (struct sockaddr *)&sin, sizeof(sin)) < 0){
                perror("client: connect");
                exit(1);
        }
       
        //Save a file
                                printf("Enter file's name:\t");
                                scanf("%[^\n]", string);
                                printf("%s", string);
                                send(s, string, STRGLEN, 0);
                                //send_file(s, string);
                               
 

  /* close connection, since were finished on both sides */

  close(s);

}

---

which works just fine


and this for my server:

Code:

---

#include <sys/types.h>  /* required include files */
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <unistd.h>


#define SOCKET_ERROR        -1
#define STRGLEN 100  /* message string length */
const int APORT = 1235;  /* port number */




//DATA STRUCTURES

typedef struct{
        char nameUser[100];
        int numUser;
}user;


typedef struct userStruct{
        user u;
        struct userStruct* next;
}userknot;

typedef struct{
        userknot* start;
        userknot* end;
        int totalUsers;
}userslist;

typedef struct{
        char nameFile[100];
        int numFile;
        int numUser;
        //time_t t;
}textFile;

typedef struct fileStruct{
        textFile tf;
        struct fileStruct* next;
}fileknot;

typedef struct{
        fileknot* start;
        fileknot* end;
        int totalFiles;
}fileslist;



//FUNCTIONS


/*  Function create_users_list
                This function initializes the users list */
userslist* create_users_list(userslist* list){
        if(list==NULL)return NULL;
        list->start=list->end=NULL;
        list->totalUsers=0;
        return list;
}


/*  Function create_files_list
                This function initializes the files list */
fileslist* create_files_list(fileslist* list){
        if(list==NULL)return NULL;
        list->start=list->end=NULL;
        list->totalFiles=0;
        return list;
}


/*        Function add_file
                add a new file */
void add_file(char* name_file, int nFile, int nUser, fileslist* flist){
        fileknot* fk;
        fk=(fileknot*)malloc(sizeof(fileknot));
        if(fk==NULL){
                printf("Can't add a new file");
                exit(-1);
        }
        else{
                strcpy(fk->tf.nameFile, name_file);
                fk->tf.numFile=nFile;
                fk->tf.numUser=nUser;
                if(flist->totalFiles==0){
                        flist->end=flist->start=fk;
                }
                else{
                        flist->end->next=fk;
                        flist->end=fk;
                }
                flist->end->next=NULL;
                flist->totalFiles++;
        }
}


/*        Function get_savings
                This function gets back the data that has been saved previously */
void get_savings(FILE* p, userslist* ul, fileslist* fl)
{
        userknot* uk;
        fileknot* fk;
        int i, length;
        char string[100];

        fgets(string, STRGLEN, p);
        sscanf(string, "%d", &(ul->totalUsers));        //read the total number of users
        uk=(userknot*)malloc(sizeof(userknot));
        if(uk==NULL){
                printf("Couldn't allocate a userknot\n");
                exit(-1);
        }
        if(ul->totalUsers!=0){
                ul->start=uk;
                fgets(string, STRGLEN, p);        //read the name of the user
                sscanf(string, "%[^\n]", uk->u.nameUser);
                length=strlen(string);
                uk->u.nameUser[length-1]='\0';
                fgets(string, STRGLEN, p);        //read the number of the user
                sscanf(string, "%d", &(uk->u.numUser));
                i=1;
                while(i<ul->totalUsers){
                        uk->next=(userknot*)malloc(sizeof(userknot));
                        uk=uk->next;
                        fgets(string, STRGLEN, p);        //read the name of the user
                        sscanf(string, "%[^\n]", uk->u.nameUser);
                        length=strlen(string);
                        uk->u.nameUser[length-1]='\0';
                        fgets(string, STRGLEN, p);        //read the number of the user
                        sscanf(string, "%d", &(uk->u.numUser));
                        i++;
                }
                uk->next=NULL;
                ul->end=uk;
        }

        fgets(string, STRGLEN, p);
        sscanf(string, "%d", &(fl->totalFiles));        //read the total number of users
        fk=(fileknot*)malloc(sizeof(fileknot));
        if(fk==NULL){
                printf("Couldn't allocate a userknot\n");
                exit(-1);
        }
        if(fl->totalFiles!=0){
                fl->start=fk;
                fgets(string, STRGLEN, p);        //read the name of the file
                sscanf(string, "%[^\n]", fk->tf.nameFile);
                length=strlen(string);
                fk->tf.nameFile[length-1]='\0';
                fgets(string, STRGLEN, p);        //read the number of the file
                sscanf(string, "%d", &(fk->tf.numFile));
                fgets(string, STRGLEN, p);        //read the number of the user
                sscanf(string, "%d", &(fk->tf.numUser));
                i=1;
                while(i<fl->totalFiles){
                        fk->next=(fileknot*)malloc(sizeof(fileknot));
                        fk=fk->next;
                        fgets(string, STRGLEN, p);        //read the name of the file
                        sscanf(string, "%[^\n]", fk->tf.nameFile);
                        length=strlen(string);
                        fk->tf.nameFile[length-1]='\0';
                        fgets(string, STRGLEN, p);        //read the number of the file
                        sscanf(string, "%d", &(fk->tf.numFile));
                        fgets(string, STRGLEN, p);        //read the number of the user
                        sscanf(string, "%d", &(fk->tf.numUser));
                        i++;
                }
                fk->next=NULL;
                fl->end=fk;
        }
}


/*        Function print_all_files
                this function prints the list of all the files of one user  */
void print_all_files(int num_user, fileslist* fl){
        fileknot* fk;
        char string[STRGLEN];
        int num, n=0, go_on, nSentFiles=0;
        fk=(fileknot*)malloc(sizeof(fileknot));
        num=fl->totalFiles;
        sprintf(string, "%d", num);
        printf("nb of files: %d\n", num);        /* send the total number of files */
        if(num!=0){
                fk=fl->start;
                while(n<num){
                        if(fk->tf.numUser==num_user){
                                strcpy(string, fk->tf.nameFile);
                                printf("%s\n", string);
                                nSentFiles++;
                        }
                        fk=fk->next;
                        n++;
                }
                printf("nSentfiles: %d\n", nSentFiles);
        }
}


/*        Function save_file       
                receive the content of one file from the client, encode it and save
                it on the server        */
void save_file(int s, char* namefile){
        int max, total = 0, i;
        const int bsize = 1024;
        char c, length[bsize+1], buffer[bsize+1],text[bsize+1];
        int read = bsize;
        FILE* p;
 
        length[0]=0;        //initialize length
        recv(s, length, bsize, 0);
        sscanf(length, "%d", &max);
        text[0] = 0; // initialize for strcat()
        while(read == bsize){
                read = recv(s, buffer, bsize, 0);
                if(read < 0){
                        printf("Server: Error while receiving file\n"); // error, bail out
                        exit(-1);
                }
                total += read;
                if(total > max){
                        printf("Error: overflow\n"); // overflowv
                        exit(-1);
                }
                buffer[read] = 0;
                strcat(text, buffer);        /* in case the string is too long and need more than one read */
    }
        total=strlen(text);
        printf("debug: %s\n", text);
        i=0;
        p=fopen(namefile, "w");
        while(i<total-1){
                c=(char)(text[i]+5);
                putc(c, p);
                i++;
        }
        fclose(p);
}


/*        Function main */
main(void){
        char string[STRGLEN], name[STRGLEN], name_file[STRGLEN];
        int fromlen;
        char hostname[64]; /* local machine hostname */
        struct hostent *hp; /* gethostbyname return ptr */
        register int s; /* socket descriptor, or -1 if error */
        register int ns; /* created new socket for accept */
        struct sockaddr_in  sin; /* socket structure */
        struct sockaddr_in fsin; /* socket str. for accept*/
        float number=0.0;
        int i;  /* loop counter */
        int selection;        /* menu choice */
        int num_user, num_file;
        userslist* ulist;
        fileslist* flist;
        FILE* p;
        char* text;


        text=(char*)malloc(1000*sizeof(char));
        ulist=(userslist*)malloc(sizeof(userslist));
        flist=(fileslist*)malloc(sizeof(fileslist));

       
        /* first need to know our hostname. */
        gethostname(hostname, sizeof(hostname));
       
        /* Next look up the network address of our host.*/
        if((hp = gethostbyname(hostname)) == NULL){
                fprintf(stderr, "%s: unknown host\n", hostname);
                exit(-1);
        }
       
        /* create socket in Internet domain(AF_INET), that is
        connection oriented (SOCK_STREAM) rather than
        connectionless (SOCK_DGRAM),
        arg3=0 for default TCP/IP protocol*/
        if(( s = socket(AF_INET, SOCK_STREAM, 0) ) < 0){
                perror("server: socket");
                exit(-1);
        }
       
        /* Create the address to connecting to. We use port
        APORT but put it into network byte order.
        Also we use bcopy to copy the network number. */
        bzero(&sin, sizeof(sin));
        sin.sin_family = AF_INET;  /* IP protocol */
        /* sin.sin_addr.s_addr = INADDR_ANY;*/
        sin.sin_port = htons(APORT);
        bcopy(hp->h_addr, &sin.sin_addr, hp->h_length);
       
        /* Try to bind(address and port no.)to socket s */
        if(bind(s, (struct sockaddr *)&sin, sizeof(sin)) < 0){
                perror("server: bind");
                exit(-1);
        }
       
        /* server ready, listen on socket s max 5 requests queued*/
        if(listen(s, 5) < 0) {
                perror("server: listen");
                exit(-1);
        }

 

  /* Accept connections then fork ns (new socket) that
  will be connected to the client. fsin will contain
  the IP address of the client. */
        bzero(&fsin, sizeof(fsin));
        fromlen = sizeof(fsin);
        if((ns = accept(s, (struct sockaddr *)&fsin, &fromlen))<0){
                perror("server: accept");
                exit(-1);
        }

        ulist=create_users_list(ulist);                        //Initialization of the users list
        if(ulist==NULL){
                printf("Impossible to allocate a users list");
                exit(-1);                        //Exit the program
        }
        flist=create_files_list(flist);                        //Initialization of the files list
        if(flist==NULL){
                printf("Impossible to allocate a files list");
                exit(-1);                        //Exit the program
        }

        /* get save file */
        p=fopen("save.txt","r");
        if(p!=NULL){
                get_savings(p, ulist, flist);
                fclose(p);
        }

        recv(ns, string, STRGLEN, 0);                //read name of the file
        strcpy(name_file, string);
        num_file=flist->totalFiles+1;
        num_user=1;
        add_file(name_file, num_file, num_user, flist);
        print_all_files(num_user, flist);
        //save_file(ns, name_file);
                               
       
        /* We can simply use close() to terminate the
        connection, since we're done with both sides */
        close(s);
}

---

even if I put exit() instead of close, my program still freezes after the print_all_files. Well not freezes maybe, but I don't have the command prompter as I should.
Can anyone help me?

If its looping, run it through a debugger. If you haven't got one, or think its not practicle to use one, try putting lots of printf("checkpoint 1"); type statements in the code to help you pin-point the problem area.

well I know where the problem is
I just don't know what the problem is and how to solve it

it's just the last line of my server's code:
close(s);
If I put a printf before it, my screens will print whatever I want but will stop right after that
I've also tried to put an exit() instead of close but it doesn't work either
I really don't know what to do