Linux实现自己的ls命令-a -l -R

最新推荐文章于 2023-02-03 16:26:58 发布
最新推荐文章于 2023-02-03 16:26:58 发布
阅读量433 收藏 8
点赞数 3
分类专栏： c linux 文章标签： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51665789/article/details/115414089
版权
c 同时被 2 个专栏收录
10 篇文章 0 订阅
订阅专栏
linux
6 篇文章 0 订阅
订阅专栏

目前已完成：

  • -a -l -R随机组合
  • 输出对齐
  • 屏蔽ctrl+c信号
  • 文件名排序（冒泡）
  • 在任意目录下使用
    将编译生成的文件放入/usr/bin中即可

注意

  1. 未根据文件属性加入不同的颜色
  2. 使用快排将路径名下标排序之后报段错误

输出颜色

printf("\033[字背景颜色;字体颜色m字符串\033[0m" );

//ps:
printf("\033[47;31mThis is a color test.\033[0m");

本文未对输出的字体颜色进行调整，如果有兴趣可以在本文的几个函数中加入适当的参数，稍加调整即可。

实现ls命令需要用到的几个函数

理解以下几个函数的具体作用是实现ls命令的基础

stat.h:
lstat();

dirent.h:
opendir();
readdir();
closedir();

本代码中还大量用到了字符串的复制拼接操作，如

strcpy();
strcat();

以下为源代码：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<time.h>
#include<sys/stat.h>
#include<sys/types.h>
#include<linux/limits.h>
#include<dirent.h>
#include<grp.h>
#include<pwd.h>
#include<signal.h>
#include<errno.h>

#define PARAM_NONE  0
#define PARAM_A     1
#define PARAM_L     2
//#define PARAM_R     4

#define MAXROWLEN   80
#define MAXLEN    51200

int PARAM_R = 0;    //-R命令

int g_leave_len = MAXROWLEN;
int g_maxlen;

void my_err(const char *err_string, int line);
void display_dir(int flag_param, char * path);
void display(int flag, char * pathname);
void display_single(char * name);
void display_attribute(struct stat buf, char * name);
void display_R(int flag, char *filename);
void examine(int len, char *filename);
void qsort_string(char **num, int order[], int start, int finish);
int color(char *filename);
//目录蓝色  普通文件绿色


int main(int argc, char * argv[])
{
    int i, j, k, num;
    char path[PATH_MAX + 1];
    char param[32];     //保存命令行参数，目标文件名和目录名不在此列
    int flag_param = PARAM_NONE;    //参数种类，即是否有-l和-a选项
    struct stat buf;

    signal(SIGINT, SIG_IGN);    //屏蔽ctrl+c信号

    //命令行参数的解析，分析-l、-a、-al、-la选项
    j = 0;
    num = 0;
    for(i=1; i<argc; i++)
    {
        if(argv[i][0] == '-')
        {
            for(k=1; k<strlen(argv[i]); k++, j++)
            {
                param[j] = argv[i][k];  //获取-后面的参数保存到数组param中
            }
            num++;      //保存'-'的个数
        }
    }

    for(i=0; i<j; i++)
    {
        if(param[i] == 'a')
        {
            flag_param |= PARAM_A;
            continue;
        }
        else if(param[i] == 'l')
        {
            flag_param |= PARAM_L;
            continue;
        }
        else if(param[i] == 'R')
        {
            PARAM_R = 1;
            continue;
        }
        else
        {
            printf("my_ls: invalid option -%c\n", param[i]);
            exit(1);
        }
    }
    param[j] = '\0';

    //如果没有输入文件名或目录，就显示当前目录
    if((num + 1) == argc)
    {
        strcpy(path, "./");
        path[2] ='\0';
        display_dir(flag_param, path);

        return 0;
    }

    i = 1;
    do
    {
        //如果不是目标文件名或目录，就显示当前目录
        if(argv[i][0] == '-')
        {
            i++;
            continue;
        }
        else
        {
            strcpy(path, argv[i]);

            //如果目标文件或目录不存在，报错并退出程序
            if(lstat(path, &buf) == -1)
            {
                my_err("stat", __LINE__);
            }

            if(S_ISDIR(buf.st_mode))
            {
                //argv[i]是一个目录
                //如果目录的最后一个字符不是'/'，就加上'/'
                if(path[strlen(argv[i]) - 1] != '/')
                {
                    path[strlen(argv[i])] = '/';
                    path[strlen(argv[i]) + 1] = '\0';
                }
                else
                {
                    path[strlen(argv[i])] = '\0';
                }

                display_dir(flag_param, path);
                i++;
            }
            else
            {
                //argv[i]是一个文件
                display(flag_param, path);
                i++;
            }
        }
    } while(i<argc);

    return 0;
}

void display_dir(int flag_param, char * path)
{
    DIR *dir;
    struct dirent *ptr;
    int count = 0;  //记录该目录下文件的数量
    char temp[PATH_MAX+1];

    //打开目录
    //获取该目录下文件总数和最长文件名
    dir = opendir(path);
    if(dir == NULL)
    {
        my_err("opendir", __LINE__);
    }
    while((ptr = readdir(dir)) != NULL)
    {
        if(g_maxlen < strlen(ptr->d_name))
        {
            g_maxlen = strlen(ptr->d_name);
        }
        count++;
    }
    //关闭目录
    closedir(dir);

    if(count > MAXLEN)
    {
        printf("too many files under this dir", __LINE__);
    }

    //获取该目录下所有文件路径名
    int i, j, len = strlen(path);
    dir = opendir(path);

    char **filenames = (char **)malloc(sizeof(char *)*MAXLEN);
    for(i=0; i<count; i++)
    {
        filenames[i] = (char *)malloc(sizeof(char)*MAXLEN);
    }
    //char filenames[MAXLEN][MAXLEN];

	//获取路径名到filenames中
    for(i=0; i<count; i++)
    {
        ptr = readdir(dir);
        if(ptr == NULL)
        {
            my_err("readdir", __LINE__);
        }
        //先获取该目录的路径
        strncpy(filenames[i], path, len);
        //examine用来修正路径名
		examine(len, filenames[i]);
		//在修正之后的路径名后拼接上文件名
		strcat(filenames[i], ptr->d_name);
		filenames[i][len+1+strlen(ptr->d_name)] = '\0';
    }


    //使用冒泡法对路径名进行排序
    //由于路径相同，因此也就是对文件名进行排序
    for(i=0; i<count-1; i++)
    {
        for(j=0; j<count-i-1; j++)
        {
            if(strcmp(filenames[j], filenames[j+1]) > 0)
            {
                strcpy(temp, filenames[j]);
                temp[strlen(filenames[j])] = '\0';
                strcpy(filenames[j], filenames[j+1]);
                filenames[j][strlen(filenames[j+1])] = '\0';
                strcpy(filenames[j+1], temp);
                filenames[j+1][strlen(temp)] = '\0';
            }
        }
    }

	//使用快排对路径名的下标进行排序
	//而不进行实际的strcpy
	/*int order[count];
	for(i=0; i<count; i++)
	{
		order[i] = i;
	}
	qsort_string(filenames, order, 0, count-1);*/
    
    //如果有-R参数，就先打印出路径名
    if(PARAM_R)
    {
        printf("\n %s :\n", path);
    }

    //int color_num;
    //输出文件名
    for(i=0; i<count; i++)
    {
        display(flag_param, filenames[i]);
    }
    /*for(i=0; i<count; i++)
    {
        //color_num = color(filenames[i]);
        display(flag_param, filenames[order[i]]);
    }*/
    printf("\n");

    closedir(dir);

    //printf("Hello!");
    //如果命令行中没有-l选项，打印一个换行符
    /*if((flag_param & PARAM_L) == 0)
    {
        //printf("Hello!");
        printf("\n");
    }*/

    //进行递归
    if(PARAM_R)
    {
        for(i=2; i<count; i++)
        {
            display_R(flag_param, filenames[i]);
        }
    }
}

//根据命令行参数和完整路径名显示目标文件
//参数 flag：命令行参数     如：-a、-l
//参数 pathname：包含了文件名的路径名
void display(int flag, char * pathname)
{
    int i,j;
    struct stat buf;    //获取文件的属性
    char name[MAXLEN];  //存储文件名

    //从路径中解析出文件名
    for(i=0,j=0; i<strlen(pathname); i++)
    {
        if(pathname[i] == '/')
        {
            j=0;
            continue;
        }
        name[j++] = pathname[i];
    }
    name[j] = '\0';
    //printf("%s ", name);
    //用lstat而不是stat以方便解析链接文件
    //lstat返回的是符号链接文件本身的状态信息

    //exit(0);
    if(lstat(pathname, &buf) == -1)
    {
        printf("pathname :%s\n",pathname);
        my_err(" stat",__LINE__);
    }

    switch(flag)
    {
        case PARAM_NONE:        //没有-l和-a选项
            if(name[0] != '.')  //如果遇到隐藏文件则直接break
            {
                display_single(name);
            }
            break;
    
    case PARAM_A:           //-a：显示包括隐藏文件在内的所有文件
        display_single(name);
        break;

    case PARAM_L:           //-l：每个文件单独占一行， 显示文件的详细属性信息
        if(name[0] != '.')  //如果遇到隐藏文件则直接break
        {
            display_attribute(buf, name);
            printf(" %-s\n", name);
        }
        break;

    case PARAM_A + PARAM_L: //同时有-a和-l选项的情况
        display_attribute(buf, name);
        printf(" %-s\n", name);
        break;

    default:
        break;
    }
}

void display_single(char * name)
{
    int i,len;

    //如果本行不足以打印一个文件名则换行
    if(g_leave_len < g_maxlen)
    {
        printf("\n");
        g_leave_len = MAXROWLEN;
    }

    len = strlen(name);
    len = g_maxlen - len;
    printf("%-s", name);
    //printf("\033[%dm%s\033[0m\t",  name); //输出自体带颜色的语法，其中%d是颜色

    for(i=0; i<len; i++)
    {
        printf(" ");
    }

    printf("  ");
    g_leave_len -= (g_maxlen + 2);
}


void display_attribute(struct stat buf, char * name)
{
    char buf_time[32];
    struct passwd *psd;         //从该结构体中获取文件所有者的用户名
    struct group *grp;          //从该结构体中获取文件所有者所属组的组名

    //获取并打印文件类型
    if(S_ISLNK(buf.st_mode)){
        printf("l");
    }
    else if(S_ISREG(buf.st_mode)){
        printf("-");
    }
    else if(S_ISDIR(buf.st_mode)){
        printf("d");
    }
    else if(S_ISCHR(buf.st_mode)){
        printf("c");
    }
    else if(S_ISBLK(buf.st_mode)){
        printf("b");
    }
    else if(S_ISFIFO(buf.st_mode)){
        printf("f");
    }
    else if(S_ISSOCK(buf.st_mode)){
        printf("s");
    }
    
    //获取并打印文件所有者的权限
    if(buf.st_mode & S_IRUSR){
        printf("r");
    }
    else{
        printf("-");
    }

    if(buf.st_mode & S_IWUSR){
        printf("w");
    }
    else{
        printf("-");
    }

    if(buf.st_mode & S_IXUSR){
        printf("x");
    }
    else{
        printf("-");
    }

    //获取并打印与文件所有者同组的用户对该文件的操作权限
    if(buf.st_mode & S_IRGRP){
        printf("r");
    }
    else{
        printf("-");
    }

    if(buf.st_mode & S_IWGRP){
        printf("w");
    }
    else{
        printf("-");
    }

    if(buf.st_mode & S_IXGRP){
        printf("x");
    }
    else{
        printf("-");
    }

    //获取并打印其他用户对该文件的操作权限
    if(buf.st_mode & S_IROTH){
        printf("r");
    }
    else{
        printf("-");
    }

    if(buf.st_mode & S_IWOTH){
        printf("w");
    }
    else{
        printf("-");
    }

    if(buf.st_mode & S_IXOTH){
        printf("x");
    }
    else{
        printf("-");
    }

    printf("    ");


    //根据uid与gid获取文件所有者的用户名与组名
    psd = getpwuid(buf.st_uid);
    grp = getgrgid(buf.st_gid);
    printf("%-4d", buf.st_nlink);    //打印文件的链接数
    printf("%-8s", psd->pw_name);
    printf("%-8s", grp->gr_name);

    printf("%6d", buf.st_size);     //打印文件的大小
    strcpy(buf_time, ctime(&buf.st_mtime));
    buf_time[strlen(buf_time) - 1] = '\0';  //去掉换行符
    printf(" %s", buf_time);                //打印文件的时间信息
}

void display_R(int flag, char *filename)
{
    //获取文件属性信息
    struct stat buf;
    lstat(filename, &buf);

    //如果是目录的话进行递归
    if(S_ISDIR(buf.st_mode))
    {
        int i,j;
        char name[MAXLEN];  //从路径名中获取文件名

        for(i=0; i<strlen(filename); i++)
        {
            if(filename[i] == '/')
            {
                j = 0;
                continue;
            }
            name[j++] = filename[i];
        }
        name[j] = '\0';

        switch(flag)
        {
            case PARAM_NONE:
                if(name[0] != '.')
                    display_dir(flag, filename);
                    break;
            case PARAM_A:
                display_dir(flag, filename);
                break;
            case PARAM_L:
                if(name[0] != '.')
                    display_dir(flag, filename);
                    break;
            case PARAM_A + PARAM_L:
                display_dir(flag, filename);
                break;
            default:
                break;
        }
    }
}

void my_err(const char *err_string, int line)
{
    fprintf(stderr, "line:%d", line);
    perror(err_string);
    exit(1);
}

int color(char *filename)
{
    struct stat buf;
    lstat(filename, &buf);

    if(S_ISREG(buf.st_mode))
    {
        return 32;      //绿色
    }
    else if(S_ISDIR(buf.st_mode))
    {
        return 34;      //蓝色
    }

    return 0;
}

void examine(int len, char *filename)
{
    if(filename[len-1] != '/')
    {
        filename[len] = '/';
        filename[len+1] = '\0';
    }
    else
    {
        filename[len] = '\0';
    }
}

//对文件名的下标进行快排
void qsort_string(char **num, int order[], int start, int finish)
{
    int left = start;
    int right = finish;
    int duff;
    if(start < finish)
    {
        duff = order[start];
        while(start < finish && strcmp(num[order[finish]], num[duff]) >= 0)
        {
            finish--;
        }
        order[start] = order[finish];
        while(start < finish && strcmp(num[order[start]], num[duff]) <= 0)
        {
            start++;
        }
        order[finish] = order[start];
    }
    if(start == finish)
    {
        order[finish] = duff;
    }
    qsort_string(num, order, finish+1, right);
    qsort_string(num, order, left, finish-1);
}
魔法海螺yuto
关注
专栏目录
Linux的ls命令和ls -l列表信息
Jackice_Lee的博客
12-20 2192
Linux ls linux ls 命令 含义：Linux ls（英文全拼：list files）命令用于显示指定工作目录下之内容（列出目前工作目录所含之文件及子目录)。 语法： ls [-alrtAFR] [name…] 参数 : -a 显示所有文件及目录 (. 开头的隐藏文件也会列出) -l 除文件名称外，亦将文件型态、权限、拥有者、文件大小等资讯详细列出 -r 将文件以相反次序显示(原定依英文字母次序) -t 将文件依建立时间之先后次序列出 -A 同 -a ，但不列出 “.” (目前目录) 及 “…”
LinuxC编程——ls的实现（-R,-a,-l）
dream0130__的博客
07-28 5275
Linux下的系统编程指的是程序员使用系统调用或C语言本身所携带的库函数来设计和编写某一特定的程序 ls是日常所用的比较常见的命令之一,那么如何实现ls命令 首先实现ls要明确参数的作用是什么 ls -a 可以将目录中的所有文件（包括以.开头的文件）显示出来 ls -l 列出文件中的所有信息，包括文件的属性和权限等数据 ls -R 使用递归连同目录中的子目录中的文...
自己实现linux下ls命令的代码
12-23
使用c语言实现linux下的ls命令，功能齐全，代码精简，适合初学者进行学习与研究
实现自己的ls命令
weixin_30552811的博客
07-27 131
实现自己的ls命令 估计每个使用过linux系统的人都知道ls是啥吧。也相信大家都对ls的简单命令烂熟于心了吧，这里就不想再赘述了，直接进入正题吧。 代码里面会有许多注释，相信的家一定能看懂的。 说明：此代码我在kail linux下编译无任何错误，运行也基本无bug，相信大家在一般linux下运行也无问题。 代码： #include <stdio.h> #include...
自己实现 ls命令
Tattoo的博客
05-07 458
实现代码如下： #include #include #include #include #include #include #include #include #include #include #include #include #define PARAM_NONE 0 #define PARAM_A 1 #define PARAM_L 2 #define MAXROWLEN
ls命令的自己实现
YinJianxiang的博客
07-21 1420
ls命令的自己实现
实现自己的LS指令
m0_61924236的博客
04-21 216
实验要求 ls 的这些 -a、-l、-R、-t、-r、-i、-s 参数实现，并允许任意参数组合。 -R需要通对/的遍历测试 界面外观（输出、与颜色显示等） 资源与目标 开发记录、总结、发布在个人博客中 这个很早前就完成了，但是一直没有发博客，现在补上。 #include <stdio.h> #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #include &l
linux 系统命令 ls -l命令的实现
07-15
通过理解上述知识点，你可以自己编写一个基本的`ls -l`命令实现，或者更好地理解现有的`ls`命令的工作原理。在实际操作中，理解这些底层机制有助于优化和调试相关问题，或者开发自定义的文件管理系统工具。
Linux程序设计课程要求实现ls(-l,-a,-i,-R,-d)、wc_[filename]命令_ls_wc_achiev
最新发布
09-17
Linux程序设计课程要求实现ls(-l,-a,-i,-R,-d)、wc_[filename]命令_ls_wc_achieve
linux_ls_-l.zip_linux c ls_ls_l linux
09-19
在Linux操作系统中，`ls`命令是一个非常基础且重要的工具，用于列出目录中的文件和子目录。`ls -l`是其一个常用的选项，它会以长格式显示文件的详细信息，包括权限、所有者、组、大小、修改日期以及文件或链接的名字...
自定义函数实现linux ls -a -l 命令_ls函数linux_自定义函数实现linux命令_
10-01
自定义函数实现linux ls -a -l 命令
自己实现linux下ls命令 的两个选项
12-18
自己c实现linux下ls的两个选项 给大家提供个思路
自己写的linux ls 命令 包括 -l -R -a -U 及各种组合，还有是三种特殊位
06-01
自己写的linux ls 命令 包括 -l -R -a -U 及各种组合，还有是三种特殊位
ls -R 递归显示
12-17
这是自己写的ls -R函数，实现了分栏、隐藏文件隐藏、上色等功能，没有排序。用的时候根据输入不同有两种功能 ls 和ls -R 、用的时候只要再加一个主函数就可以了。
[GNU/Linux] 自己实现ls
Pangda code twice
07-23 551
随便扯点什么实际上刚开始让我实现ls（1）我是拒绝的，因为，你不能让我写，我就马上去写，第一我要看一下，因为我不愿意写完了以后再加一些特技上去，比如ls忽然“Segmentation Fault”了，很懵逼、很低能，这样用过ls的人出来一定会骂我，根本没有这样辣鸡的ls，就证明这ls一点也不好用，就是在骗人。后来组长告诉我只用实现-a -l -R就好，我写了两天左右，感觉还不错，后来我在使用的时候就
Linux系统编程：简单实现ls -R 功能
重庆李四
04-05 4624
实现效果这是系统提供的这是自己实现的实现思路主要是目录项的读取和文件详细信息的获取以及文件类型的判断。打开目录opendir-&gt;读取目录readdir-&gt;展示文件名-&gt;判断是否是普通文件还是目录文件是目录文件保存目录文件路径-&gt;递归遍历目录文件。这里主要用到函数原型是 opendir,closedir,readdir,lstat函数。还有就是文件类型的判断，自己封装简单封装...
linux中 r命令,在linux中实现ls -R命令
weixin_42377196的博客
04-29 957
这是在C的简单的Linux ls -R实现它给有色类似ls#include #include #include #define GREEN "\x1b[32m"#define BLUE "\x1b[34m"#define WHITE "\x1b[37m"void Usage() {fprintf(stderr, "\nUsage: exec [OPTION]... [DIR]...\n");fpr...
[Linux C/C++] 实现ls -R的命令
DreamTrue520的博客
02-03 2312
关于C++语言的基础知识可以点开笔者主页专栏【跟我一起从C到C++】ls命令，想必大家在使用Linux时，都感觉十分亲切，日常必用命令之一：它可以罗列文件夹和文件，让人们更加清晰地管理自己的文件。 本文主要实现： 一、读取目录 二、分析选项 三、递归实现-R 四、输出颜色
ls -al命令的实现
qq_43666119的博客
04-24 384
#include <stdio.h> #include <string.h> #include <stdlib.h> #include <unistd.h> #include <sys/types.h> #include <sys/stat.h> #include <dirent.h> #include <time.h> #include <errno.h> #include <pwd.h&gt
Linux基础命令详解：从控制台到ls-a与ls-l
`ls -a`显示所有文件，包括以`.`开头的隐藏文件。`ls -l`则以长格式列出文件，提供更多的文件信息，如权限、所有者、大小、创建日期等。 文件属性栏位的解释如下： - 第一个小格：文件类型。d代表目录，-代表普通...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值