Please enable JavaScript.

Coggle requires JavaScript to display documents.

11.4 and 11.5 and 11.6 - Coggle Diagram

- - - - The sockets need to accept any kind of socket address structure.
        
        to solve this the socket functions expect a pointer to a generic sockaddr structure.
        
        then the applications need to cast any pointers to protocol specified structures to this generic structure.
  - - - include <sys/types.h>
        
        include <sys/socket.h>
        int socket(int domain, int type, int protocol);
    - - clientfd = Socket(AF_INET, SOCK_STREAM, 0);
      - AF_INET means we are using 32-bit IP address
      - SOCK_STREAM indicates that socket will be an endpoint for a connection. Its better to use getaddrinfo to generate parameters automatically so the code is protocol independent
      - The clientfd descriptor returned is only partially opened and cannot be used for reading or writing yet.
      - How we finish opening the socket depends on whethere we are a client or a server
        
        11.4.3 The connect function - if we are the client
        
        include <sys/socket.h> int connect(int clientfd, const struct sockaddr *addr, socklen_t addrlen);
        
        This tries to establish a connection with server at socket address addr. The connect function blocks until either the connection is successfully established or an error occurs.
        
        If successful, the clientfd descriptor is now ready for reading and writing, and a resulting conneciton is characterized by this socket pair. (x:y, addr.sin_addr:addr.sin_port)
        
        x is the client's IP addressa dn y is the port that uniquely identifies the client process on the client host.
        
        If we are the server: bind, listen and accept
        
        11.4.4 The bind function
        
        int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
        
        asks kernel to associate server's socket address in addr with the socket descriptor sockfd. The addrlen argument is sizeof(sockaddr_in). As with socket and connect, the best practice is to use getaddrinfo to supply the arguments to bind.
        
        basically we just tie a socket address to a file descriptor we got from calling a socket function
        
        11.4.5 The listen Function
        
        used to tell kernel that this file descriptor will be used by a server instead of a client
        
        int listen(int sockfd, int backlog);
        
        by default sockets are active (client). This changes that and makes it a listening socket that can accept connection requests from clients.
        
        11.4.6 The accept function
        
        Servers wait for connection requests from clients by calling the accept function
        
        int accept(int listenfd, struct sockaddr addr, int addrlen);
        
        waits for connection request
        
        fills clients socket address in addr.
        
        returns a connected descriptor that can be used to communicate with the client
- - - - replaces gethostbyname and getservbyname
      - converts string representations of hostnames, host addresses, service names and port numbers into socket address structures.
      - works with any protocol
      - how does it work?
        
        given host and service (two components of a socket address), it returns a result that points to a linked list of addrinfo structures, each of which points to a socket address structure that corresponds to host service.
        
        host + service = linked list of addrinfo structures
        
        looks like this
        
        struct addrinfo {
        
        int ai_flags; / Hints argument flags /
        
        int ai_family; / First arg to socket function /
        
        int ai_socktype; / Second arg to socket function /
        
        int ai_protocol; / Third arg to socket function /
        
        char ai_canonname; / Canonical hostname */
        
        size_t ai_addrlen; / Size of ai_addr struct /
        
        struct sockaddr ai_addr; / Ptr to socket address structure */
        
        struct addrinfo ai_next; / Ptr to next item in linked list */
        
        };
        
        after it calls getaddrinfo it walks the list trying each socket address until the calls to socket and connect succeed and a connection is established
        
        The server tries each socket address and calls socket and bind and descriptor is bound to a valid socket address
        
        to avoid memory leaks the application must eventually free the list by calling freeaddrinfo
  - - - open_clientfd
        
        int open_clientfd(char hostname, char port);
        
        establishes connection with server
        
        returns file descriptor if ok
      - open_listenfd
        
        creates a listening descriptor that is ready to receive connection requests
        
        int open_listenerfd(char *port);
- - - - Web content can be written in HTML
  - - - Sequence of bytes with MIME type
        
        What are some common mime types?
        
        html
        
        plain text
        
        postscript document
        
        gif
        
        png
        
        jpeg
      - Web content provided to clients in two ways
        
        Fetch data disk stuff
        
        This is called serving static content
        
        Run an executable file and return output to client
        
        Called serving dynamic content
    - - parameters and stuff are separated by ? and & is some special way
      - no standard way to tell if URL refers to static or dynamic content
  - - - A Linux program
      - Because HTTP is based on text lines being transmitted we can use this program
      - largely supplanted by SSH as a remote login tool
      - its good for debugging servers that talk with clients via text lines
    - - GET
        
        basically just says get me the stuff I tell you to get
    - - response line
        
        version
        
        status-code
        
        status-message
      - response headers
        
        most important header is content-type
        
        content-length
      - response body
    - - uses CGI ( common gateway interface )
      - How Client Pass program arguments to server?
        
        ? separates filename from arguments
        
        & separates arguments
        
        spaces become 20%
      - suppose a server gets request GET /cgi-bin/adder?15000&213 HTTP/1.1
        
        it forks
        
        it calls execve in the child
        
        child process sets CGI environment variable QUERY_STRING to 15000&213
        
        output
        
        to standard output
        
        before it uses dup2 to redirect standard output to client fd
      - CGI defines a number of other environment variables that a CGI program can expect to be set when it runs