568 lines
14 KiB
C
568 lines
14 KiB
C
#define _GNU_SOURCE
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <stdarg.h>
|
|
#include <getopt.h>
|
|
#include <unistd.h>
|
|
#include <sysexits.h>
|
|
#include <errno.h>
|
|
|
|
#include <patty/ax25.h>
|
|
#include <patty/daemon.h>
|
|
#include <patty/conf.h>
|
|
|
|
#define DEFAULT_CONFIG_FILE "/etc/patty/pattyd.conf"
|
|
#define DEFAULT_IFNAME "kiss0"
|
|
|
|
static int usage(int argc, char **argv, const char *message, ...) {
|
|
if (message != NULL) {
|
|
va_list args;
|
|
|
|
va_start(args, message);
|
|
vfprintf(stderr, message, args);
|
|
fprintf(stderr, "\n");
|
|
va_end(args);
|
|
}
|
|
|
|
fprintf(stderr, "usage: %s [-f] [-c pattyd.conf]\n"
|
|
" %s [-f] -s patty.sock MYCALL /dev/ttyXYZ [tioflags ...]\n",
|
|
argv[0], argv[0]);
|
|
|
|
return EX_USAGE;
|
|
}
|
|
|
|
static int handle_sock(patty_daemon *daemon,
|
|
int lineno,
|
|
int argc,
|
|
char **argv) {
|
|
if (argc != 2) {
|
|
fprintf(stderr, "Invalid arguments for 'sock' on line %d\n", lineno);
|
|
|
|
goto error_invalid_args;
|
|
}
|
|
|
|
if (patty_daemon_set_sock_path(daemon, argv[1]) < 0) {
|
|
fprintf(stderr, "Line %d: unable to set socket path to %s: %s",
|
|
lineno, argv[1], strerror(errno));
|
|
|
|
goto error_set_sock_path;
|
|
}
|
|
|
|
return 0;
|
|
|
|
error_set_sock_path:
|
|
error_invalid_args:
|
|
return -1;
|
|
}
|
|
|
|
static int handle_pid(patty_daemon *daemon,
|
|
int lineno,
|
|
int argc,
|
|
char **argv) {
|
|
if (argc != 2) {
|
|
fprintf(stderr, "Invalid arguments for 'sock' on line %d\n", lineno);
|
|
|
|
goto error_invalid_args;
|
|
}
|
|
|
|
if (patty_daemon_set_pidfile(daemon, argv[1]) < 0) {
|
|
fprintf(stderr, "Line %d: Unable to set pidfile to %s: %s",
|
|
lineno, argv[1], strerror(errno));
|
|
|
|
goto error_set_pidfile;
|
|
}
|
|
|
|
return 0;
|
|
|
|
error_set_pidfile:
|
|
error_invalid_args:
|
|
return -1;
|
|
}
|
|
|
|
struct if_context {
|
|
patty_daemon *daemon;
|
|
patty_ax25_addr addr;
|
|
patty_kiss_tnc_info info;
|
|
};
|
|
|
|
static int handle_if_ax25(struct if_context *ctx,
|
|
int lineno,
|
|
char *opt,
|
|
char *value) {
|
|
if (patty_ax25_pton(value, &ctx->addr) < 0) {
|
|
fprintf(stderr, "Line %d: Invalid interface address '%s'\n",
|
|
lineno, value);
|
|
|
|
goto error_pton;
|
|
}
|
|
|
|
return 0;
|
|
|
|
error_pton:
|
|
return -1;
|
|
}
|
|
|
|
static int handle_if_kiss(struct if_context *ctx,
|
|
int lineno,
|
|
char *opt,
|
|
char *value) {
|
|
ctx->info.flags |= PATTY_KISS_TNC_DEVICE;
|
|
ctx->info.device = value;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int handle_if_baud(struct if_context *ctx,
|
|
int lineno,
|
|
char *opt,
|
|
char *value) {
|
|
ctx->info.flags |= PATTY_KISS_TNC_BAUD;
|
|
ctx->info.baud = atoi(value);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int handle_if_flow(struct if_context *ctx,
|
|
int lineno,
|
|
char *opt,
|
|
char *value) {
|
|
if (strcmp(value, "xonxoff") == 0) {
|
|
ctx->info.flow = PATTY_KISS_TNC_FLOW_XONXOFF;
|
|
} else if (strcmp(value, "crtscts") == 0) {
|
|
ctx->info.flow = PATTY_KISS_TNC_FLOW_CRTSCTS;
|
|
} else {
|
|
fprintf(stderr, "Line %d: Invalid flow control '%s'\n",
|
|
lineno, value);
|
|
|
|
goto error_invalid_flow;
|
|
}
|
|
|
|
ctx->info.flags |= PATTY_KISS_TNC_FLOW;
|
|
|
|
return 0;
|
|
|
|
error_invalid_flow:
|
|
return -1;
|
|
}
|
|
|
|
struct if_opt_handler {
|
|
char *name;
|
|
int (*func)(struct if_context *, int, char *, char *);
|
|
};
|
|
|
|
static struct if_opt_handler if_opt_handlers[] = {
|
|
{ "ax25", handle_if_ax25 },
|
|
{ "kiss", handle_if_kiss },
|
|
{ "baud", handle_if_baud },
|
|
{ "flow", handle_if_flow },
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
static int handle_if_opt(struct if_context *ctx,
|
|
int lineno,
|
|
char *opt,
|
|
char *value) {
|
|
int i;
|
|
|
|
for (i=0; if_opt_handlers[i].name; i++) {
|
|
if (strcmp(opt, if_opt_handlers[i].name) == 0) {
|
|
return if_opt_handlers[i].func(ctx, lineno, opt, value);
|
|
}
|
|
}
|
|
|
|
fprintf(stderr, "Line %d: Invalid interface option '%s'\n",
|
|
lineno, opt);
|
|
|
|
return -1;
|
|
}
|
|
|
|
static int handle_if(patty_daemon *daemon,
|
|
int lineno,
|
|
int argc,
|
|
char **argv) {
|
|
char *name;
|
|
struct if_context ctx;
|
|
patty_ax25_if *iface;
|
|
|
|
int i;
|
|
|
|
if (argc < 2) {
|
|
fprintf(stderr, "Line %d: No interface name provided\n", lineno);
|
|
|
|
goto error_no_ifname;
|
|
}
|
|
|
|
if (argc < 3) {
|
|
fprintf(stderr, "Line %d: No interface options provided\n", lineno);
|
|
|
|
goto error_no_options;
|
|
}
|
|
|
|
if (argc % 2 != 0) {
|
|
fprintf(stderr, "Line %d: Invalid number of values provided\n", lineno);
|
|
|
|
goto error_invalid_values;
|
|
}
|
|
|
|
memset(&ctx, '\0', sizeof(ctx));
|
|
ctx.daemon = daemon;
|
|
|
|
name = argv[1];
|
|
|
|
for (i=2; i<argc; i+=2) {
|
|
char *opt = argv[i],
|
|
*value = argv[i+1];
|
|
|
|
if (handle_if_opt(&ctx, lineno, opt, value) < 0) {
|
|
goto error_handle_if_opt;
|
|
}
|
|
}
|
|
|
|
if ((iface = patty_ax25_if_new(PATTY_AX25_IF_KISS_TNC,
|
|
name,
|
|
&ctx.info,
|
|
&ctx.addr)) == NULL) {
|
|
goto error_if_new;
|
|
} else {
|
|
int fd = patty_kiss_tnc_fd(iface->tnc);
|
|
char *pty;
|
|
|
|
if (isatty(fd) && (pty = ptsname(fd)) != NULL) {
|
|
printf("if %s pty %s\n", name, pty);
|
|
}
|
|
}
|
|
|
|
if (patty_daemon_if_add(daemon, iface) < 0) {
|
|
fprintf(stderr, "Line %d: Unable to create interface %s: %s\n",
|
|
lineno, name, strerror(errno));
|
|
|
|
goto error_daemon_if_add;
|
|
}
|
|
|
|
return 0;
|
|
|
|
error_daemon_if_add:
|
|
patty_ax25_if_destroy(iface);
|
|
|
|
error_if_new:
|
|
error_handle_if_opt:
|
|
error_invalid_values:
|
|
error_no_options:
|
|
error_no_ifname:
|
|
return -1;
|
|
}
|
|
|
|
static int handle_route(patty_daemon *daemon,
|
|
int lineno,
|
|
int argc,
|
|
char **argv) {
|
|
if (argc < 2) {
|
|
fprintf(stderr, "Line %d: Invalid route declaration\n", lineno);
|
|
|
|
goto error_invalid_route;
|
|
}
|
|
|
|
if (strcmp(argv[1], "default") == 0) {
|
|
if (argc != 4 || strcmp(argv[2], "if") != 0) {
|
|
fprintf(stderr, "Line %d: Invalid default route declaration\n",
|
|
lineno);
|
|
|
|
goto error_invalid_route;
|
|
}
|
|
|
|
if (patty_daemon_route_add_default(daemon, argv[3]) < 0) {
|
|
fprintf(stderr, "Line %d: Unable to add default route for interface %s: %s\n",
|
|
lineno, argv[3], strerror(errno));
|
|
|
|
goto error_daemon_route_add;
|
|
}
|
|
} else if (strcmp(argv[1], "station") == 0) {
|
|
if (argc < 7 || strcmp(argv[3], "if") != 0 || strcmp(argv[5], "path") != 0) {
|
|
fprintf(stderr, "Line %d: Invalid station route declaration\n",
|
|
lineno);
|
|
|
|
goto error_invalid_route;
|
|
}
|
|
|
|
if (patty_daemon_route_add(daemon,
|
|
argv[4],
|
|
argv[2],
|
|
(const char **)&argv[6],
|
|
argc - 6) < 0) {
|
|
fprintf(stderr, "Line %d: Unable to add route for interface %s: %s\n",
|
|
lineno, argv[4], strerror(errno));
|
|
|
|
goto error_daemon_route_add;
|
|
}
|
|
} else {
|
|
fprintf(stderr, "Line %d: Invalid route type '%s'\n",
|
|
lineno, argv[1]);
|
|
|
|
goto error_invalid_route;
|
|
}
|
|
|
|
return 0;
|
|
|
|
error_daemon_route_add:
|
|
error_invalid_route:
|
|
return -1;
|
|
}
|
|
|
|
struct config_handler {
|
|
const char *name;
|
|
int (*func)(patty_daemon *, int, int, char **);
|
|
};
|
|
|
|
struct config_handler handlers[] = {
|
|
{ "sock", handle_sock },
|
|
{ "pid", handle_pid },
|
|
{ "if", handle_if },
|
|
{ "route", handle_route },
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
static int handle_config_line(patty_conf_file *file,
|
|
patty_list *line,
|
|
void *ctx) {
|
|
patty_daemon *daemon = ctx;
|
|
patty_list_item *item = line->first;
|
|
|
|
int argc = (int)line->length,
|
|
i = 0,
|
|
ret = 0,
|
|
lineno = 0;
|
|
|
|
char **argv;
|
|
|
|
if (!item) {
|
|
return 0;
|
|
}
|
|
|
|
if ((argv = malloc((argc + 1) * sizeof(char *))) == NULL) {
|
|
goto error_malloc_argv;
|
|
}
|
|
|
|
while (item) {
|
|
patty_conf_token *token = item->value;
|
|
|
|
if (lineno == 0) {
|
|
lineno = token->lineno;
|
|
}
|
|
|
|
argv[i++] = token->text;
|
|
|
|
item = item->next;
|
|
}
|
|
|
|
argv[argc] = NULL;
|
|
|
|
for (i=0; handlers[i].name; i++) {
|
|
if (strcmp(argv[0], handlers[i].name) == 0) {
|
|
ret = handlers[i].func(daemon, lineno, argc, argv);
|
|
|
|
goto done;
|
|
}
|
|
}
|
|
|
|
fprintf(stderr, "Unknown configuration value '%s'\n", argv[0]);
|
|
|
|
done:
|
|
free(argv);
|
|
|
|
return ret;
|
|
|
|
error_malloc_argv:
|
|
return -1;
|
|
}
|
|
|
|
static int handle_simple_config(patty_daemon *daemon,
|
|
int argc,
|
|
char *argv0,
|
|
char **argv) {
|
|
patty_ax25_if *iface;
|
|
patty_ax25_addr addr;
|
|
|
|
patty_kiss_tnc_info info = {
|
|
.flags = PATTY_KISS_TNC_DEVICE,
|
|
.device = argv[2]
|
|
};
|
|
|
|
int i;
|
|
|
|
for (i=3; i<argc; i++) {
|
|
if (strcmp(argv[i], "crtscts") == 0) {
|
|
info.flags |= PATTY_KISS_TNC_FLOW;
|
|
info.flow = PATTY_KISS_TNC_FLOW_CRTSCTS;
|
|
} else if (strcmp(argv[i], "xonxoff") == 0) {
|
|
info.flags |= PATTY_KISS_TNC_FLOW;
|
|
info.flow = PATTY_KISS_TNC_FLOW_XONXOFF;
|
|
} else if (argv[i][0] >= '0' && argv[i][0] <= '9') {
|
|
int baud = atoi(argv[i]);
|
|
|
|
info.flags |= PATTY_KISS_TNC_BAUD;
|
|
info.baud = baud;
|
|
} else {
|
|
fprintf(stderr, "%s: Invalid device setting '%s'\n",
|
|
argv0, argv[i]);
|
|
|
|
goto error_invalid_device_setting;
|
|
}
|
|
}
|
|
|
|
if (patty_daemon_set_sock_path(daemon, argv[0]) < 0) {
|
|
fprintf(stderr, "%s: Unable to set socket path to %s: %s\n",
|
|
argv0, argv[0], strerror(errno));
|
|
|
|
goto error_set_sock_path;
|
|
}
|
|
|
|
if (patty_ax25_pton(argv[1], &addr) < 0) {
|
|
fprintf(stderr, "%s: Invalid callsign '%s'\n",
|
|
argv0, argv[1]);
|
|
|
|
goto error_invalid_callsign;
|
|
}
|
|
|
|
if ((iface = patty_ax25_if_new(PATTY_AX25_IF_KISS_TNC,
|
|
DEFAULT_IFNAME,
|
|
&info,
|
|
&addr)) == NULL) {
|
|
fprintf(stderr, "%s: Unable to create network interface %s: %s\n",
|
|
argv0, DEFAULT_IFNAME, strerror(errno));
|
|
|
|
goto error_if_new;
|
|
} else {
|
|
int fd = patty_kiss_tnc_fd(iface->tnc);
|
|
char *pty;
|
|
|
|
if (isatty(fd) && (pty = ptsname(fd)) != NULL) {
|
|
printf("if %s pty %s\n", DEFAULT_IFNAME, pty);
|
|
}
|
|
}
|
|
|
|
if (patty_daemon_if_add(daemon, iface) < 0) {
|
|
fprintf(stderr, "%s: Unable to add interface %s: %s\n",
|
|
argv0, DEFAULT_IFNAME, strerror(errno));
|
|
|
|
goto error_daemon_if_add;
|
|
}
|
|
|
|
if (patty_daemon_route_add_default(daemon, DEFAULT_IFNAME) < 0) {
|
|
fprintf(stderr, "%s: Unable to add default route to %s: %s\n",
|
|
argv0, DEFAULT_IFNAME, strerror(errno));
|
|
|
|
goto error_daemon_route_add_default;
|
|
}
|
|
|
|
return 0;
|
|
|
|
error_daemon_route_add_default:
|
|
error_daemon_if_add:
|
|
error_if_new:
|
|
error_invalid_callsign:
|
|
error_invalid_device_setting:
|
|
error_set_sock_path:
|
|
return -1;
|
|
}
|
|
|
|
enum flags {
|
|
FLAG_FG,
|
|
FLAG_STANDALONE,
|
|
FLAG_COUNT
|
|
};
|
|
|
|
int main(int argc, char **argv) {
|
|
int ret = 0,
|
|
index,
|
|
ch,
|
|
flags[FLAG_COUNT];
|
|
|
|
struct option opts[] = {
|
|
{ "fg", no_argument, &flags[FLAG_FG], 1 },
|
|
{ "config", required_argument, NULL, 'c' },
|
|
{ "standalone", no_argument, &flags[FLAG_STANDALONE], 1 },
|
|
{ NULL, no_argument, NULL, 0 }
|
|
};
|
|
|
|
char *config_file = DEFAULT_CONFIG_FILE;
|
|
|
|
patty_daemon *daemon;
|
|
|
|
memset(flags, '\0', sizeof(flags));
|
|
|
|
if ((daemon = patty_daemon_new()) == NULL) {
|
|
fprintf(stderr, "%s: %s: %s\n",
|
|
argv[0], "patty_daemon_new()", strerror(errno));
|
|
|
|
goto error_daemon_new;
|
|
}
|
|
|
|
while ((ch = getopt_long(argc, argv, "fc:s", opts, &index)) >= 0) {
|
|
switch (ch) {
|
|
case '?':
|
|
ret = usage(argc, argv, NULL);
|
|
goto error_invalid_args;
|
|
|
|
case 'c':
|
|
config_file = optarg;
|
|
break;
|
|
|
|
case 's':
|
|
flags[FLAG_STANDALONE] = 1;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (flags[FLAG_STANDALONE]) {
|
|
if (argc - optind < 1) {
|
|
ret = usage(argc, argv, "No socket path provided");
|
|
|
|
goto error_config;
|
|
} else if (argc - optind < 2) {
|
|
ret = usage(argc, argv, "No device path provided");
|
|
|
|
goto error_config;
|
|
} else if (argc - optind < 3) {
|
|
ret = usage(argc, argv, "No callsign provided");
|
|
|
|
goto error_config;
|
|
}
|
|
|
|
if (handle_simple_config(daemon,
|
|
argc - optind,
|
|
argv[0],
|
|
argv + optind) < 0) {
|
|
goto error_config;
|
|
}
|
|
} else if (patty_conf_read(config_file, handle_config_line, daemon) < 0) {
|
|
if (errno) {
|
|
fprintf(stderr, "%s: %s: %s: %s\n",
|
|
argv[0], "patty_conf_read()", config_file, strerror(errno));
|
|
}
|
|
|
|
goto error_config;
|
|
}
|
|
|
|
if (patty_daemon_run(daemon) < 0) {
|
|
fprintf(stderr, "%s: %s: %s\n",
|
|
argv[0], "patty_daemon_run()", strerror(errno));
|
|
|
|
goto error_daemon_run;
|
|
}
|
|
|
|
patty_daemon_destroy(daemon);
|
|
|
|
return 0;
|
|
|
|
error_daemon_run:
|
|
error_config:
|
|
error_invalid_args:
|
|
patty_daemon_destroy(daemon);
|
|
|
|
error_daemon_new:
|
|
return ret;
|
|
}
|