sync with latest
[sdk/emulator/qemu.git] / qemu-sockets.c
1 /*
2  *  inet and unix socket functions for qemu
3  *
4  *  (c) 2008 Gerd Hoffmann <kraxel@redhat.com>
5  *
6  *  This program is free software; you can redistribute it and/or modify
7  *  it under the terms of the GNU General Public License as published by
8  *  the Free Software Foundation; under version 2 of the License.
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  * Contributions after 2012-01-13 are licensed under the terms of the
16  * GNU GPL, version 2 or (at your option) any later version.
17  */
18 #include <stdio.h>
19 #include <stdlib.h>
20 #include <string.h>
21 #include <ctype.h>
22 #include <errno.h>
23 #include <unistd.h>
24
25 #include "qemu_socket.h"
26 #include "qemu-common.h" /* for qemu_isdigit */
27
28 #ifndef AI_ADDRCONFIG
29 # define AI_ADDRCONFIG 0
30 #endif
31
32 static const int on=1, off=0;
33
34 /* used temporarely until all users are converted to QemuOpts */
35 static QemuOptsList dummy_opts = {
36     .name = "dummy",
37     .head = QTAILQ_HEAD_INITIALIZER(dummy_opts.head),
38     .desc = {
39         {
40             .name = "path",
41             .type = QEMU_OPT_STRING,
42         },{
43             .name = "host",
44             .type = QEMU_OPT_STRING,
45         },{
46             .name = "port",
47             .type = QEMU_OPT_STRING,
48         },{
49             .name = "to",
50             .type = QEMU_OPT_NUMBER,
51         },{
52             .name = "ipv4",
53             .type = QEMU_OPT_BOOL,
54         },{
55             .name = "ipv6",
56             .type = QEMU_OPT_BOOL,
57         },{
58             .name = "block",
59             .type = QEMU_OPT_BOOL,
60         },
61         { /* end if list */ }
62     },
63 };
64
65 static int inet_getport(struct addrinfo *e)
66 {
67     struct sockaddr_in *i4;
68     struct sockaddr_in6 *i6;
69
70     switch (e->ai_family) {
71     case PF_INET6:
72         i6 = (void*)e->ai_addr;
73         return ntohs(i6->sin6_port);
74     case PF_INET:
75         i4 = (void*)e->ai_addr;
76         return ntohs(i4->sin_port);
77     default:
78         return 0;
79     }
80 }
81
82 static void inet_setport(struct addrinfo *e, int port)
83 {
84     struct sockaddr_in *i4;
85     struct sockaddr_in6 *i6;
86
87     switch (e->ai_family) {
88     case PF_INET6:
89         i6 = (void*)e->ai_addr;
90         i6->sin6_port = htons(port);
91         break;
92     case PF_INET:
93         i4 = (void*)e->ai_addr;
94         i4->sin_port = htons(port);
95         break;
96     }
97 }
98
99 const char *inet_strfamily(int family)
100 {
101     switch (family) {
102     case PF_INET6: return "ipv6";
103     case PF_INET:  return "ipv4";
104     case PF_UNIX:  return "unix";
105     }
106     return "unknown";
107 }
108
109 int inet_listen_opts(QemuOpts *opts, int port_offset, Error **errp)
110 {
111     struct addrinfo ai,*res,*e;
112     const char *addr;
113     char port[33];
114     char uaddr[INET6_ADDRSTRLEN+1];
115     char uport[33];
116     int slisten, rc, to, port_min, port_max, p;
117
118     memset(&ai,0, sizeof(ai));
119     ai.ai_flags = AI_PASSIVE | AI_ADDRCONFIG;
120     ai.ai_family = PF_UNSPEC;
121     ai.ai_socktype = SOCK_STREAM;
122
123     if ((qemu_opt_get(opts, "host") == NULL) ||
124         (qemu_opt_get(opts, "port") == NULL)) {
125         fprintf(stderr, "%s: host and/or port not specified\n", __FUNCTION__);
126         error_set(errp, QERR_SOCKET_CREATE_FAILED);
127         return -1;
128     }
129     pstrcpy(port, sizeof(port), qemu_opt_get(opts, "port"));
130     addr = qemu_opt_get(opts, "host");
131
132     to = qemu_opt_get_number(opts, "to", 0);
133     if (qemu_opt_get_bool(opts, "ipv4", 0))
134         ai.ai_family = PF_INET;
135     if (qemu_opt_get_bool(opts, "ipv6", 0))
136         ai.ai_family = PF_INET6;
137
138     /* lookup */
139     if (port_offset)
140         snprintf(port, sizeof(port), "%d", atoi(port) + port_offset);
141     rc = getaddrinfo(strlen(addr) ? addr : NULL, port, &ai, &res);
142     if (rc != 0) {
143         fprintf(stderr,"getaddrinfo(%s,%s): %s\n", addr, port,
144                 gai_strerror(rc));
145         error_set(errp, QERR_SOCKET_CREATE_FAILED);
146         return -1;
147     }
148
149     /* create socket + bind */
150     for (e = res; e != NULL; e = e->ai_next) {
151         getnameinfo((struct sockaddr*)e->ai_addr,e->ai_addrlen,
152                         uaddr,INET6_ADDRSTRLEN,uport,32,
153                         NI_NUMERICHOST | NI_NUMERICSERV);
154         slisten = qemu_socket(e->ai_family, e->ai_socktype, e->ai_protocol);
155         if (slisten < 0) {
156             fprintf(stderr,"%s: socket(%s): %s\n", __FUNCTION__,
157                     inet_strfamily(e->ai_family), strerror(errno));
158             if (!e->ai_next) {
159                 error_set(errp, QERR_SOCKET_CREATE_FAILED);
160             }
161             continue;
162         }
163
164         setsockopt(slisten,SOL_SOCKET,SO_REUSEADDR,(void*)&on,sizeof(on));
165 #ifdef IPV6_V6ONLY
166         if (e->ai_family == PF_INET6) {
167             /* listen on both ipv4 and ipv6 */
168             setsockopt(slisten,IPPROTO_IPV6,IPV6_V6ONLY,(void*)&off,
169                 sizeof(off));
170         }
171 #endif
172
173         port_min = inet_getport(e);
174         port_max = to ? to + port_offset : port_min;
175         for (p = port_min; p <= port_max; p++) {
176             inet_setport(e, p);
177             if (bind(slisten, e->ai_addr, e->ai_addrlen) == 0) {
178                 goto listen;
179             }
180             if (p == port_max) {
181                 fprintf(stderr,"%s: bind(%s,%s,%d): %s\n", __FUNCTION__,
182                         inet_strfamily(e->ai_family), uaddr, inet_getport(e),
183                         strerror(errno));
184                 if (!e->ai_next) {
185                     error_set(errp, QERR_SOCKET_BIND_FAILED);
186                 }
187             }
188         }
189         closesocket(slisten);
190     }
191     fprintf(stderr, "%s: FAILED\n", __FUNCTION__);
192     freeaddrinfo(res);
193     return -1;
194
195 listen:
196     if (listen(slisten,1) != 0) {
197         error_set(errp, QERR_SOCKET_LISTEN_FAILED);
198         perror("listen");
199         closesocket(slisten);
200         freeaddrinfo(res);
201         return -1;
202     }
203     snprintf(uport, sizeof(uport), "%d", inet_getport(e) - port_offset);
204     qemu_opt_set(opts, "host", uaddr);
205     qemu_opt_set(opts, "port", uport);
206     qemu_opt_set(opts, "ipv6", (e->ai_family == PF_INET6) ? "on" : "off");
207     qemu_opt_set(opts, "ipv4", (e->ai_family != PF_INET6) ? "on" : "off");
208     freeaddrinfo(res);
209     return slisten;
210 }
211
212 int inet_connect_opts(QemuOpts *opts, bool *in_progress, Error **errp)
213 {
214     struct addrinfo ai,*res,*e;
215     const char *addr;
216     const char *port;
217     char uaddr[INET6_ADDRSTRLEN+1];
218     char uport[33];
219     int sock,rc;
220     bool block;
221
222     memset(&ai,0, sizeof(ai));
223     ai.ai_flags = AI_CANONNAME | AI_ADDRCONFIG;
224     ai.ai_family = PF_UNSPEC;
225     ai.ai_socktype = SOCK_STREAM;
226
227     if (in_progress) {
228         *in_progress = false;
229     }
230
231     addr = qemu_opt_get(opts, "host");
232     port = qemu_opt_get(opts, "port");
233     block = qemu_opt_get_bool(opts, "block", 0);
234     if (addr == NULL || port == NULL) {
235         fprintf(stderr, "inet_connect: host and/or port not specified\n");
236         error_set(errp, QERR_SOCKET_CREATE_FAILED);
237         return -1;
238     }
239
240     if (qemu_opt_get_bool(opts, "ipv4", 0))
241         ai.ai_family = PF_INET;
242     if (qemu_opt_get_bool(opts, "ipv6", 0))
243         ai.ai_family = PF_INET6;
244
245     /* lookup */
246     if (0 != (rc = getaddrinfo(addr, port, &ai, &res))) {
247         fprintf(stderr,"getaddrinfo(%s,%s): %s\n", addr, port,
248                 gai_strerror(rc));
249         error_set(errp, QERR_SOCKET_CREATE_FAILED);
250         return -1;
251     }
252
253     for (e = res; e != NULL; e = e->ai_next) {
254         if (getnameinfo((struct sockaddr*)e->ai_addr,e->ai_addrlen,
255                             uaddr,INET6_ADDRSTRLEN,uport,32,
256                             NI_NUMERICHOST | NI_NUMERICSERV) != 0) {
257             fprintf(stderr,"%s: getnameinfo: oops\n", __FUNCTION__);
258             continue;
259         }
260         sock = qemu_socket(e->ai_family, e->ai_socktype, e->ai_protocol);
261         if (sock < 0) {
262             fprintf(stderr,"%s: socket(%s): %s\n", __FUNCTION__,
263             inet_strfamily(e->ai_family), strerror(errno));
264             continue;
265         }
266         setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,(void*)&on,sizeof(on));
267         if (!block) {
268             socket_set_nonblock(sock);
269         }
270         /* connect to peer */
271         do {
272             rc = 0;
273             if (connect(sock, e->ai_addr, e->ai_addrlen) < 0) {
274                 rc = -socket_error();
275             }
276         } while (rc == -EINTR);
277
278   #ifdef _WIN32
279         if (!block && (rc == -EINPROGRESS || rc == -EWOULDBLOCK
280                        || rc == -WSAEALREADY)) {
281   #else
282         if (!block && (rc == -EINPROGRESS)) {
283   #endif
284             if (in_progress) {
285                 *in_progress = true;
286             }
287         } else if (rc < 0) {
288             if (NULL == e->ai_next)
289                 fprintf(stderr, "%s: connect(%s,%s,%s,%s): %s\n", __FUNCTION__,
290                         inet_strfamily(e->ai_family),
291                         e->ai_canonname, uaddr, uport, strerror(errno));
292             closesocket(sock);
293             continue;
294         }
295         freeaddrinfo(res);
296         return sock;
297     }
298     error_set(errp, QERR_SOCKET_CONNECT_FAILED);
299     freeaddrinfo(res);
300     return -1;
301 }
302
303 int inet_dgram_opts(QemuOpts *opts)
304 {
305     struct addrinfo ai, *peer = NULL, *local = NULL;
306     const char *addr;
307     const char *port;
308     char uaddr[INET6_ADDRSTRLEN+1];
309     char uport[33];
310     int sock = -1, rc;
311
312     /* lookup peer addr */
313     memset(&ai,0, sizeof(ai));
314     ai.ai_flags = AI_CANONNAME | AI_ADDRCONFIG;
315     ai.ai_family = PF_UNSPEC;
316     ai.ai_socktype = SOCK_DGRAM;
317
318     addr = qemu_opt_get(opts, "host");
319     port = qemu_opt_get(opts, "port");
320     if (addr == NULL || strlen(addr) == 0) {
321         addr = "localhost";
322     }
323     if (port == NULL || strlen(port) == 0) {
324         fprintf(stderr, "inet_dgram: port not specified\n");
325         return -1;
326     }
327
328     if (qemu_opt_get_bool(opts, "ipv4", 0))
329         ai.ai_family = PF_INET;
330     if (qemu_opt_get_bool(opts, "ipv6", 0))
331         ai.ai_family = PF_INET6;
332
333     if (0 != (rc = getaddrinfo(addr, port, &ai, &peer))) {
334         fprintf(stderr,"getaddrinfo(%s,%s): %s\n", addr, port,
335                 gai_strerror(rc));
336         return -1;
337     }
338
339     /* lookup local addr */
340     memset(&ai,0, sizeof(ai));
341     ai.ai_flags = AI_PASSIVE;
342     ai.ai_family = peer->ai_family;
343     ai.ai_socktype = SOCK_DGRAM;
344
345     addr = qemu_opt_get(opts, "localaddr");
346     port = qemu_opt_get(opts, "localport");
347     if (addr == NULL || strlen(addr) == 0) {
348         addr = NULL;
349     }
350     if (!port || strlen(port) == 0)
351         port = "0";
352
353     if (0 != (rc = getaddrinfo(addr, port, &ai, &local))) {
354         fprintf(stderr,"getaddrinfo(%s,%s): %s\n", addr, port,
355                 gai_strerror(rc));
356         return -1;
357     }
358
359     /* create socket */
360     sock = qemu_socket(peer->ai_family, peer->ai_socktype, peer->ai_protocol);
361     if (sock < 0) {
362         fprintf(stderr,"%s: socket(%s): %s\n", __FUNCTION__,
363                 inet_strfamily(peer->ai_family), strerror(errno));
364         goto err;
365     }
366     setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,(void*)&on,sizeof(on));
367
368     /* bind socket */
369     if (getnameinfo((struct sockaddr*)local->ai_addr,local->ai_addrlen,
370                     uaddr,INET6_ADDRSTRLEN,uport,32,
371                     NI_NUMERICHOST | NI_NUMERICSERV) != 0) {
372         fprintf(stderr, "%s: getnameinfo: oops\n", __FUNCTION__);
373         goto err;
374     }
375     if (bind(sock, local->ai_addr, local->ai_addrlen) < 0) {
376         fprintf(stderr,"%s: bind(%s,%s,%d): OK\n", __FUNCTION__,
377                 inet_strfamily(local->ai_family), uaddr, inet_getport(local));
378         goto err;
379     }
380
381     /* connect to peer */
382     if (getnameinfo((struct sockaddr*)peer->ai_addr, peer->ai_addrlen,
383                     uaddr, INET6_ADDRSTRLEN, uport, 32,
384                     NI_NUMERICHOST | NI_NUMERICSERV) != 0) {
385         fprintf(stderr, "%s: getnameinfo: oops\n", __FUNCTION__);
386         goto err;
387     }
388     if (connect(sock,peer->ai_addr,peer->ai_addrlen) < 0) {
389         fprintf(stderr, "%s: connect(%s,%s,%s,%s): %s\n", __FUNCTION__,
390                 inet_strfamily(peer->ai_family),
391                 peer->ai_canonname, uaddr, uport, strerror(errno));
392         goto err;
393     }
394
395     freeaddrinfo(local);
396     freeaddrinfo(peer);
397     return sock;
398
399 err:
400     if (-1 != sock)
401         closesocket(sock);
402     if (local)
403         freeaddrinfo(local);
404     if (peer)
405         freeaddrinfo(peer);
406     return -1;
407 }
408
409 /* compatibility wrapper */
410 static int inet_parse(QemuOpts *opts, const char *str)
411 {
412     const char *optstr, *h;
413     char addr[64];
414     char port[33];
415     int pos;
416
417     /* parse address */
418     if (str[0] == ':') {
419         /* no host given */
420         addr[0] = '\0';
421         if (1 != sscanf(str,":%32[^,]%n",port,&pos)) {
422             fprintf(stderr, "%s: portonly parse error (%s)\n",
423                     __FUNCTION__, str);
424             return -1;
425         }
426     } else if (str[0] == '[') {
427         /* IPv6 addr */
428         if (2 != sscanf(str,"[%64[^]]]:%32[^,]%n",addr,port,&pos)) {
429             fprintf(stderr, "%s: ipv6 parse error (%s)\n",
430                     __FUNCTION__, str);
431             return -1;
432         }
433         qemu_opt_set(opts, "ipv6", "on");
434     } else if (qemu_isdigit(str[0])) {
435         /* IPv4 addr */
436         if (2 != sscanf(str,"%64[0-9.]:%32[^,]%n",addr,port,&pos)) {
437             fprintf(stderr, "%s: ipv4 parse error (%s)\n",
438                     __FUNCTION__, str);
439             return -1;
440         }
441         qemu_opt_set(opts, "ipv4", "on");
442     } else {
443         /* hostname */
444         if (2 != sscanf(str,"%64[^:]:%32[^,]%n",addr,port,&pos)) {
445             fprintf(stderr, "%s: hostname parse error (%s)\n",
446                     __FUNCTION__, str);
447             return -1;
448         }
449     }
450     qemu_opt_set(opts, "host", addr);
451     qemu_opt_set(opts, "port", port);
452
453     /* parse options */
454     optstr = str + pos;
455     h = strstr(optstr, ",to=");
456     if (h)
457         qemu_opt_set(opts, "to", h+4);
458     if (strstr(optstr, ",ipv4"))
459         qemu_opt_set(opts, "ipv4", "on");
460     if (strstr(optstr, ",ipv6"))
461         qemu_opt_set(opts, "ipv6", "on");
462     return 0;
463 }
464
465 int inet_listen(const char *str, char *ostr, int olen,
466                 int socktype, int port_offset, Error **errp)
467 {
468     QemuOpts *opts;
469     char *optstr;
470     int sock = -1;
471
472     opts = qemu_opts_create(&dummy_opts, NULL, 0, NULL);
473     if (inet_parse(opts, str) == 0) {
474         sock = inet_listen_opts(opts, port_offset, errp);
475         if (sock != -1 && ostr) {
476             optstr = strchr(str, ',');
477             if (qemu_opt_get_bool(opts, "ipv6", 0)) {
478                 snprintf(ostr, olen, "[%s]:%s%s",
479                          qemu_opt_get(opts, "host"),
480                          qemu_opt_get(opts, "port"),
481                          optstr ? optstr : "");
482             } else {
483                 snprintf(ostr, olen, "%s:%s%s",
484                          qemu_opt_get(opts, "host"),
485                          qemu_opt_get(opts, "port"),
486                          optstr ? optstr : "");
487             }
488         }
489     } else {
490         error_set(errp, QERR_SOCKET_CREATE_FAILED);
491     }
492     qemu_opts_del(opts);
493     return sock;
494 }
495
496 int inet_connect(const char *str, bool block, bool *in_progress, Error **errp)
497 {
498     QemuOpts *opts;
499     int sock = -1;
500
501     opts = qemu_opts_create(&dummy_opts, NULL, 0, NULL);
502     if (inet_parse(opts, str) == 0) {
503         if (block) {
504             qemu_opt_set(opts, "block", "on");
505         }
506         sock = inet_connect_opts(opts, in_progress, errp);
507     } else {
508         error_set(errp, QERR_SOCKET_CREATE_FAILED);
509     }
510     qemu_opts_del(opts);
511     return sock;
512 }
513
514 #ifndef _WIN32
515
516 int unix_listen_opts(QemuOpts *opts)
517 {
518     struct sockaddr_un un;
519     const char *path = qemu_opt_get(opts, "path");
520     int sock, fd;
521
522     sock = qemu_socket(PF_UNIX, SOCK_STREAM, 0);
523     if (sock < 0) {
524         perror("socket(unix)");
525         return -1;
526     }
527
528     memset(&un, 0, sizeof(un));
529     un.sun_family = AF_UNIX;
530     if (path && strlen(path)) {
531         snprintf(un.sun_path, sizeof(un.sun_path), "%s", path);
532     } else {
533         char *tmpdir = getenv("TMPDIR");
534         snprintf(un.sun_path, sizeof(un.sun_path), "%s/qemu-socket-XXXXXX",
535                  tmpdir ? tmpdir : "/tmp");
536         /*
537          * This dummy fd usage silences the mktemp() unsecure warning.
538          * Using mkstemp() doesn't make things more secure here
539          * though.  bind() complains about existing files, so we have
540          * to unlink first and thus re-open the race window.  The
541          * worst case possible is bind() failing, i.e. a DoS attack.
542          */
543         fd = mkstemp(un.sun_path); close(fd);
544         qemu_opt_set(opts, "path", un.sun_path);
545     }
546
547     unlink(un.sun_path);
548     if (bind(sock, (struct sockaddr*) &un, sizeof(un)) < 0) {
549         fprintf(stderr, "bind(unix:%s): %s\n", un.sun_path, strerror(errno));
550         goto err;
551     }
552     if (listen(sock, 1) < 0) {
553         fprintf(stderr, "listen(unix:%s): %s\n", un.sun_path, strerror(errno));
554         goto err;
555     }
556
557     return sock;
558
559 err:
560     closesocket(sock);
561     return -1;
562 }
563
564 int unix_connect_opts(QemuOpts *opts)
565 {
566     struct sockaddr_un un;
567     const char *path = qemu_opt_get(opts, "path");
568     int sock;
569
570     if (NULL == path) {
571         fprintf(stderr, "unix connect: no path specified\n");
572         return -1;
573     }
574
575     sock = qemu_socket(PF_UNIX, SOCK_STREAM, 0);
576     if (sock < 0) {
577         perror("socket(unix)");
578         return -1;
579     }
580
581     memset(&un, 0, sizeof(un));
582     un.sun_family = AF_UNIX;
583     snprintf(un.sun_path, sizeof(un.sun_path), "%s", path);
584     if (connect(sock, (struct sockaddr*) &un, sizeof(un)) < 0) {
585         fprintf(stderr, "connect(unix:%s): %s\n", path, strerror(errno));
586         close(sock);
587         return -1;
588     }
589
590     return sock;
591 }
592
593 /* compatibility wrapper */
594 int unix_listen(const char *str, char *ostr, int olen)
595 {
596     QemuOpts *opts;
597     char *path, *optstr;
598     int sock, len;
599
600     opts = qemu_opts_create(&dummy_opts, NULL, 0, NULL);
601
602     optstr = strchr(str, ',');
603     if (optstr) {
604         len = optstr - str;
605         if (len) {
606             path = g_malloc(len+1);
607             snprintf(path, len+1, "%.*s", len, str);
608             qemu_opt_set(opts, "path", path);
609             g_free(path);
610         }
611     } else {
612         qemu_opt_set(opts, "path", str);
613     }
614
615     sock = unix_listen_opts(opts);
616
617     if (sock != -1 && ostr)
618         snprintf(ostr, olen, "%s%s", qemu_opt_get(opts, "path"), optstr ? optstr : "");
619     qemu_opts_del(opts);
620     return sock;
621 }
622
623 int unix_connect(const char *path)
624 {
625     QemuOpts *opts;
626     int sock;
627
628     opts = qemu_opts_create(&dummy_opts, NULL, 0, NULL);
629     qemu_opt_set(opts, "path", path);
630     sock = unix_connect_opts(opts);
631     qemu_opts_del(opts);
632     return sock;
633 }
634
635 #else
636
637 int unix_listen_opts(QemuOpts *opts)
638 {
639     fprintf(stderr, "unix sockets are not available on windows\n");
640     errno = ENOTSUP;
641     return -1;
642 }
643
644 int unix_connect_opts(QemuOpts *opts)
645 {
646     fprintf(stderr, "unix sockets are not available on windows\n");
647     errno = ENOTSUP;
648     return -1;
649 }
650
651 int unix_listen(const char *path, char *ostr, int olen)
652 {
653     fprintf(stderr, "unix sockets are not available on windows\n");
654     errno = ENOTSUP;
655     return -1;
656 }
657
658 int unix_connect(const char *path)
659 {
660     fprintf(stderr, "unix sockets are not available on windows\n");
661     errno = ENOTSUP;
662     return -1;
663 }
664
665 #endif
666
667 #ifdef _WIN32
668 static void socket_cleanup(void)
669 {
670     WSACleanup();
671 }
672 #endif
673
674 int socket_init(void)
675 {
676 #ifdef _WIN32
677     WSADATA Data;
678     int ret, err;
679
680     ret = WSAStartup(MAKEWORD(2,2), &Data);
681     if (ret != 0) {
682         err = WSAGetLastError();
683         fprintf(stderr, "WSAStartup: %d\n", err);
684         return -1;
685     }
686     atexit(socket_cleanup);
687 #endif
688     return 0;
689 }