[UNIX 시스템 프로그래밍 second Edition - KEITH HAVILAND저] 연습문제 풀이입니다.


(저작권에 저촉 될 우려가 있어 문제 내용은 생략합니다.)


연습문제 3.6 입니다.

주어진 화일에 대해 읽기, 쓰기 또는 수행접근 여부를 확인하기 위해 access 함수를 이용했습니다.

코드를 보면 쉽게 이해할 것이라 생각합니다.


코드는 C++로 작성하였습니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
 
void whatable(char* filename) {
    if(access (filename, R_OK) == -1)
        perror("cannot read ");
    else
        printf("%s readable, proceeding\n", filename);
    
    if(access (filename, W_OK) == -1)
        perror("cannot write ");
    else
        printf("%s writeable, proceeding\n", filename);
 
    if(access (filename, X_OK) == -1)
        perror("cannot execute ");
    else
        printf("%s executable, proceeding\n", filename);
}
 
int main(int argc, char* argv[]) {
    if(argc == 2)
        whatable(argv[1]);
    else {
        printf("error : no filename or many filename\n");
        return -1;    
    }
    return 0;
}
 
cs


[UNIX 시스템 프로그래밍 second Edition - KEITH HAVILAND저] 연습문제 풀이입니다.


(저작권에 저촉 될 우려가 있어 문제 내용은 생략합니다.)


연습문제 3.3 입니다.

문자열로 입력받은 권한을 팔진수 값으로 바꾸기 위해 lsoct 함수를 정의했습니다.

반대로 팔진수 값으로 입력받은 권한을 문자열로 변환하기 위해 octls 함수를 정의했습니다.

변환하는 과정은 코드를 참고하면 쉽게 이해할 수 있을 것이라 생각합니다.


코드는 C++로 작성하였습니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
#include <stdio.h>
#include <string.h>
 
int lsoct(char* ls) {
    int oc[4= {0};    
    int check = 0;
    for(int i=0; i<=8; i++) {
        switch(ls[i]) {
            case 'r':
                check += 4;
                break;
            case 'w':
                check += 2;                
                break;
            case 'x':
                check += 1;                
                break;
            case '-':
                break;
            default:
                printf("signal error\n");
                return -1;            
        }
        
        if(i%3 == 2) {
            oc[i/3+1]=check;
            check = 0;
        }
    }
    printf("convert complete : %d%d%d%d\n", oc[0], oc[1], oc[2], oc[3]);
    return 0;
}
 
int octls(char* oc) {
    char ls[9= "";
    if(oc[0== '0') {
        for(int i=1; i<=3; i++) {
        switch(oc[i]) {
            case '0':
                strcat(ls,"---");
                break;
            case '1':
                strcat(ls,"--x");
                break;
            case '2':
                strcat(ls,"-w-");
                break;
            case '3':
                strcat(ls,"-wx");
                break;
            case '4':
                strcat(ls,"r--");
                break;
            case '5':
                strcat(ls,"r-x");
                break;
            case '6':
                strcat(ls,"rw-");
                break;
            case '7':
                strcat(ls,"rwx");
                break;
            default:
                printf("number error\n");
                return -1;            
        }
        }
    }
    else {
        printf("this number is not octal number\n");
        return -1;    
    }
    printf("convert complete : %s\n",ls);
    return 0;
}
 
int main(int argc, char* argv[]) {
    if(!strcmp(argv[1],"lsoct"))
        lsoct(argv[2]);
    else if(!strcmp(argv[1],"octls"))
        octls(argv[2]);
    else {
        printf("Don't find you want\n");
        return -1;    
    }
    return 0;
}
 
cs


[UNIX 시스템 프로그래밍 second Edition - KEITH HAVILAND저] 연습문제 풀이입니다.


(저작권에 저촉 될 우려가 있어 문제 내용은 생략합니다.)


연습문제 2.15 입니다.

먼저 받아오는 인수를 for문을 이용해서 처리합니다.

각각의 인수를 파일 이름으로 보고 open함수를 통해 파일을 open 합니다.

open한 파일은 read 함수로 읽어들이고 write함수로 출력하는 과정을 반복합니다.

만약, 받아오는 인수가 없다면 표준 입력으로 파일 이름을 받아와 출력합니다.


코드는 C++로 작성하였습니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
 
#define SIZE 512
 
int main(int argc, char* argv[]) {
    ssize_t nread;
    int fd;
    int i;
    char buf[SIZE];
    if(argc > 1) {
        for(i=1; i<argc; i++) {
            if ((fd = open(argv[i], O_RDWR)) == -1) {
                printf("file can not open TT \n");
                return (-1);
            }
            while((nread = read(fd, buf, SIZE)) > 0) {
                write(1,buf,nread);                        
            }
            close(fd);
        }    
    }
    else {
        nread = read(0, buf, SIZE);
        write(1, buf, nread);
    }
    
        exit(0);
}
 



[UNIX 시스템 프로그래밍 second Edition - KEITH HAVILAND저] 연습문제 풀이입니다.


(저작권에 저촉 될 우려가 있어 문제 내용은 생략합니다.)


연습문제 2.14입니다.

두 번째 인수에서 r, w, rw, a 문자(열)만 체크해서 그에 따른 적절한 처리를 해 주면 됩니다.

문자를 하나씩 받아오면 예외 처리 할 부분이 많아져 string으로 받아와 strcmp 함수를 통해 적절히 처리하였습니다.


코드는 C++로 작성하였습니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
 
int fileopen(char* filename, char* filetype) {
    int filedes;
    printf("%s\n",filetype);
    if(!strcmp(filetype,"r"))
        filedes = open(filename, O_RDONLY);
    else if(!strcmp(filetype,"rw"))
        filedes = open(filename, O_RDWR);
    else if(!strcmp(filetype,"w"))
        filedes = open(filename, O_WRONLY);
    else if(!strcmp(filetype,"a"))
        filedes = open(filename, O_WRONLY | O_APPEND);
    else {
        printf("cannot find filetype\n");
        filedes = -1;
        return (-1);
    }
    printf("ok\n");
    return filedes;
}
 
int main(int argc, char* argv[]) {
    int filedes = fileopen(argv[1], argv[2]);
    printf("file discripter is %d\n",filedes);
    return 0;
}



[UNIX 시스템 프로그래밍 second Edition - KEITH HAVILAND저] 연습문제 풀이입니다.


(저작권에 저촉 될 우려가 있어 문제 내용은 생략합니다.)


연습문제 2.7입니다.

파일 복사를 위해 한 파일을 모두 읽어들여 새로 만든 파일에 내용을 모두 덮어쓰는 방식으로 진행했습니다.

오류 처리 외에는 특별히 신경 쓸 부분이 없습니다.


코드는 C++로 작성하였습니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
#include <unistd.h>
#include <fcntl.h>
 
#define BUFSIZE 512
#define PERM 0644
 
int mycp (const char* name1, const char* name2) {
    int infile, outfile;
    ssize_t nread;
    char buffer[BUFSIZE];
    
    if((infile = open(name1, O_RDONLY)) == -1)
        return (-1);
 
    if((outfile = open(name2, O_WRONLY|O_CREAT|O_TRUNC, PERM)) == -1) {
        close(infile);
        return (-2);
    }
    
    while((nread = read(infile, buffer, BUFSIZE)) > 0) {
        if(write(outfile, buffer, nread) < BUFSIZE) {
            close(infile);
                close(outfile);
            return (-3);
        }
    }
    
    close(infile);
    close(outfile);
    
    if(nread == -1)
        return (-4);
    else
        return (0);
        return 0;
}
 
int main(int argc, char* argv[]) {
    mycp(argv[1],argv[2]);
    return 0;
}
 
cs