- allow building for MinGW using either -mno-cygwin or the MinGW gcc
[openocd.git] / src / server / server.c
1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
4 * *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
9 * *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
14 * *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19 ***************************************************************************/
20 #ifdef HAVE_CONFIG_H
21 #include "config.h"
22 #endif
23
24 #include "replacements.h"
25
26 #include "server.h"
27
28 #include "log.h"
29 #include "telnet_server.h"
30 #include "target.h"
31
32 #include <command.h>
33 #include <string.h>
34 #include <stdlib.h>
35 #include <errno.h>
36 #include <unistd.h>
37 #include <sys/types.h>
38 #include <fcntl.h>
39 #include <signal.h>
40
41 service_t *services = NULL;
42
43 /* shutdown_openocd == 1: exit the main event loop, and quit the debugger */
44 static int shutdown_openocd = 0;
45 int handle_shutdown_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
46
47 int add_connection(service_t *service, command_context_t *cmd_ctx)
48 {
49 unsigned int address_size;
50 connection_t *c, *p;
51 int retval;
52
53 c = malloc(sizeof(connection_t));
54 c->fd = -1;
55 memset(&c->sin, 0, sizeof(c->sin));
56 c->cmd_ctx = copy_command_context(cmd_ctx);
57 c->service = service;
58 c->input_pending = 0;
59 c->priv = NULL;
60 c->next = NULL;
61
62 address_size = sizeof(c->sin);
63 c->fd = accept(service->fd, (struct sockaddr *)&service->sin, &address_size);
64
65 if ((retval = service->new_connection(c)) == ERROR_OK)
66 {
67 INFO("accepted '%s' connection from %i", service->name, c->sin.sin_port);
68 }
69 else
70 {
71 close_socket(c->fd);
72 INFO("attempted '%s' connection rejected", service->name);
73 free(c);
74 }
75
76 if (service->connections)
77 {
78 for (p = service->connections; p && p->next; p = p->next);
79 if (p)
80 p->next = c;
81 }
82 else
83 {
84 service->connections = c;
85 }
86
87 service->max_connections--;
88
89 return ERROR_OK;
90 }
91
92 int remove_connection(service_t *service, connection_t *connection)
93 {
94 connection_t *c = service->connections;
95
96 /* find connection */
97 while(c)
98 {
99 connection_t *next = c->next;
100
101 if (c->fd == connection->fd)
102 {
103 service->connections = next;
104 service->connection_closed(c);
105 close_socket(c->fd);
106
107 command_done(c->cmd_ctx);
108
109 /* delete connection */
110 free(c);
111
112 service->max_connections++;
113 break;
114 }
115
116 /* remember the last connection for unlinking */
117 c = next;
118 }
119
120 return ERROR_OK;
121 }
122
123 int add_service(char *name, enum connection_type type, unsigned short port, int max_connections, new_connection_handler_t new_connection_handler, input_handler_t input_handler, connection_closed_handler_t connection_closed_handler, void *priv)
124 {
125 service_t *c, *p;
126 int so_reuseaddr_option = 1;
127
128 c = malloc(sizeof(service_t));
129
130 c->name = strdup(name);
131 c->type = type;
132 c->port = port;
133 c->max_connections = max_connections;
134 c->fd = -1;
135 c->connections = NULL;
136 c->new_connection = new_connection_handler;
137 c->input = input_handler;
138 c->connection_closed = connection_closed_handler;
139 c->priv = priv;
140 c->next = NULL;
141
142 if ((c->fd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
143 {
144 ERROR("error creating socket: %s", strerror(errno));
145 exit(-1);
146 }
147
148 setsockopt(c->fd, SOL_SOCKET, SO_REUSEADDR, (void*)&so_reuseaddr_option, sizeof(int));
149
150 socket_nonblock(c->fd);
151
152 memset(&c->sin, 0, sizeof(c->sin));
153 c->sin.sin_family = AF_INET;
154 c->sin.sin_addr.s_addr = INADDR_ANY;
155 c->sin.sin_port = htons(port);
156
157 if (bind(c->fd, (struct sockaddr *)&c->sin, sizeof(c->sin)) == -1)
158 {
159 ERROR("couldn't bind to socket: %s", strerror(errno));
160 exit(-1);
161 }
162
163 if (listen(c->fd, 1) == -1)
164 {
165 ERROR("couldn't listen on socket: %s", strerror(errno));
166 exit(-1);
167 }
168
169 if (services)
170 {
171 for (p = services; p && p->next; p = p->next);
172 if (p)
173 p->next = c;
174 }
175 else
176 {
177 services = c;
178 }
179
180 return ERROR_OK;
181 }
182
183 int remove_service(unsigned short port)
184 {
185 service_t *c = services;
186
187 /* find service */
188 while(c)
189 {
190 service_t *next = c->next;
191
192 if (c->port == port)
193 {
194 if (c->name)
195 free(c->name);
196
197 if (c->priv)
198 free(c->priv);
199
200 /* delete service */
201 free(c);
202 }
203
204 /* remember the last service for unlinking */
205 c = next;
206 }
207
208 return ERROR_OK;
209 }
210
211 int remove_services()
212 {
213 service_t *c = services;
214
215 /* loop service */
216 while(c)
217 {
218 service_t *next = c->next;
219
220 if (c->name)
221 free(c->name);
222
223 if (c->priv)
224 free(c->priv);
225
226 /* delete service */
227 free(c);
228
229 /* remember the last service for unlinking */
230 c = next;
231 }
232
233 return ERROR_OK;
234 }
235
236 int server_loop(command_context_t *command_context)
237 {
238 service_t *service;
239
240 /* used in select() */
241 fd_set read_fds;
242 struct timeval tv;
243 int fd_max;
244
245 /* used in accept() */
246 int retval;
247
248 #ifndef _WIN32
249 if (signal(SIGPIPE, SIG_IGN) == SIG_ERR)
250 ERROR("couldn't set SIGPIPE to SIG_IGN");
251 #endif
252
253 /* do regular tasks after at most 10ms */
254 tv.tv_sec = 0;
255 tv.tv_usec = 10000;
256
257 while(!shutdown_openocd)
258 {
259 /* monitor sockets for acitvity */
260 fd_max = 0;
261 FD_ZERO(&read_fds);
262
263 /* add service and connection fds to read_fds */
264 for (service = services; service; service = service->next)
265 {
266 if (service->fd != -1)
267 {
268 /* listen for new connections */
269 FD_SET(service->fd, &read_fds);
270
271 if (service->fd > fd_max)
272 fd_max = service->fd;
273 }
274
275 if (service->connections)
276 {
277 connection_t *c;
278
279 for (c = service->connections; c; c = c->next)
280 {
281 /* check for activity on the connection */
282 FD_SET(c->fd, &read_fds);
283 if (c->fd > fd_max)
284 fd_max = c->fd;
285 }
286 }
287 }
288
289 #ifndef _WIN32
290 /* add STDIN to read_fds */
291 FD_SET(fileno(stdin), &read_fds);
292 #endif
293
294 if ((retval = select(fd_max + 1, &read_fds, NULL, NULL, &tv)) == -1)
295 {
296 #ifdef _WIN32
297
298 errno = WSAGetLastError();
299
300 if (errno == WSAEINTR)
301 FD_ZERO(&read_fds);
302 else
303 {
304 ERROR("error during select: %d", strerror(errno));
305 exit(-1);
306 }
307 #else
308
309 if (errno == EINTR)
310 FD_ZERO(&read_fds);
311 else
312 {
313 ERROR("error during select: %s", strerror(errno));
314 exit(-1);
315 }
316 #endif
317 }
318
319 target_call_timer_callbacks();
320
321 if (retval == 0)
322 {
323 /* do regular tasks after at most 100ms */
324 tv.tv_sec = 0;
325 tv.tv_usec = 10000;
326
327 #if 0
328 if (shutdown_openocd)
329 return ERROR_COMMAND_CLOSE_CONNECTION;
330
331 handle_target();
332 #endif
333 }
334
335 for (service = services; service; service = service->next)
336 {
337 /* handle new connections on listeners */
338 if ((service->fd != -1)
339 && (FD_ISSET(service->fd, &read_fds)))
340 {
341 if (service->max_connections > 0)
342 add_connection(service, command_context);
343 else
344 {
345 struct sockaddr_in sin;
346 unsigned int address_size = sizeof(sin);
347 int tmp_fd;
348 tmp_fd = accept(service->fd, (struct sockaddr *)&service->sin, &address_size);
349 close_socket(tmp_fd);
350 INFO("rejected '%s' connection, no more connections allowed", service->name);
351 }
352 }
353
354 /* handle activity on connections */
355 if (service->connections)
356 {
357 connection_t *c;
358
359 for (c = service->connections; c;)
360 {
361 if ((FD_ISSET(c->fd, &read_fds)) || c->input_pending)
362 {
363 if (service->input(c) != ERROR_OK)
364 {
365 connection_t *next = c->next;
366 remove_connection(service, c);
367 INFO("dropped '%s' connection", service->name);
368 c = next;
369 continue;
370 }
371 }
372 c = c->next;
373 }
374 }
375 }
376
377 #ifndef _WIN32
378 if (FD_ISSET(fileno(stdin), &read_fds))
379 {
380 if (getc(stdin) == 'x')
381 {
382 shutdown_openocd = 1;
383 }
384 }
385 #endif
386 }
387
388 return ERROR_OK;
389 }
390
391 #ifdef _WIN32
392 BOOL WINAPI ControlHandler(DWORD dwCtrlType)
393 {
394 shutdown_openocd = 1;
395 return TRUE;
396 }
397 #endif
398
399 int server_init()
400 {
401 #ifdef _WIN32
402 WORD wVersionRequested;
403 WSADATA wsaData;
404
405 wVersionRequested = MAKEWORD( 2, 2 );
406
407 if (WSAStartup(wVersionRequested, &wsaData) != 0)
408 {
409 ERROR("Failed to Open Winsock");
410 exit(-1);
411 }
412
413 SetConsoleCtrlHandler( ControlHandler, TRUE );
414 #endif
415
416
417 return ERROR_OK;
418 }
419
420 int server_quit()
421 {
422 remove_services();
423
424 #ifdef _WIN32
425 WSACleanup();
426 SetConsoleCtrlHandler( ControlHandler, FALSE );
427 #endif
428
429 return ERROR_OK;
430 }
431
432 int server_register_commands(command_context_t *context)
433 {
434 register_command(context, NULL, "shutdown", handle_shutdown_command,
435 COMMAND_ANY, "shut the server down");
436
437 return ERROR_OK;
438 }
439
440 /* tell the server we want to shut down */
441 int handle_shutdown_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
442 {
443 shutdown_openocd = 1;
444
445 return ERROR_COMMAND_CLOSE_CONNECTION;
446 }
447