1 /* -*- Mode: C; tab-width: 2; c-basic-offset: 2; indent-tabs-mode: nil -*- */
3 * What is a library without an example to show you how to use the library?
4 * This example use both interfaces to implement a small memcached server.
5 * Please note that this is an exemple on how to use the library, not
6 * an implementation of a scalable memcached server. If you look closely
7 * at the example it isn't even multithreaded ;-)
9 * With that in mind, let me give you some pointers into the source:
10 * storage.c/h - Implements the item store for this server and not really
11 * interesting for this example.
12 * interface_v0.c - Shows an implementation of the memcached server by using
13 * the "raw" access to the packets as they arrive
14 * interface_v1.c - Shows an implementation of the memcached server by using
15 * the more "logical" interface.
16 * memcached_light.c - This file sets up all of the sockets and run the main
20 * config.h is included so that I can use the ntohll/htonll on platforms that
21 * doesn't have that (this is a private function inside libmemcached, so you
22 * cannot use it directly from libmemcached without special modifications to
28 #include <sys/types.h>
29 #include <sys/socket.h>
31 #include <netinet/tcp.h>
40 #include <libmemcached/protocol_handler.h>
41 #include <libmemcached/byteorder.h>
44 extern memcached_binary_protocol_callback_st interface_v0_impl
;
45 extern memcached_binary_protocol_callback_st interface_v1_impl
;
47 static int server_sockets
[1024];
48 static int num_server_sockets
= 0;
49 static void* socket_userdata_map
[1024];
50 static bool verbose
= false;
53 * Create a socket and bind it to a specific port number
54 * @param port the port number to bind to
56 static int server_socket(const char *port
) {
58 struct addrinfo hints
= { .ai_flags
= AI_PASSIVE
,
59 .ai_family
= AF_UNSPEC
,
60 .ai_socktype
= SOCK_STREAM
};
62 int error
= getaddrinfo("127.0.0.1", port
, &hints
, &ai
);
65 if (error
!= EAI_SYSTEM
)
66 fprintf(stderr
, "getaddrinfo(): %s\n", gai_strerror(error
));
68 perror("getaddrinfo()");
73 struct linger ling
= {0, 0};
75 for (struct addrinfo
*next
= ai
; next
; next
= next
->ai_next
)
77 int sock
= socket(ai
->ai_family
, ai
->ai_socktype
, ai
->ai_protocol
);
80 perror("Failed to create socket");
84 int flags
= fcntl(sock
, F_GETFL
, 0);
87 perror("Failed to get socket flags");
92 if ((flags
& O_NONBLOCK
) != O_NONBLOCK
)
94 if (fcntl(sock
, F_SETFL
, flags
| O_NONBLOCK
) == -1)
96 perror("Failed to set socket to nonblocking mode");
103 if (setsockopt(sock
, SOL_SOCKET
, SO_REUSEADDR
, (void *)&flags
, sizeof(flags
)) != 0)
104 perror("Failed to set SO_REUSEADDR");
106 if (setsockopt(sock
, SOL_SOCKET
, SO_KEEPALIVE
, (void *)&flags
, sizeof(flags
)) != 0)
107 perror("Failed to set SO_KEEPALIVE");
109 if (setsockopt(sock
, SOL_SOCKET
, SO_LINGER
, (void *)&ling
, sizeof(ling
)) != 0)
110 perror("Failed to set SO_LINGER");
112 if (setsockopt(sock
, IPPROTO_TCP
, TCP_NODELAY
, (void *)&flags
, sizeof(flags
)) != 0)
113 perror("Failed to set TCP_NODELAY");
115 if (bind(sock
, next
->ai_addr
, next
->ai_addrlen
) == -1)
117 if (errno
!= EADDRINUSE
)
126 if (listen(sock
, 1024) == -1)
133 server_sockets
[num_server_sockets
++]= sock
;
138 return (num_server_sockets
> 0) ? 0 : 1;
142 * Convert a command code to a textual string
143 * @param cmd the comcode to convert
144 * @return a textual string with the command or NULL for unknown commands
146 static const char* comcode2str(uint8_t cmd
)
148 static const char * const text
[] = {
149 "GET", "SET", "ADD", "REPLACE", "DELETE",
150 "INCREMENT", "DECREMENT", "QUIT", "FLUSH",
151 "GETQ", "NOOP", "VERSION", "GETK", "GETKQ",
152 "APPEND", "PREPEND", "STAT", "SETQ", "ADDQ",
153 "REPLACEQ", "DELETEQ", "INCREMENTQ", "DECREMENTQ",
154 "QUITQ", "FLUSHQ", "APPENDQ", "PREPENDQ"
157 if (cmd
<= PROTOCOL_BINARY_CMD_PREPENDQ
)
164 * Print out the command we are about to execute
166 static void pre_execute(const void *cookie
__attribute__((unused
)),
167 protocol_binary_request_header
*header
__attribute__((unused
)))
171 const char *cmd
= comcode2str(header
->request
.opcode
);
173 fprintf(stderr
, "pre_execute from %p: %s\n", cookie
, cmd
);
175 fprintf(stderr
, "pre_execute from %p: 0x%02x\n", cookie
, header
->request
.opcode
);
180 * Print out the command we just executed
182 static void post_execute(const void *cookie
__attribute__((unused
)),
183 protocol_binary_request_header
*header
__attribute__((unused
)))
187 const char *cmd
= comcode2str(header
->request
.opcode
);
189 fprintf(stderr
, "post_execute from %p: %s\n", cookie
, cmd
);
191 fprintf(stderr
, "post_execute from %p: 0x%02x\n", cookie
, header
->request
.opcode
);
196 * Callback handler for all unknown commands.
197 * Send an unknown command back to the client
199 static protocol_binary_response_status
unknown(const void *cookie
,
200 protocol_binary_request_header
*header
,
201 memcached_binary_protocol_raw_response_handler response_handler
)
203 protocol_binary_response_no_extras response
= {
206 .magic
= PROTOCOL_BINARY_RES
,
207 .opcode
= header
->request
.opcode
,
208 .status
= htons(PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND
),
209 .opaque
= header
->request
.opaque
214 return response_handler(cookie
, header
, (void*)&response
);
217 static void work(void);
220 * Program entry point. Bind to the specified port(s) and serve clients
222 * @param argc number of items in the argument vector
223 * @param argv argument vector
224 * @return 0 on success, 1 otherwise
226 int main(int argc
, char **argv
)
228 bool port_specified
= false;
230 memcached_binary_protocol_callback_st
*interface
= &interface_v0_impl
;
232 while ((cmd
= getopt(argc
, argv
, "v1p:?")) != EOF
)
236 interface
= &interface_v1_impl
;
239 port_specified
= true;
240 (void)server_socket(optarg
);
245 case '?': /* FALLTHROUGH */
247 (void)fprintf(stderr
, "Usage: %s [-p port] [-v] [-1]\n", argv
[0]);
252 if (!initialize_storage())
254 /* Error message already printed */
259 (void)server_socket("9999");
261 if (num_server_sockets
== 0)
263 fprintf(stderr
, "I don't have any server sockets\n");
268 * Create and initialize the handles to the protocol handlers. I want
269 * to be able to trace the traffic throught the pre/post handlers, and
270 * set up a common handler for unknown messages
272 interface
->pre_execute
= pre_execute
;
273 interface
->post_execute
= post_execute
;
274 interface
->unknown
= unknown
;
276 struct memcached_protocol_st
*protocol_handle
;
277 if ((protocol_handle
= memcached_protocol_create_instance()) == NULL
)
279 fprintf(stderr
, "Failed to allocate protocol handle\n");
283 memcached_binary_protocol_set_callbacks(protocol_handle
, interface
);
284 memcached_binary_protocol_set_pedantic(protocol_handle
, true);
286 for (int xx
= 0; xx
< num_server_sockets
; ++xx
)
287 socket_userdata_map
[server_sockets
[xx
]]= protocol_handle
;
289 /* Serve all of the clients */
296 static void work(void)
298 #define MAX_SERVERS_TO_POLL 100
299 struct pollfd fds
[MAX_SERVERS_TO_POLL
];
302 for (max_poll
= 0; max_poll
< num_server_sockets
; ++max_poll
)
304 fds
[max_poll
].events
= POLLIN
;
305 fds
[max_poll
].revents
= 0;
306 fds
[max_poll
].fd
= server_sockets
[max_poll
];
312 int err
= poll(fds
, (nfds_t
)max_poll
, -1);
314 if (err
== 0 || (err
== -1 && errno
!= EINTR
))
316 perror("poll() failed");
320 /* find the available filedescriptors */
321 for (int x
= max_poll
- 1; x
> -1 && err
> 0; --x
)
323 if (fds
[x
].revents
!= 0)
326 if (x
< num_server_sockets
)
328 /* accept new client */
329 struct sockaddr_storage addr
;
330 socklen_t addrlen
= sizeof(addr
);
331 int sock
= accept(fds
[x
].fd
, (struct sockaddr
*)&addr
,
336 perror("Failed to accept client");
340 struct memcached_protocol_st
*protocol
;
341 protocol
= socket_userdata_map
[fds
[x
].fd
];
343 struct memcached_protocol_client_st
* c
;
344 c
= memcached_protocol_create_client(protocol
, sock
);
347 fprintf(stderr
, "Failed to create client\n");
352 socket_userdata_map
[sock
]= c
;
353 fds
[max_poll
].events
= POLLIN
;
354 fds
[max_poll
].revents
= 0;
355 fds
[max_poll
].fd
= sock
;
361 /* drive the client */
362 struct memcached_protocol_client_st
* c
;
363 c
= socket_userdata_map
[fds
[x
].fd
];
365 fds
[max_poll
].events
= 0;
367 memcached_protocol_event_t events
= memcached_protocol_client_work(c
);
368 if (events
& MEMCACHED_PROTOCOL_WRITE_EVENT
)
369 fds
[max_poll
].events
= POLLOUT
;
371 if (events
& MEMCACHED_PROTOCOL_READ_EVENT
)
372 fds
[max_poll
].events
= POLLIN
;
374 if (!(events
& MEMCACHED_PROTOCOL_PAUSE_EVENT
||
375 fds
[max_poll
].events
!= 0))
377 memcached_protocol_client_destroy(c
);
381 if (x
!= max_poll
- 1)
382 memmove(fds
+ x
, fds
+ x
+ 1, (size_t)(max_poll
- x
));