server/server: Add ability to remove services
[openocd.git] / src / server / server.c
1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
4 * *
5 * Copyright (C) 2007-2010 √ėyvind Harboe *
6 * oyvind.harboe@zylin.com *
7 * *
8 * Copyright (C) 2008 by Spencer Oliver *
9 * spen@spen-soft.co.uk *
10 * *
11 * This program is free software; you can redistribute it and/or modify *
12 * it under the terms of the GNU General Public License as published by *
13 * the Free Software Foundation; either version 2 of the License, or *
14 * (at your option) any later version. *
15 * *
16 * This program is distributed in the hope that it will be useful, *
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
19 * GNU General Public License for more details. *
20 * *
21 * You should have received a copy of the GNU General Public License *
22 * along with this program. If not, see <http://www.gnu.org/licenses/>. *
23 ***************************************************************************/
24
25 #ifdef HAVE_CONFIG_H
26 #include "config.h"
27 #endif
28
29 #include "server.h"
30 #include <target/target.h>
31 #include <target/target_request.h>
32 #include <target/openrisc/jsp_server.h>
33 #include "openocd.h"
34 #include "tcl_server.h"
35 #include "telnet_server.h"
36
37 #include <signal.h>
38
39 #ifdef HAVE_NETDB_H
40 #include <netdb.h>
41 #endif
42
43 #ifndef _WIN32
44 #include <netinet/tcp.h>
45 #endif
46
47 static struct service *services;
48
49 enum shutdown_reason {
50 CONTINUE_MAIN_LOOP, /* stay in main event loop */
51 SHUTDOWN_REQUESTED, /* set by shutdown command; exit the event loop and quit the debugger */
52 SHUTDOWN_WITH_ERROR_CODE, /* set by shutdown command; quit with non-zero return code */
53 SHUTDOWN_WITH_SIGNAL_CODE /* set by sig_handler; exec shutdown then exit with signal as return code */
54 };
55 static enum shutdown_reason shutdown_openocd = CONTINUE_MAIN_LOOP;
56
57 /* store received signal to exit application by killing ourselves */
58 static int last_signal;
59
60 /* set the polling period to 100ms */
61 static int polling_period = 100;
62
63 /* address by name on which to listen for incoming TCP/IP connections */
64 static char *bindto_name;
65
66 static int add_connection(struct service *service, struct command_context *cmd_ctx)
67 {
68 socklen_t address_size;
69 struct connection *c, **p;
70 int retval;
71 int flag = 1;
72
73 c = malloc(sizeof(struct connection));
74 c->fd = -1;
75 c->fd_out = -1;
76 memset(&c->sin, 0, sizeof(c->sin));
77 c->cmd_ctx = copy_command_context(cmd_ctx);
78 c->service = service;
79 c->input_pending = 0;
80 c->priv = NULL;
81 c->next = NULL;
82
83 if (service->type == CONNECTION_TCP) {
84 address_size = sizeof(c->sin);
85
86 c->fd = accept(service->fd, (struct sockaddr *)&service->sin, &address_size);
87 c->fd_out = c->fd;
88
89 /* This increases performance dramatically for e.g. GDB load which
90 * does not have a sliding window protocol.
91 *
92 * Ignore errors from this fn as it probably just means less performance
93 */
94 setsockopt(c->fd, /* socket affected */
95 IPPROTO_TCP, /* set option at TCP level */
96 TCP_NODELAY, /* name of option */
97 (char *)&flag, /* the cast is historical cruft */
98 sizeof(int)); /* length of option value */
99
100 LOG_INFO("accepting '%s' connection on tcp/%s", service->name, service->port);
101 retval = service->new_connection(c);
102 if (retval != ERROR_OK) {
103 close_socket(c->fd);
104 LOG_ERROR("attempted '%s' connection rejected", service->name);
105 command_done(c->cmd_ctx);
106 free(c);
107 return retval;
108 }
109 } else if (service->type == CONNECTION_STDINOUT) {
110 c->fd = service->fd;
111 c->fd_out = fileno(stdout);
112
113 #ifdef _WIN32
114 /* we are using stdin/out so ignore ctrl-c under windoze */
115 SetConsoleCtrlHandler(NULL, TRUE);
116 #endif
117
118 /* do not check for new connections again on stdin */
119 service->fd = -1;
120
121 LOG_INFO("accepting '%s' connection from pipe", service->name);
122 retval = service->new_connection(c);
123 if (retval != ERROR_OK) {
124 LOG_ERROR("attempted '%s' connection rejected", service->name);
125 command_done(c->cmd_ctx);
126 free(c);
127 return retval;
128 }
129 } else if (service->type == CONNECTION_PIPE) {
130 c->fd = service->fd;
131 /* do not check for new connections again on stdin */
132 service->fd = -1;
133
134 char *out_file = alloc_printf("%so", service->port);
135 c->fd_out = open(out_file, O_WRONLY);
136 free(out_file);
137 if (c->fd_out == -1) {
138 LOG_ERROR("could not open %s", service->port);
139 command_done(c->cmd_ctx);
140 free(c);
141 return ERROR_FAIL;
142 }
143
144 LOG_INFO("accepting '%s' connection from pipe %s", service->name, service->port);
145 retval = service->new_connection(c);
146 if (retval != ERROR_OK) {
147 LOG_ERROR("attempted '%s' connection rejected", service->name);
148 command_done(c->cmd_ctx);
149 free(c);
150 return retval;
151 }
152 }
153
154 /* add to the end of linked list */
155 for (p = &service->connections; *p; p = &(*p)->next)
156 ;
157 *p = c;
158
159 if (service->max_connections != CONNECTION_LIMIT_UNLIMITED)
160 service->max_connections--;
161
162 return ERROR_OK;
163 }
164
165 static int remove_connection(struct service *service, struct connection *connection)
166 {
167 struct connection **p = &service->connections;
168 struct connection *c;
169
170 /* find connection */
171 while ((c = *p)) {
172 if (c->fd == connection->fd) {
173 service->connection_closed(c);
174 if (service->type == CONNECTION_TCP)
175 close_socket(c->fd);
176 else if (service->type == CONNECTION_PIPE) {
177 /* The service will listen to the pipe again */
178 c->service->fd = c->fd;
179 }
180
181 command_done(c->cmd_ctx);
182
183 /* delete connection */
184 *p = c->next;
185 free(c);
186
187 if (service->max_connections != CONNECTION_LIMIT_UNLIMITED)
188 service->max_connections++;
189
190 break;
191 }
192
193 /* redirect p to next list pointer */
194 p = &(*p)->next;
195 }
196
197 return ERROR_OK;
198 }
199
200 static void free_service(struct service *c)
201 {
202 free(c->name);
203 free(c->port);
204 free(c);
205 }
206
207 int add_service(char *name,
208 const char *port,
209 int max_connections,
210 new_connection_handler_t new_connection_handler,
211 input_handler_t input_handler,
212 connection_closed_handler_t connection_closed_handler,
213 void *priv)
214 {
215 struct service *c, **p;
216 struct hostent *hp;
217 int so_reuseaddr_option = 1;
218
219 c = malloc(sizeof(struct service));
220
221 c->name = strdup(name);
222 c->port = strdup(port);
223 c->max_connections = 1; /* Only TCP/IP ports can support more than one connection */
224 c->fd = -1;
225 c->connections = NULL;
226 c->new_connection = new_connection_handler;
227 c->input = input_handler;
228 c->connection_closed = connection_closed_handler;
229 c->priv = priv;
230 c->next = NULL;
231 long portnumber;
232 if (strcmp(c->port, "pipe") == 0)
233 c->type = CONNECTION_STDINOUT;
234 else {
235 char *end;
236 portnumber = strtol(c->port, &end, 0);
237 if (!*end && (parse_long(c->port, &portnumber) == ERROR_OK)) {
238 c->portnumber = portnumber;
239 c->type = CONNECTION_TCP;
240 } else
241 c->type = CONNECTION_PIPE;
242 }
243
244 if (c->type == CONNECTION_TCP) {
245 c->max_connections = max_connections;
246
247 c->fd = socket(AF_INET, SOCK_STREAM, 0);
248 if (c->fd == -1) {
249 LOG_ERROR("error creating socket: %s", strerror(errno));
250 free_service(c);
251 return ERROR_FAIL;
252 }
253
254 setsockopt(c->fd,
255 SOL_SOCKET,
256 SO_REUSEADDR,
257 (void *)&so_reuseaddr_option,
258 sizeof(int));
259
260 socket_nonblock(c->fd);
261
262 memset(&c->sin, 0, sizeof(c->sin));
263 c->sin.sin_family = AF_INET;
264
265 if (bindto_name == NULL)
266 c->sin.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
267 else {
268 hp = gethostbyname(bindto_name);
269 if (hp == NULL) {
270 LOG_ERROR("couldn't resolve bindto address: %s", bindto_name);
271 close_socket(c->fd);
272 free_service(c);
273 return ERROR_FAIL;
274 }
275 memcpy(&c->sin.sin_addr, hp->h_addr_list[0], hp->h_length);
276 }
277 c->sin.sin_port = htons(c->portnumber);
278
279 if (bind(c->fd, (struct sockaddr *)&c->sin, sizeof(c->sin)) == -1) {
280 LOG_ERROR("couldn't bind %s to socket on port %d: %s", name, c->portnumber, strerror(errno));
281 close_socket(c->fd);
282 free_service(c);
283 return ERROR_FAIL;
284 }
285
286 #ifndef _WIN32
287 int segsize = 65536;
288 setsockopt(c->fd, IPPROTO_TCP, TCP_MAXSEG, &segsize, sizeof(int));
289 #endif
290 int window_size = 128 * 1024;
291
292 /* These setsockopt()s must happen before the listen() */
293
294 setsockopt(c->fd, SOL_SOCKET, SO_SNDBUF,
295 (char *)&window_size, sizeof(window_size));
296 setsockopt(c->fd, SOL_SOCKET, SO_RCVBUF,
297 (char *)&window_size, sizeof(window_size));
298
299 if (listen(c->fd, 1) == -1) {
300 LOG_ERROR("couldn't listen on socket: %s", strerror(errno));
301 close_socket(c->fd);
302 free_service(c);
303 return ERROR_FAIL;
304 }
305
306 struct sockaddr_in addr_in;
307 addr_in.sin_port = 0;
308 socklen_t addr_in_size = sizeof(addr_in);
309 if (getsockname(c->fd, (struct sockaddr *)&addr_in, &addr_in_size) == 0)
310 LOG_INFO("Listening on port %hu for %s connections",
311 ntohs(addr_in.sin_port), name);
312 } else if (c->type == CONNECTION_STDINOUT) {
313 c->fd = fileno(stdin);
314
315 #ifdef _WIN32
316 /* for win32 set stdin/stdout to binary mode */
317 if (_setmode(_fileno(stdout), _O_BINARY) < 0)
318 LOG_WARNING("cannot change stdout mode to binary");
319 if (_setmode(_fileno(stdin), _O_BINARY) < 0)
320 LOG_WARNING("cannot change stdin mode to binary");
321 if (_setmode(_fileno(stderr), _O_BINARY) < 0)
322 LOG_WARNING("cannot change stderr mode to binary");
323 #else
324 socket_nonblock(c->fd);
325 #endif
326 } else if (c->type == CONNECTION_PIPE) {
327 #ifdef _WIN32
328 /* we currenty do not support named pipes under win32
329 * so exit openocd for now */
330 LOG_ERROR("Named pipes currently not supported under this os");
331 free_service(c);
332 return ERROR_FAIL;
333 #else
334 /* Pipe we're reading from */
335 c->fd = open(c->port, O_RDONLY | O_NONBLOCK);
336 if (c->fd == -1) {
337 LOG_ERROR("could not open %s", c->port);
338 free_service(c);
339 return ERROR_FAIL;
340 }
341 #endif
342 }
343
344 /* add to the end of linked list */
345 for (p = &services; *p; p = &(*p)->next)
346 ;
347 *p = c;
348
349 return ERROR_OK;
350 }
351
352 static void remove_connections(struct service *service)
353 {
354 struct connection *connection;
355
356 connection = service->connections;
357
358 while (connection) {
359 struct connection *tmp;
360
361 tmp = connection->next;
362 remove_connection(service, connection);
363 connection = tmp;
364 }
365 }
366
367 int remove_service(const char *name, const char *port)
368 {
369 struct service *tmp;
370 struct service *prev;
371
372 prev = services;
373
374 for (tmp = services; tmp; prev = tmp, tmp = tmp->next) {
375 if (!strcmp(tmp->name, name) && !strcmp(tmp->port, port)) {
376 remove_connections(tmp);
377
378 if (tmp == services)
379 services = tmp->next;
380 else
381 prev->next = tmp->next;
382
383 if (tmp->type != CONNECTION_STDINOUT)
384 close_socket(tmp->fd);
385
386 free(tmp->priv);
387 free_service(tmp);
388
389 return ERROR_OK;
390 }
391 }
392
393 return ERROR_OK;
394 }
395
396 static int remove_services(void)
397 {
398 struct service *c = services;
399
400 /* loop service */
401 while (c) {
402 struct service *next = c->next;
403
404 remove_connections(c);
405
406 if (c->name)
407 free(c->name);
408
409 if (c->type == CONNECTION_PIPE) {
410 if (c->fd != -1)
411 close(c->fd);
412 }
413 if (c->port)
414 free(c->port);
415
416 if (c->priv)
417 free(c->priv);
418
419 /* delete service */
420 free(c);
421
422 /* remember the last service for unlinking */
423 c = next;
424 }
425
426 services = NULL;
427
428 return ERROR_OK;
429 }
430
431 int server_loop(struct command_context *command_context)
432 {
433 struct service *service;
434
435 bool poll_ok = true;
436
437 /* used in select() */
438 fd_set read_fds;
439 int fd_max;
440
441 /* used in accept() */
442 int retval;
443
444 #ifndef _WIN32
445 if (signal(SIGPIPE, SIG_IGN) == SIG_ERR)
446 LOG_ERROR("couldn't set SIGPIPE to SIG_IGN");
447 #endif
448
449 while (shutdown_openocd == CONTINUE_MAIN_LOOP) {
450 /* monitor sockets for activity */
451 fd_max = 0;
452 FD_ZERO(&read_fds);
453
454 /* add service and connection fds to read_fds */
455 for (service = services; service; service = service->next) {
456 if (service->fd != -1) {
457 /* listen for new connections */
458 FD_SET(service->fd, &read_fds);
459
460 if (service->fd > fd_max)
461 fd_max = service->fd;
462 }
463
464 if (service->connections) {
465 struct connection *c;
466
467 for (c = service->connections; c; c = c->next) {
468 /* check for activity on the connection */
469 FD_SET(c->fd, &read_fds);
470 if (c->fd > fd_max)
471 fd_max = c->fd;
472 }
473 }
474 }
475
476 struct timeval tv;
477 tv.tv_sec = 0;
478 if (poll_ok) {
479 /* we're just polling this iteration, this is faster on embedded
480 * hosts */
481 tv.tv_usec = 0;
482 retval = socket_select(fd_max + 1, &read_fds, NULL, NULL, &tv);
483 } else {
484 /* Every 100ms, can be changed with "poll_period" command */
485 tv.tv_usec = polling_period * 1000;
486 /* Only while we're sleeping we'll let others run */
487 openocd_sleep_prelude();
488 kept_alive();
489 retval = socket_select(fd_max + 1, &read_fds, NULL, NULL, &tv);
490 openocd_sleep_postlude();
491 }
492
493 if (retval == -1) {
494 #ifdef _WIN32
495
496 errno = WSAGetLastError();
497
498 if (errno == WSAEINTR)
499 FD_ZERO(&read_fds);
500 else {
501 LOG_ERROR("error during select: %s", strerror(errno));
502 return ERROR_FAIL;
503 }
504 #else
505
506 if (errno == EINTR)
507 FD_ZERO(&read_fds);
508 else {
509 LOG_ERROR("error during select: %s", strerror(errno));
510 return ERROR_FAIL;
511 }
512 #endif
513 }
514
515 if (retval == 0) {
516 /* We only execute these callbacks when there was nothing to do or we timed
517 *out */
518 target_call_timer_callbacks();
519 process_jim_events(command_context);
520
521 FD_ZERO(&read_fds); /* eCos leaves read_fds unchanged in this case! */
522
523 /* We timed out/there was nothing to do, timeout rather than poll next time
524 **/
525 poll_ok = false;
526 } else {
527 /* There was something to do, next time we'll just poll */
528 poll_ok = true;
529 }
530
531 /* This is a simple back-off algorithm where we immediately
532 * re-poll if we did something this time around.
533 *
534 * This greatly improves performance of DCC.
535 */
536 poll_ok = poll_ok || target_got_message();
537
538 for (service = services; service; service = service->next) {
539 /* handle new connections on listeners */
540 if ((service->fd != -1)
541 && (FD_ISSET(service->fd, &read_fds))) {
542 if (service->max_connections != 0)
543 add_connection(service, command_context);
544 else {
545 if (service->type == CONNECTION_TCP) {
546 struct sockaddr_in sin;
547 socklen_t address_size = sizeof(sin);
548 int tmp_fd;
549 tmp_fd = accept(service->fd,
550 (struct sockaddr *)&service->sin,
551 &address_size);
552 close_socket(tmp_fd);
553 }
554 LOG_INFO(
555 "rejected '%s' connection, no more connections allowed",
556 service->name);
557 }
558 }
559
560 /* handle activity on connections */
561 if (service->connections) {
562 struct connection *c;
563
564 for (c = service->connections; c; ) {
565 if ((FD_ISSET(c->fd, &read_fds)) || c->input_pending) {
566 retval = service->input(c);
567 if (retval != ERROR_OK) {
568 struct connection *next = c->next;
569 if (service->type == CONNECTION_PIPE ||
570 service->type == CONNECTION_STDINOUT) {
571 /* if connection uses a pipe then
572 * shutdown openocd on error */
573 shutdown_openocd = SHUTDOWN_REQUESTED;
574 }
575 remove_connection(service, c);
576 LOG_INFO("dropped '%s' connection",
577 service->name);
578 c = next;
579 continue;
580 }
581 }
582 c = c->next;
583 }
584 }
585 }
586
587 #ifdef _WIN32
588 MSG msg;
589 while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
590 if (msg.message == WM_QUIT)
591 shutdown_openocd = SHUTDOWN_WITH_SIGNAL_CODE;
592 }
593 #endif
594 }
595
596 /* when quit for signal or CTRL-C, run (eventually user implemented) "shutdown" */
597 if (shutdown_openocd == SHUTDOWN_WITH_SIGNAL_CODE)
598 command_run_line(command_context, "shutdown");
599
600 return shutdown_openocd == SHUTDOWN_WITH_ERROR_CODE ? ERROR_FAIL : ERROR_OK;
601 }
602
603 void sig_handler(int sig)
604 {
605 /* store only first signal that hits us */
606 if (shutdown_openocd == CONTINUE_MAIN_LOOP) {
607 shutdown_openocd = SHUTDOWN_WITH_SIGNAL_CODE;
608 last_signal = sig;
609 LOG_DEBUG("Terminating on Signal %d", sig);
610 } else
611 LOG_DEBUG("Ignored extra Signal %d", sig);
612 }
613
614
615 #ifdef _WIN32
616 BOOL WINAPI ControlHandler(DWORD dwCtrlType)
617 {
618 shutdown_openocd = SHUTDOWN_WITH_SIGNAL_CODE;
619 return TRUE;
620 }
621 #else
622 static void sigkey_handler(int sig)
623 {
624 /* ignore keystroke generated signals if not in foreground process group */
625
626 if (tcgetpgrp(STDIN_FILENO) > 0)
627 sig_handler(sig);
628 else
629 LOG_DEBUG("Ignored Signal %d", sig);
630 }
631 #endif
632
633
634 int server_preinit(void)
635 {
636 /* this currently only calls WSAStartup on native win32 systems
637 * before any socket operations are performed.
638 * This is an issue if you call init in your config script */
639
640 #ifdef _WIN32
641 WORD wVersionRequested;
642 WSADATA wsaData;
643
644 wVersionRequested = MAKEWORD(2, 2);
645
646 if (WSAStartup(wVersionRequested, &wsaData) != 0) {
647 LOG_ERROR("Failed to Open Winsock");
648 return ERROR_FAIL;
649 }
650
651 /* register ctrl-c handler */
652 SetConsoleCtrlHandler(ControlHandler, TRUE);
653
654 signal(SIGBREAK, sig_handler);
655 signal(SIGINT, sig_handler);
656 #else
657 signal(SIGHUP, sig_handler);
658 signal(SIGPIPE, sig_handler);
659 signal(SIGQUIT, sigkey_handler);
660 signal(SIGINT, sigkey_handler);
661 #endif
662 signal(SIGTERM, sig_handler);
663 signal(SIGABRT, sig_handler);
664
665 return ERROR_OK;
666 }
667
668 int server_init(struct command_context *cmd_ctx)
669 {
670 int ret = tcl_init();
671
672 if (ret != ERROR_OK)
673 return ret;
674
675 ret = telnet_init("Open On-Chip Debugger");
676
677 if (ret != ERROR_OK) {
678 remove_services();
679 return ret;
680 }
681
682 return ERROR_OK;
683 }
684
685 int server_quit(void)
686 {
687 remove_services();
688 target_quit();
689
690 #ifdef _WIN32
691 WSACleanup();
692 SetConsoleCtrlHandler(ControlHandler, FALSE);
693
694 return ERROR_OK;
695 #endif
696
697 /* return signal number so we can kill ourselves */
698 return last_signal;
699 }
700
701 void server_free(void)
702 {
703 tcl_service_free();
704 telnet_service_free();
705 jsp_service_free();
706 }
707
708 void exit_on_signal(int sig)
709 {
710 #ifndef _WIN32
711 /* bring back default system handler and kill yourself */
712 signal(sig, SIG_DFL);
713 kill(getpid(), sig);
714 #endif
715 }
716
717 int connection_write(struct connection *connection, const void *data, int len)
718 {
719 if (len == 0) {
720 /* successful no-op. Sockets and pipes behave differently here... */
721 return 0;
722 }
723 if (connection->service->type == CONNECTION_TCP)
724 return write_socket(connection->fd_out, data, len);
725 else
726 return write(connection->fd_out, data, len);
727 }
728
729 int connection_read(struct connection *connection, void *data, int len)
730 {
731 if (connection->service->type == CONNECTION_TCP)
732 return read_socket(connection->fd, data, len);
733 else
734 return read(connection->fd, data, len);
735 }
736
737 /* tell the server we want to shut down */
738 COMMAND_HANDLER(handle_shutdown_command)
739 {
740 LOG_USER("shutdown command invoked");
741
742 shutdown_openocd = SHUTDOWN_REQUESTED;
743
744 if (CMD_ARGC == 1) {
745 if (!strcmp(CMD_ARGV[0], "error")) {
746 shutdown_openocd = SHUTDOWN_WITH_ERROR_CODE;
747 return ERROR_FAIL;
748 }
749 }
750
751 return ERROR_COMMAND_CLOSE_CONNECTION;
752 }
753
754 COMMAND_HANDLER(handle_poll_period_command)
755 {
756 if (CMD_ARGC == 0)
757 LOG_WARNING("You need to set a period value");
758 else
759 COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], polling_period);
760
761 LOG_INFO("set servers polling period to %ums", polling_period);
762
763 return ERROR_OK;
764 }
765
766 COMMAND_HANDLER(handle_bindto_command)
767 {
768 switch (CMD_ARGC) {
769 case 0:
770 command_print(CMD_CTX, "bindto name: %s", bindto_name);
771 break;
772 case 1:
773 free(bindto_name);
774 bindto_name = strdup(CMD_ARGV[0]);
775 break;
776 default:
777 return ERROR_COMMAND_SYNTAX_ERROR;
778 }
779 return ERROR_OK;
780 }
781
782 static const struct command_registration server_command_handlers[] = {
783 {
784 .name = "shutdown",
785 .handler = &handle_shutdown_command,
786 .mode = COMMAND_ANY,
787 .usage = "",
788 .help = "shut the server down",
789 },
790 {
791 .name = "poll_period",
792 .handler = &handle_poll_period_command,
793 .mode = COMMAND_ANY,
794 .usage = "",
795 .help = "set the servers polling period",
796 },
797 {
798 .name = "bindto",
799 .handler = &handle_bindto_command,
800 .mode = COMMAND_ANY,
801 .usage = "[name]",
802 .help = "Specify address by name on which to listen for "
803 "incoming TCP/IP connections",
804 },
805 COMMAND_REGISTRATION_DONE
806 };
807
808 int server_register_commands(struct command_context *cmd_ctx)
809 {
810 int retval = telnet_register_commands(cmd_ctx);
811 if (ERROR_OK != retval)
812 return retval;
813
814 retval = tcl_register_commands(cmd_ctx);
815 if (ERROR_OK != retval)
816 return retval;
817
818 retval = jsp_register_commands(cmd_ctx);
819 if (ERROR_OK != retval)
820 return retval;
821
822 return register_commands(cmd_ctx, NULL, server_command_handlers);
823 }
824
825 COMMAND_HELPER(server_port_command, unsigned short *out)
826 {
827 switch (CMD_ARGC) {
828 case 0:
829 command_print(CMD_CTX, "%d", *out);
830 break;
831 case 1:
832 {
833 uint16_t port;
834 COMMAND_PARSE_NUMBER(u16, CMD_ARGV[0], port);
835 *out = port;
836 break;
837 }
838 default:
839 return ERROR_COMMAND_SYNTAX_ERROR;
840 }
841 return ERROR_OK;
842 }
843
844 COMMAND_HELPER(server_pipe_command, char **out)
845 {
846 switch (CMD_ARGC) {
847 case 0:
848 command_print(CMD_CTX, "%s", *out);
849 break;
850 case 1:
851 {
852 if (CMD_CTX->mode == COMMAND_EXEC) {
853 LOG_WARNING("unable to change server port after init");
854 return ERROR_COMMAND_ARGUMENT_INVALID;
855 }
856 free(*out);
857 *out = strdup(CMD_ARGV[0]);
858 break;
859 }
860 default:
861 return ERROR_COMMAND_SYNTAX_ERROR;
862 }
863 return ERROR_OK;
864 }