#include <stdio.h>
#include <signal.h>
#include <err.h>

static void sig_int(int);
static void pr_mask(const char *);

int main(void) {
    sigset_t newmask, oldmask, zeromask;

    if (signal(SIGINT, sig_int) == SIG_ERR) {
        perror("signal(SIGINT) error");
        return -1;
    }

    sigemptyset(&zeromask);
    sigemptyset(&newmask);
    sigaddset(&newmask, SIGINT);

    if (sigprocmask(SIG_BLOCK, &newmask, &oldmask) < 0) {
        perror("SIG_BLOCK error");
        return -1;
    }

    pr_mask("in crticial region:");

    if (sigsuspend(&zeromask) != -1) {
        perror ("siguspend error");
        return -1;
    }

    pr_mask("after : ");

    if (sigprocmask(SIG_SETMASK, &oldmask, NULL) < 0) {
        perror ("siguspend error");
        return -1;
    }

    return 0;
}

static void sig_int(int signo) {
    pr_mask("\n in sig_init: " );
    return;
}

static void pr_mask(const char *str) {
    sigset_t sigset;
    int errno_save;

    errno_save = errno;
    if (sigprocmask(0, NULL, &sigset) < 0) {
        perror("sigprocmask error");
        exit(1);
    }

    printf("%s", str);

    if (sigismember(&sigset, SIGINT)) {
        printf("SIGINT");
    }
    if (sigismember(&sigset, SIGQUIT)) {
        printf("SIGQUIT");
    }
    if (sigismember(&sigset, SIGUSR1)) {
        printf("SIGUSR1");
    }
    if (sigismember(&sigset, SIGALRM)) {
        printf("SIGALRM");
    }
   

    printf("\n");
    errno = errno_save;
}

#include <signal.h>
#include <unistd.h>

static void sig_alrm(int signo) {
    printf("sig_alrm!!\n");
    return;
}

unsigned int sleep1(unsigned int nsecs) {
    if (signal(SIGALRM, sig_alrm) == SIG_ERR) {
        return(nsecs);
    }

    alarm(nsecs);
    pause();
    return(alarm(0));
}

int main() {
    sleep1(10);
    return 0;
}

#include <setjmp.h>
#include <signal.h>
#include <unistd.h>

static jmp_buf env_alrm;

static void sig_alrm(int signo) {
    printf("longjmp before\n");
    longjmp(env_alrm, 1);
    printf("longjmp after\n");
}

unsigned int sleep2(unsigned int nsecs) {
    if (signal(SIGALRM, sig_alrm) == SIG_ERR) {
        return nsecs;
    }

    printf("0\n");
    if (setjmp(env_alrm) == 0) {
        printf("1\n");
        alarm(nsecs);
       
        printf("2\n");
        pause();
        printf("3\n");
    }

    printf("sleep2 end");
    return (alarm(0));
}

int main() {
    sleep2(5);
    return 1;
}

#include <stdio.h>
#include <signal.h>

static void sig_usr(int);

int main(void) {
    printf("1");
    if (signal(SIGUSR1, sig_usr) == SIG_ERR) {
        perror("can not catch SIGUSR1");
        return -1;
    }

    printf("2");
    if (signal(SIGUSR2, sig_usr) == SIG_ERR) {
        perror("can not catch SIGUSR1");
        return -1;
    }

    printf("3");
    if (signal(SIGINT, sig_usr) == SIG_ERR) {
        perror("can not catch SIGUSR1");
        return -1;
    }

    printf("4");
    for ( ; ; ) {
        pause();
    }

    return 1;
}

    static void sig_usr(int signo) {
        if (signo == SIGUSR1) {
            printf("received SIGUSR1\n");
        } else if (signo == SIGUSR2) {
            printf("received SIGUSR2\n");
        } else {
            fprintf(stderr, "received signal %d\n", signo);
        }
        return;

    }

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <fcntl.h>

int main(void) {
    int fd, val;
    pid_t pid;
    char buf[10];

    struct stat statbuf;
    struct flock lock;

    fd = open("lockfile", O_RDWR | O_CREAT | O_TRUNC, 0644);
    if (fd < 0) {
        perror("open error");
        return -1;
    }

    if (write(fd, "aaa", 3) != 3) {
        perror("write error");
        return -1;
    }

    if (fstat(fd, &statbuf) < 0) {
        perror("write error");
        return -1;
    }

    if (fchmod(fd, (statbuf.st_mode & ~S_IXGRP) | S_ISGID) < 0) {
        perror("write error");
        return -1;
    }

    if ((pid = fork()) < 0) {
        perror("write error");
        return -1;
    }
   
    if (pid > 0) {
        printf("parent 1\n");
        lock.l_type = F_WRLCK;
        lock.l_start = 0;
        lock.l_whence = SEEK_SET;
        lock.l_len = 0;

        if (fcntl(fd, F_SETLK, &lock) < 0) {
            perror("write error");
            return -1;
        }
        printf("parent 2\n");
        sleep(10);
        printf("parent 3\n");
        if (waitpid(pid, NULL, 0) < 0) {
            perror("write error");
            return -1;
        }
        printf("parent 4\n");
    } else {
    printf("child 1\n");
        sleep(10);
        printf("child 2\n");
        val = fcntl(fd, F_GETFL, 0);
        if (val < 0) {
            perror("write error");
            return -1;
        }

        val |= O_NONBLOCK;
        if (fcntl(fd, F_SETFL, &lock) < 0) {
            perror("fcntl error");
            return -1;
        }
        printf("child 3\n");
        lseek(fd, 0, SEEK_SET);
        if (read(fd, buf, 6) < 0) {
            perror("read error");
            return -1;
        }

        printf("child 4\n");
        printf ("read success!!");
    }


    return 1;
}

struct flock {
                    short l_type; /* F_RDLCK, F_WRLCK, or F_UNLCK */
                    off_t l_start; /* offset in bytes, relative to l_whence */
                    short l_whence; /* SEEK_SET, SEEK_CUR, or SEEK_END */
                    off_t l_len; /* length, in bytes; 0 means lock to EOF */
                    pid_t l_pid; /* returned with F_GETLK */
 };

#include <dirent.h>
#include <sys/types.h>
#include <stdio.h>
#include <string.h>

int main() {
    struct dirent *item;
    DIR *dp;

    dp = opendir("/");
    if (dp != NULL) {
        for ( ; ;) {
            item = readdir(dp);
            if (item == NULL) {
                break;
            }

            printf("DIR : %s \n", item->d_name);
        }
        closedir(dp);
    }
    return 1;
}

#include <stdio.h>
#include <string.h>
#include <limits.h>
#include <unistd.h>

int main(int argc, char **argv) {
    char buf[255];
    if (chdir(argv[1])) {
        perror("error");
        return -1;
    }

    char *cwd = getcwd(buf, PATH_MAX) ;
    if (cwd == NULL) {
        perror("error");
    } else {
        printf ("current working dir : %s\n", buf);
    }
    return 1;
}

#include <sys/types.h>
#include <sys/stat.h>

int main(void) {
    struct stat statbuf;

    if (stat("foo", &statbuf) < 0 ) {
        perror("stat error for foo");
        return -1;
    }

    int chmodValue = chmod("foo", (statbuf.st_mode & ~S_IXGRP) | S_ISGID);
    if (chmodValue < 0) {
        perror("chmod error for foo");
        return -1;
    }

    int chmod2Value = chmod("bar", S_IRUSR| S_IWUSR| S_IRGRP| S_IROTH);
    if (chmod2Value < 0) {
        perror("chmod error for foo");
        return -1;
    }

    return 0;
}

S_IRWXU

read, write, execute/search by owner

S_IRUSR

read permission, owner

S_IWUSR

write permission, owner

S_IXUSR

execute/search permission, owner

S_IRWXG

read, write, execute/search by group

S_IRGRP

read permission, group

S_IWGRP

write permission, group

S_IXGRP

execute/search permission, group

S_IRWXO

read, write, execute/search by others

S_IROTH

read permission, others

S_IWOTH

write permission, others

S_IXOTH

execute/search permission, others

S_ISUID

set-user-ID on execution

S_ISGID

set-group-ID on execution

S_ISVTX

on directories, restricted deletion flag

Unix Domain Socket(이하 UDS) 는 socket API를 수정없이 이용며, port 기반의 Inernet Domain Socket에 비해서 로컬 시스템의 파일시스템을 이용해서 내부프로세스간의 통신을 위해 사용한다는 점이 다르다고 할수 있다.

* 비교
- AF_INET : 유닉스 지역 네트워크와 인터넷자체에서 사용되는 인터넷 네트워크.
기반이 되는 프로토콜은 인터넷 프로토콜(IP)
- AR_UNIX : 네트워크를 통해 연결되지 않은 단일 컴퓨터 기반의 소켓에의해 사용.
유닉스 파일체계 도메인. 기반이 되는 프로토콜은 파일 입/출력

* 형태
①streams : 순차적이고 신뢰적인 양방향 바이트 스트림인 접속을 제공
전달되는 데이터가 상실되지 않도록 보장되고, 에러 발생시 복제되거
나 재요청. 예상 가능한 동작을 가짐.
AF_INET 도메인에서 TCP/IP 접속에 의해 구현, AF_UNIX 도메인에서 일반적
②datagrams : 전달할 수 있는 데이터 그램의 크기에는 제한이 있다.
이것은 상실되거나 복제되거나 순서를 벗어난 상태로 전달될 수 있는 단일 네트워크 메시지로 전송.
AF_INET도메인에서 UDP/IP접속에 의해 구현
장점은 리소스의 측면에서는 상대적으로 효율.

/usr/include/sys/un.h
     30 struct sockaddr_un
     31   {
     32     __SOCKADDR_COMMON (sun_);
     33     char sun_path[108];     /* Path name.  */
     34   };

 /usr/include/bits/sockaddr.h:
#define __SOCKADDR_COMMON(sa_prefix) \
  sa_family_t sa_prefix##family

sa_family_t 타입의 sun_family

struct sockaddr_un
{
sa_family_t sun_family;
char sun_path[];
}

* 프로그래밍 유의사항
1. 파일명은 같은 것으로
2. 통신 완료후 unlink(path이름) 하기

PF_LOCAL = PF_UNIX  = PF_FILE