A. 网络编程（五）TCP详解
考虑最简单的情况：两台主机之间的通信。这个时候只需要一条网线把两者连起来，规定好彼此的硬件接口，如都用 USB、电压 10v、频率 2.4GHz 等， 这一层就是物理层，这些规定就是物理层协议 。
我们当然不满足于只有两台电脑连接，因此我们可以使用交换机把多个电脑连接起来，如下图：
这样连接起来的网络，称为局域网，也可以称为以太网（以太网是局域网的一种）。在这个网络中，我们需要标识每个机器，这样才可以指定要和哪个机器通信。这个标识就是硬件地址 MAC。
硬件地址随机器的生产就被确定，永久性唯一。在局域网中，我们需要和另外的机器通信时，只需要知道他的硬件地址，交换机就会把我们的消息发送到对应的机器。
这里我们可以不管底层的网线接口如何发送，把物理层抽离，在他之上创建一个新的层次，这就是 数据链路层 。
我们依然不满足于局域网的规模，需要把所有的局域网联系起来，这个时候就需要用到路由器来连接两个局域网：
但是如果我们还是使用硬件地址来作为通信对象的唯一标识，那么当网络规模越来越大，需要记住所有机器的硬件地址是不现实的；
同时，一个网络对象可能会频繁更换设备，这个时候硬件地址表维护起来更加复杂。这里使用了一个新的地址来标记一个网络对象： IP 地址 。
通过一个简单的寄信例子来理解 IP 地址。
我住在北京市，我朋友 A 住在上海市，我要给朋友 A 写信：
因此，这里 IP 地址就是一个网络接入地址（朋友 A 的住址），我只需要知道目标 IP 地址，路由器就可以把消息给我带到。 在局域网中，就可以动态维护一个 MAC 地址与 IP 地址的映射关系，根据目的 IP 地址就可以寻找到机器的 MAC 地址进行发送 。
这样我们不需管理底层如何去选择机器，我们只需要知道 IP 地址，就可以和我们的目标进行通信。这一层就是 网络层 。网络层的核心作用就是 提供主机之间的逻辑通信 。
这样，在网络中的所有主机，在逻辑上都连接起来了，上层只需要提供目标 IP 地址和数据，网络层就可以把消息发送到对应的主机。
一个主机有多个进程，进程之间进行不同的网络通信，如边和朋友开黑边和女朋友聊微信。我的手机同时和两个不同机器进行通信。
那么当我的手机收到数据时，如何区分是微信的数据，还是王者的数据？那么就必须在网络层之上再添加一层： 运输层 ：
运输层通过 socket（套接字），将网络信息进行进一步的拆分，不同的应用进程可以独立进行网络请求，互不干扰。
这就是运输层的最本质特点： 提供进程之间的逻辑通信 。这里的进程可以是主机之间，也可以是同个主机，所以在 android 中，socket 通信也是进程通信的一种方式。
现在不同的机器上的应用进程之间可以独立通信了，那么我们就可以在计算机网络上开发出形形式式的应用：如 web 网页的 http，文件传输 ftp 等等。这一层称为 应用层 。
应用层还可以进一步拆分出表示层、会话层，但他们的本质特点都没有改变： 完成具体的业务需求 。和下面的四层相比，他们并不是必须的，可以归属到应用层中。
最后对计网分层进行小结：
这里需要注意的是，分层并不是在物理上的分层，而是逻辑上的分层。通过对底层逻辑的封装，使得上层的开发可以直接依赖底层的功能而无需理会具体的实现，简便了开发。
这种分层的思路，也就是责任链设计模式，通过层层封装，把不同的职责独立起来，更加方便开发、维护等等。
TCP 并不是把应用层传输过来的数据直接加上首部然后发送给目标，而是把数据看成一个字节 流，给他们标上序号之后分部分发送。这就是 TCP 的 面向字节流 特性：
面向字节流的好处是无需一次存储过大的数据占用太多内存，坏处是无法知道这些字节代表的意义，例如应用层发送一个音频文件和一个文本文件，对于 TCP 来说就是一串字节流，没有意义可言，这会导致粘包以及拆包问题，后面讲。
前面讲到，TCP 是可靠传输协议，也就是，一个数据交给他，他肯定可以完整无误地发送到目标地址，除非网络炸了。他实现的网络模型如下：
对于应用层来说，他就是一个可靠传输的底层支持服务；而运输层底层采用了网络层的不可靠传输。虽然在网络层甚至数据链路层就可以使用协议来保证数据传输的可靠性，但这样网络的设计会更加复杂、效率会随之降低。把数据传输的可靠性保证放在运输层，会更加合适。
可靠传输原理的重点总结一下有： 滑动窗口、超时重传、累积确认、选择确认、连续 ARQ 。
停止等待协议
要实现可靠传输，最简便的方法就是：我发送一个数据包给你，然后你跟我回复收到，我继续发送下一个数据包。传输模型如下：
这种“一来一去”的方法来保证传输可靠就是 停止等待协议 （stop-and-wait）。不知道还记不记得前面 TCP 首部有一个 ack 字段，当他设置为 1 的时候，表示这个报文是一个确认收到报文。
然后再来考虑另一种情况：丢包。网络环境不可靠，导致每一次发送的数据包可能会丢失，如果机器 A 发送了数据包丢失了，那么机器 B 永远接收不到数据，机器 A 永远在等待。
解决这个问题的方法是： 超时重传 。当机器 A 发出一个数据包时便开始计时，时间到还没收到确认回复，就可以认为是发生了丢包，便再次发送，也就是重传。
但重传会导致另一种问题：如果原先的数据包并没有丢失，只是在网络中待的时间比较久，这个时候机器 B 会受到两个数据包，那么机器 B 是如何辨别这两个数据包是属于同一份数据还是不同的数据？
这就需要前面讲过的方法： 给数据字节进行编号 。这样接收方就可以根据数据的字节编号，得出这些数据是接下来的数据，还是重传的数据。
在 TCP 首部有两个字段：序号和确认号，他们表示发送方数据第一个字节的编号，和接收方期待的下一份数据的第一个字节的编号。
停止等待协议的优点是简单，但缺点是 信道利用率 太低。
假定AB之间有一条直通的信道来传送分组
这里的TD是A发送分组所需要的时间（显然TD = 分组长度 / 数据速率）再假定TA是B发送确认分组所需要的时间（A和B处理分组的时间都忽略不计）那么A在经过TD+RTT+TA时间后才能发送下一个分组，这里的RTT是往返时间，因为只有TD是采用来传输有用的数据（这个数据包括了分组首部，如果可以知道传输更精确的数据的时间，可以计算的更精确），所有信道利用率为
为了提高传输效率，发送方可以不使用低效率的停止等待协议，而是采用 流水线传输 ：就是发送方可以 连续的发送多个分组 ，不必每发完一个分组就停下来等待对方的确认。这样可使信道上一直有数据不间断地在传送。显然这种传输方式可以获得很高的信道利用率
停止等待协议已经可以满足可靠传输了，但有一个致命缺点： 效率太低 。发送方发送一个数据包之后便进入等待，这个期间并没有干任何事，浪费了资源。解决的方法是： 连续发送数据包 。
也就是下面介绍的 连续ARQ协议 和 滑动窗口协议
连续 ARQ 协议
模型如下：
和停止等待最大的不同就是，他会源源不断地发送，接收方源源不断收到数据之后，逐一进行确认回复。这样便极大地提高了效率。但同样，带来了一些额外的问题:
发送是否可以无限发送直到把缓冲区所有数据发送完？不可以。因为需要考虑接收方缓冲区以及读取数据的能力。如果发送太快导致接收方无法接受，那么只是会频繁进行重传，浪费了网络资源。所以发送方发送数据的范围，需要考虑到接收方缓冲区的情况。这就是 TCP 的 流量控制 。
解决方法是： 滑动窗口 。基本模型如下：
在 TCP 的首部有一个窗口大小字段，他表示接收方的剩余缓冲区大小，让发送方可以调整自己的发送窗口大小。通过滑动窗口，就可以实现 TCP 的流量控制，不至于发送太快，导致太多的数据丢失。
连续 ARQ 带来的第二个问题是：网络中充斥着和发送数据包一样数据量的确认回复报文，因为每一个发送数据包，必须得有一个确认回复。提高网络效率的方法是： 累积确认 。
接收方不需要逐个进行回复，而是累积到一定量的数据包之后，告诉发送方，在此数据包之前的数据全都收到。例如，收到 1234，接收方只需要告诉发送方我收到 4 了，那么发送方就知道 1234 都收到了。
第三个问题是：如何处理丢包情况。在停止等待协议中很简单，直接一个超时重传就解决了。但，连续 ARQ 中不太一样。
例如：接收方收到了 123 567，六个字节，编号为 4 的字节丢失了。按照累积确认的思路，只能发送 3 的确认回复，567 都必须丢掉，因为发送方会进行重传。这就是 GBN（go-back-n) 思路。
但是我们会发现，只需要重传 4 即可，这样不是很浪费资源，所以就有了： 选择确认 SACK 。在 TCP 报文的选项字段，可以设置已经收到的报文段，每一个报文段需要两个边界来进行确定。这样发送方，就可以根据这个选项字段只重传丢失的数据了。
第四个问题是：拥塞控制的问题
也是通过窗口的大小来控制的，但是检测网络满不满是个挺难的事情，所以 TCP 发送包经常被比喻成往谁管理灌水，所以拥塞控制就是在不堵塞，不丢包的情况下尽可能的发挥带宽。
水管有粗细，网络有带宽，即每秒钟能发送多少数据；水管有长度，端到端有时延。理想状态下，水管里面的水 = 水管粗细 * 水管长度。对于网络上，通道的容量 = 带宽 * 往返时延。
如果我们设置发送窗口，使得发送但未确认的包为通道的容量，就能撑满整个管道。
如图所示，假设往返时间为 8 秒，去 4 秒，回 4 秒，每秒发送一个包，已经过去了 8 秒，则 8 个包都发出去了，其中前四个已经到达接收端，但是 ACK 还没返回，不能算发送成功，5-8 后四个包还在路上，还没被接收，这个时候，管道正好撑满，在发送端，已发送未确认的 8 个包，正好等于带宽，也即每秒发送一个包，也即每秒发送一个包，乘以来回时间 8 秒。
如果在这个基础上调大窗口，使得单位时间可以发送更多的包，那么会出现接收端处理不过来，多出来的包会被丢弃，这个时候，我们可以增加一个缓存，但是缓存里面的包 4 秒内肯定达不到接收端课，它的缺点会增加时延，如果时延达到一定程度就会超时重传
TCP 拥塞控制主要来避免两种现象，包丢失和超时重传，一旦出现了这些现象说明发送的太快了，要慢一点。
具体的方法就是发送端慢启动，比如倒水，刚开始倒的很慢，渐渐变快。然后设置一个阈值，当超过这个值的时候就要慢下来
慢下来还是在增长，这时候就可能水满则溢，出现拥塞，需要降低倒水的速度，等水慢慢渗下去。
拥塞的一种表现是丢包，需要超时重传，这个时候，采用快速重传算法，将当前速度变为一半。所以速度还是在比较高的值，也没有一夜回到解放前。
到这里关于 TCP 的可靠传输原理就已经介绍得差不多。最后进行一个小结：
当然，这只是可靠传输的冰山一角，感兴趣可以再深入去研究
B. 请问一下TCP网络编程有什么特点
TCP网络编程的特点是：
1、由于网络的复杂性，传输信息时，数据包可能会丢失，差错控制中的确认机制在接收到数据包是发送确认信息，若是数据包丢失，则回发数据包编号，让对方重新发送；
2、由于网络的复杂性，传输信息时有多种网络传送途径可以选择，数据包被接收的顺序与发送顺序不同，可以根据数据包的编号，将数据包重组。
3、网络连接是以点对点的形式，加上上述特点，保证了数据的安全性，数据包不会中途被劫。
更多关于TCP网络编程有什么特点，进入：https://m.abcgonglue.com/ask/9271361614909232.html?zd查看更多内容
C. tcp网络编程（C语言）
以下是两个文件.client.c和server.c
server.c
client.c
运行效果如下
D. C语言Linux系统下TCP编程，connect 错误
你的client有问题，连接之前没有指定server的ip。
你只指定了端口。
struct sockaddr_in servaddr;
bzero(&servaddr,sizeof(servaddr));
servaddr.sin_family=AF_INET;
servaddr.sin_port=htons(HELLO_WORLD_SERVER_PORT);
servaddr.sin_addr.s_addr=inet_addr(serverip);//加上server的ip即可
E. 怎么样用出C语言写一个分析TCP/IP报文的程
socket编程写了一个简单的DNS服务器。
是这样实现的，用两台PC，一个做客户端，一个做服务器；
在服务器用socket监视53端口，recvfrom()函数负责接收DNS查询报文，将其存入事先写好的数据结构里；
因为DNS查询报文和应答报文的前部分字段格式都是一样的，只是修改了几个参数，然后重点把DNS应答报文后面的字段进行增添。
然后用sendto()；函数发送就可以了。
在ie里面输入任意的网址，回车，就会触发客户端向服务器发出DNS查询报文，
此时你可以同时在服务器和客户端抓包，看收到的报文是否正确。
注意几点：
1、一定要熟悉报文结构，定义合适的结构体，将报文进行解析
2、一定要注意网络序和主机序的转换htonl(),htons(),ntohl(),ntohs()等
3、找个熟知端口，最好是你熟悉的协议，如ftp，http，dns等。
4、客户端要把DNS服务器配置为你的服务器ip。
F. Windows系统用C语言写TCP通信
#include
#include
#include
#pragma comment(lib,"ws2_32.lib")
typedef struct{
SOCKET accpt;
int lock;
}Arg;
void *transfer(void *arg)
{
Arg * info = (Arg *)arg;
SOCKET clientSock;
char recvbuf[102];
char sendBuf[] = "10";
int ret;
memcpy(&clientSock,(void*)&info->accpt,sizeof(clientSock));
info->lock =1;
while (TRUE)
{
ret = send(clientSock,sendBuf,2,0);
if (ret == -1)
{
break;
}
ret = recv(clientSock,recvbuf,102,0);
printf("%s\n",recvbuf);
}
return (void *)0;
}
void* timer(void *arg)
{
time_t last = time(NULL);
time_t now;
int i = 20;
while(i--)
{
now = time(NULL);
if(now - last == 1)
{
printf("1s past!\n");
last = now;
}
Sleep(500);
}
printf("timer exit.\n");
return (void *)0;
}
int main(void) {
WSADATA wsaData;
SOCKET ListenSocket;
SOCKADDR_IN service,client;
int len = sizeof(client);
Arg argument;
pthread_t tid;
char sendBuf[] = "ID=2;WHAT=host";
int iResult = WSAStartup(MAKEWORD(2,2), &wsaData);
if (iResult != NO_ERROR) {
printf("Error at WSAStartup()\n");
return 1;
}
ListenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (ListenSocket == INVALID_SOCKET) {
printf("Error at socket(): %ld\n", WSAGetLastError());
WSACleanup();
return 1;
}
service.sin_family = AF_INET;
service.sin_addr.s_addr = inet_addr("127.0.0.1");
service.sin_port = htons(27115);
if (bind( ListenSocket,
(SOCKADDR*) &service,
sizeof(service)) == SOCKET_ERROR) {
printf("bind() failed.\n");
closesocket(ListenSocket);
WSACleanup();
return 1;
}
if (listen( ListenSocket, 1 ) == SOCKET_ERROR) {
printf("Error listening on socket.\n");
closesocket(ListenSocket);
WSACleanup();
return 1;
}
argument.lock = 1;
printf("Waiting for client to connect...\n");
pthread_create(&tid,NULL,timer,NULL);
while(TRUE){
argument.accpt = accept( ListenSocket, (SOCKADDR*)&client, &len );
if (argument.accpt == INVALID_SOCKET) {
printf("accept failed: %d\n", WSAGetLastError());
closesocket(ListenSocket);
WSACleanup();
return 1;
} else {
printf("accept%s:%d\n",inet_ntoa(client.sin_addr),client.sin_port);
while (!argument.lock);
argument.lock = 0;
// sendto(argument.accpt,sendBuf,sizeof(sendBuf),0,(SOCKADDR*)&client,len);
pthread_create(&tid,NULL,transfer,&argument);
//send(AcceptSocket,sendBuf,sizeof(sendBuf),0);
}
}
// No longer need server socket
closesocket(ListenSocket);
WSACleanup();
return 0;
}