AMBE3000F new chipname for DVSI-devices

[pe1msz]

Hi, I got a message from a customer, that the dvmega dongle (latest production) does not work on dvswitch. I tested it, and the old (AMBE3000R) works fine, but the new chipmodel of DVSI fails. This chip identifies as AMBE3000F
Is there any setting I can change, or can you also allow this chip-model?

PS, bluedv identifies it, and works fine with the F-type. (only to inform that the dongle is ok)

Grts, Ruud, PE1MSZ, DVMEGA-team

[emanuelelaface]

Hi, I have the same issue with a DVS3003 and the AMBEServer3003 that presents the dongle as three DVS3000. The chip-model is AMBE3000F and the Analog Bridge doesn’t recognize it. Moreover also the reset and ack are different (maybe something else, I do not know). Any help here is appreciated. Thanks!

[pe1msz]

Hi, as the code still has not been updated to support the new F versions of DVSI, you can do the following:
download Analogbridge to your pc, and edit it with hexedit. Search for AMBE3000R, en edit the R, put an F there.
upload again and make sure the file is executable (chmod +x AnalogBdridge). this workaround should resolve the issue for now.

[emanuelelaface]

I tried it, but it does not work, at least with the AMBEServer for 3 channels. It starts but crashes immediately after with another error (I do not remember which one).

In the end I solved the problem putting a proxy in the middle that check for all the packets that are not correctly formatted and send them to the server. This is the code if someone is interested in using it.

// AMBE multi-proxy (DV3K fixed) - C port of ambeproxy.py
// Listens on local UDP ports and forwards to AMBE server ports with DV3K tweaks.

#include <arpa/inet.h>
#include <errno.h>
#include <netinet/in.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/select.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>

#define LISTEN_IP "127.0.0.1"
#define SERVER_IP "127.0.0.1"

#define MAX_PKT 8192

typedef struct {
    uint16_t lport;
    uint16_t sport;
} PortMap;

static const PortMap MAP[] = {
    // {2470, 2460},
    {2471, 2461},
    {2472, 2462},
};

static const size_t MAP_COUNT = sizeof(MAP) / sizeof(MAP[0]);

// -------- DV3K helpers (header: 0x61, LEN(2 bytes BE), TYPE(1 byte)) --------
static inline bool is_dv3k(const unsigned char *pkt, ssize_t len) {
    return len >= 4 && pkt[0] == 0x61;
}

static inline uint16_t dv3k_len(const unsigned char *pkt) {
    return (uint16_t)((pkt[1] << 8) | pkt[2]);
}


static inline unsigned char dv3k_type(const unsigned char *pkt) {
    return pkt[3];
}

static inline int dv3k_cmd(const unsigned char *pkt, ssize_t len) {
    return (len >= 5) ? pkt[4] : -1;
}

static void dv3k_fix_len(unsigned char *pkt, ssize_t len) {
    if (len < 4) {
        return;
    }
    uint16_t want = (uint16_t)(len - 4);
    uint16_t have = dv3k_len(pkt);
    if (have == want) {
        return;
    }
    // riscrive LEN in big-endian nei byte [1],[2], preserva TYPE (byte [3])
    pkt[1] = (unsigned char)((want >> 8) & 0xFF);
    pkt[2] = (unsigned char)(want & 0xFF);
}

static ssize_t dv3k_control_reply(const unsigned char *payload, size_t payload_len,
                                  unsigned char *out, size_t out_cap) {
    if (out_cap < payload_len + 4) {
        return -1;
    }
    out[0] = 0x61;
    out[1] = (unsigned char)((payload_len >> 8) & 0xFF);
    out[2] = (unsigned char)(payload_len & 0xFF);
    out[3] = 0x00; // TYPE=0
    if (payload_len > 0) {
        memcpy(out + 4, payload, payload_len);
    }
    return (ssize_t)(payload_len + 4);
}

static ssize_t dv3k_ack_reset(unsigned char cmd_byte, unsigned char status,
                              unsigned char *out, size_t out_cap) {
    unsigned char payload[2] = { (unsigned char)(cmd_byte & 0xFF), (unsigned char)(status & 0xFF) };
    return dv3k_control_reply(payload, sizeof(payload), out, out_cap);
}

static ssize_t dv3k_ready(unsigned char *out, size_t out_cap) {
    unsigned char payload[1] = { 0x39 }; // READY (payload 0x39)
    return dv3k_control_reply(payload, sizeof(payload), out, out_cap);
}

static void replace_ambe3000f(unsigned char *pkt, ssize_t len) {
    const unsigned char from[] = { 'A','M','B','E','3','0','0','0','F','\0' };
    const unsigned char to[]   = { 'A','M','B','E','3','0','0','0','R','\0' };
    const size_t pat_len = sizeof(from);

    if (len < (ssize_t)pat_len) {
        return;
    }

    for (ssize_t i = 0; i <= len - (ssize_t)pat_len; i++) {
        if (memcmp(pkt + i, from, pat_len) == 0) {
            memcpy(pkt + i, to, pat_len);
        }
    }
}

int main(void) {
    int socks[MAP_COUNT];
    struct sockaddr_in last_client[MAP_COUNT];
    bool has_last_client[MAP_COUNT];

    memset(has_last_client, 0, sizeof(has_last_client));

    for (size_t i = 0; i < MAP_COUNT; i++) {
        int s = socket(AF_INET, SOCK_DGRAM, 0);
        if (s < 0) {
            perror("socket");
            return 1;
        }

        struct sockaddr_in addr;
        memset(&addr, 0, sizeof(addr));
        addr.sin_family = AF_INET;
        addr.sin_port = htons(MAP[i].lport);
        if (inet_pton(AF_INET, LISTEN_IP, &addr.sin_addr) != 1) {
            fprintf(stderr, "Invalid LISTEN_IP: %s\n", LISTEN_IP);
            close(s);
            return 1;
        }

        if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
            perror("bind");
            close(s);
            return 1;
        }

        socks[i] = s;
    }

    printf("AMBE multi-proxy (DV3K fixed):\n");
    for (size_t i = 0; i < MAP_COUNT; i++) {
        printf("  %s:%u -> %s:%u\n", LISTEN_IP, MAP[i].lport, SERVER_IP, MAP[i].sport);
    }

    unsigned char buf[MAX_PKT];

    while (1) {
        fd_set rfds;
        FD_ZERO(&rfds);
        int maxfd = -1;
        for (size_t i = 0; i < MAP_COUNT; i++) {
            FD_SET(socks[i], &rfds);
            if (socks[i] > maxfd) {
                maxfd = socks[i];
            }
        }

        int rc = select(maxfd + 1, &rfds, NULL, NULL, NULL);
        if (rc < 0) {
            if (errno == EINTR) {
                continue;
            }
            perror("select");
            break;
        }

        for (size_t i = 0; i < MAP_COUNT; i++) {
            int s = socks[i];
            if (!FD_ISSET(s, &rfds)) {
                continue;
            }

            struct sockaddr_in src;
            socklen_t slen = sizeof(src);
            ssize_t n = recvfrom(s, buf, sizeof(buf), 0, (struct sockaddr *)&src, &slen);
            if (n < 0) {
                perror("recvfrom");
                continue;
            }

            // build server sockaddr
            struct sockaddr_in server;
            memset(&server, 0, sizeof(server));
            server.sin_family = AF_INET;
            server.sin_port = htons(MAP[i].sport);
            if (inet_pton(AF_INET, SERVER_IP, &server.sin_addr) != 1) {
                fprintf(stderr, "Invalid SERVER_IP: %s\n", SERVER_IP);
                continue;
            }

            bool from_server = (src.sin_addr.s_addr == server.sin_addr.s_addr) &&
                               (src.sin_port == server.sin_port);

            // ---------------- server -> client ----------------
            if (from_server) {
                if (!has_last_client[i]) {
                    continue;
                }

                if (is_dv3k(buf, n)) {
                    dv3k_fix_len(buf, n);

                    // cambia AMBE3000F->AMBE3000R SOLO su control cmd=0x30 (Get Product ID)
                    if (dv3k_type(buf) == 0x00 && dv3k_cmd(buf, n) == 0x30) {
                        replace_ambe3000f(buf, n);
                    }
                }

                sendto(s, buf, n, 0, (struct sockaddr *)&last_client[i], sizeof(last_client[i]));
                continue;
            }

            // ---------------- client -> server ----------------
            last_client[i] = src;
            has_last_client[i] = true;

            // intercetta RESET/RESETSOFTCFG: rispondi tu e NON inoltrare
            if (is_dv3k(buf, n) && dv3k_type(buf) == 0x00) {
                int c = dv3k_cmd(buf, n);
                if (c == 0x33 || c == 0x34) { // RESET / RESETSOFTCFG
                    unsigned char out[MAX_PKT];
                    ssize_t out_len = dv3k_ack_reset((unsigned char)c, 0x00, out, sizeof(out));
                    if (out_len > 0) {
                        sendto(s, out, (size_t)out_len, 0, (struct sockaddr *)&src, sizeof(src));
                    }
                    out_len = dv3k_ready(out, sizeof(out));
                    if (out_len > 0) {
                        sendto(s, out, (size_t)out_len, 0, (struct sockaddr *)&src, sizeof(src));
                    }
                    continue;
                }
            }

            // inoltra tutto il resto al server
            sendto(s, buf, n, 0, (struct sockaddr *)&server, sizeof(server));
        }
    }

    for (size_t i = 0; i < MAP_COUNT; i++) {
        close(socks[i]);
    }

    return 0;
}