int fd;
  ssize_t input_length;
  struct sockaddr_in   destination;

  fd = socket(AF_INET, SOCK_DGRAM, 0);
  
  memset(&destination, 0, sizeof(struct sockaddr_in));
  destination.sin_family = AF_INET;
  inet_pton(AF_INET, "134.126.125.234", &(destination.sin_addr));
  destination.sin_port = htons(22801);
  

1. Does this fragment use UDP or TCP? How do you know?
2. Is the next system call more likely to be sendto() or recvfrom()? How do you know?

 
static void
*display_wrapper(void *arg)
{
  char  *s;
  long  result;

  s = (char *)arg;
  result = display(s);
  return (void *)result;
}
  

1. Is this fragment more likely to be used in a program that uses multiple processes or multiple threads?
2. What warning/diagnostic message might you receive if you changed the type of result from long to int?

1. The server transmits a prompt (e.g., "ID:") to the client.
2. The client displays the prompt.
3. The client reads from standard input.
4. The client transmits the user's response to the server.
5. The server transmits a prompt (e.g., "Password:") to the client.
6. The client displays the prompt.
7. The client reads from standard input.
8. The client transmits the user's response to the server.

1. Explain why this application is not reliable.
2. How might acknowledgements be used to make it reliable.
3. Why would the acknowledgement scheme need to be complicated if the application-layer protocol used more than two messages (i.e., more than just a request and a response)?
4. Why would the ackowledgement scheme need to be more complicated if the server could handle multiple requests concurrently?

1. What system call causes the system to transition from the Closed state to the Listen state? Be spcific.
2. What system call causes the system to transition from the Closed state to the SYN-Sent state? Be specific.
3. When does the system transition from the Listen state to the SYN-Received state? Your answer must refer to a specific system call.

static void
handle_connection(int connection_fd)
{
  char id[4];
  int i, index, n;

  read(connection_fd, id, 3);
  id[3] = '\0';
  
  index = get_index(id);
  if (index < 0)
    {
      write(connection_fd, "No Such Course", 15);
    }
  else
    {
      n = lines[index];
      for (i=0; i<n; i++)
        {
          write(connection_fd, description[index][i], 70);
          write(connection_fd, "\n", 1);
        }
    }
  close(connection_fd);
}



int main(void)
{
  int connection_fd, listening_fd;
  int pid;
  struct sockaddr_in address;
  
  memset(&address, 0, sizeof(address));
  address.sin_family = AF_INET;
  address.sin_port = htons(22801);
  address.sin_addr.s_addr = htonl(INADDR_ANY);

  listening_fd = socket(AF_INET, SOCK_STREAM, 0);
  bind(listening_fd, (struct sockaddr *)&address, sizeof(struct sockaddr));
  listen(listening_fd, 0);

  while (1)
    {
      connection_fd = accept(listening_fd, NULL, NULL);
      handle_connection(connection_fd);
    }

  return 0;
}  

1. Is this a client or a server (at the application layer)?
2. Rewrite the above program so that it handles each connection in its own process.
3. Rewrite the above program so that it handles each connection in its own thread. (Note: You must use a wrapper for the handle_connection() function. That is, you must not change the signature of the handle_connection() function.)