/*

 * 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;

    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:\n",

             ais->type, ais->mmsi);

#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 (%zd).\n", \

                     ais->type, bitlen);                                \

            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.

     */

    // *INDENT-OFF*

    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);

        if (200 == ais->type6.dac) {

            switch (ais->type6.fid) {

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

                if (248 != bitlen) {

                    break;

                }

                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

                if (232 != bitlen) {

                    break;

                }

                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

                if (168 != bitlen) {

                    break;

                }

                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;

            }

        } else if (235 == ais->type6.dac ||

                   250 == ais->type6.dac) {

        // UK and Republic Of Ireland

            switch (ais->type6.fid) {

            case 10:    // GLA - AtoN monitoring data

                if (136 != bitlen) {

                    break;

                }

                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;

            }

        } else if (1 == ais->type6.dac) {

            // International

            switch (ais->type6.fid) {

            case 12:    // IMO236 - Dangerous cargo indication

                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);

                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_CHECK(87, 1008);

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

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

#define ARRAY_BASE 97

#define ELEMENT_SIZE 93

                if ((ARRAY_BASE +

                     ELEMENT_SIZE * ROWS(ais->type6.dac1fid32.tidals)) <

                    bitlen) {

                    bitlen = ARRAY_BASE +

                             ELEMENT_SIZE * ROWS(ais->type6.dac1fid32.tidals);

                }

                for (u = 0; ARRAY_BASE + (ELEMENT_SIZE*u) <= bitlen; u++) {

                    int a = ARRAY_BASE + (ELEMENT_SIZE*u);

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

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

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

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

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

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

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

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

                    tp->cspeed    = UBITS(a + 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_CHECK(67, 1008);

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

                ais->type6.structured = true;

                break;

            case 16:    // IMO236 - Number of persons on board

                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

                // FIXME: sometimes bitlen == 168!

                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);

                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_CHECK(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

                RANGE_CHECK(100, 1008);

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

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

                if ((100 + 17 * ROWS(ais->type6.dac1fid25.cargos)) < bitlen) {

                    bitlen = 100 + 17 * ROWS(ais->type6.dac1fid25.cargos);

                }

                for (u = 0; 100 + u * 17 < bitlen; u++) {

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

                        UBITS(100 + u * 17, 4);

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

                        UBITS(104 + u * 17, 13);

                }

                ais->type6.dac1fid25.ncargos = u;

                ais->type6.structured = true;

                break;

            case 28:    // IMO289 - Route info - addressed

                RANGE_CHECK(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

                if ((ARRAY_BASE +

                     ELEMENT_SIZE * ROWS(ais->type6.dac1fid28.waypoints)) <

                    bitlen) {

                    bitlen = ARRAY_BASE +

                        ELEMENT_SIZE * ROWS(ais->type6.dac1fid28.waypoints);

                }

                for (u = 0;

                     u < (unsigned char)ais->type6.dac1fid28.waycount; u++) {

                    int a = ARRAY_BASE + (ELEMENT_SIZE*u);

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

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

                }

#undef ARRAY_BASE

#undef ELEMENT_SIZE

                ais->type6.structured = true;

                break;

            case 30:    // IMO289 - Text description - addressed

                RANGE_CHECK(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_CHECK(97, 1008);

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

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

#define ARRAY_BASE 97

#define ELEMENT_SIZE 88

                if ((ARRAY_BASE +

                     ELEMENT_SIZE * ROWS(ais->type6.dac1fid32.tidals)) <

                    bitlen) {

                    bitlen = ARRAY_BASE +

                             ELEMENT_SIZE * ROWS(ais->type6.dac1fid32.tidals);

                }

                for (u = 0; ARRAY_BASE + (ELEMENT_SIZE * u) <= bitlen; u++) {

                    unsigned a = ARRAY_BASE + (ELEMENT_SIZE * u);

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

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

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

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

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

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

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

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

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

                }

                ais->type6.dac1fid32.ntidals = u;

#undef ARRAY_BASE

#undef ELEMENT_SIZE

                ais->type6.structured = true;

                break;

            }

        }

        if (!ais->type6.structured) {

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

                         BITS_TO_BYTES(ais->type6.bitcount));

        }

        break;

    case 7:    // Binary acknowledge

        FALLTHROUGH

    case 13:   // Safety Related Acknowledge

    {

        unsigned int mmsi[4];

        unsigned seqno[4];

        RANGE_CHECK(72, 168);

        for (u = 0; u < sizeof(mmsi)/sizeof(mmsi[0]); u++) {

            if (40 + 32 * u < bitlen) {

                mmsi[u] = UBITS(40 + 32 * u, 30);

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

            } else {

                mmsi[u] = 0;

                seqno[u] = 0;

            }

        }

        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_CHECK(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);

        if (1 == ais->type8.dac) {

            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_CHECK(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

                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

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

                // skip 5 bits

                ais->type8.structured = true;

                break;

            case 16:        // Number of Persons On Board

                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_CHECK(56, 1008);

#define ARRAY_BASE 56

#define ELEMENT_SIZE 122

                if ((ARRAY_BASE +

                     ELEMENT_SIZE * ROWS(ais->type8.dac1fid17.targets)) <

                    bitlen) {

                    bitlen = ARRAY_BASE +

                             ELEMENT_SIZE * ROWS(ais->type8.dac1fid17.targets);

                }

                for (u = 0; ARRAY_BASE + (ELEMENT_SIZE * u) <= bitlen; u++) {

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

                    unsigned a = ARRAY_BASE + (ELEMENT_SIZE * u);

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

                    switch (tp->idtype) {

                    case DAC1FID17_IDTYPE_MMSI:

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

                        break;

                    case DAC1FID17_IDTYPE_IMO:

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

                        break;

                    case DAC1FID17_IDTYPE_CALLSIGN:

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

                        break;

                    default:

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

                        break;

                    }

                    // skip 4 bits

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

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

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

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

                    tp->speed   = UBITS(a + 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_CHECK(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_CHECK(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

                if ((ARRAY_BASE +

                     ELEMENT_SIZE * ROWS(ais->type8.dac1fid27.waypoints)) <

                    bitlen) {

                    bitlen = ARRAY_BASE +

                         ELEMENT_SIZE * ROWS(ais->type8.dac1fid27.waypoints);

                }

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

                    int a = ARRAY_BASE + (ELEMENT_SIZE * u);

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

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

                }

#undef ARRAY_BASE

#undef ELEMENT_SIZE

                ais->type8.structured = true;

                break;

            case 29:        // IMO289 - Text Description - broadcast

                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

                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;

            }

        } else if (200 == ais->type8.dac) {

            switch (ais->type8.fid) {

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

                if (168 != bitlen) {

                    break;

                }

                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

                if (256 != bitlen) {

                    break;

                }

                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

                if (168 != bitlen) {

                    break;

                }

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

#define ARRAY_BASE 68

#define ELEMENT_SIZE 25

                for (u = 0; ARRAY_BASE + (ELEMENT_SIZE * u) < bitlen;

                     u++) {

                    int a = ARRAY_BASE + (ELEMENT_SIZE * u);

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

                    ais->type8.dac200fid24.gauges[u].level = SBITS(a + 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

                if (168 != bitlen) {

                    break;

                }

                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;

            }

        }

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

        if (!ais->type8.structured) {

            size_t number_of_bytes = BITS_TO_BYTES(ais->type8.bitcount);

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

                         number_of_bytes);

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

            if(valid_bits_in_last_byte > 0) {

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

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

            }

        }

        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=ais->type16.increment2 = 0;

        } else {

            ais->type16.mmsi2   = UBITS(92, 30);

            ais->type16.offset2 = UBITS(122, 12);

            ais->type16.increment2      = UBITS(134, 10);

        }

        break;

    case 17:    // GNSS Broadcast Binary Message

        RANGE_CHECK(80, 816);

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

        ais->type17.lon         = SBITS(40, 18);

        ais->type17.lat         = SBITS(58, 17);

        //ais->type17.spare     = UBITS(75, 5);

        ais->type17.bitcount    = bitlen - 80;

        (void)memcpy(ais->type17.bitdata, bits + (80 / CHAR_BIT),