1
#define _GNU_SOURCE
2
#include <errno.h>
3
#include <fcntl.h>
4
#include <signal.h>
5
#include <stdbool.h>
6
#include <stdio.h>
7
#include <stdlib.h>
8
#include <string.h>
9

10
#include <sys/epoll.h>
11
#include <sys/socket.h>
12
#include <sys/un.h>
13
#include <unistd.h>
14

15
#define SOCKET_PATH "/tmp/iomultiplex_server.sock"
16
#define MAX_EVENTS 10
17
#define BUF_SIZE 256
18

19
static volatile sig_atomic_t stop = 0;
20

21
void sigint_handler(int sig) {
22
  (void)sig; // depress `unsed` warning
23
  stop = 1;
24
}
25

26
int make_nonblocking(int fd) {
27
  int flags = fcntl(fd, F_GETFL, 0);
28
  if (flags == -1)
29
    return -1;
30
  return fcntl(fd, F_SETFL, flags | O_NONBLOCK);
31
}
32

33
int main() {
34
  if (signal(SIGINT, sigint_handler) == SIG_ERR) {
35
    perror("signal handler");
36
    exit(1);
37
  }
38

39
  int listen_fd, epoll_fd;
40
  struct sockaddr_un addr;
41
  struct epoll_event ev, events[MAX_EVENTS] = {0};
42
  char buffer[BUF_SIZE];
43

44
  // delete old socket file
45
  unlink(SOCKET_PATH);
46

47
  // create socket listen
48
  listen_fd = socket(AF_UNIX, SOCK_STREAM, 0);
49
  if (listen_fd < 0) {
50
    perror("creating socket");
51
    exit(1);
52
  }
53

54
  addr.sun_family = AF_UNIX;
55
  strncpy(addr.sun_path, SOCKET_PATH, sizeof(addr.sun_path));
56

57
  if (bind(listen_fd, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
58
    perror("bind");
59
    close(listen_fd);
60
    exit(1);
61
  }
62

63
  if (listen(listen_fd, 10) == -1) {
64
    perror("listen");
65
    close(listen_fd);
66
    exit(1);
67
  }
68

69
  // create epoll instance
70
  epoll_fd = epoll_create1(0);
71
  if (epoll_fd < 0) {
72
    perror("epoll_create1");
73
    close(listen_fd);
74
    exit(1);
75
  }
76

77
  // register listen socket to epoll
78
  ev.events = EPOLLIN;
79
  ev.data.fd = listen_fd;
80
  if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, listen_fd, &ev) == -1) {
81
    perror("epoll_ctl: listen fd");
82
    close(listen_fd);
83
    close(epoll_fd);
84
    exit(1);
85
  }
86

87
  printf("server listening on %s\n", SOCKET_PATH);
88

89
  bool client_fds[MAX_EVENTS + 1] = {0};
90
  while (!stop) {
91
    int nfds = epoll_wait(epoll_fd, events, MAX_EVENTS, -1);
92
    if (nfds == -1) {
93
      if (errno == EINTR)
94
        continue;
95
      perror("epoll_wait");
96
      break;
97
    }
98

99
    for (int i = 0; i < nfds; i++) {
100
      if (events[i].data.fd == listen_fd) {
101
        // new connection
102
        int client_fd = accept(listen_fd, NULL, NULL);
103
        if (client_fd < 0) {
104
          if (errno == EAGAIN || errno == EWOULDBLOCK)
105
            continue;
106
          perror("accept");
107
          continue;
108
        }
109
        if (make_nonblocking(client_fd) == -1) {
110
          perror("make_nonblocking client fd");
111
          close(client_fd);
112
          continue;
113
        }
114
        ev.events = EPOLLIN | EPOLLRDHUP; // readable and close
115
        ev.data.fd = client_fd;
116
        if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, client_fd, &ev) == -1) {
117
          perror("epoll_ctl: client fd");
118
          close(client_fd);
119
        } else {
120
          printf("new client connected: fd=%d\n", client_fd);
121
          fflush(stdout);
122
        }
123
        client_fds[client_fd] = true;
124
      } else {
125
        // connected
126
        int client_fd = events[i].data.fd;
127
        if (client_fds[client_fd])
128
          printf("client: %d already connected!\n", client_fd);
129
        else
130
          fprintf(stderr,
131
                  "client_fd: %d not registered! this should never happen!\n",
132
                  client_fd);
133
        ssize_t count;
134
        if (events[i].events & (EPOLLHUP | EPOLLRDHUP)) {
135
          // client closed
136
          printf("client fd=%d disconnected\n", client_fd);
137
          epoll_ctl(epoll_fd, EPOLL_CTL_DEL, client_fd, NULL);
138
          close(client_fd);
139
          client_fds[client_fd] = false;
140
          continue;
141
        }
142
        count = read(client_fd, buffer, sizeof(buffer) - 1);
143
        if (count > 0) {
144
          buffer[count] = '\0';
145
          // get client pid by SO_PEERCRED
146
          struct ucred ucred;
147
          socklen_t len = sizeof(ucred);
148
          if (getsockopt(client_fd, SOL_SOCKET, SO_PEERCRED, &ucred, &len) ==
149
              0) {
150
            printf("%d:'%s'\n", (int)ucred.pid, buffer);
151
          } else {
152
            printf("pid: unknown: '%s'\n", buffer);
153
          }
154
          fflush(stdout);
155
        } else if (count == 0) {
156
          // client closed
157
          printf("client fd=%d closed connection\n", client_fd);
158
          close(client_fd);
159
          epoll_ctl(epoll_fd, EPOLL_CTL_DEL, client_fd, NULL);
160
          client_fds[client_fd] = false;
161
        } else {
162
          if (errno != EAGAIN && errno != EWOULDBLOCK) {
163
            perror("read");
164
            close(client_fd);
165
            epoll_ctl(epoll_fd, EPOLL_CTL_DEL, client_fd, NULL);
166
            client_fds[client_fd] = false;
167
          }
168
          // EAGIAN: no more data, nomal
169
        }
170
      }
171
    }
172
  }
173

174
  printf("shutting down server\n");
175
  for (int i = 0; i <= MAX_EVENTS; i++) {
176
    if (client_fds[i]) {
177
      close(i);
178
      epoll_ctl(epoll_fd, EPOLL_CTL_DEL, i, NULL);
179
    }
180
  }
181
  epoll_ctl(epoll_fd, EPOLL_CTL_DEL, listen_fd, NULL);
182
  close(listen_fd);
183
  close(epoll_fd);
184
  unlink(SOCKET_PATH);
185
  printf("all resource freed\n");
186
  return 0;
187
}

1
#include <stdio.h>
2
#include <stdlib.h>
3
#include <string.h>
4
#include <time.h>
5

6
#include <unistd.h>
7
#include <sys/socket.h>
8
#include <sys/un.h>
9
#include <sys/types.h>
10
#include <sys/wait.h>
11

12
#define SOCKET_PATH "/tmp/iomultiplex_server.sock"
13
#define BUF_SIZE 256
14
#define MAX_PROCS 10
15
#define NUM_MSGS 10
16

17
int child(int id) {
18
  struct sockaddr_un addr;
19
  char msg[BUF_SIZE];
20
  pid_t my_pid = getpid();
21

22
  // sleep random time
23
  srand(my_pid ^ time(NULL));
24
  sleep(rand() % 4);
25

26
  int sock = socket(AF_UNIX, SOCK_STREAM, 0);
27
  if (sock == -1) {
28
    perror("socket");
29
    exit(1);
30
  }
31

32
  addr.sun_family = AF_UNIX;
33
  strncpy(addr.sun_path, SOCKET_PATH, strlen(SOCKET_PATH));
34

35
  if (connect(sock, (struct sockaddr*)&addr, sizeof(addr)) == -1) {
36
    perror("connect");
37
    close(sock);
38
    exit(1);
39
  }
40
  snprintf(msg, sizeof(msg), "Hello from client %d", (int)my_pid);
41
  if (write(sock, msg, strlen(msg)) == -1) {
42
    perror("write");
43
  }
44
  usleep(100);
45

46
  for (int i = 0; i < NUM_MSGS; i++) {
47
    snprintf(msg, sizeof(msg), "%d", rand() % 10);
48
    if (write(sock, msg, strlen(msg)) == -1) {
49
      perror("write");
50
    }
51
    usleep(1);
52
  }
53

54
  close(sock);
55
  return 0;
56
}
57

58
int main() {
59
  pid_t pids[MAX_PROCS] = {0};
60
  pid_t pid;
61
  for (int i = 0; i < MAX_PROCS; i++) {
62
    pid = fork();
63
    if (pid == 0) {
64
      // child
65
      exit(child(i));
66
    } else if (pid == -1) {
67
      // fork failed
68
      perror("fork");
69
      exit(1);
70
    } else {
71
      // parent
72
      pids[i] = pid;
73
    }
74
  }
75

76
  printf("forked pids: ");
77
  for (int i = 0; i < MAX_PROCS; i++) {
78
    printf("%d ", pids[i]);
79
  }
80
  printf("\n");
81

82
  for (int i = 0; i < MAX_PROCS; i++) {
83
    int status;
84
    waitpid(pids[i], &status, 0);
85
    if (WIFEXITED(status)) {
86
      printf("client #%d exited with status %d\n", i + 1, WEXITSTATUS(status));
87
    }
88
  }
89
  printf("all child stopped\n");
90
  return 0;
91
}