Transcript 4. 시스템, 사용자 및 시간 정보 접근

시스템 정보
유닉스 시스템 프로그래밍
학습 목표
 유닉스 시스템 정보를 검색하는 함수를 사용할 수 있다.
 사용자 관련 정보를 함수를 이용해 검색할 수 있다.
 시스템의 시간을 관리하는 함수를 사용할 수 있다.
2/45
강의 목차
 유닉스 시스템 관련 정보
 운영체제 기본정보 검색
 시스템 정보 검색과 설정
 시스템 자원 정보 검색
 사용자 정보 검색





 시간 관리 함수





초 단위 시간 검색
시간대 설정
시간 정보 분해 함수
초 단위 시간 생성 함수
형식 지정 시간 출력 함수
로그인명 검색
패스워드 파일 검색
섀도우 파일 검색
그룹 파일 검색
로그인 기록 정보 검색
3/45
유닉스 시스템 관련정보
 시스템에 설치된 운영체제에 관한 정보
 호스트 이름 정보
 하드웨어 종류에 관한 정보
 하드웨어에 따라 사용할 수 있는 자원의 최댓값
 최대 프로세스 개수
 프로세스당 열 수 있는 최대 파일 개수
 메모리 페이지 크기 등
 시스템 정보에 대한 접근
 시스템 정보에 대한 다양한 구조체와 매개변수, 상수 제공
 적절한 시스템 호출과 구조체를 사용하여 시스템 정보를 검색하거나 설정 가능
4/45
운영체제 기본 정보 검색
 시스템에 설치된 운영체제에 대한 기본 정보 검색
• 시스템은 인텔PC고 솔라리스 10운영체제가 설치되어 있고, 호스트명은 hanbit
 운영체제 정보 검색 함수 : uname(2)
#include <sys/utsname.h>
int uname(struct utsname *name);
 utsname 구조체에 운영체제 정보 저장
•
•
•
•
•
sysname : 현재 운영체제 이름
nodename : 호스트명
release : 운영체제의 릴리즈 번호
version : 운영체제 버전 번호
machine : 하드웨어 아키텍처 이름
struct
char
char
char
char
char
};
utsname {
sysname[_SYS_NMLN];
nodename[_SYS_NMLN];
release[_SYS_NMLN];
version[_SYS_NMLN];
machine[_SYS_NMLN];
5/45
[예제 4-1] uname 함수 사용하기
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
ex4_1.c
#include <sys/utsname.h>
#include <stdlib.h>
#include <stdio.h>
int main(void) {
struct utsname uts;
if (uname(&uts) == -1) {
perror("uname");
exit(1);
}
printf("OSname :
printf("Nodename
printf("Release
printf("Version
printf("Machine
# ex4_1.out
OSname : SunOS
Nodename : hanbit
Release : 5.10
Version : Generic_118855-33
Machine : i86pc
%s\n", uts.sysname);
: %s\n", uts.nodename);
: %s\n", uts.release);
: %s\n", uts.version);
: %s\n", uts.machine);
return 0;
}
6/45
시스템 정보 검색과 설정 (1)
 시스템 정보 검색과 설정: sysinfo(2)
#include <sys/systeminfo.h>
long sysinfo(int command, char *buf, long count);
 command에 검색하거나 설정할 명령 지정
 command에 사용할 상수의 범주
SVR4에서 제안, 다른
유닉스운영체제에서
는 지원하지 않을 수
있음
7/45
시스템 정보 검색과 설정 (2)
 유닉스 표준에서 정의한 정보 검색용 상수
8/45
시스템 정보 검색과 설정 (3)
 유닉스 표준에서 정의한 정보 설정용 상수
 솔라리스에서 정의한 정보 검색용 상수
9/45
[예제 4-2] sysinfo 함수 사용하기(검색)
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
ex4_2.c
#include <sys/systeminfo.h>
#include <stdlib.h>
#include <stdio.h>
int main(void) {
char buf[257];
하드웨어 일련번호 검색
if (sysinfo(SI_HW_SERIAL, buf, 257) == -1) {
perror("sysinfo");
exit(1);
}
사용가능한 아키텍처 목록검색
printf("HW Serial : %s\n", buf);
if (sysinfo(SI_ISALIST, buf, 257) == -1) {
perror("sysinfo");
exit(1);
}
printf("ISA List : %s\n", buf);
return 0;
}
# ex4_2.out
HW Serial : 545486663
ISA List : amd64 pentium_pro+mmx pentium_pro pentium+mmx pentium
i486 i386 i86
10/45
[예제 4-3] sysinfo 함수 사용하기(설정)
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include
#include
#include
#include
ex4_3.c
<sys/systeminfo.h>
<stdlib.h>
<stdio.h>
<string.h>
int main(void) {
char buf[257];
if (sysinfo(SI_HOSTNAME, buf, 257) == -1) {
perror("sysinfo");
exit(1);
}
printf("Before Hostname : %s\n", buf);
strcpy(buf, "hbooks");
if (sysinfo(SI_SET_HOSTNAME, buf, 257) == -1) {
perror("sysinfo");
exit(1);
}
호스트 이름 변경
if (sysinfo(SI_HOSTNAME, buf, 257) == -1) {
perror("sysinfo");
exit(1);
11/45
[예제 4-3] sysinfo 함수 사용하기(설정)
24
25
26
27
28
}
printf("After Hostname : %s\n", buf);
return 0;
}
# ex4_3.out
Before Hostname : hanbit
After Hostname : hbooks
12/45
시스템 정보 검색과 설정 (4) : Linux
 sysinfo(2) in Linux
#include <sys/sysinfo.h>
int sysinfo(struct sysinfo *info);
 시스템 통계값에 대한 정보 검색
 sysinfo 구조체
struct sysinfo {
long uptime;
/* Seconds since boot */
unsigned long loads[3]; /* 1, 5, and 15 minute load averages */
unsigned long totalram; /* Total usable main memory size */
unsigned long freeram;
/* Available memory size */
unsigned long sharedram; /* Amount of shared memory */
unsigned long bufferram; /* Memory used by buffers */
unsigned long totalswap; /* Total swap space size */
unsigned long freeswap; /* swap space still available */
unsigned short procs;
/* Number of current processes */
unsigned long totalhigh; /* Total high memory size */
unsigned long freehigh; /* Available high memory size */
unsigned int mem_unit;
/* Memory unit size in bytes */
char _f[20-2*sizeof(long)-sizeof(int)]; /* Padding for libc5 */
};
13/45
시스템 정보 검색과 설정 (5) : Linux
 호스트 이름 검색 및 설정
#include <unistd.h>
int gethostname(char *name, int namelen);
int sethostname(cont char *name, int namelen);
 gethostname : 현재 시스템에 설정된 호스트 명을 검색
 sethostname : 시스템에 호스트 명을 새로이 설정
 Linux를 포함한 BSD 계열 유닉스 운영체제에서 사용
14/45
시스템 자원 정보 검색 (1)
 하드웨어에 따라 사용할 수 있는 자원들의 최댓값 검색
 시스템 자원 정보 검색 : sysinfo(3)
#include <unistd.h>
long sysconf(int name);
 검색할 정보를 나타내는 상수를 사용해야 한다.
 POSIX.1에서 정의한 상수
15/45
시스템 자원 정보 검색 (2)
 SVR4에서 정의한 상수
 POSIX.4에서 정의한 상수
 XPG.4에서 정의한 상수
16/45
[예제 4-4] sysconf 함수 사용하기
01
02
03
04
05
06
07
08
09
10
ex4_4.c
#include <unistd.h>
#include <stdio.h>
int main(void) {
printf("Clock Tick : %ld\n", sysconf(_SC_CLK_TCK));
printf("Max Open File : %ld\n", sysconf(_SC_OPEN_MAX));
printf("Max Login Name Length : %ld\n", sysconf(_SC_LOGNAME_MAX));
return 0;
}
# ex4_4.out
Clock Tick : 100
Max Open File : 256
Max Login Name Length : 8
17/45
시스템 자원 정보 검색 (3)
 파일과 디렉토리 관련 자원 검색 : fpathconf(3), pathconf(3)
#include <unistd.h>
long pathconf(const char *path, int name);
long fpathconf(int fildes, int name);
 경로(path)나 파일기술자에 지정된 파일에 설정된 자원값이나 옵션값 반환
 name 사용할 상수
18/45
[예제 4-5] pathconf 함수 사용하기
01
02
03
04
05
06
07
08
09
10
ex4_5.c
#include <unistd.h>
#include <stdio.h>
int main(void) {
printf("Link Max : %ld\n", pathconf(".", _PC_LINK_MAX));
printf("Name Max : %ld\n", pathconf(".", _PC_NAME_MAX));
printf("Path Max : %ld\n", pathconf(".", _PC_PATH_MAX));
return 0;
}
# ex4_5.out
Link Max : 32767
Name Max : 255
Path Max : 1024
19/45
사용자 정보 검색 (1)
 사용자 정보, 그룹정보, 로그인 기록 검색
 /etc/passwd, /etc/shadow, /etc/group, /var/run/utmp
 사용자 식별 정보 : 로그인명 / UID(User ID)
 로그인명
• 사용자 식별 문자열
• 주로 시스템 외부에서 사용자를 식별할 때 사용
• 사용자와 관련된 시스템 자원 정보를 보여줄 때에 사용
 UID
• 사용자 식별 번호(정수)
• 주로 시스템 내부에서 사용자를 식별할 때 사용
• 시스템 자원의 소유자를 식별할 때 사용
 /etc/passwd 시스템 파일
• 사용자의 주요 정보를 저장
• 로그인명과 UID를 mapping
• 패스워드 암호화 여부 및 홈디렉토리, 로그인 쉘 정보 등을 저장
 /etc/shadow
• 패스워크의 암호화 파일
20/45
사용자 정보 검색 (2)
 로그인명 검색 : getlogin(3), cuserid(3)
#include <unistd.h>
char *getlogin(void);
 /var/run/utmp(or /var/adm/utmpx) 파일을 검색하여 현재 프로세스를 실행한
사용자의 로그인명을 반환
#include <stdio.h>
char *cuserid(char *s);
 현재 프로세스의 소유자 정보로 로그인명을 찾아 반환
 매개변수 s : 반환받을 로그인명을 저장할 버퍼 주소
• s = NULL : 시스템 메모리에 로그인명을 저장하고 그 주소를 반환
21/45
사용자 정보 검색 (3)
 UID 검색
#include <sys/types.h>
#include <unistd.h>
uid_t getuid(void);
uid_t geteuid(void);
 getuid : 실제 사용자 ID를 반환
• 실제 사용자 ID (uid) : 로그인할 때 사용한 로그인명에 대응하는 UID, 현재 프로세스를
생성한 사용자를 식별
 geteuid : 유효 사용자 ID를 반환
• 유효 사용자 ID(euid) : 프로세스에 대한 접근 권한을 부여할 때에 사용
• 로그인 시에는 uid와 euid는 동일하나, setuid 권한이 설정된 프로그램을 실행하거나
다른 사용자 ID로 변경하는 경우에 euid는 변경된다.
22/45
[예제 4-6] getuid, geteuid 함수 사용하기
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
ex4_6.c
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
int main(void) {
uid_t uid, euid;
char *name, *cname;
uid = getuid();
euid = geteuid();
name = getlogin();
cname = cuserid(NULL);
printf("Login Name=%s,%s UID=%d, EUID=%d\n", name, cname,
(int)uid, (int)euid);
# ex4_6.out
Login Name=root,root UID=0, EUID=0
return 0;
}
# chmod 4755 ex4_6.out
# ls -l ex4_6.out
-rwsr-xr-x
1 root
setuid 설정 후 일반사용자가 이 파일을 실행하면?
other
5964
1월 29일 15:11 ex4_6.out
23/45
/etc/passwd 파일 검색 (1)
 /etc/passwd 파일의 구조
# cat /etc/passwd
root:x:0:0:Super-User:/:/usr/bin/ksh
daemon:x:1:1::/:
bin:x:2:2::/usr/bin:
......
hbooks:x:100:1:Hanbit Books:/export/home/han:/bin/ksh
24/45
/etc/passwd 파일 검색 (2)
 UID로 passwd 파일 읽기 : getpwuid(3)
#include <pwd.h>
struct passwd *getpwuid(uid_t uid);
 이름으로 passwd 파일 읽기 : getpwnam(3)
#include <pwd.h>
struct passwd *getpwnam(const char *name);
 passwd 구조체
struct passwd
char
char
uid_t
gid_t
char
char
char
char
char
};
{
*pw_name;
*pw_passwd;
pw_uid;
pw_gid;
*pw_age;
*pw_comment;
*pw_gecos;
*pw_dir;
*pw_shell;
25/45
[예제 4-7] getpwuid 함수 사용하기
01
02
03
04
05
06
07
08
09
10
11
12
ex4_7.c
#include <unistd.h>
#include <pwd.h>
int main(void) {
struct passwd *pw;
pw = getpwuid(getuid());
printf("UID : %d\n", (int)pw->pw_uid);
printf("Login Name : %s\n", pw->pw_name);
return 0;
}
# ex4_7.out
UID : 0
Login Name : root
26/45
[예제 4-8] getpwnam 함수 사용하기
01
02
03
04
05
06
07
08
09
10
11
ex4_8.c
#include <pwd.h>
int main(void) {
struct passwd *pw;
pw = getpwnam("hbooks");
printf("UID : %d\n", (int)pw->pw_uid);
printf("Home Directory : %s\n", pw->pw_dir);
return 0;
}
# ex4_8.out
UID : 100
Home Directory : /export/home/han
27/45
/etc/passwd 파일 검색 (3)
 /etc/passwd 파일 순차적으로 읽기
#include <pwd.h>
struct passwd *getpwent(void);
// 사용자 정보를 순차적으로 읽어옴
void setpwent(void);
// 파일 오프셋을 파일 처음으로 이동
void endpwent(void);
// 파일 오프셋을 파일 마지막으로 이동
struct passwd *fgetpwent(FILE *fp);
[예제 4-9] getpwent 함수 사용하기
01
02
03
04
05
07
08
09
10
11
12
13
ex4_9.c
#include <pwd.h>
int main(void) {
struct passwd *pw;
int n;
for (n = 0; n < 3; n++) {
pw = getpwent();
printf("UID: %d, LoginName: %s\n", (int)pw->pw_uid,
pw->pw_name);
# ex4_9.out
}
UID: 0, LoginName: root
UID: 1, LoginName: daemon
return 0;
UID: 2, LoginName: bin
}
28/45
섀도우 파일 검색 (1)
 /etc/shadow 파일의 구조
# cat /etc/shadow
root:lyTy6ZkWh4RYw:13892::::::
daemon:NP:6445::::::
bin:NP:6445::::::
......
hbooks:KzV35jsiil./6:14273:3:30:7:10:14344:
29/45
섀도우 파일 검색 (2)
 /etc/shadow 파일 읽기 : getspnam(3)
#include <shadow.h>
struct spwd *getspnam(const char *name);
 spwd 구조체
struct spwd {
char *sp_namp;
// 로그인명
char *sp_pwdp;
// 암호화된 패스워드
int
sp_lstchg; // 패스워드를 변경한 날짜 정보
int
sp_min;
// 변경된 패스워드의 최소 사용 일 수
int
sp_max;
// 변경된 패스워드의 최대 사용 일 수
int
sp_warn;
// 패스워드 변경 경고 시작 일 수
int
sp_inact; // 사용자 계정으로 로그인할 수 없는 일 수
int
sp_expire; // 사용자 계정 만료 날짜 정보
unsigned int sp_flag;
};
30/45
[예제 4-10] getspnam 함수 사용하기
01
02
03
04
05
06
07
08
09
10
11
12
ex4_10.c
#include <shadow.h>
int main(void) {
struct spwd *spw;
spw = getspnam("hbooks");
printf("Login Name : %s\n", spw->sp_namp);
printf("Passwd : %s\n", spw->sp_pwdp);
printf("Last Change : %d\n", spw->sp_lstchg);
return 0;
}
# ex4_10.out
Login Name : hbooks
Passwd : KzV35jsiil./6
Last Change : 14273
31/45
섀도우 파일 검색 (3)
 /etc/shadow 파일 순차적으로 읽기
#include <shadow.h>
struct spwd *getspent(void);
// 패스워드 정보를 순차 읽기
void setspent(void);
// 파일 오프셋을 파일 처음으로 이동
void endspent(void);
// 파일 오프셋을 파일 마지막으로 이동
struct spwd *fgetspent(FILE *fp);
[예제 4-11] getspent 함수 사용하기
01
02
03
04
05
06
07
08
09
10
11
12
13
ex4_11.c
#include <shadow.h>
int main(void) {
struct spwd *spw;
int n;
}
for (n = 0; n < 3; n++) {
spw = getspent();
printf("LoginName: %s, Passwd: %s\n", spw->sp_namp,
spw->sp_pwdp);
}
# ex4_11.out
LoginName: root, Passwd: lyTy6ZkWh4RYw
return 0;
LoginName: daemon, Passwd: NP
LoginName: bin, Passwd: NP
32/45
그룹 정보 검색 (1)
 사용자 그룹 정보
 유닉스 시스템에서는 사용자는 하나 이상의 그룹(group)에 속한다
 그룹 식별
• 그룹명(group name) : 그룹 식별 문자열
• 그룹 ID(group ID:GID) : 그룹 식별 번호(정수)
 사용자는 소속 그룹에 따라 시스템 자원 및 파일 등에 대한 다른 접근 권한을
가진다.
 /etc/group
• 그룹 식별 정보를 저장하고 있는 파일
• 그룹명, GID, 그룹 소속 로그인명 등의 정보를 저장
33/45
그룹 정보 검색 (2)
 그룹 ID 검색하기 : getgid(2), getegid(2)
#include <sys/types.h>
#include <unistd.h>
gid_t getgid(void);
gid_t getegid(void);
// 현재 프로세스의 실제 그룹 ID
// 현재 프로세스의 유효 그룹 ID
[예제 4-12] getid, getegid 함수 사용하기
01
02
03
04
05
06
07
08
09
10
11
12
13
14
ex4_12.c
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
int main(void) {
gid_t gid, egid;
gid = getgid();
egid = getegid();
printf("GID=%d, EGID=%d\n", (int)gid, (int)egid);
return 0;
}
# ex4_12.out
GID=1, EGID=1
34/45
그룹 파일 검색 (1)
 /etc/group 파일의 구조
# cat /etc/group
root::0:
other::1:root
bin::2:root,daemon
sys::3:root,bin,adm
adm::4:root,daemon
uucp::5:root
......
 group 구조체
struct group
char
char
gid_t
char
};
{
*gr_name;
*gr_passwd;
gr_gid;
**gr_mem;
//
//
//
//
그룹명
그룹 패스워드
GID
그룹 멤버 로그인명 목록
35/45
그룹 파일 검색 (2)
 /etc/group 파일 검색 : getgrnam(3), getgrgid(3)
#include <grp.h>
struct group *getgrnam(const char *name);
struct group *getgrgid(gid_t gid);
 /etc/group 파일 순차적으로 읽기
#include <grp.h>
struct group *getgrent(void);
void setgrent(void);
void endgrent(void);
struct group *fgetgrent(FILE *fp);
36/45
[예제 4-13] getgrnam 함수 사용하기
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
ex4_13.c
#include <grp.h>
int main(void) {
struct group *grp;
int n;
grp = getgrnam("adm");
printf("Group Name : %s\n", grp->gr_name);
printf("GID : %d\n", (int)grp->gr_gid);
n = 0;
printf("Members : ");
while (grp->gr_mem[n] != NULL)
printf("%s ", grp->gr_mem[n++]);
printf("\n");
return 0;
}
# ex4_13.out
Group Name : adm
GID : 4
Members : root daemon
37/45
[예제 4-14] getgrent 함수 사용하기
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
ex4_14.c
#include <grp.h>
int main(void) {
struct group *grp;
int n,m;
for (n = 0; n < 3; n++) {
grp = getgrent();
printf("GroupName: %s, GID: %d ", grp->gr_name,
(int)grp->gr_gid);
m = 0;
printf("Members : ");
while (grp->gr_mem[m] != NULL)
printf("%s ", grp->gr_mem[m++]);
printf("\n");
}
return 0;
}
# ex4_14.out
GroupName: root, GID: 0 Members :
GroupName: other, GID: 1 Members : root
GroupName: bin, GID: 2 Members : root daemon
38/45
로그인 기록 검색 (1)
 who 명령 : 현재 시스템에 로그인하고 있는 사용자 정보
 last 명령 : 시스템의 부팅 시간 정보와 사용자 로그인 기록 정보
 /var/run/utmp : 현재 로그인된 사용자 정보를 저장
 /var/adm/utmpx – SVR4(솔라리스) 계열 유닉스에서 지원
 utmp 구조체 정보 단위로 저장 및 검색
 /var/log/wtmp : 이전에 로그인된 사용자 정보를 저장
 이전에 로그인 사용자를 추적 가능
39/45
로그인 기록 검색 (2)
 utmp 구조체 (in Linux)
/*
* utmp
*/
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
record types
EMPTY
RUN_LVL
BOOT_TIME
NEW_TIME
OLD_TIME
INIT_PROCESS
LOGIN_PROCESS
USER_PROCESS
DEAD_PROCESS
ACCOUNTING
#define UT_LINESIZE
#define UT_NAMESIZE
#define UT_HOSTSIZE
0
1
2
3
4
5
6
7
8
9
/*
/*
/*
/*
/*
/*
/*
/*
/*
/*
Record does not contain valid info */
Change in system run-level */
Time of system boot (in ut_tv) */
Time after system clock change (in ut_tv) */
Time before system clock change (in ut_tv) */
Process spawned by init(8) */
Session leader process for user login */
Normal process */
Terminated process */
Not implemented */
32
32
256
struct exit_status {
short int e_termination;
short int e_exit;
};
/* Type for ut_exit, below */
/* Process termination status */
/* Process exit status */
40/45
로그인 기록 검색 (3)
 utmp 구조체 (in Linux)
struct utmp {
short
ut_type;
pid_t
ut_pid;
char
ut_line[UT_LINESIZE];
char
ut_id[4];
char
ut_user[UT_NAMESIZE];
char
ut_host[UT_HOSTSIZE];
Type of record */
PID of login process */
Device name of tty - "/dev/" */
Terminal name suffix, or inittab(5) ID */
Username */
Hostname for remote login, or
kernel version for run-level messages */
struct exit_status ut_exit; /* Exit status of a process
marked as DEAD_PROCESS; not used by Linux init(8) */
/* The ut_session and ut_tv fields must be the same size when
compiled 32- and 64-bit. This allows data files and shared
memory to be shared between 32- and 64-bit applications. */
#if __WORDSIZE == 64 && defined __WORDSIZE_COMPAT32
int32_t ut_session;
/* Session ID (getsid(2)), used for windowing */
struct {
int32_t tv_sec;
/* Seconds */
int32_t tv_usec;
/* Microseconds */
} ut_tv;
/* Time entry was made */
#else
long
ut_session;
/* Session ID */
struct timeval ut_tv;
/* Time entry was made */
#endif
int32_t ut_addr_v6[4];
char __unused[20];
};
/*
/*
/*
/*
/*
/*
/* Internet address of remotehost;
IPv4 address uses just ut_addr_v6[0] */
/* Reserved for future use */
41/45
로그인 기록 검색 (4)
 ut_type : 현재 읽어온 항목의 종류




EMPTY(0) : 비어 있는 항목
RUN_LVL(1) : 시스템의 런레벨이 변경되었음을 나타냄. 바뀐 런레벨은 ut_id에 저장
BOOT_TIME(2) : 시스템 부팅 정보를 나타냄. 부팅 시간은 ut_time에 저장
OLD_TIME(3) : date 명령으로 시스템 시간이 변경되었음을 나타냄. 변경되기 전의 시간
을 저장
 NEW_TIME(4) : date 명령으로 시스템 시간이 변경되었음을 나타내고 변경된 시간을 저
장
 INIT_PROCESS(5) : init에 의해 생성된 프로세스임을 나타냄. 프로세스명은 ut_name에
저장하고 프로세스 ID는 ut_pid에 저장한다.
 LOGIN_PROCESS(6) : 사용자가 로그인하기를 기다리는 getty 프로세스를 나타낸다
 USER_PROCESS(7) : 사용자 프로세스를 나타낸다.
 DEAD_PROCESS(8) : 종료한 프로세스를 나타낸다.
 ACCOUNTING(9) : 로그인 정보를 기록한 것임을 나타낸다.
 DOWN_TIME(10) : 시스템을 다운시킨 시간을 나타낸다. ut_type이 가질 수 있는 가장
큰 값이다.
42/45
로그인 기록 검색 (5)
 /var/adm/utmpx 파일 순차적으로 읽기
#include <utmpx.h>
struct utmpx *getutxent(void);
void setutxent(void);
void endutxent(void);
int utmpxname(const char *file);
[예제 4-15] getutxent 함수 사용하기
// utmp 구조체 정보를 순차적으로 읽기
// 파일 오프셋을 파일 처음으로 이동
// 파일 오프셋을 파일 마지막으로 이동
ex4_15.c
...
05 int main(void) {
# ex4_15.out
06
struct utmpx *utx;
LoginName Line
07
--------------08
printf("LoginName Line\n");
root
console
09
printf("---------------\n");
root
pts/3
10
11
while ((utx=getutxent()) != NULL) {
root
pts/5
12
if (utx->ut_type != USER_PROCESS)
root
pts/4
13
continue;
14
15
printf("%s
%s\n", utx->ut_user, utx->ut_line);
16
}
17
18
return 0;
19 }
43/45
로그인 기록 검색 (6)
 /var/run/utmp 파일 순차적으로 읽기 (in Linux)
#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);





utmpname : utmp-format file 이름을 새롭게 설정
setutent / endutent : 파일 오프셋 이동
getutent : utmp-format file로 부터 utmp 구조체 정보를 순차적으로 읽기
getutid / getutline : 지정된 ut_type가 매칭되는 구조체 정보를 읽기
pututline : 새로운 utmp 구조체 정보를 utmp-format file에 저장
44/45
시간 관리 함수 (1)
 유닉스 시스템에서 시간관리
 1970년 1월 1일 0시 0분 0초(UTC)를 기준으로 현재까지 경과한 시간을 초 단
위로 저장하고 이를 기준으로 시간 정보 관리
 초 단위로 현재 시간 정보 얻기 : time(2)
#include <sys/types.h>
#include <time.h>
time_t time(time_t *tloc);
[예제 4-16] time 함수 사용하기
01
02
03
04
05
06
07
08
09
10
11
12
ex4_16.c
#include <sys/types.h>
#include <time.h>
#include <stdio.h>
int main(void) {
time_t tt;
time(&tt);
printf("Time(sec) : %d\n", (int)tt);
return 0;
}
# ex4_16.out
Time(sec) : 1233361205
45/45
시간 관리 함수 (2)
 마이크로 초 단위로 시간 정보얻기 : gettimeofday(3)
BSD 유닉스 계열에서 지원
#include <sys/time.h>
int gettimeofday(struct timeval *tp, void *tzp);
int settimeofday(struct timeval *tp, void *tzp);
 timeval 구조체
struct timeval {
time_t
tv_sec; /* 초 */
suseconds_t tv_usec; /* 마이크로 초 */
};
[예제 4-17] gettimeofday 함수 사용하기
..
04
05
06
07
08
09
10
11
12
ex4_17.c
int main(void) {
struct timeval tv;
gettimeofday(&tv, NULL);
printf("Time(sec) : %d\n", (int)tv.tv_sec);
printf("Time(micro-sec) : %d\n", (int)tv.tv_usec);
return 0;
}
# ex4_17.out
Time(sec) : 1233362365
Time(micro-sec) : 670913
46/45
시간 관리 함수 (3)
 시간대 정보 : tzset(3)
 현재 지역의 시간대로 시간을 설정
 전역변수 4개에 정보를 설정
•
•
•
•
#include <time.h>
void tzset(void);
timezone : UTC와 지역 시간대와 시차를 초 단위로 저장
altzone : UTC와 일광절약제 등으로 보정된 지역시간대와의 시차를 초 단위로 저장
daylight : 일광절약제를 시행하면 0이 아니고, 아니면 0
tzname : 지역시간대와 보정된 시간대명을 약어로 저장
[예제 4-18] tzset 함수 사용하기
01
02
03
04
05
06
07
08
09
10
11
12
13
14
#include <time.h>
#include <stdio.h>
int main(void) {
tzset();
printf("Timezone : %d\n", (int)timezone);
printf("Altzone : %d\n", (int)altzone);
printf("Daylight : %d\n", daylight);
printf("TZname[0] : %s\n", tzname[0]);
printf("TZname[1] : %s\n", tzname[1]);
ex4_18.c
# ex4_18.out
Timezone : -32400
Altzone : -36000
Daylight : 1
TZname[0] : KST
TZname[1] : KDT
UTC와 9시간(32,400초) 시차가 발생
return 0;
}
47/45
시간의 형태 변환 (1)
 tm 구조체
 초단위 시스템 시간을 사용자가 인식하기 쉬운 형태로 변환하여 저장할 수 있
는 구조체
 시간 정보를 시분초 및 년월일 정보 등으로 표현
struct tm {
int tm_sec; // 초(0~60)
int tm_min; // 분(0~50)
int tm_hour; // 시(0~23)
int tm_mday; // 일(1~31)
int tm_mon; // 월(0~11)
int tm_year; // 년도: (현재 년도 – 1900)
int tm_wday; // 요일(0~6)
int tm_yday; // 일 수(0~365)
int tm_isdst; // 일과제 시행 여부
};
48/45
시간의 형태 변환 (2)
 초 단위 시간 정보 분해 : gmtime(3), localtime(3)
#include <time.h>
struct tm *localtime(const time_t *clock);
struct tm *gmtime(const time_t *clock);
 초단위 시간을 인자로 받아 tm 구조체 반환
 gmtime은 UTC기준, localtime은 지역시간대 기준으로 환산
 초 단위 시간으로 역산 : mktime(3)
#include <time.h>
time_t mktime(struct tm *timeptr);
 tm 구조체로 주어진 시간 정보를 초단위 시간 정보로 역산
49/45
[예제 4-19] gmtime, localtime 함수 사용하기
01 #include <time.h>
02 #include <stdio.h>
03
04 int main(void) {
05
struct tm *tm;
06
time_t t;
07
08
time(&t);
09
printf("Time(sec) : %d\n", (int)t);
10
11
tm = gmtime(&t);
12
printf("GMTIME=Y:%d ", tm->tm_year);
13
printf("M:%d ", tm->tm_mon);
printf("D:%d ", tm->tm_mday);
15
printf("H:%d ", tm->tm_hour);
16
printf("M:%d ", tm->tm_min);
17
printf("S:%d\n", tm->tm_sec);
18
19
tm = localtime(&t);
20
printf("LOCALTIME=Y:%d ", tm->tm_year);
21
printf("M:%d ", tm->tm_mon);
22
printf("D:%d ", tm->tm_mday);
ex4_19.c
50/45
[예제 4-19] gmtime, localtime 함수 사용하기
23
24
25
26
27
28
printf("H:%d ", tm->tm_hour);
printf("M:%d ", tm->tm_min);
printf("S:%d\n", tm->tm_sec);
return 0;
}
# ex4_19.out
Time(sec) : 1233369331
GMTIME=Y:109 M:0 D:31 H:2 M:35 S:31
LOCALTIME=Y:109 M:0 D:31 H:11 M:35 S:31
연도가 109?
어떻게 해석해야하나?
51/45
[예제 4-20] mktime 함수 사용하기
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
ex4_20.c
#include <time.h>
#include <stdio.h>
int main(void) {
struct tm tm;
time_t t;
time(&t);
printf("Current Time(sec) : %d\n", (int)t);
tm.tm_year = 109;
tm.tm_mon = 11;
tm.tm_mday = 31;
tm.tm_hour = 12;
tm.tm_min = 30;
tm.tm_sec = 0;
t = mktime(&tm);
printf("2009/12/31 12:30:00 Time(sec) : %d\n", (int)t);
return 0;
}
# ex4_20.out
Current Time(sec) : 1233370219
2009/12/31 12:30:00 Time(sec) : 1262226600
52/45
형식 지정 시간 출력 (1)
 초 단위 시간을 변환해 출력하기: ctime(3)
#include <time.h>
초단위 시간을 시분초 시간의 문자열로 변환
char *ctime(const time_t *clock);
[예제 4-21] ctime 함수 사용하기
01
02
03
04
05
06
07
08
09
10
11
12
13
ex4_21.c
#include <time.h>
#include <stdio.h>
int main(void) {
time_t t;
time(&t);
printf("Time(sec) : %d\n", (int)t);
printf("Time(date) : %s\n", ctime(&t));
return 0;
}
# ex4_21.out
Time(sec) : 1233370759
Time(date) : Sat Jan 31 11:59:19 2009
53/45
형식 지정 시간 출력 (2)
 tm 구조체 시간을 변환해 출력하기: asctime(3)
#include <time.h>
tm 구조체 시간을 시분초 시간의 문자열로 변환
char *asctime(const struct tm *tm);
[예제 4-22] asctime 함수 사용하기
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
ex4_22.c
#include <time.h>
#include <stdio.h>
int main(void) {
struct tm *tm;
time_t t;
time(&t);
tm = localtime(&t);
printf("Time(sec) : %d\n", (int)t);
printf("Time(date) : %s\n", asctime(tm));
return 0;
}
# ex4_22.out
Time(sec) : 1233371061
Time(date) : Sat Jan 31 12:04:21 2009
54/45
형식 지정 시간 출력 (3)
 출력 형식 기호 사용 : strftime(3)
#include <time.h>
size_t strftime(char *restrict s, size_t maxsize,
const char *restrict format, const struct tm *restrict timeptr);




s : 출력할 시간 정보를 저장할 문자열 주소
maxsize : s의 크기
format : 출력 형식 – 형식 지정자로 출력형식을 정의한 문자열
timeptr : 출력할 시간정보를 저장한 구조체 주소
55/45
형식 지정 시간 출력 (4)
 시간정보 출력 형식 지정자
56/45
형식 지정 시간 출력 (5)
57/45
[예제 4-23] strftime 함수 사용하기
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
ex4_23.c
#include <time.h>
#include <stdio.h>
char *output[] = {
"%x %X",
"%G% ‚֙ mਘ %dੌ %U઱ %H:%M",
"%r"
};
int main(void) {
struct tm *tm;
int n;
time_t t;
char buf[257];
time(&t);
tm = localtime(&t);
for (n = 0; n < 3; n++) {
strftime(buf, sizeof(buf), output[n], tm);
printf("%s = %s\n", output[n], buf);
}
return 0;
}
# ex4-23.out
%x %X = 01/31/09 12:43:12
%G년 %m월 %d일 %U주 %H:%M = 2009년 01월 31일 04주 12:43
%r = 12:43:12 PM
58/45
과제물 #3
1. 과제물 내용
현재 시스템에서 제일 마지막에 로그인하였던 사용자를 식별하고, 이 사용자
가 가장 최근에 로그인한 후에 수정한 홈디렉토리 항목(파일, 디렉토리)을 모
두 찾아 그 항목에 대한 자세한 정보를 출력하여라.
2. 제출일
- 2012년 4월 9일 수업시간
3. 제출물
- 프로그램 설계에 대한 구체적인 설명
- 프로그램 소스
- 프로그램 실행 예
59/45
유닉스 시스템 프로그래밍