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