目录
一、网络采用分层的思想：
二、各层典型的协议：
三、网络的封包和拆包：
四、网络编程的预备知识
4.1.SOCKET
4.2 IP地址
4.3 端口号
4.4 字节序
五、TCP编程API
一、网络采用分层的思想：
1.每一层实现不同的功能，对上册的数据做透明传输
2. 每一层向上层提供服务，同时使用下层提供的服务
令牌环网：WIFI、 光纤。
FDDI：GPRS、3G、4G。
底层：Linux内核层
FTP：传输文件
SMTP：传输邮件
TCP/IP协议分为哪四层，具体作用是什么——仅用于个人学习收藏分享_- Demon的博客-CSDN博客_tcp/ip协议包含哪几层
二、各层典型的协议：
1. 网络接口与物理层
MAC地址： 48位全球唯一，网络设备的身份标识
ARP/RARP:
ARP: IP地址----->MAC地址
RARP: MAC地址--->IP地址
PPP协议： 拨号协议（GPRS/3G/4G）
网络层：
IP地址
IP: Internet protocol(分为IPV4和IPV6)
ICMP: Internet控制管理协议，ping命令属于ICMP
IGMP: Internet分组管理协议，广播、组播
传输层：
TCP: (Transfer Control protocol，传输控制协议) 提供面向连接的，一对一的可靠数据传输的协议
即数据无误、数据无丢失、数据无失序、数据无重复到达的通信
UDP: (user Datagram Protocol， 用户数据报协议)： 提供不可靠，无连接的尽力传输协议
是不可靠的无连接的协议。在数据发送前，因为不需要进行连接，所以可以进行高效率的数据传输。
SCTP： 是可靠传输，是TCP的增强版，它能实现多主机、多链路的通信（军方使用）
流控制传输协议_百度百科
应用层：
网页访问协议：HTTP/HTTPS
邮件发送接收协议： POP3（收）/SMTP(发) 、IMAP（可接收邮件的一部分)
FTP（采用TCP的）,
Telnet/SSH: 远程登录 （不太一样，前者是明文的，后者是加密的）
嵌入式相关：
NTP: 网络时钟协议
SNMP: 简单网络管理协议（实现对网络设备集中式管理）
RTP/RTSP：用传输音视频的协议（安防监控）
三、网络的封包和拆包：
TCP和FTP之间用socket（系统调用）编程实现
不断在数据前面加头部，在加上最后一个硬件头部后和CRC验证后，通过驱动来发给以太网或者网卡硬件设备来发送
这就是一个以太网包 App加DATA就是FTP
MSS和MTU
最大传输单元_百度百科
MSS（最大报文段长度）_百度百科
路由器和交换机
路由器与交换机基本原理_sj7575的博客-CSDN博客_交换机和路由器工作原理
请问交换机和路由器分别的实现原理是什么？分别在哪个层次上面实现的？_keepingstudying的博客-CSDN博客_请问交换机和路由器分别的实现原理是什么?分别在哪个层次上面实现的?
四、网络编程的预备知识
4.1.SOCKET
4.1.1 socket是一个应用编程的接口，它是一种特殊的文件描述符（对它执行IO的操作函数，比如,read(),write(),close()等操作函数）
4.1.2 socket代表着网络编程的一种资源
4.1.3 socket的类型：
|
流式套接字(SOCK_STREAM)： 唯一对应着TCP
提供了一个面向连接、可靠的数据传输服务，数据无差错、无重复的发送且按发送顺序接收。内设置流量控制，避免数据流淹没慢的接收方。数据被看作是字节流，无长度限制。
数据报套接字(SOCK_DGRAM)： 唯一对应着UDP
提供无连接服务。数据包以独立数据包的形式被发送，不提供无差错保证，数据可能丢失或重复，顺序发送，可能乱序接收。
原始套接字(SOCK_RAW)：（对应着多个协议，发送穿透了传输层） 可以对较低层次协议如IP、ICMP直接访问。 |
4.2 IP地址
1.IP地址分为IPV4和IPV6
IPV4:采用32位的整数来表示
IPV6：采用了128位整数来表示
mobileIPV6: local IP(本地注册的IP)，roam IP(漫游IP)
IPV4地址：
点分形式： 192.168.7.246
32位整数
特殊IP地址:
局域网IP: 192.XXX.XXX.XXX 10.XXX.XXX.XXX
广播IP: xxx.xxx.xxx.255, 255.255.255.255(全网广播)
组播IP: 224.XXX.XXX.XXX~239.xxx.xxx.xxx
4.3 端口号
16位的数字（1-65535）
众所周知端口： 1~1023（FTP: 21，SSH： 22， HTTP:80， HTTPS:469）
保留端口： 1024-5000（不建议使用）
可以使用的：5000~65535
TCP端口和UDP端口是相互独立的
网络里面的通信是由 IP地址+端口号 来决定
ip数据流走向图解(图)_JasonTome的博客-CSDN博客_ip数据流
4.4 字节序
字节序是指不同的CPU访问内存中的多字节数据时候，存在大小端（字节序）问题
如CPU访问的是字符串，则不存在大小端问题
一般来说：
X86/ARM： 小端
powerpc（摩托罗拉的）/mips, ARM作为路由器时，大端模式
网络传输的时候采用大端模式
=====
本地字节序、网络字节序
IP地址转换函数：
in_addr_t inet_addr(const char *cp);
cp: 点分形式的IP地址，结果是32位整数（内部包含了字节序的转换，默认是网络字节序的模式）
特点： 1. 仅适应于IPV4
2. 当出错时，返回-1
3.此函数不能用于255.255.255.255的转换
inet_pton()/inet_ntop()
特点： 1.适应于IPV4和IPV6
2.能正确的处理255.255.255.255的转换问题
参数：
1. af: 地址协议族（AF_INET或AF_INET6）
2.src:是一个指针（填写点分形式的IP地址[主要指IPV4]）
3.dst: 转换的结果给到dst
RETURN VALUE
inet_pton() returns 1 on success (network address was successfully con‐
verted). 0 is returned if src does not contain a character string representing a valid network address in the specified address family. If af does not contain a valid address family, -1 is returned and errno is set to EAFNOSUPPORT.
五、TCP编程API
1.socket()函数
1.1 参数：
1.domain:
AF_INET IPv4 Internet protocols ip(7)
AF_INET6 IPv6 Internet protocols ipv6(7)
AF_UNIX, AF_LOCAL Local communication unix(7)
AF_NETLINK Kernel user interface device netlink(7)
AF_PACKET Low level packet interface packet(7)
2.type:
SOCK_STREAM: 流式套接字 唯一对应于TCP
SOCK_DGRAM： 数据报套接字，唯一对应着UDP
SOCK_RAW： 原始套接字
3.protocol: 一般填0，原始套接字编程时需填充
1.2 返回值：
RETURN VALUE
On success, a file descriptor for the new socket is returned. On
error, -1 is returned, and errno is set appropriately.
成功时返回文件描述符，出错时返回为-1
2.bind()函数
2.1 参数：
sockfd: 通过socket()函数拿到的fd
addr: struct sockaddr的结构体变量的地址
addrlen: 地址长度
RETURN VALUE
On success, zero is returned. On error, -1 is returned, and errno is set appropriately.
示例代码：
如果是IPV6的编程，要使用struct sockddr_in6结构体（详细情况请参考man 7 ipv6）,通常更通用的方法可以通过struct sockaddr_storage来编程
3.listen()函数: 把主动套接字变成被动套接字
参数：
sockfd: 通过socket()函数拿到的fd
backlog： 同时允许几路客户端和服务器进行正在连接的过程（正在三次握手）
一般填5， 测试得知,ARM最大为8
TCP需要三次握手建立连接之后才能传输数据，所以使用TCP原始套接字传输数据需要先完成三次握手：
第一次握手：客户端TCP头部 SYN位至为1 给定seq位的值
第二次握手：服务端返回SYN+ACK(0x012)，ack_seq 为客户端第一次握手的seq位+1，并且会随机一个seq位值
第三次握手：客户端需要获取到服务端响应seq位的值，将其+1，存入TCP头部ack_seq位中，seq位同样+1
原始套接字构建 TCP三次握手 及相关问题_CodeGuN的博客-CSDN博客
|
内核中服务器的套接字fd会维护2个链表： 1. 正在三次握手的的客户端链表(数量=2*backlog+1) ２.已经建立好连接的客户端链表（已经完成３次握手分配好了newfd） |
比如：listen(fd, 5); //表示系统允许11(=2*5+1)个客户端同时进行三次握手
返回值：
RETURN VALUE
On success, zero is returned. On error, -1 is returned, and errno is set appropriately.
4.accept(): 阻塞等待客户端连接请求
４.１ 参数：
sockfd: 经过前面socket()创建并通过bind(),listen()设置过的fd
addr和addrlen: 获取连接过来的客户的信息
4.2 返回值：
RETURN VALUE
On success, these system calls return a nonnegative integer that is a descriptor for the accepted socket. On
error, -1 is returned, and errno is set appropriately.
成功时返回已经建立好连接的新的newfd
5.客户端的连接函数 connect()
connect()函数和服务器的bind()函数写法类似：
5.1 参数：
sockfd: 通过socket()函数拿到的fd
addr: struct sockaddr的结构体变量的地址
addrlen: 地址长度
5.2 返回值：
RETURN VALUE
If the connection or binding succeeds, zero is returned. On error, -1
is returned, and errno is set appropriately.
实验程序
#ifndef __NET_H__
#define __NET_H__
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <strings.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <errno.h>
#include <stdlib.h>
#include <arpa/inet.h>
#define SERV_PORT 5001
#define SERV_IP_ADDR "192.168.26.128"
#define BACKLOG 5
#define QUIT_STR "quit"
#endif#include "net.h"
int main(void)
{
int fd = -1;
struct sockaddr_in sin;
/* 1. 创建socket fd*/
if( (fd = socket(AF_INET,SOCK_STREAM, 0)) < 0) {
perror("socket");
exit(1);
}
/*2.连接服务器 */
/*2.1 填充struct sockaddr_in结构体变量 */
bzero(&sin,sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_port = htons(SERV_PORT); //网络字节序的端口号
#if 0
sin.sin_addr.s_addr = inet_addr(SERV_IP_ADDR);
#else
if( inet_pton(AF_INET, SERV_IP_ADDR, (void *)&sin.sin_addr) != 1) {
perror("inet_pton");
exit(1);
}
#endif
if( connect(fd, (struct sockaddr *)&sin, sizeof(sin)) < 0) {
perror("connect");
exit(1);
}
printf("Client staring...OK!\n");
/*3. 读写数据 */
char buf[BUFSIZ];
int ret = -1;
while(1) {
bzero(buf, BUFSIZ);
if( fgets(buf, BUFSIZ-1, stdin) ==NULL) {
continue;
}
do {
ret = write(fd, buf, strlen(buf));
}while(ret < 0 && EINTR == errno);
if( !strncasecmp(buf, QUIT_STR, strlen(QUIT_STR))) { //用户输入了quit字符
printf("Client is exiting!\n");
break;
}
}
/*4.关闭套接字 */
close(fd);
}
#include "net.h"
int main()
{
int fd = -1;
struct sockaddr_in sin;
//创建socket fd*
if((fd = socket(AF_INET,SOCK_STREAM, 0)) < 0){
perror("socket");
//return -1;
exit(1);
}
//绑定
//填充struct socketddr_in结构体变量
bzero(&sin,sizeof(sin));//把sin全填充0
sin.sin_family = AF_INET;
sin.sin_port = htons(SERV_PORT); //网络字节端口号
#if 0
sin.sin_addr.s_addr = inet_addr(SERV_IP_ADDR);
#else
if( inet_pton(AF_INET,SERV_IP_ADDR,(void *)&sin.sin_addr) != 1){
perror("inet_pton");
exit(1);
}
#endif
//绑定
if(bind(fd, (struct sockaddr *)&sin, sizeof(sin)) < 0) {
perror("bind");
exit(1);
}
//调用listen()把主动套接字变成被动套接字
if(listen(fd,BACKLOG) < 0 ){
perror("listen");
exit(1);
}
printf("Server starting...OK!\n");
int newfd = -1;
//阻塞等待客户端连接
newfd = accept(fd, NULL, NULL);
if(newfd < 0){
perror("accept");
exit(1);
}
//5读写
//..和newfd进行数据读写
int ret = -1;
char buf[BUFSIZ];
bzero(buf,BUFSIZ);
while(1){
// bzero(buf, BUFSIZ);
do {
ret = read(newfd, buf, BUFSIZ - 1);
}while(ret < 0 && EINTR == errno);
if(ret < 0) {
perror("read");
exit(1);
}
if(!ret) {
break;
}
printf("Receive data: %s\n", buf);
if(!strncasecmp(buf,QUIT_STR, strlen(QUIT_STR))) { // 用户输入了quit字符
printf("Client is exiting!\n");
break;
}
}
close(newfd);
close(fd);
return 0;
}
运行结果：
现在还有一个问题换了机器后需要改程序把ip换成新机器的
sin.sin_addr.s_addr = htonl(INADDR_ANY);//INADDR_ANY = -1
这样就可以绑定在任意ip上，htonl将本地字节序转化为网络字节序，INADDR_ANY = -1但是机器存的其实是全1，虽然大端字序小端字序一样但是这样写更严谨一些，这样写程序可以在任意一台机器运行，并且从同台机器的不同网卡接收到的信息都可处理。
htonl(),htons(),ntohl(),ntons()--大小端模式转换函数 - 功夫 熊猫 - 博客园
优化一下服务器和客户端：
客户端：
/*./client serv_ip serv_port */
#include "net.h"
void usage (char *s)
{
printf ("\n%s serv_ip serv_port", s);
printf ("\n\t serv_ip: server ip address");
printf ("\n\t serv_port: server port(>5000)\n\n");
}
int main (int argc, char **argv)
{
int fd = -1;
int port = -1;
struct sockaddr_in sin;
if (argc != 3) {
usage (argv[0]);
exit (1);
}
/* 1. 创建socket fd */
if ((fd = socket (AF_INET, SOCK_STREAM, 0)) < 0) {
perror ("socket");
exit (1);
}
port = atoi (argv[2]);
if (port < 5000) {
usage (argv[0]);
exit (1);
}
/*2.连接服务器 */
/*2.1 填充struct sockaddr_in结构体变量 */
bzero (&sin, sizeof (sin));
sin.sin_family = AF_INET;
sin.sin_port = htons (port); //网络字节序的端口号
#if 0
sin.sin_addr.s_addr = inet_addr (SERV_IP_ADDR);
#else
if (inet_pton (AF_INET, argv[1], (void *) &sin.sin_addr) != 1) {
perror ("inet_pton");
exit (1);
}
#endif
if (connect (fd, (struct sockaddr *) &sin, sizeof (sin)) < 0) {
perror ("connect");
exit (1);
}
printf ("Client staring...OK!\n");
/*3. 读写数据 */
char buf[BUFSIZ];
int ret = -1;
while (1) {
bzero (buf, BUFSIZ);
if (fgets (buf, BUFSIZ - 1, stdin) == NULL) {
continue;
}
do {
ret = write (fd, buf, strlen (buf));
} while (ret < 0 && EINTR == errno);
if (!strncasecmp (buf, QUIT_STR, strlen (QUIT_STR))) { //用户输入了quit字符
printf ("Client is exiting!\n");
break;
}
}
/*4.关闭套接字 */
close (fd);
}
服务器端：
#include "net.h"
void cli_data_handle (void *arg);
int main()
{
int fd = -1;
struct sockaddr_in sin;
//创建socket fd*
if((fd = socket(AF_INET,SOCK_STREAM, 0)) < 0){
perror("socket");
//return -1;
exit(1);
}
/*优化4： 允许绑定地址快速重用 */
int b_reuse = 1;
setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, &b_reuse, sizeof (int));
//绑定
//填充struct socketddr_in结构体变量
bzero(&sin,sizeof(sin));//把sin全填充0
sin.sin_family = AF_INET;//地址族网际网区域
sin.sin_port = htons(SERV_PORT); //网络字节端口号
//优化使server可以绑定在任意IP上
#if 1
sin.sin_addr.s_addr = htonl(INADDR_ANY);//INADDY_ANY = -1
#else
if( inet_pton(AF_INET,SERV_IP_ADDR,(void *)&sin.sin_addr) != 1){
perror("inet_pton");
exit(1);
}
#endif
//绑定
if(bind(fd, (struct sockaddr *)&sin, sizeof(sin)) < 0) {
perror("bind");
exit(1);
}
//调用listen()把主动套接字变成被动套接字
if(listen(fd,BACKLOG) < 0 ){
perror("listen");
exit(1);
}
printf("Server starting...OK!\n");
int newfd = -1;
//阻塞等待客户端连接
#if 0
newfd = accept(fd, NULL, NULL);
if(newfd < 0){
perror("accept");
exit(1);
}
#else
//通过程序获取刚建立连接的socket客户端的ip地址和端口号
pthread_t tid;
struct sockaddr_in cin;
socklen_t addrlen = sizeof (cin);
while (1) {
if ((newfd = accept (fd, (struct sockaddr *) &cin, &addrlen)) < 0) {
perror ("accept");
exit (1);
}
char ipv4_addr[16];
if (!inet_ntop (AF_INET, (void *) &cin.sin_addr, ipv4_addr, sizeof (cin))) {
perror ("inet_ntop");
exit (1);
}
printf ("Clinet(%s:%d) is connected!\n", ipv4_addr, htons (cin.sin_port));
pthread_create (&tid, NULL, (void *) cli_data_handle, (void *) &newfd);
}
close (fd);
return 0;
}
#endif
void cli_data_handle (void *arg)
{
int newfd = *(int *) arg;
printf ("handler thread: newfd =%d\n", newfd);
//..和newfd进行数据读写
int ret = -1;
char buf[BUFSIZ];
while (1) {
bzero (buf, BUFSIZ);
do {
ret = read (newfd, buf, BUFSIZ - 1);
} while (ret < 0 && EINTR == errno);
if (ret < 0) {
perror ("read");
exit (1);
}
if (!ret) { //对方已经关闭
break;
}
printf ("Receive data: %s\n", buf);
if (!strncasecmp (buf, QUIT_STR, strlen (QUIT_STR))) { //用户输入了quit字符
printf ("Client(fd=%d) is exiting!\n", newfd);
break;
}
}
close (newfd);
}
结果：
下面试试多进程服务器
#include <pthread.h>
#include <signal.h>
#include "net.h"
void cli_data_handle (void *arg);
void sig_child_handle(int signo)
{
if(SIGCHLD == signo) {
waitpid(-1, NULL, WNOHANG);
}
}
int main (void)
{
int fd = -1;
struct sockaddr_in sin;
signal(SIGCHLD, sig_child_handle);
/* 1. 创建socket fd */
if ((fd = socket (AF_INET, SOCK_STREAM, 0)) < 0) {
perror ("socket");
exit (1);
}
/*优化4： 允许绑定地址快速重用 */
int b_reuse = 1;
setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, &b_reuse, sizeof (int));
/*2. 绑定 */
/*2.1 填充struct sockaddr_in结构体变量 */
bzero (&sin, sizeof (sin));
sin.sin_family = AF_INET;
sin.sin_port = htons (SERV_PORT); //网络字节序的端口号
/*优化1: 让服务器程序能绑定在任意的IP上 */
#if 1
sin.sin_addr.s_addr = htonl (INADDR_ANY);
#else
if (inet_pton (AF_INET, SERV_IP_ADDR, (void *) &sin.sin_addr) != 1) {
perror ("inet_pton");
exit (1);
}
#endif
/*2.2 绑定 */
if (bind (fd, (struct sockaddr *) &sin, sizeof (sin)) < 0) {
perror ("bind");
exit (1);
}
/*3. 调用listen()把主动套接字变成被动套接字 */
if (listen (fd, BACKLOG) < 0) {
perror ("listen");
exit (1);
}
printf ("Server starting....OK!\n");
int newfd = -1;
/*4. 阻塞等待客户端连接请求 */
struct sockaddr_in cin;
socklen_t addrlen = sizeof (cin);
while(1) {
pid_t pid = -1;
if ((newfd = accept (fd, (struct sockaddr *) &cin, &addrlen)) < 0) {
perror ("accept");
break;
}
/*创建一个子进程用于处理已建立连接的客户的交互数据*/
if((pid = fork()) < 0) {
perror("fork");
break;
}
if(0 == pid) { //子进程中
close(fd);
char ipv4_addr[16];
if (!inet_ntop (AF_INET, (void *) &cin.sin_addr, ipv4_addr, sizeof (cin))) {
perror ("inet_ntop");
exit (1);
}
printf ("Clinet(%s:%d) is connected!\n", ipv4_addr, ntohs(cin.sin_port));
cli_data_handle(&newfd);
return 0;
} else { //实际上此处 pid >0, 父进程中
close(newfd);
}
}
close (fd);
return 0;
}
void cli_data_handle (void *arg)
{
int newfd = *(int *) arg;
printf ("Child handling process: newfd =%d\n", newfd);
//..和newfd进行数据读写
int ret = -1;
char buf[BUFSIZ];
while (1) {
bzero (buf, BUFSIZ);
do {
ret = read (newfd, buf, BUFSIZ - 1);
} while (ret < 0 && EINTR == errno);
if (ret < 0) {
perror ("read");
exit (1);
}
if (!ret) { //对方已经关闭
break;
}
printf ("Receive data: %s\n", buf);
if (!strncasecmp (buf, QUIT_STR, strlen (QUIT_STR))) { //用户输入了quit字符
printf ("Client(fd=%d) is exiting!\n", newfd);
break;
}
}
close (newfd);
}
![[附源码]java毕业设计社区健康服务平台管理系统lunwen](https://img-blog.csdnimg.cn/46631ce80b8a41a99f6f28cfd9e913e5.png)
![[附源码]java毕业设计人口老龄化社区服务与管理平台](https://img-blog.csdnimg.cn/5752d36f256241b291fd5f8cb759171e.png)
