]> cvs.zerfleddert.de Git - hmcfgusb/blob - hmland.c
typo
[hmcfgusb] / hmland.c
1 /* HM-CFG-LAN emulation for HM-CFG-USB
2 *
3 * Copyright (c) 2013 Michael Gernoth <michael@gernoth.net>
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining a copy
6 * of this software and associated documentation files (the "Software"), to
7 * deal in the Software without restriction, including without limitation the
8 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
9 * sell copies of the Software, and to permit persons to whom the Software is
10 * furnished to do so, subject to the following conditions:
11 *
12 * The above copyright notice and this permission notice shall be included in
13 * all copies or substantial portions of the Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
21 * IN THE SOFTWARE.
22 */
23
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <unistd.h>
27 #include <stdint.h>
28 #include <string.h>
29 #include <strings.h>
30 #include <poll.h>
31 #include <signal.h>
32 #include <errno.h>
33 #include <sys/types.h>
34 #include <sys/socket.h>
35 #include <sys/stat.h>
36 #include <fcntl.h>
37 #include <netinet/in.h>
38 #include <arpa/inet.h>
39 #include <libusb-1.0/libusb.h>
40
41 #include "hexdump.h"
42 #include "hmcfgusb.h"
43
44 #define PID_FILE "/var/run/hmland.pid"
45
46 extern char *optarg;
47
48 static int impersonate_hmlanif = 0;
49 static int debug = 0;
50 static int verbose = 0;
51
52 #define FLAG_LENGTH_BYTE (1<<0)
53 #define FLAG_FORMAT_HEX (1<<1)
54 #define FLAG_COMMA_BEFORE (1<<2)
55 #define FLAG_COMMA_AFTER (1<<3)
56 #define FLAG_NL (1<<4)
57 #define FLAG_IGNORE_COMMAS (1<<5)
58 #define FLAG_PERIODIC_WAKEUP (1<<6)
59
60 #define CHECK_SPACE(x) if ((*outpos + x) > outend) { fprintf(stderr, "Not enough space!\n"); return 0; }
61 #define CHECK_AVAIL(x) if ((*inpos + x) > inend) { fprintf(stderr, "Not enough input available!\n"); return 0; }
62
63 static int format_part_out(uint8_t **inpos, int inlen, uint8_t **outpos, int outlen, int len, int flags)
64 {
65 const uint8_t nibble[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
66 'A', 'B', 'C', 'D', 'E', 'F'};
67 uint8_t *buf_out = *outpos;
68 uint8_t *outend = *outpos + outlen;
69 uint8_t *inend = *inpos + inlen;
70 int i;
71
72 if (flags & FLAG_COMMA_BEFORE) {
73 CHECK_SPACE(1);
74 **outpos=',';
75 *outpos += 1;
76 }
77
78 if (flags & FLAG_LENGTH_BYTE) {
79 CHECK_AVAIL(1);
80 len = **inpos;
81 *inpos += 1;
82 }
83
84 if (flags & FLAG_FORMAT_HEX) {
85 CHECK_AVAIL(len);
86 CHECK_SPACE(len*2);
87 for (i = 0; i < len; i++) {
88 **outpos = nibble[((**inpos) & 0xf0) >> 4];
89 *outpos += 1;
90 **outpos = nibble[((**inpos) & 0xf)];
91 *inpos += 1; *outpos += 1;
92 }
93 } else {
94 CHECK_AVAIL(len);
95 CHECK_SPACE(len);
96 memcpy(*outpos, *inpos, len);
97 *outpos += len;
98 *inpos += len;
99 }
100
101 if (flags & FLAG_COMMA_AFTER) {
102 CHECK_SPACE(1);
103 **outpos=',';
104 *outpos += 1;
105 }
106
107 if (flags & FLAG_NL) {
108 CHECK_SPACE(2);
109 **outpos='\r';
110 *outpos += 1;
111 **outpos='\n';
112 *outpos += 1;
113 }
114
115 return *outpos - buf_out;
116 }
117
118 static uint8_t ascii_to_nibble(uint8_t a)
119 {
120 uint8_t c = 0x00;
121
122 if ((a >= '0') && (a <= '9')) {
123 c = a - '0';
124 } else if ((a >= 'A') && (a <= 'F')) {
125 c = (a - 'A') + 10;
126 } else if ((a >= 'a') && (a <= 'f')) {
127 c = (a - 'a') + 10;
128 }
129
130 return c;
131 }
132
133 static int parse_part_in(uint8_t **inpos, int inlen, uint8_t **outpos, int outlen, int flags)
134 {
135 uint8_t *buf_out = *outpos;
136 uint8_t *outend = *outpos + outlen;
137 uint8_t *inend = *inpos + inlen;
138
139 if (flags & FLAG_LENGTH_BYTE) {
140 int len = 0;
141 uint8_t *ip;
142
143 ip = *inpos;
144 while(ip < inend) {
145 if (*ip == ',') {
146 ip++;
147 if (!(flags & FLAG_IGNORE_COMMAS))
148 break;
149
150 continue;
151 }
152 len++;
153 ip++;
154 }
155 CHECK_SPACE(1);
156 **outpos = (len / 2);
157 *outpos += 1;
158 }
159
160 while(*inpos < inend) {
161 if (**inpos == ',') {
162 *inpos += 1;
163 if (!(flags & FLAG_IGNORE_COMMAS))
164 break;
165
166 continue;
167 }
168
169 CHECK_SPACE(1);
170 CHECK_AVAIL(2);
171
172 **outpos = ascii_to_nibble(**inpos) << 4;
173 *inpos += 1;
174 **outpos |= ascii_to_nibble(**inpos);
175 *inpos += 1; *outpos += 1;
176 }
177
178 return *outpos - buf_out;
179 }
180
181 static int hmlan_format_out(uint8_t *buf, int buf_len, void *data)
182 {
183 uint8_t out[1024];
184 uint8_t *outpos;
185 uint8_t *inpos;
186 int fd = *((int*)data);
187 int w;
188
189 if (buf_len < 1)
190 return 1;
191
192 memset(out, 0, sizeof(out));
193 outpos = out;
194 inpos = buf;
195
196 format_part_out(&inpos, (buf_len-(inpos-buf)), &outpos, (sizeof(out)-(outpos-out)), 1, 0);
197 switch(buf[0]) {
198 case 'H':
199 if (impersonate_hmlanif) {
200 buf[5] = 'L';
201 buf[6] = 'A';
202 buf[7] = 'N';
203 }
204 format_part_out(&inpos, (buf_len-(inpos-buf)), &outpos, (sizeof(out)-(outpos-out)), 0, FLAG_LENGTH_BYTE);
205 format_part_out(&inpos, (buf_len-(inpos-buf)), &outpos, (sizeof(out)-(outpos-out)), 2, FLAG_FORMAT_HEX | FLAG_COMMA_BEFORE);
206 format_part_out(&inpos, (buf_len-(inpos-buf)), &outpos, (sizeof(out)-(outpos-out)), 0, FLAG_COMMA_BEFORE | FLAG_LENGTH_BYTE);
207 format_part_out(&inpos, (buf_len-(inpos-buf)), &outpos, (sizeof(out)-(outpos-out)), 3, FLAG_FORMAT_HEX | FLAG_COMMA_BEFORE);
208 format_part_out(&inpos, (buf_len-(inpos-buf)), &outpos, (sizeof(out)-(outpos-out)), 3, FLAG_FORMAT_HEX | FLAG_COMMA_BEFORE);
209 format_part_out(&inpos, (buf_len-(inpos-buf)), &outpos, (sizeof(out)-(outpos-out)), 4, FLAG_FORMAT_HEX | FLAG_COMMA_BEFORE);
210 format_part_out(&inpos, (buf_len-(inpos-buf)), &outpos, (sizeof(out)-(outpos-out)), 2, FLAG_FORMAT_HEX | FLAG_COMMA_BEFORE | FLAG_NL);
211
212 break;
213 case 'E':
214 format_part_out(&inpos, (buf_len-(inpos-buf)), &outpos, (sizeof(out)-(outpos-out)), 3, FLAG_FORMAT_HEX);
215 format_part_out(&inpos, (buf_len-(inpos-buf)), &outpos, (sizeof(out)-(outpos-out)), 2, FLAG_FORMAT_HEX | FLAG_COMMA_BEFORE);
216 format_part_out(&inpos, (buf_len-(inpos-buf)), &outpos, (sizeof(out)-(outpos-out)), 4, FLAG_FORMAT_HEX | FLAG_COMMA_BEFORE);
217 format_part_out(&inpos, (buf_len-(inpos-buf)), &outpos, (sizeof(out)-(outpos-out)), 1, FLAG_FORMAT_HEX | FLAG_COMMA_BEFORE);
218 format_part_out(&inpos, (buf_len-(inpos-buf)), &outpos, (sizeof(out)-(outpos-out)), 2, FLAG_FORMAT_HEX | FLAG_COMMA_BEFORE);
219 format_part_out(&inpos, (buf_len-(inpos-buf)), &outpos, (sizeof(out)-(outpos-out)), 0, FLAG_FORMAT_HEX | FLAG_COMMA_BEFORE | FLAG_LENGTH_BYTE | FLAG_NL);
220
221 break;
222 case 'R':
223 format_part_out(&inpos, (buf_len-(inpos-buf)), &outpos, (sizeof(out)-(outpos-out)), 4, FLAG_FORMAT_HEX);
224 format_part_out(&inpos, (buf_len-(inpos-buf)), &outpos, (sizeof(out)-(outpos-out)), 2, FLAG_FORMAT_HEX | FLAG_COMMA_BEFORE);
225 format_part_out(&inpos, (buf_len-(inpos-buf)), &outpos, (sizeof(out)-(outpos-out)), 4, FLAG_FORMAT_HEX | FLAG_COMMA_BEFORE);
226 format_part_out(&inpos, (buf_len-(inpos-buf)), &outpos, (sizeof(out)-(outpos-out)), 1, FLAG_FORMAT_HEX | FLAG_COMMA_BEFORE);
227 format_part_out(&inpos, (buf_len-(inpos-buf)), &outpos, (sizeof(out)-(outpos-out)), 2, FLAG_FORMAT_HEX | FLAG_COMMA_BEFORE);
228 format_part_out(&inpos, (buf_len-(inpos-buf)), &outpos, (sizeof(out)-(outpos-out)), 0, FLAG_FORMAT_HEX | FLAG_COMMA_BEFORE | FLAG_LENGTH_BYTE | FLAG_NL);
229
230 break;
231 case 'I':
232 format_part_out(&inpos, (buf_len-(inpos-buf)), &outpos, (sizeof(out)-(outpos-out)), 1, FLAG_FORMAT_HEX);
233 format_part_out(&inpos, (buf_len-(inpos-buf)), &outpos, (sizeof(out)-(outpos-out)), 1, FLAG_FORMAT_HEX | FLAG_COMMA_BEFORE);
234 format_part_out(&inpos, (buf_len-(inpos-buf)), &outpos, (sizeof(out)-(outpos-out)), 1, FLAG_FORMAT_HEX | FLAG_COMMA_BEFORE);
235 format_part_out(&inpos, (buf_len-(inpos-buf)), &outpos, (sizeof(out)-(outpos-out)), 1, FLAG_FORMAT_HEX | FLAG_COMMA_BEFORE | FLAG_NL);
236
237 break;
238 default:
239 format_part_out(&inpos, (buf_len-(inpos-buf)), &outpos, (sizeof(out)-(outpos-out)), buf_len-1, FLAG_FORMAT_HEX | FLAG_NL);
240 hexdump(buf, buf_len, "Unknown> ");
241 break;
242 }
243 if (debug)
244 fprintf(stderr, "LAN < %s\n", out);
245
246 w = write(fd, out, outpos-out);
247 if (w <= 0) {
248 perror("write");
249 return 0;
250 }
251
252 return 1;
253 }
254
255 static int hmlan_parse_in(int fd, void *data)
256 {
257 struct hmcfgusb_dev *dev = data;
258 uint8_t buf[1025];
259 uint8_t out[0x40]; //FIXME!!!
260 uint8_t *outpos;
261 uint8_t *inpos;
262 int i;
263 int last;
264 int r;
265
266 memset(buf, 0, sizeof(buf));
267
268 r = read(fd, buf, sizeof(buf)-1);
269 if (r > 0) {
270 uint8_t *inend = buf + r;
271
272 inpos = buf;
273
274 if (debug)
275 fprintf(stderr, "\nLAN > %s", buf);
276
277 while (inpos < inend) {
278 uint8_t *instart = inpos;
279
280 if ((*inpos == '\r') || (*inpos == '\n')) {
281 inpos++;
282 continue;
283 }
284
285 outpos = out;
286
287 last = inend - inpos;
288
289 for (i = 0; i < last; i++) {
290 if ((inpos[i] == '\r') || (inpos[i] == '\n')) {
291 last = i;
292 break;
293 }
294 }
295
296 if (last == 0)
297 continue;
298
299 memset(out, 0, sizeof(out));
300 *outpos++ = *inpos++;
301
302 switch(*instart) {
303 case 'S':
304 parse_part_in(&inpos, (last-(inpos-instart)), &outpos, (sizeof(out)-(outpos-out)), 0);
305 parse_part_in(&inpos, (last-(inpos-instart)), &outpos, (sizeof(out)-(outpos-out)), 0);
306 parse_part_in(&inpos, (last-(inpos-instart)), &outpos, (sizeof(out)-(outpos-out)), 0);
307 parse_part_in(&inpos, (last-(inpos-instart)), &outpos, (sizeof(out)-(outpos-out)), 0);
308 parse_part_in(&inpos, (last-(inpos-instart)), &outpos, (sizeof(out)-(outpos-out)), 0);
309 parse_part_in(&inpos, (last-(inpos-instart)), &outpos, (sizeof(out)-(outpos-out)), FLAG_LENGTH_BYTE);
310 break;
311 default:
312 parse_part_in(&inpos, (last-(inpos-instart)), &outpos, (sizeof(out)-(outpos-out)), FLAG_IGNORE_COMMAS);
313 break;
314 }
315
316 hmcfgusb_send(dev, out, sizeof(out), 1);
317 }
318 } else if (r < 0) {
319 perror("read");
320 return r;
321 } else {
322 return 0;
323 }
324
325 return 1;
326 }
327
328 static int comm(int fd_in, int fd_out, int master_socket, int flags)
329 {
330 struct hmcfgusb_dev *dev;
331 uint8_t out[0x40]; //FIXME!!!
332 int poll_timeout = 3600;
333 int quit = 0;
334
335 hmcfgusb_set_debug(debug);
336
337 dev = hmcfgusb_init(hmlan_format_out, &fd_out);
338 if (!dev) {
339 fprintf(stderr, "Can't initialize HM-CFG-USB!\n");
340 return 0;
341 }
342
343 if (!hmcfgusb_add_pfd(dev, fd_in, POLLIN)) {
344 fprintf(stderr, "Can't add client to pollfd!\n");
345 hmcfgusb_close(dev);
346 return 0;
347 }
348
349 if (master_socket >= 0) {
350 if (!hmcfgusb_add_pfd(dev, master_socket, POLLIN)) {
351 fprintf(stderr, "Can't add master_socket to pollfd!\n");
352 hmcfgusb_close(dev);
353 return 0;
354 }
355 }
356
357 if (flags & FLAG_PERIODIC_WAKEUP)
358 poll_timeout = 1;
359
360 memset(out, 0, sizeof(out));
361 out[0] = 'K';
362 hmcfgusb_send_null_frame(dev);
363 hmcfgusb_send(dev, out, sizeof(out), 1);
364
365 while(!quit) {
366 int fd;
367
368 fd = hmcfgusb_poll(dev, poll_timeout);
369 if (fd >= 0) {
370 if (fd == master_socket) {
371 int client;
372
373 client = accept(master_socket, NULL, 0);
374 if (client >= 0) {
375 shutdown(client, SHUT_RDWR);
376 close(client);
377 }
378 } else {
379 if (hmlan_parse_in(fd, dev) <= 0) {
380 quit = 1;
381 }
382 }
383 } else if (fd == -1) {
384 if (errno) {
385 perror("hmcfgusb_poll");
386 quit = 1;
387 } else {
388 /* periodically wakeup the device */
389 hmcfgusb_send_null_frame(dev);
390 }
391 }
392 }
393
394 hmcfgusb_close(dev);
395 return 1;
396 }
397
398 void sigterm_handler(int sig)
399 {
400 if (unlink(PID_FILE) == -1)
401 perror("Can't remove PID file");
402
403 exit(EXIT_SUCCESS);
404 }
405
406 #define FLAG_DAEMON (1 << 0)
407 #define FLAG_PID_FILE (1 << 1)
408
409 static int socket_server(char *iface, int port, int flags)
410 {
411 struct sigaction sact;
412 struct sockaddr_in sin;
413 int sock;
414 int n;
415 pid_t pid;
416
417 if (flags & FLAG_DAEMON) {
418 FILE *pidfile = NULL;
419
420 if (flags & FLAG_PID_FILE) {
421 int fd;
422
423 fd = open(PID_FILE, O_CREAT | O_EXCL | O_WRONLY, 0644);
424 if (fd == -1) {
425 if (errno == EEXIST) {
426 pid_t old_pid;
427 pidfile = fopen(PID_FILE, "r");
428 if (!pidfile) {
429 perror("PID file " PID_FILE " already exists, already running?");
430 exit(EXIT_FAILURE);
431 }
432
433 if (fscanf(pidfile, "%u", &old_pid) != 1) {
434 fclose(pidfile);
435 fprintf(stderr, "Can't read old PID from " PID_FILE ", already running?\n");
436 exit(EXIT_FAILURE);
437 }
438
439 fclose(pidfile);
440
441 fprintf(stderr, "Already running with PID %u according to " PID_FILE "!\n", old_pid);
442 exit(EXIT_FAILURE);
443 }
444 perror("Can't create PID file " PID_FILE);
445 exit(EXIT_FAILURE);
446 }
447
448 pidfile = fdopen(fd, "w");
449 if (!pidfile) {
450 perror("Can't reopen PID file fd");
451 exit(EXIT_FAILURE);
452 }
453
454 memset(&sact, 0, sizeof(sact));
455 sact.sa_handler = sigterm_handler;
456
457 if (sigaction(SIGTERM, &sact, NULL) == -1) {
458 perror("sigaction(SIGTERM)");
459 exit(EXIT_FAILURE);
460 }
461 }
462
463 pid = fork();
464 if (pid > 0) {
465 if (pidfile) {
466 fprintf(pidfile, "%u\n", pid);
467 fclose(pidfile);
468 }
469
470 printf("Daemon with PID %u started!\n", pid);
471 exit(EXIT_SUCCESS);
472 } else if (pid < 0) {
473 perror("fork");
474 exit(EXIT_FAILURE);
475 }
476
477 if (pidfile)
478 fclose(pidfile);
479 }
480
481 memset(&sact, 0, sizeof(sact));
482 sact.sa_handler = SIG_IGN;
483
484 if (sigaction(SIGPIPE, &sact, NULL) == -1) {
485 perror("sigaction(SIGPIPE)");
486 exit(EXIT_FAILURE);
487 }
488
489 impersonate_hmlanif = 1;
490
491 sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
492 if (sock == -1) {
493 perror("Can't open socket");
494 return EXIT_FAILURE;
495 }
496
497 n = 1;
498 if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &n, sizeof(n)) == -1) {
499 perror("Can't set socket options");
500 return EXIT_FAILURE;
501 }
502
503 memset(&sin, 0, sizeof(sin));
504 sin.sin_family = AF_INET;
505 sin.sin_port = htons(port);
506 if (!iface) {
507 sin.sin_addr.s_addr = htonl(INADDR_ANY);
508 } else {
509 if (inet_pton(AF_INET, iface, &(sin.sin_addr.s_addr)) != 1) {
510 perror("inet_ntop");
511 return EXIT_FAILURE;
512 }
513 }
514
515 if (bind(sock, (struct sockaddr*)&sin, sizeof(sin)) == -1) {
516 perror("Can't bind socket");
517 return EXIT_FAILURE;
518 }
519
520 if (listen(sock, 1) == -1) {
521 perror("Can't listen on socket");
522 return EXIT_FAILURE;
523 }
524
525 while(1) {
526 struct sockaddr_in csin;
527 socklen_t csinlen;
528 int client;
529 in_addr_t client_addr;
530
531 memset(&csin, 0, sizeof(csin));
532 csinlen = sizeof(csin);
533 client = accept(sock, (struct sockaddr*)&csin, &csinlen);
534 if (client == -1) {
535 perror("Couldn't accept client");
536 continue;
537 }
538
539 /* FIXME: getnameinfo... */
540 client_addr = ntohl(csin.sin_addr.s_addr);
541
542 if (verbose) {
543 printf("Client %d.%d.%d.%d connected!\n",
544 (client_addr & 0xff000000) >> 24,
545 (client_addr & 0x00ff0000) >> 16,
546 (client_addr & 0x0000ff00) >> 8,
547 (client_addr & 0x000000ff));
548 }
549
550 comm(client, client, sock, flags);
551
552 shutdown(client, SHUT_RDWR);
553 close(client);
554
555 if (verbose) {
556 printf("Connection to %d.%d.%d.%d closed!\n",
557 (client_addr & 0xff000000) >> 24,
558 (client_addr & 0x00ff0000) >> 16,
559 (client_addr & 0x0000ff00) >> 8,
560 (client_addr & 0x000000ff));
561 }
562 sleep(1);
563 }
564
565 return EXIT_SUCCESS;
566 }
567
568 static int interactive_server(int flags)
569 {
570 if (!comm(STDIN_FILENO, STDOUT_FILENO, -1, flags))
571 return EXIT_FAILURE;
572
573 return EXIT_SUCCESS;
574 }
575
576 void hmlan_syntax(char *prog)
577 {
578 fprintf(stderr, "Syntax: %s options\n\n", prog);
579 fprintf(stderr, "Possible options:\n");
580 fprintf(stderr, "\t-D\tdebug mode\n");
581 fprintf(stderr, "\t-d\tdaemon mode\n");
582 fprintf(stderr, "\t-h\tthis help\n");
583 fprintf(stderr, "\t-i\tinteractive mode (connect HM-CFG-USB to terminal)\n");
584 fprintf(stderr, "\t-l ip\tlisten on given IP address only (for example 127.0.0.1)\n");
585 fprintf(stderr, "\t-P\tcreate PID file " PID_FILE " in daemon mode\n");
586 fprintf(stderr, "\t-p n\tlisten on port n (default 1000)\n");
587 fprintf(stderr, "\t-R\twakeup the device (and USB-bus) every second (fix for e.g. Raspberry Pi)\n");
588 fprintf(stderr, "\t-v\tverbose mode\n");
589
590 }
591
592 int main(int argc, char **argv)
593 {
594 int port = 1000;
595 char *iface = NULL;
596 int interactive = 0;
597 int flags = 0;
598 char *ep;
599 int opt;
600
601 while((opt = getopt(argc, argv, "DdhiPp:Rl:v")) != -1) {
602 switch (opt) {
603 case 'D':
604 debug = 1;
605 verbose = 1;
606 break;
607 case 'd':
608 flags |= FLAG_DAEMON;
609 break;
610 case 'i':
611 interactive = 1;
612 break;
613 case 'P':
614 flags |= FLAG_PID_FILE;
615 break;
616 case 'p':
617 port = strtoul(optarg, &ep, 10);
618 if (*ep != '\0') {
619 fprintf(stderr, "Can't parse port!\n");
620 exit(EXIT_FAILURE);
621 }
622 break;
623 case 'R':
624 flags |= FLAG_PERIODIC_WAKEUP;
625 break;
626 case 'l':
627 iface = optarg;
628 break;
629 case 'v':
630 verbose = 1;
631 break;
632 case 'h':
633 case ':':
634 case '?':
635 default:
636 hmlan_syntax(argv[0]);
637 exit(EXIT_FAILURE);
638 break;
639 }
640 }
641
642 if (interactive) {
643 return interactive_server(flags);
644 } else {
645 return socket_server(iface, port, flags);
646 }
647 }
Impressum, Datenschutz