/*

 * Driver for AIS messages.

 *

 * See the file AIVDM.txt on the GPSD website for documentation and references.

 * AIVDM de-armoring is handled elsewhere; this is the binary-packet driver.

 *

 * Code for message types 1-15, 18-21, and 24 has been tested against

 * live data with known-good decodings. Code for message types 16-17,

 * 22-23, and 25-27 has not.

 * For the special IMO messages (types 6 and 8), only the following have been

 * tested against known-good decodings:

 *  - IMO236 met/hydro message: Type=8, DAC=1, FI=11

 *  - IMO289 met/hydro message: Type=8, DAC=1, FI=31

 *

 * This file is Copyright 2010 by the GPSD project

 * SPDX-License-Identifier: BSD-2-clause

 */

#include "../include/gpsd_config.h"  // must be before all includes

#include <ctype.h>

#include <stdlib.h>

#include <string.h>

#include "../include/gpsd.h"

#include "../include/bits.h"

/*

 * Parse the data from the device

 */

// beginning at bitvec bit start, unpack count sixbit characters

static void from_sixbit_untrimmed(const struct gpsd_errout_t *errout,

                                  const unsigned char *bitvec,

                                  const size_t bitlen,

                                  const unsigned start,

                                  unsigned count, char *to,

                                  const size_t to_sz)

{

    const char sixchr[65] =

        "@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_ !\"#$%&'()*+,-./0123456789:;<=>?";

    unsigned i;

    if (bitlen <= start) {

        GPSD_LOG(LOG_WARN, errout, "AIVDM bitlen %zu <=  start %u\n",

                 bitlen, start);

        to[0] = '\0';

        return;

    }

    if (to_sz <= count) {

        count = to_sz - 1;

    }

    // six-bit to ASCII

    for (i = 0; i < count; i++) {

        char newchar = sixchr[ubits(bitvec, start + 6 * i, 6U, false)];

        if ('@' == newchar) {

            break;

        }

        to[i] = newchar;

    }

    to[i] = '\0';

}

// trim spaces on right end

static void trim_spaces_on_right_end(char *to, size_t max)

{

    long long i;

    // pacify Coverity 498043, overflow

    for (i = strnlen(to, max) - 1; i >= 0; i--) {

        if (' ' == to[i] ||

            '@' == to[i]) {

            to[i] = '\0';

        } else {

            break;

        }

    }

}

/* beginning at bitvec bit start, unpack count sixbit characters

 * and remove trailing spaces */

static void from_sixbit(const struct gpsd_errout_t *errout,

                        const unsigned char *bitvec, const size_t bitlen,

                        const unsigned start,

                        const unsigned count, char *to, const size_t to_sz)

{

    from_sixbit_untrimmed(errout, bitvec, bitlen, start, count, to, to_sz);

    trim_spaces_on_right_end(to, count);

}

#define UBITS(s, l)     ubits(bits, s, l, false)

#define SBITS(s, l)     sbits(bits, s, l, false)

#define UCHARS(start, to)  \

        from_sixbit(errout, bits, bitlen, start, sizeof(to) - 1, \

                    to, sizeof(to))

#define ENDCHARS(start, to, to_sz)  \

        from_sixbit(errout, bits, bitlen, start, (bitlen - start) / 6, \

                    to, to_sz)

/* decode an AIS binary packet

 *

 * Return: True on success

 *         False on failure

 */

bool ais_binary_decode(const struct gpsd_errout_t *errout,

                       struct ais_t *ais,

                       const unsigned char *bits, size_t bitlen,

                       struct ais_type24_queue_t *type24_queue)

{

    unsigned int u;

    size_t bytelen = BITS_TO_BYTES(bitlen);

    ais->type = UBITS(0, 6);

    ais->repeat = UBITS(6, 2);

    ais->mmsi = UBITS(8, 30);

    GPSD_LOG(LOG_INF, errout,

             "AIVDM message type %d, MMSI %09d bitlen %zu bytelen %zu\n",

             ais->type, ais->mmsi, bitlen, bytelen);

#define PERMISSIVE_LENGTH_CHECK(correct) \

        if (bitlen < correct) { \

            GPSD_LOG(LOG_ERROR, errout, \

                     "AIVDM message type %d size < %d bits (%zd).\n",   \

                     ais->type, correct, bitlen);                       \

            return false; \

        } else if (bitlen > correct) { \

            GPSD_LOG(LOG_WARN, errout, \

                     "AIVDM message type %d size > %d bits (%zd).\n",   \

                     ais->type, correct, bitlen);                       \

        }

#define RANGE_CHECK(min, max) \

        if (bitlen < min || \

            bitlen > max) { \

            GPSD_LOG(LOG_ERROR, errout, \

                     "AIVDM message type %d size is out of range: " \

                     " %u <= (%zu) <= %u.\n", \

                     ais->type, min, bitlen, max);  \

            return false; \

        }

#define RANGE_CHECK6(min, max) \

        if (bitlen < min || \

            bitlen > max) { \

            GPSD_LOG(LOG_ERROR, errout, \

                     "AIVDM message type %d dac %u fid %u size is out of " \

                     "range %u <= (%zu) <= %u.\n", \

                     ais->type, ais->type6.dac, ais->type6.fid, \

                     min, bitlen, max);  \

            return false; \

        }

#define RANGE_CHECK8(min, max) \

        if (bitlen < min || \

            bitlen > max) { \

            GPSD_LOG(LOG_ERROR, errout, \

                     "AIVDM message type %d dac %u fid %u size is out of " \

                     "range %u <= (%zu) <= %u.\n", \

                     ais->type, ais->type8.dac, ais->type8.fid, \

                     min, bitlen, max);  \

            return false; \

        }

    /*

     * Something about the shape of this switch statement confuses

     * GNU indent so badly that there is no point in trying to be

     * finer-grained than leaving it all alone.

     */

// calculate offset into array

#define OFF(index) (ARRAY_BASE + (ELEMENT_SIZE * index))

    switch (ais->type) {

    case 1:  // Position Report

        FALLTHROUGH

    case 2:

        FALLTHROUGH

    case 3:

        // per https://www.navcen.uscg.gov/ais-class-a-reports

        // In 2023, most of our samples are 168, but some are 163 and 204.

        RANGE_CHECK(163, 204)

        ais->type1.status = UBITS(38, 4);

        ais->type1.turn = SBITS(42, 8);

        ais->type1.speed = UBITS(50, 10);

        ais->type1.accuracy = UBITS(60, 1) != 0;

        ais->type1.lon = SBITS(61, 28);

        ais->type1.lat = SBITS(89, 27);

        ais->type1.course = UBITS(116, 12);

        ais->type1.heading = UBITS(128, 9);

        ais->type1.second = UBITS(137, 6);

        ais->type1.maneuver = UBITS(143, 2);

        // ais->type1.spare     = UBITS(145, 3);

        ais->type1.raim = UBITS(148, 1) != 0;

        if (bitlen >= 168) {

            ais->type1.radio = UBITS(149, 19);

        } else {

            // less than 168, as of 2023 we have no examples of this.

            ais->type1.radio = UBITS(149, bitlen - 149);

        }

        break;

    case 4:  // Base Station Report

        FALLTHROUGH

    case 11: // UTC/Date Response

        PERMISSIVE_LENGTH_CHECK(168)

        ais->type4.year = UBITS(38, 14);

        ais->type4.month = UBITS(52, 4);

        ais->type4.day = UBITS(56, 5);

        ais->type4.hour = UBITS(61, 5);

        ais->type4.minute = UBITS(66, 6);

        ais->type4.second = UBITS(72, 6);

        ais->type4.accuracy = UBITS(78, 1) != 0;

        ais->type4.lon = SBITS(79, 28);

        ais->type4.lat = SBITS(107, 27);

        ais->type4.epfd = UBITS(134, 4);

        // ais->type4.spare      = UBITS(138, 10);

        ais->type4.raim = UBITS(148, 1) != 0;

        ais->type4.radio = UBITS(149, 19);

        break;

    case 5:  // Ship static and voyage related data

        if (424 != bitlen) {

            GPSD_LOG(LOG_WARN, errout,

                     "AIVDM message type 5 size not 424 bits (%zd).\n",

                     bitlen);

            /*

             * For unknown reasons, a lot of transmitters in the wild ship

             * with a length of 420 or 422.  This is a recoverable error.

             */

            if (420 > bitlen) {

                return false;

            }

        }

        ais->type5.ais_version = UBITS(38, 2);

        ais->type5.imo = UBITS(40, 30);

        UCHARS(70, ais->type5.callsign);

        UCHARS(112, ais->type5.shipname);

        ais->type5.shiptype = UBITS(232, 8);

        ais->type5.to_bow = UBITS(240, 9);

        ais->type5.to_stern = UBITS(249, 9);

        ais->type5.to_port = UBITS(258, 6);

        ais->type5.to_starboard = UBITS(264, 6);

        ais->type5.epfd = UBITS(270, 4);

        ais->type5.month = UBITS(274, 4);

        ais->type5.day = UBITS(278, 5);

        ais->type5.hour = UBITS(283, 5);

        ais->type5.minute = UBITS(288, 6);

        ais->type5.draught = UBITS(294, 8);

        UCHARS(302, ais->type5.destination);

        if (423 <= bitlen) {

            ais->type5.dte = UBITS(422, 1);

        }

        // ais->type5.spare        = UBITS(423, 1);

        break;

    case 6:  // Addressed Binary Message

        RANGE_CHECK(88, 1008);

        ais->type6.seqno = UBITS(38, 2);

        ais->type6.dest_mmsi = UBITS(40, 30);

        ais->type6.retransmit = UBITS(70, 1) != 0;

        // ais->type6.spare        = UBITS(71, 1);

        ais->type6.dac = UBITS(72, 10);

        ais->type6.fid = UBITS(82, 6);

        ais->type6.bitcount = bitlen - 88;

        // not strictly required - helps stability in testing

        (void)memset(ais->type6.bitdata, '\0', sizeof(ais->type6.bitdata));

        ais->type6.structured = false;

        // Inland AIS

        GPSD_LOG(LOG_PROG, errout,

                 "AIVDM: type 6 dac %u fid %u bitlen %zu\n",

                 ais->type6.dac, ais->type6.fid, bitlen);

        switch (ais->type6.dac) {

        case 1:

            // International

            switch (ais->type6.fid) {

            case 12:  // IMO236 - Dangerous cargo indication

                RANGE_CHECK6(144, 360);

                UCHARS(88, ais->type6.dac1fid12.lastport);

                ais->type6.dac1fid12.lmonth = UBITS(118, 4);

                ais->type6.dac1fid12.lday = UBITS(122, 5);

                ais->type6.dac1fid12.lhour = UBITS(127, 5);

                ais->type6.dac1fid12.lminute = UBITS(132, 6);

                if (144 < bitlen) {

                    RANGE_CHECK6(360, 360);

                    UCHARS(138, ais->type6.dac1fid12.nextport);

                    ais->type6.dac1fid12.nmonth = UBITS(168, 4);

                    ais->type6.dac1fid12.nday = UBITS(172, 5);

                    ais->type6.dac1fid12.nhour = UBITS(177, 5);

                    ais->type6.dac1fid12.nminute = UBITS(182, 6);

                    UCHARS(188, ais->type6.dac1fid12.dangerous);

                    UCHARS(308, ais->type6.dac1fid12.imdcat);

                    ais->type6.dac1fid12.unid = UBITS(332, 13);

                    ais->type6.dac1fid12.amount = UBITS(345, 10);

                    ais->type6.dac1fid12.unit = UBITS(355, 2);

                    // skip 3 bits

                }

                ais->type6.structured = true;

                break;

            case 14:

                // IMO236 - Tidal Window

                // similar to fid 32.

                RANGE_CHECK6(87, 1008);

                ais->type6.dac1fid32.month = UBITS(88, 4);

                ais->type6.dac1fid32.day = UBITS(92, 5);

#define ARRAY_BASE 97

#define ELEMENT_SIZE 93

                for (u = 0; ; u++) {

                    size_t off = OFF(u);

                    struct tidal_t *tp = &ais->type6.dac1fid32.tidals[u];

                    if (off >= bitlen ||

                        ROWS(ais->type6.dac1fid32.tidals) <= u) {

                        break;

                    }

                    tp->lat = SBITS(off + 0, 27);

                    tp->lon = SBITS(off + 27, 28);

                    tp->from_hour = UBITS(off + 55, 5);

                    tp->from_min = UBITS(off + 60, 6);

                    tp->to_hour = UBITS(off + 66, 5);

                    tp->to_min = UBITS(off + 71, 6);

                    tp->cdir = UBITS(off + 77, 9);

                    tp->cspeed = UBITS(off + 86, 7);

                }

                ais->type6.dac1fid32.ntidals = u;

#undef ARRAY_BASE

#undef ELEMENT_SIZE

                ais->type6.structured = true;

                break;

            case 15:

                // IMO236 - Extended Ship Static and Voyage Related Data

                RANGE_CHECK6(67, 1008);

                ais->type6.dac1fid15.airdraught = UBITS(56, 11);

                ais->type6.structured = true;

                break;

            case 16:

                // IMO236 - Number of persons on board

                RANGE_CHECK6(236, 289);

                if (136 == ais->type6.bitcount) {

                    ais->type6.dac1fid16.persons = UBITS(88, 13);  // 289

                } else {

                    ais->type6.dac1fid16.persons = UBITS(55, 13);  // 236

                }

                ais->type6.structured = true;

                break;

            case 18:

                // IMO289 - Clearance time to enter port

                // sometimes bitlen == 168!

                RANGE_CHECK6(168, 1008);

                ais->type6.dac1fid18.linkage = UBITS(88, 10);

                ais->type6.dac1fid18.month = UBITS(98, 4);

                ais->type6.dac1fid18.day = UBITS(102, 5);

                ais->type6.dac1fid18.hour = UBITS(107, 5);

                ais->type6.dac1fid18.minute = UBITS(112, 6);

                UCHARS(118, ais->type6.dac1fid18.portname);

                if (318 <= bitlen) {

                    UCHARS(238, ais->type6.dac1fid18.destination);

                    ais->type6.dac1fid18.lon = SBITS(268, 25);

                    ais->type6.dac1fid18.lat = SBITS(293, 24);

                    // skip 43 bits

                }

                ais->type6.structured = true;

                break;

            case 20:  // IMO289 - Berthing data - addressed

                RANGE_CHECK6(360, 1008);

                ais->type6.dac1fid20.linkage = UBITS(88, 10);

                ais->type6.dac1fid20.berth_length = UBITS(98, 9);

                ais->type6.dac1fid20.berth_depth = UBITS(107, 8);

                ais->type6.dac1fid20.position = UBITS(115, 3);

                ais->type6.dac1fid20.month = UBITS(118, 4);

                ais->type6.dac1fid20.day = UBITS(122, 5);

                ais->type6.dac1fid20.hour = UBITS(127, 5);

                ais->type6.dac1fid20.minute = UBITS(132, 6);

                ais->type6.dac1fid20.availability = UBITS(138, 1);

                ais->type6.dac1fid20.agent = UBITS(139, 2);

                ais->type6.dac1fid20.fuel = UBITS(141, 2);

                ais->type6.dac1fid20.chandler = UBITS(143, 2);

                ais->type6.dac1fid20.stevedore = UBITS(145, 2);

                ais->type6.dac1fid20.electrical = UBITS(147, 2);

                ais->type6.dac1fid20.water = UBITS(149, 2);

                ais->type6.dac1fid20.customs = UBITS(151, 2);

                ais->type6.dac1fid20.cartage = UBITS(153, 2);

                ais->type6.dac1fid20.crane = UBITS(155, 2);

                ais->type6.dac1fid20.lift = UBITS(157, 2);

                ais->type6.dac1fid20.medical = UBITS(159, 2);

                ais->type6.dac1fid20.navrepair = UBITS(161, 2);

                ais->type6.dac1fid20.provisions = UBITS(163, 2);

                ais->type6.dac1fid20.shiprepair = UBITS(165, 2);

                ais->type6.dac1fid20.surveyor = UBITS(167, 2);

                ais->type6.dac1fid20.steam = UBITS(169, 2);

                ais->type6.dac1fid20.tugs = UBITS(171, 2);

                ais->type6.dac1fid20.solidwaste = UBITS(173, 2);

                ais->type6.dac1fid20.liquidwaste = UBITS(175, 2);

                ais->type6.dac1fid20.hazardouswaste = UBITS(177, 2);

                ais->type6.dac1fid20.ballast = UBITS(179, 2);

                ais->type6.dac1fid20.additional = UBITS(181, 2);

                ais->type6.dac1fid20.regional1 = UBITS(183, 2);

                ais->type6.dac1fid20.regional2 = UBITS(185, 2);

                ais->type6.dac1fid20.future1 = UBITS(187, 2);

                ais->type6.dac1fid20.future2 = UBITS(189, 2);

                UCHARS(191, ais->type6.dac1fid20.berth_name);

                ais->type6.dac1fid20.berth_lon = SBITS(311, 25);

                ais->type6.dac1fid20.berth_lat = SBITS(336, 24);

                ais->type6.structured = true;

                break;

            case 23:  // IMO289 - Area notice - addressed

                break;

            case 25:  // IMO289 - Dangerous cargo indication

#define ARRAY_BASE 100

#define ELEMENT_SIZE 17

                RANGE_CHECK6(100, 1008);

                ais->type6.dac1fid25.unit = UBITS(88, 2);

                ais->type6.dac1fid25.amount = UBITS(90, 10);

                for (u = 0; ; u++) {

                    size_t off = OFF(u);

                    if (off >= bitlen ||

                        ROWS(ais->type6.dac1fid25.cargos) <= u) {

                        break;

                    }

                    ais->type6.dac1fid25.cargos[u].code = UBITS(off, 4);

                    ais->type6.dac1fid25.cargos[u].subtype =

                        UBITS(off + 4, 13);

                }

                ais->type6.dac1fid25.ncargos = u;

                ais->type6.structured = true;

#undef ARRAY_BASE

#undef ELEMENT_SIZE

                break;

            case 28:  // IMO289 - Route info - addressed

                RANGE_CHECK6(149, 1008);

                ais->type6.dac1fid28.linkage = UBITS(88, 10);

                ais->type6.dac1fid28.sender = UBITS(98, 3);

                ais->type6.dac1fid28.rtype = UBITS(101, 5);

                ais->type6.dac1fid28.month = UBITS(106, 4);

                ais->type6.dac1fid28.day = UBITS(110, 5);

                ais->type6.dac1fid28.hour = UBITS(115, 5);

                ais->type6.dac1fid28.minute = UBITS(120, 6);

                ais->type6.dac1fid28.duration = UBITS(126, 18);

                ais->type6.dac1fid28.waycount = UBITS(144, 5);

#define ARRAY_BASE 149

#define ELEMENT_SIZE 55

                for (u = 0; ; u++) {

                    size_t off = OFF(u);

                    if (off >= bitlen ||

                        ROWS(ais->type6.dac1fid28.waypoints) <= u ||

                        u >= ais->type6.dac1fid28.waycount) {

                        break;

                    }

                    ais->type6.dac1fid28.waypoints[u].lon = SBITS(off + 0, 28);

                    ais->type6.dac1fid28.waypoints[u].lat = SBITS(off + 28, 27);

                }

#undef ARRAY_BASE

#undef ELEMENT_SIZE

                ais->type6.structured = true;

                break;

            case 30:  // IMO289 - Text description - addressed

                RANGE_CHECK6(98, 1008);

                ais->type6.dac1fid30.linkage = UBITS(88, 10);

                ENDCHARS(98, ais->type6.dac1fid30.text,

                         sizeof(ais->type6.dac1fid30.text));

                ais->type6.structured = true;

                break;

            case 32:  // IMO289 - Tidal Window

                // similar to fid 14.

                RANGE_CHECK6(97, 1008);

                ais->type6.dac1fid32.month = UBITS(88, 4);

                ais->type6.dac1fid32.day = UBITS(92, 5);

#define ARRAY_BASE 97

#define ELEMENT_SIZE 88

                for (u = 0; ; u++) {

                    size_t off = OFF(u);

                    if (off >= bitlen ||

                        ROWS(ais->type6.dac1fid32.tidals) <= u) {

                        break;

                    }

                    struct tidal_t *tp = &ais->type6.dac1fid32.tidals[u];

                    tp->lon = SBITS(off + 0, 25);

                    tp->lat = SBITS(off + 25, 24);

                    tp->from_hour = UBITS(off + 49, 5);

                    tp->from_min = UBITS(off + 54, 6);

                    tp->to_hour = UBITS(off + 60, 5);

                    tp->to_min = UBITS(off + 65, 6);

                    tp->cdir = UBITS(off + 71, 9);

                    tp->cspeed = UBITS(off + 80, 8);

                }

                ais->type6.dac1fid32.ntidals = u;

#undef ARRAY_BASE

#undef ELEMENT_SIZE

                ais->type6.structured = true;

                break;

            }

            break;

        case  200:

            switch (ais->type6.fid) {

            case 21:  // ETA at lock/bridge/terminal

                RANGE_CHECK6(248, 248);

                UCHARS(88, ais->type6.dac200fid21.country);

                UCHARS(100, ais->type6.dac200fid21.locode);

                UCHARS(118, ais->type6.dac200fid21.section);

                UCHARS(148, ais->type6.dac200fid21.terminal);

                UCHARS(178, ais->type6.dac200fid21.hectometre);

                ais->type6.dac200fid21.month = UBITS(208, 4);

                ais->type6.dac200fid21.day = UBITS(212, 5);

                ais->type6.dac200fid21.hour = UBITS(217, 5);

                ais->type6.dac200fid21.minute = UBITS(222, 6);

                ais->type6.dac200fid21.tugs = UBITS(228, 3);

                ais->type6.dac200fid21.airdraught = UBITS(231, 12);

                // skip 5 bits

                ais->type6.structured = true;

                break;

            case 22:  // RTA at lock/bridge/terminal

                RANGE_CHECK6(232, 232);

                UCHARS(88, ais->type6.dac200fid22.country);

                UCHARS(100, ais->type6.dac200fid22.locode);

                UCHARS(118, ais->type6.dac200fid22.section);

                UCHARS(148, ais->type6.dac200fid22.terminal);

                UCHARS(178, ais->type6.dac200fid22.hectometre);

                ais->type6.dac200fid22.month = UBITS(208, 4);

                ais->type6.dac200fid22.day = UBITS(212, 5);

                ais->type6.dac200fid22.hour = UBITS(217, 5);

                ais->type6.dac200fid22.minute = UBITS(222, 6);

                ais->type6.dac200fid22.status = UBITS(228, 2);

                // skip 2 bits

                ais->type6.structured = true;

                break;

            case 55:

                // Number of Persons On Board

                RANGE_CHECK6(168, 168);

                ais->type6.dac200fid55.crew = UBITS(88, 8);

                ais->type6.dac200fid55.passengers = UBITS(96, 13);

                ais->type6.dac200fid55.personnel = UBITS(109, 8);

                // skip 51 bits

                ais->type6.structured = true;

                break;

            }

            break;

        case 235:

            FALLTHROUGH

        case 250:

            // UK and Republic Of Ireland

            switch (ais->type6.fid) {

            case 10:  // GLA - AtoN monitoring data

                RANGE_CHECK6(136, 136);

                ais->type6.dac235fid10.ana_int = UBITS(88, 10);

                ais->type6.dac235fid10.ana_ext1 = UBITS(98, 10);

                ais->type6.dac235fid10.ana_ext2 = UBITS(108, 10);

                ais->type6.dac235fid10.racon = UBITS(118, 2);

                ais->type6.dac235fid10.light = UBITS(120, 2);

                ais->type6.dac235fid10.alarm = UBITS(122, 1);

                ais->type6.dac235fid10.stat_ext = UBITS(123, 8);

                ais->type6.dac235fid10.off_pos = UBITS(131, 1);

                // skip 4 bits

                ais->type6.structured = true;

                break;

            }

            break;

        default:

            break;

        }

        if (!ais->type6.structured) {

            u = BITS_TO_BYTES(ais->type6.bitcount);

            if (sizeof(ais->type6.bitdata) < u) {

                u = sizeof(ais->type6.bitdata);

                ais->type6.bitcount = u * 8;

            }

            (void)memcpy(ais->type6.bitdata, bits + (88 / CHAR_BIT), u);

            GPSD_LOG(LOG_WARN, errout,

                     "AIVDM: type 6 unknown dac %u fid %u bitlen %zu\n",

                     ais->type6.dac, ais->type6.fid, bitlen);

        }

        break;

    case 7:  // Binary acknowledge

        FALLTHROUGH

    case 13: // Safety Related Acknowledge

    {

        unsigned int mmsi[4];

        unsigned seqno[4];

        RANGE_CHECK(72, 168);

#define ARRAY_BASE 40

#define ELEMENT_SIZE 32

        for (u = 0; u < ROWS(mmsi); u++) {

            size_t off = OFF(u);

            if (off < bitlen) {

                mmsi[u] = UBITS(off, 30);

                seqno[u] = UBITS(off + 32, 2);

            } else {

                mmsi[u] = 0;

                seqno[u] = 0;

            }

        }

#undef ARRAY_BASE

#undef ELEMENT_SIZE

        ais->type7.mmsi1 = mmsi[0];

        ais->type7.seqno1 = seqno[0];

        ais->type7.mmsi2 = mmsi[1];

        ais->type7.seqno2 = seqno[1];

        ais->type7.mmsi3 = mmsi[2];

        ais->type7.seqno3 = seqno[2];

        ais->type7.mmsi4 = mmsi[3];

        ais->type7.seqno4 = seqno[3];

        break;

    }

    case 8:  // Binary Broadcast Message

        RANGE_CHECK8(56, 1008);

        // ais->type8.spare        = UBITS(38, 2);

        ais->type8.dac = UBITS(40, 10);

        ais->type8.fid = UBITS(50, 6);

        ais->type8.bitcount = bitlen - 56;

        // not strictly required - helps stability in testing

        (void)memset(ais->type8.bitdata, '\0', sizeof(ais->type8.bitdata));

        ais->type8.structured = false;

        GPSD_LOG(LOG_PROG, errout, "AIVDM: type 8 dac %u fid %u bitlen %zu\n",

                 ais->type8.dac, ais->type8.fid, bitlen);

        switch (ais->type8.dac) {

        case 1:

            // International

            switch (ais->type8.fid) {

            case 11:  // IMO236 - Meteorological/Hydrological data

                // layout is almost identical to FID=31 from IMO289

                // FIXME: we get length 352??

                RANGE_CHECK8(346, 352);

                ais->type8.dac1fid11.lat = SBITS(56, 24);

                ais->type8.dac1fid11.lon = SBITS(80, 25);

                ais->type8.dac1fid11.day = UBITS(105, 5);

                ais->type8.dac1fid11.hour = UBITS(110, 5);

                ais->type8.dac1fid11.minute = UBITS(115, 6);

                ais->type8.dac1fid11.wspeed = UBITS(121, 7);

                ais->type8.dac1fid11.wgust = UBITS(128, 7);

                ais->type8.dac1fid11.wdir = UBITS(135, 9);

                ais->type8.dac1fid11.wgustdir = UBITS(144, 9);

                ais->type8.dac1fid11.airtemp = UBITS(153, 11);

                ais->type8.dac1fid11.humidity = UBITS(164, 7);

                ais->type8.dac1fid11.dewpoint = UBITS(171, 10);

                ais->type8.dac1fid11.pressure = UBITS(181, 9);

                ais->type8.dac1fid11.pressuretend = UBITS(190, 2);

                ais->type8.dac1fid11.visibility = UBITS(192, 8);

                ais->type8.dac1fid11.waterlevel = UBITS(200, 9);

                ais->type8.dac1fid11.leveltrend = UBITS(209, 2);

                ais->type8.dac1fid11.cspeed = UBITS(211, 8);

                ais->type8.dac1fid11.cdir = UBITS(219, 9);

                ais->type8.dac1fid11.cspeed2 = UBITS(228, 8);

                ais->type8.dac1fid11.cdir2 = UBITS(236, 9);

                ais->type8.dac1fid11.cdepth2 = UBITS(245, 5);

                ais->type8.dac1fid11.cspeed3 = UBITS(250, 8);

                ais->type8.dac1fid11.cdir3 = UBITS(258, 9);

                ais->type8.dac1fid11.cdepth3 = UBITS(267, 5);

                ais->type8.dac1fid11.waveheight = UBITS(272, 8);

                ais->type8.dac1fid11.waveperiod = UBITS(280, 6);

                ais->type8.dac1fid11.wavedir = UBITS(286, 9);

                ais->type8.dac1fid11.swellheight = UBITS(295, 8);

                ais->type8.dac1fid11.swellperiod = UBITS(303, 6);

                ais->type8.dac1fid11.swelldir = UBITS(309, 9);

                ais->type8.dac1fid11.seastate = UBITS(318, 4);

                ais->type8.dac1fid11.watertemp = UBITS(322, 10);

                ais->type8.dac1fid11.preciptype = UBITS(332, 3);

                ais->type8.dac1fid11.salinity = UBITS(335, 9);

                ais->type8.dac1fid11.ice = UBITS(344, 2);

                ais->type8.structured = true;

                break;

            case 13:  // IMO236 - Fairway closed

                RANGE_CHECK8(468, 468);

                UCHARS(56, ais->type8.dac1fid13.reason);

                UCHARS(176, ais->type8.dac1fid13.closefrom);

                UCHARS(296, ais->type8.dac1fid13.closeto);

                ais->type8.dac1fid13.radius = UBITS(416, 10);

                ais->type8.dac1fid13.extunit = UBITS(426, 2);

                ais->type8.dac1fid13.fday = UBITS(428, 5);

                ais->type8.dac1fid13.fmonth = UBITS(433, 4);

                ais->type8.dac1fid13.fhour = UBITS(437, 5);

                ais->type8.dac1fid13.fminute = UBITS(442, 6);

                ais->type8.dac1fid13.tday = UBITS(448, 5);

                ais->type8.dac1fid13.tmonth = UBITS(453, 4);

                ais->type8.dac1fid13.thour = UBITS(457, 5);

                ais->type8.dac1fid13.tminute = UBITS(462, 6);

                // skip 4 bits

                ais->type8.structured = true;

                break;

            case 15:  // IMO236 -

                      // Extended

                      // ship and

                      // voyage

                RANGE_CHECK8(67, 72);

                ais->type8.dac1fid15.airdraught = UBITS(56, 11);

                // skip 5 bits

                ais->type8.structured = true;

                break;

            case 16:

                // Number of Persons On Board

                // dac 1, fid 18.  bitlen = 776 ???

                RANGE_CHECK8(72, 776);

                if (136 == ais->type8.bitcount) {

                    ais->type8.dac1fid16.persons = UBITS(88, 13);  // 289

                    ais->type8.structured = true;

                } else if (72 == ais->type8.bitcount) {

                    ais->type8.dac1fid16.persons = UBITS(55, 13);  // 236

                    ais->type8.structured = true;

                }

                break;

            case 17:

                // IMO289 - VTS-generated/synthetic targets

                RANGE_CHECK8(56, 1008);

#define ARRAY_BASE 56

#define ELEMENT_SIZE 122

                for (u = 0; ; u++) {

                    struct target_t *tp;

                    size_t off = OFF(u);

                    if (off >= bitlen ||

                        ROWS(ais->type8.dac1fid17.targets) <= u) {

                        break;

                    }

                    tp = &ais->type8.dac1fid17.targets[u];

                    tp->idtype = UBITS(off + 0, 2);

                    switch (tp->idtype) {

                    case DAC1FID17_IDTYPE_MMSI:

                        tp->id.mmsi = UBITS(off + 2, 42);

                        break;

                    case DAC1FID17_IDTYPE_IMO:

                        tp->id.imo = UBITS(off + 2, 42);

                        break;

                    case DAC1FID17_IDTYPE_CALLSIGN:

                        UCHARS(off + 2, tp->id.callsign);

                        break;

                    default:

                        UCHARS(off + 2, tp->id.other);

                        break;

                    }

                    // skip 4 bits

                    tp->lat = SBITS(off + 48, 24);

                    tp->lon = SBITS(off + 72, 25);

                    tp->course = UBITS(off + 97, 9);

                    tp->second = UBITS(off + 106, 6);

                    tp->speed = UBITS(off + 112, 10);

                }

                ais->type8.dac1fid17.ntargets = u;

#undef ARRAY_BASE

#undef ELEMENT_SIZE

                ais->type8.structured = true;

                break;

            case 19:  // IMO289 - Marine Traffic Signal

                RANGE_CHECK8(258, 1008);

                ais->type8.dac1fid19.linkage = UBITS(56, 10);

                UCHARS(66, ais->type8.dac1fid19.station);

                ais->type8.dac1fid19.lon = SBITS(186, 25);

                ais->type8.dac1fid19.lat = SBITS(211, 24);

                ais->type8.dac1fid19.status = UBITS(235, 2);

                ais->type8.dac1fid19.signal = UBITS(237, 5);

                ais->type8.dac1fid19.hour = UBITS(242, 5);

                ais->type8.dac1fid19.minute = UBITS(247, 6);

                ais->type8.dac1fid19.nextsignal = UBITS(253, 5);

                // skip 102 bits

                ais->type8.structured = true;

                break;

            case 21:  // IMO289 - Weather obs. report from ship

                break;

            case 22:  // IMO289 - Area notice - broadcast

                break;

            case 24:

                // IMO289 - Extended ship static & voyage-related data

                break;

            case 26:  // IMO289 - Environmental

                break;

            case 27:  // IMO289 - Route information - broadcast

                RANGE_CHECK8(117, 1008);

                ais->type8.dac1fid27.linkage = UBITS(56, 10);

                ais->type8.dac1fid27.sender = UBITS(66, 3);

                ais->type8.dac1fid27.rtype = UBITS(69, 5);

                ais->type8.dac1fid27.month = UBITS(74, 4);

                ais->type8.dac1fid27.day = UBITS(78, 5);

                ais->type8.dac1fid27.hour = UBITS(83, 5);

                ais->type8.dac1fid27.minute = UBITS(88, 6);

                ais->type8.dac1fid27.duration = UBITS(94, 18);

                ais->type8.dac1fid27.waycount = UBITS(112, 5);

#define ARRAY_BASE 117

#define ELEMENT_SIZE 55

                for (u = 0; u < ais->type8.dac1fid27.waycount; u++) {

                    size_t off = OFF(u);

                    if (off >= bitlen ||

                        ROWS(ais->type8.dac1fid27.waypoints) <= u) {

                        break;

                    }

                    ais->type8.dac1fid27.waypoints[u].lon = SBITS(off + 0, 28);

                    ais->type8.dac1fid27.waypoints[u].lat = SBITS(off + 28, 27);

                }

#undef ARRAY_BASE

#undef ELEMENT_SIZE

                ais->type8.structured = true;

                break;

            case 29:  // IMO289 - Text Description - broadcast

                RANGE_CHECK8(66, 1008);

                ais->type8.dac1fid29.linkage = UBITS(56, 10);

                ENDCHARS(66, ais->type8.dac1fid29.text,

                         sizeof(ais->type8.dac1fid29.text));

                ais->type8.structured = true;

                break;

            case 31:  // IMO289 - Meteorological/Hydrological data

                // 368??

                RANGE_CHECK8(340, 368);

                ais->type8.dac1fid31.lon = SBITS(56, 25);

                ais->type8.dac1fid31.lat = SBITS(81, 24);

                ais->type8.dac1fid31.accuracy = (bool)UBITS(105, 1);

                ais->type8.dac1fid31.day = UBITS(106, 5);

                ais->type8.dac1fid31.hour = UBITS(111, 5);

                ais->type8.dac1fid31.minute = UBITS(116, 6);

                ais->type8.dac1fid31.wspeed = UBITS(122, 7);

                ais->type8.dac1fid31.wgust = UBITS(129, 7);

                ais->type8.dac1fid31.wdir = UBITS(136, 9);

                ais->type8.dac1fid31.wgustdir = UBITS(145, 9);

                ais->type8.dac1fid31.airtemp = SBITS(154, 11);

                ais->type8.dac1fid31.humidity = UBITS(165, 7);

                ais->type8.dac1fid31.dewpoint = SBITS(172, 10);

                ais->type8.dac1fid31.pressure = UBITS(182, 9);

                ais->type8.dac1fid31.pressuretend = UBITS(191, 2);

                ais->type8.dac1fid31.visgreater = UBITS(193, 1);

                ais->type8.dac1fid31.visibility = UBITS(194, 7);

                ais->type8.dac1fid31.waterlevel = UBITS(201, 12);

                ais->type8.dac1fid31.leveltrend = UBITS(213, 2);

                ais->type8.dac1fid31.cspeed = UBITS(215, 8);

                ais->type8.dac1fid31.cdir = UBITS(223, 9);

                ais->type8.dac1fid31.cspeed2 = UBITS(232, 8);

                ais->type8.dac1fid31.cdir2 = UBITS(240, 9);

                ais->type8.dac1fid31.cdepth2 = UBITS(249, 5);

                ais->type8.dac1fid31.cspeed3 = UBITS(254, 8);

                ais->type8.dac1fid31.cdir3 = UBITS(262, 9);

                ais->type8.dac1fid31.cdepth3 = UBITS(271, 5);

                ais->type8.dac1fid31.waveheight = UBITS(276, 8);

                ais->type8.dac1fid31.waveperiod = UBITS(284, 6);

                ais->type8.dac1fid31.wavedir = UBITS(290, 9);

                ais->type8.dac1fid31.swellheight = UBITS(299, 8);

                ais->type8.dac1fid31.swellperiod = UBITS(307, 6);

                ais->type8.dac1fid31.swelldir = UBITS(313, 9);

                ais->type8.dac1fid31.seastate = UBITS(322, 4);

                ais->type8.dac1fid31.watertemp = SBITS(326, 10);

                ais->type8.dac1fid31.preciptype = UBITS(336, 3);

                ais->type8.dac1fid31.salinity = UBITS(339, 9);

                ais->type8.dac1fid31.ice = UBITS(348, 2);

                ais->type8.structured = true;

                break;

            }

            break;

        case 200:

            switch (ais->type8.fid) {

            case 10:  // Inland ship static and voyage related data

                // bitlen = 424??

                RANGE_CHECK8(168, 424);

                UCHARS(56, ais->type8.dac200fid10.vin);

                ais->type8.dac200fid10.length = UBITS(104, 13);

                ais->type8.dac200fid10.beam = UBITS(117, 10);

                ais->type8.dac200fid10.shiptype = UBITS(127, 14);

                ais->type8.dac200fid10.hazard = UBITS(141, 3);

                ais->type8.dac200fid10.draught = UBITS(144, 11);

                ais->type8.dac200fid10.loaded = UBITS(155, 2);

                ais->type8.dac200fid10.speed_q = (bool)UBITS(157, 1);

                ais->type8.dac200fid10.course_q = (bool)UBITS(158, 1);

                ais->type8.dac200fid10.heading_q = (bool)UBITS(159, 1);

                // skip 8 bits

                /*

                 * Attempt to prevent false matches with this message type

                 * by range-checking certain fields.

                 */

                if (DAC200FID10_HAZARD_MAX < ais->type8.dac200fid10.hazard ||

                    !isascii((int)ais->type8.dac200fid10.vin[0])) {

                    ais->type8.structured = false;

                } else {

                    ais->type8.structured = true;

                }

                break;

            case 23:  // EMMA warning

                RANGE_CHECK8(256, 256);

                ais->type8.dac200fid23.start_year = UBITS(56, 8);

                ais->type8.dac200fid23.start_month = UBITS(64, 4);

                ais->type8.dac200fid23.start_day = UBITS(68, 5);

                ais->type8.dac200fid23.end_year = UBITS(73, 8);

                ais->type8.dac200fid23.end_month = UBITS(81, 4);

                ais->type8.dac200fid23.end_day = UBITS(85, 5);

                ais->type8.dac200fid23.start_hour = UBITS(90, 5);

                ais->type8.dac200fid23.start_minute = UBITS(95, 6);

                ais->type8.dac200fid23.end_hour = UBITS(101, 5);

                ais->type8.dac200fid23.end_minute = UBITS(106, 6);

                ais->type8.dac200fid23.start_lon = SBITS(112, 28);

                ais->type8.dac200fid23.start_lat = SBITS(140, 27);

                ais->type8.dac200fid23.end_lon = SBITS(167, 28);

                ais->type8.dac200fid23.end_lat = SBITS(195, 27);

                ais->type8.dac200fid23.type = UBITS(222, 4);

                ais->type8.dac200fid23.min = SBITS(226, 9);

                ais->type8.dac200fid23.max = SBITS(235, 9);

                ais->type8.dac200fid23.intensity = UBITS(244, 2);

                ais->type8.dac200fid23.wind = UBITS(246, 4);

                // skip 6 bits

                ais->type8.structured = true;

                break;

            case 24:  // Water level

                RANGE_CHECK8(168, 168);

                UCHARS(56, ais->type8.dac200fid24.country);

#define ARRAY_BASE 68

#define ELEMENT_SIZE 25

                for (u = 0; ; u++) {

                    size_t off = OFF(u);

                    if (off >= bitlen ||

                        ROWS(ais->type8.dac200fid24.gauges) <= u) {

                        break;

                    }

                    ais->type8.dac200fid24.gauges[u].id = UBITS(off + 0,  11);

                    ais->type8.dac200fid24.gauges[u].level = SBITS(off + 11,

                                                                   14);

                }

                ais->type8.dac200fid24.ngauges = u;

#undef ARRAY_BASE

#undef ELEMENT_SIZE

                // skip 6 bits

                ais->type8.structured = true;

                break;

            case 40:  // Signal status

                RANGE_CHECK8(168, 168);

                ais->type8.dac200fid40.lon = SBITS(56, 28);

                ais->type8.dac200fid40.lat = SBITS(84, 27);

                ais->type8.dac200fid40.form = UBITS(111, 4);

                ais->type8.dac200fid40.facing = UBITS(115, 9);

                ais->type8.dac200fid40.direction = UBITS(124, 3);

                ais->type8.dac200fid40.status = UBITS(127, 30);

                // skip 11 bits

                ais->type8.structured = true;

                break;

            }

            break;

        default:

            break;

        }

        // land here if we failed to match a known DAC/FID

        if (!ais->type8.structured) {

            u = BITS_TO_BYTES(ais->type8.bitcount);

            if (sizeof(ais->type8.bitdata) < u) {

                u = sizeof(ais->type8.bitdata);

                ais->type8.bitcount = u * 8;

            }

            (void)memcpy(ais->type8.bitdata, bits + (56 / CHAR_BIT), u);

            size_t valid_bits_in_last_byte = ais->type8.bitcount % CHAR_BIT;

            if (valid_bits_in_last_byte > 0) {

                // huh??

                ais->type8.bitdata[u - 1] &=

                    (0xFF << (8 - valid_bits_in_last_byte));

            }

            GPSD_LOG(LOG_WARN, errout,

                     "AIVDM: type 8 unknown dac %u fid %u bitlen %zu\n",

                     ais->type8.dac, ais->type8.fid, bitlen);

        }

        break;

    case 9:  // Standard SAR Aircraft Position Report

        PERMISSIVE_LENGTH_CHECK(168);

        ais->type9.alt = UBITS(38, 12);

        ais->type9.speed = UBITS(50, 10);

        ais->type9.accuracy = (bool)UBITS(60, 1);

        ais->type9.lon = SBITS(61, 28);

        ais->type9.lat = SBITS(89, 27);

        ais->type9.course = UBITS(116, 12);

        ais->type9.second = UBITS(128, 6);

        ais->type9.regional = UBITS(134, 8);

        ais->type9.dte = UBITS(142, 1);

        // ais->type9.spare      = UBITS(143, 3);

        ais->type9.assigned = UBITS(146, 1) != 0;

        ais->type9.raim = UBITS(147, 1) != 0;

        ais->type9.radio = UBITS(148, 20);

        break;

    case 10:  // UTC/Date inquiry

        PERMISSIVE_LENGTH_CHECK(72);

        // ais->type10.spare        = UBITS(38, 2);

        ais->type10.dest_mmsi = UBITS(40, 30);

        // ais->type10.spare2       = UBITS(70, 2);

        break;

    case 12:  // Safety Related Message

        RANGE_CHECK(72, 1008);

        ais->type12.seqno = UBITS(38, 2);

        ais->type12.dest_mmsi = UBITS(40, 30);

        ais->type12.retransmit = (bool)UBITS(70, 1);

        // ais->type12.spare        = UBITS(71, 1);

        ENDCHARS(72, ais->type12.text, sizeof(ais->type12.text));

        break;

    case 14:  // Safety Related Broadcast Message

        RANGE_CHECK(40, 960);

        // ais->type14.spare          = UBITS(38, 2);

        ENDCHARS(40, ais->type14.text, sizeof(ais->type14.text));

        break;

    case 15:

        // Interrogation

        RANGE_CHECK(88, 168);

        (void)memset(&ais->type15, '\0', sizeof(ais->type15));

        // ais->type14.spare         = UBITS(38, 2);

        ais->type15.mmsi1 = UBITS(40, 30);

        ais->type15.type1_1 = UBITS(70, 6);

        ais->type15.offset1_1 = UBITS(76, 12);

        // ais->type14.spare2        = UBITS(88, 2);

        if (90 < bitlen) {

            ais->type15.type1_2 = UBITS(90, 6);

            ais->type15.offset1_2 = UBITS(96, 12);

            // ais->type14.spare3      = UBITS(108, 2);

            if (110 < bitlen) {

                ais->type15.mmsi2 = UBITS(110, 30);

                ais->type15.type2_1 = UBITS(140, 6);

                ais->type15.offset2_1 = UBITS(146, 12);

                // ais->type14.spare4    = UBITS(158, 2);

            }

        }

        break;

    case 16:

        // Assigned Mode Command

        RANGE_CHECK(96, 168);

        ais->type16.mmsi1 = UBITS(40, 30);

        ais->type16.offset1 = UBITS(70, 12);

        ais->type16.increment1 = UBITS(82, 10);

        if (144 > bitlen) {

            ais->type16.mmsi2 = ais->type16.offset2 = 0;

            ais->type16.increment2 = 0;

        } else {