手写简易操作系统(二十八)--实现简单shell

news2024/11/26 20:25:28

前情提要

Shell是计算机操作系统中的一个重要概念，它是用户与操作系统内核之间的接口。Shell接受用户的命令，并将其转换为操作系统能够理解的指令，然后执行这些指令，并将执行结果返回给用户。

Shell可以理解为一个命令解释器，它负责解释和执行用户输入的命令。它不仅仅是一个命令解释器，还提供了一些功能，如命令历史记录、自动补全、脚本编程等，以方便用户进行操作。

一、实现清屏

global cls_screen
cls_screen:
    pushad
    ;;;;;;;;;;;;;;;
        ; 由于用户程序的cpl为3,显存段的dpl为0,故用于显存段的选择子gs在低于自己特权的环境中为0,
        ; 导致用户程序再次进入中断后,gs为0,故直接在put_str中每次都为gs赋值. 
    mov ax, SELECTOR_VIDEO	   ; 不能直接把立即数送入gs,须由ax中转
    mov gs, ax

    mov ebx, 0
    mov ecx, 80*25
.cls:
    mov word [gs:ebx], 0x0720 ;0x0720是黑底白字的空格键
    add ebx, 2
    loop .cls 
    mov ebx, 0

.set_cursor:			      ;直接把set_cursor搬过来用,省事
    ;;;;;;; 1 先设置高8位 ;;;;;;;;
    mov dx, 0x03d4			  ;索引寄存器
    mov al, 0x0e			  ;用于提供光标位置的高8位
    out dx, al
    mov dx, 0x03d5			  ;通过读写数据端口0x3d5来获得或设置光标位置 
    mov al, bh
    out dx, al

    ;;;;;;; 2 再设置低8位 ;;;;;;;;;
    mov dx, 0x03d4
    mov al, 0x0f
    out dx, al
    mov dx, 0x03d5 
    mov al, bl
    out dx, al
    popad
    ret

这是一段汇编代码，实际上用C实现也可以，只是效率低了那么一点。这个就很简单了，把显存段覆盖，然后设置光标即可，这两个函数实际上之前就实现了。

二、简单的shell

现在这个简单的shell只是简单打印一下字符

2.1、代码

#define cmd_len 128	       // 最大支持键入128个字符的命令行输入
#define MAX_ARG_NR 16	   // 加上命令名外,最多支持15个参数

// 存储输入的命令
static char cmd_line[cmd_len] = { 0 };

// 用来记录当前目录,是当前目录的缓存,每次执行cd命令时会更新此内容
char cwd_cache[64] = { 0 };

// 输出提示符
void print_prompt(void) {
    printf("[lyj@%s]$ ", cwd_cache);
}

/**
 * @description: 从键盘缓冲区中最多读入count个字节到buf。
 * @param {char*} buf
 * @param {int32_t} count
 * @return {*}
 */
static void readline(char* buf, int32_t count) {
    char* pos = buf;
    while (read(stdin_no, pos, 1) != -1 && (pos - buf) < count) {
        // 在不出错情况下,直到找到回车符才返回
        switch (*pos) {

        // 找到回车或换行符后认为键入的命令结束,直接返回
        case '\n':
        case '\r':
            // 添加cmd_line的终止字符0
            *pos = 0;
            putchar('\n');
            return;

        // 退格键
        case '\b':
            if (buf[0] != '\b') {
                // 退回到缓冲区cmd_line中上一个字符
                --pos;
                putchar('\b');
            }
            break;

        // 非控制键则输出字符
        default:
            putchar(*pos);
            pos++;
        }
    }
    printf("readline: can`t find enter_key in the cmd_line, max num of char is 128\n");
}

/**
 * @description: 简单的shell
 * @return {*}
 */
void my_shell(void) {
    cwd_cache[0] = '/';
    while (1) {
        print_prompt();
        memset(cmd_line, 0, cmd_len);
        readline(cmd_line, cmd_len);
        // 若只键入了一个回车
        if (cmd_line[0] == 0) {
            continue;
        }
    }
}

2.2、仿真

image-20240408165520663

三、添加 Ctrl+u 和 Ctrl+l 快捷键

在Linux中，“Ctrl+u”的作用是清除输入，也就是在回车前，按下“Ctrl+u”可以清掉本次的输入，相当于连续按下退格键的效果。“Ctrl+l”的作用是清屏，效果等同于Clear命令，但是有一点要注意，“Ctrl+l”并不会清掉本次的输入。

        /* ctrl+l 清屏 */
        case 'l' - 'a':
            // 1 先将当前的字符'l'-'a'置为0
            *pos = 0;
            // 2 再将屏幕清空
            clear();
            // 3 打印提示符
            print_prompt();
            // 4 将之前键入的内容再次打印
            printf("%s", buf);
            break;

        /* ctrl+u 清掉输入 */
        case 'u' - 'a':
            while (buf != pos) {
                putchar('\b');
                *(pos--) = 0;
            }
            break;

image-20240408170110221

四、解析键入字符

这里解析输入的字符，怎么解析呢，就是将输入的一个字符串按照空格键分隔为多个字符串

/**
 * @description: 分析字符串cmd_str中以token为分隔符的单词,将各单词的指针存入argv数组
 * @param {char*} cmd_str
 * @param {char**} argv
 * @param {char} token
 * @return {*}
 */
static int32_t cmd_parse(char* cmd_str, char** argv, char token) {
    int32_t arg_idx = 0;
    while (arg_idx < MAX_ARG_NR) {
        argv[arg_idx] = NULL;
        arg_idx++;
    }
    char* next = cmd_str;
    int32_t argc = 0;
    /* 外层循环处理整个命令行 */
    while (*next) {
        /* 去除命令字或参数之间的空格 */
        while (*next == token) {
            next++;
        }
        /* 处理最后一个参数后接空格的情况,如"ls dir2 " */
        if (*next == 0) {
            break;
        }
        argv[argc] = next;

        /* 内层循环处理命令行中的每个命令字及参数 */
        while (*next && *next != token) {	  // 在字符串结束前找单词分隔符
            next++;
        }

        /* 如果未结束(是token字符),使tocken变成0 */
        if (*next) {
            // 将token字符替换为字符串结束符0,做为一个单词的结束,并将字符指针next指向下一个字符
            *next++ = 0;
        }

        /* 避免argv数组访问越界,参数过多则返回0 */
        if (argc > MAX_ARG_NR) {
            return -1;
        }
        argc++;
    }
    return argc;
}


int32_t argc = -1;
/**
 * @description: 简单的shell
 * @return {*}
 */
void my_shell(void) {
    cwd_cache[0] = '/';
    while (1) {
        print_prompt();
        memset(final_path, 0, MAX_PATH_LEN);
        memset(cmd_line, 0, MAX_PATH_LEN);
        readline(cmd_line, MAX_PATH_LEN);
        // 若只键入了一个回车
        if (cmd_line[0] == 0) {
            continue;
        }
        argc = -1;
        argc = cmd_parse(cmd_line, argv, ' ');
        if (argc == -1) {
            printf("num of arguments exceed %d\n", MAX_ARG_NR);
            continue;
        }

        int32_t arg_idx = 0;
        while (arg_idx < argc) {
            printf("%s ", argv[arg_idx]);
            arg_idx++;
        }
        printf("\n");
    }
}

image-20240408170818377

五、添加ps调用

5.1、代码

/**
 * @description: 以填充空格的方式输出buf
 * @param {char*} buf 
 * @param {int32_t} buf_len
 * @param {void*} ptr
 * @param {char} format
 * @return {*}
 */
static void pad_print(char* buf, int32_t buf_len, void* ptr, char format) {
    memset(buf, 0, buf_len);
    uint8_t out_pad_0idx = 0;
    switch (format) {
    case 's':
        out_pad_0idx = sprintf(buf, "%s", ptr);
        break;
    case 'd':
        out_pad_0idx = sprintf(buf, "%d", *((int32_t*)ptr));
        break;
    case 'x':
        out_pad_0idx = sprintf(buf, "%x", *((uint32_t*)ptr));
        break;
    }
    while (out_pad_0idx < buf_len) {
        // 以空格填充
        buf[out_pad_0idx] = ' ';
        out_pad_0idx++;
    }
    sys_write(stdout_no, buf, buf_len - 1);
}


/**
 * @description: 用于在list_traversal函数中的回调函数,用于针对线程队列的处理
 * @param {list_elem*} pelem
 * @param {int arg} UNUSED
 * @return {*}
 */
static bool elem2thread_info(struct list_elem* pelem, int arg UNUSED) {
    struct task_struct* pthread = elem2entry(struct task_struct, all_tag, pelem);
    char out_pad[16] = { 0 };

    pad_print(out_pad, 16, &pthread->pid, 'd');

    if (pthread->parent_pid == -1) {
        pad_print(out_pad, 16, "NULL", 's');
    }
    else {
        pad_print(out_pad, 16, &pthread->parent_pid, 'd');
    }

    switch (pthread->status) {
    case 0:
        pad_print(out_pad, 16, "RUNNING", 's');
        break;
    case 1:
        pad_print(out_pad, 16, "READY", 's');
        break;
    case 2:
        pad_print(out_pad, 16, "BLOCKED", 's');
        break;
    case 3:
        pad_print(out_pad, 16, "WAITING", 's');
        break;
    case 4:
        pad_print(out_pad, 16, "HANGING", 's');
        break;
    case 5:
        pad_print(out_pad, 16, "DIED", 's');
    }
    pad_print(out_pad, 16, &pthread->elapsed_ticks, 'x');

    memset(out_pad, 0, 16);
    memcpy(out_pad, pthread->name, strlen(pthread->name));
    strcat(out_pad, "\n");
    sys_write(stdout_no, out_pad, strlen(out_pad));
    // 此处返回false是为了迎合主调函数list_traversal,只有回调函数返回false时才会继续调用此函数
    return false;
}

/**
 * @description: 打印任务列表
 * @return {*}
 */
void sys_ps(void) {
    char* ps_title = "PID            PPID           STAT           TICKS          COMMAND\n";
    sys_write(stdout_no, ps_title, strlen(ps_title));
    list_traversal(&thread_all_list, elem2thread_info, 0);
}

5.2、仿真

image-20240408175456386

六、路径解析

6.1、代码

这里的路径解析指的是将当前的路径，包含 . 和 .. 的路径，解析成绝对路径

/**
 * @description: 将路径old_abs_path中的..和.转换为实际路径后存入new_abs_path
 * @param {char*} old_abs_path 旧的绝对路径
 * @param {char*} new_abs_path 新的绝对路径
 * @return {*}
 */
static void wash_path(char* old_abs_path, char* new_abs_path) {
    char name[MAX_FILE_NAME_LEN] = { 0 };
    char* sub_path = old_abs_path;
    sub_path = path_parse(sub_path, name);
    // 若只键入了"/",直接将"/"存入new_abs_path后返回 
    if (name[0] == 0) {
        new_abs_path[0] = '/';
        new_abs_path[1] = 0;
        return;
    }
    // 避免传给new_abs_path的缓冲区不干净
    new_abs_path[0] = 0;
    strcat(new_abs_path, "/");
    while (name[0]) {
        // 如果是上一级目录“..”
        if (!strcmp("..", name)) {
            char* slash_ptr = strrchr(new_abs_path, '/');
            // 如果未到new_abs_path中的顶层目录,就将最右边的'/'替换为0,这样便去除了new_abs_path中最后一层路径,相当于到了上一级目录
            if (slash_ptr != new_abs_path) {
                // 如new_abs_path为“/a/b”,".."之后则变为“/a”
                *slash_ptr = 0;
            }
            else {
                // 如new_abs_path为"/a",".."之后则变为"/"
                *(slash_ptr + 1) = 0;
            }
        }
        // 如果路径不是‘.’,就将name拼接到new_abs_path
        else if (strcmp(".", name)) {
            // 如果new_abs_path不是"/",就拼接一个"/",此处的判断是为了避免路径开头变成这样"//"
            if (strcmp(new_abs_path, "/")) {
                strcat(new_abs_path, "/");
            }
            strcat(new_abs_path, name);
        }
        // 若name为当前目录".",无须处理new_abs_path

        // 继续遍历下一层路径
        memset(name, 0, MAX_FILE_NAME_LEN);
        if (sub_path) {
            sub_path = path_parse(sub_path, name);
        }
    }
}

/**
 * @description: 将path处理成不含..和.的绝对路径,存储在final_path
 * @param {char*} path
 * @param {char*} final_path
 * @return {*}
 */
void make_clear_abs_path(char* path, char* final_path) {
    char abs_path[MAX_PATH_LEN] = { 0 };
    // 先判断是否输入的是绝对路径
    if (path[0] != '/') {
        // 若输入的不是绝对路径,就拼接成绝对路径
        memset(abs_path, 0, MAX_PATH_LEN);
        if (getcwd(abs_path, MAX_PATH_LEN) != NULL) {
            // 若abs_path表示的当前目录不是根目录/
            if (!((abs_path[0] == '/') && (abs_path[1] == 0))) {
                strcat(abs_path, "/");
            }
        }
    }
    strcat(abs_path, path);
    wash_path(abs_path, final_path);
}

6.2、仿真

image-20240408193114116

七、实现基础命令

命令分为两大类，一种是外部命令，另一种是内部命令。

外部命令是指该命令是个存储在文件系统上的外部程序，执行该命令实际上是从文件系统上加载该程序到内存后运行的过程，也就是说外部命令会以进程的方式执行。大伙儿应该最为熟悉ls命令，它就是典型的外部命令，它通常的存储路径是/bin/ls。

内部命令也称为内建命令，是系统本身提供的功能，它们并不以单独的程序文件存在，只是一些单独的功能函数，系统执行这些命令实际上是在调用这些函数。比如cd、fg、jobs等命令是由bash提供的，因此它们称为BASH_BUILTINS。

我们的内部命令保存在 shell/buildin_cmd.c 路径下

7.1、pwd命令

将当前工作的绝对路径返回到 final_path 中并打印

/**
 * @description: pwd命令的内建函数
 * @param {uint32_t} argc
 * @param {char** argv} UNUSED
 * @return {*}
 */
void buildin_pwd(uint32_t argc, char** argv UNUSED) {
    if (argc != 1) {
        printf("pwd: no argument support!\n");
        return;
    }
    else {
        if (NULL != getcwd(final_path, MAX_PATH_LEN)) {
            printf("%s\n", final_path);
        }
        else {
            printf("pwd: get current work directory failed.\n");
        }
    }
}

7.2、cd命令

/**
 * @description: cd命令的内建函数
 * @param {uint32_t} argc
 * @param {char**} argv
 * @return {*}
 */
char* buildin_cd(uint32_t argc, char** argv) {
    if (argc > 2) {
        printf("cd: only support 1 argument!\n");
        return NULL;
    }

    // 若是只键入cd而无参数,直接返回到根目录.
    if (argc == 1) {
        final_path[0] = '/';
        final_path[1] = 0;
    }
    // 否则清洗成绝对路径
    else {
        make_clear_abs_path(argv[1], final_path);
    }
    // 将当前目录修改
    if (chdir(final_path) == -1) {
        printf("cd: no such directory %s\n", final_path);
        return NULL;
    }
    return final_path;
}

7.3、ls命令

/**
 * @description: ls命令的内建函数
 * @param {uint32_t} argc
 * @param {char**} argv
 * @return {*}
 */
void buildin_ls(uint32_t argc, char** argv) {
    char* pathname = NULL;
    struct stat file_stat;
    memset(&file_stat, 0, sizeof(struct stat));
    bool long_info = false;
    uint32_t arg_path_nr = 0;

    // 跨过argv[0],argv[0]是字符串“ls”
    for (uint32_t arg_idx = 1; arg_idx < argc; arg_idx++) {
        if (argv[arg_idx][0] == '-') {
            // 如果是参数-l
            if (!strcmp("-l", argv[arg_idx])) {         
                long_info = true;
            }
            // 如果是参数-h
            else if (!strcmp("-h", argv[arg_idx])) {
                printf(ls_help);
                return;
            }
            // 其他不支持的参数
            else {
                printf("ls: invalid option %s\nTry `ls -h' for more information.\n", argv[arg_idx]);
                return;
            }
        }
        // ls的路径参数
        else {
            if (arg_path_nr == 0) {
                pathname = argv[arg_idx];
                arg_path_nr = 1;
            }
            else {
                printf("ls: only support one path\n");
                return;
            }
        }
    }

    // 若只输入了ls 或 ls -l,没有输入操作路径,默认以当前路径的绝对路径为参数.
    if (pathname == NULL) {
        if (NULL != getcwd(final_path, MAX_PATH_LEN)) {
            pathname = final_path;
        }
        else {
            printf("ls: getcwd for default path failed\n");
            return;
        }
    }
    else {
        make_clear_abs_path(pathname, final_path);
        pathname = final_path;
    }

    // 遍历目录文件
    if (stat(pathname, &file_stat) == -1) {
        printf("ls: cannot access %s: No such file or directory\n", pathname);
        return;
    }
    if (file_stat.st_filetype == FT_DIRECTORY) {
        struct dir* dir = opendir(pathname);
        struct dir_entry* dir_e = NULL;
        char sub_pathname[MAX_PATH_LEN] = { 0 };
        uint32_t pathname_len = strlen(pathname);
        uint32_t last_char_idx = pathname_len - 1;
        memcpy(sub_pathname, pathname, pathname_len);
        if (sub_pathname[last_char_idx] != '/') {
            sub_pathname[pathname_len] = '/';
            pathname_len++;
        }
        rewinddir(dir);
        if (long_info) {
            char ftype;
            printf("total: %d\n", file_stat.st_size);
            while ((dir_e = readdir(dir))) {
                ftype = 'd';
                if (dir_e->f_type == FT_REGULAR) {
                    ftype = '-';
                }
                sub_pathname[pathname_len] = 0;
                strcat(sub_pathname, dir_e->filename);
                memset(&file_stat, 0, sizeof(struct stat));
                if (stat(sub_pathname, &file_stat) == -1) {
                    printf("ls: cannot access %s: No such file or directory\n", dir_e->filename);
                    return;
                }
                printf("%c  %d  %d  %s\n", ftype, dir_e->i_no, file_stat.st_size, dir_e->filename);
            }
        }
        else {
            while ((dir_e = readdir(dir))) {
                printf("%s ", dir_e->filename);
            }
            printf("\n");
        }
        closedir(dir);
    }
    else {
        if (long_info) {
            printf("-  %d  %d  %s\n", file_stat.st_ino, file_stat.st_size, pathname);
        }
        else {
            printf("%s\n", pathname);
        }
    }
}

7.4、ps命令

/**
 * @description: ps命令内建函数
 * @param {uint32_t} argc
 * @param {char** argv} UNUSED
 * @return {*}
 */
void buildin_ps(uint32_t argc, char** argv UNUSED) {
    if (argc != 1) {
        printf("ps: no argument support!\n");
        return;
    }
    ps();
}

7.5、clear命令

/**
 * @description: clear命令内建函数
 * @param {uint32_t} argc
 * @param {char** argv} UNUSED
 * @return {*}
 */
void buildin_clear(uint32_t argc, char** argv UNUSED) {
    if (argc != 1) {
        printf("clear: no argument support!\n");
        return;
    }
    clear();
}

7.6、mkdir命令

/**
 * @description: mkdir命令内建函数
 * @param {uint32_t} argc
 * @param {char**} argv
 * @return {*}
 */
int32_t buildin_mkdir(uint32_t argc, char** argv) {
    int32_t ret = -1;
    if (argc != 2) {
        printf("mkdir: only support 1 argument!\n");
    }
    else {
        make_clear_abs_path(argv[1], final_path);
        // 若创建的不是根目录
        if (strcmp("/", final_path)) {
            if (mkdir(final_path) == 0) {
                ret = 0;
            }
            else {
                printf("mkdir: create directory %s failed.\n", argv[1]);
            }
        }
    }
    return ret;
}

7.7、rmdir命令

/**
 * @description: rmdir命令内建函数
 * @param {uint32_t} argc
 * @param {char**} argv
 * @return {*}
 */
int32_t buildin_rmdir(uint32_t argc, char** argv) {
    int32_t ret = -1;
    if (argc != 2) {
        printf("rmdir: only support 1 argument!\n");
    }
    else {
        make_clear_abs_path(argv[1], final_path);
        // 若删除的不是根目录
        if (strcmp("/", final_path)) {
            if (rmdir(final_path) == 0) {
                ret = 0;
            }
            else {
                printf("rmdir: remove %s failed.\n", argv[1]);
            }
        }
    }
    return ret;
}

7.8、rm命令

/**
 * @description: rm命令内建函数
 * @param {uint32_t} argc
 * @param {char**} argv
 * @return {*}
 */
int32_t buildin_rm(uint32_t argc, char** argv) {
    int32_t ret = -1;
    if (argc != 2) {
        printf("rm: only support 1 argument!\n");
    }
    else {
        make_clear_abs_path(argv[1], final_path);
        // 若删除的不是根目录
        if (strcmp("/", final_path)) {
            if (unlink(final_path) == 0) {
                ret = 0;
            }
            else {
                printf("rm: delete %s failed.\n", argv[1]);
            }

        }
    }
    return ret;
}

7.9、touch命令

void buildin_touch(uint32_t argc, char** argv) {
    if (argc != 2) {
        printf("rm: only support 1 argument!\n");
    }
    else {
        make_clear_abs_path(argv[1], final_path);
        int fd = open(final_path, O_CREAT);
        if (fd != -1) {
            close(fd);
        }
    }
}

7.10、写入shell

void my_shell(void) {
    cwd_cache[0] = '/';
    clear();
    while (1) {
        print_prompt();
        memset(final_path, 0, MAX_PATH_LEN);
        memset(cmd_line, 0, MAX_PATH_LEN);
        readline(cmd_line, MAX_PATH_LEN);
        if (cmd_line[0] == 0) {	 // 若只键入了一个回车
            continue;
        }
        argc = -1;
        argc = cmd_parse(cmd_line, argv, ' ');
        if (argc == -1) {
            printf("num of arguments exceed %d\n", MAX_ARG_NR);
            continue;
        }
        if (!strcmp("ls", argv[0])) {
            buildin_ls(argc, argv);
        }
        else if (!strcmp("cd", argv[0])) {
            if (buildin_cd(argc, argv) != NULL) {
                memset(cwd_cache, 0, MAX_PATH_LEN);
                strcpy(cwd_cache, final_path);
            }
        }
        else if (!strcmp("pwd", argv[0])) {
            buildin_pwd(argc, argv);
        }
        else if (!strcmp("ps", argv[0])) {
            buildin_ps(argc, argv);
        }
        else if (!strcmp("clear", argv[0])) {
            buildin_clear(argc, argv);
        }
        else if (!strcmp("mkdir", argv[0])) {
            buildin_mkdir(argc, argv);
        }
        else if (!strcmp("rmdir", argv[0])) {
            buildin_rmdir(argc, argv);
        }
        else if (!strcmp("rm", argv[0])) {
            buildin_rm(argc, argv);
        }
        else {
            printf("external command\n");
        }
    }
}

7.11、仿真

image-20240408195007962

结束语

本节实现了一个简单的shell，其实不难发现，就是我们之前写的那些调用

老规矩，本节的代码地址：https://github.com/lyajpunov/os

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1582442.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

全面的网络流量监控

全面的网络流量监控

流量监控指的是对数据流进行的监控&#xff0c;通常包括出数据、入数据的速度、总流量。通过网络流量监控&#xff0c;组织可以确保只有业务关键型流量通过网络传输&#xff0c;并限制不需要的网络流量&#xff0c;从而提高网络效率&#xff0c;又可以防止停机、减少 MTTR、帮助…
阅读更多...
OSPF防环文档

OSPF防环文档

OPSF在区域内会产生俩类LSA&#xff1a;Router LSA &#xff0c;Network LSA 路由器以自己为树根构建最短路径树 &#xff0c;这里的最短路径树按两步形 成&#xff0c;第一步&#xff0c;仅考虑路由器和传输网络之间的连接。通过 Dijkstra 算法&#xff0c;根据链路状态数据…
阅读更多...
FebHost：瑞士.CH域名注册介绍

FebHost：瑞士.CH域名注册介绍

瑞士&#xff0c;一个位于欧洲心脏地带的多元文化国家&#xff0c;不仅以其精准的钟表和迷人的巧克力闻名于世&#xff0c;还因其独特的国家代码顶级域名“.ch”在互联网上占有一席之地。与全球广泛使用的通用顶级域名&#xff08;gTLDs&#xff09;如“.com”、“.org”或“.n…
阅读更多...
sqli-labs（宽字节less-33，二次less-24，update less-17，堆叠less-38）pikachu（insert，delete）

sqli-labs（宽字节less-33，二次less-24，update less-17，堆叠less-38）pikachu（insert，delete）

目录 宽字节 less-33 具体使用 sqlmap爆破宽字节 二次注入 less-24 靶场运用&#xff1a; update注入 less-17 具体使用&#xff1a; insert注入 pikachu演示 具体使用 delete注入 pikachu演示 堆叠注入 less-38 宽字节 less-33 宽字节注入是利用 mysql 的一个特性&…
阅读更多...
访问elasticsearch集群提示ERROR 新增es数据失败，后台日志返回413 Request Entity Too Larg

访问elasticsearch集群提示ERROR 新增es数据失败，后台日志返回413 Request Entity Too Larg

一、背景&#xff1a; 在运维paas云平台时有研发反馈客户端访问elasticsearch服务偶发性的出现报错&#xff0c;提示报错如下&#xff1a; ERROR 1 --- [io-8407-exec-35] c.j.b.c.c.e.s.ElasticOperateServiceImpl : 新增es数据失败 二、问题分析&#xff1a; 报错日志内容核…
阅读更多...
【Machine Learning系列】带你快速学习十大机器学习算法

【Machine Learning系列】带你快速学习十大机器学习算法

前言 机器学习算法是一类用于从数据中学习模式和规律的算法。这些算法可以通过训练样本的输入和输出来推断出模型的参数&#xff0c;然后用于预测新的未知数据。 文章目录 前言机器学习算法1. 线性回归算法 Linear Regression2. 支持向量机算法(Support Vector Machine,SVM)3. …
阅读更多...
实战-edusrc漏洞挖掘-接口未授权访问

实战-edusrc漏洞挖掘-接口未授权访问

0x01系统初探 通过fofa对大学进行搜索 fofa:host"edu.cn" &amp;&amp; status_code"200"在随意的翻阅查看时&#xff0c;发现访问xxx.edu.cn登录页面会优先访问登录后的页面&#xff0c;再跳转至登录页面。盲猜应该是前端校验&#xff0c;可以通过…
阅读更多...
Netty 入门应用之Http服务WebSocket

Netty 入门应用之Http服务WebSocket

Netty实现Http服务 主要的变化是在初始化器中引入了新的编解码器 一些创建的类作用和Netty HelloWorld的小demo一样我这里就不再次重复了 1、Http服务端代码 public class HttpServer {public static void main(String[] args) {// 创建Reactor// 用来管理channel 监听事件 …
阅读更多...
氮气柜温湿度含氧量控制及联网监测功能介绍

氮气柜温湿度含氧量控制及联网监测功能介绍

氮气柜主要用于存储对氧气敏感的物料&#xff0c;如精密电子元器件、金属材料、化学品、药品、IC芯片等。通过持续充入氮气&#xff0c;降低柜内氧气含量至安全水平&#xff0c;从而抑制氧化反应的发生&#xff0c;保护物料免受氧化损害。 氮气柜可以通过氧浓度传感器来实现对柜…
阅读更多...
【TI毫米波雷达】MMWave SDK：UART串口数据发送时的数据丢失、出错及避坑配置，Polling方法和Write方法的使用避坑

【TI毫米波雷达】MMWave SDK：UART串口数据发送时的数据丢失、出错及避坑配置，Polling方法和Write方法的使用避坑

【TI毫米波雷达】MMWave SDK&#xff1a;UART串口数据发送时的数据丢失、出错及避坑配置&#xff0c;Polling方法和Write方法的使用避坑 文章目录 BUG复现Polling方法和Write方法的使用避坑串口配置避坑附录&#xff1a;结构框架雷达基本原理叙述雷达天线排列位置芯片框架Demo工…
阅读更多...
手术麻醉信息管理系统源码 网格编辑、麻醉质控指标

手术麻醉信息管理系统源码 网格编辑、麻醉质控指标

目录 什么是手术麻醉信息管理系统 满足医院等级评级需求 满足电子病历评级需求 满足科室需求 术前 1、患者术前评估/诊断 2、术前讨论制定手术方案 3、手术准备 4、术前准备 术中 1、送手术室 2、麻醉前 3、手术 术后 1、手术结束 2、术后监护 3、术后随访 什…
阅读更多...
龙蜥社区「人人都可以参与开源」——体验开源成为“开源人“

龙蜥社区「人人都可以参与开源」——体验开源成为“开源人“

龙蜥社区「人人都可以参与开源」体验开源——让更多的人了解开源&#xff01; 龙蜥社区开源概述&#xff1a;龙蜥社区开源的探索过程:龙蜥社区收获总结:AtomGit评测:服务设计上:功能结构上:安全设计上: AtomGit测评总结: 龙蜥社区开源概述&#xff1a; 在追求技术的路上少不了…
阅读更多...
Netty学习——高级篇2 Netty解码技术 备份

Netty学习——高级篇2 Netty解码技术 备份

接上篇&#xff1a;Netty学习——高级篇1 拆包 、粘包与编解码技术&#xff0c;本章继续介绍Netty的其他解码器 1 DelimiterBasedFrameDecoder分隔符解码器 DelimiterBasedFrameDecoder 分隔符解码器是按照指定分隔符进行解码的解码器&#xff0c;通过分隔符可以将二进制流拆分…
阅读更多...
将扁平数据转换为树形数据的方法

将扁平数据转换为树形数据的方法

当遇到了好多扁平数据我们都无从下手&#xff1f;不知道如何处理&#xff1f; 家人们 无脑调用这个函数就好了 接口请求回来以后 调用这个函数传入实参就可以用啦~ // 树形菜单函数 function GetTreeData(data) {let TreeData [];let map new Map(); //存在id,对应所在的内…
阅读更多...
大厂Java笔试题之判断字母大小写

大厂Java笔试题之判断字母大小写

/*** 题目&#xff1a;如果一个由字母组成的字符串&#xff0c;首字母是大写&#xff0c;那么就统计该字符串中大写字母的数量&#xff0c;并输出该字符串中所有的大写字母。否则&#xff0c;就输出* 该字符串不是首字母大写*/ public class Demo2 {public static void main(St…
阅读更多...
功能测试_验证某城市电话号码的正确性

功能测试_验证某城市电话号码的正确性

案例&#xff1a;验证某城市电话号码的正确性 功能测试_等价类设计用例&#xff1a; 步骤&#xff1a; 1:明确需求&#xff1a;电话号码是否正确 2:划分等价类&#xff1a;有效等价类、有效取值、无效等价类、无效取值 3&#xff1a;提取数据编写用例&#xff1a;用例编号…
阅读更多...
4.9QT

4.9QT

完善对话框&#xff0c;点击登录对话框&#xff0c;如果账号和密码匹配&#xff0c;则弹出信息对话框&#xff0c;给出提示”登录成功“&#xff0c;提供一个Ok按钮&#xff0c;用户点击Ok后&#xff0c;关闭登录界面&#xff0c;跳转到其他界面 如果账号和密码不匹配&#xf…
阅读更多...
vite+react+ts+scss 创建项目

vite+react+ts+scss 创建项目

npm create vitelatest输入项目名称选择react选择typescript swc WC 通过利用 Rust 编写的编译器&#xff0c;使用了更先进的优化技术&#xff0c;使得它在处理 TypeScript 代码时能够更快地进行转换和编译。特别是在大型项目中&#xff0c;SWC 相对于传统的 TypeScript 编译器…
阅读更多...
液冷是大模型对算力需求的必然选择？｜英伟达 GTC 2024六大亮点

液冷是大模型对算力需求的必然选择？｜英伟达 GTC 2024六大亮点

在这个以高性能计算和大模型推动未来通用人工智能时代&#xff0c;算力已成为科技发展的隐形支柱。本文将重点探讨算力的演进&#xff0c;深入分析在不同领域中算力如何成为推动进步的基石&#xff1b;着眼于液冷如何突破算力瓶颈成为引领未来的先锋&#xff0c;对液冷散热的三…
阅读更多...
探索RAG：加强问答能力的新技术

探索RAG：加强问答能力的新技术

文章目录 1. RAG是什么&#xff1f;1.1 技术简介1.2 挑战与解决方案1.3 RAG技术构成1.4 应用与前景 2. RAG架构详解2.1 典型的RAG应用有两个主要组件2.2 从原始数据到答案的完整流程 3. RAG在实际应用中的案例 1. RAG是什么&#xff1f; 1.1 技术简介 Retrieval Augmented Ge…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023