Linux服务器开发--1(网络和文件操作)

最新推荐文章于 2024-06-12 21:23:37 发布

那一次，回眸

最新推荐文章于 2024-06-12 21:23:37 发布

阅读量69

点赞数

文章标签： c++ c语言

本文链接：https://blog.csdn.net/qq_45132890/article/details/116809411

版权

socket通讯编程

1.socket套接字的概念
在这里插入图片描述
2.socket通讯创建流程图

3. 网络字节序
在计算机世界里，有两种字节序：
大端字节序 - 低地址高字节,高地址低字节
小段字节序 - 低地址低字节,高地址高字节
如: 存1001 = Ox03e9(16进制)

小端: (从小到大排列) e9 03
大端:(从大到小排列) 03 e9

内存中的多字节数据相对于内存地址有大端和小端之分，磁盘文件中的多字节数据相对于文件中的偏移地址也有大端小端之分。网络数据流同样有大端小端之分，那么如何定义网络数据流的地址呢？发送主机通常将发送缓冲区中的数据按内存地址从低到高的顺序发出，接收主机把从网络上接到的字节依次保存在接收缓冲区中，也是按内存地址从低到高的顺序保存，因此，网络数据流的地址应这样规定：先发出的数据是低地址，后发出的数据是高地址。
TCP/IP协议规定，网络数据流应采用大端字节序，即低地址高字节。
例如端口号是1001（0x3e9），由两个字节保存，采用大端字节序，则低地址是0x03，高地址是0xe9，也就是先发0x03，再发0xe9，这16位在发送主机的缓冲区中也应该是低地址存0x03，高地址存0xe9。但是，如果发送主机是小端字节序的，这16位被解释成0xe903，而不是1001。因此，发送主机把1001填到发送缓冲区之前需要做字节序的转换。同样地，接收主机如果是小端字节序的，接到16位的源端口号也要做字节序的转换。如果主机是大端字节序的，发送和接收都不需要做转换。同理，32位的IP地址也要考虑网络字节序和主机字节序的问题。
为使网络程序具有可移植性，使同样的C代码在大端和小端计算机上编译后都能正常运行，可以调用以下库函数做网络字节序和主机字节序的转换。

#include <arpa/inet.h>

uint32_t htonl(uint32_t hostlong);
uint16_t htons(uint16_t hostshort);
uint32_t ntohl(uint32_t netlong);
uint16_t ntohs(uint16_t netshort);
h表示host，n表示network，l表示32位长整数，s表示16位短整数。
如果主机是小端字节序，这些函数将参数做相应的大小端转换然后返回，如果主机是大端字节序，这些函数不做转换，将参数原封不动地返回。

4.sockaddr数据结构
很多网络编程函数诞生早于IPv4协议，那时候都使用的是sockaddr结构体,为了向前兼容，现在sockaddr退化成了（void ）的作用，传递一个地址给函数，至于这个函数是sockaddr_in还是其他的，由地址族确定，然后函数内部再强制类型转化为所需的地址类型。

sockaddr数据结构
struct sockaddr {
sa_family_t sa_family; / address family, AF_xxx /(协议组)
char sa_data[14]; / 14 bytes of protocol address */
};

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 */(网络地址类型)
};

IPv4的地址格式定义在netinet/in.h中，IPv4地址用sockaddr_in结构体表示，包括16位端口号和32位IP地址，但是sock API的实现早于ANSI C标准化，那时还没有void *类型，因此这些像bind 、accept函数的参数都用struct sockaddr *类型表示，在传递参数之前要强制类型转换一下，例如：
struct sockaddr_in servaddr;
bind(listen_fd, (struct sockaddr )&servaddr, sizeof(servaddr)); / initialize servaddr */

5.ip地址转换函数

如: IP: “1.2.3.4”
大端字节序: 4.3.2.1 的存储方式
小端字节序: 1.2.3.4 的存储方式

#include <arpa/inet.h>
int inet_pton(int af, const char *src, void *dst);
const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);
af 取值可选为 AF_INET 和 AF_INET6 ，即和 ipv4 和ipv6对应
支持IPv4和IPv6

其中inet_pton和inet_ntop不仅可以转换IPv4的in_addr，还可以转换IPv6的in6_addr。
因此函数接口是void *addrptr。

例子:

#include <stdio.h>
#include <string.h>
#include <arpa/inet.h>

int main(void){

    char ip[]="2.3.4.5";
    char server_ip[64];
    
    struct sockaddr_in server_addr;
    inet_pton(AF_INET, ip, &server_addr.sin_addr.s_addr);

    printf("s_addr : %x\n", server_addr.sin_addr.s_addr);
    printf("s_addr from net to host: %x\n", ntohl(server_addr.sin_addr.s_addr));
    
    inet_ntop(AF_INET, &server_addr.sin_addr.s_addr, server_ip, 64);

    printf("server ip : %s\n", server_ip);

    printf("INADDR_ANY: %d\n", INADDR_ANY);
    server_addr.sin_addr.s_addr = INADDR_ANY;
    inet_ntop(AF_INET, &server_addr.sin_addr.s_addr, server_ip, 64);
    printf("INADDR_ANY ip : %s\n", server_ip);
    return 0;
}

在这里插入图片描述
6.socket编程函数
6.1 socket函数

#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>

int socket(int domain, int type, int protocol);
domain:
	AF_INET 这是大多数用来产生socket的协议，使用TCP或UDP来传输，用IPv4的地址

	AF_INET6 与上面类似，不过是来用IPv6的地址
	AF_UNIX 本地协议，使用在Unix和Linux系统上，一般都是当客户端和服务器在同一台及其上的时候使用
type:
	SOCK_STREAM 这个协议是按照顺序的、可靠的、数据完整的基于字节流的连接。这是一个使用最多的socket类型，这个socket是使用TCP来进行传输。
	SOCK_DGRAM 这个协议是无连接的、固定长度的传输调用。该协议是不可靠的，使用UDP来进行它的连接。
	SOCK_SEQPACKET该协议是双线路的、可靠的连接，发送固定长度的数据包进行传输。必须把这个包完整的接受才能进行读取。
	SOCK_RAW socket类型提供单一的网络访问，这个socket类型使用ICMP公共协议。（ping、traceroute使用该协议）
	SOCK_RDM 这个类型是很少使用的，在大部分的操作系统上没有实现，它是提供给数据链路层使用，不保证数据包的顺序
protocol:
	传0 表示使用默认协议。
返回值：
	成功：返回指向新创建的socket的文件描述符，失败：返回-1，设置errno

socket()打开一个网络通讯端口，如果成功的话，就像open()一样返回一个文件描述符，应用程序可以像读写文件一样用read/write在网络上收发数据，如果socket()调用出错则返回-1。对于IPv4，domain参数指定为AF_INET。对于TCP协议，type参数指定为SOCK_STREAM，表示面向流的传输协议。如果是UDP协议，则type参数指定为SOCK_DGRAM，表示面向数据报的传输协议。protocol参数的介绍从略，指定为0即可。

6.2 bind 函数

#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
sockfd：
	socket文件描述符
addr:
	构造出IP地址加端口号
addrlen:
	sizeof(addr)长度
返回值：
	成功返回0，失败返回-1, 设置errno

服务器程序所监听的网络地址和端口号通常是固定不变的，客户端程序得知服务器程序的地址和端口号后就可以向服务器发起连接，因此服务器需要调用bind绑定一个固定的网络地址和端口号。
bind()的作用是将参数sockfd和addr绑定在一起，使sockfd这个用于网络通讯的文件描述符监听addr所描述的地址和端口号。前面讲过，struct sockaddr *是一个通用指针类型，addr参数实际上可以接受多种协议的sockaddr结构体，而它们的长度各不相同，所以需要第三个参数addrlen指定结构体的长度。如：

struct sockaddr_in servaddr;
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(6666);

首先将整个结构体清零，然后设置地址类型为AF_INET，网络地址为INADDR_ANY，这个宏表示本地的任意IP地址，因为服务器可能有多个网卡，每个网卡也可能绑定多个IP地址，这样设置可以在所有的IP地址上监听，直到与某个客户端建立了连接时才确定下来到底用哪个IP地址，端口号为6666。

6.3 listen 函数

#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
int listen(int sockfd, int backlog);
sockfd:
	socket文件描述符
backlog:
	在Linux 系统中，它是指排队等待建立3次握手队列长度(接收客户端连接的数量)
查看系统默认backlog:
	cat /proc/sys/net/ipv4/tcp_max_syn_backlog
改变 系统限制的backlog 大小:
	vim /etc/sysctl.conf
	最后添加
	net.core.somaxconn = 1024
	net.ipv4.tcp_max_syn_backlog = 1024
	保存，然后执行
	sysctl -p
**注意:如果你指定的队列长度大于系统默认的长度时,必须把系统的长度修改大于指定的长度;**

6.4 accept 函数

#include <sys/types.h> 		/* See NOTES */
#include <sys/socket.h>
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
sockdf:
	socket文件描述符
addr:
	传出参数，返回链接客户端地址信息，含IP地址和端口号
addrlen:
	传入传出参数（值-结果）,传入sizeof(addr)大小，函数返回时返回真正接收到地址结构体的大小
返回值：
	成功返回一个新的socket文件描述符，用于和客户端通信，失败返回-1，设置errno

		*三次握手过程*
三次握手完成后，服务器调用accept()接受连接，如果服务器调用accept()时还没有客户端的连接请求，就阻塞等待直到有客户端连接上来。addr是一个传出参数，accept()返回时传出客户端的地址和端口号。addrlen参数是一个传入传出参数（value-result argument），传入的是调用者提供的缓冲区addr的长度以避免缓冲区溢出问题，传出的是客户端地址结构体的实际长度（有可能没有占满调用者提供的缓冲区）。如果给addr参数传NULL，表示不关心客户端的地址。
我们的服务器程序结构是这样的：
while (1) {
	cliaddr_len = sizeof(cliaddr);
	connfd = accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddr_len);
	n = read(connfd, buf, MAXLINE);
	......
	close(connfd);
}
整个是一个while死循环，每次循环处理一个客户端连接。由于cliaddr_len是传入传出参数，每次调用accept()之前应该重新赋初值。accept()的参数listenfd是先前的监听文件描述符，而accept()的返回值是另外一个文件描述符connfd，之后与客户端之间就通过这个connfd通讯，最后关闭connfd断开连接，而不关闭listenfd，再次回到循环开头listenfd仍然用作accept的参数。accept()成功返回一个文件描述符，出错返回-1。

6.5 connect函数

#include <sys/types.h> 					/* See NOTES */
#include <sys/socket.h>
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
sockdf:
	socket文件描述符
addr:
	传入参数，指定服务器端地址信息，含IP地址和端口号
addrlen:
	传入参数,传入sizeof(addr)大小
返回值：
	成功返回0，失败返回-1，设置errno
客户端需要调用connect()连接服务器，connect和bind的参数形式一致，区别在于bind的参数是自己的地址，而connect的参数是对方的地址。connect()成功返回0，出错返回-1。

6.6 出错处理函数
我们知道，系统函数调用不能保证每次都成功，必须进行出错处理，这样一方面可以保证程序逻辑正常，另一方面可以迅速得到故障信息。

#include <errno.h>
#include <string.h>

//往日志里写入报错消息
char *strerror(int errnum);     /* See NOTES */
errnum:
	传入参数,错误编号的值，一般取 errno 的值
返回值：
	错误原因

#include <stdio.h>
#include <errno.h>

//控制台打印报错消息,
void perror(const char *str);    /* See NOTES */
str:
	传入参数,自定义的描述
返回值：
	无
	向标准出错stderr 输出出错原因

文件操作

1. 文件的作用
linux中，一切皆文件（网络设备除外）硬件设备也“是”文件，通过文件来使用设备目录（文件夹）也是一种文件
在这里插入图片描述
2.Linux的文件结构

root: 该目录为系统管理员(也称作超级管理员)的用户主目录。

bin: 是Binary的缩写, 这个目录存放着最经常使用的命令。

boot：这里存放的是启动Linux时使用的一些核心文件，包括一些连接文件以及镜像文件。

dev:是Device(设备)的缩写, 该目录下存放的是Linux的外部设备，在Linux中访问设备的方式和访问文件的方式是相同的。

etc:所有的配置文件, 所有的系统管理所需要的配置文件和子目录都存放在这里。

home:用户的主目录，在Linux中，每个用户都有一个自己的目录，一般该目录名是以用户的账号命名的。

var:存放着在不断变化的文件数据，我们习惯将那些经常被修改的目录放在这个目录下。包括各种日志文件。

lib:这个目录里存放着系统最基本的动态连接共享库，其作用类似于Windows里的DLL文件。几乎所有的应用程序都需要用到这些共享库。

usr:系统用户工具和程序
– bin：用户命令
– sbin：超级用户使用的比较高级的管理程序和系统守护程序。
– include：标准头文件
– lib：库文件
– src：内核源代码

tmp: 用来存放一些临时文件。

media：linux 系统会自动识别一些设备，例如U盘、光驱等等，当识别后，linux会把识别的设备挂载到这个目录下。

mnt：临时挂载其他文件。

proc: 包含了进程的相关信息。

3.文件的操作方式
0) 文件描述符 fd
是一个>=0的整数
每打开一个文件，就创建一个文件描述符，通过文件描述符来操作文件

     预定义的文件描述符：
     0：标准输入，对应于已打开的标准输入设备（键盘）
     1：标准输出，对应于已打开的标准输出设备（控制台）
     2. 标准错误， 对应于已打开的标准错误输出设备（控制台）
     
     多次打开同一个文件，可得到多个不同的文件描述符。
            
1） 使用底层文件操作（系统调用）
       比如：read
       可使用man 2 查看
       
2） 使用I/O库函数
		比如：fread
		可使用man 3 查看

4. 底层文件操作(关于文件的系统调用）
4.1 write
用法: write(fd(文件描述符),buf(写入的内容),sizeof(buf)(内容的大小));

	返回值:
           成功：返回实际写入的字节数
           失败：返回 -1， 错误编号设置 errno  可用( strerror(errno) ) 查看
   注意：是从文件的当前指针位置写入! 文件刚打开时，文件的位置指针指向文件头;
   例子:

#include <errno.h>
#include <string.h>

int main(void){
    int len = 0;

    char buff[] = "hello world\n";

    len = write(1, buff, sizeof(buff)); 
    if(len < 0){
        printf("write to stdout failed. reason: %s\n", strerror(errno));
    }else {
        printf("write %d bytes.\n", len);
    }

    len = write(2, buff, sizeof(buff));

    if(len < 0){
        printf("write to stderr failed. reason: %s\n", strerror(errno));
    }
    
    return 0;
    }

4.2 read
用法: read(fd(文件描述符),buf(读取的内容),sizeof(buf)(内容的大小));

	返回值
 	        >0 : 实际读取的字节数
 	        0  : 已读到文件尾
 	        -1 ：出错
 	  注意：参数3表示最多能接受的字节数，而不是指一定要输入的字节数
 	  运行：# ./a.out          /* 用户输入回车符时结束输入 */
 	      		 # ./a.out < main.c      /* 利用重定向， 使用文件main.c作为输入 */

4.3 open
用法: fd = open(“file_name(文件名)”,打开方式,设置访问权限(默认为读,写,执行));

	返回值
 	        成功：文件描述符
 	        失败：-1
	打开方式
 	        O_RDONLY        只读
 	        O_WRONLY        只写
 	        O_RDWR           读写
 	        O_CREAT           如果文件不存在，则创建该文件，并使用第3个 
										参数设置权限,如果文件存在 ，则只打开文件
			O_EXCL            如果同时使用O_CREAT而且该文件又已经存在时，则返回错误, 用途：以防					止多个进程同时创建
			O_APPEND         尾部追加方式（打开后，文件指针指向文件的末尾）
			O_TRUNC          若文件存在，则长度被截为0，属性不变

参数3 (设置权限）
当使用O_CREAT时，使用参数3

 	        S_I(R/W/X)(USR/GRP/OTH)
 	        例：
 	          S_IRUSR | S_IWUSR    文件的所有者对该文件可读可写
 	          (八进制表示法)0600     文件的所有者对该文件可读可写

注意：
返回的文件描述符是该进程未打开的最小的文件描述符

4.4 close
用法: close(fd(文件描述符));
终止指定文件描述符与对应文件之间的关联，并释放该文件描述符，即该文件描述符可被重新使用

	返回值
           成功： 0
           失败： -1
           
           观察耗时
         ./a.out
         time  ./a.out   
         
         补充：time命令
          time命令分别输出:
              real - 程序总的执行时间、
              usr - 该程序本身所消耗的时间、
              sys - 系统调用所消耗的时间

4.5 lseek
用法: ret = lseek(file1, 0, SEEK_END); 获取文件大小或者偏移值

   返回值
          成功：返回新的文件位置与文件头之间偏移
          失败： -1

 实例：从文件偏移量100的位置拷贝100个字节到另一个文件
 file1 = open(FILE1_NAME, O_RDONLY);
 file2 = open(FILE2_NAME, O_WRONLY|O_CREAT, S_IRUSR|S_IWUSR);

 ret = lseek(file1, 100, SEEK_SET);
 ret = read(file1, buffer, SIZE);
if(ret > 0){
    buffer[ret] = '\0';
    printf("read[%d]: %s\n", ret, buffer);
    write(file2, buffer, SIZE);
}

4.6 ioctl (嵌入式使用的函数)
用法: int ioctl(int fd, int cmd,[int *argdx, int argcx]);
ioctl是设备驱动程序中对设备的I/O通道进行管理的函数。所谓对I/O通道进行管理，就是对设备的一些特性进行控制，例如串口的传输波特率、马达的转速等等。是设备驱动程序中设备控制接口函数,用来控制设备.

函数名: ioctl

功能: 控制I/O设备

参数：fd是用户程序打开设备时使用open函数返回的文件标示符，cmd是用户程序对设备的控制命令，后面是一些补充参数，一般最多一个，这个参数的有无和cmd的意义相关;

5.标准I/O库

直接使用系统调用的缺点
(1) 影响系统性能
系统调用比普通函数调用开销大
因为，频繁的系统调用要进行用户空间和内核空间的切换
(2) 系统调用一次所能读写的数据量大小，受硬件的限制

解决方案: 使用带缓冲功能的标准I/O库（以减少系统调用次数）

/* C语言中的文件操作中已描述 */
1) fwrite
2) fread
3) fopen
4) fclose
5) fseek
6) fflush

6. proc文件系统

/proc是一个特殊的文件系统，
该目录下文件用来表示与启动、内核相关的特殊信息

1) /proc/cpuinfo
   CPU详细信息
   
2) /proc/meminfo
   内存相关信息

3) /proc/version
   版本信息

4) /proc/sys/fs/file-max
   系统中能同时打开的文件总数
   可修改该文件

5) 进程的相关信息
   /proc/32689/ 表示指定进程（进程号为32689)的相关信息
   
6) /proc/devices
    已分配的字符设备、块设备的设备号

7.文件锁

并发对文件I/O操作的影响
解决办法？
2)文件锁
用法：man 2 fcntl
```
头文件：#include <unistd.h>
        #include <fcntl.h>
```
函数定义：int fcntl(int fd, int cmd, … /* arg */ );
参数： cmd 取值 F_GETLK, F_SETLK 和 F_SETLKW ,分别表示获取锁、设置锁和同步设置锁.

文件锁的表示:
struct flock

// struct flock 结构体说明
struct flock {
    short l_type;  /*F_RDLCK, F_WRLCK, or F_UNLCK */
    off_t l_start;  /*offset in bytes, relative to l_whence */
    short l_whence;  /*SEEK_SET, SEEK_CUR, or SEEK_END */
    off_t l_len;   /*length, in bytes; 0 means lock to EOF */
    pid_t l_pid;   /*returned with F_GETLK */
	};

	l_type:  第一个成员是加锁的类型：只读锁，读写锁，或是解锁。
	l_start和l_whence: 用来指明加锁部分的开始位置。
	l_len: 是加锁的长度。
	l_pid: 是加锁进程的进程id。

举例： 

我们现在需要把一个文件的前三个字节加读锁，则该结构体的l_type=F_RDLCK, l_start=0,
l_whence=SEEK_SET,  l_len=3,  l_pid不需要指定，然后调用fcntl函数时，
cmd参数使F_SETLK.

实例:

#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>

#define FILE_NAME 	"test.txt"
	   
int flock_set(int fd, int type)
{
	printf("pid=%d into...\n", getpid());
	
	struct flock flock;
	flock.l_type = type;
	flock.l_whence = SEEK_SET;
	flock.l_start = 0;
	flock.l_len = 0;   
	flock.l_pid = -1;

	fcntl(fd, F_GETLK, &flock);

	if (flock.l_type != F_UNLCK) {
		if (flock.l_type == F_RDLCK) {
			printf("flock has been set to read lock by %d\n", flock.l_pid);
		} else if (flock.l_type == F_WRLCK) {
			printf("flock has been set to write lock by %d\n", flock.l_pid);
		}
	}

	flock.l_type = type;
	if (fcntl(fd, F_SETLKW, &flock) < 0) {
		printf("set lock failed!\n");

		return -1;
	}	

	switch (flock.l_type) {
	case F_RDLCK:
		printf("read lock is set by %d\n", getpid());
		break;
	case F_WRLCK:
		printf("write lock is set by %d\n", getpid());
		break;
	case F_UNLCK:
		printf("lock is released by %d\n", getpid());
		break;
	default:
		break;
	}

	printf("pid=%d out.\n", getpid());
	return 0;
}

int main(void)
{
	int fd;

	fd = open(FILE_NAME, O_RDWR|O_CREAT, 0666);
	if (fd < 0) {
		printf("open file %s failed!\n", FILE_NAME);
	}

	//flock_set(fd, F_WRLCK);
	flock_set(fd, F_RDLCK);
	getchar();
	flock_set(fd, F_UNLCK);
	getchar();

	close(fd);
	return 0;
}