C: Linux C 编程 - AF_UNIX

 

#ifndef __SIGNAL__
#define __SIGNAL__
int user_context_setup(int arg);
int signal_setup();
#endif

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <ucontext.h>
#include <unistd.h>

void do_exit(int fd)
{  
  if (close(fd) == -1)
  {
    printf("close: err.\n");
  }
  printf("exit.\n");
  exit(0);
}

int ucstoi(stack_t stack)
{
  return *((int *) stack.ss_sp);
}

void on_signal_int_action(int signal, siginfo_t *info, void *ucontext)
{
  ucontext_t *p = (ucontext_t *) ucontext;
  int fd = ucstoi(p->uc_stack);
  printf("signal: num=SIGINT(%d)\n", signal);
  do_exit(fd);
}

void on_signal_term_action(int signal, siginfo_t *info, void *ucontext)
{
  ucontext_t *p = (ucontext_t *) ucontext;
  int fd = ucstoi(p->uc_stack);
  printf("signal: num=SIGTERM(%d)\n", signal);
  do_exit(fd);
}

void on_signal_kill_action(int signal, siginfo_t *info, void *ucontext)
{
  ucontext_t *p = (ucontext_t *) ucontext;
  int fd = ucstoi(p->uc_stack);
  printf("signal: num=SIGKILL(%d)\n", signal);
  do_exit(fd);
}

int createcontext(int arg)
{
  stack_t stack;
  ucontext_t ucontext;

  stack.ss_size = SIGSTKSZ;
  stack.ss_sp = malloc(stack.ss_size);
  stack.ss_flags = 0;

  memcpy(stack.ss_sp, &arg, sizeof(arg));

  if (sigaltstack(&stack, NULL) == -1)
  {
    printf("sig alt stack err.\n");
    return 1;
  }

  ucontext.uc_link = NULL;
  ucontext.uc_stack = stack;
  if (getcontext(&ucontext) == -1) 
  {
    printf("get context err.\n");
    return 1;
  }
  return 0;
}

int setup_signal(int signum, 
  void (*action)(int, siginfo_t *, void *))
{
  struct sigaction on_signal;
  on_signal.sa_sigaction = action;
  on_signal.sa_flags = SA_SIGINFO;
  if (sigaction(signum, &on_signal, NULL) == -1)
  {
    return 1;
  }
  return 0;
}

int signal_setup()
{
  // SIGINT signal
  if (setup_signal(SIGINT, on_signal_int_action))
  {
    printf("setup signal SIGINT err.\n");
    return 1;
  }
  // SIGTERM signal
  if (setup_signal(SIGTERM, on_signal_term_action))
  {
    printf("setup signal SIGTERM err.\n");
    return 1;
  }

  // The signals SIGKILL and SIGSTOP cannot be caught or ignored.
  // SIGKILL signal
  /*
  if (setup_signal(SIGKILL, on_signal_kill_action))
  {
    printf("setup signal SIGKILL err.\n");
    return 1;
  }
  */
  return 0;
}

int user_context_setup(int arg)
{
  if (createcontext(arg))
  {
    printf("create context err.\n");
    return 1;
  }
  return 0;
}

 

#ifndef NT_SOCKET
#define NT_SOCKET
int ftonb(int fd);

int nt_socket();
int nt_socket_s(char *path);

int nt_connect(int fd, char *path);
#endif

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

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

#include <sys/un.h>

#include <unistd.h>
#include <fcntl.h>

int ftonb(int fd)
{
  int flags = fcntl(fd, F_GETFL);
  if (flags == -1) 
  {
    return 1;
  }
  if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) 
  {
    return 1;
  }
  return 0;
}

int nt_socket()
{
  int fd;

  fd = socket(AF_UNIX, SOCK_STREAM, 0);
  if (fd == -1)
  {
    return -1;
  }
  return fd;
}

int nt_socket_s(char *path)
{
  struct sockaddr_un sock_addr;
  int fd = nt_socket();
  unlink(path);
  if (fd == -1)
  {
    return -1;
  }

  if(ftonb(fd))
  {
    return -1;
  }

  memset(&sock_addr, 0, sizeof(struct sockaddr_un));
  sock_addr.sun_family = AF_UNIX;
  memcpy(sock_addr.sun_path, path, strlen(path));

  if (bind(fd, (struct sockaddr *) &sock_addr, sizeof(struct sockaddr_un)) == -1) 
  {
    printf("socket: bind err: %d.\n", errno);
    return -1;
  }
  if (listen(fd, 50) == -1) 
  {
    return -1;
  }
  return fd;
}

int nt_connect(int fd, char *path)
{
  struct sockaddr_un sock_addr;

  memset(&sock_addr, 0, sizeof(struct sockaddr_un));
  sock_addr.sun_family = AF_UNIX;
  memcpy(sock_addr.sun_path, path, strlen(path));

  if (connect(fd, (struct sockaddr *) &sock_addr, sizeof(struct sockaddr_un)) == -1)
  {
    return -1;
  }
  return 0;
}

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

#include <netinet/in.h>  
#include <arpa/inet.h>

#include <unistd.h>

#include <sys/epoll.h>

#include "internal/socket.h"
#include "internal/signal.h"

#define MAX_EPOLL_EVENT_SIZE 16

int main()
{
  int fd;
  int ep_fd;
  struct epoll_event ev, ep_event[MAX_EPOLL_EVENT_SIZE];

  char *sock_path = "./sock";
  fd = nt_socket_s(sock_path);
  if (fd == -1)
  {
    printf("socket: nt_socket_s err.\n");
    return -1;
  }

  user_context_setup(fd);
  signal_setup();

  ep_fd = epoll_create(20000);
  if (ep_fd == -1)
  {
    return 1;
  }
 
  ev.events = EPOLLIN;
  ev.data.fd = fd; 
  if (epoll_ctl(ep_fd, EPOLL_CTL_ADD, fd, &ev) == -1)
  {
    return 1;
  }

  for (;;)
  {
    int num = epoll_wait(ep_fd, ep_event, MAX_EPOLL_EVENT_SIZE, -1);
    if (num == -1)
    {
      printf("epoll: epoll wait err.\n");
    }
    else 
    {
      int i;
      for (i = 0; i < num; i++)
      {
        uint32_t events = ep_event[i].events;
        printf("epoll: events=0x%x on fd=%d\n", events, ep_event[i].data.fd);

        if (ep_event[i].data.fd == fd)
        {
          struct sockaddr_in sock_addr_from;
          int addrlen = sizeof(struct sockaddr_in);
          int fd_got = accept(fd, (struct sockaddr *) &sock_addr_from, &addrlen);
          if (fd_got == -1)
          {
            printf("sock: accept err.\n");
          }
          else
          {
            printf("sock: accepted.\n");
            if (ftonb(fd_got))
            {
              printf("fd: ftonb err.\n");
            }
            
            ev.events = EPOLLIN | EPOLLRDHUP | EPOLLET;
            ev.data.fd = fd_got;
            if (epoll_ctl(ep_fd, EPOLL_CTL_ADD, fd_got, &ev) == -1)
            {
              printf("epoll: epoll ctl err.\n");
            }
          }
        }
        else
        {
          if (events & EPOLLIN)
          {
            char c;
            int nbytes = read(ep_event[i].data.fd, &c, 1);
            if (nbytes == -1)
            {
              printf("read: read err.\n");
            }
            else
            if (nbytes > 0)
            {
              printf("%c", c);

              ep_event[i].events = ep_event[i].events | EPOLLIN | EPOLLOUT | EPOLLRDHUP | EPOLLET;
              if (epoll_ctl(ep_fd, EPOLL_CTL_MOD, ep_event[i].data.fd, &ep_event[i]) == -1)
              {
                printf("epoll: epoll ctl err.\n");
              }
            }
          }
          if (events & EPOLLRDHUP)
          {
            close(ep_event[i].data.fd);
            printf("close: fd=%d\n", ep_event[i].data.fd);
          }
          if (events & EPOLLOUT)
          {
            //printf("write: ok.\n");
          }
        }
      }
    }
  }
}

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

#include <unistd.h>

#include "internal/socket.h"

int main(int argc, char **argv)
{
  int i;
  int fd = nt_socket();
  char *sock_path = "./sock";
  if (fd == -1)
  {
    return -1;
  }
  if (nt_connect(fd, sock_path) == -1)
  {
    return -1;
  }

  for (i = 1; i < argc; i++)
  {
    write(fd, argv[i], strlen(argv[i]));
  }

  close(fd);
  return 0;
}