when to close a socket

I don't know where I have to put my close():

my code is like this:

Code:

---

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


/*        Function main */
main(){
        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*/
        int p1;

       
        /* 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 2 requests queued*/
        if(listen(s, 2) < 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);
        }

        if((p1 = fork()) > 0){
                server(ns);
        }
        else{        /* child */
                server(ns);
        }
       
}

---

do I put my close(s) in the if, else, or elsewhere?

Where's your loop? Assuming this is a server that listens for connections and then forks a new process for the actual client communication, you need logic like so:

Code:

---

/* Open a socket to listen with */
while (1) {
        /* Accept a connection */
        switch (fork()) {
        case -1:
                /* Error */
                break;
        case 0:
                /* Child closes the listening socket */
                /* Child processes the request */
                break;
        }
        /* Parent closes the connection */
        /* Parent cleans up zombies */
}

---

I don't understand several things

1)what is the loop for? and how do you get out of this loop when you write while(1)?

2)

Quote:

---

/* Child closes the listening socket */
/* Child processes the request */

---

Shouldn't the child close the socket after it processes the request? (my request include some send/recv)

3)When I have listen(s, 2), do I have to make 2 fork() (or more) or is one enough?

4)

Quote:

---

/* Parent closes the connection */

---

What's the difference between closing the listening socket and closing the connection? Is "s" the connection and "ns" the listening socket in my code?

5)

Quote:

---

/* Parent cleans up zombies */

---

How do you do that?

s is the listening socket
ns is a new socket created by accept
when a connnection is accepted you need to fork to handle that connection (ns) but keep looping to accept future connections. Only one fork statement is required since in a loop it should be called each time accept returns a new socket.

do I have to put a particular condition in the loop or is "while(1)" just enough?

and I just don't understand why I have to close the listening socket "s" before the accepted socket "ns". It doesn't seem logical to me

if I've understood, I should do this, right?

Code:

---

while(1){
      if((child = fork()) == 0){  /* child process */
        close(s);  /* close s because this socket was copied with the fork */
        server(ns);  /* exchange data with the client */
        close(ns);  /* once the childs process is done, close the socket */
      }
  }
   
  /* use close() to terminate the
  connection, since we're done with both sides */
  close(s);

---