Ada banyak protokol dalam keluarga protokol. Buku ini hanya memilih protokol IP dan TCP - yang memiliki dampak paling langsung pada pemrograman jaringan.
Tujuh lapisan yang sama adalah model referensi osi. Setelah disederhanakan, empat lapisan berbeda berkomunikasi satu sama lain melalui antarmuka, yang memfasilitasi modifikasi setiap lapisan.
Lapisan aplikasi Bertanggung jawab untuk menangani logika aplikasi
Lapisan presentasi Mendefinisikan format dan enkripsi data
lapisan sesi Ini mendefinisikan cara memulai, mengontrol, dan mengakhiri sesi, termasuk kontrol dan pengelolaan beberapa pesan dua arah, sehingga aplikasi dapat diberitahu ketika hanya sebagian dari pesan berkelanjutan yang diselesaikan, sehingga data yang dilihat oleh lapisan presentasi bersifat kontinu.
lapisan transportasi Menyediakan komunikasi end-to-end untuk aplikasi pada dua host. Berbeda dengan hop berikutnya yang digunakan oleh lapisan jaringan, ia hanya peduli pada awal dan akhir, dan proses transfer diserahkan ke lapisan bawah lapisan ini: Protokol TCP dan protokol UDP Protokol TCP (Protokol Kontrol Transmisi Protokol Kontrol Transmisi)
可靠的, 面向连接, 基于流的服务
ke lapisan aplikasi超时重传
dan数据确认
.不可靠的, 无连接的, 基于数据报的服务
ke lapisan aplikasi数据确认
dan超时重传
.有自己的长度
. lapisan jaringan Ia menyadari perutean dan penerusan paket data. Jika paket data tidak dapat mencapai alamat tujuan, ia akan下一跳
hop berikutnya (hop demi hop) dan memilih protokol IP terdekat (Internet Protocol) dan protokol ICMP (Internet Control Message Protocol). ) . Protokol terakhir Ini adalah pelengkap protokol IP, digunakan untuk mendeteksi koneksi jaringan 1. Pesan kesalahan, digunakan untuk merespons status 2. Pesan kueri (program ping menggunakan pesan ini untuk menentukan apakah informasi telah terkirim)
lapisan tautan data Driver jaringan yang mengimplementasikan antarmuka kartu jaringan. Driver di sini memfasilitasi modifikasi lapisan bawah dari pabrikan dan hanya perlu menyediakan antarmuka yang ditentukan ke lapisan atas. Ada dua protokol : ARP (Address Resolve Protocol, Address Resolusi Protocol) . juga RARP ( Reverse ~, Reverse Address Resolusi Protocol) . Karena lapisan jaringan menggunakan alamat IP untuk menangani mesin, tetapi lapisan data link menggunakan alamat fisik (biasanya alamat MAC), konversi di antara keduanya melibatkan spoofing ARP protokol ARP, yang mungkin berhubungan dengan ini. Tidak sedang belajar saat ini
enkapsulasi Protokol lapisan atas dikirim ke protokol lapisan TCP报文段
. Ini diimplementasikan melalui enkapsulasi. Saat transmisi antar lapisan, informasi headernya sendiri ditambahkan.
Data yang dienkapsulasi oleh UDP menjadi UDP数据报
Setelah dienkapsulasi oleh IP, itu menjadi IP数据报
Terakhir, dienkapsulasi oleh lapisan data link dan menjadi帧
Bingkai data maksimum Ethernet adalah 1518 byte, membuang 14 header dan 4 checksum di akhir bingkai. MTU: Unit transmisi maksimum bingkai umumnya 1500 byte: Beban data maksimum paket TCP adalah 1460 byte = 1500 byte - header 20Ip. -20TCP header memiliki bagian opsional tambahan 40-byte
ARP Protokol ARP dapat mewujudkan konversi alamat lapisan jaringan apa pun ke alamat fisik apa pun.
Protokol IP adalah protokol inti dari rangkaian protokol TCP/IP dan salah satu dasar pemrograman jaringan soket. Protokol IP menyediakan layanan tanpa kewarganegaraan, tanpa koneksi, dan tidak dapat diandalkan untuk protokol lapisan atas.
Panjang maksimum datagram IP adalah 65535 (2^16 - 1) byte, tetapi ada batasan MTU
Ketika panjang datagram IP melebihi MTU, maka akan terfragmentasi untuk transmisi. Fragmentasi dapat terjadi pada pengirim, atau pada router transit, atau mungkin terfragmentasi beberapa kali dirakit kembali oleh modul ip di kernel
mekanisme perutean
Setelah alamat IP target diberikan, item mana dalam tabel routing yang akan dicocokkan? Ada tiga langkah.
Membaca dan menulis Tcp semuanya untuk buffer, jadi tidak ada korespondensi tetap antara jumlah membaca dan menulis.
UDP tidak memiliki buffer. Data harus diterima tepat waktu jika tidak, paket akan hilang, atau jika buffer penerima terlalu kecil, datagram akan terpotong.
ISN - Nilai nomor urut awal Nomor urut 32-bit Nilai nomor urut di segmen pesan TCP berikutnya seq = ISN + Offset byte pertama segmen pesan di seluruh aliran byte Nomor konfirmasi 32-bit Nilai nomor urut dari pesan TCP diterima + 1 . Nomor konfirmasi 32-bit ini dikirim setiap kali respons terakhir.
Bendera ACK: Menunjukkan apakah nomor konfirmasi valid. Segmen pesan yang membawa bendera ACK disebut确认报文段
. Bendera PSH: Meminta aplikasi penerima untuk membaca data dari buffer penerimaan TCP untuk memberikan ruang bagi data berikutnya. Persyaratan Pihak lain membangun kembali koneksi dan membawa...复位报文段
SYN flag: flag meminta untuk membuat koneksi dan membawa...同步报文段
FIN flag: memberi tahu pihak lain bahwa koneksi lokal akan ditutup , dan membawa...结束报文段
Ukuran jendela 16-bit: Jendela mengacu pada jendela pemberitahuan penerimaan, yang memberi tahu pihak lain berapa banyak byte data yang dapat ditampung oleh buffer penerima TCP lokal. Checksum 16-bit:可靠传输的重要保障
dan pihak penerima melakukan verifikasi algoritma CRC. Periksa apakah rusak, dan periksa TCP头部
dan数据部分
pada saat yang bersamaan
Pembentukan dan penutupan koneksi TCP
# 三次握手
# 客户端发送请求连接 ISN= seq + 0 = 3683340920
# mss 最大数据载量1460
IP 192 . 168 . 80 . 1 . 7467 > ubuntu. 8000 :
Flags [S], seq 3683340920 , win 64240 ,
options [mss 1460 , nop ,wscale 8 , nop , nop ,sackOK], length 0
# 同意客户端连接
# ack = 客户端发送 seq + 1
# 同时发送服务端的seq
IP ubuntu. 8000 > 192 . 168 . 80 . 1 . 7467 :
Flags [S.], seq 938535101 , ack 3683340921 , win 64240 ,
options [mss 1460 , nop , nop ,sackOK, nop ,wscale 7 ], length 0
# 虽然这个报文段没有字节 但由于是同步报文段 需要占用一个序号值
# 这里是tcpdump的处理 ack显示相对值 即 3683340921 - 3683340920 = 1
IP 192 . 168 . 80 . 1 . 7467 > ubuntu. 8000 :
Flags [.], ack 938535102 , win 4106 , length 0
# 包含FIN标志 说明要求结束连接 也需要占用一个序号值
IP 192 . 168 . 80 . 1 . 7467 > ubuntu. 8000 :
Flags [F.], seq 1 , ack 1 , win 4106 , length 0
# 服务端确认关闭连接
IP ubuntu. 8000 > 192 . 168 . 80 . 1 . 7467 :
Flags [.], ack 2 , win 502 , length 0
# 服务端发送关闭连接
IP ubuntu. 8000 > 192 . 168 . 80 . 1 . 7467 :
Flags [F.], seq 1 , ack 2 , win 4105 , length 0
# 客户端确认
IP 192 . 168 . 80 . 1 . 7467 > ubuntu. 8000 :
Flags [.], ack 2 , win 503 , length 0
API soket dasar terletak di file header sys/socket.h
. Arti awal soket adalah alamat IP dan pasangan port. Satu-satunya informasi jaringan yang mewakili komunikasi TCP ada di file header netdb.h
.
Urutan byte dibagi menjadi大端字节序
dan小端字节序
Karena sebagian besar PC menggunakan urutan byte little-endian (bit tinggi ada di alamat tinggi), urutan byte little-endian juga disebut urutan byte host.
Untuk mencegah kebingungan yang disebabkan oleh urutan byte yang berbeda dari mesin yang berbeda, ditetapkan bahwa transmisi harus disatukan ke dalam urutan byte big-endian (urutan byte jaringan). untuk mengonversi urutan byte data yang diterima
koneksi dasar
// 主机序和网络字节序转换
# include < netinet/in.h >
unsigned long int htonl ( unsigned long int hostlong); // host to network long
unsigned short int htons ( unsigned short int hostlong); // host to network short
unsigned long int htonl ( unsigned long int netlong);
unsigned short int htons ( unsigned short int netlong);
// IP地址转换函数
# include < arpa/inet.h >
// 将点分十进制字符串的IPv4地址, 转换为网络字节序整数表示的IPv4地址. 失败返回INADDR_NONE
in_addr_t inet_addr ( const char * strptr);
// 功能相同不过转换结果存在 inp指向的结构体中. 成功返回1 反之返回0
int inet_aton ( const char * cp, struct in_addr * inp);
// 函数返回一个静态变量地址值, 所以多次调用会导致覆盖
char * inet_ntoa ( struct in_addr in);
// src为 点分十进制字符串的IPv4地址 或 十六进制字符串表示的IPv6地址 存入dst的内存中 af指定地址族
// 可以为 AF_INET AF_INET6 成功返回1 失败返回-1
int inet_pton ( int af, const char * src, void * dst);
// 协议名, 需要转换的ip, 存储地址, 长度(有两个常量 INET_ADDRSTRLEN, INET6_ADDRSTRLEN)
const char * inet_ntop ( int af, const void * src, char * dst, socklen_t cnt);
// 创建 命名 监听 socket
# include < sys/types.h >
# include < sys/socket.h >
// domain指定使用那个协议族 PF_INET PF_INET6
// type指定服务类型 SOCK_STREAM (TCP协议) SOCK_DGRAM(UDP协议)
// protocol设置为默认的0
// 成功返回socket文件描述符(linux一切皆文件), 失败返回-1
int socket ( int domain, int type, int protocol);
// socket为socket文件描述符
// my_addr 为地址信息
// addrlen为socket地址长度
// 成功返回0 失败返回 -1
int bind ( int socket, const struct sockaddr * my_addr, socklen_t addrlen);
// backlog表示队列最大的长度
int listen ( int socket, int backlog);
// 接受连接 失败返回-1 成功时返回socket
int accept ( int sockfd, struct sockaddr * addr, socklen_t * addrlen)
klien
// 发起连接
#include <sys/types.h>
#include <sys/socket.h>
// 第三个参数为 地址指定的长度
// 成功返回0 失败返回-1
int connect ( int sockfd , const struct sockaddr * serv_addr , socklen_t addrlen );
// 关闭连接
#include <unistd.h>
// 参数为保存的socket
// 并非立即关闭, 将socket的引用计数-1, 当fd的引用计数为0, 才能关闭(需要查阅)
int close ( int fd );
// 立即关闭
#include <sys/socket.h>
// 第二个参数为可选值
// SHUT_RD 关闭读, socket的接收缓冲区的数据全部丢弃
// SHUT_WR 关闭写 socket的发送缓冲区全部在关闭前发送出去
// SHUT_RDWR 同时关闭读和写
// 成功返回0 失败为-1 设置errno
int shutdown ( int sockfd , int howto )
TCP dasar
#include <sys/socket.h>
#include <sys/types.h>
// 读取sockfd的数据
// buf 指定读缓冲区的位置
// len 指定读缓冲区的大小
// flags 参数较多
// 成功的时候返回读取到的长度, 可能小于预期长度, 需要多次读取. 读取到0 通信对方已经关闭连接, 错误返回-1
ssize_t recv ( int sockfd , void * buf , size_t len , int flags );
// 发送
ssize_t send ( int sockfd , const void * buf , size_t len , int flags );
nama opsi | arti | Tersedia untuk dikirim | tersedia untuk diterima |
---|---|---|---|
MSG_CONFIRM | Menginstruksikan protokol lapisan tautan untuk terus mendengarkan hingga balasan diterima (Hanya dapat digunakan untuk soket tipe SOCK_DGRAM dan SOCK_RAW) | Y | N |
MSG_DONTROUTE | Tanpa memeriksa tabel routing, data dikirim langsung ke host LAN lokal (artinya pengirim mengetahui bahwa host target ada di jaringan lokal) | Y | N |
MSG_JANGAN TUNGGU | non-pemblokiran | Y | Y |
MSG_LEBIH LANJUT | Beri tahu kernel bahwa ada lebih banyak data yang akan dikirim, dan tunggu hingga data ditulis ke dalam buffer sebelum mengirimkan semuanya secara bersamaan. Kurangi pesan singkat dan tingkatkan efisiensi transmisi. | Y | N |
MSG_TUNGGU | Operasi baca menunggu hingga byte yang ditentukan dibaca sebelum dikembalikan. | N | Y |
MSG_PEEK | Lihatlah data cache internal, itu tidak akan mempengaruhi data | N | Y |
MSG_OOB | Mengirim atau menerima data darurat | Y | Y |
MSG_NOSIGNAL | Menulis data ke sambungan pipa atau soket baca-tertutup tidak akan memicu sinyal SIGPIPE. | Y | N |
UDP Dasar
#include <sys/types.h>
#include <sys/socket.h>
// 由于UDP不保存状态, 每次发送数据都需要 加入目标地址.
// 不过recvfrom和sendto 也可以用于 面向STREAM的连接, 这样可以省略发送和接收端的socket地址
ssize_t recvfrom ( int sockfd , void * buf , size_t len , int flags , struct sockaddr * src_addr , socklen_t * addrlen );
ssize_t sendto ( int sockfd , const void * buf , size_t len , ing flags , const struct sockaddr * dest_addr , socklen_t addrlen );
Fungsi baca dan tulis umum
#inclued <sys/socket.h>
ssize_t recvmsg ( int sockfd , struct msghdr * msg , int flags );
ssize_t sendmsg ( int sockfd , struct msghdr * msg , int flags );
struct msghdr
{
/* socket address --- 指向socket地址结构变量, 对于TCP连接需要设置为NULL*/
void * msg_name ;
socklen_t msg_namelen ;
/* 分散的内存块 --- 对于 recvmsg来说数据被读取后将存放在这里的块内存中, 内存的位置和长度由
* msg_iov指向的数组指定, 称为分散读(scatter read) ---对于sendmsg而言, msg_iovlen块的分散内存中
* 的数据将一并发送称为集中写(gather write);
*/
struct iovec * msg_iov ;
int msg_iovlen ; /* 分散内存块的数量*/
void * msg_control ; /* 指向辅助数据的起始位置*/
socklen_t msg_controllen ; /* 辅助数据的大小*/
int msg_flags ; /* 复制函数的flags参数, 并在调用过程中更新*/
};
struct iovec
{
void * iov_base /* 内存起始地址*/
size_t iov_len /* 这块内存长度*/
}
API lainnya
#include <sys/socket.h>
// 用于判断 sockfd是否处于带外标记, 即下一个被读取到的数据是否是带外数据,
// 是的话返回1, 不是返回0
// 这样就可以选择带MSG_OOB标志的recv调用来接收带外数据.
int sockatmark ( int sockfd );
// getsockname 获取sockfd对应的本端socket地址, 存入address指定的内存中, 长度存入address_len中 成功返回0失败返回-1
// getpeername 获取远端的信息, 同上
int getsockname ( int sockfd , struct sockaddr * address , socklen_t * address_len );
int getpeername ( int sockfd , struct sockaddr * address , socklen_t * address_len );
/* 以下函数头文件均相同*/
// sockfd 目标socket, level执行操作协议(IPv4, IPv6, TCP) option_name 参数指定了选项的名字. 后面值和长度
// 成功时返回0 失败返回-1
int getsockopt ( int sockfd , int level , int option_name , void * option_value ,
socklen_t restrict option_len );
int setsockopt ( int sockfd , int level , int option_name , void * option_value ,
socklen_t restrict option_len );
JADI_REUSEADDR | Gunakan kembali alamat lokal | Setelah kaus kaki disetel dengan atribut ini, meskipun kaus kaki berada dalam status TIME_WAIT setelah diikat(), alamat soket yang terikat padanya masih dapat segera digunakan kembali untuk mengikat kaus kaki baru. |
---|---|---|
JADI_RCVBUF | TCP menerima ukuran buffer | Nilai minimumnya adalah 256 byte. Setelah pengaturan, sistem akan secara otomatis menggandakan nilai yang Anda tetapkan. |
JADI_SNDBUF | TCP mengirim ukuran buffer | Nilai minimumnya adalah 2048 byte |
JADI_RCVLOWAT | Menerima tanda air rendah | Standarnya adalah 1 byte. Ketika jumlah total data yang dapat dibaca dalam buffer penerimaan TCP lebih besar dari tanda air rendahnya, panggilan sistem multipleks IO akan memberi tahu aplikasi bahwa data dapat dibaca dari soket yang sesuai. |
JADI_SNDLOWAT | tanda air tinggi dikirim | Standarnya adalah 1 byte. Data dapat ditulis ketika ruang kosong di buffer pengiriman TCP lebih besar dari tanda air rendah. |
JADI_LINGER |
struct linger
{
int l_onoff /* 开启非0, 关闭为0*/
int l_linger ; /* 滞留时间*/
/*
* 当onoff为0的时候此项不起作用, close调用默认行为关闭socket
* 当onoff不为0 且linger为0, close将立即返回, TCP将丢弃发送缓冲区的残留数据, 同时发送一个复位报文段
* 当onoff不为0 且linger大于0 . 当socket阻塞的时候close将会等待TCP模块发送完残留数据并得到确认后关
* 闭, 如果是处于非阻塞则立即关闭
*/
};
API Informasi Jaringan
#include <netdb.h>
// 通过主机名查找ip
struct hostent * gethostbyname ( const char * name );
// 通过ip获取主机完整信息
// type为IP地址类型 AF_INET和AF_INET6
struct hostent * gethostbyaddr ( const void * addr , size_t len , int type );
struct hostent
{
char * h_name ; /* Official name of host. */
char * * h_aliases ; /* Alias list. */
int h_addrtype ; /* Host address type. */
int h_length ; /* Length of address. */
char * * h_addr_list ; /* List of addresses from name server. */
}
int main ( int argc , char * argv [])
{
if ( argc != 2 )
{
printf ( "非法输入n" );
exit ( 0 );
}
char * name = argv [ 1 ];
struct hostent * hostptr {};
hostptr = gethostbyname ( name );
if ( hostptr == nullptr )
{
printf ( "输入存在错误 或无法获取n" );
exit ( 0 );
}
printf ( "Official name of hostptr: %sn" , hostptr -> h_name );
char * * pptr ;
char inet_addr [ INET_ADDRSTRLEN ];
printf ( "Alias list:n" );
for ( pptr = hostptr -> h_aliases ; * pptr != nullptr ; ++ pptr )
{
printf ( "t%sn" , * pptr );
}
switch ( hostptr -> h_addrtype )
{
case AF_INET :
{
printf ( "List of addresses from name server:n" );
for ( pptr = hostptr -> h_addr_list ; * pptr != nullptr ; ++ pptr )
{
printf ( "t%sn" ,
inet_ntop ( hostptr -> h_addrtype , * pptr , inet_addr , sizeof ( inet_addr )));
}
break ;
}
default :
{
printf ( "unknow address typen" );
exit ( 0 );
}
}
return 0 ;
}
/*
./run baidu.com
Official name of hostptr: baidu.com
Alias list:
List of addresses from name server:
39.156.69.79
220.181.38.148
*/
Dua fungsi berikut memperoleh informasi layanan dengan membaca file /etc/services. Konten berikut berasal dari Wikipedia
File Layanan adalah file konfigurasi di direktori dll sistem operasi modern. File ini mencatat nomor port dan protokol yang sesuai dengan nama layanan jaringan
#include <netdb.h>
// 根据名称获取某个服务的完整信息
struct servent getservbyname ( const char * name , const char * proto );
// 根据端口号获取服务信息
struct servent getservbyport ( int port , const char * proto );
struct servent
{
char * s_name ; /* 服务名称*/
char * * s_aliases ; /* 服务的别名列表*/
int s_port ; /* 端口号*/
char * s_proto ; /* 服务类型, 通常为TCP或UDP*/
}
#include <netdb.h>
// 内部使用的gethostbyname 和 getserverbyname
// hostname 用于接收主机名, 也可以用来接收字符串表示的IP地址(点分十进制, 十六进制字符串)
// service 用于接收服务名, 字符串表示的十进制端口号
// hints参数 对getaddrinfo的输出进行更准确的控制, 可以设置为NULL, 允许反馈各种有用的结果
// result 指向一个链表, 用于存储getaddrinfo的反馈结果
int getaddrinfo ( const char * hostname , const char * service , const struct addrinfo * hints , struct addrinfo * * result )
struct addrinfo
{
int ai_flags ;
int ai_family ;
int ai_socktype ; /* 服务类型, SOCK_STREAM或者SOCK_DGRAM*/
int ai_protocol ;
socklen_t ai_addrlen ;
char * ai_canonname ; /* 主机的别名*/
struct sockaddr * ai_addr ; /* 指向socket地址*/
struct addrinfo * ai_next ; /* 指向下一个结构体*/
}
// 需要手动的释放堆内存
void freeaddrinfo ( struct addrinfo * res );
#include <netdb.h>
// host 存储返回的主机名
// serv存储返回的服务名
int getnameinfo ( const struct sockaddr * sockaddr , socklen_t addrlen , char * host , socklen_t hostlen , char * serv
socklen_t servlen , int flags );
Uji penggunaan
telnet ip port #来连接服务器的此端口
netstat -nt | grep port #来查看此端口的监听
Fungsi IO tingkat lanjut yang disediakan oleh Linux secara alami lebih kuat dalam kondisi tertentu. Jika tidak, apa lagi yang akan mereka lakukan? Kondisi tertentu secara alami membatasi frekuensi penggunaan deskriptor file. Deskriptor file adalah bilangan bulat non-negatif. Merupakan nilai indeks yang menunjuk ke tabel rekaman file yang dibuka oleh proses yang dikelola oleh kernel untuk setiap proses. STDOUT_FILENO (nilai 1) - Deskriptor file dengan nilai 1 adalah keluaran standar. Setelah mematikan STDOUT_FILENO, gunakan dup untuk mengembalikan nilai terkecil yang tersedia (saat ini, 1). parameter memanggil dup.
fungsi pipa Fungsi ini dapat digunakan untuk membuat pipa untuk mengimplementasikan komunikasi antar proses.
// 函数定义
// 参数文件描述符数组 fd[0] 读出 fd[1]写入 单向管道
// 成功返回0, 并将一对打开的文件描述符填入其参数指向的数组
// 失败返回-1 errno
#include <unistd.h>
int pipe ( int fd [ 2 ]);
// 双向管道
// 第一个参数为 协议PF_UNIX(书上是AF_UNIX)感觉这里指明协议使用PF更好一些
#include <sys/types.h>
#include <sys/socket.h>
int socketpair ( int domain , int type , int protocol , int fd [ 2 ]);
Setelah mempelajari isi dan pengertian komunikasi antar proses berikut ini, saya akan kembali dan menambahkan contoh.
int main ()
{
int fds [ 2 ];
socketpair ( PF_UNIX , SOCK_STREAM , 0 , fds );
int pid = fork ();
if ( pid == 0 )
{
close ( fds [ 0 ]);
char a [] = "123" ;
send ( fds [ 1 ], a , strlen ( a ), 0 );
}
else if ( pid > 0 )
{
close ( fds [ 1 ]);
char b [ 20 ] {};
recv ( fds [ 0 ], b , 20 , 0 );
printf ( "%s" , b );
}
}
fungsi dup dan dup2 Salin deskriptor file yang ada
#include <unistd.h>
// 返回的文件描述符总是取系统当前可用的最小整数值
int dup ( int oldfd );
// 可以用newfd来制定新的文件描述符, 如果newfd已经被打开则先关闭
// 如果newfd==oldfd 则不关闭newfd直接返回
int dup2 ( int oldfd , int newfd );
Fungsi dup membuat deskriptor file baru. Deskriptor file baru dan file_descriptor asli keduanya menunjuk ke target yang sama. Kembali dan tambahkan contoh, karena STDOUT_FILENO
dimatikan, dup terkecil adalah STDOUT_FILENO
, jadi standarnya. output masuk ke ini di file
int main ()
{
int filefd = open ( "/home/lsmg/1.txt" , O_WRONLY );
close ( STDOUT_FILENO );
dup ( filefd );
printf ( "123n" );
exit ( 0 );
}
bacav/tulisv
#include <sys/uio.h>
// count 为 vector的长度, 即为有多少块内存
// 成功时返回写入读取的长度 失败返回-1
ssize_t readv ( int fd , const struct iovec * vector , int count );
ssize_t writev ( int fd , const struct iovec * vector , int count );
struct iovec {
void * iov_base /* 内存起始地址*/
size_t iov_len /* 这块内存长度*/
}
Kembali dan tambahkan contoh penggunaan. Contoh ini menulis representasi memori int ke dalam file. Gunakan hexdump untuk melihat file 0000000 86a0 0001
Anda dapat melihat 186a0
adalah 100000.
// 2020年1月7日16:52:11
int main ()
{
int file = open ( "/home/lsmg/1.txt" , O_WRONLY );
int temp = 100000 ;
iovec temp_iovec {};
temp_iovec . iov_base = & temp ;
temp_iovec . iov_len = sizeof ( temp );
writev ( file , & temp_iovec , 1 );
}
fungsi kirim file
#include <sys/sendfile.h>
// offset为指定输入流从哪里开始读, 如果为NULL 则从开头读取
ssize_t sendfile ( int out_fd , int in_fd , off_t * offset , size_t count );
O_RDONLY只读模式
O_WRONLY只写模式
O_RDWR读写模式
int open ( file_name , flag );
Struktur stat dapat dibuat dengan fstat, yang merupakan kartu ID file.
#include <sys/stat.h>
struct stat
{
dev_t st_dev ; /* ID of device containing file -文件所在设备的ID*/
ino_t st_ino ; /* inode number -inode节点号*/
mode_t st_mode ; /* protection -保护模式?*/
nlink_t st_nlink ; /* number of hard links -链向此文件的连接数(硬连接)*/
uid_t st_uid ; /* user ID of owner -user id*/
gid_t st_gid ; /* group ID of owner - group id*/
dev_t st_rdev ; /* device ID (if special file) -设备号,针对设备文件*/
off_t st_size ; /* total size, in bytes -文件大小,字节为单位*/
blksize_t st_blksize ; /* blocksize for filesystem I/O -系统块的大小*/
blkcnt_t st_blocks ; /* number of blocks allocated -文件所占块数*/
time_t st_atime ; /* time of last access -最近存取时间*/
time_t st_mtime ; /* time of last modification -最近修改时间*/
time_t st_ctime ; /* time of last status change - */
};
Fungsi pembuatan kartu ID
// 第一个参数需要调用open生成文件描述符
// 下面其他两个为文件全路径
int fstat ( int filedes , struct stat * buf );
// 当路径指向为符号链接的时候, lstat为符号链接的信息. stat为符号链接指向文件信息
int stat ( const char * path , struct stat * buf );
int lstat ( const char * path , struct stat * buf );
/*
* ln -s source dist 建立软连接, 类似快捷方式, 也叫符号链接
* ln source dist 建立硬链接, 同一个文件使用多个不同的别名, 指向同一个文件数据块, 只要硬链接不被完全
* 删除就可以正常访问
* 文件数据块 - 文件的真正数据是一个文件数据块, 打开的`文件`指向这个数据块, 就是说
* `文件`本身就类似快捷方式, 指向文件存在的区域.
*/
fungsi mmap dan munmap
mmap
membuat memori yang dibagikan melalui komunikasi proses (file dapat dipetakan ke dalamnya), munmap
melepaskan memori ini.
#include <sys/mman.h>
// start 内存起始位置, 如果为NULL则系统分配一个地址 length为长度
// port参数 PROT_READ(可读) PROT_WRITE(可写) PROT_EXEC(可执行), PROT_NONE(不可访问)
// flag参数 内存被修改后的行为
// - MAP_SHARED 进程间共享内存, 对内存的修改反映到映射文件中
// - MAP_PRIVATE 为调用进程私有, 对该内存段的修改不会反映到文件中
// - MAP_ANONUMOUS 不是从文件映射而来, 内容被初始化为0, 最后两个参数被忽略
// 成功返回区域指针, 失败返回 -1
void * mmap ( void * start , size_t length , int port , int flags , int fd , off_t offset );
// 成功返回0 失败返回-1
int munmap ( void * start , size_t length );
fungsi sambungan Digunakan untuk memindahkan data antara dua deskriptor nama file, 0 operasi penyalinan
#include <fcntl.h>
// fd_in 为文件描述符, 如果为管道文件描述符则 off_in必须为NULL, 否则为读取开始偏移位置
// len为指定移动的数据长度, flags参数控制数据如何移动.
// - SPLICE_F_NONBLOCK 非阻塞splice操作, 但会受文件描述符自身的阻塞
// - SPLICE_F_MORE 给内核一个提示, 后续的splice调用将读取更多的数据???????
ssize_t splice ( int fd_in , loff_t * off_in , int fd_out , loff_t * off_out , size_t len , unsigned int flags );
// 使用splice函数 实现echo服务器
int main ( int argc , char * argv [])
{
if ( argc <= 2 )
{
printf ( "the parmerters is wrongn" );
exit ( errno );
}
char * ip = argv [ 1 ];
int port = atoi ( argv [ 2 ]);
printf ( "the port is %d the ip is %sn" , port , ip );
int sockfd = socket ( PF_INET , SOCK_STREAM , 0 );
assert ( sockfd >= 0 );
struct sockaddr_in address {};
address . sin_family = AF_INET ;
address . sin_port = htons ( port );
inet_pton ( AF_INET , ip , & address . sin_addr );
int ret = bind ( sockfd , ( sockaddr * ) & address , sizeof ( address ));
assert ( ret != -1 );
ret = listen ( sockfd , 5 );
int clientfd {};
sockaddr_in client_address {};
socklen_t client_addrlen = sizeof ( client_address );
clientfd = accept ( sockfd , ( sockaddr * ) & client_address , & client_addrlen );
if ( clientfd < 0 )
{
printf ( "accept errorn" );
}
else
{
printf ( "a new connection from %s:%d successn" , inet_ntoa ( client_address . sin_addr ), ntohs ( client_address . sin_port ));
int fds [ 2 ];
pipe ( fds );
ret = splice ( clientfd , nullptr , fds [ 1 ], nullptr , 32768 , SPLICE_F_MORE );
assert ( ret != -1 );
ret = splice ( fds [ 0 ], nullptr , clientfd , nullptr , 32768 , SPLICE_F_MORE );
assert ( ret != -1 );
close ( clientfd );
}
close ( sockfd );
exit ( 0 );
}
fungsi pilih Fungsi pilih kembali ketika daftar parameter kedua dapat dibaca atau menunggu waktu yang ditentukan untuk kembali.
Setelah kembali, koleksi yang ditunjuk oleh parameter kedua fdset diubah menjadi daftar fd yang dapat dibaca. Hal ini memerlukan pembaruan koleksi fdset setelah setiap pengembalian.
Setelah kembali, nilai yang dikembalikan dari fungsi ini adalah jumlah fds yang dapat dibaca. Ini melintasi koleksi fdset dan menggunakan FD_ISSET untuk menentukan apakah fdset[i] ada di dalamnya dan kemudian menentukan apakah fd tersebut mendengarkanfd Jika belum berarti sudah diterima oleh orang lain. fd menentukan apakah ada data yang dibaca atau koneksi terputus
#include <fcntl.h>
// maxfdp 最大数 FD_SETSIZE
// struct fd_set 一个集合,可以存储多个文件描述符
// - FD_ZERO(&fd_set) 清空 -FD_SET(fd, &fd_set) 放入fd FD_CLR(fd, &fd_set)从其中清除fd
// - FD_ISSET(fd, &fd_set) 判断是否在其中
// readfds 需要监视的文件描述符读变化, 其中的文件描述符可读的时候返回
// writefds 需要监视的文件描述符写变化, 其中的文件描述符可写的时候返回
// errorfds 错误
// timeout 传入NULL为阻塞, 设置为0秒0微秒则变为非阻塞函数
// 返回值 负值为错误 等待超时说明文件无变化返回0 有变化返回正值
int select ( int maxfdp , fd_set * readfds , fd_set * writefds , fd_set * errorfds , struct timeval * timeout );
#define exit_if ( r , ...)
{
if (r)
{
printf(__VA_ARGS__);
printf("errno no: %d, error msg is %s", errno, strerror(errno));
exit(1);
}
}
int main ( int argc , char * argv [])
{
int keyboard_fd = open ( "/dev/tty" , O_RDONLY | O_NONBLOCK );
exit_if ( keyboard_fd < 0 , "open keyboard fd errorn" );
fd_set readfd ;
char recv_buffer = 0 ;
while (true)
{
FD_ZERO ( & readfd );
FD_SET ( 0 , & readfd );
timeval timeout { 5 , 0 };
int ret = select ( keyboard_fd + 1 , & readfd , nullptr , nullptr , & timeout );
exit_if ( ret == -1 , "select errorn" );
if ( ret > 0 )
{
if ( FD_ISSET ( keyboard_fd , & readfd ))
{
recv_buffer = 0 ;
read ( keyboard_fd , & recv_buffer , 1 );
if ( 'n' == recv_buffer )
{
continue ;
}
if ( 'q' == recv_buffer )
{
break ;
}
printf ( "the input is %cn" , recv_buffer );
}
}
if ( ret == 0 )
{
printf ( "timeoutn" );
}
}
}
sudo service rsyslog restart // 启动守护进程
#include <syslog.h>
// priority参数是所谓的设施值(记录日志信息来源, 默认为LOG_USER)与日志级别的按位或
// - 0 LOG_EMERG /* 系统不可用*/
// - 1 LOG_ALERT /* 报警需要立即采取行动*/
// - 2 LOG_CRIT /* 非常严重的情况*/
// - 3 LOG_ERR /* 错误*/
// - 4 LOG_WARNING /* 警告*/
// - 5 LOG_NOTICE /* 通知*/
// - 6 LOG_INFO /* 信息*/
// -7 LOG_DEBUG /* 调试*/
void syslog ( int priority , const char * message , .....);
// ident 位于日志的时间后 通常为名字
// logopt 对后续 syslog调用的行为进行配置
// - 0x01 LOG_PID /* 在日志信息中包含程序PID*/
// - 0x02 LOG_CONS /* 如果信息不能记录到日志文件, 则打印到终端*/
// - 0x04 LOG_ODELAY /* 延迟打开日志功能直到第一次调用syslog*/
// - 0x08 LOG_NDELAY /* 不延迟打开日志功能*/
// facility参数可以修改syslog函数中的默认设施值
void openlog ( const char * ident , int logopt , int facility );
// maskpri 一共八位 0000-0000
// 如果将最后一个0置为1 表示 记录0级别的日志
// 如果将最后两个0都置为1 表示记录0和1级别的日志
// 可以通过LOG_MASK() 宏设定 比如LOG_MASK(LOG_CRIT) 表示将倒数第三个0置为1, 表示只记录LOG_CRIT
// 如果直接设置setlogmask(3); 3的二进制最后两个数均为1 则记录 0和1级别的日志
int setlogmask ( int maskpri );
// 关闭日志功能
void closelog ();
UID - ID pengguna asli EUID - ID pengguna efektif - memfasilitasi akses sumber daya GID - ID grup nyata EGID - ID grup efektif
#include <sys/types.h>
#include <unistd.h>
uid_t getuid ();
uid_t geteuid ();
gid_t getgid ();
gid_t getegid ();
int setuid ( uid_t uid );
int seteuid ( uid_t euid );
int setgid ( gid_t gid );
int setegid ( gid_t gid );
Anda dapat mengganti pengguna melalui setuid
dan setgid
Uid dan gid pengguna root keduanya 0.
PGID - ID grup proses (setiap proses di Linux termasuk dalam grup proses)
#include <unistd.h> pid_t getpgid(pid_t pid); Mengembalikan pgid yang menjadi milik pid jika berhasil. Mengembalikan -1 jika gagal int setpgid(pid_t pid, pid_t pgid);
sidang Beberapa grup proses terkait akan membentuk lompatan sesi
Periksa hubungan proses ps dan less
Batasan sumber daya Ubah sedikit direktori agak
Model server-model CS
keuntungan
Diagram pola
Demo yang ditulis tidak menggunakan fungsi fork. Ini akan diperbaiki di masa depan.
Model IO kerangka server
Saya mungkin dapat memahami model ini, dan saya telah mempelajari Javaweb selama setengah tahun.
Soket memblokir secara default saat dibuat, tetapi dapat diselesaikan dengan meneruskan parameter SOCK_NONBLOCK
. Panggilan non-pemblokiran akan segera kembali, tetapi peristiwa tersebut mungkin tidak terjadi (recv tidak menerima informasi). terjadi atau terjadi kesalahan,返回-1
jadi perlu dibedakan dengan errno
Kesalahan ini tidak terjadi terima, kirim, recv errno diatur ke EAGAIN(再来一次)
atau EWOULDBLOCK(期望阻塞)
connect diatur ke EINPROGRESS(正在处理中)
IO non-pemblokiran perlu dipanggil ketika peristiwa telah terjadi untuk meningkatkan kinerja.
Fungsi multiplexing IO yang umum digunakan select
poll
epoll_wait
akan dijelaskan nanti di Bab 9. Sinyalnya akan dijelaskan di Bab 10.
Dua mode pemrosesan acara yang efisien dan mode konkurensi
Program dibagi menjadi komputasi intensif (menggunakan banyak CPU dan sedikit sumber daya IO) dan intensif IO (sebaliknya). Yang pertama akan mengurangi efisiensi ketika menggunakan pemrograman bersamaan, sedangkan yang kedua akan meningkatkan efisiensi dan cara multi-threading
Mode konkurensi - metode mengoordinasikan tugas antara unit IO dan beberapa unit logis. Server memiliki dua mode konkurensi utama
Mode semi-sinkron/semi-asinkron Dalam model IO, perbedaan antara asynchronous dan synchronous adalah jenis event IO yang diberitahukan kernel kepada aplikasi (event siap atau event penyelesaian), dan siapa yang menyelesaikan pembacaan dan penulisan IO (aplikasi atau kernel)
Dan di sini sinkronisasi (mode konkurensi) mengacu pada eksekusi sepenuhnya dalam urutan urutan kode - utas yang berjalan secara sinkron disebut utas asinkron perlu didorong oleh peristiwa sistem (interupsi, sinyal) - utas yang berjalan secara asinkron disebut thread asinkron
Server (membutuhkan kinerja real-time yang baik dan dapat menangani beberapa permintaan pelanggan secara bersamaan) - umumnya diimplementasikan menggunakan thread sinkron dan thread asinkron, yaitu mode semi-sinkron/semi-asinkron Thread sinkron - memproses logika pelanggan dan memproses objek dalam antrian permintaan secara asinkron Thread - menangani peristiwa IO, setelah menerima permintaan pelanggan, merangkumnya ke dalam objek permintaan dan memasukkannya ke dalam antrian permintaan
Terdapat variasi Pola Semi-Sinkron/Semi-Async半同步/半反应堆模式
Utas asinkron - utas utama - bertanggung jawab untuk memantau peristiwa di semua soket
model pemimpin/pengikut agak
Metode pemrograman yang efisien - mesin keadaan terbatas
// 状态独立的有限状态机
STATE_MACHINE ( Package _pack ) {
PackageType _type = _pack . GetType ();
switch ( _type ) {
case type_A :
xxxx ;
break ;
case type_B :
xxxx ;
break ;
}
}
// 带状态转移的有限状态机
STATE_MACHINE () {
State cur_State = type_A ;
while ( cur_State != type_C ) {
Package _pack = getNewPackage ();
switch ( cur_State ) {
case type_A :
process_package_state_A ( _pack );
cur_State = type_B ;
break ;
case type_B :
xxxx ;
cur_State = type_C ;
break ;
}
}
}
Butuh waktu satu jam bagi saya untuk akhirnya menyalin kode 5.000 kata itu huruf demi huruf @8 September 2019 22:08:46@
Kumpulan - Perdagangkan ruang untuk kumpulan proses waktu dan kumpulan thread
Replikasi Data - Server berkinerja tinggi harus berusaha menghindari replikasi yang tidak perlu
Sakelar dan kunci konteks Kurangi cakupan锁
. Anda tidak boleh membuat terlalu banyak proses pekerja, namun gunakan thread logika bisnis khusus.
Multiplexing I/O memungkinkan program memantau beberapa deskriptor file secara bersamaan.
Metode yang umum digunakan select
, poll
, epoll
# include < sys/select.h >
// nfds - 被监听的文件描述符总数
// 后面三个分别指向 可读, 可写, 异常等事件对应的文件描述符集合
// timeval select超时时间 如果传递0 则为非阻塞, 设置为NULL则为阻塞
// 成功返回就绪(可读, 可写, 异常)文件描述符的总数, 没有则返回0 失败返回-1
int select ( int nfds, fd_set * readfds, fd_set * writefds, fd_set * exceptfds, struct timeval * timeout);
//操作fd_set的宏
FD_ZERO ( fd_set * fdset);
FD_SET ( int fd, fd_set * fdset);
FD_CLR ( int fd, fd_set * fdset);
FD_ISSET ( int fd, fd_set * fdset);
// 设置 timeval 超时时间
struct timeval
{
long tv_sec; // 秒
long tv_usec; // 微秒
}
memilih
kondisi siap deskriptor file
pemilihan
# include < poll.h >
// fds 结构体类型数组 指定我们感兴趣的文件描述符上发生的可读可写和异常事件
// nfds 遍历结合大小 左闭右开
// timeout 单位为毫秒 -1 为阻塞 0 为立即返回
int poll ( struct pollfd * fds, nfds_t nfds, int timeout);
struct pollfd
{
int fd;
short events; //注册的事件, 告知poll监听fd上的哪些事件
short revents; // 实际发生的事件
}
# define exit_if (r, ...)
{
if (r)
{
printf (__VA_ARGS__);
printf ( " errno no: %d, error msg is %s " , errno, strerror (errno));
exit ( 1 );
}
}
struct client_info
{
char *ip_;
int port_;
};
int main ( int argc, char * argv[])
{
int port = 8001 ;
char ip[] = " 127.0.0.1 " ;
struct sockaddr_in address;
address. sin_port = htons (port);
address. sin_family = AF_INET;
address. sin_addr . s_addr = htons (INADDR_ANY);
int listenfd = socket (PF_INET, SOCK_STREAM, 0 );
exit_if (listenfd < 0 , " socket error n " );
int ret = bind (listenfd, ( struct sockaddr *)&address, sizeof (address));
exit_if (ret == - 1 , " bind error n " );
ret = listen (listenfd, 5 );
exit_if (ret == - 1 , " listen error n " );
constexpr int MAX_CLIENTS = 1024 ;
struct pollfd polls[MAX_CLIENTS] = {};
struct client_info clientsinfo[MAX_CLIENTS] = {};
polls[ 3 ]. fd = listenfd;
polls[ 3 ]. events = POLLIN | POLLRDHUP;
while ( true )
{
ret = poll (polls, MAX_CLIENTS + 1 , - 1 );
exit_if (ret == - 1 , " poll error n " );
for ( int i = 3 ; i <= MAX_CLIENTS; ++i)
{
int fd = polls[i]. fd ;
if (polls[i]. revents & POLLRDHUP)
{
polls[i]. events = 0 ;
printf ( " close fd-%d from %s:%d n " , fd, clientsinfo[fd]. ip_ , clientsinfo[fd]. port_ );
}
if (polls[i]. revents & POLLIN)
{
if (fd == listenfd)
{
struct sockaddr_in client_address;
socklen_t client_addresslen = sizeof (client_address);
int clientfd = accept (listenfd, ( struct sockaddr *)&client_address,
&client_addresslen);
struct client_info *clientinfo = &clientsinfo[clientfd];
clientinfo-> ip_ = inet_ntoa (client_address. sin_addr );
clientinfo-> port_ = ntohs (client_address. sin_port );
exit_if (clientfd < 0 , " accpet error, from %s:%d n " , clientinfo-> ip_ ,
clientinfo-> port_ );
printf ( " accept from %s:%d n " , clientinfo-> ip_ , clientinfo-> port_ );
polls[clientfd]. fd = clientfd;
polls[clientfd]. events = POLLIN | POLLRDHUP;
}
else
{
char buffer[ 1024 ];
memset (buffer, '