MiniShell 项目总结 2月21~22日总结

最新推荐文章于 2024-11-09 22:46:56 发布
最新推荐文章于 2024-11-09 22:46:56 发布
阅读量1k 收藏 13
点赞数 23
文章标签： linux 运维 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/l22221/article/details/136241041
版权

一、项目说明

利用Linux中IO接口实现 terminal 的shell命令 制作成一个minishell 的可执行文件

输出形式为：

[linux@Ubuntu:当前所在目录]

项目要求：

一、基本实现

  1.         cd
  2.         ls 
  3.         ls -l
  4.         ls -a
  5.         pwd
  6.         mkdir
  7.         mv
  8.         rm
  9.         rmdir
  10.         cp
  11.         touch
  12.         cat
  13.         ln

这13个shell 命令

  二、将用户输入命令的时间及其命令写入到日志文件中并纪录
  三、根据代码功能,将代码划分成若干个文件,并使用多文件编程来实现代码

 二、实现思路

1.打印终端命令行如何实现?
        [linux@Ubuntu:当前所在目录]                getcwd -> 绝对路径 -> 显示最后一部分内容
                                                                         /home/linux/Desktop/dirname

2.能够接收用户的命令?
        ls                                       fgets -> 解析字符串获得命令及其参数
        touch a.txt                             
        rmdir dirname 
        cp a.txt b.txt 

* 难点在于如何解析输入进去的字符串

        后面有三种方法：分别是 1.切割字符串存入新的字符串中

                                                 2.使用指针 

                                                3.使用strtok函数

将获得的一段段字符串分别进行传参。

3.实现对应命令?
        ls                                       opendir readdir closedir 
        ls -a                                   opendir readdir closedir 
        ls -l                                   
        touch                                   fopen fclose 
        rm                                    remove 
        mkdir                                   mkdir 
        rmdir                                   rmdir 
        cp                                       IO 
        cat                                      IO 
        ln                                    symlink link 
        pwd                                   getcwd 
        cd                                    chdir 

        mv                                    rename 
        chmod                                 chmod 


4.命令记录
        写入文件                              fopen fprintf fclose

三、具体实现

 分为

main.c

command.c

command.h

terminal.c

terminal.h

record.c

record.h

record.txt

makfile  (进行链接)

首先是 main.c  其中定义了 接收命令的数组


#include<stdio.h>
#include<string.h>
#include"terminal.h"
#include"command.h"
#include"record.h"
int main(void)
{
    char command[1024] = {0};
    char *parg[10] = {NULL};
    int curcmdlen = 0;
    InitRecord();
    while(1)
    {
        ShowTerminal();
        GetCommand(command,1024);
        if(!strcmp(command,"exit"))
        {
            break;
        }

        curcmdlen = SplitCommand(command,parg,10);
        ExecCommand(parg,curcmdlen);
    }

    return 0;
}

command.c

#include<sys/types.h>
#include<sys/stat.h>
#include<unistd.h>
#include<fcntl.h>
#include<stdio.h>
#include<string.h>
#include<dirent.h>
#include<pwd.h>
#include<grp.h>
#include<time.h>
int Myls(void)
{
    DIR *dp = NULL;
    struct dirent *pp =NULL;

    dp = opendir(".");
    if(NULL == dp)
    {
        perror("fail to opendir");
        return -1;
    }

    while(1)
    {
        pp = readdir(dp);
        if(NULL == pp)
        {
            break;
        }

        if('.' == pp->d_name[0])
        {
            continue;
        }
        printf("%s  ",pp->d_name);
    }
    putchar('\n');
    closedir(dp);
    return 0;
}

int Myls_a(void)
{
    DIR *dp = NULL;
    struct dirent *pp =NULL;

    dp = opendir(".");
    if(NULL == dp)
    {
        perror("fail to opendir");
        return -1;
    }

    while(1)
    {
        pp = readdir(dp);
        if(NULL == pp)
        {
            break;
        }
        printf("%s  ",pp->d_name);
    }
    putchar('\n');
    closedir(dp);
    return 0;
}
int DisplayFile(char *pfilename)
{
    struct stat buf;
    int ret = 0;
    struct passwd *pwd =NULL;
    struct group *grp = NULL;
    struct tm *ptm =NULL;
    char tmpbuff[1024] = {0};
    char *mon[12] = {"Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"};

    ret = lstat(pfilename,&buf);
    if(-1 == ret)
    {
        perror("fail to lstat");
        return -1;
    }

    if(S_ISBLK(buf.st_mode))
    {
        putchar('b');
    }
    else if(S_ISCHR(buf.st_mode))
    {
        putchar('c');
    }
    else if(S_ISDIR(buf.st_mode))
    {
        putchar('d');
    }
    else if(S_ISREG(buf.st_mode))
    {
        putchar('-');
    }
    else if(S_ISLNK(buf.st_mode))
    {
        putchar('l');
    }
    else if(S_ISSOCK(buf.st_mode))
    {
        putchar('s');
    }
    else if(S_ISFIFO(buf.st_mode))
    {
        putchar('p');    
    }

    buf.st_mode & S_IRUSR ?putchar('r'):putchar('-');
    buf.st_mode & S_IWUSR ?putchar('w'):putchar('-');
    buf.st_mode & S_IXUSR ?putchar('x'):putchar('-');

    buf.st_mode & S_IRGRP ?putchar('r'):putchar('-');
    buf.st_mode & S_IWGRP ?putchar('w'):putchar('-');
    buf.st_mode & S_IXGRP ?putchar('x'):putchar('-');

    buf.st_mode & S_IROTH ?putchar('r'):putchar('-');
    buf.st_mode & S_IWOTH ?putchar('w'):putchar('-');
    buf.st_mode & S_IXOTH ?putchar('x'):putchar('-');

    printf("%ld",buf.st_nlink);

    pwd = getpwuid(buf.st_uid);
    printf(" %s",pwd->pw_name);

    grp = getgrgid(buf.st_gid);
    printf(" %s",grp->gr_name);

    printf("%5ld",buf.st_size);

    ptm = localtime(&buf.st_mtime);
    printf("%s %02d %02d:%02d",mon[ptm->tm_mon],ptm->tm_mday,ptm->tm_hour,ptm->tm_min);

    printf(" %s",pfilename);

    if(S_ISLNK(buf.st_mode))
    {
        readlink(pfilename,tmpbuff,sizeof(tmpbuff));
        printf("->%s",tmpbuff);
    }

    printf("\n");

    return 0;
}

int Myls_l(void)
{
    DIR *dp = NULL;
    struct dirent*pp = NULL;

    dp = opendir(".");
    if(NULL == dp)
    {
        perror("fial to opendir");
        return -1;
    }

    while(1)
    {
        pp = readdir(dp);
        if(NULL == pp)
        {
            break;
        }

        if('.' == pp->d_name[0])
        {
            continue;
        }

        DisplayFile(pp->d_name);
    }
    closedir(dp);
    return 0;
}

int Touch(const char *filename)
{
    FILE *fp = NULL;

    fp = fopen(filename,"w");
    if(NULL == fp)
    {
        perror("fail fopen");
        return -1;
    }
    
    fclose(fp);

    return 0;

}

int Cp(const char *file1,const char *file2)
{
    FILE *fsrc = NULL;
    FILE *fdst = NULL;
    size_t nret = 0;
    char tmpbuff[4096] = {0};

    fsrc = fopen(file1,"r");
    if(NULL ==fsrc)
    {
        perror("fail to fopen");
        return -1;
    }

    fdst = fopen(file2,"w");
    if(NULL == fdst)
    {
        perror("fail to open");
        return -1;
    }

    while(1)
    {
        nret =fread(tmpbuff,1,sizeof(tmpbuff),fsrc);
        if(0 == nret)
        {
            break;
        }

        fwrite(tmpbuff,1,nret,fdst);
    }

    fclose(fsrc);
    fclose(fdst);

    return 0;
}
int Cat(char *pcmdbuf)
{
    FILE *fp = NULL;
    size_t ret = 0;
    int i = 0;
    char tmpbuff[4096] = "0";

    fp = fopen(pcmdbuf,"r");
    if(NULL == fp)
    {
        perror("fail to open");
        return -1;
    }
    ret=fread(tmpbuff,1,sizeof(tmpbuff),fp);
    for(i = 0;i<ret;++i)
    {
        printf("%c",tmpbuff[i]);
    }
    fclose(fp);
    return 0;
}
int Pwd(char* pcmdbuf)
{
    char tmpbuff[4096] ={0};
    getcwd(tmpbuff,sizeof(tmpbuff));
    printf("%s\n",tmpbuff);
    return 0;
}
int Ln(char *file1,char *file2)
{
    link(file1,file2);
    return 0;
}

int Mychmod(char *pcmdbuf,char *mode)
{
    int ret = 0;
    int len = strlen(mode);
    int num = 0;
    int i,j;
    int a[len];

    for(i = 0;i< len ;++i,++mode)
    {
        a[i] = *mode -48;
    }

    for(i = len -1,j = 1;i>=0;--i,j*=10)
    {
        num += a[i]*j;
    }

    chmod(pcmdbuf,num);
    return 0;
}

command.h

#ifndef _COMMAND_H
#define _COMMAND_H

extern int Myls(void);
extern int Myls_a(void);
extern int DisplayFile(char *pfilename);
extern int Myls_l(void);
extern int Touch(const char *filename);
extern int Cp(const char *file1,const char *file2);
extern int Cat(char *pcmdbuf);
extern int Pwd(char* pcmdbuf);
extern int Ln(char *file1,char *file2);
extern int Mychmod(char *pcmdbuf,char *mode);

#endif

terminal.c

#include<stdio.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<unistd.h>
#include<fcntl.h>
#include<stdio.h>
#include<string.h>
#include"command.h"
/*********************************
 * File Name:ShowTerminal
 * Parameter: void
 * Return value :  succes >0
 *                 fail   >-1
 ********************************/
int ShowTerminal(void)
{
    char tmpbuff[1024] = {0};
    char *ptmp = NULL;

    getcwd(tmpbuff,sizeof(tmpbuff));

    ptmp = tmpbuff + strlen(tmpbuff); // 首地址+字符串长度 尾 ‘/0’ 的地址
    while(*ptmp != '/')
    {
        ptmp--;
    }
    if(strcmp(tmpbuff,"/"))
    {
        ptmp++;
    }

    printf("[linux@Ubuntu:%s]",ptmp);

    return 0;
}
/*********************************
 * File Name:GetCommand
 * Parameter:  
 *          pcmdbuff:存放命令空间首地址
 *          maxlen:最大存放字符串个数
 * Return value :  succes >0
 *                 fail   >-1
 ********************************/
 int GetCommand(char *pcmdbuff,int maxlen)
 {
    fgets(pcmdbuff,maxlen,stdin);
    pcmdbuff[strlen(pcmdbuff)-1] = '\0';

    return 0;
 }

/*********************************
 * File Name:SplitCommand 解析命令 把命令分成小段 返回小段的个数
 * Parameter:  
 *          pcmdbuff:存放命令空间首地址
 *          maxlen:最大存放字符串个数
 *          parg:存放解析后字符串地址的指针数组
 * Return value :  succes >解析到命令的个数
 *                 fail   >-1
 ********************************/
 int SplitCommand(char *pcmdbuff,char **parg,int maxlen) // char **parg == char *parg[]
 {
    char *ptmp = NULL;
     int cnt = 0;

     ptmp = pcmdbuff;

     while(1)
     {
        parg[cnt] = ptmp;
         cnt++;
         while(*ptmp != '\0' && *ptmp != ' ')//指针在遇到‘ ’或最后的‘\0’时停下
         {
            ptmp++;
         }
         if('\0'== *ptmp)
         {
            break;
         }

         *ptmp = '\0';//给每个命令段后面补上 ‘\0’使其成为一个字符串

         ptmp++;
         while(*ptmp == ' ')
         {
            ptmp++;
         }
     }

     return cnt;
 }

/*********************************
 * File Name:ExecCommand  判断命令 
 * Parameter:  
 *          curlen:命令的个数
 *          parg:存放解析后字符串地址的指针数组
 * Return value :  succes >0
 *                 fail   >-1
 ********************************/
int ExecCommand(char **parg ,int curlen)
{
    if(!strcmp(parg[0],"ls"))
    {
        if(2 == curlen && !strcmp(parg[1],"-l"))
        {
            Myls_l();
            return 0;
        }
        else if(2 == curlen && !strcmp(parg[1],"-a"))
        {
            Myls_a();
            return 0;
        }
        Myls();
    }
    else if(!strcmp(parg[0],"cp"))
    {
        Cp(parg[1],parg[2]);
    }
    else if(!strcmp(parg[0],"cat"))
    {
        Cat(parg[1]);
    }    
    else if(!strcmp(parg[0],"pwd"))
    {
        Pwd(parg[1]);
    } 
    else if(!strcmp(parg[0],"ln"))
    {
        Ln(parg[1],parg[2]);
    }
    else if(!strcmp(parg[0],"cd"))
    {
        chdir(parg[1]);
    }
    else if(!strcmp(parg[0],"touch"))
    {
        Touch(parg[1]);
    }
    else if(!strcmp(parg[0],"mkdir"))
    {
        mkdir(parg[1],0777);
    }
    else if(!strcmp(parg[0],"rmdir"))
    {
        rmdir(parg[1]);
    }
    
    else if(!strcmp(parg[0],"rm"))
    {
        remove(parg[1]);
    }
    else if(!strcmp(parg[0],"ln"))
    {
        Ln(parg[1],parg[2]);
    }
    else if(!strcmp(parg[0],"chmod"))
    {
        Mychmod(parg[1],parg[2]);
    }

    return 0;
}

terminal.h

#ifndef _TERMINAL_H
#define _TERMINAL_H
extern int ShowTerminal(void);
extern int ExecCommand(char **parg ,int curlen);
extern int SplitCommand(char *pcmdbuff,char **parg,int maxlen); 
extern int GetCommand(char *pcmdbuff,int maxlen);             
#endif

record.c

#include"record.h"
#include<stdio.h>
#include<time.h>
FILE *fp = NULL;

int InitRecord(void)
{
    fp = fopen(RECORD_PATH,"a");
    if(NULL == fp)
    {
        perror("fail fopen");
        return -1;
    }

    return 0;
}

int RecordCommand(char *pcmdbuf)
{
    time_t t;
    struct tm *ptm = NULL;

    time(&t);
    ptm = localtime(&t);

    fprintf(fp,"[%04d-%02d-%02d% 02d:%02d:%02d]%s\n",ptm->tm_year + 1900,ptm->tm_mon+1,ptm->tm_mday,ptm->tm_hour,ptm->tm_min,ptm->tm_sec,pcmdbuf);
    fflush(fp);//更新缓存 让数据存入文件中；
    return 0;
}

int DelnitRecord(void)
{
    if(fp != NULL)
    {
        fclose(fp);
        fp = NULL ;
    }
    return 0;
}

record.h


#ifndef _RECORD_H
#define _RECORD_H
#define RECORD_PATH "./record.txt"

extern int InitRecord(void);
extern int RecordCommand(char *pcmdbuf);
extern int DelnitRecord(void);

#endif

makefile

OBJ = minishell
OBJS += main.c
OBJS += terminal.c
OBJS += command.c
OBJS += record.c

$(OBJ):$(OBJS)
	gcc $^ -o $@

.PHONY:
	clean:
		rm$(OBJ)
install:
	sudo cp $(OBJ)  /bin
uninstall:
	sudo rm /bin/$(OBJ)

四、实现效果

五、项目总结

1.Terminal多窗口的使用可以更快捷方便的进行代码的调试

        以及vim 编辑器 的  vsp功能 分屏打开文件 利于 复制y  粘贴p

2.之前所学IO的多有不熟悉 ，需要翻阅笔记才能对照着打出来。

        一是不熟练，其次就是理解也不够深刻

3.对 man手册的使用更为熟练了 ，主要是对各个函数的参数进一步了解

4.对char *tmpbuf  与 char  tmpbuf[4096] ={0};

        以及加强char **p 和 char *p[]的理解

*************************************

Makefile

Makefile 是一种文本文件，通常用于描述软件项目的构建规则和依赖关系。它配合构建工具如 GNU Make，可以自动化构建过程，提高软件开发的效率。

strtok函数

char *strtok(char *str, const char *delim);

功能： 用于将字符串分割成多个子字符串

参数： 

  • str: 要分割的字符串，第一次调用时传入需要分割的字符串，后续调用传入 NULL 即可。
  • delim: 分割字符串时所用的分隔符，可以是单个字符或字符串。

 返回值：一个指向分割得到的子字符串的指针

strtok 函数在第一次调用时，会使用参数 str 指向的字符串进行分割操作，并返回第一个找到的子字符串。在后续调用中，如果传入 NULL 作为参数，strtok 函数会继续使用上一次的字符串进行分割并返回下一个子字符串，直到字符串被完全分割。在分割过程中，strtok 函数会修改参数 str 指向的字符串，在其中插入 NULL 终止符以分隔子字符串。

需要注意的是，由于 strtok 函数会修改传入的字符串，因此在多线程环境下需要谨慎使用。

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

int main(void)
{
	char cmdbuf[1024] = {0};
	char *pret = NULL;
	char *parg[10] = {NULL};
	int cnt = 0;

	//ln -s file.txt a.txt
	gets(cmdbuf);

	parg[cnt] = strtok(cmdbuf, " ");
	cnt++;
	
	while (1)
	{
		parg[cnt] = strtok(NULL, " ");
		if (NULL == parg[cnt])
		{
			break;
		}
		cnt++;
	}
	
	int i = 0;

	for (i = 0; i < cnt; i++)
	{
		printf("parg[%d] = %s\n", i, parg[i]);
	}

	return 0;
}

望远山而力行
关注
Linux项目实践（Minishell）
qq_43344188的博客
08-05 1468
3.makefile维护文件时间戳,需要编译的重新编译，不需要重新的编译则省略编译的时间。9.cat 实现。1.ls 实现。ln -s file.txt a.txt 实现。3.rm 实现。2.touch 实现。3.minishell记录了用户输入命令的时间和内容,可以支持用户。
Minishell 项目使用教程
gitblog_00984的博客
08-16 384
Minishell 项目使用教程 minishellAs beautiful as a shell项目地址:https://gitcode.com/gh_mirrors/mi/minishell 1. 项目的目录结构及介绍 Minishell 项目的目录结构如下： minishell/ ├── includes/ │ └── minishell.h ├── libft/ │ ├── sr...
阶段小结（minishell的设计与总结）
m0_70493759的博客
07-16 358
1.获取终端用户输入的命令，并输出相应的执行结果。touchcpmvlsls -als -lmkdirrmdirpwdcdlnln -sexit ---------->退出minishell2. 使用多文件方式实现，使用Makefile管理。
Minishell 开源项目教程
gitblog_00394的博客
08-16 224
Minishell 开源项目教程 minishellAs beautiful as a shell项目地址:https://gitcode.com/gh_mirrors/mi/minishell 项目介绍 Minishell 是一个由 42 学校团队开发的基本 shell 程序，使用 C 语言编写。该项目旨在实现一个类似于 Bash 的迷你 shell，支持重定向、管道、环境变量以及一些内置命令...
【Linux】项目-minishell的实现
qq_41669298的博客
05-01 557
minishell的实现 实现原理   我们在这里手动实现一个小型的shell，可以用来处理我们一般常规的指令如ls，还可以附加参数-l，并且还可以进行重定向操作。   实现原理很简单，我们将用户输入的字符串读取到我们的缓冲区中，然后首先遍历一遍整个缓冲区看是否存在重定向符>或者>>，并且将重定向符改为\0并且读取出重定向的文件，随后保存判断结果。之后我们再次遍历一遍进行指令处理...
minishell
weixin_43886592的博客
01-13 294
shell就是一个命令解释器 实现思路： 1、等待用户的标准输入 [ls -l -a] 2、对用户数据进行解析，得到程序名称以及参数信息[-l]和[-a]
Linux 软件编程学习之minishell小项目
mxyzhy的博客
08-05 1143
Linux 软件编程小练习
linux学习 第二十天（minishell工程文件）
2401_85258690的博客
08-05 256
Shell 是操作系统中的一种程序，它为用户提供了一种与操作系统内核和计算机硬件进行交互的界面。在linux操作系统中，用户对操作系统进行的一系列操作都不能直接操作内核，而是通过shell间接对内核进行操作。需要说明一点：我们在这里还添加了历史查看功能，输入history将会显示之前输入的命令记录。我们此次目标是自己编写一个minishell软件，可以完成shell的的基础功能。在实现chmod命令时，要注意将输入的字符串“0777”转换成八进制在进行判断！4.各部分功能的实现。
实现简易minishell
m0_63020222的博客
09-01 350
实现一个简易的minishell命令行解释器
minishell:项目描述：shell
05-01
minishell 项目描述：shell
minishell_test:测试42所学校的minishell项目
05-03
minishell_test 文献资料 有关该项目的完整文档，请访问 。 入门 安装 $ pip3 install minishell-test $ pip3 install --user minishell-test # if you don't have root access 兼容性 您的可执行文件必须支持-c选项...
miniShell
03-15
"miniShell"是一个基于C语言实现的微型命令行解释器，通常用于教学或者轻量级的系统环境。在深入理解这个项目之前，我们先要了解什么是shell。Shell是操作系统提供的一种用户界面，允许用户通过命令行与操作系统进行...
42cursus-03-minishell:42cursus的minishell项目的开发回购
04-03
42cursus的minishell项目的开发回购有关42cursus及其项目的更多信息，请参考 。 ····· :speaking_head: 关于 该项目的目的是为您创建一个简单的外壳。 是的，您自己的小bash或zsh。 您将学到很多有关进程和...
linux长时间运行任务中断报警trap
djl的专栏，blog.djl.cx好记
11-08 255
每天要运行的定时任务, 时间很长, 有一天突然被中断了, 如果能有个中断提醒就好了。sleep 命令模拟一个长时间运行的任务，并在后台运行它。wait 命令等待任务完成或被杀死，并检查。wait 命令的退出状态码来判断脚本是否被。在这个脚本中，我们使用。
Linux下的systemd/service
zxz_Fine的博客
11-05 591
开机自启任务
linux rocky 9.4部署和管理docker harbor私有源
xikui1551的博客
11-08 1084
rocky 部署Harbor私有镜像仓库
linux-find和zgrep
luxideyao的专栏
11-07 315
命令本身并不支持递归搜索，它只能搜索单个压缩文件。但是，你可以结合使用。如果你想要搜索所有类型的压缩文件，你可以使用。是你想要搜索的目录的路径。是你想要搜索的文本模式，文件，你可能需要使用。文件并搜索其中的内容。作为输入文件的占位符。
Xshell，Shell的相关介绍与Linux中的权限问题
最新发布
2301_81265915的博客
11-09 519
首先，先介绍一下我们学习Linux的工具：XshellXShell 是一个流行的 Windows 平台上的 SSH、Telnet 和 Rlogin 客户端，主要用于远程连接 Linux/Unix 系统。它的运行原理大致如下：1：协议支持： XShell 支持多种远程协议（如 SSH、Telnet、Rlogin 等）。最常用的是 SSH 协议，它提供了安全的加密通信。SSH（Secure Shell）通过加密对客户端和服务器之间的通信进行保护，以防止数据在网络中被窃听和篡改。2：建立连接。
minishell项目
03-16
minishell项目是一个简单的shell程序，它可以在Linux系统上运行。它的主要功能是提供一个命令行界面，让用户可以输入命令并执行。它支持常见的shell命令，如cd、ls、echo等，还可以支持管道、重定向等高级功能。通过...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值