• View
• Edit
• History
• Print

Network Programming in C and UNIX

A Network Programming Lecture by Steven Choy

Lecture Overview: This lecture explains the concept of socket programming, and outlines the structure of a socket address and some system calls for socket programming. It also shows some example programs that implements the socket programming using C programming language for TCP and UDP communication.

Reference: Beej's Guide to Network Programming

Review of Basic Concepts on Network Programming

• What is a socket?
• Two Types of Internet Sockets

• IP Addresses, versions 4 and 6
• Port Numbers

Socket Structure

• The structure of a socket address is used to organize the information for the communication of application programs. What you need to do is to fill in all of the information and data in a socket, and then the lower layers will complete the data communication.
• The definition of the structure of a general socket address can be found in <sys/socket.h>:

        struct sockaddr {
            u_short sa_family; /* address family: AF_xxx value */
            char sa_data[14]; /* up to 14 bytes of protocol */
            /* specific address */
        }

• In the Internet family, we use the following specific structures for defining IP socket address in <netinet/in.h>:

        struct in_addr {
            u_long s_addr; /* 32-bit IP address */
            /* network byte ordered */
        }

        struct sockaddr_in {
            short sin_family; /* AF_INET */
            u_short sin_port; /* 16-bit TCP or UDP port number */
            struct in_addr sin_addr; /* 32-bit IP address */
            /* network byte ordered */
            char sin_zero[8]; /* unused */
        }

        struct sockaddr_in {
            short int          sin_family;  // Address family, AF_INET
            unsigned short int sin_port;    // Port number
            struct in_addr     sin_addr;    // Internet address
            unsigned char      sin_zero[8]; // To make it the same size as struct sockaddr
        };

Socket System Calls

Socket

• Before starting the communication, we need the socket system call to specify the type of communication protocol desired (e.g. TCP, UDP, etc.) and to define the end point.

      #include <sys/types.h>
      #include <sys/socket.h>
      int socket(int family, int type, int protocol);

• The following constants are the choices to put into the first argument family to indicate which protocol is used:

      AF_UNIX or AF_LOCAL (UNIX internal protocols);
      AF_INET (Internet protocols, IPv4);
      AF_INET6 (IPv6 protocols);
      AF_NS (Xerox NS protocols); and
      AF_IMPLINK (IMP link layer).

• We use AF_INET addresses in the later examples, because they are the most useful and widely used address family.
• For the second argument type, the choices are shown below.

• The socket system call returns an integer called a socket descriptor, or sockfd. This integer represents a communication end point whose communication protocol is selected after executing the socket system call.
• On successful completion, the socket system call will return a nonnegative integer for the socket descriptor. Otherwise, it will return –1 to indicate that an error occurred.

bind

• The bind system call is used to assign an address (both an IP address and a port number) to a socket.

        #include <sys/types.h>
        #include <sys/socket.h>
        int bind(int sockfd, struct sockaddr *myaddr,
        int addrlen);

• The first argument sockfd is the socket descriptor returned by the socket system call.
• The second argument *myaddr is a pointer to the socket address myaddr
• The third one addrlen is the length of the socket address myaddr.

• The output returns 0 if the bind system call is successfully executed; otherwise, it returns -1 if it failed.

connect

• The connect system call allows a client to establish a connection with a server.

        #include <sys/types.h>
        #include <sys/socket.h>
        int connect(int sockfd, struct sockaddr *servaddr, int addrlen);

• The first argument sockfd is the socket descriptor returned by the socket system call.
• The second argument *servaddr is a pointer to the socket address servaddr, which is the socket address of the server.
• The third one addrlen is the length of the socket address servaddr.

• The client uses TCP communication system call to establish a connection to its corresponding server.
• If the system call is successfully executed, the connection will be established and then data or packets can be exchanged through the connection; otherwise, an error will be returned to the process.
• Note that we do not use this system call in UDP communication.
• Note that both system connect and bind calls require the pointer to the socket address structure (*myaddr and *servaddr) only, not the protocol.
• The reason is that the first 2 bytes of the socket address store the address family AF_INET, and the sockfd argument yields the desired protocol after the socket system call has created the socket descriptor.

listen

• A TCP server uses the listen system call to indicate the number of connections that it is willing to receive.
• It is used after executing the socket and bind system calls and before executing the accept system call. Note that only TCP communication requires this system call, whereas UDP communication does not.

        #include <sys/types.h>
        #include <sys/socket.h>
        int listen(int sockfd, int backlog);

• The first argument sockfd is the socket descriptor returned by the socket system call.
• The second argument backlog specifies the maximum number of connections allowed to be queued by the system while it waits for the server to execute the accept system call.

accept

• The accept system call takes the first connection request from the queue that stores all incoming connection requests, and creates another socket with the same properties as sockfd.

        #include <sys/types.h>
        #include <sys/socket.h>
        int accept(int sockfd, struct sockaddr *peer, int *addrlen);

• The first argument sockfd is the socket descriptor of the first connection request from the waiting queue (if any).
• The second and third arguments peer and addrlen are used to return the address of the connected peer process (the client), and thus they are pointers but not variables. The second argument peer is the socket address of the client process, and the third argument addrlen is the size of this address.

send, sendto, recv and recvfrom

• These four system calls are used for message exchange. The send and recv system calls are for TCP communication, whereas the sendto and recvfrom system calls are for UDP communication.

        #include <sys/types.h>
        #include <sys/socket.h>

        int send(int sockfd, char *buff, int nbytes, int flags);
        int recv(int sockfd, char *buff, int nbytes, int flags);

        int sendto(int sockfd, char *buff, int nbytes, int flags, struct sockaddr *to, int addrlen);
        int recvfrom(int sockfd, char *buff, int nbytes, int flags, struct sockaddr *from, int *addrlen);

close

• The close system call is used to close one end of a socket connection.

        int close(int fd);

• The following is a summary of the socket system calls.

• The following shows the general client and server operations for connection-oriented protocol.

Socket programming flow

• The following two diagrams illustrate the general program flow of two communication protocols: TCP and UDP.

Socket programming Examples

• Example 1: Daytime Server

• Example 2: Daytime Client

• Example 3: TCP Echo Server

• Example 4: TCP Echo Client

• Example 5: UDP Echo Server

• Example 6: UDP Echo Client

• A necessary header file: inet.h

Tools

• Cygwin is a Linux-like environment for Windows

Thanks for Reading

If you would rather like to have this lecture note in printed format, please click the print action link in the top right corner.

If you find any problem in this lecture note, please feel free to tell Steven via steven@findaway.hk.