Linux script and scriptreplay（三）

最新推荐文章于 2024-04-18 19:30:51 发布
最新推荐文章于 2024-04-18 19:30:51 发布
阅读量1.2k 收藏 3
点赞数 1
分类专栏： linux golang 文章标签： linux 终端 golang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hazing/article/details/51311841
版权

前言

在上面两篇博客中，介绍了script和scriptreplay的使用以及原理，这节中就来分析一下script的原理。

在分析script之前需要了解终端的概念

终端是一种字符设备，它有多种类型，通常使用tty来简称各种类型的终端设备。 设备名放在特殊目录/dev/下，终端特殊设备文件一般有以下几种：

1.串行端口终端（/dev/ttySn）

串行端口终端是使用计算机串行端口连接的终端设备。计算机把每个串行端口看做是一个字符设备，有段时间这些串行端口设备通常称为终端设备，那是它们的最大用途就是用来连接终端。

2.伪终端

伪终端（Pseudo Terminal）是成对的逻辑终端设备，即伪终端是由Master和Slave共同组成的，通常用于实现网络登陆功能，如ssh，telnet等。伪终端一般分为两类：

(1)BSD 伪终端

BSD伪终端中，定义/dev/pty[p-za-e][0-9a-f] 是Master; /dev/tty[p-za-e][0-9a-f] 是Slave，他们都是配对好的，即/dev/ptyp1对应/dev/ttyp1，共同伪终端。这种看似简单的定义使得编程实现很困难，因为我们需要遍历/dev/目录，一个一个的尝试才能找到一对合适的终端

(2)Unix 98伪终端

与BSD伪终端不同，始终以/dev/ptmx作为Master的复制设备，每次打开/dev/ptmx才能得到一个master设备的fd，同时在/dev/pts目录下得到一个Slave设备，这种方式下，编程就变得简单了许多。

3.控制终端

如果当前进程有控制终端的话，那么/dev/tty就是当前进程的控制终端的特殊文件。可以使用ps -ef来查看进程与哪个控制终端相连。对于你登陆的shell，/dev/tty就是你使用的终端。你可以使用tty命令查看它具体对应哪个实际终端设备

4.控制台终端

在linux系统中，计算机显示器通常被称为控制台终端。它仿真了类型为linux的一种终端（TERM=Linux），并且有一些设备特殊文件与之相关联：tty[1-6]使用Alt+[F1—F6]组合键时，我们就可以切换到tty2、tty3等上面去。tty1–tty6等称为虚拟终端，而tty0则是当前所使用虚拟终端的一个别名，系统所产生的信息会发送到该终端上。因此不管当前正在使用哪个虚拟终端，系统信息都会发送到控制台终端上。你可以登录到不同的虚拟终端上去，因而可以让系统同时有几个不同的会话期存在。

script关键代码分析

getmaster

void
getmaster() {
//此种方式为Unix98伪终端，直接调用openpty函数获取Master和Slave
#if HAVE_LIBUTIL && HAVE_PTY_H
    tcgetattr(STDIN_FILENO, &tt);
    ioctl(STDIN_FILENO, TIOCGWINSZ, (char *)&win);
    if (openpty(&master, &slave, NULL, &tt, &win) < 0) {
        warn(_("openpty failed"));
        fail();
    }
#else
//BSD伪终端，需要便利/dev目录，找到一对可用的Master和Slave
    char *pty, *bank, *cp;
    struct stat stb;

    pty = &line[strlen("/dev/ptyp")];
    for (bank = "pqrs"; *bank; bank++) {
        line[strlen("/dev/pty")] = *bank;
        *pty = '0';
        if (stat(line, &stb) < 0)
            break;
        for (cp = "0123456789abcdef"; *cp; cp++) {
            *pty = *cp;
            master = open(line, O_RDWR);
            if (master >= 0) {
                char *tp = &line[strlen("/dev/")];
                int ok;

                /* verify slave side is usable */
                *tp = 't';
                ok = access(line, R_OK|W_OK) == 0;
                *tp = 'p';
                if (ok) {
                    tcgetattr(STDIN_FILENO, &tt);
                    ioctl(STDIN_FILENO, TIOCGWINSZ,
                        (char *)&win);
                    return;
                }
                close(master);
                master = -1;
            }
        }
    }
    master = -1;
    warn(_("out of pty's"));
    fail();
#endif /* not HAVE_LIBUTIL */
}

dooutput

void
dooutput(FILE *timingfd) {
    ssize_t cc;
    time_t tvec;
    char obuf[BUFSIZ];
    struct timeval tv;
    double oldtime=time(NULL), newtime;
    int flgs = 0;
    ssize_t wrt;
    ssize_t fwrt;

    close(STDIN_FILENO);
#ifdef HAVE_LIBUTIL
    close(slave);
#endif
    tvec = time((time_t *)NULL);
    my_strftime(obuf, sizeof obuf, "%c\n", localtime(&tvec));
    //输出开始信息到typescript文件
    fprintf(fscript, _("Script started on %s"), obuf);

    do {
        if (die && flgs == 0) {
            /* ..child is dead, but it doesn't mean that there is
             * nothing in buffers.
             */
            flgs = fcntl(master, F_GETFL, 0);
            if (fcntl(master, F_SETFL, (flgs | O_NONBLOCK)) == -1)
                break;
        }
        if (tflg)
            gettimeofday(&tv, NULL);

        errno = 0;
        //从master中读取数据
        cc = read(master, obuf, sizeof (obuf));

        if (die && errno == EINTR && cc <= 0)
            /* read() has been interrupted by SIGCHLD, try it again
             * with O_NONBLOCK
             */
            continue;
        if (cc <= 0)
            break;
        //计算上次输出到本次输出的时间间隔  
        if (tflg) {
            newtime = tv.tv_sec + (double) tv.tv_usec / 1000000;
            fprintf(timingfd, "%f %zd\n", newtime - oldtime, cc);
            oldtime = newtime;
        }
        //将从master中读到的数据输出到stdout
        wrt = write(STDOUT_FILENO, obuf, cc);
        if (wrt < 0) {
            warn (_("write failed"));
            fail();
        }
        //将数据写入到typescript文件中
        fwrt = fwrite(obuf, 1, cc, fscript);
        if (fwrt < cc) {
            warn (_("cannot write script file"));
            fail();
        }
        if (fflg)
            fflush(fscript);
    } while(1);

    if (flgs)
        fcntl(master, F_SETFL, flgs);
    done();
}

doinput

void
doinput() {
    ssize_t cc;
    char ibuf[BUFSIZ];

    fclose(fscript);
    //从stdin中读取输入，写入到master中
    while (die == 0) {
        if ((cc = read(STDIN_FILENO, ibuf, BUFSIZ)) > 0) {
            ssize_t wrt = write(master, ibuf, cc);
            if (wrt < 0) {
                warn (_("write failed"));
                fail();
            }
        }
        else if (cc < 0 && errno == EINTR && resized)
            resized = 0;
        else
            break;
    }

    done();
}

script程序流程梳理

Created with Raphaël 2.1.0 开始 读取参数 获取主设备 fork子进程 是否是子进程？ fork子进程 是否是子进程 dooutput(记录数据以及输出) 结束 doshell(execl启动一个shell) doinput（循环读取输入） yes no yes no

golang实现一个Unix98伪终端的script程序

package main

import (
    "bufio"
    "flag"
    "fmt"
    "os"
    "os/exec"
    "syscall"
    "time"
    "unsafe"
)

// #include <termios.h>
import "C"

const (
    PtyMaster = "/dev/ptmx"
)

var (
    TimingFile = flag.String("t", "timing", "timing file")
)

func main() {
    flag.Parse()

    typeScript := "typescript"

    fmt.Println(os.Args, len(os.Args), *TimingFile)
    args := flag.Args()
    if len(args) != 1 {
        fmt.Printf("[usage]\n\n%s -t timingfile typescript\n", os.Args[0])
        os.Exit(1)
    }

    typeScript = args[0]
    script, err := os.OpenFile(typeScript, os.O_RDWR|os.O_CREATE, 0664)
    if err != nil {
        fmt.Printf("Open Typescript %s Error:%v", typeScript, err)
        os.Exit(1)
    }

    timing, err := os.OpenFile(*TimingFile, os.O_RDWR|os.O_CREATE, 0664)
    if err != nil {
        fmt.Printf("Open Timing %s Error:%v", TimingFile, err)
        os.Exit(1)
    }

    cmd := exec.Command("/bin/bash")
    p, err := start(cmd)
    if err != nil {
        fmt.Printf("start error:%v", err)
        os.Exit(1)
    }

    err = fixtty()
    if err != nil {
        fmt.Printf("fixtty error:%v", err)
        os.Exit(1)
    }

    // 循环从master中读取输出
    go func(p, timing, script *os.File) {
        fmt.Fprintf(script, "Script started on %s\n", time.Now())
        oldTime := time.Now()
        for {
            // fmt.Println("2")
            buf := make([]byte, 1024)
            n, err := p.Read(buf)

            if err != nil {
                break
            }
            newTime := time.Now()
            delay := newTime.Sub(oldTime)
            oldTime = newTime
            //print data to stdout
            fmt.Print(string(buf[:n]))
            //save data to file
            fmt.Fprintf(timing, "%f %d\n", float64(delay)/1e9, n)
            fmt.Fprint(script, string(buf[:n]))
        }
        done(script)
        os.Exit(0)
    }(p, timing, script)

    //循环从标准输入中读取输入
    for {

        buf := make([]byte, 1024)
        rd := bufio.NewReader(os.Stdin)
        n, err := rd.Read(buf)
        if err != nil {
            fmt.Printf("outside:%v\n", err)
            // close master
            p.Close()
            break
        }
        p.Write(buf[:n])
    }

}

func done(f *os.File) {
    fmt.Fprintf(f, "Script done on %s\n", time.Now())
    fmt.Printf("Script done, file is %s", f.Name())
}

// fixtty  将stdin对应的终端设备设置为不回显，非规范方式
func fixtty() error {
    var term Termios
    e := tcget(os.Stdin.Fd(), &term)
    if e != 0 {
        return e
    }
    term.Lflag &^= (syscall.ECHO | syscall.ICANON)
    e = tcset(os.Stdin.Fd(), &term)
    if e != 0 {
        return e
    }
    return nil
}

//start 启动子进程
func start(cmd *exec.Cmd) (pty *os.File, err error) {
    m, s, e := getPty()
    if e != nil {
        return nil, e
    }
    defer s.Close()
    cmd.Stdin = s
    cmd.Stdout = s
    cmd.Stderr = s
    cmd.SysProcAttr = &syscall.SysProcAttr{Setctty: true, Setsid: true}
    err = cmd.Start()
    if err != nil {
        m.Close()
        return nil, err
    }
    return m, err

}

//getPty 获取一对Pty设备
func getPty() (master, slave *os.File, err error) {
    m, e := os.OpenFile(PtyMaster, os.O_RDWR, 0)
    if e != nil {
        return nil, nil, e
    }

    sname, e := ptsName(m)
    if e != nil {
        return nil, nil, e
    }

    e = unlockpt(m)

    if e != nil {
        return nil, nil, e
    }

    s, e := os.OpenFile(sname, os.O_RDWR, 0)
    if e != nil {
        return nil, nil, e
    }
    return m, s, nil
}

//ioctl 模拟c中的ioctl函数
func ioctl(fd, cmd, ptr uintptr) error {
    _, _, e := syscall.Syscall(syscall.SYS_IOCTL, fd, cmd, ptr)
    if e != 0 {
        return e
    }
    return nil
}

//ptsName 获取master对应的slave
func ptsName(f *os.File) (string, error) {
    var n int
    if err := ioctl(f.Fd(), syscall.TIOCGPTN, uintptr(unsafe.Pointer(&n))); err != nil {
        return "", err
    }
    return fmt.Sprintf("/dev/pts/%d", n), nil
}

//unlockpt 释放pty锁
func unlockpt(f *os.File) error {
    var n int
    return ioctl(f.Fd(), syscall.TIOCSPTLCK, uintptr(unsafe.Pointer(&n)))
}

// Termios is the Unix API for terminal I/O.
// It is passthrough for syscall.Termios in order to make it portable with
// other platforms where it is not available or handled differently.
type Termios syscall.Termios

// func cfmakeraw()
func tcget(fd uintptr, p *Termios) syscall.Errno {
    ret, err := C.tcgetattr(C.int(fd), (*C.struct_termios)(unsafe.Pointer(p)))
    if ret != 0 {
        return err.(syscall.Errno)
    }
    return 0
}

func tcset(fd uintptr, p *Termios) syscall.Errno {
    ret, err := C.tcsetattr(C.int(fd), C.TCSANOW, (*C.struct_termios)(unsafe.Pointer(p)))
    if ret != 0 {
        return err.(syscall.Errno)
    }
    return 0
}
hazing
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linux-scripts:有用Linux脚本的集合
05-23
Linux脚本 有用Linux脚本的集合
android 伪终端,伪终端(pty)机制祥解
weixin_29536515的博客
05-28 467
-----------------------------------------------------------本文系本站原创,欢迎转载!转载请注明出处:http://sjj0412.cublog.cn/-----------------------------------------------------------Linux下伪终端是对应于/dev/pts/x，这个/dev/pts其实...
linux 查看伪终端,Linux 伪终端
weixin_39907939的博客
05-03 618
1、综述伪终端对于一个应用程序而言，看上去像一个终端，但事实上伪终端并不是一个真正的终端。从内核角度看，伪终端看起来像一个双向管道，而事实上Solaris的伪终端就是用STREAMS构建的。伪终端总是成对地使用的，就好像是个管道的两端。一端的设备称为"主设备"(master)，另一端的设备称为"从设备"(slave)，每一对伪终端设备，例如/dev/ptys0和/dev/ttys0，就好像是通过一...
利用 script 和 scriptreplay 记录/回放操作
许诺的博客
03-14 552
script makes a typescript of everything displayed on your terminal. It is useful for students who need a hardcopy record of an interactive session as proof of an assignment, as the typescript file can be printed out later with lpr(1). 译文：脚本可以对.
【linux命令讲解大全】086.终端会话重现工具scriptreplay的使用方法详解
全栈若城,专注知识分享
09-08 188
本文介绍了一个名为scriptreplay的终端会话重现工具，它可以根据时间日志和终端数据文件，精确地重现用户在终端中的所有操作和命令输出。该工具适用于教程演示、学习记录等场景。文章详细介绍了scriptreplay命令的选项和参数，并给出了使用示例。通过记录时间日志和终端数据文件，用户可以在任何支持scriptreplay命令的机器上重新播放终端会话，准确呈现用户的操作过程。本文还强调了scriptreplay的独特之处，它不是重新执行命令，而是通过回放输入字符和输出信息的方式实现终端会话的重现。最后，文
Linux用户态编程-伪终端(一)
happyAnger6的专栏
01-24 3936
最近在看telnet终端登陆的相关程序，了解到了telnet登陆的进程安排。对照UNIX环境高级编程对其中使用伪终端的部分进行了一些学习。
Linux Performance and Tuning Guidelines
05-07
Linux Performance and Tuning Guidelines IBM 红皮书
Windows中直接运行Linux程序andLinux官方下载
09-16
andLinux是一个完整的Ubuntu Linux系统,它能够直接运行于Windows 2000/XP/2003和Vista的32位版本上,它由GP2X社区负责维护,而且是永久免费的.andLinux基于CoLinux开发的技术,它提供了一个让Windows连接Linux内核的...
Linux shell Script
10-12
Linux shell Script
Mastering Linux Security and Hardening
07-27
Table of ContentsRunning Linux in a virtual environmentSecuring user accountsSecuring your server with a FirewallEncrypting and SSH HardeningMastering Discretionary Access ControlAccess Control Lists ...
PDF Linux Performance and Tuning Guidelines 4285
02-20
Linux Performance and Tuning Guidelines 4285 PDF Linux® is an open source operating system developed by people from all over the world. The source code is freely available and can be used under the ...
终端主从设备
B10090411的博客
11-11 1557
这两天一直在叽叽复叽叽的念叨着伪终端的相关机制。一直不懂，或者是很多东西在脑子里横冲直撞。好不容易走到了最后，就这么放弃实属可惜。但是把一大本书看下来，的确也花了我很多的时间和精力，不能就因为这么点坎而让这项工程留有遗憾。其实也在网上找了相关的资料，但是我觉得解释的都不透彻，也有可能是我智拙，总之是得不到我想要的东西。后来无奈，只能从头再来，现在也算是略知一二吧。 WHY?　对，有好好的终端
实现Webconsole功能
tankpanv的博客
04-18 3078
近期负责运维研发的工作，前段时间研究了一下WebSocket和Linux下伪终端的功能，主要目的是一直在思考，如何实现WebConsole功能，让公司的同事能够基于浏览器能够安全的登录到公司的服务器，并与公司的安全体系一起，实现权限可管理的、安全性有保证的Web端的shell的功能。 WebConsole简介 理论上来说应该叫做WebShell，它是一种以网页形势存在的一种命令执行环境，也...
ptmx/pts
luckywang1103的专栏
05-05 7926
简介ptmx,pts pseudo terminal master and slavelinux支持的两种pty a. UNIX98 pseudoterminal，使用的是devpts文件系统，挂载在/dev /pts目录 b. 在UNIX98 pseudoterminal之前，master pseudoterminal名字为/dev/ptyp0,…，slave pseudoterminal名字
六 linux串口编程
paomadi的专栏
01-30 4212
一.结构体 1.termios struct termios { tcflag_t c_iflag; /* 输入模式标志 */ tcflag_t c_oflag; /* 输出模式标志 */ tcflag_t c_cflag; /* 控制模式标志 */ tcflag_t c_lflag; /* 本地模式标志 */ cc_t c_line
linux终端和控制台,Linux下的consolen(控制台)和terminal(终端)
weixin_39857899的博客
05-03 3000
console和terminal是很容易让人迷惑的两个概念。要本质上区别这两个名词背后的差异，应该从它的使用角度去区分。terminal(终端),其实是处于用户使用系统的角度来说的，相对于提供服务的系统终端是用户使用这个系统的入口，这个名词的使用范围比console要广。而console(控制台)则强调是控制系统(几乎就是大机了)的地方，其使用者主要是管理员。由于历史的的原因，在计算机世界里ter...
K8s ingress-controller中nginx文件上传大小的限制
最新发布
niwoxiangyu的博客
04-18 554
删除命令： kubectl delete configmap nginx-configuration -n ingress-nginx。2.通过F12 可以看到，后台提示 403错误，可以看到出错是由于nginx的限制，并提示nginx版本号为：nginx/1.13.9。业务自己搭建的nginx ---> 开发者中心主节点的nginx ---> k8s的ingress-control中的nginx；2.查看已存在的configmap，并删除将要更新的configmap。
linux script
03-16
一旦脚本文件被赋予可执行权限，就可以通过在终端中输入 ./script.sh 执行该脚本文件。 在编写 Linux 脚本时，可以使用许多不同的命令和工具。例如，可以使用条件语句、循环语句、函数和变量等来编写复杂的脚本。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值