TCP/IP和网络编程

一、知识点归纳

（一）网络编程简介

如今，上网已成为日常生活的需要。虽然大多数人可能只把互联网作为一种信息收集、网上购物和社交媒体等的工具，但计算机科学的学生必须对互联网技术有一定的了解，并掌握一定的网络编程的技能。在本章中，我们将介绍TCP/IP网络和网络编程的基础知识，包括 TCP/IP 协议、UDP 和 TCP 协议、服务器-客户机计算、HTTP 和 Web 页面、动态 Web 页面的 PHP 和 CGI 编程。

（二）TCP/IP 协议

TCP/IP (Comer 1988, 2001; RFC1180 1991 )是互联网的基础。TCP 代表传输控制协议。IP 代表互联网协议。目前有两个版本的IP，即 IPv4 和 IPv6。IPv4 使用32位地址，IPv6 则使用128位地址。本节围绕 IPv4 进行讨论，它仍然是目前使用最多的IP版本。TCP/IP 的组织结构分为几个层级，通常称为TCP/IP 堆栈，如图所示为TCP/IP的各个层级以及每一层级的代表性组件及其功能。

Layer	Components	Functions
Application Layer	ssh ping	Application commands
Transport Layer	TCP UCP	Connection Datagram
Internet Layer IP	send/receive	data frames
Link Layer	Ethernet	send/receive data frames

顶层是使用 TCP/IP 的应用程序。用于登录到远程主机的 ssh、用于交换电子邮件的 mail、用于 Web 页面的 http 等应用程序需要可靠的数据传输。通常，这类应用程序在传输层使用 TCP。另一方面，有些应用程序，例如用于查询其他主机的ping命令，则不需要可靠性。这类应用程序可以在传输层使用 UDP 来提高效率(RFC 768 1980; Comer 1988)。传输层负责以包的形式向 IP 主机发送/接收来自 IP 主机的应用程序数据。进程与主机之间的传输层或其上方的数据传输只是逻辑传输。实际数据传输发生在互联网(IP) 和链路层，这些层将数据包分成数据帧，以便在物理网络之间传输。

（三）IP 主机和 IP 地址

主机是支持TCP/IP协议的计算机或设备。每个主机由一个32位的 IP地址来标识。为了方便起见，32位的 IP地址号通常用点记法表示，例如：134.121.64.1,其中各个字节用点号分开。主机也可以用主机名来表示，如 dnsl.eec.wsu.edu。实际上，应用程序通常使用主机名而不是 IP 地址。在这个意义上说，主机名就等同于IP地址，因为给定其中一个，我们可以通过 DNS (域名系统)(RFC 134 1987; RFC 1035 1987 )服务器找到另一个，它将IP地址转换为主机名，反之亦然。
IP地址分为两部分，即NetworkID字段和HostID字段。根据划分，1P地址分为 A~E 类。例如，一个B类 IP 地址被划分为一个16位 NetworklD，其中前2位是10，然后是一个16位的 HostID 字段。发往IP地址的数据包首先被发送到具有相同 networkID 的路由器。路由器将通过 HostID 将数据包转发到网络中的特定主机。每个主机都有一个本地主机名 localhost，默认 IP 地址为127.0.0.1。本地主机的链路层是一个回送虚拟设备，它将每个数据包路由回同一个 localhost0 这个特性可以让我们在同一台计算机上运行 TCP/IP 应用程序，而不需要实际连接到互联网。

（四）IP 协议

IP 协议用于在 IP 主机之间发送/接收数据包。IP 尽最大努力运行。IP 主机只向接收主机发送数据包，但它不能保证数据包会被发送到它们的目的地，也不能保证按顺序发送。这意味着 IP 并非可靠的协议。必要时，必须在 IP 层的上面实现可靠性。

（五）IP 数据包格式

IP 数据包由 IP 头、发送方 IP 地址和接收方 IP 地址以及数据组成。每个 IP 数据包的大小最大为64KB。IP 头包含有关数据包的更多信息，例如数据包的总长度、数据包使用 TCP 还是 UDP、生存时间（TTL）计数、错误检测的校验和等。

（六）UDP

在IP上运行，用于发送/接收数据报。与IP类似，UDP不能保证可靠性，但是快速高效。ping是一个向目标主机发送带时间戳UDP包的应用程序。接收到一个pinging数据包后，目标主机将带有时间戳的UDP包回送给发送者，让发送者可以计算和显示往返时间。如果目标主机不存在或宕机，当TTL减小为0时，路由器将会丢弃pinging UDP数据包。在这种情况下，用户会发现目标主机没有任何响应。用户可以尝试再次ping，或者断定目标主机宕机。

（七）TCP

是一种面向连接的协议，用于发送/接收数据流。TCP也可在IP上运行，但它保证了可靠的数据传输。通常，UDP类似于发送邮件的USPS，而TCP类似于电话连接。

（八）端口编号

端口号是分配给应用程序的唯一无符号短整数。要想使用UDP或TCP，应用程序（进程)必须先选择或获取一个端口号。前1024个端口号已被预留。其他端口号可供一般使用。应用程序可以选择一个可用端口号，也可以让操作系统内核分配端口号。

（九）网络和主机字节序

计算机可以使用大端字节序，也可以使用小端字节序。在互联网上，数据始终按网络序排列，这是大端。在小端机器上，例如基于Intel x86的PC，htons()、htonl()、ntohs()、ntohl()等库函数，可在主机序和网络序之间转换数据。例如，PC中的端口号1234按主机字节序(小端)是无符号短整数。必须先通过htons(1234)把它转换成网络序，才能使用。相反，从互联网收到的端口号必须先通过ntohs(port)转换为主机序。

（十）套接字API

在网络编程中，TCP/IP的用户界面是通过一系列C语言库函数和系统调用来实现的，这些函数和系统调用统称为套接字API((Rago1993;Stevens等2004)。为了使用套接字 API，我们需要套接字地址结构，它用于标识服务器和客户机。netdbh和sys/socketh中有套接字地址结构的定义。

1.套接字地址

struct sockaddr_in {
sa_family_t sin_family; // AF_INET for TCP/IP
in port_t sinport; // port number 
struct in_addr sin_addr; // IP address
};
struct in_addr{ //internet address 
uint32_t s_addr; // IP address in network byte order 
};

在套接字地址结构中

TCP/IP网络的sin family始终设置为AFINET。
sin_port包含按网络字节顺序排列的端口号。
sin_addr是按网络字节顺序排列的主机IP地址。

2. 套接字API

int套接字 (int域，int类型，int协议)
int bind(int sockfd,struct sockaddr *addr,socklen_t addrlen)
UDP套接字
UDP套接字使用sendto()/recvfrom0)来发送/接收数据报。
TCP套接字
在创建套接字并将其绑定到服务器地址之后，TCP服务器使用listen()和accept()来接收来自客户机的连接

二、苏格拉底挑战

挑战一

挑战二

三、问题

问题：在网络编程过程中，服务器端和客户端的套接字有什么区别？
解决：在网络编程中，服务器端和客户端的套接字有以下区别：
角色和功能：服务器端套接字用于监听和接受客户端的连接请求，并提供服务；而客户端套接字用于向服务器端发送连接请求，并与服务器端进行通信。
创建和绑定：在服务器端，首先要创建套接字并绑定到一个特定的IP地址和端口号，以便能够监听客户端的连接请求。而在客户端，只需要创建套接字，然后指定服务器端的IP地址和端口号。
连接过程：在服务器端，套接字通过调用listen()函数进行监听，并使用accept()函数接受客户端的连接请求，返回一个新的套接字用于与客户端通信。而在客户端，套接字通过调用connect()函数与服务器端建立连接。
数据传输：一旦连接建立，服务器端和客户端的套接字都可以使用send()和receive()函数进行数据的发送和接收。然而，服务器端套接字通常会同时处理多个客户端的连接请求，而客户端套接字只与服务器端进行一对一的通信。
总结起来，服务器端套接字负责监听和接受连接请求，并提供服务，而客户端套接字负责发送连接请求并与服务器端进行通信。它们在创建、绑定、连接和数据传输等方面存在一些区别。

四、实践

13.14

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>  // Added inclusion of arpa/inet.h for inet_aton function
#define SERVER_HOST "127.0.0.1"  // Default server IP: localhost
#define SERVER_PORT 1234  // Fixed server port number
#define BUFLEN 256  // Max length of buffer

char line[BUFLEN];
struct sockaddr_in server;
int sock, rlen, slen = sizeof(server);

int main() {
    printf("1. create a UDP socket\n");
    sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
    printf("2. fill in server address and port number\n");
    memset((char*)&server, 0, sizeof(server));
    server.sin_family = AF_INET;
    server.sin_port = htons(SERVER_PORT);
    inet_aton(SERVER_HOST, &server.sin_addr);
    
    while (1) {
        printf("Enter a line: ");
        fgets(line, BUFLEN, stdin);
        line[strlen(line) - 1] = '\0';  // Fixed newline character removal
        printf("send line to server\n");
        sendto(sock, line, strlen(line), 0, (struct sockaddr*)&server, slen);
        memset(line, 0, BUFLEN);
        printf("try to receive a line from server\n");
        rlen = recvfrom(sock, line, BUFLEN, 0, (struct sockaddr*)&server, &slen);
        printf("rlen=%d: line=%s\n", rlen, line);
    }

    return 0;
}

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define BUFLEN 256
#define PORT 1234

char line[BUFLEN];
struct sockaddr_in me, client;  // 淇敼浜嗘嫾鍐欓敊璇?
int sock, rlen, clen = sizeof(client);  // 鍒犻櫎浜嗗浣欑殑閫楀彿

int main() {
    printf("1. create a UDP socket\n");
    sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);

    printf("2. fill me with server address and port number\n");
    memset((char*)&me, 0, sizeof(me));
    me.sin_family = AF_INET;
    me.sin_port = htons(PORT);
    me.sin_addr.s_addr = htonl(INADDR_ANY);

    printf("3. bind socket to server IP and port\n");
    bind(sock, (struct sockaddr*)&me, sizeof(me));

    printf("4. wait for datagram\n");
    while (1) {
        memset(line, 0, BUFLEN);
        printf("UDP server: waiting for datagram\n");
        // recvfrom() gets client IP, port in sockaddr_in client
        rlen = recvfrom(sock, line, BUFLEN, 0, (struct sockaddr*)&client, &clen);
        printf("received a datagram from [host:port] = [%s:%d]\n", inet_ntoa(client.sin_addr), ntohs(client.sin_port));
        printf("rlen=%d: line=%s\n", rlen, line);
        printf("send reply\n");
        sendto(sock, line, rlen, 0, (struct sockaddr*)&client, clen);
    }
}

13.15

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>  // Added inclusion of unistd.h for close function

#define MAX 256
#define SERVER_HOST "localhost"
#define SERVER_IP "127.0.0.1"
#define SERVER_PORT 1234  // Defined SERVER_PORT here

struct sockaddr_in server_addr, client_addr;
int mysock, csock;

void server_init() {
    printf("================ server init =================\n");

    // 1. Create a TCP socket
    printf("1 : create a TCP socket\n");
    mysock = socket(AF_INET, SOCK_STREAM, 0);
    if (mysock < 0) {
        perror("socket call failed");
        exit(1);
    }

    // 2. Fill server_addr with server's IP and PORT#
    printf("2 : fill server_addr with server's IP and PORT#\n");
    memset((char*)&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY); // Use localhost
    server_addr.sin_port = htons(SERVER_PORT);

    // 3. Bind socket to server address
    printf("3 : bind socket to server address\n");
    int r = bind(mysock, (struct sockaddr*)&server_addr, sizeof(server_addr));
    if (r < 0) {
        perror("bind failed");
        exit(3);
    }

    printf("hostname = %s port = %d\n", SERVER_HOST, SERVER_PORT);
    printf("4 : server is listening ....\n");
    
    // 4. Listen for incoming connections
    listen(mysock, 5); // Queue length = 5

    printf("================== init done ===============\n");
}

int main() {
    int n;
    char line[MAX];

    server_init();

    while (1) {
        // Try to accept a client request
        printf("server: accepting new connection ....\n");
        socklen_t len = sizeof(client_addr);
        csock = accept(mysock, (struct sockaddr*)&client_addr, &len);
        if (csock < 0) {
            perror("server: accept error");
            exit(1);
        }

        printf("server: accepted a client connection from\n");
        printf("Client: IP=%s port=%d\n", inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));

        // Processing loop: client_sock <== data ==> client
        while (1) {
            n = recv(csock, line, MAX, 0);
            if (n <= 0) {
                printf("server: client closed the connection, server loops\n");
                close(csock);
                break;
            }

            // Show the received line string
            printf("server: received n=%d bytes; line=%s\n", n, line);

            // Echo line to client
            n = send(csock, line, n, 0);
            printf("server: sent n=%d bytes; echo=%s\n", n, line);
        }
    }

    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <arpa/inet.h> // Added inclusion of arpa/inet.h for bzero function

#define MAX 256
#define SERVER_HOST "localhost"
#define SERVER_PORT 1234

struct sockaddr_in server_addr;
int sock, r;

int client_init() {
    printf("================ client init =================\n");

    // 1. Create a TCP socket
    printf("1 : create a TCP socket\n");
    sock = socket(AF_INET, SOCK_STREAM, 0);
    if (sock < 0) {
        perror("socket call failed");
        exit(1);
    }

    // 2. Fill server_addr with server's IP and PORT#
    printf("2 : fill server_addr with server's IP and PORT#\n");
    memset((char*)&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY); // Use localhost
    server_addr.sin_port = htons(SERVER_PORT);

    // 3. Connect to server
    printf("3 : connecting to server ...\n");
    r = connect(sock, (struct sockaddr*)&server_addr, sizeof(server_addr));
    if (r < 0) {
        perror("connect failed");
        exit(3);
    }

    printf("4 : connected OK to\n");
    printf("-----------------------------\n");
    printf("Server hostname=%s PORT=%d\n", SERVER_HOST, SERVER_PORT);
    printf("-----------------------------\n");
    printf("================ init done ================\n");
}

int main() {
    int n;
    char line[MAX], ans[MAX];
    client_init();
    printf("********** processing loop ************\n");

    while (1) {
        printf("input a line : ");
        bzero(line, MAX); // Zero out line[]
        fgets(line, MAX, stdin); // Get a line from stdin
        line[strlen(line) - 1] = '\0'; // Kill \n at end

        if (line[0] == '\0') // Exit if NULL line
            exit(0);

        // Send line to server
        n = write(sock, line, MAX);
        printf("client: wrote n=%d bytes; line=%s\n", n, line);

        // Read a line from sock and show it
        n = read(sock, ans, MAX);
        printf("client: read n=%d bytes; echo=%s\n", n, ans);
    }

    return 0;
}

发表于 2023-11-26 11:01 20211401 阅读(2) 评论(0) 编辑收藏举报

学习笔记11