1 /**
2 * cmake .
3 * make test_server
4 * ./bin/test_server
5 */
6 #include "swoole_server.h"
7 #include "swoole_util.h"
8
9 using namespace swoole;
10
11 int my_onPacket(Server *serv, RecvData *req);
12 int my_onReceive(Server *serv, RecvData *req);
13 void my_onStart(Server *serv);
14 void my_onShutdown(Server *serv);
15 void my_onConnect(Server *serv, DataHead *info);
16 void my_onClose(Server *serv, DataHead *info);
17 void my_onWorkerStart(Server *serv, int worker_id);
18 void my_onWorkerStop(Server *serv, int worker_id);
19
20 static int g_receive_count = 0;
21
main(int argc,char ** argv)22 int main(int argc, char **argv) {
23 swoole_init();
24
25 sw_logger()->set_date_format("%F %T");
26 sw_logger()->set_date_with_microseconds(true);
27
28 Server serv(Server::MODE_BASE);
29
30 serv.reactor_num = 4;
31 serv.worker_num = 1;
32
33 serv.set_max_connection(10000);
34 // serv.open_cpu_affinity = 1;
35 // serv.open_tcp_nodelay = 1;
36 // serv.daemonize = 1;
37 // memcpy(serv.log_file, SW_STRS("/tmp/swoole.log"));
38
39 serv.dispatch_mode = 2;
40 // serv.open_tcp_keepalive = 1;
41
42 #ifdef HAVE_OPENSSL
43 // serv.ssl_cert_file = "tests/ssl/ssl.crt";
44 // serv.ssl_key_file = "tests/ssl/ssl.key";
45 // serv.open_ssl = 1;
46 #endif
47
48 serv.onStart = my_onStart;
49 serv.onShutdown = my_onShutdown;
50 serv.onConnect = my_onConnect;
51 serv.onReceive = my_onReceive;
52 serv.onPacket = my_onPacket;
53 serv.onClose = my_onClose;
54 serv.onWorkerStart = my_onWorkerStart;
55 serv.onWorkerStop = my_onWorkerStop;
56
57 // swSignal_set(SIGINT, user_signal);
58
59 serv.add_port(SW_SOCK_UDP, "0.0.0.0", 9502);
60 serv.add_port(SW_SOCK_TCP6, "::", 9503);
61 serv.add_port(SW_SOCK_UDP6, "::", 9504);
62
63 swListenPort *port = serv.add_port(SW_SOCK_TCP, "127.0.0.1", 9501);
64 if (!port) {
65 swoole_warning("listen failed, [error=%d]", swoole_get_last_error());
66 exit(2);
67 }
68
69 port->open_eof_check = 0;
70 // config
71 port->backlog = 128;
72 memcpy(port->protocol.package_eof, SW_STRL("\r\n\r\n"));
73
74 if (serv.create()) {
75 swoole_warning("create server fail[error=%d]", swoole_get_last_error());
76 exit(1);
77 }
78
79 if (serv.start() < 0) {
80 swoole_warning("start server fail[error=%d]", swoole_get_last_error());
81 exit(3);
82 }
83 return 0;
84 }
85
my_onWorkerStart(Server * serv,int worker_id)86 void my_onWorkerStart(Server *serv, int worker_id) {
87 swoole_notice("WorkerStart[%d]PID=%d", worker_id, getpid());
88 }
89
my_onWorkerStop(Server * serv,int worker_id)90 void my_onWorkerStop(Server *serv, int worker_id) {
91 swoole_notice("WorkerStop[%d]PID=%d", worker_id, getpid());
92 }
93
my_onReceive(Server * serv,RecvData * req)94 int my_onReceive(Server *serv, RecvData *req) {
95 char req_data[SW_IPC_BUFFER_SIZE];
96 char resp_data[SW_IPC_BUFFER_SIZE];
97
98 g_receive_count++;
99
100 Connection *conn = serv->get_connection_by_session_id(req->info.fd);
101
102 memcpy(req_data, req->data, req->info.len);
103 swoole::rtrim(req_data, req->info.len);
104 swoole_notice("onReceive[%d]: ip=%s|port=%d Data=%s|Len=%d",
105 g_receive_count,
106 conn->info.get_ip(),
107 conn->info.get_port(),
108 req_data,
109 req->info.len);
110
111 int n = sw_snprintf(resp_data, SW_IPC_BUFFER_SIZE, "Server: %.*s\n", req->info.len, req_data);
112
113 if (!serv->send(req->info.fd, resp_data, n)) {
114 swoole_notice("send to client fail. errno=%d", errno);
115 } else {
116 swoole_notice("send %d bytes to client success. data=%s", n, resp_data);
117 }
118 return SW_OK;
119 }
120
my_onPacket(Server * serv,RecvData * req)121 int my_onPacket(Server *serv, RecvData *req) {
122 char address[256];
123 int port = 0;
124 int ret = 0;
125
126 DgramPacket *packet = (DgramPacket *) req->data;
127
128 auto serv_socket = serv->get_server_socket(req->info.server_fd);
129
130 if (packet->socket_type == SW_SOCK_UDP) {
131 inet_ntop(AF_INET, &packet->socket_addr.addr.inet_v4.sin_addr, address, sizeof(address));
132 port = ntohs(packet->socket_addr.addr.inet_v4.sin_port);
133 } else if (packet->socket_type == SW_SOCK_UDP6) {
134 inet_ntop(AF_INET6, &packet->socket_addr.addr.inet_v6.sin6_addr, address, sizeof(address));
135 port = ntohs(packet->socket_addr.addr.inet_v6.sin6_port);
136 } else if (packet->socket_type == SW_SOCK_UNIX_DGRAM) {
137 strcpy(address, packet->socket_addr.addr.un.sun_path);
138 } else {
139 abort();
140 }
141
142 char *data = packet->data;
143 uint32_t length = packet->length;
144
145 swoole_notice("Packet[client=%s:%d, %d bytes]: data=%.*s", address, port, length, length, data);
146
147 char resp_data[SW_IPC_BUFFER_SIZE];
148 int n = sw_snprintf(resp_data, SW_IPC_BUFFER_SIZE, "Server: %.*s", length, data);
149
150 ret = serv_socket->sendto(address, port, resp_data, n);
151
152 if (ret < 0) {
153 swoole_notice("send to client fail. errno=%d", errno);
154 } else {
155 swoole_notice("send %d bytes to client success. data=%s", n, resp_data);
156 }
157
158 return SW_OK;
159 }
160
my_onStart(Server * serv)161 void my_onStart(Server *serv) {
162 swoole_notice("Server is running");
163 }
164
my_onShutdown(Server * serv)165 void my_onShutdown(Server *serv) {
166 swoole_notice("Server is shutdown");
167 }
168
my_onConnect(Server * serv,DataHead * info)169 void my_onConnect(Server *serv, DataHead *info) {
170 swoole_notice("PID=%d\tConnect fd=%ld|reactor_id=%d", getpid(), info->fd, info->reactor_id);
171 }
172
my_onClose(Server * serv,DataHead * info)173 void my_onClose(Server *serv, DataHead *info) {
174 swoole_notice("PID=%d\tClose fd=%ld|reactor_id=%d", getpid(), info->fd, info->reactor_id);
175 }
176