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

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)