/src/gpsd/gpsd-3.27.6~dev/drivers/driver_ais.c
Line | Count | Source |
1 | | /* |
2 | | * Driver for AIS messages. |
3 | | * |
4 | | * See the file AIVDM.txt on the GPSD website for documentation and references. |
5 | | * AIVDM de-armoring is handled elsewhere; this is the binary-packet driver. |
6 | | * |
7 | | * Code for message types 1-15, 18-21, and 24 has been tested against |
8 | | * live data with known-good decodings. Code for message types 16-17, |
9 | | * 22-23, and 25-27 has not. |
10 | | * For the special IMO messages (types 6 and 8), only the following have been |
11 | | * tested against known-good decodings: |
12 | | * - IMO236 met/hydro message: Type=8, DAC=1, FI=11 |
13 | | * - IMO289 met/hydro message: Type=8, DAC=1, FI=31 |
14 | | * |
15 | | * This file is Copyright 2010 by the GPSD project |
16 | | * SPDX-License-Identifier: BSD-2-clause |
17 | | */ |
18 | | |
19 | | #include "../include/gpsd_config.h" // must be before all includes |
20 | | |
21 | | #include <ctype.h> |
22 | | #include <stdlib.h> |
23 | | #include <string.h> |
24 | | |
25 | | #include "../include/gpsd.h" |
26 | | #include "../include/bits.h" |
27 | | |
28 | | /* |
29 | | * Parse the data from the device |
30 | | */ |
31 | | |
32 | | // beginning at bitvec bit start, unpack count sixbit characters |
33 | | static void from_sixbit_untrimmed(const struct gpsd_errout_t *errout, |
34 | | const unsigned char *bitvec, |
35 | | const size_t bitlen, |
36 | | const unsigned start, |
37 | | unsigned count, char *to, |
38 | | const size_t to_sz) |
39 | 0 | { |
40 | 0 | const char sixchr[65] = |
41 | 0 | "@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_ !\"#$%&'()*+,-./0123456789:;<=>?"; |
42 | 0 | unsigned i; |
43 | |
|
44 | 0 | if (bitlen <= start) { |
45 | 0 | GPSD_LOG(LOG_WARN, errout, "AIVDM bitlen %zu <= start %u\n", |
46 | 0 | bitlen, start); |
47 | 0 | to[0] = '\0'; |
48 | 0 | return; |
49 | 0 | } |
50 | 0 | if (to_sz <= count) { |
51 | 0 | count = to_sz - 1; |
52 | 0 | } |
53 | | |
54 | | // six-bit to ASCII |
55 | 0 | for (i = 0; i < count; i++) { |
56 | 0 | char newchar = sixchr[ubits(bitvec, start + 6 * i, 6U, false)]; |
57 | |
|
58 | 0 | if ('@' == newchar) { |
59 | 0 | break; |
60 | 0 | } |
61 | 0 | to[i] = newchar; |
62 | 0 | } |
63 | 0 | to[i] = '\0'; |
64 | 0 | } |
65 | | |
66 | | // trim spaces on right end |
67 | | static void trim_spaces_on_right_end(char* to, size_t max) |
68 | 0 | { |
69 | 0 | long long i; |
70 | | |
71 | | // pacify Coverity 498043, overflow |
72 | 0 | for (i = strnlen(to, max) - 1; i >= 0; i--) { |
73 | 0 | if (' ' == to[i] || |
74 | 0 | '@' == to[i]) { |
75 | 0 | to[i] = '\0'; |
76 | 0 | } else { |
77 | 0 | break; |
78 | 0 | } |
79 | 0 | } |
80 | 0 | } |
81 | | |
82 | | /* beginning at bitvec bit start, unpack count sixbit characters |
83 | | * and remove trailing spaces */ |
84 | | static void from_sixbit(const struct gpsd_errout_t *errout, |
85 | | const unsigned char *bitvec, const size_t bitlen, |
86 | | const unsigned start, |
87 | | const unsigned count, char *to, const size_t to_sz) |
88 | 0 | { |
89 | 0 | from_sixbit_untrimmed(errout, bitvec, bitlen, start, count, to, to_sz); |
90 | 0 | trim_spaces_on_right_end(to, count); |
91 | 0 | } |
92 | | |
93 | 0 | #define UBITS(s, l) ubits(bits, s, l, false) |
94 | 0 | #define SBITS(s, l) sbits(bits, s, l, false) |
95 | | #define UCHARS(start, to) \ |
96 | 0 | from_sixbit(errout, bits, bitlen, start, sizeof(to) - 1, to, sizeof(to)) |
97 | | |
98 | | #define ENDCHARS(start, to, to_sz) \ |
99 | 0 | from_sixbit(errout, bits, bitlen, start, (bitlen - start) / 6, to, to_sz) |
100 | | |
101 | | /* decode an AIS binary packet |
102 | | * |
103 | | * Return: True on success |
104 | | * False on failure |
105 | | */ |
106 | | bool ais_binary_decode(const struct gpsd_errout_t *errout, |
107 | | struct ais_t *ais, |
108 | | const unsigned char *bits, size_t bitlen, |
109 | | struct ais_type24_queue_t *type24_queue) |
110 | 0 | { |
111 | 0 | unsigned int u; |
112 | |
|
113 | 0 | ais->type = UBITS(0, 6); |
114 | 0 | ais->repeat = UBITS(6, 2); |
115 | 0 | ais->mmsi = UBITS(8, 30); |
116 | 0 | GPSD_LOG(LOG_INF, errout, "AIVDM message type %d, MMSI %09d:\n", |
117 | 0 | ais->type, ais->mmsi); |
118 | |
|
119 | 0 | #define PERMISSIVE_LENGTH_CHECK(correct) \ |
120 | 0 | if (bitlen < correct) { \ |
121 | 0 | GPSD_LOG(LOG_ERROR, errout, \ |
122 | 0 | "AIVDM message type %d size < %d bits (%zd).\n", \ |
123 | 0 | ais->type, correct, bitlen); \ |
124 | 0 | return false; \ |
125 | 0 | } else if (bitlen > correct) { \ |
126 | 0 | GPSD_LOG(LOG_WARN, errout, \ |
127 | 0 | "AIVDM message type %d size > %d bits (%zd).\n", \ |
128 | 0 | ais->type, correct, bitlen); \ |
129 | 0 | } |
130 | |
|
131 | 0 | #define RANGE_CHECK(min, max) \ |
132 | 0 | if (bitlen < min || bitlen > max) { \ |
133 | 0 | GPSD_LOG(LOG_ERROR, errout, \ |
134 | 0 | "AIVDM message type %d size is out of range (%zd).\n", \ |
135 | 0 | ais->type, bitlen); \ |
136 | 0 | return false; \ |
137 | 0 | } |
138 | | |
139 | | /* |
140 | | * Something about the shape of this switch statement confuses |
141 | | * GNU indent so badly that there is no point in trying to be |
142 | | * finer-grained than leaving it all alone. |
143 | | */ |
144 | | // *INDENT-OFF* |
145 | 0 | switch (ais->type) { |
146 | 0 | case 1: // Position Report |
147 | 0 | FALLTHROUGH |
148 | 0 | case 2: |
149 | 0 | FALLTHROUGH |
150 | 0 | case 3: |
151 | | // per https://www.navcen.uscg.gov/ais-class-a-reports |
152 | | // In 2023, most of our samples are 168, but some are 163 and 204. |
153 | 0 | RANGE_CHECK(163, 204) |
154 | 0 | ais->type1.status = UBITS(38, 4); |
155 | 0 | ais->type1.turn = SBITS(42, 8); |
156 | 0 | ais->type1.speed = UBITS(50, 10); |
157 | 0 | ais->type1.accuracy = UBITS(60, 1) != 0; |
158 | 0 | ais->type1.lon = SBITS(61, 28); |
159 | 0 | ais->type1.lat = SBITS(89, 27); |
160 | 0 | ais->type1.course = UBITS(116, 12); |
161 | 0 | ais->type1.heading = UBITS(128, 9); |
162 | 0 | ais->type1.second = UBITS(137, 6); |
163 | 0 | ais->type1.maneuver = UBITS(143, 2); |
164 | | // ais->type1.spare = UBITS(145, 3); |
165 | 0 | ais->type1.raim = UBITS(148, 1) != 0; |
166 | 0 | if(bitlen >= 168) { |
167 | 0 | ais->type1.radio = UBITS(149, 19); |
168 | 0 | } else { |
169 | | // less than 168, as of 2023 we have no examples of this. |
170 | 0 | ais->type1.radio = UBITS(149, bitlen - 149); |
171 | 0 | } |
172 | 0 | break; |
173 | 0 | case 4: // Base Station Report |
174 | 0 | FALLTHROUGH |
175 | 0 | case 11: // UTC/Date Response |
176 | 0 | PERMISSIVE_LENGTH_CHECK(168) |
177 | 0 | ais->type4.year = UBITS(38, 14); |
178 | 0 | ais->type4.month = UBITS(52, 4); |
179 | 0 | ais->type4.day = UBITS(56, 5); |
180 | 0 | ais->type4.hour = UBITS(61, 5); |
181 | 0 | ais->type4.minute = UBITS(66, 6); |
182 | 0 | ais->type4.second = UBITS(72, 6); |
183 | 0 | ais->type4.accuracy = UBITS(78, 1) != 0; |
184 | 0 | ais->type4.lon = SBITS(79, 28); |
185 | 0 | ais->type4.lat = SBITS(107, 27); |
186 | 0 | ais->type4.epfd = UBITS(134, 4); |
187 | | //ais->type4.spare = UBITS(138, 10); |
188 | 0 | ais->type4.raim = UBITS(148, 1) != 0; |
189 | 0 | ais->type4.radio = UBITS(149, 19); |
190 | 0 | break; |
191 | 0 | case 5: // Ship static and voyage related data |
192 | 0 | if (424 != bitlen) { |
193 | 0 | GPSD_LOG(LOG_WARN, errout, |
194 | 0 | "AIVDM message type 5 size not 424 bits (%zd).\n", |
195 | 0 | bitlen); |
196 | | /* |
197 | | * For unknown reasons, a lot of transmitters in the wild ship |
198 | | * with a length of 420 or 422. This is a recoverable error. |
199 | | */ |
200 | 0 | if (420 > bitlen) { |
201 | 0 | return false; |
202 | 0 | } |
203 | 0 | } |
204 | 0 | ais->type5.ais_version = UBITS(38, 2); |
205 | 0 | ais->type5.imo = UBITS(40, 30); |
206 | 0 | UCHARS(70, ais->type5.callsign); |
207 | 0 | UCHARS(112, ais->type5.shipname); |
208 | 0 | ais->type5.shiptype = UBITS(232, 8); |
209 | 0 | ais->type5.to_bow = UBITS(240, 9); |
210 | 0 | ais->type5.to_stern = UBITS(249, 9); |
211 | 0 | ais->type5.to_port = UBITS(258, 6); |
212 | 0 | ais->type5.to_starboard = UBITS(264, 6); |
213 | 0 | ais->type5.epfd = UBITS(270, 4); |
214 | 0 | ais->type5.month = UBITS(274, 4); |
215 | 0 | ais->type5.day = UBITS(278, 5); |
216 | 0 | ais->type5.hour = UBITS(283, 5); |
217 | 0 | ais->type5.minute = UBITS(288, 6); |
218 | 0 | ais->type5.draught = UBITS(294, 8); |
219 | 0 | UCHARS(302, ais->type5.destination); |
220 | 0 | if (423 <= bitlen) { |
221 | 0 | ais->type5.dte = UBITS(422, 1); |
222 | 0 | } |
223 | | //ais->type5.spare = UBITS(423, 1); |
224 | 0 | break; |
225 | 0 | case 6: // Addressed Binary Message |
226 | 0 | RANGE_CHECK(88, 1008); |
227 | 0 | ais->type6.seqno = UBITS(38, 2); |
228 | 0 | ais->type6.dest_mmsi = UBITS(40, 30); |
229 | 0 | ais->type6.retransmit = UBITS(70, 1) != 0; |
230 | | //ais->type6.spare = UBITS(71, 1); |
231 | 0 | ais->type6.dac = UBITS(72, 10); |
232 | 0 | ais->type6.fid = UBITS(82, 6); |
233 | 0 | ais->type6.bitcount = bitlen - 88; |
234 | | // not strictly required - helps stability in testing |
235 | 0 | (void)memset(ais->type6.bitdata, '\0', sizeof(ais->type6.bitdata)); |
236 | 0 | ais->type6.structured = false; |
237 | | // Inland AIS |
238 | 0 | GPSD_LOG(LOG_PROG, errout, "AIVDM: type 6 dac %u fid %u bitlen %zu\n", |
239 | 0 | ais->type6.dac, ais->type6.fid, bitlen); |
240 | 0 | if (200 == ais->type6.dac) { |
241 | 0 | switch (ais->type6.fid) { |
242 | 0 | case 21: // ETA at lock/bridge/terminal |
243 | 0 | if (248 != bitlen) { |
244 | 0 | break; |
245 | 0 | } |
246 | 0 | UCHARS(88, ais->type6.dac200fid21.country); |
247 | 0 | UCHARS(100, ais->type6.dac200fid21.locode); |
248 | 0 | UCHARS(118, ais->type6.dac200fid21.section); |
249 | 0 | UCHARS(148, ais->type6.dac200fid21.terminal); |
250 | 0 | UCHARS(178, ais->type6.dac200fid21.hectometre); |
251 | 0 | ais->type6.dac200fid21.month = UBITS(208, 4); |
252 | 0 | ais->type6.dac200fid21.day = UBITS(212, 5); |
253 | 0 | ais->type6.dac200fid21.hour = UBITS(217, 5); |
254 | 0 | ais->type6.dac200fid21.minute = UBITS(222, 6); |
255 | 0 | ais->type6.dac200fid21.tugs = UBITS(228, 3); |
256 | 0 | ais->type6.dac200fid21.airdraught = UBITS(231, 12); |
257 | | // skip 5 bits |
258 | 0 | ais->type6.structured = true; |
259 | 0 | break; |
260 | 0 | case 22: // RTA at lock/bridge/terminal |
261 | 0 | if (232 != bitlen) { |
262 | 0 | break; |
263 | 0 | } |
264 | 0 | UCHARS(88, ais->type6.dac200fid22.country); |
265 | 0 | UCHARS(100, ais->type6.dac200fid22.locode); |
266 | 0 | UCHARS(118, ais->type6.dac200fid22.section); |
267 | 0 | UCHARS(148, ais->type6.dac200fid22.terminal); |
268 | 0 | UCHARS(178, ais->type6.dac200fid22.hectometre); |
269 | 0 | ais->type6.dac200fid22.month = UBITS(208, 4); |
270 | 0 | ais->type6.dac200fid22.day = UBITS(212, 5); |
271 | 0 | ais->type6.dac200fid22.hour = UBITS(217, 5); |
272 | 0 | ais->type6.dac200fid22.minute = UBITS(222, 6); |
273 | 0 | ais->type6.dac200fid22.status = UBITS(228, 2); |
274 | | // skip 2 bits |
275 | 0 | ais->type6.structured = true; |
276 | 0 | break; |
277 | 0 | case 55: // Number of Persons On Board |
278 | 0 | if (168 != bitlen) { |
279 | 0 | break; |
280 | 0 | } |
281 | 0 | ais->type6.dac200fid55.crew = UBITS(88, 8); |
282 | 0 | ais->type6.dac200fid55.passengers = UBITS(96, 13); |
283 | 0 | ais->type6.dac200fid55.personnel = UBITS(109, 8); |
284 | | // skip 51 bits |
285 | 0 | ais->type6.structured = true; |
286 | 0 | break; |
287 | 0 | } |
288 | 0 | } else if (235 == ais->type6.dac || |
289 | 0 | 250 == ais->type6.dac) { |
290 | | // UK and Republic Of Ireland |
291 | 0 | switch (ais->type6.fid) { |
292 | 0 | case 10: // GLA - AtoN monitoring data |
293 | 0 | if (136 != bitlen) { |
294 | 0 | break; |
295 | 0 | } |
296 | 0 | ais->type6.dac235fid10.ana_int = UBITS(88, 10); |
297 | 0 | ais->type6.dac235fid10.ana_ext1 = UBITS(98, 10); |
298 | 0 | ais->type6.dac235fid10.ana_ext2 = UBITS(108, 10); |
299 | 0 | ais->type6.dac235fid10.racon = UBITS(118, 2); |
300 | 0 | ais->type6.dac235fid10.light = UBITS(120, 2); |
301 | 0 | ais->type6.dac235fid10.alarm = UBITS(122, 1); |
302 | 0 | ais->type6.dac235fid10.stat_ext = UBITS(123, 8); |
303 | 0 | ais->type6.dac235fid10.off_pos = UBITS(131, 1); |
304 | | // skip 4 bits |
305 | 0 | ais->type6.structured = true; |
306 | 0 | break; |
307 | 0 | } |
308 | 0 | } else if (1 == ais->type6.dac) { |
309 | | // International |
310 | 0 | switch (ais->type6.fid) { |
311 | 0 | case 12: // IMO236 - Dangerous cargo indication |
312 | 0 | UCHARS(88, ais->type6.dac1fid12.lastport); |
313 | 0 | ais->type6.dac1fid12.lmonth = UBITS(118, 4); |
314 | 0 | ais->type6.dac1fid12.lday = UBITS(122, 5); |
315 | 0 | ais->type6.dac1fid12.lhour = UBITS(127, 5); |
316 | 0 | ais->type6.dac1fid12.lminute = UBITS(132, 6); |
317 | 0 | UCHARS(138, ais->type6.dac1fid12.nextport); |
318 | 0 | ais->type6.dac1fid12.nmonth = UBITS(168, 4); |
319 | 0 | ais->type6.dac1fid12.nday = UBITS(172, 5); |
320 | 0 | ais->type6.dac1fid12.nhour = UBITS(177, 5); |
321 | 0 | ais->type6.dac1fid12.nminute = UBITS(182, 6); |
322 | 0 | UCHARS(188, ais->type6.dac1fid12.dangerous); |
323 | 0 | UCHARS(308, ais->type6.dac1fid12.imdcat); |
324 | 0 | ais->type6.dac1fid12.unid = UBITS(332, 13); |
325 | 0 | ais->type6.dac1fid12.amount = UBITS(345, 10); |
326 | 0 | ais->type6.dac1fid12.unit = UBITS(355, 2); |
327 | | // skip 3 bits |
328 | 0 | ais->type6.structured = true; |
329 | 0 | break; |
330 | 0 | case 14: // IMO236 - Tidal Window |
331 | | // similar to fid 32. |
332 | 0 | RANGE_CHECK(87, 1008); |
333 | 0 | ais->type6.dac1fid32.month = UBITS(88, 4); |
334 | 0 | ais->type6.dac1fid32.day = UBITS(92, 5); |
335 | 0 | #define ARRAY_BASE 97 |
336 | 0 | #define ELEMENT_SIZE 93 |
337 | 0 | if ((ARRAY_BASE + |
338 | 0 | ELEMENT_SIZE * ROWS(ais->type6.dac1fid32.tidals)) < |
339 | 0 | bitlen) { |
340 | 0 | bitlen = ARRAY_BASE + |
341 | 0 | ELEMENT_SIZE * ROWS(ais->type6.dac1fid32.tidals); |
342 | 0 | } |
343 | 0 | for (u = 0; ARRAY_BASE + (ELEMENT_SIZE*u) <= bitlen; u++) { |
344 | 0 | int a = ARRAY_BASE + (ELEMENT_SIZE*u); |
345 | 0 | struct tidal_t *tp = &ais->type6.dac1fid32.tidals[u]; |
346 | 0 | tp->lat = SBITS(a + 0, 27); |
347 | 0 | tp->lon = SBITS(a + 27, 28); |
348 | 0 | tp->from_hour = UBITS(a + 55, 5); |
349 | 0 | tp->from_min = UBITS(a + 60, 6); |
350 | 0 | tp->to_hour = UBITS(a + 66, 5); |
351 | 0 | tp->to_min = UBITS(a + 71, 6); |
352 | 0 | tp->cdir = UBITS(a + 77, 9); |
353 | 0 | tp->cspeed = UBITS(a + 86, 7); |
354 | 0 | } |
355 | 0 | ais->type6.dac1fid32.ntidals = u; |
356 | 0 | #undef ARRAY_BASE |
357 | 0 | #undef ELEMENT_SIZE |
358 | 0 | ais->type6.structured = true; |
359 | 0 | break; |
360 | 0 | case 15: |
361 | | // IMO236 - Extended Ship Static and Voyage Related Data |
362 | 0 | RANGE_CHECK(67, 1008); |
363 | 0 | ais->type6.dac1fid15.airdraught = UBITS(56, 11); |
364 | 0 | ais->type6.structured = true; |
365 | 0 | break; |
366 | 0 | case 16: // IMO236 - Number of persons on board |
367 | 0 | if (136 == ais->type6.bitcount) { |
368 | 0 | ais->type6.dac1fid16.persons = UBITS(88, 13); // 289 |
369 | 0 | } else { |
370 | 0 | ais->type6.dac1fid16.persons = UBITS(55, 13); // 236 |
371 | 0 | } |
372 | 0 | ais->type6.structured = true; |
373 | 0 | break; |
374 | 0 | case 18: // IMO289 - Clearance time to enter port |
375 | | // FIXME: sometimes bitlen == 168! |
376 | 0 | ais->type6.dac1fid18.linkage = UBITS(88, 10); |
377 | 0 | ais->type6.dac1fid18.month = UBITS(98, 4); |
378 | 0 | ais->type6.dac1fid18.day = UBITS(102, 5); |
379 | 0 | ais->type6.dac1fid18.hour = UBITS(107, 5); |
380 | 0 | ais->type6.dac1fid18.minute = UBITS(112, 6); |
381 | 0 | UCHARS(118, ais->type6.dac1fid18.portname); |
382 | 0 | UCHARS(238, ais->type6.dac1fid18.destination); |
383 | 0 | ais->type6.dac1fid18.lon = SBITS(268, 25); |
384 | 0 | ais->type6.dac1fid18.lat = SBITS(293, 24); |
385 | | // skip 43 bits |
386 | 0 | ais->type6.structured = true; |
387 | 0 | break; |
388 | 0 | case 20: // IMO289 - Berthing data - addressed |
389 | 0 | RANGE_CHECK(360, 1008); |
390 | 0 | ais->type6.dac1fid20.linkage = UBITS(88, 10); |
391 | 0 | ais->type6.dac1fid20.berth_length = UBITS(98, 9); |
392 | 0 | ais->type6.dac1fid20.berth_depth = UBITS(107, 8); |
393 | 0 | ais->type6.dac1fid20.position = UBITS(115, 3); |
394 | 0 | ais->type6.dac1fid20.month = UBITS(118, 4); |
395 | 0 | ais->type6.dac1fid20.day = UBITS(122, 5); |
396 | 0 | ais->type6.dac1fid20.hour = UBITS(127, 5); |
397 | 0 | ais->type6.dac1fid20.minute = UBITS(132, 6); |
398 | 0 | ais->type6.dac1fid20.availability = UBITS(138, 1); |
399 | 0 | ais->type6.dac1fid20.agent = UBITS(139, 2); |
400 | 0 | ais->type6.dac1fid20.fuel = UBITS(141, 2); |
401 | 0 | ais->type6.dac1fid20.chandler = UBITS(143, 2); |
402 | 0 | ais->type6.dac1fid20.stevedore = UBITS(145, 2); |
403 | 0 | ais->type6.dac1fid20.electrical = UBITS(147, 2); |
404 | 0 | ais->type6.dac1fid20.water = UBITS(149, 2); |
405 | 0 | ais->type6.dac1fid20.customs = UBITS(151, 2); |
406 | 0 | ais->type6.dac1fid20.cartage = UBITS(153, 2); |
407 | 0 | ais->type6.dac1fid20.crane = UBITS(155, 2); |
408 | 0 | ais->type6.dac1fid20.lift = UBITS(157, 2); |
409 | 0 | ais->type6.dac1fid20.medical = UBITS(159, 2); |
410 | 0 | ais->type6.dac1fid20.navrepair = UBITS(161, 2); |
411 | 0 | ais->type6.dac1fid20.provisions = UBITS(163, 2); |
412 | 0 | ais->type6.dac1fid20.shiprepair = UBITS(165, 2); |
413 | 0 | ais->type6.dac1fid20.surveyor = UBITS(167, 2); |
414 | 0 | ais->type6.dac1fid20.steam = UBITS(169, 2); |
415 | 0 | ais->type6.dac1fid20.tugs = UBITS(171, 2); |
416 | 0 | ais->type6.dac1fid20.solidwaste = UBITS(173, 2); |
417 | 0 | ais->type6.dac1fid20.liquidwaste = UBITS(175, 2); |
418 | 0 | ais->type6.dac1fid20.hazardouswaste = UBITS(177, 2); |
419 | 0 | ais->type6.dac1fid20.ballast = UBITS(179, 2); |
420 | 0 | ais->type6.dac1fid20.additional = UBITS(181, 2); |
421 | 0 | ais->type6.dac1fid20.regional1 = UBITS(183, 2); |
422 | 0 | ais->type6.dac1fid20.regional2 = UBITS(185, 2); |
423 | 0 | ais->type6.dac1fid20.future1 = UBITS(187, 2); |
424 | 0 | ais->type6.dac1fid20.future2 = UBITS(189, 2); |
425 | 0 | UCHARS(191, ais->type6.dac1fid20.berth_name); |
426 | 0 | ais->type6.dac1fid20.berth_lon = SBITS(311, 25); |
427 | 0 | ais->type6.dac1fid20.berth_lat = SBITS(336, 24); |
428 | 0 | ais->type6.structured = true; |
429 | 0 | break; |
430 | 0 | case 23: // IMO289 - Area notice - addressed |
431 | 0 | break; |
432 | 0 | case 25: // IMO289 - Dangerous cargo indication |
433 | 0 | RANGE_CHECK(100, 1008); |
434 | 0 | ais->type6.dac1fid25.unit = UBITS(88, 2); |
435 | 0 | ais->type6.dac1fid25.amount = UBITS(90, 10); |
436 | 0 | if ((100 + 17 * ROWS(ais->type6.dac1fid25.cargos)) < bitlen) { |
437 | 0 | bitlen = 100 + 17 * ROWS(ais->type6.dac1fid25.cargos); |
438 | 0 | } |
439 | |
|
440 | 0 | for (u = 0; 100 + u * 17 < bitlen; u++) { |
441 | 0 | ais->type6.dac1fid25.cargos[u].code = |
442 | 0 | UBITS(100 + u * 17, 4); |
443 | 0 | ais->type6.dac1fid25.cargos[u].subtype = |
444 | 0 | UBITS(104 + u * 17, 13); |
445 | 0 | } |
446 | 0 | ais->type6.dac1fid25.ncargos = u; |
447 | 0 | ais->type6.structured = true; |
448 | 0 | break; |
449 | 0 | case 28: // IMO289 - Route info - addressed |
450 | 0 | RANGE_CHECK(149, 1008); |
451 | 0 | ais->type6.dac1fid28.linkage = UBITS(88, 10); |
452 | 0 | ais->type6.dac1fid28.sender = UBITS(98, 3); |
453 | 0 | ais->type6.dac1fid28.rtype = UBITS(101, 5); |
454 | 0 | ais->type6.dac1fid28.month = UBITS(106, 4); |
455 | 0 | ais->type6.dac1fid28.day = UBITS(110, 5); |
456 | 0 | ais->type6.dac1fid28.hour = UBITS(115, 5); |
457 | 0 | ais->type6.dac1fid28.minute = UBITS(120, 6); |
458 | 0 | ais->type6.dac1fid28.duration = UBITS(126, 18); |
459 | 0 | ais->type6.dac1fid28.waycount = UBITS(144, 5); |
460 | 0 | #define ARRAY_BASE 149 |
461 | 0 | #define ELEMENT_SIZE 55 |
462 | 0 | if ((ARRAY_BASE + |
463 | 0 | ELEMENT_SIZE * ROWS(ais->type6.dac1fid28.waypoints)) < |
464 | 0 | bitlen) { |
465 | 0 | bitlen = ARRAY_BASE + |
466 | 0 | ELEMENT_SIZE * ROWS(ais->type6.dac1fid28.waypoints); |
467 | 0 | } |
468 | 0 | for (u = 0; |
469 | 0 | u < (unsigned char)ais->type6.dac1fid28.waycount; u++) { |
470 | 0 | int a = ARRAY_BASE + (ELEMENT_SIZE*u); |
471 | 0 | ais->type6.dac1fid28.waypoints[u].lon = SBITS(a + 0, 28); |
472 | 0 | ais->type6.dac1fid28.waypoints[u].lat = SBITS(a + 28, 27); |
473 | 0 | } |
474 | 0 | #undef ARRAY_BASE |
475 | 0 | #undef ELEMENT_SIZE |
476 | 0 | ais->type6.structured = true; |
477 | 0 | break; |
478 | 0 | case 30: // IMO289 - Text description - addressed |
479 | 0 | RANGE_CHECK(98, 1008); |
480 | 0 | ais->type6.dac1fid30.linkage = UBITS(88, 10); |
481 | 0 | ENDCHARS(98, ais->type6.dac1fid30.text, |
482 | 0 | sizeof(ais->type6.dac1fid30.text)); |
483 | 0 | ais->type6.structured = true; |
484 | 0 | break; |
485 | 0 | case 32: // IMO289 - Tidal Window |
486 | | // similar to fid 14. |
487 | 0 | RANGE_CHECK(97, 1008); |
488 | 0 | ais->type6.dac1fid32.month = UBITS(88, 4); |
489 | 0 | ais->type6.dac1fid32.day = UBITS(92, 5); |
490 | 0 | #define ARRAY_BASE 97 |
491 | 0 | #define ELEMENT_SIZE 88 |
492 | 0 | if ((ARRAY_BASE + |
493 | 0 | ELEMENT_SIZE * ROWS(ais->type6.dac1fid32.tidals)) < |
494 | 0 | bitlen) { |
495 | 0 | bitlen = ARRAY_BASE + |
496 | 0 | ELEMENT_SIZE * ROWS(ais->type6.dac1fid32.tidals); |
497 | 0 | } |
498 | 0 | for (u = 0; ARRAY_BASE + (ELEMENT_SIZE * u) <= bitlen; u++) { |
499 | 0 | unsigned a = ARRAY_BASE + (ELEMENT_SIZE * u); |
500 | 0 | struct tidal_t *tp = &ais->type6.dac1fid32.tidals[u]; |
501 | |
|
502 | 0 | tp->lon = SBITS(a + 0, 25); |
503 | 0 | tp->lat = SBITS(a + 25, 24); |
504 | 0 | tp->from_hour = UBITS(a + 49, 5); |
505 | 0 | tp->from_min = UBITS(a + 54, 6); |
506 | 0 | tp->to_hour = UBITS(a + 60, 5); |
507 | 0 | tp->to_min = UBITS(a + 65, 6); |
508 | 0 | tp->cdir = UBITS(a + 71, 9); |
509 | 0 | tp->cspeed = UBITS(a + 80, 8); |
510 | 0 | } |
511 | 0 | ais->type6.dac1fid32.ntidals = u; |
512 | 0 | #undef ARRAY_BASE |
513 | 0 | #undef ELEMENT_SIZE |
514 | 0 | ais->type6.structured = true; |
515 | 0 | break; |
516 | 0 | } |
517 | 0 | } |
518 | 0 | if (!ais->type6.structured) { |
519 | 0 | (void)memcpy(ais->type6.bitdata, bits + (88 / CHAR_BIT), |
520 | 0 | BITS_TO_BYTES(ais->type6.bitcount)); |
521 | 0 | } |
522 | 0 | break; |
523 | 0 | case 7: // Binary acknowledge |
524 | 0 | FALLTHROUGH |
525 | 0 | case 13: // Safety Related Acknowledge |
526 | 0 | { |
527 | 0 | unsigned int mmsi[4]; |
528 | 0 | unsigned seqno[4]; |
529 | 0 | RANGE_CHECK(72, 168); |
530 | 0 | for (u = 0; u < sizeof(mmsi)/sizeof(mmsi[0]); u++) { |
531 | 0 | if (40 + 32 * u < bitlen) { |
532 | 0 | mmsi[u] = UBITS(40 + 32 * u, 30); |
533 | 0 | seqno[u] = UBITS(72 + 32 * u, 2); |
534 | 0 | } else { |
535 | 0 | mmsi[u] = 0; |
536 | 0 | seqno[u] = 0; |
537 | 0 | } |
538 | 0 | } |
539 | 0 | ais->type7.mmsi1 = mmsi[0]; |
540 | 0 | ais->type7.seqno1 = seqno[0]; |
541 | 0 | ais->type7.mmsi2 = mmsi[1]; |
542 | 0 | ais->type7.seqno2 = seqno[1]; |
543 | 0 | ais->type7.mmsi3 = mmsi[2]; |
544 | 0 | ais->type7.seqno3 = seqno[2]; |
545 | 0 | ais->type7.mmsi4 = mmsi[3]; |
546 | 0 | ais->type7.seqno4 = seqno[3]; |
547 | 0 | break; |
548 | 0 | } |
549 | 0 | case 8: // Binary Broadcast Message |
550 | 0 | RANGE_CHECK(56, 1008); |
551 | | //ais->type8.spare = UBITS(38, 2); |
552 | 0 | ais->type8.dac = UBITS(40, 10); |
553 | 0 | ais->type8.fid = UBITS(50, 6); |
554 | 0 | ais->type8.bitcount = bitlen - 56; |
555 | | // not strictly required - helps stability in testing |
556 | 0 | (void)memset(ais->type8.bitdata, '\0', sizeof(ais->type8.bitdata)); |
557 | 0 | ais->type8.structured = false; |
558 | 0 | GPSD_LOG(LOG_PROG, errout, "AIVDM: type 8 dac %u fid %u bitlen %zu\n", |
559 | 0 | ais->type8.dac, ais->type8.fid, bitlen); |
560 | 0 | if (1 == ais->type8.dac) { |
561 | 0 | switch (ais->type8.fid) { |
562 | 0 | case 11: // IMO236 - Meteorological/Hydrological data |
563 | | // layout is almost identical to FID=31 from IMO289 |
564 | | // FIXME: we get length 352?? |
565 | 0 | RANGE_CHECK(346, 352); |
566 | 0 | ais->type8.dac1fid11.lat = SBITS(56, 24); |
567 | 0 | ais->type8.dac1fid11.lon = SBITS(80, 25); |
568 | 0 | ais->type8.dac1fid11.day = UBITS(105, 5); |
569 | 0 | ais->type8.dac1fid11.hour = UBITS(110, 5); |
570 | 0 | ais->type8.dac1fid11.minute = UBITS(115, 6); |
571 | 0 | ais->type8.dac1fid11.wspeed = UBITS(121, 7); |
572 | 0 | ais->type8.dac1fid11.wgust = UBITS(128, 7); |
573 | 0 | ais->type8.dac1fid11.wdir = UBITS(135, 9); |
574 | 0 | ais->type8.dac1fid11.wgustdir = UBITS(144, 9); |
575 | 0 | ais->type8.dac1fid11.airtemp = UBITS(153, 11); |
576 | 0 | ais->type8.dac1fid11.humidity = UBITS(164, 7); |
577 | 0 | ais->type8.dac1fid11.dewpoint = UBITS(171, 10); |
578 | 0 | ais->type8.dac1fid11.pressure = UBITS(181, 9); |
579 | 0 | ais->type8.dac1fid11.pressuretend = UBITS(190, 2); |
580 | 0 | ais->type8.dac1fid11.visibility = UBITS(192, 8); |
581 | 0 | ais->type8.dac1fid11.waterlevel = UBITS(200, 9); |
582 | 0 | ais->type8.dac1fid11.leveltrend = UBITS(209, 2); |
583 | 0 | ais->type8.dac1fid11.cspeed = UBITS(211, 8); |
584 | 0 | ais->type8.dac1fid11.cdir = UBITS(219, 9); |
585 | 0 | ais->type8.dac1fid11.cspeed2 = UBITS(228, 8); |
586 | 0 | ais->type8.dac1fid11.cdir2 = UBITS(236, 9); |
587 | 0 | ais->type8.dac1fid11.cdepth2 = UBITS(245, 5); |
588 | 0 | ais->type8.dac1fid11.cspeed3 = UBITS(250, 8); |
589 | 0 | ais->type8.dac1fid11.cdir3 = UBITS(258, 9); |
590 | 0 | ais->type8.dac1fid11.cdepth3 = UBITS(267, 5); |
591 | 0 | ais->type8.dac1fid11.waveheight = UBITS(272, 8); |
592 | 0 | ais->type8.dac1fid11.waveperiod = UBITS(280, 6); |
593 | 0 | ais->type8.dac1fid11.wavedir = UBITS(286, 9); |
594 | 0 | ais->type8.dac1fid11.swellheight = UBITS(295, 8); |
595 | 0 | ais->type8.dac1fid11.swellperiod = UBITS(303, 6); |
596 | 0 | ais->type8.dac1fid11.swelldir = UBITS(309, 9); |
597 | 0 | ais->type8.dac1fid11.seastate = UBITS(318, 4); |
598 | 0 | ais->type8.dac1fid11.watertemp = UBITS(322, 10); |
599 | 0 | ais->type8.dac1fid11.preciptype = UBITS(332, 3); |
600 | 0 | ais->type8.dac1fid11.salinity = UBITS(335, 9); |
601 | 0 | ais->type8.dac1fid11.ice = UBITS(344, 2); |
602 | 0 | ais->type8.structured = true; |
603 | 0 | break; |
604 | 0 | case 13: // IMO236 - Fairway closed |
605 | 0 | UCHARS(56, ais->type8.dac1fid13.reason); |
606 | 0 | UCHARS(176, ais->type8.dac1fid13.closefrom); |
607 | 0 | UCHARS(296, ais->type8.dac1fid13.closeto); |
608 | 0 | ais->type8.dac1fid13.radius = UBITS(416, 10); |
609 | 0 | ais->type8.dac1fid13.extunit = UBITS(426, 2); |
610 | 0 | ais->type8.dac1fid13.fday = UBITS(428, 5); |
611 | 0 | ais->type8.dac1fid13.fmonth = UBITS(433, 4); |
612 | 0 | ais->type8.dac1fid13.fhour = UBITS(437, 5); |
613 | 0 | ais->type8.dac1fid13.fminute = UBITS(442, 6); |
614 | 0 | ais->type8.dac1fid13.tday = UBITS(448, 5); |
615 | 0 | ais->type8.dac1fid13.tmonth = UBITS(453, 4); |
616 | 0 | ais->type8.dac1fid13.thour = UBITS(457, 5); |
617 | 0 | ais->type8.dac1fid13.tminute = UBITS(462, 6); |
618 | | // skip 4 bits |
619 | 0 | ais->type8.structured = true; |
620 | 0 | break; |
621 | 0 | case 15: // IMO236 - Extended ship and voyage |
622 | 0 | ais->type8.dac1fid15.airdraught = UBITS(56, 11); |
623 | | // skip 5 bits |
624 | 0 | ais->type8.structured = true; |
625 | 0 | break; |
626 | 0 | case 16: // Number of Persons On Board |
627 | 0 | if (136 == ais->type8.bitcount) { |
628 | 0 | ais->type8.dac1fid16.persons = UBITS(88, 13); // 289 |
629 | 0 | ais->type8.structured = true; |
630 | 0 | } else if (72 == ais->type8.bitcount) { |
631 | 0 | ais->type8.dac1fid16.persons = UBITS(55, 13); // 236 |
632 | 0 | ais->type8.structured = true; |
633 | 0 | } |
634 | 0 | break; |
635 | 0 | case 17: // IMO289 - VTS-generated/synthetic targets |
636 | 0 | RANGE_CHECK(56, 1008); |
637 | 0 | #define ARRAY_BASE 56 |
638 | 0 | #define ELEMENT_SIZE 122 |
639 | 0 | if ((ARRAY_BASE + |
640 | 0 | ELEMENT_SIZE * ROWS(ais->type8.dac1fid17.targets)) < |
641 | 0 | bitlen) { |
642 | 0 | bitlen = ARRAY_BASE + |
643 | 0 | ELEMENT_SIZE * ROWS(ais->type8.dac1fid17.targets); |
644 | 0 | } |
645 | 0 | for (u = 0; ARRAY_BASE + (ELEMENT_SIZE * u) <= bitlen; u++) { |
646 | 0 | struct target_t *tp = &ais->type8.dac1fid17.targets[u]; |
647 | 0 | unsigned a = ARRAY_BASE + (ELEMENT_SIZE * u); |
648 | 0 | tp->idtype = UBITS(a + 0, 2); |
649 | 0 | switch (tp->idtype) { |
650 | 0 | case DAC1FID17_IDTYPE_MMSI: |
651 | 0 | tp->id.mmsi = UBITS(a + 2, 42); |
652 | 0 | break; |
653 | 0 | case DAC1FID17_IDTYPE_IMO: |
654 | 0 | tp->id.imo = UBITS(a + 2, 42); |
655 | 0 | break; |
656 | 0 | case DAC1FID17_IDTYPE_CALLSIGN: |
657 | 0 | UCHARS(a + 2, tp->id.callsign); |
658 | 0 | break; |
659 | 0 | default: |
660 | 0 | UCHARS(a + 2, tp->id.other); |
661 | 0 | break; |
662 | 0 | } |
663 | | // skip 4 bits |
664 | 0 | tp->lat = SBITS(a + 48, 24); |
665 | 0 | tp->lon = SBITS(a + 72, 25); |
666 | 0 | tp->course = UBITS(a + 97, 9); |
667 | 0 | tp->second = UBITS(a + 106, 6); |
668 | 0 | tp->speed = UBITS(a + 112, 10); |
669 | 0 | } |
670 | 0 | ais->type8.dac1fid17.ntargets = u; |
671 | 0 | #undef ARRAY_BASE |
672 | 0 | #undef ELEMENT_SIZE |
673 | 0 | ais->type8.structured = true; |
674 | 0 | break; |
675 | 0 | case 19: // IMO289 - Marine Traffic Signal |
676 | 0 | RANGE_CHECK(258, 1008); |
677 | 0 | ais->type8.dac1fid19.linkage = UBITS(56, 10); |
678 | 0 | UCHARS(66, ais->type8.dac1fid19.station); |
679 | 0 | ais->type8.dac1fid19.lon = SBITS(186, 25); |
680 | 0 | ais->type8.dac1fid19.lat = SBITS(211, 24); |
681 | 0 | ais->type8.dac1fid19.status = UBITS(235, 2); |
682 | 0 | ais->type8.dac1fid19.signal = UBITS(237, 5); |
683 | 0 | ais->type8.dac1fid19.hour = UBITS(242, 5); |
684 | 0 | ais->type8.dac1fid19.minute = UBITS(247, 6); |
685 | 0 | ais->type8.dac1fid19.nextsignal = UBITS(253, 5); |
686 | | // skip 102 bits |
687 | 0 | ais->type8.structured = true; |
688 | 0 | break; |
689 | 0 | case 21: // IMO289 - Weather obs. report from ship |
690 | 0 | break; |
691 | 0 | case 22: // IMO289 - Area notice - broadcast |
692 | 0 | break; |
693 | 0 | case 24: |
694 | | // IMO289 - Extended ship static & voyage-related data |
695 | 0 | break; |
696 | 0 | case 26: // IMO289 - Environmental |
697 | 0 | break; |
698 | 0 | case 27: // IMO289 - Route information - broadcast |
699 | 0 | RANGE_CHECK(117, 1008); |
700 | 0 | ais->type8.dac1fid27.linkage = UBITS(56, 10); |
701 | 0 | ais->type8.dac1fid27.sender = UBITS(66, 3); |
702 | 0 | ais->type8.dac1fid27.rtype = UBITS(69, 5); |
703 | 0 | ais->type8.dac1fid27.month = UBITS(74, 4); |
704 | 0 | ais->type8.dac1fid27.day = UBITS(78, 5); |
705 | 0 | ais->type8.dac1fid27.hour = UBITS(83, 5); |
706 | 0 | ais->type8.dac1fid27.minute = UBITS(88, 6); |
707 | 0 | ais->type8.dac1fid27.duration = UBITS(94, 18); |
708 | 0 | ais->type8.dac1fid27.waycount = UBITS(112, 5); |
709 | 0 | #define ARRAY_BASE 117 |
710 | 0 | #define ELEMENT_SIZE 55 |
711 | 0 | if ((ARRAY_BASE + |
712 | 0 | ELEMENT_SIZE * ROWS(ais->type8.dac1fid27.waypoints)) < |
713 | 0 | bitlen) { |
714 | 0 | bitlen = ARRAY_BASE + |
715 | 0 | ELEMENT_SIZE * ROWS(ais->type8.dac1fid27.waypoints); |
716 | 0 | } |
717 | 0 | for (u = 0; u < ais->type8.dac1fid27.waycount; u++) { |
718 | 0 | int a = ARRAY_BASE + (ELEMENT_SIZE * u); |
719 | 0 | ais->type8.dac1fid27.waypoints[u].lon = SBITS(a + 0, 28); |
720 | 0 | ais->type8.dac1fid27.waypoints[u].lat = SBITS(a + 28, 27); |
721 | 0 | } |
722 | 0 | #undef ARRAY_BASE |
723 | 0 | #undef ELEMENT_SIZE |
724 | 0 | ais->type8.structured = true; |
725 | 0 | break; |
726 | 0 | case 29: // IMO289 - Text Description - broadcast |
727 | 0 | ais->type8.dac1fid29.linkage = UBITS(56, 10); |
728 | 0 | ENDCHARS(66, ais->type8.dac1fid29.text, |
729 | 0 | sizeof(ais->type8.dac1fid29.text)); |
730 | 0 | ais->type8.structured = true; |
731 | 0 | break; |
732 | 0 | case 31: // IMO289 - Meteorological/Hydrological data |
733 | 0 | ais->type8.dac1fid31.lon = SBITS(56, 25); |
734 | 0 | ais->type8.dac1fid31.lat = SBITS(81, 24); |
735 | 0 | ais->type8.dac1fid31.accuracy = (bool)UBITS(105, 1); |
736 | 0 | ais->type8.dac1fid31.day = UBITS(106, 5); |
737 | 0 | ais->type8.dac1fid31.hour = UBITS(111, 5); |
738 | 0 | ais->type8.dac1fid31.minute = UBITS(116, 6); |
739 | 0 | ais->type8.dac1fid31.wspeed = UBITS(122, 7); |
740 | 0 | ais->type8.dac1fid31.wgust = UBITS(129, 7); |
741 | 0 | ais->type8.dac1fid31.wdir = UBITS(136, 9); |
742 | 0 | ais->type8.dac1fid31.wgustdir = UBITS(145, 9); |
743 | 0 | ais->type8.dac1fid31.airtemp = SBITS(154, 11); |
744 | 0 | ais->type8.dac1fid31.humidity = UBITS(165, 7); |
745 | 0 | ais->type8.dac1fid31.dewpoint = SBITS(172, 10); |
746 | 0 | ais->type8.dac1fid31.pressure = UBITS(182, 9); |
747 | 0 | ais->type8.dac1fid31.pressuretend = UBITS(191, 2); |
748 | 0 | ais->type8.dac1fid31.visgreater = UBITS(193, 1); |
749 | 0 | ais->type8.dac1fid31.visibility = UBITS(194, 7); |
750 | 0 | ais->type8.dac1fid31.waterlevel = UBITS(201, 12); |
751 | 0 | ais->type8.dac1fid31.leveltrend = UBITS(213, 2); |
752 | 0 | ais->type8.dac1fid31.cspeed = UBITS(215, 8); |
753 | 0 | ais->type8.dac1fid31.cdir = UBITS(223, 9); |
754 | 0 | ais->type8.dac1fid31.cspeed2 = UBITS(232, 8); |
755 | 0 | ais->type8.dac1fid31.cdir2 = UBITS(240, 9); |
756 | 0 | ais->type8.dac1fid31.cdepth2 = UBITS(249, 5); |
757 | 0 | ais->type8.dac1fid31.cspeed3 = UBITS(254, 8); |
758 | 0 | ais->type8.dac1fid31.cdir3 = UBITS(262, 9); |
759 | 0 | ais->type8.dac1fid31.cdepth3 = UBITS(271, 5); |
760 | 0 | ais->type8.dac1fid31.waveheight = UBITS(276, 8); |
761 | 0 | ais->type8.dac1fid31.waveperiod = UBITS(284, 6); |
762 | 0 | ais->type8.dac1fid31.wavedir = UBITS(290, 9); |
763 | 0 | ais->type8.dac1fid31.swellheight = UBITS(299, 8); |
764 | 0 | ais->type8.dac1fid31.swellperiod = UBITS(307, 6); |
765 | 0 | ais->type8.dac1fid31.swelldir = UBITS(313, 9); |
766 | 0 | ais->type8.dac1fid31.seastate = UBITS(322, 4); |
767 | 0 | ais->type8.dac1fid31.watertemp = SBITS(326, 10); |
768 | 0 | ais->type8.dac1fid31.preciptype = UBITS(336, 3); |
769 | 0 | ais->type8.dac1fid31.salinity = UBITS(339, 9); |
770 | 0 | ais->type8.dac1fid31.ice = UBITS(348, 2); |
771 | 0 | ais->type8.structured = true; |
772 | 0 | break; |
773 | 0 | } |
774 | 0 | } else if (200 == ais->type8.dac) { |
775 | 0 | switch (ais->type8.fid) { |
776 | 0 | case 10: // Inland ship static and voyage related data |
777 | 0 | if (168 != bitlen) { |
778 | 0 | break; |
779 | 0 | } |
780 | 0 | UCHARS(56, ais->type8.dac200fid10.vin); |
781 | 0 | ais->type8.dac200fid10.length = UBITS(104, 13); |
782 | 0 | ais->type8.dac200fid10.beam = UBITS(117, 10); |
783 | 0 | ais->type8.dac200fid10.shiptype = UBITS(127, 14); |
784 | 0 | ais->type8.dac200fid10.hazard = UBITS(141, 3); |
785 | 0 | ais->type8.dac200fid10.draught = UBITS(144, 11); |
786 | 0 | ais->type8.dac200fid10.loaded = UBITS(155, 2); |
787 | 0 | ais->type8.dac200fid10.speed_q = (bool)UBITS(157, 1); |
788 | 0 | ais->type8.dac200fid10.course_q = (bool)UBITS(158, 1); |
789 | 0 | ais->type8.dac200fid10.heading_q = (bool)UBITS(159, 1); |
790 | | // skip 8 bits |
791 | | /* |
792 | | * Attempt to prevent false matches with this message type |
793 | | * by range-checking certain fields. |
794 | | */ |
795 | 0 | if (DAC200FID10_HAZARD_MAX < ais->type8.dac200fid10.hazard || |
796 | 0 | !isascii((int)ais->type8.dac200fid10.vin[0])) { |
797 | 0 | ais->type8.structured = false; |
798 | 0 | } else { |
799 | 0 | ais->type8.structured = true; |
800 | 0 | } |
801 | 0 | break; |
802 | 0 | case 23: // EMMA warning |
803 | 0 | if (256 != bitlen) { |
804 | 0 | break; |
805 | 0 | } |
806 | 0 | ais->type8.dac200fid23.start_year = UBITS(56, 8); |
807 | 0 | ais->type8.dac200fid23.start_month = UBITS(64, 4); |
808 | 0 | ais->type8.dac200fid23.start_day = UBITS(68, 5); |
809 | 0 | ais->type8.dac200fid23.end_year = UBITS(73, 8); |
810 | 0 | ais->type8.dac200fid23.end_month = UBITS(81, 4); |
811 | 0 | ais->type8.dac200fid23.end_day = UBITS(85, 5); |
812 | 0 | ais->type8.dac200fid23.start_hour = UBITS(90, 5); |
813 | 0 | ais->type8.dac200fid23.start_minute = UBITS(95, 6); |
814 | 0 | ais->type8.dac200fid23.end_hour = UBITS(101, 5); |
815 | 0 | ais->type8.dac200fid23.end_minute = UBITS(106, 6); |
816 | 0 | ais->type8.dac200fid23.start_lon = SBITS(112, 28); |
817 | 0 | ais->type8.dac200fid23.start_lat = SBITS(140, 27); |
818 | 0 | ais->type8.dac200fid23.end_lon = SBITS(167, 28); |
819 | 0 | ais->type8.dac200fid23.end_lat = SBITS(195, 27); |
820 | 0 | ais->type8.dac200fid23.type = UBITS(222, 4); |
821 | 0 | ais->type8.dac200fid23.min = SBITS(226, 9); |
822 | 0 | ais->type8.dac200fid23.max = SBITS(235, 9); |
823 | 0 | ais->type8.dac200fid23.intensity = UBITS(244, 2); |
824 | 0 | ais->type8.dac200fid23.wind = UBITS(246, 4); |
825 | | // skip 6 bits |
826 | 0 | ais->type8.structured = true; |
827 | 0 | break; |
828 | 0 | case 24: // Water level |
829 | 0 | if (168 != bitlen) { |
830 | 0 | break; |
831 | 0 | } |
832 | 0 | UCHARS(56, ais->type8.dac200fid24.country); |
833 | 0 | #define ARRAY_BASE 68 |
834 | 0 | #define ELEMENT_SIZE 25 |
835 | 0 | for (u = 0; ARRAY_BASE + (ELEMENT_SIZE * u) < bitlen; |
836 | 0 | u++) { |
837 | 0 | int a = ARRAY_BASE + (ELEMENT_SIZE * u); |
838 | 0 | ais->type8.dac200fid24.gauges[u].id = UBITS(a + 0, 11); |
839 | 0 | ais->type8.dac200fid24.gauges[u].level = SBITS(a + 11, 14); |
840 | 0 | } |
841 | 0 | ais->type8.dac200fid24.ngauges = u; |
842 | 0 | #undef ARRAY_BASE |
843 | 0 | #undef ELEMENT_SIZE |
844 | | // skip 6 bits |
845 | 0 | ais->type8.structured = true; |
846 | 0 | break; |
847 | 0 | case 40: // Signal status |
848 | 0 | if (168 != bitlen) { |
849 | 0 | break; |
850 | 0 | } |
851 | 0 | ais->type8.dac200fid40.lon = SBITS(56, 28); |
852 | 0 | ais->type8.dac200fid40.lat = SBITS(84, 27); |
853 | 0 | ais->type8.dac200fid40.form = UBITS(111, 4); |
854 | 0 | ais->type8.dac200fid40.facing = UBITS(115, 9); |
855 | 0 | ais->type8.dac200fid40.direction = UBITS(124, 3); |
856 | 0 | ais->type8.dac200fid40.status = UBITS(127, 30); |
857 | | // skip 11 bits |
858 | 0 | ais->type8.structured = true; |
859 | 0 | break; |
860 | 0 | } |
861 | 0 | } |
862 | | // land here if we failed to match a known DAC/FID |
863 | 0 | if (!ais->type8.structured) { |
864 | 0 | size_t number_of_bytes = BITS_TO_BYTES(ais->type8.bitcount); |
865 | 0 | (void)memcpy(ais->type8.bitdata, bits + (56 / CHAR_BIT), |
866 | 0 | number_of_bytes); |
867 | 0 | size_t valid_bits_in_last_byte = ais->type8.bitcount % CHAR_BIT; |
868 | 0 | if(valid_bits_in_last_byte > 0) { |
869 | 0 | ais->type8.bitdata[number_of_bytes - 1] &= |
870 | 0 | (0xFF << (8 - valid_bits_in_last_byte)); |
871 | 0 | } |
872 | 0 | } |
873 | 0 | break; |
874 | 0 | case 9: // Standard SAR Aircraft Position Report |
875 | 0 | PERMISSIVE_LENGTH_CHECK(168); |
876 | 0 | ais->type9.alt = UBITS(38, 12); |
877 | 0 | ais->type9.speed = UBITS(50, 10); |
878 | 0 | ais->type9.accuracy = (bool)UBITS(60, 1); |
879 | 0 | ais->type9.lon = SBITS(61, 28); |
880 | 0 | ais->type9.lat = SBITS(89, 27); |
881 | 0 | ais->type9.course = UBITS(116, 12); |
882 | 0 | ais->type9.second = UBITS(128, 6); |
883 | 0 | ais->type9.regional = UBITS(134, 8); |
884 | 0 | ais->type9.dte = UBITS(142, 1); |
885 | | //ais->type9.spare = UBITS(143, 3); |
886 | 0 | ais->type9.assigned = UBITS(146, 1) != 0; |
887 | 0 | ais->type9.raim = UBITS(147, 1) != 0; |
888 | 0 | ais->type9.radio = UBITS(148, 20); |
889 | 0 | break; |
890 | 0 | case 10: // UTC/Date inquiry |
891 | 0 | PERMISSIVE_LENGTH_CHECK(72); |
892 | | //ais->type10.spare = UBITS(38, 2); |
893 | 0 | ais->type10.dest_mmsi = UBITS(40, 30); |
894 | | //ais->type10.spare2 = UBITS(70, 2); |
895 | 0 | break; |
896 | 0 | case 12: // Safety Related Message |
897 | 0 | RANGE_CHECK(72, 1008); |
898 | 0 | ais->type12.seqno = UBITS(38, 2); |
899 | 0 | ais->type12.dest_mmsi = UBITS(40, 30); |
900 | 0 | ais->type12.retransmit = (bool)UBITS(70, 1); |
901 | | //ais->type12.spare = UBITS(71, 1); |
902 | 0 | ENDCHARS(72, ais->type12.text, sizeof(ais->type12.text)); |
903 | 0 | break; |
904 | 0 | case 14: // Safety Related Broadcast Message |
905 | 0 | RANGE_CHECK(40, 960); |
906 | | //ais->type14.spare = UBITS(38, 2); |
907 | 0 | ENDCHARS(40, ais->type14.text, sizeof(ais->type14.text)); |
908 | 0 | break; |
909 | 0 | case 15: // Interrogation |
910 | 0 | RANGE_CHECK(88, 168); |
911 | 0 | (void)memset(&ais->type15, '\0', sizeof(ais->type15)); |
912 | | //ais->type14.spare = UBITS(38, 2); |
913 | 0 | ais->type15.mmsi1 = UBITS(40, 30); |
914 | 0 | ais->type15.type1_1 = UBITS(70, 6); |
915 | 0 | ais->type15.offset1_1 = UBITS(76, 12); |
916 | | //ais->type14.spare2 = UBITS(88, 2); |
917 | 0 | if (90 < bitlen) { |
918 | 0 | ais->type15.type1_2 = UBITS(90, 6); |
919 | 0 | ais->type15.offset1_2 = UBITS(96, 12); |
920 | | //ais->type14.spare3 = UBITS(108, 2); |
921 | 0 | if (110 < bitlen) { |
922 | 0 | ais->type15.mmsi2 = UBITS(110, 30); |
923 | 0 | ais->type15.type2_1 = UBITS(140, 6); |
924 | 0 | ais->type15.offset2_1 = UBITS(146, 12); |
925 | | //ais->type14.spare4 = UBITS(158, 2); |
926 | 0 | } |
927 | 0 | } |
928 | 0 | break; |
929 | 0 | case 16: // Assigned Mode Command |
930 | 0 | RANGE_CHECK(96, 168); |
931 | 0 | ais->type16.mmsi1 = UBITS(40, 30); |
932 | 0 | ais->type16.offset1 = UBITS(70, 12); |
933 | 0 | ais->type16.increment1 = UBITS(82, 10); |
934 | 0 | if (144 > bitlen) { |
935 | 0 | ais->type16.mmsi2=ais->type16.offset2=ais->type16.increment2 = 0; |
936 | 0 | } else { |
937 | 0 | ais->type16.mmsi2 = UBITS(92, 30); |
938 | 0 | ais->type16.offset2 = UBITS(122, 12); |
939 | 0 | ais->type16.increment2 = UBITS(134, 10); |
940 | 0 | } |
941 | 0 | break; |
942 | 0 | case 17: // GNSS Broadcast Binary Message |
943 | 0 | RANGE_CHECK(80, 816); |
944 | | //ais->type17.spare = UBITS(38, 2); |
945 | 0 | ais->type17.lon = SBITS(40, 18); |
946 | 0 | ais->type17.lat = SBITS(58, 17); |
947 | | //ais->type17.spare = UBITS(75, 5); |
948 | 0 | ais->type17.bitcount = bitlen - 80; |
949 | 0 | (void)memcpy(ais->type17.bitdata, bits + (80 / CHAR_BIT), |
950 | 0 | BITS_TO_BYTES(ais->type17.bitcount)); |
951 | 0 | break; |
952 | 0 | case 18: // Standard Class B CS Position Report |
953 | | // Per https://www.navcen.uscg.gov/ais-class-b-reports |
954 | 0 | PERMISSIVE_LENGTH_CHECK(168) |
955 | 0 | ais->type18.reserved = UBITS(38, 8); |
956 | 0 | ais->type18.speed = UBITS(46, 10); |
957 | 0 | ais->type18.accuracy = UBITS(56, 1) != 0; |
958 | 0 | ais->type18.lon = SBITS(57, 28); |
959 | 0 | ais->type18.lat = SBITS(85, 27); |
960 | 0 | ais->type18.course = UBITS(112, 12); |
961 | 0 | ais->type18.heading = UBITS(124, 9); |
962 | 0 | ais->type18.second = UBITS(133, 6); |
963 | 0 | ais->type18.regional = UBITS(139, 2); |
964 | 0 | ais->type18.cs = UBITS(141, 1) != 0; |
965 | 0 | ais->type18.display = UBITS(142, 1) != 0; |
966 | 0 | ais->type18.dsc = UBITS(143, 1) != 0; |
967 | 0 | ais->type18.band = UBITS(144, 1) != 0; |
968 | 0 | ais->type18.msg22 = UBITS(145, 1) != 0; |
969 | 0 | ais->type18.assigned = UBITS(146, 1) != 0; |
970 | 0 | ais->type18.raim = UBITS(147, 1) != 0; |
971 | 0 | ais->type18.radio = UBITS(148, 20); |
972 | 0 | break; |
973 | 0 | case 19: // Extended Class B CS Position Report |
974 | 0 | PERMISSIVE_LENGTH_CHECK(312) |
975 | 0 | ais->type19.reserved = UBITS(38, 8); |
976 | 0 | ais->type19.speed = UBITS(46, 10); |
977 | 0 | ais->type19.accuracy = UBITS(56, 1) != 0; |
978 | 0 | ais->type19.lon = SBITS(57, 28); |
979 | 0 | ais->type19.lat = SBITS(85, 27); |
980 | 0 | ais->type19.course = UBITS(112, 12); |
981 | 0 | ais->type19.heading = UBITS(124, 9); |
982 | 0 | ais->type19.second = UBITS(133, 6); |
983 | 0 | ais->type19.regional = UBITS(139, 4); |
984 | 0 | UCHARS(143, ais->type19.shipname); |
985 | 0 | ais->type19.shiptype = UBITS(263, 8); |
986 | 0 | ais->type19.to_bow = UBITS(271, 9); |
987 | 0 | ais->type19.to_stern = UBITS(280, 9); |
988 | 0 | ais->type19.to_port = UBITS(289, 6); |
989 | 0 | ais->type19.to_starboard = UBITS(295, 6); |
990 | 0 | ais->type19.epfd = UBITS(301, 4); |
991 | 0 | ais->type19.raim = UBITS(305, 1) != 0; |
992 | 0 | ais->type19.dte = UBITS(306, 1) != 0; |
993 | 0 | ais->type19.assigned = UBITS(307, 1) != 0; |
994 | | //ais->type19.spare = UBITS(308, 4); |
995 | 0 | break; |
996 | 0 | case 20: // Data Link Management Message |
997 | 0 | RANGE_CHECK(72, 186); |
998 | | //ais->type20.spare = UBITS(38, 2); |
999 | 0 | ais->type20.offset1 = UBITS(40, 12); |
1000 | 0 | ais->type20.number1 = UBITS(52, 4); |
1001 | 0 | ais->type20.timeout1 = UBITS(56, 3); |
1002 | 0 | ais->type20.increment1 = UBITS(59, 11); |
1003 | 0 | ais->type20.offset2 = UBITS(70, 12); |
1004 | 0 | ais->type20.number2 = UBITS(82, 4); |
1005 | 0 | ais->type20.timeout2 = UBITS(86, 3); |
1006 | 0 | ais->type20.increment2 = UBITS(89, 11); |
1007 | 0 | ais->type20.offset3 = UBITS(100, 12); |
1008 | 0 | ais->type20.number3 = UBITS(112, 4); |
1009 | 0 | ais->type20.timeout3 = UBITS(116, 3); |
1010 | 0 | ais->type20.increment3 = UBITS(119, 11); |
1011 | 0 | ais->type20.offset4 = UBITS(130, 12); |
1012 | 0 | ais->type20.number4 = UBITS(142, 4); |
1013 | 0 | ais->type20.timeout4 = UBITS(146, 3); |
1014 | 0 | ais->type20.increment4 = UBITS(149, 11); |
1015 | 0 | break; |
1016 | 0 | case 21: // Aid-to-Navigation Report |
1017 | | // Per https://www.navcen.uscg.gov/ais-class-b-reports |
1018 | 0 | RANGE_CHECK(272, 368); |
1019 | 0 | ais->type21.aid_type = UBITS(38, 5); |
1020 | 0 | from_sixbit_untrimmed(errout, bits, bitlen, 43, 20, ais->type21.name, |
1021 | 0 | sizeof(ais->type21.name)); |
1022 | 0 | ais->type21.accuracy = UBITS(163, 1); |
1023 | 0 | ais->type21.lon = SBITS(164, 28); |
1024 | 0 | ais->type21.lat = SBITS(192, 27); |
1025 | 0 | ais->type21.to_bow = UBITS(219, 9); |
1026 | 0 | ais->type21.to_stern = UBITS(228, 9); |
1027 | 0 | ais->type21.to_port = UBITS(237, 6); |
1028 | 0 | ais->type21.to_starboard = UBITS(243, 6); |
1029 | 0 | ais->type21.epfd = UBITS(249, 4); |
1030 | 0 | ais->type21.second = UBITS(253, 6); |
1031 | 0 | ais->type21.off_position = UBITS(259, 1)!= 0; |
1032 | 0 | ais->type21.regional = UBITS(260, 8); |
1033 | 0 | ais->type21.raim = UBITS(268, 1) != 0; |
1034 | 0 | ais->type21.virtual_aid = UBITS(269, 1) != 0; |
1035 | 0 | ais->type21.assigned = UBITS(270, 1) != 0; |
1036 | | //ais->type21.spare = UBITS(271, 1); |
1037 | 0 | if (20 == strnlen(ais->type21.name, 21) && |
1038 | 0 | 272 < bitlen) { |
1039 | 0 | ENDCHARS(272, ais->type21.name + 20, |
1040 | 0 | sizeof(ais->type21.name) - 20); |
1041 | 0 | } |
1042 | 0 | trim_spaces_on_right_end(ais->type21.name, sizeof(ais->type21.name)); |
1043 | 0 | break; |
1044 | 0 | case 22: // Channel Management |
1045 | 0 | PERMISSIVE_LENGTH_CHECK(168) |
1046 | 0 | ais->type22.channel_a = UBITS(40, 12); |
1047 | 0 | ais->type22.channel_b = UBITS(52, 12); |
1048 | 0 | ais->type22.txrx = UBITS(64, 4); |
1049 | 0 | ais->type22.power = UBITS(68, 1); |
1050 | 0 | ais->type22.addressed = UBITS(139, 1); |
1051 | 0 | if (!ais->type22.addressed) { |
1052 | 0 | ais->type22.area.ne_lon = SBITS(69, 18); |
1053 | 0 | ais->type22.area.ne_lat = SBITS(87, 17); |
1054 | 0 | ais->type22.area.sw_lon = SBITS(104, 18); |
1055 | 0 | ais->type22.area.sw_lat = SBITS(122, 17); |
1056 | 0 | } else { |
1057 | 0 | ais->type22.mmsi.dest1 = UBITS(69, 30); |
1058 | 0 | ais->type22.mmsi.dest2 = UBITS(104, 30); |
1059 | 0 | } |
1060 | 0 | ais->type22.band_a = UBITS(140, 1); |
1061 | 0 | ais->type22.band_b = UBITS(141, 1); |
1062 | 0 | ais->type22.zonesize = UBITS(142, 3); |
1063 | 0 | break; |
1064 | 0 | case 23: // Group Assignment Command |
1065 | 0 | PERMISSIVE_LENGTH_CHECK(160) |
1066 | 0 | ais->type23.ne_lon = SBITS(40, 18); |
1067 | 0 | ais->type23.ne_lat = SBITS(58, 17); |
1068 | 0 | ais->type23.sw_lon = SBITS(75, 18); |
1069 | 0 | ais->type23.sw_lat = SBITS(93, 17); |
1070 | 0 | ais->type23.stationtype = UBITS(110, 4); |
1071 | 0 | ais->type23.shiptype = UBITS(114, 8); |
1072 | 0 | ais->type23.txrx = UBITS(144, 4); |
1073 | 0 | ais->type23.interval = UBITS(146, 4); |
1074 | 0 | ais->type23.quiet = UBITS(150, 4); |
1075 | 0 | break; |
1076 | 0 | case 24: // Class B CS Static Data Report |
1077 | 0 | switch (UBITS(38, 2)) { |
1078 | 0 | case 0: |
1079 | 0 | RANGE_CHECK(160, 168); |
1080 | | // save incoming 24A shipname/MMSI pairs in a circular queue |
1081 | 0 | { |
1082 | 0 | struct ais_type24a_t *saveptr = |
1083 | 0 | &type24_queue->ships[type24_queue->index]; |
1084 | |
|
1085 | 0 | GPSD_LOG(LOG_PROG, errout, "AIVDM: 24A from %09u stashed.\n", |
1086 | 0 | ais->mmsi); |
1087 | 0 | saveptr->mmsi = ais->mmsi; |
1088 | 0 | UCHARS(40, saveptr->shipname); |
1089 | 0 | ++type24_queue->index; |
1090 | 0 | type24_queue->index %= MAX_TYPE24_INTERLEAVE; |
1091 | 0 | } |
1092 | | //ais->type24.a.spare = UBITS(160, 8); |
1093 | |
|
1094 | 0 | UCHARS(40, ais->type24.shipname); |
1095 | 0 | ais->type24.part = part_a; |
1096 | 0 | return true; |
1097 | 0 | case 1: |
1098 | 0 | PERMISSIVE_LENGTH_CHECK(168) |
1099 | 0 | ais->type24.shiptype = UBITS(40, 8); |
1100 | | /* |
1101 | | * In ITU-R 1371-4, there are new model and serial fields |
1102 | | * carved out of the right-hand end of vendorid, which is |
1103 | | * reduced from 7 chars to 3. To cope with older AIS |
1104 | | * implementations conforming to revision 3 and older, |
1105 | | * unpack the trailing bits *both* ways; truly |
1106 | | * revision-4-conformant implementations will have up to |
1107 | | * four characters of trailing garbage on the vendorid, |
1108 | | * and older implementations will have garbafe in the |
1109 | | * model and serial fields. |
1110 | | */ |
1111 | 0 | UCHARS(48, ais->type24.vendorid); |
1112 | 0 | ais->type24.model = UBITS(66, 4); |
1113 | 0 | ais->type24.serial = UBITS(70, 20); |
1114 | 0 | UCHARS(90, ais->type24.callsign); |
1115 | 0 | if (AIS_AUXILIARY_MMSI(ais->mmsi)) { |
1116 | 0 | ais->type24.mothership_mmsi = UBITS(132, 30); |
1117 | 0 | } else { |
1118 | 0 | ais->type24.dim.to_bow = UBITS(132, 9); |
1119 | 0 | ais->type24.dim.to_stern = UBITS(141, 9); |
1120 | 0 | ais->type24.dim.to_port = UBITS(150, 6); |
1121 | 0 | ais->type24.dim.to_starboard = UBITS(156, 6); |
1122 | 0 | } |
1123 | | //ais->type24.b.spare = UBITS(162, 8); |
1124 | | |
1125 | | // search the 24A queue for a matching MMSI |
1126 | 0 | for (u = 0; u < MAX_TYPE24_INTERLEAVE; u++) { |
1127 | 0 | if (type24_queue->ships[u].mmsi == ais->mmsi) { |
1128 | 0 | (void)strlcpy(ais->type24.shipname, |
1129 | 0 | type24_queue->ships[u].shipname, |
1130 | 0 | sizeof(ais->type24.shipname)); |
1131 | 0 | GPSD_LOG(LOG_PROG, errout, |
1132 | 0 | "AIVDM 24B from %09u matches a 24A.\n", |
1133 | 0 | ais->mmsi); |
1134 | | // prevent false match if a 24B is repeated |
1135 | 0 | type24_queue->ships[u].mmsi = 0; |
1136 | 0 | ais->type24.part = both; |
1137 | 0 | return true; |
1138 | 0 | } |
1139 | 0 | } |
1140 | | |
1141 | | // no match, return Part B |
1142 | 0 | ais->type24.part = part_b; |
1143 | 0 | return true; |
1144 | 0 | default: |
1145 | 0 | GPSD_LOG(LOG_WARN, errout, |
1146 | 0 | "AIVDM message type 24 of subtype unknown.\n"); |
1147 | 0 | return false; |
1148 | 0 | } |
1149 | | // break; |
1150 | 0 | case 25: // Binary Message, Single Slot |
1151 | | // this check and the following one reject line noise |
1152 | 0 | if (40 > bitlen || |
1153 | 0 | 168 < bitlen) { |
1154 | 0 | GPSD_LOG(LOG_WARN, errout, |
1155 | 0 | "AIVDM message type 25 size not between " |
1156 | 0 | "40 to 168 bits (%zd).\n", bitlen); |
1157 | 0 | return false; |
1158 | 0 | } |
1159 | 0 | ais->type25.addressed = (bool)UBITS(38, 1); |
1160 | 0 | ais->type25.structured = (bool)UBITS(39, 1); |
1161 | 0 | if (bitlen < (unsigned)(40 + (16 * ais->type25.structured) + |
1162 | 0 | (30 * ais->type25.addressed))) { |
1163 | 0 | GPSD_LOG(LOG_WARN, errout, |
1164 | 0 | "AIVDM message type 25 too short for mode.\n"); |
1165 | 0 | return false; |
1166 | 0 | } |
1167 | 0 | if (ais->type25.addressed) { |
1168 | 0 | ais->type25.dest_mmsi = UBITS(40, 30); |
1169 | 0 | } |
1170 | 0 | if (ais->type25.structured) { |
1171 | 0 | ais->type25.app_id = UBITS(40 + ais->type25.addressed * 30,16); |
1172 | 0 | } |
1173 | 0 | ais->type25.bitcount = bitlen - 40 - 16 * ais->type25.structured; |
1174 | | // bit 40 is exactly 5 bytes in; 2 bytes is 16 bits |
1175 | 0 | (void)memcpy(ais->type25.bitdata, |
1176 | 0 | bits + 5 + 2 * ais->type25.structured, |
1177 | 0 | BITS_TO_BYTES(ais->type25.bitcount)); |
1178 | | // discard MMSI if addressed |
1179 | 0 | if (ais->type25.addressed) { |
1180 | 0 | shiftleft((unsigned char *)ais->type25.bitdata, |
1181 | 0 | ais->type25.bitcount, 30); |
1182 | 0 | ais->type25.bitcount -= 30; |
1183 | 0 | } |
1184 | 0 | break; |
1185 | 0 | case 26: // Binary Message, Multiple Slot |
1186 | 0 | RANGE_CHECK(60, 1004); |
1187 | 0 | ais->type26.addressed = (bool)UBITS(38, 1); |
1188 | 0 | ais->type26.structured = (bool)UBITS(39, 1); |
1189 | 0 | if ((signed)bitlen < 40 + 16 * ais->type26.structured + |
1190 | 0 | 30 * ais->type26.addressed + 20) { |
1191 | 0 | GPSD_LOG(LOG_WARN, errout, |
1192 | 0 | "AIVDM message type 26 too short for mode.\n"); |
1193 | 0 | return false; |
1194 | 0 | } |
1195 | 0 | if (ais->type26.addressed) { |
1196 | 0 | ais->type26.dest_mmsi = UBITS(40, 30); |
1197 | 0 | } |
1198 | 0 | if (ais->type26.structured) { |
1199 | 0 | ais->type26.app_id = UBITS(40 + ais->type26.addressed * 30, 16); |
1200 | 0 | } |
1201 | 0 | ais->type26.bitcount = bitlen - 60 - 16 * ais->type26.structured; |
1202 | 0 | (void)memcpy(ais->type26.bitdata, |
1203 | 0 | bits + 5 + 2 * ais->type26.structured, |
1204 | 0 | BITS_TO_BYTES(ais->type26.bitcount)); |
1205 | | // discard MMSI if addressed |
1206 | 0 | if (ais->type26.addressed) { |
1207 | 0 | shiftleft((unsigned char *)ais->type26.bitdata, |
1208 | 0 | ais->type26.bitcount, 30); |
1209 | 0 | ais->type26.bitcount -= 30; |
1210 | 0 | } |
1211 | 0 | break; |
1212 | 0 | case 27: // Long Range AIS Broadcast message |
1213 | 0 | if (96 != bitlen && |
1214 | 0 | 168 != bitlen) { |
1215 | 0 | GPSD_LOG(LOG_WARN, errout, |
1216 | 0 | "unexpected AIVDM message type 27 (%zd).\n", |
1217 | 0 | bitlen); |
1218 | 0 | return false; |
1219 | 0 | } |
1220 | 0 | if (168 == bitlen) { |
1221 | | /* |
1222 | | * This is an implementation error observed in the wild, |
1223 | | * sending a full 168-bit slot rather than just 96 bits. |
1224 | | */ |
1225 | 0 | GPSD_LOG(LOG_WARN, errout, |
1226 | 0 | "oversized 168-bit AIVDM message type 27.\n"); |
1227 | 0 | } |
1228 | 0 | ais->type27.accuracy = (bool)UBITS(38, 1); |
1229 | 0 | ais->type27.raim = UBITS(39, 1) != 0; |
1230 | 0 | ais->type27.status = UBITS(40, 4); |
1231 | 0 | ais->type27.lon = SBITS(44, 18); |
1232 | 0 | ais->type27.lat = SBITS(62, 17); |
1233 | 0 | ais->type27.speed = UBITS(79, 6); |
1234 | 0 | ais->type27.course = UBITS(85, 9); |
1235 | 0 | ais->type27.gnss = (bool)UBITS(94, 1); |
1236 | 0 | break; |
1237 | 0 | default: |
1238 | 0 | GPSD_LOG(LOG_ERROR, errout, |
1239 | 0 | "Unparsed AIVDM message type %d.\n",ais->type); |
1240 | 0 | return false; |
1241 | 0 | } |
1242 | | // *INDENT-ON* |
1243 | 0 | #undef UCHARS |
1244 | 0 | #undef SBITS |
1245 | 0 | #undef UBITS |
1246 | | |
1247 | | // data is fully decoded |
1248 | 0 | return true; |
1249 | 0 | } |
1250 | | // vim: set expandtab shiftwidth=4 |