计算机网络代写｜COEN 146: Computer Networks Lab 3: TCP/IP Socket Programming

这是一个CS代写的相关案例，与计算机网络有关

Objectives

1.     To develop client/ server applications using TCP/IP Sockets

2.     To write a C program to transfer file over TCP/IP Socket

TCP/IP Client/ Server^[1]

The following figure shows the steps taken by each program:

[1] http://beej.us/guide/bgnet/

On the client and server sides:

The socket() system call creates an unbound socket in a communications domain, and return a file descriptor that can be used in later function calls that operate on sockets.

int sockfd = socket(domain, type, protocol)

• sockfd:socket descriptor, an integer (like a file-handle)
• domain:integer, communication domain e.g., AF_INET (IPv4 protocol) , AF_INET6 (IPv6 protocol), AF_UNIX (local channel, similar to pipes)
• type:communication type
  SOCK_STREAM: TCP (reliable, connection oriented)
  SOCK_DGRAM: UDP (unreliable, connectionless)

SOCK_RAW (direct IP service)

• protocol: This is useful in cases where some families may have more than one protocol to support a given type of service. Protocol value for Internet Protocol (IP), which is 0. This is the same number which appears on protocol field in the IP header of a packet.

#include <sys/socket.h>
…
…if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
{
perror(“cannot create socket”);
return 0;
}

On the server side:

After creation of the socket, bind() system call binds the socket to the address and port number specified in addr(custom data structure). In the example code, we bind the server to the localhost, hence we use INADDR_ANY to specify the IP address.

int bind (int sockfd, const struct sockaddr *addr, socklen_t addrlen);

• addr: Points to a sockaddrstructure containing the address to be bound to the socket. The length and format of the address depend on the address family of the socket.
• addrlen: Specifies the length of the sockaddrstructure pointed to by the addr

The listen() function puts the server socket in a passive mode, where it waits for the client to approach the server to make a connection.

int listen(int sockfd, int backlog);

• backlog: defines the maximum length to which the queue of pending connections for sockfd may grow. If a connection request arrives when the queue is full, the client may receive an error with an indication of ECONNREFUSED.

The accept() system call extracts the first connection request on the queue of pending connections for the listening socket (sockfd), creates a new connected socket, and returns a new file descriptor referring to that socket. At this point, connection is established between client and server, and they are ready to transfer data.

int new_socket= accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

On the client side:

The connect() system call connects the socket referred to by the file descriptor sockfd to the address specified by addr. Server’s address and port is specified in addr.

int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

Read and write over socket:

bzero(buffer, 256);

n = read(newsockfd, buffer, 255);

if (n < 0) error(“ERROR reading from socket”);

printf(“Here is the message: %s\n”, buffer);

This code initializes the buffer using the bzero() function, and then reads from the socket.

Note that the read call uses the new file descriptor, the one returned by accept(), not the original file descriptor returned by socket().

Note also that the read() will block until there is something for it to read in the socket, i.e. after the client has executed a write(). It will read either the total number of characters in the socket or 255, whichever is less, and return the number of characters read

n = write(newsockfd, “I got your message”, 18);

if (n < 0) error(“ERROR writing to socket”);

Once a connection has been established, both ends can both read and write to the connection. Naturally, everything written by the client will be read by the server, and everything written by the server will be read by the client. This code simply writes a short message to the client. The last argument of write is the size of the message.

Structures:

Address format

An IP socket address is defined as a combination of an IP interface address and a 16-bit port number. The basic IP protocol does not supply port numbers, they are implemented by higher level protocols like UDP and TCP. On raw sockets sin_port is set to the IP protocol.

struct sockaddr_in {

sa_family_t    sin_family; /* address family: AF_INET */

in_port_t      sin_port;   /* port in network byte order */

struct in_addr sin_addr;   /* internet address */

};

/* Internet address. */

struct in_addr {

uint32_t       s_addr;     /* address in network byte order */

};

This is defined in netinet/in.h

sin_family is always set to AF_INET.

sin_port contains the port in network byte order. The port numbers below 1024 are called privileged ports (or sometimes: reserved ports). Only privileged processes) may bind to these sockets.

sin_addr is the IP host address.

s_addr member of struct in_addr contains the host interface address in network byte order.

in_addr should be assigned one of the INADDR_* values (e.g., INADDR_ANY) or set using the inet_aton, inet_addr, inet_makeaddr library functions or directly with the name resolver (see gethostbyname).

INADDR_ANY allows your program to work without knowing the IP address of the machine it was running on, or, in the case of a machine with multiple network interfaces, it allowed your server to receive packets destined to any of the interfaces.

INADDR_ANY has the following semantics: When receiving, a socket bound to this address receives packets from all interfaces. For example, suppose that a host has interfaces 0, 1 and 2. If a UDP socket on this host is bound using INADDR_ANY and udp port 8000, then the socket will receive all packets for port 8000 that arrive on interfaces 0, 1, or 2. If a second socket attempts to Bind to port 8000 on interface 1, the Bind will fail since the first socket already “owns” that port/interface.

Example: