Sockets Overview

• For stream sockets
  • After socket
  • int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
    • Assigns an address to the socket.
      • This is so clients know "where" to connect to this socket.
      • The man page refers to this as "assigning a name to a socket".
    • sockfd is the file descriptor created by the socket command
    • addr is the address we wish to bind to.

      • struct sockaddr {
             sa_family_t sa_family;
             char        sa_data[14];
        }; 

      • AF_UNIX, AF_INET, ...
      • this is different for each address family.
      • This is a struc from a pre-polymorphic language.
      • We cast to this so the compiler doesn't complain
      • See the code in the bind man page.
        • void *memset(void *s, int c, size_t n);
          • Sets the memory of size n bytes to be multiple copies of the first byte of c
        • char *strncpy(char *restrict dest, const char *restrict src, size_t n);

        • #define MY_SOCK_PATH "/somepath"
          ...
          
          int sfd, cfd;
          struct sockaddr_un my_addr, peer_addr;
          socklen_t peer_addr_size;
          
          sfd = socket(AF_UNIX, SOCK_STREAM, 0);
          if (sfd == -1)
              handle_error("socket");
          
          memset(&my_addr, 0, sizeof(my_addr));
          my_addr.sun_family = AF_UNIX;
          strncpy(my_addr.sun_path, MY_SOCK_PATH,
                  sizeof(my_addr.sun_path) - 1);
          
          if (bind(sfd, (struct sockaddr *) &my_addr,
                  sizeof(my_addr)) == -1)
              handle_error("bind"); 

  • int listen(int sockfd, int backlog);
    • The socket will "listen" for incoming connections.
    • The backlog says how many clients can be on "hold" before the connection will be refused.
    • This is not always done, but typically in a server...
  • int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
    • Once an incoming connection has been detected, this performs the final connection piece.
    • This tells us who has connected to us.
    • This actually creates a new socket, which is used for communication
    • This is normally followed by a series of reads/writes.
    • This might block, unless marked as non-blocking.
  • This describes a passive server, stream socket.
    • Look at the pictures on 1156, 1157.
  • The client does
    • Socket
    • int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
    • Then a series of reads and writes.
• For Datagram
  • server
    • Socket
    • bind
    • recvfrom/sendto
    • close
  • client
    • socket
    • recvfrom/sendto
    • close
  • ssize_t sendto(int sockfd, const void *buf, size_t len, int flags, const struct sockaddr *dest_addr, socklen_t addrlen);
  • ssize_t recvfrom(int sockfd, void *restrict buf, size_t len, int flags, struct sockaddr *restrict src_addr, socklen_t *restrict addrlen);
• Not included is int poll(struct pollfd *fds, nfds_t nfds, int timeout);
  • A replacement for select, but checks multiple sockets at once.