1f4ffc98ac
Implement new patty client code, replacing src/call.c with src/client.c
providing clients with an interface dealing with file descriptors valid
in their process space; this also obviates the need to open a Unix
domain socket to a patty server explicitly, and helps keep track of
sockets opened on the server, locally
Changes:
* Implement patty_client_new() to handle opening the server Unix
domain socket, and to allocate a dict for mapping server-side
sockets with current process file descriptors
* Reimplement all server calls in src/call.c around the new
patty_client type; calls which result in the creation of a
Unix98 PTY by the patty server now handle opening the local PTY
and setting the file descriptor to raw mode. Furthermore, these
calls deal exclusively in terms of current process file
descriptors
* Refactor src/server.c to use the new patty_client type and calls
* Refactor examples/client.c, examples/server.c, examples/ax25dump.c
to use the new patty_client type and calls
* Fix a bug in src/server.c, respond_accept() wherein a 0, rather
than the file descriptor of the socket, is sent to the client as a
return value
160 lines
4.1 KiB
C
160 lines
4.1 KiB
C
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <stdarg.h>
|
|
#include <unistd.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/socket.h>
|
|
#include <sys/un.h>
|
|
#include <fcntl.h>
|
|
#include <errno.h>
|
|
|
|
#include <patty/ax25.h>
|
|
#include <patty/print.h>
|
|
|
|
static void 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 /var/run/patty/patty.sock localcall\n", argv[0]);
|
|
|
|
exit(1);
|
|
}
|
|
|
|
int main(int argc, char **argv) {
|
|
patty_client *client;
|
|
patty_client_setsockopt_if ifreq;
|
|
|
|
patty_ax25_addr peer;
|
|
|
|
uint8_t buf[4096];
|
|
ssize_t readlen;
|
|
|
|
patty_kiss_tnc *raw;
|
|
|
|
int fd;
|
|
|
|
if (argc < 2) {
|
|
usage(argc, argv, "No patty socket provided");
|
|
} else if (argc < 3) {
|
|
usage(argc, argv, "No local callsign provided");
|
|
} else if (argc > 3) {
|
|
usage(argc, argv, "Too many arguments provided");
|
|
}
|
|
|
|
patty_ax25_pton(argv[2], 0, &peer);
|
|
|
|
if ((client = patty_client_new(argv[1])) == NULL) {
|
|
fprintf(stderr, "%s: %s: %s: %s\n",
|
|
argv[0], "patty_client_new()", argv[1], strerror(errno));
|
|
|
|
goto error_client_new;
|
|
}
|
|
|
|
if ((fd = patty_client_socket(client, PATTY_AX25_PROTO_NONE, PATTY_AX25_SOCK_RAW)) < 0) {
|
|
fprintf(stderr, "%s: %s: %s\n",
|
|
argv[0], "patty_client_socket()", strerror(errno));
|
|
|
|
goto error_client_socket;
|
|
}
|
|
|
|
strncpy(ifreq.name, "kiss0", sizeof(ifreq.name));
|
|
|
|
if (patty_client_setsockopt(client, fd, PATTY_AX25_SOCK_IF, &ifreq, sizeof(ifreq)) < 0) {
|
|
fprintf(stderr, "%s: %s: %s\n",
|
|
argv[0], "patty_client_setsockopt()", strerror(errno));
|
|
|
|
goto error_client_setsockopt;
|
|
}
|
|
|
|
if ((raw = patty_kiss_tnc_new_fd(fd)) == NULL) {
|
|
fprintf(stderr, "%s: fd %d: %s: %s\n",
|
|
argv[0], fd, "patty_kiss_tnc_new_fd()", strerror(errno));
|
|
|
|
goto error_kiss_tnc_new_fd;
|
|
}
|
|
|
|
while ((readlen = patty_kiss_tnc_recv(raw, buf, sizeof(buf), NULL)) > 0) {
|
|
ssize_t decoded,
|
|
offset = 0;
|
|
|
|
patty_ax25_frame frame;
|
|
|
|
if ((decoded = patty_ax25_frame_decode_address(&frame, buf, readlen)) < 0) {
|
|
printf("Invalid frame address\n");
|
|
|
|
goto error_ax25_frame_decode_address;
|
|
} else {
|
|
offset += decoded;
|
|
}
|
|
|
|
if ((decoded = patty_ax25_frame_decode_control(&frame, PATTY_AX25_FRAME_NORMAL, buf, decoded, readlen)) < 0) {
|
|
printf("Invalid frame control\n");
|
|
|
|
goto error_ax25_frame_decode_control;
|
|
} else {
|
|
offset += decoded;
|
|
}
|
|
|
|
if (patty_print_frame_header(stdout, &frame) < 0) {
|
|
fprintf(stderr, "%s: %s: %s\n",
|
|
argv[0], "patty_print_frame_header()", strerror(errno));
|
|
|
|
goto error_io;
|
|
}
|
|
|
|
if (frame.type == PATTY_AX25_FRAME_XID) {
|
|
patty_ax25_params params;
|
|
|
|
if (patty_ax25_frame_decode_xid(¶ms,
|
|
buf,
|
|
offset,
|
|
readlen) < 0) {
|
|
printf("Invalid XID parameters\n");
|
|
|
|
goto error_ax25_frame_decode_xid;
|
|
} else {
|
|
if (patty_print_params(stdout, ¶ms) < 0) {
|
|
goto error_io;
|
|
}
|
|
}
|
|
}
|
|
|
|
error_ax25_frame_decode_xid:
|
|
error_ax25_frame_decode_control:
|
|
error_ax25_frame_decode_address:
|
|
if (patty_print_hexdump(stdout, buf, readlen) < 0) {
|
|
goto error_io;
|
|
}
|
|
|
|
if (fflush(stdout) < 0) {
|
|
goto error_io;
|
|
}
|
|
}
|
|
|
|
patty_kiss_tnc_destroy(raw);
|
|
|
|
patty_client_close(client, fd);
|
|
|
|
patty_client_destroy(client);
|
|
|
|
return 0;
|
|
|
|
error_io:
|
|
patty_kiss_tnc_destroy(raw);
|
|
|
|
error_kiss_tnc_new_fd:
|
|
error_client_setsockopt:
|
|
error_client_socket:
|
|
(void)patty_client_close(client, fd);
|
|
|
|
error_client_new:
|
|
return 1;
|
|
}
|