server: fix small mem leak of bindto_name
[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 free(bindto_name);
708 }
709
710 void exit_on_signal(int sig)
711 {
712 #ifndef _WIN32
713 /* bring back default system handler and kill yourself */
714 signal(sig, SIG_DFL);
715 kill(getpid(), sig);
716 #endif
717 }
718
719 int connection_write(struct connection *connection, const void *data, int len)
720 {
721 if (len == 0) {
722 /* successful no-op. Sockets and pipes behave differently here... */
723 return 0;
724 }
725 if (connection->service->type == CONNECTION_TCP)
726 return write_socket(connection->fd_out, data, len);
727 else
728 return write(connection->fd_out, data, len);
729 }
730
731 int connection_read(struct connection *connection, void *data, int len)
732 {
733 if (connection->service->type == CONNECTION_TCP)
734 return read_socket(connection->fd, data, len);
735 else
736 return read(connection->fd, data, len);
737 }
738
739 /* tell the server we want to shut down */
740 COMMAND_HANDLER(handle_shutdown_command)
741 {
742 LOG_USER("shutdown command invoked");
743
744 shutdown_openocd = SHUTDOWN_REQUESTED;
745
746 if (CMD_ARGC == 1) {
747 if (!strcmp(CMD_ARGV[0], "error")) {
748 shutdown_openocd = SHUTDOWN_WITH_ERROR_CODE;
749 return ERROR_FAIL;
750 }
751 }
752
753 return ERROR_COMMAND_CLOSE_CONNECTION;
754 }
755
756 COMMAND_HANDLER(handle_poll_period_command)
757 {
758 if (CMD_ARGC == 0)
759 LOG_WARNING("You need to set a period value");
760 else
761 COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], polling_period);
762
763 LOG_INFO("set servers polling period to %ums", polling_period);
764
765 return ERROR_OK;
766 }
767
768 COMMAND_HANDLER(handle_bindto_command)
769 {
770 switch (CMD_ARGC) {
771 case 0:
772 command_print(CMD_CTX, "bindto name: %s", bindto_name);
773 break;
774 case 1:
775 free(bindto_name);
776 bindto_name = strdup(CMD_ARGV[0]);
777 break;
778 default:
779 return ERROR_COMMAND_SYNTAX_ERROR;
780 }
781 return ERROR_OK;
782 }
783
784 static const struct command_registration server_command_handlers[] = {
785 {
786 .name = "shutdown",
787 .handler = &handle_shutdown_command,
788 .mode = COMMAND_ANY,
789 .usage = "",
790 .help = "shut the server down",
791 },
792 {
793 .name = "poll_period",
794 .handler = &handle_poll_period_command,
795 .mode = COMMAND_ANY,
796 .usage = "",
797 .help = "set the servers polling period",
798 },
799 {
800 .name = "bindto",
801 .handler = &handle_bindto_command,
802 .mode = COMMAND_ANY,
803 .usage = "[name]",
804 .help = "Specify address by name on which to listen for "
805 "incoming TCP/IP connections",
806 },
807 COMMAND_REGISTRATION_DONE
808 };
809
810 int server_register_commands(struct command_context *cmd_ctx)
811 {
812 int retval = telnet_register_commands(cmd_ctx);
813 if (ERROR_OK != retval)
814 return retval;
815
816 retval = tcl_register_commands(cmd_ctx);
817 if (ERROR_OK != retval)
818 return retval;
819
820 retval = jsp_register_commands(cmd_ctx);
821 if (ERROR_OK != retval)
822 return retval;
823
824 return register_commands(cmd_ctx, NULL, server_command_handlers);
825 }
826
827 COMMAND_HELPER(server_port_command, unsigned short *out)
828 {
829 switch (CMD_ARGC) {
830 case 0:
831 command_print(CMD_CTX, "%d", *out);
832 break;
833 case 1:
834 {
835 uint16_t port;
836 COMMAND_PARSE_NUMBER(u16, CMD_ARGV[0], port);
837 *out = port;
838 break;
839 }
840 default:
841 return ERROR_COMMAND_SYNTAX_ERROR;
842 }
843 return ERROR_OK;
844 }
845
846 COMMAND_HELPER(server_pipe_command, char **out)
847 {
848 switch (CMD_ARGC) {
849 case 0:
850 command_print(CMD_CTX, "%s", *out);
851 break;
852 case 1:
853 {
854 if (CMD_CTX->mode == COMMAND_EXEC) {
855 LOG_WARNING("unable to change server port after init");
856 return ERROR_COMMAND_ARGUMENT_INVALID;
857 }
858 free(*out);
859 *out = strdup(CMD_ARGV[0]);
860 break;
861 }
862 default:
863 return ERROR_COMMAND_SYNTAX_ERROR;
864 }
865 return ERROR_OK;
866 }

Linking to existing account procedure

If you already have an account and want to add another login method you MUST first sign in with your existing account and then change URL to read https://review.openocd.org/login/?link to get to this page again but this time it'll work for linking. Thank you.

SSH host keys fingerprints

1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=..              |
|+o..   .         |
|*.o   . .        |
|+B . . .         |
|Bo. = o S        |
|Oo.+ + =         |
|oB=.* = . o      |
| =+=.+   + E     |
|. .=o   . o      |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)