공간사랑

socket pthread

공간사랑 — Sat, 23 Aug 2025 02:17:15 +0900

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/time.h>

#define PORT 9090
#define BUFFER_SIZE 1024

int server_fd, client_socket;
struct sockaddr_in address;
socklen_t addr_len = sizeof(address);

void timer_handler(int sig) {
    printf("Timer triggered!\n");
}

void* listen_thread(void* arg) {
    server_fd = socket(AF_INET, SOCK_STREAM, 0);
    int opt = 1;
    setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt));

    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(PORT);

    bind(server_fd, (struct sockaddr*)&address, sizeof(address));
    listen(server_fd, 3);

    printf("Listening on port %d...\n", PORT);
    client_socket = accept(server_fd, (struct sockaddr*)&address, &addr_len);
    printf("Client connected!\n");

    return NULL;
}

void* recv_thread(void* arg) {
    char buffer[BUFFER_SIZE];
    while (1) {
        memset(buffer, 0, BUFFER_SIZE);
        int valread = recv(client_socket, buffer, BUFFER_SIZE, 0);
        if (valread > 0) {
            printf("Received: %s\n", buffer);
        }
    }
    return NULL;
}

void* send_thread(void* arg) {
    char msg[BUFFER_SIZE];
    while (1) {
        printf("Enter message: ");
        fgets(msg, BUFFER_SIZE, stdin);
        send(client_socket, msg, strlen(msg), 0);
    }
    return NULL;
}

void start_timer() {
    struct itimerval timer;
    signal(SIGALRM, timer_handler);

    timer.it_value.tv_sec = 5;        // First trigger in 5 seconds
    timer.it_value.tv_usec = 0;
    timer.it_interval.tv_sec = 5;     // Then every 5 seconds
    timer.it_interval.tv_usec = 0;

    setitimer(ITIMER_REAL, &timer, NULL);
}

int main() {
    pthread_t listen_tid, send_tid, recv_tid;

    // Start listener
    pthread_create(&listen_tid, NULL, listen_thread, NULL);
    pthread_join(listen_tid, NULL); // Wait until a client connects

    // Start other threads
    pthread_create(&recv_tid, NULL, recv_thread, NULL);
    pthread_create(&send_tid, NULL, send_thread, NULL);

    // Start timer
    start_timer();

    pthread_join(recv_tid, NULL);
    pthread_join(send_tid, NULL);

    close(server_fd);
    return 0;
}

execve

공간사랑 — Sat, 23 Aug 2025 02:12:52 +0900

#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <errno.h>
#include <stdlib.h>

void func(char *input)
{
  pid_t pid;
  int status;
  pid_t ret;
  char *const args[3] = {"any_exe", input, NULL};
  char **env;
  extern char **environ;

  /* ... Sanitize arguments ... */

  pid = fork();
  if(pid == -1){
    /* Handle error */
  }
  else if(pid != 0){
    while ((ret = waitpid(pid, &status, 0)) == -1){
      if(errno != EINTR){
        /* Handle error */
        break;
      }
    }
    if((ret == 0) ||
        !(WIFEXITED(status) && !WEXITSTATUS(status))){
      /* Report unexpected child status */
    }
  }
  else {
    /* ... Initialize env as a sanitized copy of environ ... */
    if(execve("/usr/bin/any_cmd", args, env) == -1){
      /* Handle error */
      _Exit(127);
    }
  }
}

pre fork read_fd write_fd

공간사랑 — Sat, 23 Aug 2025 02:00:26 +0900

#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>

#define SA struct sockaddr

struct _SocketInfo
{
  int pid;
  int fd;
  int status;
};

int write_fd(int fd, void *ptr, size_t nbytes, int sendfd);
int prefork_client(int fd);
int read_fd(int fd);

int main_server(int server_sockfd,
                struct _SocketInfo *SInfo,
                struct sockaddr_in clientaddr,
                int preforknum);

int main(int argc, char **argv)
{
    char buf_in[80];
    int state;
    int clilen;
    int n,i,pid;
    int preforknum;
    int ppid;

    int sv[2];

    struct _SocketInfo *SocketArray;

    int server_sockfd, client_sockfd;
    struct sockaddr_in clientaddr, serveraddr;

    if (argc != 2)
    {
      fprintf(stderr, "Usage: %s [prefork#]\n", argv[0]);
      return 1;
    }
    preforknum = atoi(argv[1]);

    if ((server_sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
    {
        perror("Error");
        return 1;
    }
    bzero(&serveraddr, sizeof(serveraddr));

    serveraddr.sin_family = AF_INET;
    serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);
    serveraddr.sin_port = htons(8083);

    bind(server_sockfd, (SA *)&serveraddr, sizeof(serveraddr));
    if ((state = listen(server_sockfd, 5))<0)
    {
        perror("listen error: ");
        exit(0);
    }

    if(preforknum > 10)
    {
      fprintf(stderr,"Max preforknum is 10\n");
      exit(0);
    }
    ppid = getpid();

    // Socket Infomation Array
    SocketArray = (void *)malloc(sizeof(struct _SocketInfo)*preforknum);

    memset((void *)SocketArray, 0x00, sizeof(struct _SocketInfo)*preforknum);

    for (i = 0; i < preforknum; i++)
    {
      socketpair(AF_LOCAL, SOCK_STREAM, AF_LOCAL, sv);

      pid = fork();

      if (pid < 0)
      {
        perror("fork error");
        exit(0);
      }

      if (pid == 0)
      {
        dup2(sv[0], 0);
        close(sv[1]);
        close(sv[0]);
        close(server_sockfd);
        prefork_client(0);
      }
      else
      {
        close(sv[0]);
        SocketArray[i].pid    = pid;
        SocketArray[i].fd     = sv[1];
        SocketArray[i].status = 1;
      }
    }

    main_server(server_sockfd, SocketArray, clientaddr, preforknum);

}

int write_fd(int fd, void *ptr, size_t nbytes, int sendfd)
{
  struct msghdr msg;
  struct iovec iov[1];

  union {
    struct cmsghdr cm;
    char  control[CMSG_SPACE(sizeof(int))];
  } control_un;

  struct cmsghdr *cmptr;

  msg.msg_control = control_un.control;
  msg.msg_controllen = sizeof(control_un.control);

  cmptr = CMSG_FIRSTHDR(&msg);
  cmptr->cmsg_len = CMSG_LEN(sizeof(int));
  cmptr->cmsg_level = SOL_SOCKET;
  cmptr->cmsg_type = SCM_RIGHTS;

  *((int *) CMSG_DATA(cmptr)) = sendfd;

  msg.msg_name = NULL;
  msg.msg_namelen = 0;

  iov[0].iov_base = ptr;
  iov[0].iov_len = nbytes;

  msg.msg_iov = iov;
  msg.msg_iovlen = 1;

  return(sendmsg(fd, &msg, 0));

}

int read_fd(int fd)
{
  int n;
  int recvfd;
  char ptr;

  struct iovec iov[1];
  struct cmsghdr *cmptr;
  struct msghdr msg;

  union {
    struct cmsghdr cm;
    char control[CMSG_SPACE(sizeof(int))];
  } control_un;

  msg.msg_control = control_un.control;
  msg.msg_controllen = sizeof(control_un.control);

  msg.msg_name = NULL;
  msg.msg_namelen = 0;

  iov[0].iov_base = (void *)&ptr;
  iov[0].iov_len = 1;

  msg.msg_iov = iov;
  msg.msg_iovlen = 1;

  if ( (n = recvmsg(fd, &msg, 0)) <= 0)
  {
    perror("recvmsg Error");
    return -1;
  }

  cmptr = CMSG_FIRSTHDR(&msg);
  if ((cmptr == NULL))
  {
    perror("CMSG ERROR\n");
    return -1;
  }
  recvfd = *((int *) CMSG_DATA(cmptr));

  return recvfd;

}

int main_server(int server_sockfd,
      struct _SocketInfo *SocketArray,
      struct sockaddr_in clientaddr,
      int preforknum)
{
    int clilen;
    int client_sockfd;
    int i;
    char ptr;
    int n;
    int maxfd;
    fd_set readfds, allfds;
    int data;

    FD_ZERO(&readfds);
    FD_SET(server_sockfd, &readfds);

    for (i = 0; i < preforknum; i++)
    {
      FD_SET(SocketArray[i].fd, &readfds);
      maxfd = SocketArray[i].fd;
      printf("socketpair fd %d\n", maxfd);
    }

    printf("%d\n", maxfd+1);
    allfds = readfds;

    while(1)
    {
        readfds = allfds;
        clilen = sizeof(clientaddr);

        printf("select Wait\n");
        n = select(maxfd + 1, &readfds, (fd_set *)0, (fd_set *)0, NULL);
        printf("select Wait End %d\n", n);
        if (n < 0) continue;

        if (FD_ISSET(server_sockfd, &readfds))
        {
           printf("ACCEPT\n");
           if ((client_sockfd = accept(server_sockfd, (SA *)&clientaddr, (size_t *)&clilen)) ==-1)
           {
              perror("accept error:");
              close(client_sockfd);
           }
           else
           {
             for (i = 0; i < preforknum; i++)
             {
                if(SocketArray[i].status)
                {
                  printf("SocketSend pid(%d) -> %d\n", SocketArray[i].pid, client_sockfd);
                  write_fd(SocketArray[i].fd, &ptr, 1, client_sockfd);
                  SocketArray[i].status = 0;
                  close(client_sockfd);
                  break;
                }
              }
              if (i == preforknum)
              {
                fprintf(stderr, "max Client error\n");
                close(client_sockfd);
              }
           }
        }

        for (i = 0; i < preforknum; i++)
        {
          if(FD_ISSET(SocketArray[i].fd, &readfds))
          {
            printf("OK Chield Data\n");
            read(SocketArray[i].fd, (void *)&data, sizeof(data));
            printf("(%d) : Read Data %d\n", SocketArray[i].fd, data);
            if(data == 0)
            {
              SocketArray[i].status = 1;
            }
          }
        }
    }
}

int prefork_client(int fd)
{
  int n;
  char buf_in[80]={0x00,};
  int sockfd;
  int msg = 0;
  printf("Child PID %d\n", getpid());

  while(1)
  {
    sockfd = read_fd(fd);
    for(;;)
    {
      if ((n = read(sockfd, buf_in, 79)) > 0)
      {
        write(sockfd, buf_in, strlen(buf_in));
      }
      else
      {
        printf("Client Socket Close\n");
        write(fd, (void *)&msg, sizeof(msg));
        close(sockfd);
        break;
      }
      memset(buf_in, 0x00, sizeof(buf_in));
    }
  }
}

processes-example-creating-server-that-uses-spawn

공간사랑 — Sat, 23 Aug 2025 01:44:29 +0900

/*** https://www.ibm.com/docs/ko/i/7.3.0?topic=processes-example-creating-server-that-uses-spawn ***/

/**************************************************************************/
/* Application creates an child process using spawn().                    */
/**************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <spawn.h>

#define SERVER_PORT  12345

main (int argc, char *argv[])
{
   int    i, num, pid, rc, on = 1;
   int    listen_sd, accept_sd;
   int    spawn_fdmap[1];
   char  *spawn_argv[1];
   char  *spawn_envp[1];
   struct inheritance   inherit;
   struct sockaddr_in6   addr;

   /*************************************************/
   /* If an argument was specified, use it to       */
   /* control the number of incoming connections    */
   /*************************************************/
   if (argc >= 2)
      num = atoi(argv[1]);
   else
      num = 1;

   /*************************************************/
   /* Create an AF_INET6 stream socket to receive   */
   /* incoming connections on                       */
   /*************************************************/
   listen_sd = socket(AF_INET6, SOCK_STREAM, 0);
   if (listen_sd < 0)
   {
      perror("socket() failed");
      exit(-1);
   }

   /*************************************************/
   /* Allow socket descriptor to be reuseable       */
   /*************************************************/
   rc = setsockopt(listen_sd,
                   SOL_SOCKET,  SO_REUSEADDR,
                   (char *)&on, sizeof(on));
   if (rc < 0)
   {
      perror("setsockopt() failed");
      close(listen_sd);
      exit(-1);
   }

   /*************************************************/
   /* Bind the socket                               */
   /*************************************************/
   memset(&addr, 0, sizeof(addr));
   addr.sin6_family      = AF_INET6;
   addr.sin6_port        = htons(SERVER_PORT);
   memcpy(&addr.sin6_addr, &in6addr_any, sizeof(in6addr_any));
   rc = bind(listen_sd,
             (struct sockaddr *)&addr, sizeof(addr));
   if (rc < 0)
   {
      perror("bind() failed");
      close(listen_sd);
      exit(-1);
   }

   /*************************************************/
   /* Set the listen back log                       */
   /*************************************************/
   rc = listen(listen_sd, 5);
   if (rc < 0)
   {
      perror("listen() failed");
      close(listen_sd);
      exit(-1);
   }

   /*************************************************/
   /* Inform the user that the server is ready      */
   /*************************************************/
   printf("The server is ready\n");

   /*************************************************/
   /* Go through the loop once for each connection  */
   /*************************************************/
   for (i=0; i < num; i++)
   {
      /**********************************************/
      /* Wait for an incoming connection            */
      /**********************************************/
      printf("Interation: %d\n", i+1);
      printf("  waiting on accept()\n");
      accept_sd = accept(listen_sd, NULL, NULL);
      if (accept_sd < 0)
      {
         perror("accept() failed");
         close(listen_sd);
         exit(-1);
      }
      printf("  accept completed successfully\n");

      /**********************************************/
      /* Initialize the spawn parameters            */
      /*                                            */
      /* The socket descriptor for the new          */
      /* connection is mapped over to descriptor 0  */
      /* in the child program.                      */
      /**********************************************/
      memset(&inherit, 0, sizeof(inherit));
      spawn_argv[0]  = NULL;
      spawn_envp[0]  = NULL;
      spawn_fdmap[0] = accept_sd;

      /**********************************************/
      /* Create the worker job                      */
      /**********************************************/
      printf("  creating worker job\n");
      pid = spawn("/QSYS.LIB/QGPL.LIB/WRKR1.PGM",
                  1, spawn_fdmap, &inherit,
                  spawn_argv, spawn_envp);
      if (pid < 0)
      {
         perror("spawn() failed");
         close(listen_sd);
         close(accept_sd);
         exit(-1);
      }
      printf("  spawn completed successfully\n");

      /**********************************************/
      /* Close down the incoming connection since   */
      /* it has been given to a worker to handle    */
      /**********************************************/
      close(accept_sd);
   }

   /*************************************************/
   /* Close down the listen socket                  */
   /*************************************************/
   close(listen_sd);
}

daemonize

공간사랑 — Mon, 21 Jul 2025 07:51:42 +0900

void daemonize() {
    pid_t pid = fork();
    if (pid < 0) exit(EXIT_FAILURE);
    if (pid > 0) exit(EXIT_SUCCESS); // 부모 종료

    if (setsid() < 0) exit(EXIT_FAILURE);

    signal(SIGCHLD, SIG_IGN);
    signal(SIGHUP, SIG_IGN);

    pid = fork();
    if (pid < 0) exit(EXIT_FAILURE);
    if (pid > 0) exit(EXIT_SUCCESS); // 첫 번째 자식 종료

    umask(0);
    chdir("/");

    close(STDIN_FILENO);
    close(STDOUT_FILENO);
    close(STDERR_FILENO);
}

C언어 프로세서 kill 하기

공간사랑 — Sun, 2 Mar 2025 18:36:56 +0900

int fnKillProcByPid(pid_t pid)
{
    if( kill(pid, SIGTERM) < 0 ){

        if( kill(pid, SIGKILL) < 0 ){
            fprintf(stderr, "[fnKillProcByPid()] Can Not Kill Running Process Pid[%d] \n", (int)pid);
            return (-1);
        }

    }

    return 1;

}

C언어 리눅스 프로세서 이름을 이용하여 PID구하기

공간사랑 — Sun, 2 Mar 2025 18:21:16 +0900

리눅스 / proc/PID/ 파일을 이용하여 pid구하기

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <ctype.h>
#include <unistd.h>
#include <sys/errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/procfs.h>
#include <sys/signal.h>
#include <dirent.h>

#define DEF_PROC_DIR       "/proc"
#define DEF_PROC_NAME_LEN  128

pid_t fnGetPidByProcName(char *szInProcName)
{
    int    fd;
    int    pid;
    int    status;

    DIR    *dirp;

    struct dirent *direntp;

    char   *dname;

    char   fname[256];
    char   pname[256];

    struct stat st;

    if( (dirp = opendir(DEF_PROC_DIR)) == NULL ){
        fprintf(stderr,"[fnGetPidByProcName()] ERROR_FAIL opendir fail[%s] errno[%d][%s]\n", DEF_PROC_DIR, errno, strerror(errno));
        return (-1);
    }

    while( (direntp = readdir(dirp)) != NULL ){

        dname = direntp->d_name;

        if(!isdigit(*dname)) continue;

        pid = atoi(dname);

        memset(fname, 0x00, sizeof(fname));
        sprintf(fname, "/proc/%d/cmdline", pid);

        /* get the process owner */
        status = stat( fname, &st );

        if(status != 0) continue;

        if( st.st_uid != getuid() ){
            continue;
        }

        fd = open(fname, O_RDONLY);
        if( fd < 0 ){
            continue;
        }
        else{
            memset( pname, 0x00, sizeof(pname) );
            if( read(fd, pname, DEF_PROC_NAME_LEN-1) < 0 ){
                close(fd);
                continue;
            }
            else{
                close(fd);

                if( !strcasecmp(szInProcName, pname) ){
                    fprintf(stderr,"[fnGetPidByProcName()] szInProcName[%s] pname[%s] pid[%d]\n", szInProcName, pname, pid);
                    closedir( dirp );
                    return (pid);
                }
            }
        }
    }
    closedir( dirp );

    return (-1);

}

int fnGetPidExistCheck(int pid)
{
    DIR           *dirp;
    struct dirent *direntp;

    if( (dirp = opendir(DEF_PROC_DIR)) == NULL ){
        fprintf(stderr,"[fnGetPidExistCheck()] ERROR_FAIL opendir fail[%s] errno[%d][%s]\n", DEF_PROC_DIR, errno, strerror(errno));
        return 0;
    }

    while( (direntp = readdir(dirp)) != NULL ){
        if( pid == atoi(direntp->d_name) ){
            closedir(dirp);
            return (1);
        }
    }
    closedir(dirp);

    return (0);

}

http -> https 강제 전환 막기

공간사랑 — Sun, 16 Feb 2025 11:13:00 +0900

http -> https 강제 전환 막기

edge://net-internals/#hsts

chrome://net-internals/#hsts

edge://net-internals/#hsts

chrome://net-internals/#hsts

전자금융업 등록현황

공간사랑 — Sun, 15 Dec 2024 21:14:03 +0900

https://fine.fss.or.kr/fine/bbs/B0000392/list.do?menuNo=900495

파인(금융소비자정보포탈) -> 금융회사정보 -> 전자금융업 등록현황 조회

한강 공식 영문 표기 - Hangang River

공간사랑 — Thu, 12 Dec 2024 13:41:05 +0900

한강의 공식 영문 표기

Hangang River

아보하 소확행

공간사랑 — Wed, 20 Nov 2024 20:43:21 +0900

아보하
아주 보통의 하루

소확행
소소하지만 확실한 행복

YOLO YONO

공간사랑 — Sun, 10 Nov 2024 16:43:50 +0900

YOLO(Your Only Live Once)
한정된 인생을 살며 순간을 즐기자는 철학을 바탕으로 다양한 경험을 위해 소비의 경험을 중시하고 자신이 가치 있다고 여기는 것에 아낌없이 소비하는 것

YONO(You Only Need One)
네가 필요한 건 이거 하나뿐이야
불필요한 소비를 줄이고 꼭 필요한 것에만 집중하는 사람들을 말하며 최소한의 소비를 통해 삶의 질을 높이는 라이프스타일을 추구하며 불필요한 물건을 줄이고 실용성을 중시

VOC

공간사랑 — Wed, 23 Oct 2024 22:28:10 +0900

VOC(Voice Of Customer, 고객 의견)

아보하

공간사랑 — Thu, 26 Sep 2024 06:44:27 +0900

아보하

아주 보통의 하루가 가지는 힘을 의미하며 무탈하고 특별할 것 없이 평온한 하루를 통해 자신에게 집중하는 태도를 갖는 것이다.

옴니보어(Omnivores)

공간사랑 — Thu, 26 Sep 2024 06:42:34 +0900

옴니보어(Omnivores)
여러 분야에 관심을 두는 ‘잡식성 소비자’를 의미한다. 나이와 성별, 소득 등의 경계가 사라지고 개인의 취향이 또렷해진 것인데, 집단보다는 개인 취미에 방점을 두고 다양성을 추구하는 사람을 일컫는다.

openssl sha256 example source code

공간사랑 — Wed, 18 Sep 2024 23:29:45 +0900

#include <stdio.h>
#include <openssl/sha.h>
#include <string.h>

int main()
{

    // The input message
    const char *message = "Hello, OpenSSL SHA-256!";

    // Buffer to hold the SHA256 digest
    unsigned char hash[SHA256_DIGEST_LENGTH];

    // Compute the SHA-256 hash
    SHA256_CTX sha256;
    SHA256_Init(&sha256);
    SHA256_Update(&sha256, message, strlen(message));
    SHA256_Final(hash, &sha256);

    // Print the hash as hexadecimal
    printf("SHA-256 hash: ");
    for (int i = 0; i < SHA256_DIGEST_LENGTH; i++) {
        printf("%02x", hash[i]);
    }
    printf("\n");

    return 0;
}

컴파일

gcc -o sha256_example sha256_example.c -lssl -lcrypto

개인정보처리방침

공간사랑 — Sun, 25 Aug 2024 18:59:44 +0900

UPLE 은 개인정보를 보관 저장하지 않습니다.

아이폰 기기보증확인하기

공간사랑 — Thu, 28 Mar 2024 21:41:59 +0900

아이폰 기기보증확인하기

https://checkcoverage.apple.com/?locale=ko_KR

nonblock / no_nonblock

공간사랑 — Sat, 26 Aug 2023 20:09:34 +0900

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>

#include <fcntl.h>

bool nonblock(int fd)
{
    int fdflags;

    fdflags = fcntl(fd, F_GETFL);
    if (fdflags < 0) {
        fprintf(stderr, "%d: fcntl(F_GETFL): %s\n", fd, strerror(errno));
        exit(1);
    }
    if (fcntl(fd, F_SETFL, fdflags | O_NONBLOCK) < 0) {
        fprintf(stderr, "%d: fcntl(F_SETFL): %s\n", fd, strerror(errno));
        exit(1);
    }

    return fdflags & O_NONBLOCK;
}

bool no_nonblock(int fd)
{
    int fdflags;

    fdflags = fcntl(fd, F_GETFL);
    if (fdflags < 0) {
        fprintf(stderr, "%d: fcntl(F_GETFL): %s\n", fd, strerror(errno));
        exit(1);
    }
    if (fcntl(fd, F_SETFL, fdflags & ~O_NONBLOCK) < 0) {
        fprintf(stderr, "%d: fcntl(F_SETFL): %s\n", fd, strerror(errno));
        exit(1);
    }

    return fdflags & O_NONBLOCK;
}

윈도우10 시리얼넘버 제품키 확인

공간사랑 — Mon, 17 Jul 2023 21:42:15 +0900

윈도우10 시리얼넘버 제품키 확인

reg query “HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\SoftwareProtectionPlatform” /v BackupProductKeyDefault

Microsoft Windows [Version 10.0.19045.3208]
(c) Microsoft Corporation. All rights reserved.

C:\WINDOWS\system32>reg query "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\SoftwareProtectionPlatform" /v BackupProductKeyDefault

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\SoftwareProtectionPlatform
BackupProductKeyDefault REG_SZ QJNXR-****-****-****-6MT6Y

C:\WINDOWS\system32>

영어회화 패턴 50가지

공간사랑 — Sat, 8 Jul 2023 23:15:22 +0900

영어회화 패턴 50가지

　
1. I think... 나는 ... 같은데

I think you're right. 난 네 말이 맞는 것 같아.
I think we're lost. 난 우리가 길을 잃어버린것 같아.
I think this is it. 난 이것이 그것 같은데.
I think this is yours. 난 이것이 네 것 같은데.
I think this is enough. 난 이거면 충분한 것 같아.
I think that is better. 난 저것이 더 나은 것 같아.
I think it's two hours long. 난 2시간 정도 되는 것 같은데.

　
2. I mean... 내 말은...

I mean I love you. 내 말은 당신을 사랑한다는거야.
I mean I hate you. 내 말은 네가 싫다는거야.
I mean I'll do it for you. 내 말은 너를 위해 하겠다는거야.
I mean I don't want any. 내 말은 아무것도 필요없다는거야.
I mean I don't know how. 내 말은 어떻게 해야 할지 모르겠다는거야.
I mean we should help. 내 말은 우리가 도와줘야 한다는거야.
I mean to clean up first. 내 말은 청소를 먼저 하라는거야.

　
3. I like... 나는 ... 좋아해

I like you. 난 널 좋아해.
I like this. 난 이게 맘에 들어.
I like to swim. 난 수영하는 게 좋아.
I like my job. 난 내 일이 좋아.
I like reading. 난 책 읽는 걸 좋아해.
I like the movies. 난 영화를 좋아해.
I like your shoes. 난 네 신발이 맘에 들어.

　
4. Do you... ...하니?

Do you live here? 여기 살아?
Do you like this? 이게 맘에 들어?
Do you have a car? 너 차 있어?
Do you have enough? 충분히 있니?
Do you want more? 좀 더 줄까?
Do you want to go out? 밖에 나갈까?
Do you come here often? 여기에 자주 오니?

　
5. Are you...? ...하니?

Are you okay? 괜찮아?
Are you done? 다 끝냈어?
Are you alone? 혼자세요?
Are you happy? 행복하니?
Are you leaving? 지금 가는거야?
Are you working today? 오늘 일하니?
Are you going shopping? 쇼핑 가는거야?

　
6. Can I...? 내가 ...해도 돼요?

Can I drive? 내가 운전해도 돼?
Can I help you? 도와줄까?
Can I see that? 저것 봐도 돼?
Can I call you? 내가 전화해도 돼?
Can I keep this? 이거 내가 가져도 돼?
Can I go with you? 너랑 같이 가도 돼?
Can I have some more? 좀더 먹어도 돼?

　
7. Could you...? 내가 ...해도 돼요?

Could you help me? 날 좀 도와줄래요?
Could you turn off the TV? TV 좀 꺼줄래요?
Could you pass the salt? 소금을 건네주시겠어요?
Could you hold this a minute? 이거 잠깐만 들어줄래요?
Could you check this for me? 이것 좀 체크해 주시겠어요?
Could you give me some more? 조금만 더 주시겠어요?
Could you take out the trash? 쓰레기 좀 밖에 내다 놓을래요?

　
8. Let's... ...하자

Let's go. 가자.
Let's eat. 먹자.
Let's go to bed. 자자.
Let's grab a beer. 맥주 한 잔 하자.
Let's go for a drive. 드라이브나 가자.
Let's take a break. 좀 쉬자.
Let's finish this later. 이거 나중에 끝내자.

　
9. I feel... ...한 것 같아

I feel sad. 슬퍼.
I feel cold. 추워.
I feel tired. 피곤해.
I feel thirsty. 목말라.
I feel sick. 아픈거 같아.
I feel hungry. 배고파.
I feel good. 느낌이 좋아.

　
10. I need to... 나는 ...해야 해

I need to get a job. 난 일자리가 필요해.
I need to get new shoes. 새 신발을 사야겠군.
I need to go shopping. 쇼핑하러 가야겠어.
I need to buy some milk. 우유를 사야겠어.
I need to study tonight. 오늘 밤에는 공부해야 돼.
I need to use the restroom. 화장실을 써야겠어.
I need to call my parents. 부모님께 전화를 해야 돼.

　
11. Can I have...? 나 ...해도 돼?

Can I have this? 나 이거 가져도 돼?
Can I have a pet? 나 애완동물 가져도 돼?
Can I have a cookie? 나 쿠키 먹어도 돼?
Can I have some time off? 좀 쉴 수가 있을까요?
Can I have some more time? 시간을 좀 더 가져도 될까?
Can I have another beer? 맥주 한 병 더 마셔도 돼?
Can I have another chance? 다른 기회를 갖을 수 있을까?

　
12. I'm sure... 나는 ...라고 확신해

I'm sure she'll come. 그녀는 꼭 올거야.
I'm sure she'll call soon. 그녀가 곧 전화활거야.
I'm sure she'll be surprised. 그녀가 깜짝 놀랄거야.
I'm sure he'll like it. 그는 이걸 좋아할거야.
I'm sure this is enough. 이거면 충분해.
I'm sure excited about it. 기분이 정말 짱이야.
I'm sure glad you came. 네가 와서 정말 기뻐.

　
13. I'm sorry... ...해서 미안해

I'm sorry I'm late. 늦어서 미안해.
I'm sorry I broke it. 부러뜨려서 미안해.
I'm sorry I lost the keys. 열쇠를 잃어버려서 미안해.
I'm sorry I forgot to call. 전화하는거 잊어버려서 미안해.
I'm sorry you couldn't come. 네가 못 온다니 유감이야.
I'm sorry you didn't get any. 네가 아무 것도 갖지 못해서 미안해.
I'm sorry It's not the color you wanted. 네가 원하는 색깔이 아니어서 미안해.

　
14. I have to... 난 ...을 해야해

I have to study. 난 공부를 해야 해.
I have to go to work. 난 일하러 가야 해.
I have to go home now. 난 지금 집에 가야 해.
I have to write a paper. 난 보고서를 써야 해.
I have to do my makeup. 난 화장을 해야 해.
I have to brush my teeth. 난 이를 닦아야 해.
I have to call my mom. 난 엄마한테 전화를 해야 해.

　
15. How about... ...는 어때?

How about you? 넌 어때?
How about him? 그 사람 어때?
How about later? 다음에 어때?
How about one more? 하나 더 어때?
How about a bigger one? 좀 큰 게 어때?
How about Chinese food? 중국 음식은 어때?
How about watching a movie? 영화 보는거 어때?

　
16. Do you want to...? ...할래?

Do you want to drive? 운전할래?
Do you want to go home now? 지금 집에 갈래?
Do you want to go to the mall? 쇼핑몰에 갈래?
Do you want to watch a movie? 영화 볼래?
Do you want to have a beer? 맥주 할래?
Do you want to have a cup of coffee? 커피 한 잔 할래?
Do you want to have dinner with me? 나랑 저녁 먹을래?

　
17. Do you think...? 넌 ...라고 생각하니?

Do you think she's nice? 그 여자가 멋있다고 생각하니?
Do you think this is right? 이렇게 하는 게 맞다고 생각해?
Do you think this'll work? 이것이 효과가 있다고 생각하니?
Do you think this tastes okay? 이 맛이 괜찮다고 생각해?
Do you think I should do this? 내가 이걸 해야 한다고 생각해?
Do you think we're too early? 우리가 너무 빠르다고 생각하니?
Do you think we have enough? 우리가 충분히 갖고 있다고 생각하니?

　
18. How do you...? 넌 ...라고 생각하니?

How do you feel? 느낌이 어때?
How do you do that? 그거 어떻게 해?
How do you make it? 이거 어떻게 만들었어?
How do you know him? 그 사람을 어떻게 알아?
How do you like this? 어떻게 이걸 좋아해?
How do you like my new dress? 내 새 드레스 어때?
How do you want your eggs? 계란을 어떻게 해서 먹을래?

　
19. I don't want to... 나는 ...하고 싶지 않아

I don't want to drive. 운전하고 싶지 않아.
I don't want to get up. 일어나고 싶지 않아.
I don't want to go to bed. 자고 싶지 않아.
I don't want to go to school. 학교 가고 싶지 않아.
I don't want to work today. 오늘 일하고 싶지 않아.
I don't want to talk to him. 그 남자와 말하고 싶지 않아.
I don't want to be seen like this. 난 이렇게 보이기 싫어.

　
20. Would you like to...? ...하고 싶으세요?

Would you like to do this? 이것을 하고 싶으세요?
Would you like to keep it? 이것을 갖고 싶으세요?
Would you like to have one? 하나 갖고 싶으세요?
Would you like to take a break? 좀 쉬고 싶으세요?
Would you like to try again? 다시 한 번 해보고 싶으세요?
Would you like to go home? 집에 가시고 싶으세요?
Would you like to go to the mall? 쇼핑몰에 가고 싶으세요?

　
21. Have you...? ...한 적 있어?

Have you found it yet? 그거 아직 못 찾았나?
Have you seen my keys? 내 열쇠 본 적 있나?
Have you seen this movie? 이 영화 본 적 있어?
Have you been here before? 여기 와 본 적 있니?
Have you been waiting long? 오래 기다려본 적 있어?
Have you ever done this before? 이거 전에 해본 적 있어?
Have you ever met her before? 그 여자를 전에 만난 적 있니?

　
22. I'm going to... 나는 ... 하려고 해

I'm going to work? 일하러 갈거야.
I'm going to buy it. 그것을 살거야.
I'm going to leave now. 지금 떠날거야.
I'm going to finish this. 이것을 끝낼거야.
I'm going to call him. 그 남자한테 전화할거야.
I'm going to go upstairs. 위층에 올라갈거야.
I'm going to bake a cake. 케이크를 만들거야.

　
23. Don't forget to... ... 하는거 잊지마

Don't forget to study. 공부하는거 잊지 마.
Don't forget to call me. 나한테 전화하는거 잊지 마.
Don't forget to write me. 나한테 편지 쓰는거 잊지 마.
Don't forget to bring the beer. 맥주 갖고 오는거 잊지 마.
Don't forget to invite your brother. 네 남동생 초대하는거 잊지마.
Don't forget to take out the garabage. 쓰레기 버리는거 잊지 마.
Don't forget to thank your sister for me. 네 여동생에게 고맙다는 말 잊지 마.

　
24. Are you going to...? 너 ...할거니?

Are you going to study? 공부할거니?
Are you going to buy it? 그거 살거니?
Are you going to leave soon? 금방 떠날거니?
Are you going to call her? 그녀한테 전화할거야?
Are you going to watch the game? 게임 볼거니?
Are you going to see him again? 그 남자를 다시 볼거니?
Are you going to be home tonight? 오늘 밤에 집에 있을거니?

　
25. Where do you...? 너 어디에 ...?

Where do you live? 너 어디에 살아?
Where do you work? 너 어디서 일해?
Where do you put this? 이거 어디에 놓을거니?
Where do you want to go? 너 어디게 가고 싶니?
Where do you go to school? 어디에서 학교 다니니?
Where do you buy your shoes? 네 신발 어디에서 샀니?
Where do you come from? 너 어디에서 왔니?

　
26. Thank you for... ...해줘서 고마워

Thank you for coming. 와줘서 고마워.
Thank you for calling. 전화해줘서 고마워.
Thank you for all your help. 도와줘서 고마워.
Thank you for cleaning up. 청소해줘서 고마워.
Thank you for reminding me. 알려줘서 고마워.
Thank you for making dinner. 저녁을 해줘서 고마워.
Thank you for driving me home. 집까지 태워줘서 고마워.

　
27. Who likes...? 누가 ...를 좋아하지?

Who likes this? 누가 이거 좋아하지?
Who likes her? 누가 그녀를 좋아하지?
Who likes spaghetti? 누가 스파게티를 좋아하지?
Who likes this movie? 누가 이 영화 좋아하지?
Who likes to swim? 누가 수영을 좋아하지?
Who likes to work? 누가 일하는거 좋아하지?
Who likes to get up early? 누가 아침 일찍 일어나는거 좋아하지?

　
28. used to... 나는 ...하곤 했어

I used to eat out. 외식을 많이 했었어.
I used to like him. 그 남자를 좋아했었어.
I used to like working. 일을 좋아했었어.
I used to hate math. 수학을 싫어했었어.
I used to drink a lot. 술을 많이 마셨었어.
I used to drink coffee. 커피를 마셨었어.
I used to travel a lot. 여행을 많이 다녔었어.

　
29. Who's going to...? 누가 ...할래?

Who's going to drive? 누가 운전할거니?
Who's going to fix this? 누가 이것을 고칠거니?
Who's going to the store? 누가 가게에 갈래?
Who's going to tell him? 누가 그에게 말을거니?
Who's going to buy the ticket? 누가 표를 사러 갈래?
Who's going to watch the baby? 누가 아이를 볼거니?
Who's going to wash the dishes? 누가 설거지할거니?

　
30. It looks like... ...한 것 같아

It looks like I'm wrong. 내가 틀린 것 같아.
It looks like you're right. 네가 맞는 것 같아.
It looks like we might win. 우리가 이길 것 같아.
It looks like Jack's coming. Jack이 온 것 같아.
It looks like it might rain. 비가 올 것 같아.
It looks like I'm going to be late. 내가 좀 늦을 것 같아.
It looks like we're ready to leave. 우리는 떠날 준비가 된 것 같아.

　
31. Why don't you...? ...하는 게 어때?

Why don't you like me? 날 좋아하는게 어때?
Why don't you take a break? 좀 쉬는 게 어때?
Why don't you take the bus? 버스를 타는 게 어때?
Why don't you leave me alone? 날 가만히 놔두는 게 어때?
Why don't you ask for directions. 방향을 물어볼는 게 어때?
Why don't you ask your mother? 네 엄마한테 물어보는 게 어때?
Why don't you find someone else? 다른 사람을 찾아보는 게 어때?

　
32. I'm trying to... ...하려고 노력 중이야

I'm trying to work. 일하려고 노력 중이야.
I'm trying to study. 공부하려고 노력 중이야.
I'm trying to find my keys. 내 열쇠를 찾는 중이야.
I'm trying to make a cake. 케이크를 만들려는 중이야.
I'm trying to finish this. 이걸 끝내려고 노력 중이야.
I'm trying to finish it on time. 이걸 시간에 맞춰 끝내려는 중이야.
I'm trying to remember her name. 그녀의 이름을 기억해내려는 중이야.

　
33. I told you to... 내가 너한테 ...려고 했잖아

I told you to go away. 내가 저리 가라고 했잖아.
I told you to be careful. 내가 조심하라고 했잖아.
I told you to leave me alone. 날 혼자 내버려두라고 했잖아.
I told you to stop smoking. 내가 담배 끊으라고 했잖아.
I told you to stop calling me. 나한테 전화하지 말라고 했잖아.
I told you to help your mom. 네 엄마를 도와드리라고 했잖아.
I told you to ask someone else. 내가 다른 사람에게 물어보라고 했잖아.

　
34. You don't have to... 네가 ...하지 않아도 돼

You don't have to leave. 떠나지 않아도 돼.
You don't have to stay. 더 있지 않아도 돼.
You don't have to eat it. 그거 먹지 않아도 돼.
You don't have to do anything. 아무 것도 하지 않아도 돼.
You don't have to say anything. 아무 말도 하지 않아도 돼.
You don't have to bring anything. 아무 것도 안 가져와도 돼.
You don't have to come with me. 나랑 같이 안 가도 돼.

　
35. It's time to... ...할 시간이야

It's time to leave. 가야 할 시간이야.
It's time to go home. 집에 갈 시간이야.
It's time to go to school. 학교 갈 시간이야.
It's time to have lunch. 점심 먹을 시간이야.
It's time to say goodbye. 헤어질 시간이야.
It's time to take a break. 휴식 시간이야.
It's time to brush your teeth. 이 닦을 시간이야.

　
36. What if...? ...하면 어떡하지?

What if I'm late? 늦으면 어떡하지?
What if I lose it? 그걸 잃어버리면 어떡하지?
What if I can't do it? 내가 이걸 못 하면 어떡하지?
What if it snows? 눈이 오면 어떡하지?
What if no one comes? 아무도 안 오면 어떡하지?
What if he says 'No'? 그 사람이 싫다고 하면 어떡하지?
What if he's not there? 그가 거기에 없으면 어떡하지?

　
37. When do you plan to...? 언제 ...할 계획이야?

When do you plan to leave? 언제 떠날거니?
When do you plan to study? 언제 공부할거니?
When do you plan to go home? 언제 집에 갈거니?
When do you plan to graduate? 언제 졸업할거니?
When do you plan to finish this? 이것을 언제 끝낼 계획이니?
When do you plan to have some fun? 언제 좀 놀거니?
When do you plan to take a vacation? 언제 휴가를 갈 계획이니?

　
38. I just wanted to... 난 단지 ...하고 싶었어

I just wanted to be alone. 난 단지 혼자 있고 싶었어.
I just wanted to go home. 난 단지 집에 가고 싶었어.
I just wanted to get my coat. 난 단지 내 코트를 가지러 갔어.
I just wanted to see you again. 난 단지 널 다시 보고 싶었어.
I just wanted to know the truth. 난 단지 진실을 알고 싶었어.
I just wanted to hear you say it. 난 단지 네게 그것을 듣고 싶었어.
I just wanted to find my cell phone. 난 단지 내 휴대폰을 찾고 싶었어.

　
39. I'm thinking... 난 ...할까 생각 중이야

I'm thinking about moving. 난 이사를 할까 생각 중이야.
I'm thinking we're finished. 난 우리가 끝났다고 생각 중이야.
I'm thinking of going to bed. 난 잠자리에 들까 생각 중이야.
I'm thinking of riding the bus. 난 버스를 탈까 생각 중이야.
I'm thinking I'll skip the class. 난 수업을 땡땡이 칠까 생각 중이야.
I'm thinking about getting a job. 난 일자리를 얻을까 생각 중이야.
I'm thinking you should go first. 난 네가 먼저 가야 한다고 생각 중이야.

　
40. Do you want me to...? 넌 내가 ...하기를 원해?

Do you want me to drive? 내가 운전할까?
Do you want me to fix that? 저것을 고쳐줄까?
Do you want me to call you? 내가 전화할까?
Do you want me to meet you? 한번 만날까?
Do you want me to help you? 내가 도와줄까?
Do you want me to get some more? 내가 좀더 갖다줄까?
Do you want me to wash the dishes? 내가 설거지 해줄까?

　
41. I should have... 내가 ...했어야 했는데

I should have worn a coat. 코트를 입었어야 했는데.
I should have come sooner. 내가 곧 왔었어야 했는데.
I should have reminded him. 내가 그에게 알려줬어야 했는데.
I should have told the truth. 진실을 말했어야 했는데.
I should have called you. 내가 너에게 전화 했었어야 했는데.
I should have studied hard. 공부를 열심히 했어야 했는데.
I should have listened to her. 그녀의 말을 들었어야 했는데.

　
42. Is there anyone who...? 혹시 ...할 사람 있어요?

Is there anyone who can cook? 요리할 수 있는 사람 있나요?
Is there anyone who can fix it? 혹시 이것을 고칠 사람이 있나요?
Is there anyone who can help me? 저를 도와줄 사람 있나요?
Is there anyone who can speaks English? 영어를 할 줄 아는 사람 있나요?
Is there anyone who knows Peter? 혹시 Peter를 아는 사람 있나요?
Is there anyone who knows how to do this? 이거 어떻게 하는지 아는 사람 있나요?
Is there anyone who knows about computers? 컴퓨터에 대해 아는 사람 있나요?

　
43. Have you ever... ...한 적 있어?

Have you ever seen a whale? 고래 본 적 있어?
Have you ever played pool? 포켓볼 쳐본 적 있어?
Have you ever eaten sushi? 초밥 먹어본 적 있어?
Have you ever been to a zoo? 동물원 가본 적 있어?
Have you ever cooked before? 요리해본 적 있어?
Have you ever driven a car before? 운전해본 적 있어?
Have you ever traveled overseas? 해외여행 해본 적 있어?

　
44. I was wondering if... ...할지 궁금했어

I was wondering if you'd call. 네가 전화올지 궁금했어.
I was wondering if you'd like it. 네가 좋아할지 걱정했어.
I was wondering if you'd help me. 네가 도와줄지 걱정했어.
I was wondering if you'd go out with me. 나랑 데이트할지 걱정했어.
I was wondering if you'd remember. 네가 기억하고 있을지 궁금했어.
I was wondering if he'd be here. 그가 여기에 올지 궁금했어.
I was wondering if I could take a break. 쉴 수가 있을지 궁금했어.

　
45. Is it possible that...? ...하는 게 가능해?

Is it possible that he's married? 그 남자가 결혼했다는 게 가능해?
Is it possible that I got fired? 내가 해고됐다는 게 가능해?
Is it possible that it was canceled? 그게 취소되었다는 게 가능해?
Is it possible that the battery's dead? 배터리가 나갔다는 게 가능해?
Is it possible that we'd get caught? 우리가 잡혔다는 게 가능해?
Is it possible that they've forgotten? 그 사람들이 잊어버렸다는 게 가능해?
Is it possible that we've the wrong address? 우리가 틀린 주소를 갖고 있다는 게 가능해?

　
46. Is it okay if...? ...해도 괜찮겠어요?

Is it okay if I'm late? 제가 늦어도 괜찮겠어요?
Is it okay if I go first? 제가 먼저 가도 괜찮겠어요?
Is it okay if I go home early? 제가 일찍 가도 괜찮겠어요?
Is it okay if I make a call first? 제가 전화를 먼저 해도 될까요?
Is it okay if I have one more? 제가 하나 더 가져도 괜찮겠어요?
Is it okay if we leave now? 우리가 지금 떠나도 괜찮겠어요?
Is it okay if we do this later? 우리가 이걸 나중에 해도 괜찮겠어요?

　
47. Would you mind if...? ...해도 될까요?

Would you mind if we leave? 우리가 떠나도 될까요?
Would you mind if we didn't go? 우리가 안 가도 될까요?
Would you mind if we go tomorrow? 우리 내일 가도 될까요?
Would you mind if I drive? 내가 운전해도 될까요?
Would you mind if I left early? 내가 일찍 떠나도 될까요?
Would you mind if I'm a little late? 내가 좀 늦어도 될까요?
Would you mind if I listened to some music? 내가 음악을 좀 들어도 될까요?

　
48. How come...? 어떻게 ...할 수 있지?

How come it's so hard? 왜 이게 이렇게 힘들지?
How come I always get sick? 왜 난 항상 아플까?
How come I have to do it? 어째서 내가 이것을 해야 하지?
How come I failed the exam? 왜 내가 시험에서 떨어졌지?
How come we have to go? 어째서 우리가 가야 하지?
How come you're always late? 왜 넌 항상 늦니?
How come you never listen to me? 왜 넌 항상 내 말을 안 듣지?

　
49. What makes you...? 너는 왜 ... ?

What makes you laugh? 너는 왜 웃는거니?
What makes you happy? 너는 왜 행복하니?
What makes you crying? 너는 왜 우는거니?
What makes you live here? 너는 왜 여기에 사니?
What makes you feel that way? 너는 왜 그렇게 느끼니?
What makes you think that? 너는 왜 그렇게 생각하니?
What makes you so sure? 너는 왜 그렇게 확신하니?

　
50. I can't believe... 난 ...를 믿을 수 없어

I can't believe it. 난 그것을 믿을 수 없어.
I can't believe it's free. 난 그것이 공짜라는 게 믿을 수 없어.
I can't believe he's alive. 난 그가 살아있는 것을 믿을 수 없어.
I can't believe he got married. 난 그가 결혼했다는 걸 믿을 없어.
I can't believe we're here. 난 우리가 여기 있다는 게 믿을 수 없어.
I can't believe they did that. 난 그들이 그렇게 했다는 걸 믿을 수 없어.
I can't believe she said that. 난 그녀가 그렇게 말했다는 걸 믿을 수 없어.

posix_spawn

공간사랑 — Tue, 4 Jul 2023 20:52:31 +0900

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#include <unistd.h>
#include <spawn.h>
#include <sys/wait.h>

extern char **environ;

void run_cmd(char *cmd)
{
status = posix_spawn(&pid, "/bin/sh", NULL, NULL, argv, environ);

if(status == 0){
printf("Child pid: %i\n", pid);

if(waitpid(pid, &status, 0) != -1){
printf("Child exited with status %i\n", status);
}
else{
do{
if(waitpid(pid, &status, 0) != -1){
printf("Child status %d\n", WEXITSTATUS(status));
}
else{
perror("waitpid");
}
exit(1);
}
}
while(!WIFEXITED(status) && !WIFSIGNALED(status));
}
else{
printf("posix_spawn: %s\n", strerror(status));
}
}

void main(int argc, char* argv[])
{
run_cmd(argv[1]);
return;
}

posix_spawn_test.c

0.00MB

AI 검색

공간사랑 — Thu, 29 Jun 2023 00:00:49 +0900

Bard

https://bard.google.com/

‎Google의 AI 실험 버전인 Bard 사용해 보기

Bard는 창의적이고 유용한 파트너로서, 상상력을 마음껏 발휘하고 생산성을 높이며 아이디어를 실현하도록 도와줍니다.

bard.google.com

ChatGPT

https://chat.openai.com/

C 언어에서 CRC16을 구현하는 방법

공간사랑 — Wed, 28 Jun 2023 23:15:43 +0900

C 언어에서 CRC16을 구현하는 방법

#include <stdio.h>
#include <stdlib.h>

// CRC-16 다항식
const int CRC16_POLYNOMIAL = 0x8005;

// CRC16 계산
int crc16(const unsigned char *data, int len) {
  int crc = 0;
  for (int i = 0; i < len; i++) {
    crc = (crc << 8) ^ data[i];
    for (int j = 0; j < 8; j++) {
      if (crc & 0x8000) {
        crc = crc ^ CRC16_POLYNOMIAL;
      }
      crc <<= 1;
    }
  }
  return crc;
}

int main(void) {
  unsigned char data[] = {0x01, 0x02, 0x03, 0x04, 0x05};
  int len = sizeof(data) / sizeof(data[0]);
  int crc = crc16(data, len);
  printf("CRC-16: %x\n", crc);

  return 0;
}

이 코드는 "0x0102030405"라는 데이터의 CRC-16을 계산하고, 그 결과는 "0x29b1"입니다.

===============================

URL: https://devcoons.com/crc16-simple-algorithm-c/

crc.h 파일

/* CRC_H_ */

#ifndef CRC_H_
#define CRC_H_

#ifdef __cplusplus
extern "C" {
#endif

#include <string.h>
#include <inttypes.h>

static const uint16_t crc16_table[256] = {
          0x0000, 0xC0C1, 0xC181, 0x0140, 0xC301, 0x03C0, 0x0280, 0xC241,
          0xC601, 0x06C0, 0x0780, 0xC741, 0x0500, 0xC5C1, 0xC481, 0x0440,
          0xCC01, 0x0CC0, 0x0D80, 0xCD41, 0x0F00, 0xCFC1, 0xCE81, 0x0E40,
          0x0A00, 0xCAC1, 0xCB81, 0x0B40, 0xC901, 0x09C0, 0x0880, 0xC841,
          0xD801, 0x18C0, 0x1980, 0xD941, 0x1B00, 0xDBC1, 0xDA81, 0x1A40,
          0x1E00, 0xDEC1, 0xDF81, 0x1F40, 0xDD01, 0x1DC0, 0x1C80, 0xDC41,
          0x1400, 0xD4C1, 0xD581, 0x1540, 0xD701, 0x17C0, 0x1680, 0xD641,
          0xD201, 0x12C0, 0x1380, 0xD341, 0x1100, 0xD1C1, 0xD081, 0x1040,
          0xF001, 0x30C0, 0x3180, 0xF141, 0x3300, 0xF3C1, 0xF281, 0x3240,
          0x3600, 0xF6C1, 0xF781, 0x3740, 0xF501, 0x35C0, 0x3480, 0xF441,
          0x3C00, 0xFCC1, 0xFD81, 0x3D40, 0xFF01, 0x3FC0, 0x3E80, 0xFE41,
          0xFA01, 0x3AC0, 0x3B80, 0xFB41, 0x3900, 0xF9C1, 0xF881, 0x3840,
          0x2800, 0xE8C1, 0xE981, 0x2940, 0xEB01, 0x2BC0, 0x2A80, 0xEA41,
          0xEE01, 0x2EC0, 0x2F80, 0xEF41, 0x2D00, 0xEDC1, 0xEC81, 0x2C40,
          0xE401, 0x24C0, 0x2580, 0xE541, 0x2700, 0xE7C1, 0xE681, 0x2640,
          0x2200, 0xE2C1, 0xE381, 0x2340, 0xE101, 0x21C0, 0x2080, 0xE041,
          0xA001, 0x60C0, 0x6180, 0xA141, 0x6300, 0xA3C1, 0xA281, 0x6240,
          0x6600, 0xA6C1, 0xA781, 0x6740, 0xA501, 0x65C0, 0x6480, 0xA441,
          0x6C00, 0xACC1, 0xAD81, 0x6D40, 0xAF01, 0x6FC0, 0x6E80, 0xAE41,
          0xAA01, 0x6AC0, 0x6B80, 0xAB41, 0x6900, 0xA9C1, 0xA881, 0x6840,
          0x7800, 0xB8C1, 0xB981, 0x7940, 0xBB01, 0x7BC0, 0x7A80, 0xBA41,
          0xBE01, 0x7EC0, 0x7F80, 0xBF41, 0x7D00, 0xBDC1, 0xBC81, 0x7C40,
          0xB401, 0x74C0, 0x7580, 0xB541, 0x7700, 0xB7C1, 0xB681, 0x7640,
          0x7200, 0xB2C1, 0xB381, 0x7340, 0xB101, 0x71C0, 0x7080, 0xB041,
          0x5000, 0x90C1, 0x9181, 0x5140, 0x9301, 0x53C0, 0x5280, 0x9241,
          0x9601, 0x56C0, 0x5780, 0x9741, 0x5500, 0x95C1, 0x9481, 0x5440,
          0x9C01, 0x5CC0, 0x5D80, 0x9D41, 0x5F00, 0x9FC1, 0x9E81, 0x5E40,
          0x5A00, 0x9AC1, 0x9B81, 0x5B40, 0x9901, 0x59C0, 0x5880, 0x9841,
          0x8801, 0x48C0, 0x4980, 0x8941, 0x4B00, 0x8BC1, 0x8A81, 0x4A40,
          0x4E00, 0x8EC1, 0x8F81, 0x4F40, 0x8D01, 0x4DC0, 0x4C80, 0x8C41,
          0x4400, 0x84C1, 0x8581, 0x4540, 0x8701, 0x47C0, 0x4680, 0x8641,
          0x8201, 0x42C0, 0x4380, 0x8341, 0x4100, 0x81C1, 0x8081, 0x4040
  };

static inline uint16_t crc16_byte(uint16_t crc, uint8_t data)
{
   return (crc >> 8) ^ crc16_table[(crc ^ data) & 0xff];
}

uint16_t crc16(uint16_t, uint8_t *, size_t);

#ifdef __cplusplus
}
#endif
#endif 

/* CRC_H_ */

crc.c 파일

/* CRC_C_ */

#include "crc.h"

uint16_t crc16(uint16_t crc, uint8_t *buffer, size_t len)
{
    while (len--)
        crc = crc16_byte(crc, *buffer++);
    return crc;
}

/* CRC_C_ */

#### CRC-16 생성 방법 #####

CRC-16   CCITT

x16 + x12 + x5 + 1

#define CRC16_INIT_VALUE    0xffff
#define CRC16_XOR_VALUE        0x0000

============ 만들기  ==========================
static unsigned short crctable[256];

/*
   Generate a table for a byte-wise 16-bit CRC calculation on the polynomial:
   x^16 + x^12 + x^5 + x^0
*/

void make_crc_table( void ) {
    int i, j;
    unsigned long poly, c;
    /* terms of polynomial defining this crc (except x^16): */
    static const byte p[] = {0,5,12};

    /* make exclusive-or pattern from polynomial (0x1021) */
    poly = 0L;
    for ( i = 0; i < sizeof( p ) / sizeof( byte ); i++ ) {
        poly |= 1L << p[i];
    }

    for ( i = 0; i < 256; i++ ) {
        c = i << 8;
        for ( j = 0; j < 8; j++ ) {
            c = ( c & 0x8000 ) ? poly ^ ( c << 1 ) : ( c << 1 );
        }
        crctable[i] = (unsigned short) c;
    }
}

/*
  Table of CRC-16's of all single-byte values (made by make_crc_table)
*/
static unsigned short crctable[256] = {
    0x0000,    0x1021,    0x2042,    0x3063,    0x4084,    0x50a5,    0x60c6,    0x70e7,
    0x8108,    0x9129,    0xa14a,    0xb16b,    0xc18c,    0xd1ad,    0xe1ce,    0xf1ef,
    0x1231,    0x0210,    0x3273,    0x2252,    0x52b5,    0x4294,    0x72f7,    0x62d6,
    0x9339,    0x8318,    0xb37b,    0xa35a,    0xd3bd,    0xc39c,    0xf3ff,    0xe3de,
    0x2462,    0x3443,    0x0420,    0x1401,    0x64e6,    0x74c7,    0x44a4,    0x5485,
    0xa56a,    0xb54b,    0x8528,    0x9509,    0xe5ee,    0xf5cf,    0xc5ac,    0xd58d,
    0x3653,    0x2672,    0x1611,    0x0630,    0x76d7,    0x66f6,    0x5695,    0x46b4,
    0xb75b,    0xa77a,    0x9719,    0x8738,    0xf7df,    0xe7fe,    0xd79d,    0xc7bc,
    0x48c4,    0x58e5,    0x6886,    0x78a7,    0x0840,    0x1861,    0x2802,    0x3823,
    0xc9cc,    0xd9ed,    0xe98e,    0xf9af,    0x8948,    0x9969,    0xa90a,    0xb92b,
    0x5af5,    0x4ad4,    0x7ab7,    0x6a96,    0x1a71,    0x0a50,    0x3a33,    0x2a12,
    0xdbfd,    0xcbdc,    0xfbbf,    0xeb9e,    0x9b79,    0x8b58,    0xbb3b,    0xab1a,
    0x6ca6,    0x7c87,    0x4ce4,    0x5cc5,    0x2c22,    0x3c03,    0x0c60,    0x1c41,
    0xedae,    0xfd8f,    0xcdec,    0xddcd,    0xad2a,    0xbd0b,    0x8d68,    0x9d49,
    0x7e97,    0x6eb6,    0x5ed5,    0x4ef4,    0x3e13,    0x2e32,    0x1e51,    0x0e70,
    0xff9f,    0xefbe,    0xdfdd,    0xcffc,    0xbf1b,    0xaf3a,    0x9f59,    0x8f78,
    0x9188,    0x81a9,    0xb1ca,    0xa1eb,    0xd10c,    0xc12d,    0xf14e,    0xe16f,
    0x1080,    0x00a1,    0x30c2,    0x20e3,    0x5004,    0x4025,    0x7046,    0x6067,
    0x83b9,    0x9398,    0xa3fb,    0xb3da,    0xc33d,    0xd31c,    0xe37f,    0xf35e,
    0x02b1,    0x1290,    0x22f3,    0x32d2,    0x4235,    0x5214,    0x6277,    0x7256,
    0xb5ea,    0xa5cb,    0x95a8,    0x8589,    0xf56e,    0xe54f,    0xd52c,    0xc50d,
    0x34e2,    0x24c3,    0x14a0,    0x0481,    0x7466,    0x6447,    0x5424,    0x4405,
    0xa7db,    0xb7fa,    0x8799,    0x97b8,    0xe75f,    0xf77e,    0xc71d,    0xd73c,
    0x26d3,    0x36f2,    0x0691,    0x16b0,    0x6657,    0x7676,    0x4615,    0x5634,
    0xd94c,    0xc96d,    0xf90e,    0xe92f,    0x99c8,    0x89e9,    0xb98a,    0xa9ab,
    0x5844,    0x4865,    0x7806,    0x6827,    0x18c0,    0x08e1,    0x3882,    0x28a3,
    0xcb7d,    0xdb5c,    0xeb3f,    0xfb1e,    0x8bf9,    0x9bd8,    0xabbb,    0xbb9a,
    0x4a75,    0x5a54,    0x6a37,    0x7a16,    0x0af1,    0x1ad0,    0x2ab3,    0x3a92,
    0xfd2e,    0xed0f,    0xdd6c,    0xcd4d,    0xbdaa,    0xad8b,    0x9de8,    0x8dc9,
    0x7c26,    0x6c07,    0x5c64,    0x4c45,    0x3ca2,    0x2c83,    0x1ce0,    0x0cc1,
    0xef1f,    0xff3e,    0xcf5d,    0xdf7c,    0xaf9b,    0xbfba,    0x8fd9,    0x9ff8,
    0x6e17,    0x7e36,    0x4e55,    0x5e74,    0x2e93,    0x3eb2,    0x0ed1,    0x1ef0
};

C source code for base64 encoding / C source code for base64 decoding

공간사랑 — Wed, 28 Jun 2023 23:14:31 +0900

#include <stdio.h>
#include <stdlib.h>

const char base64_table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

void base64_encode(const char *input, char *output) {
  int i, j;

  for (i = 0, j = 0; input[i]; i += 3) {
    output[j++] = base64_table[input[i] >> 2];
    output[j++] = base64_table[((input[i] & 0x03) << 4) | (input[i + 1] >> 4)];
    output[j++] = base64_table[((input[i + 1] & 0x0f) << 2) | (input[i + 2] >> 6)];
    output[j++] = base64_table[input[i + 2] & 0x3f];
  }

  output[j] = '\0';
}

int main(void) {
  char input[] = "Hello, world!";
  char output[1024];

  base64_encode(input, output);

  printf("Base64 encoded string: %s\n", output);

  return 0;
}

==========================

#include <stdio.h>
#include <stdlib.h>

const char base64_table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

void base64_decode(const char *input, char *output) {
  int i, j;

  for (i = 0, j = 0; input[i]; i += 4) {
    output[j++] = (base64_table[input[i]] << 2) | (base64_table[input[i + 1]] >> 4);
    if (input[i + 2] != '=') {
      output[j++] = ((base64_table[input[i + 1]] & 0x0f) << 4) | (base64_table[input[i + 2]] >> 2);
    }
    if (input[i + 3] != '=') {
      output[j++] = ((base64_table[input[i + 2]] & 0x03) << 6) | base64_table[input[i + 3]];
    }
  }

  output[j] = '\0';
}

int main(void) {
  char input[] = "SGVsbG8sIHdvcmxkIQ==";
  char output[1024];

  base64_decode(input, output);

  printf("Base64 decoded string: %s\n", output);

  return 0;
}

CALL BY VALUE / CALL BY REFERENCE

공간사랑 — Wed, 28 Jun 2023 22:50:16 +0900

====================
변수의 값을 인수로 주는 경우
====================

#include <stdio.h>

void swap(int x, int y); // 두 변수의 값을 바꾸는 함수 선언

int main(void){
    int a = 10, b = 20; // 변수 선언과 초기화

    swap(a, b); // a, b의 값을 복사해서 전달
    printf(“a:%d, b:%d\n”, a, b); // 변수 a, b 출력

    return 0;
}

void swap(int x, int y){ // 인수 a, b의 값을 x, y에 복사해서 저장
    int temp; // 교환을 위한 변수

    temp = x; // temp에 x 값 저장
    x = y; // x에 y 값 저장
    y = temp; // y에 temp 값 저장
}

====================
포인터를 사용한 두 변수 값의 교환
====================

#include <stdio.h>

void swap(int *pa, int *pb); // 두 변수의 값을 바꾸는 함수의 선언

int main(void){
    int a = 10, b = 20; // 변수 선언과 초기화

    swap(&a, &b); // a, b의 주소를 인수로 주고 함수 호출
    printf(“a:%d, b:%d\n”, a, b); // 변수 a, b 출력

    return 0;
}

void swap(int *pa, int *pb){ // 매개변수로 포인터 선언
    int temp; // 교환을 위한 임시 변수

    temp = *pa; // temp에 pa가 가리키는 변수의 값 저장
    *pa = *pb; // pa가 가리키는 변수에 pb가 가리키는 변수의 값 저장
    *pb = temp; // pb가 가리키는 변수에 temp 값 저장
}

BASE64_SIZE

공간사랑 — Wed, 28 Jun 2023 22:25:10 +0900

#define BASE64_SIZE(x) (((x)+2) / 3 * 4 + 1)

신용카드등부가통신업(VAN)등록 현황('22.11.8.현재)

공간사랑 — Mon, 24 Apr 2023 23:27:40 +0900

https://www.fss.or.kr

금융감독권 >> 업무자료 >> 은행.중소서민금융 >> 중소서민금융업무자료

신용카드등부가통신업(VAN) 등록 현황('22.11.8. 현재).xlsx

0.02MB

Base64

공간사랑 — Mon, 24 Apr 2023 23:15:25 +0900

base64.h 파일

-----------------------

#ifndef _BASE64_H_
#define _BASE64_H_

#ifdef __cplusplus
extern "C" {
#endif

int Base64encode_len(int len);
int Base64encode(char * coded_dst, const char *plain_src,int len_plain_src);

int Base64decode_len(const char * coded_src);
int Base64decode(char * plain_dst, const char *coded_src);

#ifdef __cplusplus
}
#endif

#endif //_BASE64_H_

--------------------------------------------------

base64.c

------------------

#include <string.h>

#include "base64.h"

/* aaaack but it's fast and const should make it shared text page. */
static const unsigned char pr2six[256] =
{
    /* ASCII table */
    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 62, 64, 64, 64, 63,
    52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 64, 64, 64, 64, 64, 64,
    64,  0,  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, 64, 64, 64, 64, 64,
    64, 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, 64, 64, 64, 64, 64,
    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64
};

int Base64decode_len(const char *bufcoded)
{
    int nbytesdecoded;
    register const unsigned char *bufin;
    register int nprbytes;

    bufin = (const unsigned char *) bufcoded;
    while (pr2six[*(bufin++)] <= 63);

    nprbytes = (bufin - (const unsigned char *) bufcoded) - 1;
    nbytesdecoded = ((nprbytes + 3) / 4) * 3;

    return nbytesdecoded + 1;
}

int Base64decode(char *bufplain, const char *bufcoded)
{
    int nbytesdecoded;
    register const unsigned char *bufin;
    register unsigned char *bufout;
    register int nprbytes;

    bufin = (const unsigned char *) bufcoded;
    while (pr2six[*(bufin++)] <= 63);
    nprbytes = (bufin - (const unsigned char *) bufcoded) - 1;
    nbytesdecoded = ((nprbytes + 3) / 4) * 3;

    bufout = (unsigned char *) bufplain;
    bufin = (const unsigned char *) bufcoded;

    while (nprbytes > 4) {

        *(bufout++) = (unsigned char) (pr2six[*bufin] << 2 | pr2six[bufin[1]] >> 4);
        *(bufout++) = (unsigned char) (pr2six[bufin[1]] << 4 | pr2six[bufin[2]] >> 2);
        *(bufout++) = (unsigned char) (pr2six[bufin[2]] << 6 | pr2six[bufin[3]]);

        bufin += 4;
        nprbytes -= 4;

    }

    /* Note: (nprbytes == 1) would be an error, so just ingore that case */
    if (nprbytes > 1) {
        *(bufout++) = (unsigned char) (pr2six[*bufin] << 2 | pr2six[bufin[1]] >> 4);
    }
    if (nprbytes > 2) {
        *(bufout++) = (unsigned char) (pr2six[bufin[1]] << 4 | pr2six[bufin[2]] >> 2);
    }
    if (nprbytes > 3) {
        *(bufout++) = (unsigned char) (pr2six[bufin[2]] << 6 | pr2six[bufin[3]]);
    }

    *(bufout++) = '\0';

    nbytesdecoded -= (4 - nprbytes) & 3;

    return nbytesdecoded;
}

static const char basis_64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

int Base64encode_len(int len)
{
    return ((len + 2) / 3 * 4) + 1;
}

int Base64encode(char *encoded, const char *string, int len)
{
    int i;
    char *p;

    p = encoded;

    for (i = 0; i < len - 2; i += 3) {
        *p++ = basis_64[(string[i] >> 2) & 0x3F];
        *p++ = basis_64[((string[i] & 0x3) << 4) | ((int) (string[i + 1] & 0xF0) >> 4)];
        *p++ = basis_64[((string[i + 1] & 0xF) << 2) | ((int) (string[i + 2] & 0xC0) >> 6)];
        *p++ = basis_64[string[i + 2] & 0x3F];
    }

    if (i < len) {

        *p++ = basis_64[(string[i] >> 2) & 0x3F];

        if (i == (len - 1)) {
            *p++ = basis_64[((string[i] & 0x3) << 4)];
            *p++ = '=';
        }
        else {
            *p++ = basis_64[((string[i] & 0x3) << 4) | ((int) (string[i + 1] & 0xF0) >> 4)];
            *p++ = basis_64[((string[i + 1] & 0xF) << 2)];
        }

        *p++ = '=';

    }

    *p++ = '\0';

    return p - encoded;
}

------------------------

apple_base64.tar

0.01MB

MBC KBS SBS JTBC tvN EBS OCN

공간사랑 — Sun, 9 Apr 2023 10:59:05 +0900

Munhwa Broadcasting Coperation

Korean Broadcasting System

Seoul Broadcasting System

Joongang Tongyang Broadcasting Company

Total Variety Network

Educational Broadcasting System

Orion Cinema Network

RE100 CF100

공간사랑 — Thu, 23 Mar 2023 07:10:23 +0900

RE100(재생에너지, Renewable Electricity 100%)

CF100(무탄소, Carbon Free 100%)

챗GPT - ChatGPT

공간사랑 — Mon, 13 Feb 2023 08:17:50 +0900

챗GPT - ChatGPT(Chat Generative Pretrained Transformer)

OpenAI에서 개발한 AI 언어 모델.
사용자가 입력한 문장을 기반으로 답변을 생성하는 서비스.

curl

공간사랑 — Wed, 11 Jan 2023 21:07:04 +0900

curl 다운로드 : https://curl.se/download.html

cc / bcc

공간사랑 — Thu, 22 Dec 2022 08:29:28 +0900

cc : carbon copy 주 수신자와 구별하기 위한 사본을 받는 사람
bcc : blind carbon copy 보이지않는 사본

재핑(zapping)

공간사랑 — Thu, 22 Dec 2022 07:36:45 +0900

재핑(zapping): TV 광고가 나오면 이리저리 채널을 옮기는 시청 패턴

자동차 자율 주행 단계 구분

공간사랑 — Sun, 18 Sep 2022 09:43:48 +0900

ssh 로그인 끄고 sftp 허용

공간사랑 — Fri, 19 Aug 2022 08:11:15 +0900

$ sudo vim /etc/sshd_config
#Subsystem sftp /usr/lib/openssh/sftp-server
Subsystem sftp internal-sftp

CENTOS 리눅스 SFTP,SSH Port 분리

공간사랑 — Fri, 19 Aug 2022 08:08:05 +0900

SSH와 SFTP의 default port : 22번

/etc/ssh/sshd_config
사용하고자하는 2개의 port 기입
Port 22
Port 2222

Subsystem sftp 공간에 매칭 로컬포트 기입

22번포트-> SFTP 포트

2222번포트->SSH 포트

https://m.blog.naver.com/yeopil-yoon/221399929611

리눅스 SFTP,SSH Port 분리

이전까지 본인은 SSH포트를 바꾸면 SFTP는 자동적으로 따라오는줄 알고 있었다. 하지만 역시 갓구글...

blog.naver.com

CentOS7 SSH 공개키 자동 로그인 처리.

공간사랑 — Wed, 13 Jul 2022 23:58:43 +0900

CentOS7 SSH 공개키 자동 로그인 처리.

/etc/securetty/etc/ssh/sshd_config

PasswordAuthentication yes

RSAAuthentication yes
PubkeyAuthentication yes
AuthorizedKeysFile .ssh/authorized_keys

sshd 재시작
# systemctl restart sshd

# ssh-keygen -t rsa

# .ssh/id_rsa
# .ssh/id_rsa_pub

# id_rsa_pub를 .ssh/authorized_keys 로 복사하여 전달.

유효한 파일 권한으로 부여
# chmod 0700 ~/.ssh
# chmod 0600 ~/.ssh/authorized_keys

리눅스 진단 / 사용자 인증 - root 계정 원격 접속 제한 상식

공간사랑 — Wed, 13 Jul 2022 23:46:15 +0900

리눅스 진단 / 사용자 인증 - root 계정 원격 접속 제한 상식

■ 기능 : /etc/securetty/etc/ssh/sshd_config 리눅스 SSH 설정 파일

■ 예시

Port xx

SSH 서비스 포트는 22로 규약되어 있지만 보안을 위해 임의의 포트로 변경 하는것도 가능하다.
원하는 포트번호로 변경하고 /etc/services 파일에서 ssh 포트값도 변경해 주면 된다.

Protocol 2

SSH 프로토콜은 ver 1과 ver 2가 있는데
SSH1 클라이언트와 SSH2 클라이언트의 접속 요청에 대한 것이다.
보안상 Protocol 1은 사용하지 않고 Protocol 2 만을 사용한다
(둘다 사용하기 위해서는 Protocol 2,1 을 적어주면 된다).

ListenAddress 0.0.0.0

SSH 서버에서 Listen 할 로컬 호스트 주소를 설정하는 것이다.
여러개의 IP를 사용중일 때 특정 IP로 SSH 접속이 가능토록 설정하는 옵션으로
0.0.0.0은 모든 네트워크를 의미한다.
사용하고자 하는 특정 IP가 있다면 0.0.0.0 대신 적으면 된다.

#Hostkey ~

Protocol 1, 2(rsa, dsa) 의 호스트키 위치를 지정한다.

KeyRegenerationInterval 1h

자동으로 생성된 키의 유효시간을 지정한다(기본 3600sec 이고 h를 붙이면 1 hour의 의미이다).
이 옵션은 호스트의 세션에 있는 키를 캡쳐해서 암호를 해독하거나 훔친 키를 재사용 하지 못하도록 하기 위함이다.

ServerKeyBits 768

서버 키의 비트 길이를 설정한다. 최소 512, 기본 768.

SyslogFacility AUTH

syslog 데몬에 의한 로그 facility를 지정한다.
sub system 종류 및 내용은 syslog 관련 자료를 참조.

LogLevel INFO

로그 레벨(메시지 종류)를 지정한다.

LoginGraceTime 2m

지정한 시간내에 로그인 하지 않으면 자동으로 접속을 끊는다.
0값은 무제한.

PermitRootLogin no

공격자가 임의의 주소에 root 계정으로 접속이 가능한지 여부를 무한 스캐닝을 통해 알아 낼 수 있다.
따라서 위와 같이 root 계정의 접근을 막고 일반 유저로 접속한 다음 root 계정을 불러오는 것이 좋다.

-공개키인증
PubkeyAuthentication yes

-root 패스워드 로그인 금지하고 공개키 인증으로만 로그인
PermitRootLogin without-password

-root로는 아예 SSH로그인을 할 수 없다. (추천사항)
PermitRootLogin no

-패스워드로는 아예 로그인 못하게 설정
PasswordAuthentication no

-지정한 사용자만 SSH로 로그인 가능하게 설정
AllowUsers mysshuser

StrictModes yes

로그인을 허용하기 앞서 파일 모드 및 사용자 홈 디렉토리 소유권과 원격 호스트의 파일들을
ssh 데몬이 체크 할 수 있도록 할 때 사용.

MaxAuthTries 6

접속당 최대 인증 시도 횟수. 기본값 6, 3회이상 인증 실패시 로그가 기록된다.

#RSAAuthentication yes

RSA 인증을 설정. Protocol 1 에서만 적용되는 옵션이므로 주석처리.

#PubkeyAuthentication yes

공개키 인증 설정. Protocol 2에 적용된다.

#AuthorizedKeysFile .ssh/authorized_keys

인증키를 저장할 위치를 지정한다.

RhostsRSAAuthentication no

/etc/ssh/ssh_known_hosts 파일에 있는 호스트에 대한 인증을 허용할 것인지 설정한다.

HostbasedAuthentication no

호스트 기반의 인증 허용 여부를 결정한다.

IgnoreUserKnownHosts yes

RhostsRSAAuthentication, HostbasedAuthentication 인증시 ~/.ssh/knownhosts 파일의 호스트들을 제외할 것인지 설정한다.
rhosts 파일을 허용하지 않았으므로 yes로 설정.

IgnoreRhosts yes

~/.rhosts와 ~/.shosts 파일 사용여부를 결정한다.
보안상 이유로 사용하지 않는다.

PasswordAuthentication yes

패스워드 인증을 허용한다. Protocol 1, 2 모두 적용된다.

PermitEmptyPasswords no

패스워드 인증시 비어있는 스트링을 인정할지 여부를 결정한다.

ChallengeResponseAuthentication no

Challenge-Response 인증을 허용할지 여부를 설정한다.
UsePAM 옵션을 yes로 설정할 경우 이 옵션은 no로 설정해야 한다.

#UsePAM no

ChallengeResponseAuthentication을 이용한 PAM 인증을 허용하는 옵션이다.
이 옵션을 yes로 설정하는 경우 열쇠글 인증과 동일하게 적용되므로,
열쇠글 인증 또는 ChallengeResponseAuthentication 옵션을 꺼 놓아야 한다.

- Kerberos 및 GSSAPI 인증에 관한 내용은 필요에 따라 설정.

AllowTcpForwarding yes

TCP 포워딩을 가능토록 설정하는 옵션이다.

GatewayPorts no

클라이언트에 포워드된 포트로 원격 호스트 들이 접속할 수 있도록 설정하는 옵션이다.

X11Forwarding no

원격에서 X11 포워딩을 허용할지 여부를 설정하는 옵션이다.

#X11DisplayOffset 10

X11 포워딩이 될 때 디스플레이 offset을 설정. 허용하지 않았으므로 주석 처리.

PrintMotd yes

ssh 로그인시 /etc/motd 파일의 내용을 보여줄 것인지 여부결정. ssh 로그인을 환영하는 메시지나 공지사항 등을 출력되도록 할 수 있음.

PrintLastLog yes

로그인시 지난번 로그인 기록을 보여줄 것인가를 설정.

TCPKeepAlive yes

클라이언트의 접속이 끊어졌는지를 체크하기 위해 서버가 일정시간 메시지를 전달한다.

PermitUserEnvironment no

~/.ssh/enviroment와 ~/.ssh/authorized_keys 파일의 environment = 옵션을 sshd 데몬에서 처리 되도록 할것 인가를 설정한다.

Compression delayed

압축 사용여부를 결정.

ClientAliveInterval 0

클라이언트로부터 sshd 데몬이 아무런 데이터를 받지 못하게 되면 암호화된 채널을 통해서 메시지를 클라이언트의 요청에 응답하여 보내는데 이 때의 시간 간격을 초단위로 설정한다. 0은 클라이언트에 메시지를 보내지 않는 것을 의미. Protocol 2에서 적용된다.

ClientAliveCountMax 3

서버에게 전달되는 클라이언트의 생존 메시지 회수를 지정한다. 이 옵션으로 지정한 값에 도달하게 되면 sshd 데몬은 클라이언트와의 연결을 끊어 버리고 세션을 종료시킨다.

UseDNS yes

클라이언트 호스트 주소를 DNS 해석.

PidFile /var/run/sshd.pid

sshd 데몬의 PID를 저장할 파일을 지정한다.

MaxStartups 5

로그인하고 있지 않는 최대 접속 수를 설정한다.
이 값을 초과하게 되고 인증이 성공적으로 이뤄지지 않으면 그 다음 접속이 불가능 하다.

Subsystem sftp /usr/libexec/openssh/sftp-server

sftp는 프로토콜 버전 2에서 사용되는 것으로서 ssh와 같이 ftp의 보안을 강화하기 위해 사용되는 보안 ftp 프로그램이다. openssh를 설치하면 /usr/local/ssh/libexec/sftp-server파일이 설치된다. 이것은 sftp 서버용 프로그램으로 클라이언트 sftp프로그램은 설치되지 않는다.

따라서 서버로 가동시키고 원도용 ssh클라이언트 프로그램이나 SSH2를 설치하면 sftp를 사용이 가능하다.

UsePrivilegeSeparation yes

접속된 프로세스에 대해 상위 권한 없이 chroot로 고립된 형태로 작동

https://boanchung.tistory.com/30

Oracle Linux

공간사랑 — Tue, 5 Jul 2022 21:14:58 +0900

https://yum.oracle.com/oracle-linux-isos.html#InstallationGuides

Oracle Linux x86_64 ISOs

Oracle Linux ISO images available to download for x86_64

Release Full ISO

9.0 OracleLinux-R9-U0-x86_64-dvd.iso

https://yum.oracle.com/ISOS/OracleLinux/OL9/u0/x86_64/OracleLinux-R9-U0-x86_64-dvd.iso

Rocky Linux

공간사랑 — Sun, 19 Jun 2022 11:44:08 +0900

Rocky Linux

https://rockylinux.org/

Rocky Linux

Rocky Linux is an open enterprise Operating System designed to be 100% bug-for-bug compatible with Enterprise Linux.

rockylinux.org

BNPL

공간사랑 — Mon, 18 Apr 2022 08:16:43 +0900

후불결제(BNPL, Buy Now Pay Later)

keep in touch

공간사랑 — Sun, 3 Apr 2022 23:26:26 +0900

keep in touch

사용 가능한 Port 범위

공간사랑 — Sun, 20 Mar 2022 23:11:56 +0900

사용 가능한 Port 범위

port번호는 0 ~ 65535번까지 사용할 수 있습니다.

일반적으로 unsigned short의 2바이트 정수형을 사용합니다.
port번호는 서비스번호라고도 합니다.
그래서 /etc/services라는 파일에 등록하여 서비스명으로 port번호를 찾아서 사용할 수 있습니다.
getservbyname(3) 함수등으로 서비스명으로 port번호를 읽을 수 있습니다.
/etc/services 파일에 port번호를 등록하면
그 시스템에 사용하는 prot번호를 중복되어 오류가 나는 것을 방지하여 채번할 수 있습니다.

port 번호 사용 영역

port번호는 사용할 수 있는 영역이 정해져 있습니다.

0 ~ 1023 : well-known port번호 영역입니다.
이 영역의 port번호는 UNIX/LINUX에서 root 권한으로만 port를 열 수 있습니다.
예약영역이라고 보면 됩니다.

1024 ~ 49151번: 등록된 포트 (registered port)
이 영역은 주로 서버 소켓으로 사용하는 영역입니다.

49152 ~ 65535번 : 동적 포트(dynamic port)
이 영역은 client가 connect(2)시
또는 bind(2)없이 server socket을 생성했어 listen(2)할 경우에 자동으로 할당되는 영역입니다.
server socket에서 자동할당하면,
client에게 할당된 port번호를 알릴방법이 있어야하기 때문에 서버 소켓은 prot번호를 정합니다.

동적 포트영역은 서버 소켓 포트로 사용금지

서버 socket을 생성할 때에 동적 포트 영역의 번호를 bind(2)하여 사용할 수도 있습니다.
그러나 이 경우에는 심각한 장애가 발생할 수 있습니다.

예전에 실제로 발생한 오류인데, 서버소켓을 50000번대로 할당하여 사용하는 프로그램이 있었습니다.
이 프로그램을 실행하기 전에 여러 프로그램들이 기동하면서,
수백개의 프로그램이 Oracle DB서버와 접속을 하였습니다.
이 때에, oracle db에 접속한 프로그램이 connect(2)하면서 동적영역의
port번호를 먼저 선점하여 실행하였습니다.

뒤에 실행한 이 서버 프로그램이 port번호가 사용중이라는 오류와 함께 기동이 되지 않았습니다.
이 경우에는 장애로 이어집니다.

따라서, 동적 포트(dynamic port)영역은 서버 소켓용 port로 절대 사용금지하기 바랍니다.

출처: https://www.it-note.kr/189 [IT 개발자 Note]

It's in the middle of nowhere.

공간사랑 — Thu, 3 Mar 2022 09:21:23 +0900

It's in the middle of nowhere.

파일 EXIST 체크 access

공간사랑 — Tue, 22 Feb 2022 21:59:46 +0900

if( access( fname, F_OK ) == 0 ){
// file exists
}
else{
// file doesn't exist
}

F_OK 파일 존재여부
R_OK 파일 read 퍼미션 여부
W_OK 파일 write 퍼미션 여부
X_OK 파일 execute 퍼미션 여부

C-ISAM - Indexed Sequential Access Method Programmer’s Manual

공간사랑 — Sat, 19 Feb 2022 16:08:38 +0900

http://www.50001.com/db/informixside/data/cisam.pdf

cisam_Programmer_Manual.pdf

1.20MB

알이백(RE100)

공간사랑 — Mon, 7 Feb 2022 08:24:56 +0900

알이백(RE100)
재생에너지(Renewable Energy) 100%'의 줄임말.
기업이 사용하는 전력량의 100%를 2050년까지 재생에너지로 충당하겠다는 용어.

선거관련 여론조사 목적의 휴대폰 가상 번호 제공 안내 거부

공간사랑 — Wed, 2 Feb 2022 23:29:59 +0900

선거관련 여론조사 목적의 휴대폰 가상 번호 제공 안내 거부
SKT : 1547

KT : 080-999-1390

LG U+ : 080-855-0016