title: Keep socket open in C
body: <p>I think this may be a simple solution I'm just over thinking. I'm writing an extremely basic chat program where the client and server takes turns sending a message. Right now I have it where it sends a message back and forth only once and the client closes the socket. The program doesn't have to have sockets open simultaneously, just as long as it can switch back and forth like a swing, rather than a real chat program where the it can take multiple inputs from both sides all at once.</p>
  
  <p>Will a while loop in the client keep it open and what are the conditions of the while loop?</p>
  
  <p>I've tried several different conditions and none of them worked... it just makes it hang. I've also tried commenting out some of the <code>close()</code> functions in the server code, but that didn't work either.</p>
  
  <p>I also have a small issue of the received input printing gibberish, but I think it's because it's printing the memory addresses of the string array when there's nothing in it... I just can't remember how to shorten it. Lol.</p>
  
  <p><strong>Server.c:</strong></p>
  
  <pre><code>#include &lt;stdio.h&gt;
  #include &lt;stdlib.h&gt;
  #include &lt;unistd.h&gt;
  #include &lt;errno.h&gt;
  #include &lt;string.h&gt;
  #include &lt;sys/types.h&gt;
  #include &lt;sys/socket.h&gt;
  #include &lt;netinet/in.h&gt;
  #include &lt;netdb.h&gt;
  #include &lt;arpa/inet.h&gt;
  #include &lt;sys/wait.h&gt;
  #include &lt;signal.h&gt;
  
  #define PORT "3490"  // The port users will be connecting to
  
  #define BACKLOG 10   // How many pending connections queue will hold
  
  char input[20];
  char *pointer;
  
  void sigchld_handler(int s)
  {
      while(waitpid(-1, NULL, WNOHANG) &gt; 0);
  }
  
  // Get sockaddr, IPv4 or IPv6:
  void *get_in_addr(struct sockaddr *sa)
  {
      if (sa-&gt;sa_family == AF_INET) {
          return &amp;(((struct sockaddr_in*)sa)-&gt;sin_addr);
      }
      return &amp;(((struct sockaddr_in6*)sa)-&gt;sin6_addr);
  }
  
  int main(void)
  {
      int sockfd, new_fd;  // Listen on sock_fd, new connection on new_fd
      struct addrinfo hints, *servinfo, *p;
      struct sockaddr_storage their_addr; // Connector's address information
      socklen_t sin_size;
      struct sigaction sa;
      int yes = 1;
      char s[INET6_ADDRSTRLEN];
      int rv;
  
      memset(&amp;hints, 0, sizeof hints);
      hints.ai_family = AF_UNSPEC;
      hints.ai_socktype = SOCK_STREAM;
      hints.ai_flags = AI_PASSIVE; // use my IP
  
      if ((rv = getaddrinfo(NULL, PORT, &amp;hints, &amp;servinfo)) != 0) {
          fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv));
          return 1;
      }
  
      // loop through all the results and bind to the first we can
      for(p = servinfo; p != NULL; p = p-&gt;ai_next) {
          if ((sockfd = socket(p-&gt;ai_family, p-&gt;ai_socktype,
                               p-&gt;ai_protocol)) == -1) {
              perror("server: socket");
              continue;
          }
  
          if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &amp;yes,
                         sizeof(int)) == -1) {
              perror("setsockopt");
              exit(1);
          }
  
          if (bind(sockfd, p-&gt;ai_addr, p-&gt;ai_addrlen) == -1) {
              close(sockfd);
              perror("server: bind");
              continue;
          }
  
          break;
      }
  
      if (p == NULL)  {
          fprintf(stderr, "server: failed to bind\n");
          return 2;
      }
  
      freeaddrinfo(servinfo); // All done with this structure
  
      if (listen(sockfd, BACKLOG) == -1) {
          perror("listen");
          exit(1);
      }
  
      sa.sa_handler = sigchld_handler; // Reap all dead processes
      sigemptyset(&amp;sa.sa_mask);
      sa.sa_flags = SA_RESTART;
      if (sigaction(SIGCHLD, &amp;sa, NULL) == -1) {
          perror("sigaction");
          exit(1);
      }
  
      printf("server: waiting for connections...\n");
  
      sin_size = sizeof their_addr;
  
      while((new_fd = accept(sockfd, (struct sockaddr *)&amp;their_addr, &amp;sin_size)) &gt; 0) {  // Main accept() loop
  
          if (new_fd == -1) {
              perror("accept");
              continue;
          }
  
          inet_ntop(their_addr.ss_family,
              get_in_addr((struct sockaddr *)&amp;their_addr),
              s, sizeof s);
          printf("server: got connection from %s\n", s);
  
          if (!fork()) { // this is the child process
              close(sockfd); // child doesn't need the listener
  
              char input[20];
              char *pointer;
              printf("Type in an server's input: ");
              scanf("%s", input);
              pointer = input;  //Will need to clean this up to be more effcient... later
  
              if (send(new_fd, pointer, strlen(input), 0) == -1) //Need to change the length to
                                                                 //the actual length of the
                                                                 //input... later.
  
                  perror("send");
              close(new_fd);
              exit(0);
          }
  
          char Cinput[20];
          if ((recv(new_fd, Cinput, strlen(Cinput), 0)) == 0) { //NEW LINE ADDED HERE
              printf("No more messages");
          }
  
          if ((recv(new_fd, Cinput, strlen(Cinput), 0)) == -1) {
                  perror("recv");
                  exit(1);
          }
  
          printf("Server: received '%s'\n",Cinput);
  
          close(new_fd);  // Parent doesn't need this
      }
      return 0;
  }
  </code></pre>
  
  <p><strong>Client.c</strong></p>
  
  <pre><code>#include &lt;stdio.h&gt;
  #include &lt;stdlib.h&gt;
  #include &lt;unistd.h&gt;
  #include &lt;errno.h&gt;
  #include &lt;string.h&gt;
  #include &lt;netdb.h&gt;
  #include &lt;sys/types.h&gt;
  #include &lt;netinet/in.h&gt;
  #include &lt;sys/socket.h&gt;
  
  #include &lt;arpa/inet.h&gt;
  
  #define PORT "3490" // The port client will be connecting to
  
  #define MAXDATASIZE 100 // Max number of bytes we can get at once
  
  // Get sockaddr, IPv4 or IPv6:
  void *get_in_addr(struct sockaddr *sa)
  {
      if (sa-&gt;sa_family == AF_INET) {
          return &amp;(((struct sockaddr_in*)sa)-&gt;sin_addr);
      }
  
      return &amp;(((struct sockaddr_in6*)sa)-&gt;sin6_addr);
  }
  
  int main(int argc, char *argv[])
  {
      int sockfd, numbytes;
      char buf[MAXDATASIZE];
      struct addrinfo hints, *servinfo, *p;
      /*
          This is what is in the struct
  
          struct addrinfo {
              int ai_flags; // AI_PASSIVE, AI_CANONNAME, etc.
              int ai_family; // AF_INET, AF_INET6, AF_UNSPEC
              int ai_socktype; // SOCK_STREAM, SOCK_DGRAM
              int ai_protocol; // Use 0 for "any"
              size_t ai_addrlen; // Size of ai_addr in bytes
              struct sockaddr *ai_addr; // struct sockaddr_in or _in6
              char *ai_canonname; // Full canonical hostname
              struct addrinfo *ai_next; // Linked list, next node
          };
  
          getaddrinfo() will return a pointer to this
      */
      int rv;
      char s[INET6_ADDRSTRLEN];
  
      if (argc != 2) {
          fprintf(stderr,"usage: client hostname\n");
          exit(1);
      }
  
      memset(&amp;hints, 0, sizeof hints);
      hints.ai_family = AF_UNSPEC;
      hints.ai_socktype = SOCK_STREAM;
  
      if ((rv = getaddrinfo(argv[1], PORT, &amp;hints, &amp;servinfo)) != 0) {
          fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv));
          return 1;
      }
  
      // Loop through all the results and connect to the first we can
      for(p = servinfo; p != NULL; p = p-&gt;ai_next) {
          if ((sockfd = socket(p-&gt;ai_family, p-&gt;ai_socktype,
                               p-&gt;ai_protocol)) == -1) {
              perror("client: socket");
              continue;
          }
  
          if (connect(sockfd, p-&gt;ai_addr, p-&gt;ai_addrlen) == -1) {
              close(sockfd);
              perror("client: connect");
              continue;
          }
  
          break;
      }
  
      if (p == NULL) {
          fprintf(stderr, "client: failed to connect\n");
          return 2;
      }
  
      inet_ntop(p-&gt;ai_family, get_in_addr((struct sockaddr *)p-&gt;ai_addr),
                s, sizeof s);
      printf("client: connecting to %s\n", s);
  
      freeaddrinfo(servinfo); // All done with this structure
  
      while(1)//NEW LINE ADDEDthis is getting the client to repeat asking for the input, but doesn't send it.
      {
          if ((numbytes = recv(sockfd, buf, MAXDATASIZE-1, 0)) == 0) { //NEW LINE ADDED
                 printf("Shutdown");
          }
  
          if ((numbytes = recv(sockfd, buf, MAXDATASIZE-1, 0)) == -1) {
              perror("recv");
              exit(1);
          }
  
          buf[numbytes] = '\0';
  
          printf("client: received '%s'\n",buf);
  
          char Cinput[20];
          char *pointer;
          printf("Type in an client's input: ");
          scanf("%s", Cinput);
          pointer = Cinput;
          if (send(sockfd, pointer, strlen(Cinput), 0) == -1)
          {
              perror("send");
              close(sockfd);
              exit(0);
          }
      }
  
      close(sockfd); //As soon as the client receives a message, it closes the socket.
      //We probably need a while loop in here in order to keep the socket open,
      //but what are the parameters for the while loop?
      return 0;
  }
  </code></pre>