Unix/Linux编程：登录记账

今天药忘吃喽~ 2022-10-17 11:28 273阅读 0赞

> 登录记账关注的是哪些用户当前登录进了系统以及记录过去的登录和登出行为。

# utmp和wtmp文件 #

Unix系统维护着两个包含与用户登录和登出系统有关的信息的数据文件

*  utmp文件维护着当前登录进系统的用户记录(一起其他一些消息)。每个用户登录进系统时都会向utmp文件写入一条记录。在这条记录中包含一个ut\_user字段，它记录着用户的登录名。当用户登出的时候该条记录会被删除。向[who(1)][who_1]之类的程序会使用utmp文件中的信息来显示当前登录进系统的用户列表
 *  wtmp文件包含着所有用户登录和登出行为以供审计所用。每一个用户登录进系统时，写入 utmp 文件中的记录同时会被附加到 wtmp 文件中。当用户登出系统的时候还会向这个文件附加一条记录。这条记录包含的信息与登录记录相同，但 ut\_user 字段会被置零。last(1)命令可以用来显示和过滤 wtmp 文件中的内容。

在 Linux 上，utmp 文件位于/var/run/utmp，wtmp 文件位于/var/log/wtmp。一般来讲，应用程序无需知道这些路径名，因为这些路径名是编译进 glibc 的。需要引用这些文件的存储位置的程序应该使用在<paths.h> (和<utmpx.h>)中定义的\_PATH\_UTMP 和\_PATH\_WTM 路径名常量，而不是在代码中硬编码路径名。

SUSv3 并没有为 utmp 和 wtmp 文件的路径名提供标准化的符号名。Linux 和 BSD 使用了\_PATH\_UTMP 和\_PATH\_WTMP。而其他很多 UNIX 实现定义了 UTMP\_FILE 和WTMP\_FILE 常量来表示这两个路径名。Linux 还在<utmp.h>中定义了这些名词，但并没有在<utmpx.h>和<paths.h>中对它们进行定义。

# utmpx 结构 #

utmp 和 wtmp 文件包含 utmpx 记录。utmpx 结构式在<utmpx.h>中定义的，如下：

#define UT_UNKNOWN 0
           #define RUN_LVL 1
           #define BOOT_TIME 2
           #define NEW_TIME 3
           #define OLD_TIME 4
           #define INIT_PROCESS 5
           #define LOGIN_PROCESS 6
           #define USER_PROCESS 7
           #define DEAD_PROCESS 8
           #define ACCOUNTING 9
    
           #define UT_LINESIZE 12
           #define UT_NAMESIZE 32
           #define UT_HOSTSIZE 256
    
    		struct exit_status {
        
    	       short int e_termination; /* process termination status. */
    	       short int e_exit; /* process exit status. */
           };
    
           struct utmp {
        
    	       short ut_type; /* type of login */
    	       pid_t ut_pid; /* pid of login process */
    	       char ut_line[UT_LINESIZE]; /* 登录终端 - "/dev/" */
    	       char ut_id[4]; /* init id or abbrev. ttyname */
    	       char ut_user[UT_NAMESIZE]; /* 登录的用户名 */
    	       char ut_host[UT_HOSTSIZE]; /* hostname for remote login */
    	       struct exit_status ut_exit; /* The exit status of a process
    	       marked as DEAD_PROCESS. */
    	       long ut_session; /* session ID, used for windowing*/
    	       struct timeval ut_tv; /* time entry was made. */
    	       int32_t ut_addr_v6[4]; /* IP address of remote host. */
    	       char pad[20]; /* Reserved for future use. */
           };

utmpx结构中的所有字符串字段都以null结尾，除非值完全填满了相应的数组

ut\_type 字段是一个整数，它定义了写入文件的记录类型，其取值为下面一组常量中的一个（括号中给出了相应的数值）

*  EMPTY(0)：这个记录不包含有效的记账信息
 *  RUN\_LVL(1)：
    
     *  这个记录表明在系统启动或关闭时系统运行级别发生了变化。
     *  要在<utmpx.h>中取得这个常量的定义就必须要定义\_GNU\_SOURCE 特性测试宏
 *  BOOT\_TIME (2) ：
    
     *  这个记录包含 ut\_tv 字段中的系统启动时间。
     *  写入 RUN\_LVL 和 BOOT\_TIME 字段的进程通常是 init。这些记录会同时被写入 utmp 和 wtmp 文件
 *  NEW\_TIME (3)：这个记录包含系统时钟变更之后的新时间，记录在 ut\_tv 字段中。
 *  OLD\_TIME (4) ：
    
     *  这个记录包含系统时钟变更之前的旧时间，记录在ut\_tv字段中
     *  当系统时钟发生变更时，NTP daemon（或类似的进程）会将类型为 OLD\_TIME 和 NEW\_TIME 的记录写入到 utmp 和wtmp 文件中。
 *  INIT\_PROCESS (5) ：记录由 init 进程孵化的进程，如 getty 进程，细节信息请参考 inittab(5)手册
 *  LOGIN\_PROCESS (6) ：记录用户登录会话组长进程，如 login(1)进程。
 *  USER\_PROCESS (7) ：
    
     *  记录用户进程，通常是登录会话，用户名会出现在ut\_user字段中
     *  登录会话可能是由login(1)启动，或者是ssh、ftp之类的的提供远程登录工具的应用程序启动
 *  DEAD\_PROCESS (8)
    
     *  这个记录标识出已经退出的进程

对于登录进程来讲，存储在ut\_line和ut\_id字段中的信息都是从终端设备的名称中得出的。

*  ut\_line字段包含了终端设备的完整文件名，
 *  ut\_id字段包含了文件名的后缀——跟在 tty、pts或 pty 后面的字符串（后两个分别表示 System-V 和 BSD 风格的伪终端）。因此，对于/dev/tty2终端来讲，ut\_line 的值为 tty2，ut\_id 的值为 2

在窗口环境中，一些终端模拟器使用ut\_session字段来为终端窗口记录会话ID

在系统启动的时候，init 进程会为每个命令行和虚拟控制台创建一个子进程，每个子进程会执行 getty 程序。getty 程序会打开终端，提示用户输入用户名，然后执行 login(1)。当成功验证用户以及执行了其他一些动作之后，login 会创建一个子进程来执行用户登录 shell。这种登录会话的完整声明周期由写入 wtmp 文件的四个记录来表示，其顺序如下所示。

*  一个 INIT\_PROCESS 记录，由 init 写入。
 *  一个 LOGIN\_PROCES 记录，由 getty 写入。
 *  一个 USER\_PROCESS 记录，由 login 写入。
 *  一个 DEAD\_PROCESS 记录，当 init 进程检测到 login 子进程死亡之后（发生在用户登出时）写入。

# 从 utmp 和 wtmp 文件中检索信息 #

NAME
           getutent, getutid, getutline, pututline, setutent, endutent, utmpname -
           access utmp file entries
    
    SYNOPSIS
           #include <utmp.h>
    
           struct utmp *getutent(void);
           struct utmp *getutid(struct utmp *ut);
           struct utmp *getutline(struct utmp *ut);
    
           struct utmp *pututline(struct utmp *ut);
    
           void setutent(void);
           void endutent(void);
    
           int utmpname(const char *file);

setutxent()函数会将utmp文件的当前位置设置到文件的起始位置

*  通常，在使用任意getutx\*()函数之前应该调用setutxent()，这样就能避免因  
    程序中已经调用到的第三方函数在之前用过这些函数而产生的混淆。
 *  根据所执行的任务的不同，在程序后面合适的地方可能需要调用 setutxent()。

当utmo文件没有被打开时，setuxent()函数和getutx\*()函数会打开这个文件。当用完这个文件之后就可以使用endutxent()函数来关闭这个文件

getutxent()、getutxid()和 getutxline()函数从 utmp 文件中读取一个记录并返回一个指向utmpx 结构（静态分配）的指针

*  getutxent()函数顺序读取 utmp 文件中的下一个记录。
 *  getutxid()和 getutxline()函数会从当前文件位置开始搜索与ut参数指向的utmpx结构中指定的标准匹配的一个记录。

getutxid()函数根据ut参数中ut\_type和ut\_id字段的值在utmp文件中搜索一个记录

*  如果 ut\_type 字段是 RUN\_LVL、BOOT\_TIME、NEW\_TIME 或OLD\_TIME，那么getutxid()会找出下一个 ut\_type 字段与指定的值匹配的记录。（这种类型的记录与用户登录不相关。）这样就能够搜索与修改系统时间和运行级别相关的记录了
 *  如果 ut\_type 字段的取值是剩余的有效值中的一个（INIT\_PROCESS、LOGIN\_ PROCESS、USER\_PROCESS 或 DEAD\_PROCESS），那么 getutxent()会找出下一个ut\_type 字段与这些值中的任意一个匹配并且 ut\_id 字段与 ut 参数中指定的值匹配的记录。这样就能够扫描文件来找出对应于某个特定终端的记录了。

getutxline()函数会向前搜索 ut\_type 字段为 LOGIN\_PROCESS 或USER\_PROCESS 并且 ut\_line 字段与 ut 参数指定的值匹配的记录。这对于找出与用户登录相关的记录是非常有用的。

当搜索失败时（即达到文件尾时还没有找到匹配的记录），getutxid()和 getutxline()都返回NULL。

在一些 UNIX 实现上，getutxline()和 getutxid()将用于返回 utmpx 结构的静态区域看成是某种高速缓冲存储（cache）。如果它们确定上一个 getutx\*()调用放置在高速缓冲存储中的记录与ut指定的标准匹配，那么就不会执行文件读取操作，而是简单地再次返回同样的记录（SUSv3允许这个行为）。因此为避免当在循环中调用 getutxline()和 getutxid()时重复返回同一个记录，必须要使用下面的代码清除这个静态数据结构。

struct utmpx *res = NULL;
    
    if(res != NULL){
        
    	memset(res, 0, sizeof(struct utmpx));
    }
    res = getutxline(&ut);

glibc 实现不会进行这样的缓存，但从可移植性的角度出发，在编写程序时永远不要使用这种技术

> 由于 getutx\*()函数返回的是一个指向静态分配的结构的指针，因此它们是不可重入的。GNU C 库提供了传统的 utmp 函数的可重入版本（getutent\_r()、getutid\_r()以及getutline\_r()），但并没有为 utmpx 函数提供可重入版本。（SUSv3 并没有规定可重入版本。）

在默认情况下，所有 getutx\*()函数都使用标准的 utmp 文件。如果需要使用另一个文件，如 wtmp 文件，那么必须要首先调用 **utmpxname()并指定目标路径名**。

utmpxname()函数仅仅将传入的路径名复制一份，它不会打开文件，但会关闭之前由其他调用打开的所有文件。这表示就算指定了一个无效的路径名，utmpxname()也不会返回错误。相反，当后面调用某个 getutx\*()函数发现无法打开文件时会返回一个错误（即 NULL，errno被设为 ENOENT）。

#define _GNU_SOURCE
    #include <time.h>
    #include <utmpx.h>
    #include <paths.h>
    #include <netinet/in.h>
    #include <arpa/inet.h>
    #include <string.h>
    #include <stdio.h>
    #include <stdlib.h>
    int
    main(int argc, char *argv[])
    {
        
        struct utmpx *ut;
        struct in_addr in;
    
        if (argc > 1 && strcmp(argv[1], "--help") == 0){
        
            printf("%s [utmp-pathname]\n", argv[0]);
            exit(EXIT_FAILURE);
        }
    
    
        if (argc > 1)               /* Use alternate file if supplied */
            if (utmpxname(argv[1]) == -1){
        
                perror("utmpxname");
                exit(EXIT_FAILURE);
            }
    
    
        setutxent();
    
        printf("user     type            PID line   id  host     ");
        printf("term exit session  address         date/time\n");
    
        while ((ut = getutxent()) != NULL) {
                /* Sequential scan to EOF */
            printf("%-8s ", ut->ut_user);
            printf("%-9.9s ",
                   (ut->ut_type == EMPTY) ?         "EMPTY" :
                   (ut->ut_type == RUN_LVL) ?       "RUN_LVL" :
                   (ut->ut_type == BOOT_TIME) ?     "BOOT_TIME" :
                   (ut->ut_type == NEW_TIME) ?      "NEW_TIME" :
                   (ut->ut_type == OLD_TIME) ?      "OLD_TIME" :
                   (ut->ut_type == INIT_PROCESS) ?  "INIT_PR" :
                   (ut->ut_type == LOGIN_PROCESS) ? "LOGIN_PR" :
                   (ut->ut_type == USER_PROCESS) ?  "USER_PR" :
                   (ut->ut_type == DEAD_PROCESS) ?  "DEAD_PR" : "???");
            printf("(%1d) ", ut->ut_type);
            printf("%5ld %-6.6s %-3.5s %-9.9s ", (long) ut->ut_pid,
                   ut->ut_line, ut->ut_id, ut->ut_host);
            printf("%3d %3d ", ut->ut_exit.e_termination, ut->ut_exit.e_exit);
            printf("%8ld ", (long) ut->ut_session);
    
            /* Display IPv4 address */
    
            in.s_addr = ut->ut_addr_v6[0];
            printf(" %-15.15s ", inet_ntoa(in));
            time_t tv_sec = ut->ut_tv.tv_sec;
            printf("%s", ctime((time_t *) &tv_sec));
        }
    
        endutxent();
        exit(EXIT_SUCCESS);
    }

![在这里插入图片描述][20210603095026698.png]  
![在这里插入图片描述][20210603095035132.png]

# 获取登录名称：getlogin() #

getlogin()函数返回登录到调用进程的控制终端的用户名，它会使用在utmp文件中维护的信息：

NAME
           getlogin, getlogin_r, cuserid - get username
    
    SYNOPSIS
           #include <unistd.h>
    
           char *getlogin(void);
           int getlogin_r(char *buf, size_t bufsize);
    
           #include <stdio.h>
    
           char *cuserid(char *string);

getlogin()会调用ttypname()来找出与调用进程的标准输入相关联的终端名，接着它搜索utmp文件以找出ut\_line值与终端名相匹配的记录。如果找到了匹配的记录，那么getlogin()会返回记录中的ut\_user字符串。

如果没有找到匹配的记录或者发生了错误，那么 getlogin()会返回 NULL 并设置 errno 来标示错误。getlogin()失败原因可能是进程没有一个与其标准输入相关联的终端（ENOTTY），这可能是因为进程本身是一个 daemon。另一个可能的原因是终端会话并没有记录在utmp文件中，比如一些软件终端模拟器不会在utmp文件中创建条目

即使当一个用户ID在/etc/passwd文件中拥有多个登录名时(不常见)，getlogin()还是能返回登录这个终端的时机名，因为它依赖的是utmp文件。相反，getpwuid(getuid())总是会返回/etc/passwd 中第一个匹配的记录，不管登录名是什么。

SUSv3 规定了 getlogin()的一个可重入版本 getlogin\_r()，glibc 提供了这个函数。

LOGNAME环境变量也可以用来找出用户的登录名，但是用户可以改变这个变量的值，这表示无法使用这个变量来安全的识别出一个用户

# 为登录会话更新utmp和wtmp文件 #

在编写一个创建登录会话的应用程序（如像 login 或 sshd 那样）时应该要按照下面的步骤更新utmp和wtmp文件

*  在登录的时候应该向utmp文件写入一条记录表明这个用户登录进系统了。应用程序必须要检测utmp文件中是否存在这个终端的记录。如果已经存在了一个记录，那么必须重写这个记录，否则就在文件的后面附加一个新纪录。通常调用 pututxline()就足以确保正确执行这些步骤了。。输出的utmpx 记录至少需要填充 ut\_type、ut\_user、ut\_tv、ut\_pid、ut\_id 以及 ut\_line 字段。
    
     *  ut\_type字段应该被设置成 USER\_PROCESS。
     *  ut\_id 字段应该包含用户登录的设备名（即终端或伪终端）的后缀
     *  ut\_line 字段应该包含登录设备的名称中去除了开头的/dev/的字符串  
        一个包含完全一样的信息的记录会被附加到 wtmp 文件中

> utmp 文件中的记录以终端名（ut\_line 和 ut\_id 字段）作为唯一键。

*  在登出的时候应该删除之前写入 utmp 文件的记录，这是通过创建一个记录并将ut\_type 设置为 DEAD\_PROCESS、同时将 ut\_id 和 ut\_line 设置为登录时写入的记录中相应字段的值并将 ut\_user 字段的值置零来完成的。这个记录会覆盖之前的记录，同时这个记录的一个副本会被附加到 wtmp 文件中。

> 如果在登出时没有成功清理 utmp 中的相关记录(可能是因为程序崩溃)，那么在下一次重启的时候，init会自动清理这些记录并将记录的ut\_type设置为DEAD\_PROCESS 以及将记录中其他字段置零。

通常 utmp 和 wtmp 文件是受保护的，只有特权用户可以更新这些文件。getlogin()的精确程度依赖于 utmp 文件的完整性。正因为这个原因以及其他一些原因，在 utmp 和 wtmp 文件的权限设置中应该永远都不允许非特权用户写这两个文件。

struct utmp *pututline(struct utmp *ut);

pututxline()函数会将 ut 指向的 utmpx 结构写入到/var/run/utmp 文件中（或者如果之前调用了 utmpxname()的话将是另一个文件）。

*  在写入记录之前，pututxline()首先会使用 getutxid()向前搜索一个可被重写的记录。如果找到了这样的记录，那么会重写该记录，否则就会在文件尾附加一个新记录。
 *  在很多情况下，应用程序在调用 pututxline()之前会调用其中一个 getutx\*()函数，因为这个函数会将当前文件位置设定到正确的记录
 *  如果 pututxline()能够确定已经重置过了当前文件位置，那么就不会调用 getutxid()。

> 如果 pututxline()在内部调用了 getutxid()，那么这个调用不会改变 getutx\*()函数用来返回 utmpx 结构的静态区域。SUSv3 要求实现遵循这种行为。

在更新 wtmp 文件时仅仅是简单地打开文件并在文件尾附加一个记录。由于这是一个标准操作，因此 glibc 将其封装进了 updwtmpx()函数。

NAME
           updwtmp, logwtmp - append an entry to the wtmp file
    
    SYNOPSIS
           #include <utmp.h>
    
           void updwtmp(const char *wtmp_file, const struct utmp *ut);
           void logwtmp(const char *line, const char *name, const char *host);
    
    DESCRIPTION
           updwtmp() appends the utmp structure ut to the wtmp file.
    
           logwtmp()  constructs  a utmp structure using line, name, host, current
           time and current process ID.  Then it calls  updwtmp()  to  append  the
           structure to the wtmp file.
    
    FILES
           /var/log/wtmp
                  database of past user logins

SUSv3 没有规定 updwtmpx()，这个函数只出现了一些 UNIX 实现中。如果不存在这样的函数，那么就需要自己编写实现相同功能的函数了。

# lastlog文件 #

lastlog文件记录着每个用户最近一次登录到系统的时间(wtmp 文件记录着所有用户的登录和登出行为。）login程序通过lastlog文件能够通知用户(在新登录会话开始的时候)它们上次登录的时间。提供登录服务的应用程序除了要更新utmp和wtmp文件之外还应该更高lastlog文件。

与 utmp 和 wtmp 文件一样，不同系统实现中 lastlog 文件的存放位置和格式可能会存在差异。（一些 UNIX 实现并没有提供这个文件。）在 Linux 上，这个文件位于/var/log/lastlog，<paths.h>文件中定义的常量\_PATH\_LASTLOG 指向了这个位置。与 utmp 和 wtmp 文件一样，lastlog 文件通常也是受保护的，这样所有用户都能读取这个文件但只有特权进程才能够更新这个文件

更新 lastlog 文件时会打开文件，寻找到正确的位置，然后执行一个写入操作

lastlog 文件中的记录的格式如下所示（在<lastlog.h>中定义）。

#define UT_LINESIZE	32
    #define UT_NAMESIZE	32
    #define UT_HOSTSIZE	256
    
    struct lastlog
      {
        
        __time_t ll_time;
        char ll_line[UT_LINESIZE];
        char ll_host[UT_HOSTSIZE];
      };

注意这些记录中并没有包含用户名或用户 ID。lastlog 文件中的记录是用用户 ID 作为索引的，因此要找出用户 ID 为 1000 的 lastlog 记录就需要到文件的相应位置处（1000 \* sizeof(struct lastlog)）查找。

看个例子：

#define _GNU_SOURCE
    #include <time.h>
    #include <utmpx.h>
    #include <paths.h>
    #include <netinet/in.h>
    #include <arpa/inet.h>
    #include <string.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <time.h>
    #include <lastlog.h>
    #include <paths.h>                      /* Definition of _PATH_LASTLOG */
    #include <fcntl.h>
    #include <zconf.h>
    #include <pwd.h>
    
    uid_t           /* Return UID corresponding to 'name', or -1 on error */
    userIdFromName(const char *name)
    {
        
        struct passwd *pwd;
        uid_t u;
        char *endptr;
    
        if (name == NULL || *name == '\0')  /* On NULL or empty string */
            return -1;                      /* return an error */
    
        u = strtol(name, &endptr, 10);      /* As a convenience to caller */
        if (*endptr == '\0')                /* allow a numeric string */
            return u;
    
        pwd = getpwnam(name);
        if (pwd == NULL)
            return -1;
    
        return pwd->pw_uid;
    }
    int
    main(int argc, char *argv[])
    {
        
        struct lastlog llog;
        int fd, j;
        uid_t uid;
    
        if (argc > 1 && strcmp(argv[1], "--help") == 0){
        
            printf("%s [username...]\n", argv[0]);
            exit(EXIT_FAILURE);
        }
    
    
        fd = open(_PATH_LASTLOG, O_RDONLY);
        if (fd == -1){
        
            perror("open");
            exit(EXIT_FAILURE);
        }
    
    
        for (j = 1; j < argc; j++) {
        
            uid = userIdFromName(argv[j]);
            if (uid == -1) {
        
                printf("No such user: %s\n", argv[j]);
                continue;
            }
    
            if (lseek(fd, uid * sizeof(struct lastlog), SEEK_SET) == -1){
        
                perror("lseek");
                exit(EXIT_FAILURE);
            }
    
    
            if (read(fd, &llog, sizeof(struct lastlog)) <= 0) {
        
                printf("read failed for %s\n", argv[j]);    /* EOF or error */
                continue;
            }
    
            time_t ll_time = llog.ll_time;
            printf("%-8.8s %-6.6s %-20.20s %s", argv[j], llog.ll_line,
                   llog.ll_host, ctime((time_t *) &ll_time));
        }
    
        close(fd);
        exit(EXIT_SUCCESS);
    }

![在这里插入图片描述][20210603101243222.png]

# 总结 #

登录记账记录着当前登录的用户以及过去登录过系统的用户。这类信息维护在三个文件中：

*  utmp 文件维护了所有当前登录进系统的用户记录；
 *  wtmp 文件维护了所有登录和登出行为  
    的审计信息；  
    lastlog 文件记录着每个用户最近一次登录系统的时间。

很多命令，如 who 和 last，都使用了这些文件中的信息。

C 库提供了读取和更新登录记账文件中的信息的函数。提供登录服务的应用程序应该使用这些函数来更新登录记账文件，这样依赖于这些信息的命令才能够表现出正确的行为。

[who_1]: https://blog.csdn.net/zhizhengguan/article/details/117284655
[20210603095026698.png]: /images/20221014/03ed16ab774843a4a9b7fb9755ed85e4.png
[20210603095035132.png]: /images/20221014/191ada65f6ce4e3d89ebc97bf13874e0.png
[20210603101243222.png]: /images/20221014/2a3e69a3f8c442439caa52c2ad724003.png