Linux系统编程1、open函数 2、read读设备文件、网络文件、管道文件会阻塞 3、lseek重新制定read write的偏移 4、dup2重定向 5、常见命令(ls cp mv)的源码实现

于 2023-04-30 17:33:01 发布
阅读量118 收藏
点赞数 1
分类专栏： Linux系统编程 文章标签： linux c语言 运维
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rrrrrrrrtgghyhbh/article/details/130449871
版权

1、open函数

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>

int main(int argc, char *argv[])
{
	int fd = open("./mydir", O_WRONLY);
	printf("fd = %d, errno = %d\n", fd, errno);
	if (fd == -1)
	{
		printf("%s\n", strerror(errno));
	}

	
	int fd1 = close(fd);
	printf("fd1 = %d\n", fd1);
	if (fd1 == -1)
	{
		printf("%s\n", strerror(errno));
	}

	return 0;

}

2、实现cp-系统函数

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>


int main(int args, char *argv[])
{
	// 1、打开要复制的文件
	int fd1 = open(argv[1], O_RDONLY);
	if (fd1 == -1)
		printf("%s\n", strerror(errno));
	// 2、新建1个空文件
	int fd2 = open(argv[2], O_RDWR | O_CREAT | O_TRUNC, 0644);
	if (fd2 == -1)
		printf("%s\n", strerror(errno));
	// 循环3、4、读文件到末尾read返回0
	int counts1;
	char buf[BUFSIZ];
	while (1)
	{
		// 3、读取该文件
		counts1 = read(fd1, buf, BUFSIZ);
		// 4、读取到的内容写到空文件中
		write(fd2, buf, counts1);
		if (counts1 == 0)
			break;
	}
	// 5、关闭打开的文件
	close(fd1);
	close(fd2);

	return 0;
}

2、实现cp-库函数 

#include <stdio.h>

int main(int argc, char *argv[])
{
	// 1、只读方式打开文件
	FILE * f1 = fopen(argv[1], "r");
	// 2、创建新文件
	FILE * f2 = fopen(argv[2], "w");
	char buf[1];
	int n; //读到的字节数
	// 循环3、4、
	while (1)
	{

		// 3、读文件存到缓冲区
		 n = fgetc(f1);
		// 4、写到新文件中
		 fputc(n, f2);
		if (n == EOF)
			break;
	}
	fclose(f1);
	fclose(f2);

	return 0;
}

3、read读设备文件、网络文件、管道文件会阻塞

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

int main(void)
{
	char buf[10];
	int n;
	int flags = fcntl(STDIN_FILENO, F_GETFL);
	if (flags == -1)
	{
		perror("fcntl STDIN_FILENO");
		exit(1);
	}
	flags |= O_NONBLOCK;
	int ret = fcntl(STDIN_FILENO, F_SETFL, flags);
	if (ret == -1)
	{
		perror("fcntl STDIN_FILENO");
		exit(1);
	}

tryagain:
	n = read(STDIN_FILENO, buf, 10);
	if (n < 0)
	{
		if (errno != EAGAIN)
		{
			perror("read /dev/tty");
			exit(1);
		}
		else
		{
			write(STDOUT_FILENO, "try again\n", strlen("try again\n"));
			sleep(2);
			goto tryagain;
		}
	}
	write(STDOUT_FILENO, buf, n);

	return 0;
}

4、lseek重新制定read write的偏移位置

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <errno.h>
#include <fcntl.h>
#include <string.h>
#include <stdlib.h>


int main(void)
{
	int fd, n;
	char msg[] = "It's a test for lseek\n";
	char ch;

	fd = open("lseek.txt", O_RDWR | O_CREAT, 0644);
	if (fd < 0)
	{
		perror("open lseek.txt");
		exit(1);
	}

	write(fd, msg, strlen(msg));
	
	lseek(fd, 0, SEEK_SET);

	while ((n = read(fd, &ch, 1))) // 1个1个字符往外读
	{
		if (n < 0)
		{
			perror("read error");
			exit(1);
		}
		write(STDOUT_FILENO, &ch, n); // 1个1个字符往屏幕上写
	}
	close(fd);

	return 0;
}

4、lseek结合实际IO写入-获取文件及扩展文件大小 

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <errno.h>
#include <fcntl.h>
#include <string.h>
#include <stdlib.h>

int main(void)
{
	int fd;
	off_t n;
	fd = open("lseek.txt", O_RDWR);
	if (fd < 0)
	{
		perror("open lseek.txt");
		exit(1);
	}

	n = lseek(fd, 0, SEEK_END);
	printf("文件大小 = %ld\n", n);

	printf("扩展1000字节\n");
	n = lseek(fd, 1000 - 1, SEEK_END);
	printf("文件大小 = %ld\n", n);
	// 真正拓展文件大小-引起文件IO操作
	write(fd, "\n", 1);

	close(fd);

	return 0;
}

5、trunctate拓展文件 

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/types.h>
#include <errno.h>
#include <stdlib.h>

int main(void)
{
	int n = truncate("./dict.txt", 1000);
	if (n == -1)
	{
		perror("truncate error");
		exit(1);
	}

	return 0;

}

6、stat获取文件属性(默认穿透)

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int ret;
	struct stat buf;
	ret = stat(argv[1], &buf);
	if (ret == -1)
	{
		perror("stat error");
		exit(1);
	}
	// 打印信息
	printf("size = %ld, inode = %ld\n", buf.st_size, buf.st_ino);
	// 判断文件类型
	switch (buf.st_mode & S_IFMT)
	{
		case S_IFLNK : 
			printf("软链接文件\n"); 
			break;
		case S_IFREG : 
			printf("普通文件\n"); 
			break;
		case S_IFBLK : 
			printf("块设备文件\n"); 
			break;
		case S_IFSOCK : 
			printf("套接字文件\n"); 
			break;
		case S_IFDIR : 
			printf("目录文件\n"); 
			break;
		case S_IFCHR : 
			printf("字符设备文件\n"); 
			break;
		case S_IFIFO : 
			printf("管道文件\n"); 
			break;
		default:
			printf("未知文件类型\n");
			break;
	};

	return 0;
}

6、lstat获取文件属性(不穿透) 

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int ret;
	struct stat buf;
	ret = lstat(argv[1], &buf);
	if (ret == -1)
	{
		perror("stat error");
		exit(1);
	}
	// 打印信息
	printf("size = %ld, inode = %ld\n", buf.st_size, buf.st_ino);
	// 判断文件类型
	switch (buf.st_mode & S_IFMT)
	{
		case S_IFLNK : 
			printf("软链接文件\n"); 
			break;
		case S_IFREG : 
			printf("普通文件\n"); 
			break;
		case S_IFBLK : 
			printf("块设备文件\n"); 
			break;
		case S_IFSOCK : 
			printf("套接字文件\n"); 
			break;
		case S_IFDIR : 
			printf("目录文件\n"); 
			break;
		case S_IFCHR : 
			printf("字符设备文件\n"); 
			break;
		case S_IFIFO : 
			printf("管道文件\n"); 
			break;
		default:
			printf("未知文件类型\n");
			break;
	};

	return 0;
}

7、利用link和ulink实现mv 

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

int main(int args, char *argv[])
{
    int ret1 = link(argv[1], argv[2]);
    if (ret1 == -1)
    {
        perror("link error");
        exit(1);
    }
    int ret2 = unlink(argv[1]);
    if (ret2 == -1)
    {
        perror("link error");
        exit(1);
    }

    return 0;
}

8、getcwd获取当前工作目录 和chdir改变工作目录 

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

int main(int argc, char *argv[])
{
    char buf[1024];
    char * str = getcwd(buf, 1024);
    if (str == NULL)
    {
        perror("getcwd error");
        exit(1);
    }
    printf("当前工作目录在%s\n", buf);
    int ret2 = chdir(argv[1]);
    if (ret2 == -1)
    {
        perror("chdir error");
        exit(1);
    }
    str = getcwd(buf, 1024);
    if (str == NULL)
    {
        perror("getcwd error");
        exit(1);
    }
    printf("当前工作目录在%s\n", buf);

    return 0;
}

9、readdir实现ls(无递归) 

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <dirent.h>
#include <stdlib.h>
// 判断文件类型
int IsDir(const char *str)
{
    int ret;
    struct stat buf;
    ret = stat(str, &buf);
    if (ret == -1)
    {
        perror("stat error");
        return -1; // 判断失败
    }
    if (S_ISDIR(buf.st_mode))
        return 1; // 是目录
    else
        return 0; // 其他文件类型
}

void LS(const char *path)
{
    int ret1 = IsDir(path);
    if (ret1 != 1)
        printf("%s ", path); // 非目录直接打印
    else // 目录--
    {
        // 1、打开目录
        DIR * dp = opendir(path);
        if (dp == NULL)
        {
            perror("opendir error");
            exit(1);
        } 
        // 2、循环的读目录
        struct dirent * dbuf;
        while ((dbuf = readdir(dp)) != NULL)
        {
            // ls默认隐藏.开头的文件
            if (dbuf->d_name[0] != '.')
                printf("%s ", dbuf->d_name);
        }
        // 3、关闭目录
        int ret2 = closedir(dp);
        if (ret2 == -1)
        {
            perror("closedir error");
            exit(1);
        }
    }
    return ;
}

int main(int argc, char *argv[])
{
    if (argc == 1)
        LS("./");
    else
    {
        for (int i = 1; i < argc; ++i)
            LS(argv[i]);
    }
        
    return 0;
}

9、readdir实现ls(递归)  

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <dirent.h>
#include <stdlib.h>
// 判断文件类型
int IsDir(const char *str)
{
    int ret;
    struct stat buf;
    ret = stat(str, &buf);
    if (ret == -1)
    {
        perror("stat error");
        return -1; // 判断失败
    }
    if (S_ISDIR(buf.st_mode))
        return 1; // 是目录
    else
        return 0; // 其他文件类型
}

void LS(const char *path)
{
    int ret1 = IsDir(path);
    if (ret1 != 1)
        printf("%s\n", path); // 非目录直接打印
    else                     // 目录--
    {
        // 1、打开目录
        DIR *dp = opendir(path);
        if (dp == NULL)
        {
            perror("opendir error");
            exit(1);
        }
        // 2、循环的读目录
        struct dirent *dbuf;
        while ((dbuf = readdir(dp)) != NULL)
        {
            // ls默认隐藏.开头的文件
            if (dbuf->d_name[0] == '.')
                continue;
            // 1、判断读出来的文件是目录?
            if (dbuf->d_type == DT_DIR)
            {
                // 2、是目录-递归调用自己
                // 拼接绝对路径
                printf("%s\t", dbuf->d_name);
                char pj[BUFSIZ];
                sprintf(pj, "%s%s%s", path, "/", dbuf->d_name);
                // printf("pj = %s\n", pj);
                LS(pj);
                printf("\n");
            }
            // 2、不是目录-打印-读下一个目录项
            else
            {
                if (dbuf->d_name[0] != '.')
                    printf("%s\t", dbuf->d_name);
            }
        }
        // 3、关闭目录
        int ret2 = closedir(dp);
        if (ret2 == -1)
        {
            perror("closedir error");
            exit(1);
        }
    }
    return;
}

int main(int argc, char *argv[])
{
    if (argc == 1)
        LS("./");
    else
    {
        for (int i = 1; i < argc; ++i)
            LS(argv[i]);
    }

    return 0;
}

10、dup和dup2重定向文件描述符 

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

int main(int argc, char *argv[])
{
    int fd1 = open(argv[1], O_RDWR | O_APPEND);
    if (fd1 == -1)
    {
        perror("open error");
        exit(1);
    }
    printf("fd1 = %d\n", fd1);
    int fd2 = dup(fd1);
    printf("fd2 = %d\n", fd2);
    // read write共用同一个位置(追加O_APPEND/lseek SEEK_END设置写入位置为末尾)
    int ret2 = write(fd1, "old write\n", 10);
    if (ret2 == -1)
    {
        perror("old write");
        exit(1);
    }
    int ret3 = write(fd2, "----test----\n", 13);
    if (ret3 == -1)
    {
        perror("write error");
        exit(1);
    }
    
    int ret4 = close(fd1);
    if (ret4 == -1)
    {
        perror("close error");
        exit(1);
    }

    return 0;
}
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>

int main(int argc, char *argv[])
{
    int fd1 = open(argv[1], O_RDWR | O_APPEND);
    if (fd1 == -1)
    {
        perror("open error");
        exit(1);
    }
    printf("旧fd1 = %d\n", fd1);
    int fd2 = open(argv[2], O_RDWR | O_APPEND);
    if (fd2 == -1)
    {
        perror("open error");
        exit(1);
    }
    printf("新fd2 = %d\n", fd2);
    int ret1 = dup2(fd1, fd2);
    if (ret1 == -1)
    {
        perror("dup2 error");
        exit(1);
    }
    printf("dup2返回值 = %d\n", ret1);
    // read write共用同一个位置(追加O_APPEND/lseek SEEK_END设置写入位置为末尾)
    int ret2 = write(fd1, "old write\n", 10);
    if (ret2 == -1)
    {
        perror("old write");
        exit(1);
    }
    int ret3 = write(fd2, "----test----\n", 13);
    if (ret3 == -1)
    {
        perror("write error");
        exit(1);
    }
    
    int ret4 = close(fd1);
    if (ret4 == -1)
    {
        perror("close error");
        exit(1);
    }
    
    return 0;
}

9、dup2重定向标准输出 

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


int main(int argc, char *argv[])
{
    int fd = open(argv[1], O_RDWR | O_APPEND);
    if (fd == -1)
    {
        perror("open error");
        exit(1);
    }
    int ret1 = dup2(fd, STDOUT_FILENO); // 重定向标准输出-打开的文件上
    if (ret1 == -1)
    {
        perror("dup2 error");
        exit(1);
    }
    printf("dup2返回值%d\n", ret1);
    int i = 0;
    while (i < 20)
    {
        printf("hello %d\n", i);
        ++i;
        sleep(1);        
    }

    return 0;
}

9、fcntl实现dup2

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

int main(int argc, char *argv[])
{
    int fd1 = open(argv[1], O_RDWR | O_APPEND);
    printf("fd1 = %d\n", fd1);
    write(fd1, "the first write\n", 17);

    int ret = fcntl(fd1, F_DUPFD, 0); // 返回1个新的文件描述符--类似dup(fd); dup2(fd1, fd2);
    printf("newfd = %d\n", ret);
    write(ret, "the second write\n", 18);

    int ret1 = fcntl(fd1, F_DUPFD, 7); // 返回1个新的文件描述符--类似dup(fd); dup2(fd1, fd2);
    printf("newfd1 = %d\n", ret1);
    write(ret1, "the third write\n", 17);
    write(7, "the third 7 write\n", 19);

    return 0;
}
汪呈祥
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
管道piep使用ReadFile读取阻塞问题解决
胸怀世界
04-11 1万+
0x01.CreatePipe管 道（Pipe）实际是用于进程间通信的一段共享内存，创建管道的进程称为管道服务器，连接到一个管道的进程为管道客户机。一个进程在向管道写入数据后，另 一进程就可以从管道的另一端将其读取出来。匿名管道（Anonymous Pipes）是在父进程和子进程间单向传输数据的一种未命名的管道，只能在本地计算机中使用，而不可用于网络间的通信。BOOL WINAPI CreatePi
C语言命名管道open阻塞的原因与解决方法
阿猪米德的小本本
05-20 3320
C语言命名管道open阻塞的原因与解决方法 open()的第一个参数是文件路径，第二个参数是打开的文件的读写方式（只写，只读，读写）与堵塞/非堵塞设置。 由于open函数的第二个参数如果加上O_NONBLOCK非堵塞，则会在执行open的时候立即返回，若出错则会设置errno。本话题旨在解决不设置O_NONBLOCK非堵塞时出现的堵塞情况分析。 查阅博客资料，发现有关读写打开的堵塞在此不再赘述，请...
编写Linux设备驱动中的read、open函数
weixin_53318672的博客
12-09 1670
1.前期准备 前面已经定义了驱动层的字符数组大小为1000。 #define BUF_SIZE 1000; struct demo_device{ char *buffer[100]; struct miscdevice *mdev; }; struct demo_device *demo_dev; 2.设备驱动读函数open 废话不多说，直接上代码！简单粗暴。 static ssize_t demo_read(struct file *file, char __user *buf,
【无标题】
zlcjyg的博客
02-20 78
文件IO函数整理
0041__管道piep使用ReadFile读取阻塞问题解决
行潇
06-01 2074
https://blog.csdn.net/ktpd_pro/article/details/70049800?utm_source=blogxgwz7 0x03.管道piep使用ReadFile读取阻塞问题解决 方法一：创建一个pipe然后是cmd执行的结果输出到pipe里，然后再读取，这里遇到一个问题就是在hInput 这个witepipe写完之后得关闭，使write 结束，这样之后的readfile才可以执行而不被阻塞； ...
Linux应用编程和网络编程入门思维导图
最新发布
03-29
### Linux应用编程与网络编程入门知识点 #### 一、Linux 文件 I/O 操作 Linux 文件 I/O 是指在Linux操作系统中进行文件的读写操作。Linux 提供了一系列强大的文件 I/O 接口，使得开发者能够方便地进行文件的读写。...
linux网络编程-宋敬彬-part1
03-03
第1章 Linux操作系统概述 2 1.1 Linux发展历史 2 1.1.1 Linux的诞生和发展 2 1.1.2 Linux名称的由来 1.2 Linux的发展要素 3 1.2.1 UNIX操作系统 4 1.2.2 Minix操作系统 4 1.2.3 POSIX 标准 4 1.3 Linux与...
Linux系统编程_CN
03-20
### Linux系统编程知识点详解 #### 一、绪论与核心概念 **1.1 什么是系统编程** 系统编程是指直接与操作系统交互的编程活动，它通常涉及到操作系统的底层功能和服务。这种类型的编程需要程序员深入理解操作系统的...
对ReadFile堵塞进行异步处理
qq_43248127的博客
07-19 1962
此前使用ReadFile函数时，都是同步，这样会导致比如说一条管道，一端写入，另一端读取。若写入端出现问题或者写入不成功，读取端会一直堵塞在ReadFile处，程序就一直卡住。版权声明本文为CSDN博主「bangtan辉」的原创文章，遵循CC4.0BY-SA版权协议，转载请附上原文出处链接及本声明。原文链接https//blog.csdn.net/bangtanhui/article/details/122122560。...
失败的windows系统服务调用readfile():管道已结束?_windows安全初探之命名管道
weixin_35945980的博客
01-24 534
原创 lengyi 合天智汇 前言：最近学校开了操作系统这门课，记录自己学习命名管道中与网络安全有关的内容。关于命名管道：“命名管道”又名“命名管线”(Named Pipes)，是一种简单的进程间通信(IPC)机制，Microsoft Windows大都提供了对它的支持(但不包括Windows CE)。命名管道可在同一台计算机的不同进程之间或在跨越一个网络的不同计算机的不同进程之间，支持可靠的、单...
（转）关于有名管道open时阻塞的问题
kuimzzs的博客
02-18 890
遇到一个问题，刚好这位博主有总结，转一下 原文：https://blog.csdn.net/men_wen/article/details/59158365  关于有名管道open时阻塞的问题 1. 发现错误 在学习Unix网络编程卷二的有名管道FIFO时，无意间犯下一个错误，故写此总结。  在写FIFO的服务器和客户端之间通信的代码时，服务器端主函数创建两个有名管道，然后分被以读写打开两个...
关于fifo的open阻塞问题
无与伦比BLOG
07-28 5711
进程间通信之fifo，在阻塞模式下，只有当读和写模式都打开时才返回，否则一直阻塞； 非阻塞模式下，当读端没打开，则打开写端无效，返回错误。 建议你读一读UNP卷2。 a. 不使用O_NONBLOCK标志时，只读open要阻塞到某个其它进程为写而打开它为止 b. 不使用O_NONBLOCK标志时，只写open要阻塞到某个其它进程为读而打开它为止 c. 如果在open的时候指定O_N
linux系统下实现文件拷贝
coffee0218的博客
07-28 4105
linux系统下实现文件的方式
Unix/Linux编程：lseek函数与文件偏移量详解
"这篇文档是关于Unix操作系统的教程，特别是关注于lseek函数的使用以及Unix/Linux核心编程的各个主题。文档涵盖了从操作系统基础到高级编程技术，包括内存管理、文件I/O、进程管理、信号处理、进程间通信、多线程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

汪呈祥

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值