Quesion: AX.25 socket data corruption

* Quesion: AX.25 socket data corruption
@ 2020-02-24 13:11 Ivan Savitsky
  2020-03-15 18:58 ` Cathryn Mataga
  0 siblings, 1 reply; 6+ messages in thread
From: Ivan Savitsky @ 2020-02-24 13:11 UTC (permalink / raw)
  To: linux-hams

Hello,

I was asking this question on
https://github.com/ve7fet/linuxax25/issues but was directed to this
mailing list for further investigation. I apologise for possible
duplicates if you're reading the both discussions.

I'm writing a proxy between a AX.25 VC socket and a TCP socket.
It is needed for programmes like telnet to work directly over AX.25 VC.
This allows full screen visual remote terminal access without using IP
over AX.25.

On the server side I'm creating a listening AX.25 socket. After
accepting a AX.25 client, the TCP connection to the telnetd is
created.

On the client side a listening TCP socket is created. After accepting
a telnet connection to the TCP socket, the AX.25 VC is created.

The AX.25 link I am currently testing is created by ax25ipd over the
Ethernet LAN between two linux PCs which reside in the same room. I've
done a few tests over the real radio as well with same results.

The problem is that the data passing between the two sockets (VC and
TCP) is quite often became corrupted, duplicated or misplaced. In the
packet dump with axlisten command there are "REJ" frames from the
client side and duplicated "I" frames from the server side which are
corresponding to the corrupted output in the telnet session (LORA3-8
is a server and LORA4 is a client):

axip: fm LORA3-8 to LORA4 ctl I76^ pid=F0(Text) len 64 12:08:23
axip: fm LORA4 to LORA3-8 ctl REJ7v 12:08:23
axip: fm LORA3-8 to LORA4 ctl I77+ pid=F0(Text) len 80 12:08:23
axip: fm LORA4 to LORA3-8 ctl RR0- 12:08:23
axip: fm LORA3-8 to LORA4 ctl I77+ pid=F0(Text) len 160 12:08:23
axip: fm LORA4 to LORA3-8 ctl REJ0- 12:08:23
axip: fm LORA3-8 to LORA4 ctl I77^ pid=F0(Text) len 80 12:08:23
axip: fm LORA3-8 to LORA4 ctl I70+ pid=F0(Text) len 256 12:08:23

The data forwarding routine is straightforward:

/* Forward data between sockets */
void forward_data(int source_sock, int destination_sock, const char* name) {
    ssize_t n;
    fd_set read_fd;
    char buffer[BUF_SIZE];

    if (fcntl(source_sock, F_SETFL, O_NONBLOCK) < 0) {
        perror("socket");
        close(source_sock);
        return;
    }

    int paclen = ax25_config_get_paclen(ax25_port);

    while (1) {
        FD_ZERO(&read_fd);
        FD_SET(source_sock, &read_fd);
        select(source_sock + 1, &read_fd, NULL, NULL, NULL);
        if (FD_ISSET(source_sock, &read_fd)) {
            n = read(source_sock, buffer, BUF_SIZE);
        }
        if (n <=0 ) break;

        int offset = 0;

        while (offset != n) {
            int len = (n-offset > paclen) ? paclen : n-offset;
            int ret = write(destination_sock, buffer+offset, len); //
send data to output socket
            if (ret == -1) {
                printf("\n");
                if (errno == EWOULDBLOCK || errno == EAGAIN) {
                    perror("write");
                    usleep(100000);
                    continue;
                }
                break;
            }
            offset += ret;
        }
    }
â€¦

The question is: whether it is possible to pass the data reliably in
such a manner between the VC and TCP sockets and, if so, what should
be done from my side to eliminate the data corruption?

Thanks,
Ivan

^ permalink raw reply	[flat|nested] 6+ messages in thread