server.c 12.5 KB
Newer Older
1
2
3
4
/***************************************************************************
 *   Copyright (C) 2005 by Dominic Rath                                    *
 *   Dominic.Rath@gmx.de                                                   *
 *                                                                         *
5
 *   Copyright (C) 2007,2008 Øyvind Harboe                                 *
6
7
 *   oyvind.harboe@zylin.com                                               *
 *                                                                         *
8
9
10
 *   Copyright (C) 2008 by Spencer Oliver                                  *
 *   spen@spen-soft.co.uk                                                  *
 *                                                                         *
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "server.h"
#include "target.h"

#include <signal.h>
34

35
36
37
#ifndef _WIN32
#include <netinet/tcp.h>
#endif
38

39

40
41
42
43
44
45
service_t *services = NULL;

/* shutdown_openocd == 1: exit the main event loop, and quit the debugger */
static int shutdown_openocd = 0;
int handle_shutdown_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);

46
47
48
/* set when using pipes rather than tcp */
int server_use_pipes = 0;

49
50
int add_connection(service_t *service, command_context_t *cmd_ctx)
{
51
	socklen_t address_size;
52
53
	connection_t *c, **p;
	int retval;
zwelch's avatar
zwelch committed
54
	int flag = 1;
55

56
57
58
59
60
61
62
63
64
	c = malloc(sizeof(connection_t));
	c->fd = -1;
	memset(&c->sin, 0, sizeof(c->sin));
	c->cmd_ctx = copy_command_context(cmd_ctx);
	c->service = service;
	c->input_pending = 0;
	c->priv = NULL;
	c->next = NULL;

65
	if (service->type == CONNECTION_TCP)
66
	{
67
		address_size = sizeof(c->sin);
68

69
		c->fd = accept(service->fd, (struct sockaddr *)&service->sin, &address_size);
70

71
72
		/* This increases performance dramatically for e.g. GDB load which
		 * does not have a sliding window protocol. */
zwelch's avatar
zwelch committed
73
		retval = setsockopt(c->fd,	/* socket affected */
74
75
76
77
				IPPROTO_TCP,		/* set option at TCP level */
				TCP_NODELAY,		/* name of option */
				(char *)&flag,		/* the cast is historical cruft */
				sizeof(int));		/* length of option value */
78

79
80
81
82
83
84
85
86
		LOG_INFO("accepting '%s' connection from %i", service->name, c->sin.sin_port);
		if ((retval = service->new_connection(c)) != ERROR_OK)
		{
			close_socket(c->fd);
			LOG_ERROR("attempted '%s' connection rejected", service->name);
			free(c);
			return retval;
		}
87
	}
88
	else if (service->type == CONNECTION_PIPE)
89
	{
90
		c->fd = service->fd;
91

92
93
		/* do not check for new connections again on stdin */
		service->fd = -1;
94

95
96
97
98
99
100
101
		LOG_INFO("accepting '%s' connection from pipe", service->name);
		if ((retval = service->new_connection(c)) != ERROR_OK)
		{
			LOG_ERROR("attempted '%s' connection rejected", service->name);
			free(c);
			return retval;
		}
102
	}
103

104
105
106
	/* add to the end of linked list */
	for (p = &service->connections; *p; p = &(*p)->next);
	*p = c;
107

108
	service->max_connections--;
109

110
111
112
113
114
115
116
	return ERROR_OK;
}

int remove_connection(service_t *service, connection_t *connection)
{
	connection_t **p = &service->connections;
	connection_t *c;
117

118
	/* find connection */
zwelch's avatar
zwelch committed
119
	while ((c = *p))
120
	{
121
		if (c->fd == connection->fd)
122
		{
123
			service->connection_closed(c);
124
125
			if (service->type == CONNECTION_TCP)
				close_socket(c->fd);
126
			command_done(c->cmd_ctx);
127

128
129
130
			/* delete connection */
			*p = c->next;
			free(c);
131

132
133
134
			service->max_connections++;
			break;
		}
135

136
		/* redirect p to next list pointer */
137
		p = &(*p)->next;
138
	}
139

140
141
142
143
144
145
146
	return ERROR_OK;
}

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)
{
	service_t *c, **p;
	int so_reuseaddr_option = 1;
147

148
	c = malloc(sizeof(service_t));
149

150
151
152
153
154
155
156
157
158
159
160
	c->name = strdup(name);
	c->type = type;
	c->port = port;
	c->max_connections = max_connections;
	c->fd = -1;
	c->connections = NULL;
	c->new_connection = new_connection_handler;
	c->input = input_handler;
	c->connection_closed = connection_closed_handler;
	c->priv = priv;
	c->next = NULL;
161

162
	if (type == CONNECTION_TCP)
163
	{
164
165
166
167
168
		if ((c->fd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
		{
			LOG_ERROR("error creating socket: %s", strerror(errno));
			exit(-1);
		}
169

170
		setsockopt(c->fd, SOL_SOCKET, SO_REUSEADDR, (void*)&so_reuseaddr_option, sizeof(int));
171

172
		socket_nonblock(c->fd);
173

174
175
176
177
		memset(&c->sin, 0, sizeof(c->sin));
		c->sin.sin_family = AF_INET;
		c->sin.sin_addr.s_addr = INADDR_ANY;
		c->sin.sin_port = htons(port);
178

179
180
181
182
183
		if (bind(c->fd, (struct sockaddr *)&c->sin, sizeof(c->sin)) == -1)
		{
			LOG_ERROR("couldn't bind to socket: %s", strerror(errno));
			exit(-1);
		}
184

185
#ifndef _WIN32
zwelch's avatar
zwelch committed
186
		int segsize = 65536;
187
		setsockopt(c->fd, IPPROTO_TCP, TCP_MAXSEG,  &segsize, sizeof(int));
188
#endif
189
190
		int window_size = 128 * 1024;

191
		/* These setsockopt()s must happen before the listen() */
192

193
194
195
196
		setsockopt(c->fd, SOL_SOCKET, SO_SNDBUF,
			(char *)&window_size, sizeof(window_size));
		setsockopt(c->fd, SOL_SOCKET, SO_RCVBUF,
			(char *)&window_size, sizeof(window_size));
197

198
199
200
201
202
203
204
		if (listen(c->fd, 1) == -1)
		{
			LOG_ERROR("couldn't listen on socket: %s", strerror(errno));
			exit(-1);
		}
	}
	else if (type == CONNECTION_PIPE)
205
	{
206
207
		/* use stdin */
		c->fd = STDIN_FILENO;
208

209
210
211
212
213
214
#ifdef _WIN32
		/* for win32 set stdin/stdout to binary mode */
		if (_setmode(_fileno(stdout), _O_BINARY) < 0)
			LOG_WARNING("cannot change stdout mode to binary");
		if (_setmode(_fileno(stdin), _O_BINARY) < 0)
			LOG_WARNING("cannot change stdin mode to binary");
215
216
		if (_setmode(_fileno(stderr), _O_BINARY) < 0)
			LOG_WARNING("cannot change stderr mode to binary");
217
218
219
220
221
222
223
224
#else
		socket_nonblock(c->fd);
#endif
	}
	else
	{
		LOG_ERROR("unknown connection type: %d", type);
		exit(1);
225
	}
226

227
228
229
	/* add to the end of linked list */
	for (p = &services; *p; p = &(*p)->next);
	*p = c;
230

231
232
233
234
235
236
237
	return ERROR_OK;
}

int remove_service(unsigned short port)
{
	service_t **p = &services;
	service_t *c;
238

239
	/* find service */
zwelch's avatar
zwelch committed
240
	while ((c = *p))
241
	{
242
		if (c->port == port)
243
		{
244
245
			if (c->name)
				free(c->name);
246

247
248
			if (c->priv)
				free(c->priv);
249

250
251
252
253
254
255
256
257
			/* delete service */
			*p = c->next;
			free(c);
		}

		/* redirect p to next list pointer */
		p = &(*p)->next;
	}
258

259
260
261
	return ERROR_OK;
}

oharboe's avatar
oharboe committed
262
int remove_services(void)
263
264
265
266
{
	service_t *c = services;

	/* loop service */
zwelch's avatar
zwelch committed
267
	while (c)
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
	{
		service_t *next = c->next;

		if (c->name)
			free(c->name);

		if (c->priv)
			free(c->priv);

		/* delete service */
		free(c);

		/* remember the last service for unlinking */
		c = next;
	}

	services = NULL;
285

286
287
288
	return ERROR_OK;
}

oharboe's avatar
oharboe committed
289
290
extern void openocd_sleep_prelude(void);
extern void openocd_sleep_postlude(void);
291

292
293
294
295
296
297
298
299
int server_loop(command_context_t *command_context)
{
	service_t *service;

	/* used in select() */
	fd_set read_fds;
	struct timeval tv;
	int fd_max;
300

301
302
	/* used in accept() */
	int retval;
303

304
305
#ifndef _WIN32
	if (signal(SIGPIPE, SIG_IGN) == SIG_ERR)
306
		LOG_ERROR("couldn't set SIGPIPE to SIG_IGN");
307
#endif
308

309
310
311
	/* do regular tasks after at most 10ms */
	tv.tv_sec = 0;
	tv.tv_usec = 10000;
312

zwelch's avatar
zwelch committed
313
	while (!shutdown_openocd)
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
	{
		/* monitor sockets for acitvity */
		fd_max = 0;
		FD_ZERO(&read_fds);

		/* add service and connection fds to read_fds */
		for (service = services; service; service = service->next)
		{
			if (service->fd != -1)
			{
				/* listen for new connections */
				FD_SET(service->fd, &read_fds);

				if (service->fd > fd_max)
					fd_max = service->fd;
			}
330

331
332
333
			if (service->connections)
			{
				connection_t *c;
334

335
336
337
338
339
340
341
342
343
				for (c = service->connections; c; c = c->next)
				{
					/* check for activity on the connection */
					FD_SET(c->fd, &read_fds);
					if (c->fd > fd_max)
						fd_max = c->fd;
				}
			}
		}
344

345
#ifndef _WIN32
346
#if BUILD_ECOSBOARD == 0
347
348
349
350
351
		if (server_use_pipes == 0)
		{
			/* add STDIN to read_fds */
			FD_SET(fileno(stdin), &read_fds);
		}
352
#endif
353
354
#endif

355
		openocd_sleep_prelude();
356
		kept_alive();
357

358
		/* Only while we're sleeping we'll let others run */
359
		retval = socket_select(fd_max + 1, &read_fds, NULL, NULL, &tv);
360
		openocd_sleep_postlude();
361

362
363
364
365
366
367
368
369
370
371
		if (retval == -1)
		{
#ifdef _WIN32

			errno = WSAGetLastError();

			if (errno == WSAEINTR)
				FD_ZERO(&read_fds);
			else
			{
372
				LOG_ERROR("error during select: %s", strerror(errno));
373
374
375
376
377
378
379
380
381
382
				exit(-1);
			}
#else

			if (errno == EINTR)
			{
				FD_ZERO(&read_fds);
			}
			else
			{
383
				LOG_ERROR("error during select: %s", strerror(errno));
384
385
386
387
				exit(-1);
			}
#endif
		}
388

389
		target_call_timer_callbacks();
390
		process_jim_events ();
391
392
393
394
395
396
397
398

		if (retval == 0)
		{
			/* do regular tasks after at most 100ms */
			tv.tv_sec = 0;
			tv.tv_usec = 10000;
			FD_ZERO(&read_fds); /* eCos leaves read_fds unchanged in this case!  */
		}
399

400
401
402
		for (service = services; service; service = service->next)
		{
			/* handle new connections on listeners */
403
404
			if ((service->fd != -1)
				&& (FD_ISSET(service->fd, &read_fds)))
405
406
407
408
409
410
411
			{
				if (service->max_connections > 0)
				{
					add_connection(service, command_context);
				}
				else
				{
412
413
414
					if (service->type != CONNECTION_PIPE)
					{
						struct sockaddr_in sin;
415
						socklen_t address_size = sizeof(sin);
416
417
418
419
						int tmp_fd;
						tmp_fd = accept(service->fd, (struct sockaddr *)&service->sin, &address_size);
						close_socket(tmp_fd);
					}
420
					LOG_INFO("rejected '%s' connection, no more connections allowed", service->name);
421
422
				}
			}
423

424
425
426
427
			/* handle activity on connections */
			if (service->connections)
			{
				connection_t *c;
428

429
430
431
432
				for (c = service->connections; c;)
				{
					if ((FD_ISSET(c->fd, &read_fds)) || c->input_pending)
					{
433
						if ((retval = service->input(c)) != ERROR_OK)
434
435
						{
							connection_t *next = c->next;
436
437
438
439
440
							if (service->type == CONNECTION_PIPE)
							{
								/* if connection uses a pipe then shutdown openocd on error */
								shutdown_openocd = 1;
							}
441
							remove_connection(service, c);
442
							LOG_INFO("dropped '%s' connection - error %d", service->name, retval);
443
444
445
446
447
448
449
450
							c = next;
							continue;
						}
					}
					c = c->next;
				}
			}
		}
451

452
#ifndef _WIN32
453
#if BUILD_ECOSBOARD == 0
454
455
		/* check for data on stdin if not using pipes */
		if (server_use_pipes == 0)
456
		{
457
			if (FD_ISSET(fileno(stdin), &read_fds))
458
			{
459
460
461
462
				if (getc(stdin) == 'x')
				{
					shutdown_openocd = 1;
				}
463
464
			}
		}
465
#endif
466
467
468
469
470
471
472
473
474
#else
		MSG msg;
		while (PeekMessage(&msg,NULL,0,0,PM_REMOVE))
		{
			if (msg.message == WM_QUIT)
				shutdown_openocd = 1;
		}
#endif
	}
475

476
477
478
479
480
481
	return ERROR_OK;
}

#ifdef _WIN32
BOOL WINAPI ControlHandler(DWORD dwCtrlType)
{
482
483
	shutdown_openocd = 1;
	return TRUE;
484
485
486
}

void sig_handler(int sig) {
487
	shutdown_openocd = 1;
488
489
490
}
#endif

oharboe's avatar
oharboe committed
491
int server_init(void)
492
493
494
495
496
{
#ifdef _WIN32
	WORD wVersionRequested;
	WSADATA wsaData;

497
	wVersionRequested = MAKEWORD(2, 2);
498
499
500

	if (WSAStartup(wVersionRequested, &wsaData) != 0)
	{
501
		LOG_ERROR("Failed to Open Winsock");
502
503
504
		exit(-1);
	}

505
506
507
508
509
510
511
512
513
514
	if (server_use_pipes == 0)
	{
		/* register ctrl-c handler */
		SetConsoleCtrlHandler(ControlHandler, TRUE);
	}
	else
	{
		/* we are using pipes so ignore ctrl-c */
		SetConsoleCtrlHandler(NULL, TRUE);
	}
515
516
517
518
519
520

	signal(SIGINT, sig_handler);
	signal(SIGTERM, sig_handler);
	signal(SIGBREAK, sig_handler);
	signal(SIGABRT, sig_handler);
#endif
521

522
523
524
	return ERROR_OK;
}

oharboe's avatar
oharboe committed
525
int server_quit(void)
526
527
528
529
530
{
	remove_services();

#ifdef _WIN32
	WSACleanup();
531
	SetConsoleCtrlHandler(ControlHandler, FALSE);
532
533
534
535
536
537
538
539
540
#endif

	return ERROR_OK;
}

int server_register_commands(command_context_t *context)
{
	register_command(context, NULL, "shutdown", handle_shutdown_command,
					 COMMAND_ANY, "shut the server down");
541

542
543
544
545
546
547
548
549
550
551
	return ERROR_OK;
}

/* tell the server we want to shut down */
int handle_shutdown_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
{
	shutdown_openocd = 1;

	return ERROR_COMMAND_CLOSE_CONNECTION;
}