title: Socket in C; infinite loop
body: <p>So I'm trying to write a program that can accept inputs on both the client and server. Right now, it's infinite looping when I move these lines in the while(1) loop outside of it, like I was told to do:</p>
  
  <pre><code>sin_size = sizeof their_addr;
          new_fd = accept(sockfd, (struct sockaddr *)&amp;their_addr, &amp;sin_size);
  </code></pre>
  
  <p>I was told the reason why it's infinite looping is because the new socket is create and is now listen, while the old socket is still opened and listening. I've tried playing around with the closing of the old socket in both the client and server, but nothing is working. </p>
  
  <p>Getting rid of the while loop obviously works, but then the socket closes after receiving the input. The goal of this is basically make a chat program. It both server and client doesn't have to be opened simultaneously (for an A+ it does lol), but as long as it can go back and forth sending and receiving input. </p>
  
  <p>I've included the code for both client and server. Future thanks!</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
  
  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;
          new_fd = accept(sockfd, (struct sockaddr *)&amp;their_addr, &amp;sin_size);
  
  
      while(1) {  // 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
  printf("INFIITE LOOP");
  //does this because it waiting for another process and it' stays opened and is listnening???
  //Maybe look in the client for this
  //also said that while loop isn't probably needed and to do 
  
  
  //probably will need a recv
  //input
  //send
  //recieve
  char input[20];
  char *pointer;
  printf("Type in an input, q to quit: ");
  scanf("%s", input);
  pointer = input;  //will need to clean this up to be more effcient... later
  
  //if (input[0] == 'q')
  //{
  //printf("Testing the if");
  //close(new_fd);
  //need to break out of loop
  //}
              if (send(new_fd, pointer, 20, 0) == -1) //need to change the length to the actual length of the input... later.
  
  //int send(int sockfd, const void *msg, int len, int flags);
  //sockfd is the socket descriptor you want to send data to (whether it's the one returned by socket() or
  //the one you got with accept().) msg is a pointer to the data you want to send, and len is the length of that
  //data in bytes. Just set flags to 0. 
  
  
  //accept needs to be outstide of while loop
  //because after accepting, it blocks the socket?
  //in the while loop is where all the sending and recieving happens
  //after sending, do recieve
  
                  perror("send");
              close(new_fd); 
              exit(0);
          }
          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
  
      if ((numbytes = recv(sockfd, buf, MAXDATASIZE-1, 0)) == -1) {
          perror("recv");
          exit(1);
      }
  
      buf[numbytes] = '\0';
  
      printf("client: received '%s'\n",buf);
  
      close(sockfd); //as soon as client recieves message, it closes the socket. 
  //probably needs 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>