Coverage Report

Created: 2026-06-10 06:24

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/gpsd/gpsd-3.27.6~dev/libgps/libgps_json.c
Line
Count
Source
1
/****************************************************************************
2
3
NAME
4
   libgps_json.c - deserialize gpsd data coming from the server
5
6
DESCRIPTION
7
   This module uses the generic JSON parser to get data from JSON
8
representations to libgps structures.
9
10
PERMISSIONS
11
   Written by Eric S. Raymond, 2009
12
   This file is Copyright by the GPSD project
13
   SPDX-License-Identifier: BSD-2-clause
14
15
***************************************************************************/
16
17
/* isfinite() needs _POSIX_C_SOURCE >= 200112L
18
 * isnan(+Inf) is false, isfinite(+Inf) is false
19
 * use isfinite() to make sure a float or double is valid
20
 */
21
22
#include "../include/gpsd_config.h"   // must be before all includes
23
24
#include <assert.h>                  // for assert()  :-(
25
#include <math.h>
26
#include <stdbool.h>
27
#include <stddef.h>
28
#include <string.h>
29
30
#include "../include/gpsd.h"
31
#include "../include/strfuncs.h"
32
#include "../include/gps_json.h"
33
#include "../include/timespec.h"
34
35
static int json_tpv_read(const char *buf, struct gps_data_t *gpsdata,
36
                         const char **endptr)
37
476
{
38
476
    int ret;
39
40
476
    const struct json_attr_t json_attrs_1[] = {
41
        // *INDENT-OFF*
42
476
        {"class",  t_check,   .dflt.check = "TPV"},
43
476
        {"alt",    t_real,    .addr.real = &gpsdata->fix.altitude,
44
476
                                 .dflt.real = NAN}, // DEPRECATED, undefined
45
476
        {"altHAE", t_real,    .addr.real = &gpsdata->fix.altHAE,
46
476
                                 .dflt.real = NAN},
47
476
        {"altMSL", t_real,    .addr.real = &gpsdata->fix.altMSL,
48
476
                                 .dflt.real = NAN},
49
476
        {"ant",    t_integer, .addr.integer = &gpsdata->fix.ant_stat,
50
476
                                 .dflt.integer = 0},
51
476
        {"antPwr",    t_integer, .addr.integer = &gpsdata->fix.ant_power,
52
476
                                 .dflt.integer = 0},
53
476
        {"baseS",     t_integer,   .addr.integer = &gpsdata->fix.base.status,
54
476
         .dflt.integer = STATUS_UNK},     // aka zero
55
476
        {"baseE",     t_real,      .addr.real = &gpsdata->fix.base.east,
56
476
         .dflt.real = NAN},
57
476
        {"baseN",     t_real,      .addr.real = &gpsdata->fix.base.north,
58
476
         .dflt.real = NAN},
59
476
        {"baseU",     t_real,      .addr.real = &gpsdata->fix.base.up,
60
476
         .dflt.real = NAN},
61
476
        {"baseL",     t_real,      .addr.real = &gpsdata->fix.base.length,
62
476
         .dflt.real = NAN},
63
476
        {"baseC",     t_real,      .addr.real = &gpsdata->fix.base.course,
64
476
         .dflt.real = NAN},
65
476
        {"climb",     t_real,      .addr.real = &gpsdata->fix.climb,
66
476
                                   .dflt.real = NAN},
67
476
        {"clockbias", t_longint, .addr.longint = &gpsdata->fix.clockbias,
68
476
                                 .dflt.longint = 0},
69
476
        {"clockdrift", t_longint, .addr.longint = &gpsdata->fix.clockdrift,
70
476
                                 .dflt.longint = 0},
71
476
        {"datum",  t_string,  .addr.string = gpsdata->fix.datum,
72
476
                                 .len = sizeof(gpsdata->fix.datum)},
73
476
        {"device", t_string,  .addr.string = gpsdata->dev.path,
74
476
                                 .len = sizeof(gpsdata->dev.path)},
75
476
        {"depth", t_real,  .addr.real = &gpsdata->fix.depth,
76
476
                                 .dflt.real = NAN},
77
476
        {"dgpsAge", t_real, .addr.real = &gpsdata->fix.dgps_age,
78
476
                                 .dflt.real = NAN},
79
476
        {"dgpsRatio", t_real, .addr.real = &gpsdata->fix.base.ratio,
80
476
                                 .dflt.real = NAN},
81
476
        {"dgpsSta", t_integer, .addr.integer = &gpsdata->fix.dgps_station,
82
476
                                 .dflt.integer = -1},
83
476
        {"ecefx",  t_real,    .addr.real = &gpsdata->fix.ecef.x,
84
476
                                 .dflt.real = NAN},
85
476
        {"ecefy",  t_real,    .addr.real = &gpsdata->fix.ecef.y,
86
476
                                 .dflt.real = NAN},
87
476
        {"ecefz",  t_real,    .addr.real = &gpsdata->fix.ecef.z,
88
476
                                 .dflt.real = NAN},
89
476
        {"ecefvx", t_real,    .addr.real = &gpsdata->fix.ecef.vx,
90
476
                                 .dflt.real = NAN},
91
476
        {"ecefvy", t_real,    .addr.real = &gpsdata->fix.ecef.vy,
92
476
                                 .dflt.real = NAN},
93
476
        {"ecefvz", t_real,    .addr.real = &gpsdata->fix.ecef.vz,
94
476
                                 .dflt.real = NAN},
95
476
        {"ecefpAcc", t_real,  .addr.real = &gpsdata->fix.ecef.pAcc,
96
476
                                 .dflt.real = NAN},
97
476
        {"ecefvAcc", t_real,  .addr.real = &gpsdata->fix.ecef.vAcc,
98
476
                                 .dflt.real = NAN},
99
476
        {"epc",    t_real,    .addr.real = &gpsdata->fix.epc,
100
476
                                 .dflt.real = NAN},
101
476
        {"epd",    t_real,    .addr.real = &gpsdata->fix.epd,
102
476
                                 .dflt.real = NAN},
103
476
        {"eph",    t_real,    .addr.real = &gpsdata->fix.eph,
104
476
                                 .dflt.real = NAN},
105
476
        {"eps",    t_real,    .addr.real = &gpsdata->fix.eps,
106
476
                                 .dflt.real = NAN},
107
476
        {"ept",    t_real,    .addr.real = &gpsdata->fix.ept,
108
476
                                 .dflt.real = NAN},
109
476
        {"epx",    t_real,    .addr.real = &gpsdata->fix.epx,
110
476
                                 .dflt.real = NAN},
111
476
        {"epy",    t_real,    .addr.real = &gpsdata->fix.epy,
112
476
                                 .dflt.real = NAN},
113
476
        {"epv",    t_real,    .addr.real = &gpsdata->fix.epv,
114
476
                                 .dflt.real = NAN},
115
476
        {"geoidSep", t_real,  .addr.real = &gpsdata->fix.geoid_sep,
116
476
                                 .dflt.real = NAN},
117
476
        {"lat",    t_real,    .addr.real = &gpsdata->fix.latitude,
118
476
                                 .dflt.real = NAN},
119
476
        {"jam",    t_integer, .addr.integer = &gpsdata->fix.jam,
120
476
                                 .dflt.integer = -1},
121
476
        {"leapseconds",   t_integer, .addr.integer = &gpsdata->leap_seconds,
122
476
                                 .dflt.integer = 0},
123
476
        {"lon",    t_real,    .addr.real = &gpsdata->fix.longitude,
124
476
                                 .dflt.real = NAN},
125
476
        {"magtrack",  t_real,    .addr.real = &gpsdata->fix.magnetic_track,
126
476
                                 .dflt.real = NAN},
127
476
        {"magvar",  t_real,   .addr.real = &gpsdata->fix.magnetic_var,
128
476
                                 .dflt.real = NAN},
129
476
        {"mode",   t_integer, .addr.integer = &gpsdata->fix.mode,
130
476
                                 .dflt.integer = MODE_NOT_SEEN},
131
476
        {"relD", t_real,  .addr.real = &gpsdata->fix.NED.relPosD,
132
476
                                 .dflt.real = NAN},
133
476
        {"relE", t_real,  .addr.real = &gpsdata->fix.NED.relPosE,
134
476
                                 .dflt.real = NAN},
135
476
        {"relN", t_real,  .addr.real = &gpsdata->fix.NED.relPosN,
136
476
                                 .dflt.real = NAN},
137
476
        {"relH", t_real,  .addr.real = &gpsdata->fix.NED.relPosH,
138
476
                                 .dflt.real = NAN},
139
476
        {"relL", t_real,  .addr.real = &gpsdata->fix.NED.relPosL,
140
476
                                 .dflt.real = NAN},
141
476
        {"temp",   t_real, .addr.real = &gpsdata->fix.temp,
142
476
                                 .dflt.real = NAN},
143
476
        {"time",   t_time,    .addr.ts = &gpsdata->fix.time,
144
476
                                 .dflt.ts = {0, 0}},
145
476
        {"track",  t_real,    .addr.real = &gpsdata->fix.track,
146
476
                                 .dflt.real = NAN},
147
476
        {"sep",    t_real,    .addr.real = &gpsdata->fix.sep,
148
476
                                 .dflt.real = NAN},
149
476
        {"speed",  t_real,    .addr.real = &gpsdata->fix.speed,
150
476
                                 .dflt.real = NAN},
151
476
        {"status", t_integer, .addr.integer = &gpsdata->fix.status,
152
476
                                 .dflt.integer = STATUS_UNK},
153
476
        {"velD", t_real,  .addr.real = &gpsdata->fix.NED.velD,
154
476
                                 .dflt.real = NAN},
155
476
        {"velE", t_real,  .addr.real = &gpsdata->fix.NED.velE,
156
476
                                 .dflt.real = NAN},
157
476
        {"velN", t_real,  .addr.real = &gpsdata->fix.NED.velN,
158
476
                                 .dflt.real = NAN},
159
476
        {"wanglem", t_real, .addr.real = &gpsdata->fix.wanglem,
160
476
                                 .dflt.real = NAN},
161
476
        {"wangler", t_real, .addr.real = &gpsdata->fix.wangler,
162
476
                                 .dflt.real = NAN},
163
476
        {"wanglet", t_real, .addr.real = &gpsdata->fix.wanglet,
164
476
                                 .dflt.real = NAN},
165
476
        {"wspeedr", t_real, .addr.real = &gpsdata->fix.wspeedr,
166
476
                                 .dflt.real = NAN},
167
476
        {"wspeedt", t_real, .addr.real = &gpsdata->fix.wspeedt,
168
476
                                 .dflt.real = NAN},
169
476
        {"wtemp", t_real, .addr.real = &gpsdata->fix.wtemp,
170
476
                                 .dflt.real = NAN},
171
        // ignore unknown keys, for cross-version compatibility
172
476
        {"", t_ignore},
173
174
476
        {NULL},
175
        // *INDENT-ON*
176
476
    };
177
178
476
    ret = json_read_object(buf, json_attrs_1, endptr);
179
476
    return ret;
180
476
}
181
182
static int json_noise_read(const char *buf, struct gps_data_t *gpsdata,
183
                           const char **endptr)
184
314
{
185
314
    int ret;
186
187
314
    const struct json_attr_t json_attrs_1[] = {
188
        // *INDENT-OFF*
189
314
        {"class",  t_check,   .dflt.check = "GST"},
190
314
        {"device", t_string,  .addr.string = gpsdata->dev.path,
191
314
                                 .len = sizeof(gpsdata->dev.path)},
192
314
        {"time",   t_time,    .addr.ts = &gpsdata->gst.utctime,
193
314
                                 .dflt.ts = {0, 0}},
194
314
        {"alt",    t_real,    .addr.real = &gpsdata->gst.alt_err_deviation,
195
314
                                 .dflt.real = NAN},
196
314
        {"lat",    t_real,    .addr.real = &gpsdata->gst.lat_err_deviation,
197
314
                                 .dflt.real = NAN},
198
314
        {"lon",    t_real,    .addr.real = &gpsdata->gst.lon_err_deviation,
199
314
                                 .dflt.real = NAN},
200
314
        {"major",  t_real,    .addr.real = &gpsdata->gst.smajor_deviation,
201
314
                                 .dflt.real = NAN},
202
314
        {"minor",  t_real,    .addr.real = &gpsdata->gst.sminor_deviation,
203
314
                                 .dflt.real = NAN},
204
314
        {"orient", t_real,    .addr.real = &gpsdata->gst.smajor_orientation,
205
314
                                 .dflt.real = NAN},
206
314
        {"rms",    t_real,    .addr.real = &gpsdata->gst.rms_deviation,
207
314
                                 .dflt.real = NAN},
208
314
        {"ve",     t_real,    .addr.real = &gpsdata->gst.ve_err_deviation,
209
314
                                 .dflt.real = NAN},
210
314
        {"vn",     t_real,    .addr.real = &gpsdata->gst.vn_err_deviation,
211
314
                                 .dflt.real = NAN},
212
314
        {"vu",     t_real,    .addr.real = &gpsdata->gst.vu_err_deviation,
213
314
                                 .dflt.real = NAN},
214
        // ignore unknown keys, for cross-version compatibility
215
314
        {"", t_ignore},
216
314
        {NULL},
217
        // *INDENT-ON*
218
314
    };
219
220
314
    ret = json_read_object(buf, json_attrs_1, endptr);
221
222
314
    return ret;
223
314
}
224
225
// decode a RAW messages into gpsdata.raw
226
static int json_raw_read(const char *buf, struct gps_data_t *gpsdata,
227
                         const char **endptr)
228
134
{
229
134
    unsigned measurements;
230
    // initialized to shut up clang
231
134
    double mtime_s = 0.0, mtime_ns = 0.0;
232
233
134
    const struct json_attr_t json_attrs_meas[] = {
234
        // *INDENT-OFF*
235
134
        {"gnssid",       t_ubyte,    STRUCTOBJECT(struct meas_t, gnssid)},
236
134
        {"svid",         t_ubyte,    STRUCTOBJECT(struct meas_t, svid)},
237
134
        {"sigid",        t_ubyte,    STRUCTOBJECT(struct meas_t, sigid),
238
134
                                     .dflt.ubyte = 0},
239
134
        {"snr",          t_ubyte,    STRUCTOBJECT(struct meas_t, snr)},
240
134
        {"freqid",       t_ubyte,    STRUCTOBJECT(struct meas_t, freqid),
241
134
                                     .dflt.ubyte = 0},
242
134
        {"obs",          t_string,   STRUCTOBJECT(struct meas_t, obs_code),
243
134
                                .len = sizeof(gpsdata->raw.meas[0].obs_code)},
244
134
        {"lli",          t_ubyte,    STRUCTOBJECT(struct meas_t, lli),
245
134
                                     .dflt.ubyte = 0},
246
134
        {"locktime",     t_uinteger, STRUCTOBJECT(struct meas_t, locktime),
247
134
                                     .dflt.uinteger = 0},
248
134
        {"carrierphase", t_real,     STRUCTOBJECT(struct meas_t, carrierphase),
249
134
                                     .dflt.real = NAN},
250
134
        {"pseudorange",  t_real,     STRUCTOBJECT(struct meas_t, pseudorange),
251
134
                                     .dflt.real = NAN},
252
134
        {"doppler",      t_real,     STRUCTOBJECT(struct meas_t, doppler),
253
134
                                     .dflt.real = NAN},
254
134
        {"c2c",          t_real,     STRUCTOBJECT(struct meas_t, c2c),
255
134
                                    .dflt.real = NAN},
256
134
        {"l2c",          t_real,     STRUCTOBJECT(struct meas_t, l2c),
257
134
                                    .dflt.real = NAN},
258
        // ignore unknown keys, for cross-version compatibility
259
134
        {"", t_ignore},
260
        // *INDENT-ON*
261
134
        {NULL},
262
134
    };
263
134
    const struct json_attr_t json_attrs_raw[] = {
264
        // *INDENT-OFF*
265
134
        {"class",      t_check,   .dflt.check = "RAW"},
266
134
        {"device",     t_string,  .addr.string  = gpsdata->dev.path,
267
134
                                    .len = sizeof(gpsdata->dev.path)},
268
134
        {"time",       t_real,    .addr.real = &mtime_s,
269
134
                                 .dflt.real = NAN},
270
134
        {"nsec",       t_real,    .addr.real = &mtime_ns,
271
134
                                 .dflt.real = NAN},
272
134
        {"rawdata",    t_array,   STRUCTARRAY(gpsdata->raw.meas,
273
134
                                     json_attrs_meas, &measurements)},
274
        // ignore unknown keys, for cross-version compatibility
275
134
        {"", t_ignore},
276
134
        {NULL},
277
        // *INDENT-ON*
278
134
    };
279
134
    int status;
280
281
134
    memset(&gpsdata->raw, 0, sizeof(gpsdata->raw));
282
283
134
    status = json_read_object(buf, json_attrs_raw, endptr);
284
134
    if (0 != status) {
285
116
        return status;
286
116
    }
287
18
    gpsdata->set |= RAW_SET;
288
18
    if (0 == isfinite(mtime_s) ||
289
17
        0 == isfinite(mtime_ns)) {
290
17
        return status;
291
17
    }
292
1
    gpsdata->raw.mtime.tv_sec = (time_t)mtime_s;
293
1
    gpsdata->raw.mtime.tv_nsec = (long)mtime_ns;
294
295
1
    return 0;
296
18
}
297
298
static int json_sky_read(const char *buf, struct gps_data_t *gpsdata,
299
                         const char **endptr)
300
168
{
301
302
168
    const struct json_attr_t json_attrs_satellites[] = {
303
        // *INDENT-OFF*
304
168
        {"PRN",    t_short,   STRUCTOBJECT(struct satellite_t, PRN)},
305
168
        {"az",     t_real,    STRUCTOBJECT(struct satellite_t, azimuth),
306
168
                              .dflt.real = NAN},
307
168
        {"el",     t_real,    STRUCTOBJECT(struct satellite_t, elevation),
308
168
                              .dflt.real = NAN},
309
168
        {"freqid", t_byte,    STRUCTOBJECT(struct satellite_t, freqid),
310
168
                              .dflt.byte = -1},
311
168
        {"gnssid", t_ubyte,   STRUCTOBJECT(struct satellite_t, gnssid)},
312
168
        {"health", t_ubyte,   STRUCTOBJECT(struct satellite_t, health),
313
168
                              .dflt.ubyte = SAT_HEALTH_UNK},
314
168
        {"pr",     t_real,    STRUCTOBJECT(struct satellite_t, pr),
315
168
                              .dflt.real = NAN},
316
168
        {"prRate", t_real,    STRUCTOBJECT(struct satellite_t, prRate),
317
168
                              .dflt.real = NAN},
318
168
        {"prRes",  t_real,    STRUCTOBJECT(struct satellite_t, prRes),
319
168
                              .dflt.real = NAN},
320
168
        {"ss",     t_real,    STRUCTOBJECT(struct satellite_t, ss),
321
168
                              .dflt.real = NAN},
322
168
        {"sigid",  t_ubyte,   STRUCTOBJECT(struct satellite_t, sigid)},
323
168
        {"svid",   t_ubyte,   STRUCTOBJECT(struct satellite_t, svid)},
324
168
        {"used",   t_boolean, STRUCTOBJECT(struct satellite_t, used)},
325
        // ignore unknown keys, for cross-version compatibility
326
168
        {"", t_ignore},
327
        // *INDENT-ON*
328
168
        {NULL},
329
168
    };
330
331
168
    int nSat = -1;  // Use nSat only to know if sats are in SKY
332
333
168
    const struct json_attr_t json_attrs_2[] = {
334
        // *INDENT-OFF*
335
168
        {"class",      t_check,   .dflt.check = "SKY"},
336
168
        {"device",     t_string,  .addr.string  = gpsdata->dev.path,
337
168
                                     .len = sizeof(gpsdata->dev.path)},
338
168
        {"gdop",       t_real,    .addr.real    = &gpsdata->dop.gdop,
339
168
                                     .dflt.real = NAN},
340
168
        {"hdop",       t_real,    .addr.real    = &gpsdata->dop.hdop,
341
168
                                     .dflt.real = NAN},
342
168
        {"nSat",       t_integer, .addr.integer = &nSat,
343
168
                                     .dflt.integer = -1},
344
168
        {"pdop",       t_real,    .addr.real    = &gpsdata->dop.pdop,
345
168
                                     .dflt.real = NAN},
346
168
        {"tdop",       t_real,    .addr.real    = &gpsdata->dop.tdop,
347
168
                                     .dflt.real = NAN},
348
168
        {"vdop",       t_real,    .addr.real    = &gpsdata->dop.vdop,
349
168
                                     .dflt.real = NAN},
350
168
        {"xdop",       t_real,    .addr.real    = &gpsdata->dop.xdop,
351
168
                                     .dflt.real = NAN},
352
168
        {"ydop",       t_real,    .addr.real    = &gpsdata->dop.ydop,
353
168
                                     .dflt.real = NAN},
354
168
        {"satellites", t_array,
355
168
                                   STRUCTARRAY(gpsdata->skyview,
356
168
                                         json_attrs_satellites,
357
168
                                         &gpsdata->satellites_visible)},
358
168
        {"time",       t_time,    .addr.ts = &gpsdata->skyview_time,
359
168
                                     .dflt.ts = {0, 0}},
360
168
        {"uSat",       t_integer, .addr.integer = &gpsdata->satellites_used,
361
168
                                     .dflt.integer = 0},
362
        // ignore unknown keys, for cross-version compatibility
363
168
        {"", t_ignore},
364
168
        {NULL},
365
        // *INDENT-ON*
366
168
    };
367
168
    int status, i;
368
369
168
    memset(&gpsdata->skyview, 0, sizeof(gpsdata->skyview));
370
371
168
    status = json_read_object(buf, json_attrs_2, endptr);
372
168
    if (0 != status) {
373
63
        return status;
374
63
    }
375
376
105
    if (1 == isfinite(gpsdata->dop.hdop) ||
377
104
        1 == isfinite(gpsdata->dop.xdop) ||
378
103
        1 == isfinite(gpsdata->dop.ydop) ||
379
102
        1 == isfinite(gpsdata->dop.vdop) ||
380
101
        1 == isfinite(gpsdata->dop.tdop) ||
381
100
        1 == isfinite(gpsdata->dop.pdop) ||
382
99
        1 == isfinite(gpsdata->dop.gdop)) {
383
        // got at least one DOP
384
7
        gpsdata->set |= DOP_SET;
385
7
    }
386
387
105
    gpsdata->satellites_visible = 0;
388
389
105
    if (-1 == nSat) {
390
        // no sats in the SKY, likely just dops.  Maybe uSat
391
15
        gpsdata->set &= ~SATELLITE_SET;
392
15
        return 0;
393
15
    }
394
90
    gpsdata->satellites_used = 0;
395
396
90
    gpsdata->set |= SATELLITE_SET;
397
    // recalculate used and visible, do not use nSat, uSat
398
20.7k
    for (i = 0; i < MAXCHANNELS; i++) {
399
20.7k
        if (0 < gpsdata->skyview[i].PRN) {
400
1.17k
            gpsdata->satellites_visible++;
401
1.17k
        }
402
20.7k
        if (gpsdata->skyview[i].used) {
403
1.38k
            gpsdata->satellites_used++;
404
1.38k
        }
405
20.7k
    }
406
407
90
    return 0;
408
105
}
409
410
// decode class ATT, almost the same as IMU
411
static int json_att_read(const char *buf, struct gps_data_t *gpsdata,
412
                         const char **endptr)
413
68
{
414
68
    struct attitude_t *datap = &gpsdata->attitude;
415
416
68
    const struct json_attr_t json_attrs_1[] = {
417
        // *INDENT-OFF*
418
68
        {"class",     t_check,     .dflt.check = "ATT"},
419
68
        {"device",    t_string,    .addr.string = gpsdata->dev.path,
420
68
         .len = sizeof(gpsdata->dev.path)},
421
68
        {"acc_len",   t_real,      .addr.real = &datap->acc_len,
422
68
         .dflt.real = NAN},
423
68
        {"acc_x",     t_real,      .addr.real = &datap->acc_x,
424
68
         .dflt.real = NAN},
425
68
        {"acc_y",     t_real,      .addr.real = &datap->acc_y,
426
68
         .dflt.real = NAN},
427
68
        {"acc_z",     t_real,      .addr.real = &datap->acc_z,
428
68
         .dflt.real = NAN},
429
68
        {"baseS",     t_integer,   .addr.integer = &datap->base.status,
430
68
         .dflt.integer = STATUS_UNK},     // aka zero
431
68
        {"baseE",     t_real,      .addr.real = &datap->base.east,
432
68
         .dflt.real = NAN},
433
68
        {"baseN",     t_real,      .addr.real = &datap->base.north,
434
68
         .dflt.real = NAN},
435
68
        {"baseU",     t_real,      .addr.real = &datap->base.up,
436
68
         .dflt.real = NAN},
437
68
        {"baseL",     t_real,      .addr.real = &datap->base.length,
438
68
         .dflt.real = NAN},
439
68
        {"baseC",     t_real,      .addr.real = &datap->base.course,
440
68
         .dflt.real = NAN},
441
68
        {"dgpsRatio", t_real, .addr.real = &datap->base.ratio,
442
68
         .dflt.real = NAN},
443
68
        {"depth",     t_real,      .addr.real = &datap->depth,
444
68
         .dflt.real = NAN},
445
68
        {"dip",       t_real,      .addr.real = &datap->dip,
446
68
         .dflt.real = NAN},
447
68
        {"gyro_temp", t_real,      .addr.real = &datap->gyro_x,
448
68
         .dflt.real = NAN},
449
68
        {"gyro_x",    t_real,      .addr.real = &datap->gyro_x,
450
68
         .dflt.real = NAN},
451
68
        {"gyro_y",    t_real,      .addr.real = &datap->gyro_y,
452
68
         .dflt.real = NAN},
453
68
        {"gyro_z",    t_real,      .addr.real = &datap->gyro_z,
454
68
         .dflt.real = NAN},
455
68
        {"heading",   t_real,      .addr.real = &datap->heading,
456
68
         .dflt.real = NAN},
457
68
        {"mag_len",   t_real,      .addr.real = &datap->mag_len,
458
68
         .dflt.real = NAN},
459
68
        {"mag_st",    t_character, .addr.character = &datap->mag_st},
460
68
        {"mag_x",     t_real,      .addr.real = &datap->mag_x,
461
68
         .dflt.real = NAN},
462
68
        {"mag_y",     t_real,      .addr.real = &datap->mag_y,
463
68
         .dflt.real = NAN},
464
68
        {"mag_z",     t_real,      .addr.real = &datap->mag_z,
465
68
         .dflt.real = NAN},
466
68
        {"mheading",   t_real,     .addr.real = &datap->mheading,
467
68
         .dflt.real = NAN},
468
68
        {"msg",       t_string,    .addr.string = datap->msg,
469
68
         .len = sizeof(datap->msg)},
470
68
        {"pitch_st",  t_character, .addr.character = &datap->pitch_st},
471
68
        {"pitch",     t_real,      .addr.real = &datap->pitch,
472
68
         .dflt.real = NAN},
473
68
        {"roll_st",   t_character, .addr.character = &datap->roll_st},
474
68
        {"roll",      t_real,      .addr.real = &datap->roll,
475
68
         .dflt.real = NAN},
476
68
        {"temp",      t_real,      .addr.real = &datap->temp,
477
68
         .dflt.real = NAN},
478
68
        {"time",      t_time,      .addr.ts = &datap->mtime, .dflt.ts = {0, 0}},
479
68
        {"timeTag",   t_ulongint,  .addr.ulongint = &datap->timeTag,
480
68
         .dflt.ulongint = 0},
481
68
        {"yaw_st",    t_character, .addr.character = &datap->yaw_st},
482
68
        {"yaw",       t_real,      .addr.real = &datap->yaw, .dflt.real = NAN},
483
484
        // ignore unknown keys, for cross-version compatibility
485
68
        {"", t_ignore},
486
68
        {NULL},
487
        // *INDENT-ON*
488
68
    };
489
490
68
    return json_read_object(buf, json_attrs_1, endptr);
491
68
}
492
493
// decode class IMU, almost the ame as ATT
494
static int json_imu_read(const char *buf, struct gps_data_t *gpsdata,
495
                         const char **endptr)
496
54
{
497
    // the client only uses the first slot.
498
54
    struct attitude_t *datap = &gpsdata->imu[0];
499
500
54
    const struct json_attr_t json_attrs_1[] = {
501
        // *INDENT-OFF*
502
54
        {"class",     t_check,     .dflt.check = "IMU"},
503
54
        {"device",    t_string,    .addr.string = gpsdata->dev.path,
504
54
         .len = sizeof(gpsdata->dev.path)},
505
54
        {"acc_len",   t_real,      .addr.real = &datap->acc_len,
506
54
         .dflt.real = NAN},
507
54
        {"acc_x",     t_real,      .addr.real = &datap->acc_x,
508
54
         .dflt.real = NAN},
509
54
        {"acc_y",     t_real,      .addr.real = &datap->acc_y,
510
54
         .dflt.real = NAN},
511
54
        {"acc_z",     t_real,      .addr.real = &datap->acc_z,
512
54
         .dflt.real = NAN},
513
54
        {"depth",     t_real,      .addr.real = &datap->depth,
514
54
         .dflt.real = NAN},
515
54
        {"dip",       t_real,      .addr.real = &datap->dip,
516
54
         .dflt.real = NAN},
517
54
        {"gyro_temp", t_real,      .addr.real = &datap->gyro_temp,
518
54
         .dflt.real = NAN},
519
54
        {"gyro_x",    t_real,      .addr.real = &datap->gyro_x,
520
54
         .dflt.real = NAN},
521
54
        {"gyro_y",    t_real,      .addr.real = &datap->gyro_y,
522
54
         .dflt.real = NAN},
523
54
        {"gyro_z",    t_real,      .addr.real = &datap->gyro_z,
524
54
         .dflt.real = NAN},
525
54
        {"heading",   t_real,      .addr.real = &datap->heading,
526
54
         .dflt.real = NAN},
527
54
        {"mag_len",   t_real,      .addr.real = &datap->mag_len,
528
54
         .dflt.real = NAN},
529
54
        {"mag_st",    t_character, .addr.character = &datap->mag_st},
530
54
        {"mag_x",     t_real,      .addr.real = &datap->mag_x,
531
54
         .dflt.real = NAN},
532
54
        {"mag_y",     t_real,      .addr.real = &datap->mag_y,
533
54
         .dflt.real = NAN},
534
54
        {"mag_z",     t_real,      .addr.real = &datap->mag_z,
535
54
         .dflt.real = NAN},
536
54
        {"msg",       t_string,    .addr.string = datap->msg,
537
54
         .len = sizeof(datap->msg)},
538
54
        {"pitch_st",  t_character, .addr.character = &datap->pitch_st},
539
54
        {"pitch",     t_real,      .addr.real = &datap->pitch,
540
54
         .dflt.real = NAN},
541
54
        {"roll_st",   t_character, .addr.character = &datap->roll_st},
542
54
        {"roll",      t_real,      .addr.real = &datap->roll,
543
54
         .dflt.real = NAN},
544
54
        {"temp",      t_real,      .addr.real = &datap->temp,
545
54
         .dflt.real = NAN},
546
54
        {"time",      t_time,      .addr.ts = &datap->mtime, .dflt.ts = {0, 0}},
547
54
        {"timeTag",   t_ulongint,  .addr.ulongint = &datap->timeTag,
548
54
         .dflt.ulongint = 0},
549
54
        {"yaw_st",    t_character, .addr.character = &datap->yaw_st},
550
54
        {"yaw",       t_real,      .addr.real = &datap->yaw, .dflt.real = NAN},
551
552
        // ignore unknown keys, for cross-version compatibility
553
54
        {"", t_ignore},
554
54
        {NULL},
555
        // *INDENT-ON*
556
54
    };
557
558
54
    return json_read_object(buf, json_attrs_1, endptr);
559
54
}
560
561
static int json_devicelist_read(const char *buf, struct gps_data_t *gpsdata,
562
                                const char **endptr)
563
80
{
564
80
    const struct json_attr_t json_attrs_subdevices[] = {
565
        // *INDENT-OFF*
566
80
        {"class",      t_check,      .dflt.check = "DEVICE"},
567
80
        {"path",       t_string,     STRUCTOBJECT(struct devconfig_t, path),
568
80
         .len = sizeof(gpsdata->devices.list[0].path)},
569
80
        {"activated",  t_time,
570
80
         STRUCTOBJECT(struct devconfig_t, activated)},
571
80
        {"flags",      t_integer,    STRUCTOBJECT(struct devconfig_t, flags)},
572
80
        {"driver",     t_string,     STRUCTOBJECT(struct devconfig_t, driver),
573
80
         .len = sizeof(gpsdata->devices.list[0].driver)},
574
80
        {"hexdata",    t_string,     STRUCTOBJECT(struct devconfig_t, hexdata),
575
80
         .len = sizeof(gpsdata->devices.list[0].hexdata)},
576
80
        {"sernum",     t_string,     STRUCTOBJECT(struct devconfig_t, sernum),
577
80
                            .len = sizeof(gpsdata->devices.list[0].sernum)},
578
80
        {"subtype",    t_string,     STRUCTOBJECT(struct devconfig_t, subtype),
579
80
                            .len = sizeof(gpsdata->devices.list[0].subtype)},
580
80
        {"subtype1",   t_string,     STRUCTOBJECT(struct devconfig_t, subtype1),
581
80
                            .len = sizeof(gpsdata->devices.list[0].subtype1)},
582
80
        {"native",     t_integer, STRUCTOBJECT(struct devconfig_t, driver_mode),
583
80
                                        .dflt.integer = -1},
584
80
        {"bps",        t_uinteger,   STRUCTOBJECT(struct devconfig_t, baudrate),
585
80
                                        .dflt.uinteger = DEVDEFAULT_BPS},
586
80
        {"parity",     t_character,  STRUCTOBJECT(struct devconfig_t, parity),
587
80
                                        .dflt.character = DEVDEFAULT_PARITY},
588
80
        {"stopbits",   t_uinteger,   STRUCTOBJECT(struct devconfig_t, stopbits),
589
80
                                        .dflt.integer = DEVDEFAULT_STOPBITS},
590
80
        {"cycle",      t_timespec,   STRUCTOBJECT(struct devconfig_t, cycle),
591
80
                                        .dflt.ts = {0,0}},
592
80
        {"mincycle",   t_timespec,   STRUCTOBJECT(struct devconfig_t, mincycle),
593
80
                                        .dflt.ts = {0,0}},
594
        // ignore unknown keys, for cross-version compatibility
595
80
        {"", t_ignore},
596
80
        {NULL},
597
        // *INDENT-ON*
598
80
    };
599
80
    const struct json_attr_t json_attrs_devices[] = {
600
80
        {"class", t_check,.dflt.check = "DEVICES"},
601
80
        {"devices", t_array, STRUCTARRAY(gpsdata->devices.list,
602
80
                                         json_attrs_subdevices,
603
80
                                         &gpsdata->devices.ndevices)},
604
        // ignore unknown keys, for cross-version compatibility
605
80
        {"", t_ignore},
606
80
        {NULL},
607
80
    };
608
80
    int status;
609
610
80
    memset(&gpsdata->devices, 0, sizeof(gpsdata->devices));
611
80
    status = json_read_object(buf, json_attrs_devices, endptr);
612
80
    if (status != 0) {
613
74
        return status;
614
74
    }
615
616
    // json.c should ensure this never happens
617
80
    assert(MAXUSERDEVS >= gpsdata->devices.ndevices);
618
619
6
    (void)clock_gettime(CLOCK_REALTIME, &gpsdata->devices.time);
620
6
    return 0;
621
6
}
622
623
static int json_version_read(const char *buf, struct gps_data_t *gpsdata,
624
                             const char **endptr)
625
16
{
626
16
    const struct json_attr_t json_attrs_version[] = {
627
        // *INDENT-OFF*
628
16
        {"class",     t_check,   .dflt.check = "VERSION"},
629
16
        {"release",   t_string,  .addr.string  = gpsdata->version.release,
630
16
                                    .len = sizeof(gpsdata->version.release)},
631
16
        {"rev",       t_string,  .addr.string  = gpsdata->version.rev,
632
16
                                    .len = sizeof(gpsdata->version.rev)},
633
16
        {"proto_major", t_integer,
634
16
         .addr.integer = &gpsdata->version.proto_major},
635
16
        {"proto_minor", t_integer,
636
16
         .addr.integer = &gpsdata->version.proto_minor},
637
16
        {"remote",    t_string,  .addr.string  = gpsdata->version.remote,
638
16
                                    .len = sizeof(gpsdata->version.remote)},
639
        // ignore unknown keys, for cross-version compatibility
640
16
        {"", t_ignore},
641
16
        {NULL},
642
        // *INDENT-ON*
643
16
    };
644
16
    int status;
645
646
16
    memset(&gpsdata->version, 0, sizeof(gpsdata->version));
647
16
    status = json_read_object(buf, json_attrs_version, endptr);
648
649
16
    return status;
650
16
}
651
652
static int json_error_read(const char *buf, struct gps_data_t *gpsdata,
653
                           const char **endptr)
654
10
{
655
10
    const struct json_attr_t json_attrs_error[] = {
656
        // *INDENT-OFF*
657
10
        {"class",     t_check,   .dflt.check = "ERROR"},
658
10
        {"message",   t_string,  .addr.string  = gpsdata->error,
659
10
                                    .len = sizeof(gpsdata->error)},
660
        // ignore unknown keys, for cross-version compatibility
661
10
        {"", t_ignore},
662
10
        {NULL},
663
        // *INDENT-ON*
664
10
    };
665
10
    int status;
666
667
10
    memset(&gpsdata->error, 0, sizeof(gpsdata->error));
668
10
    status = json_read_object(buf, json_attrs_error, endptr);
669
10
    if (status != 0)
670
8
        return status;
671
672
2
    return status;
673
10
}
674
675
int json_toff_read(const char *buf, struct gps_data_t *gpsdata,
676
                           const char **endptr)
677
2.89k
{
678
2.89k
    int real_sec = 0, real_nsec = 0, clock_sec = 0, clock_nsec = 0;
679
2.89k
    const struct json_attr_t json_attrs_toff[] = {
680
        // *INDENT-OFF*
681
2.89k
        {"class",     t_check,   .dflt.check = "TOFF"},
682
2.89k
        {"device",    t_string,  .addr.string = gpsdata->dev.path,
683
2.89k
                                 .len = sizeof(gpsdata->dev.path)},
684
2.89k
        {"real_sec",  t_integer, .addr.integer = &real_sec,
685
2.89k
                                 .dflt.integer = 0},
686
2.89k
        {"real_nsec", t_integer, .addr.integer = &real_nsec,
687
2.89k
                                 .dflt.integer = 0},
688
2.89k
        {"clock_sec", t_integer, .addr.integer = &clock_sec,
689
2.89k
                                 .dflt.integer = 0},
690
2.89k
        {"clock_nsec",t_integer, .addr.integer = &clock_nsec,
691
2.89k
                                 .dflt.integer = 0},
692
        // ignore unknown keys, for cross-version compatibility
693
2.89k
        {"", t_ignore},
694
2.89k
        {NULL},
695
        // *INDENT-ON*
696
2.89k
    };
697
2.89k
    int status;
698
699
2.89k
    memset(&gpsdata->toff, 0, sizeof(gpsdata->toff));
700
2.89k
    status = json_read_object(buf, json_attrs_toff, endptr);
701
2.89k
    gpsdata->toff.real.tv_sec = (time_t)real_sec;
702
2.89k
    gpsdata->toff.real.tv_nsec = (long)real_nsec;
703
2.89k
    gpsdata->toff.clock.tv_sec = (time_t)clock_sec;
704
2.89k
    gpsdata->toff.clock.tv_nsec = (long)clock_nsec;
705
2.89k
    if (status != 0)
706
556
        return status;
707
708
2.34k
    return status;
709
2.89k
}
710
711
int json_pps_read(const char *buf, struct gps_data_t *gpsdata,
712
                  const char **endptr)
713
37
{
714
37
    int real_sec = 0, real_nsec = 0, clock_sec = 0, clock_nsec = 0, precision=0;
715
37
    int qErr = 0;
716
717
37
    const struct json_attr_t json_attrs_pps[] = {
718
        // *INDENT-OFF*
719
37
        {"class",     t_check,   .dflt.check = "PPS"},
720
37
        {"device",    t_string,  .addr.string = gpsdata->dev.path,
721
37
                                 .len = sizeof(gpsdata->dev.path)},
722
37
        {"real_sec",  t_integer, .addr.integer = &real_sec,
723
37
                                 .dflt.integer = 0},
724
37
        {"real_nsec", t_integer, .addr.integer = &real_nsec,
725
37
                                 .dflt.integer = 0},
726
37
        {"clock_sec", t_integer, .addr.integer = &clock_sec,
727
37
                                 .dflt.integer = 0},
728
37
        {"clock_nsec",t_integer, .addr.integer = &clock_nsec,
729
37
                                 .dflt.integer = 0},
730
37
        {"precision", t_integer, .addr.integer = &precision,
731
37
                                 .dflt.integer = 0},
732
37
        {"qErr", t_integer, .addr.integer = &qErr,
733
37
                                 .dflt.integer = 0},
734
        // ignore unknown keys, for cross-version compatibility
735
37
        {"", t_ignore},
736
37
        {NULL},
737
        // *INDENT-ON*
738
37
    };
739
37
    int status;
740
741
37
    memset(&gpsdata->pps, 0, sizeof(gpsdata->pps));
742
37
    status = json_read_object(buf, json_attrs_pps, endptr);
743
744
    // This is good until GPS are more than nanosec accurate
745
37
    gpsdata->pps.real.tv_sec = (time_t)real_sec;
746
37
    gpsdata->pps.real.tv_nsec = (long)real_nsec;
747
37
    gpsdata->pps.clock.tv_sec = (time_t)clock_sec;
748
37
    gpsdata->pps.clock.tv_nsec = (long)clock_nsec;
749
    // hope qErr fits in int
750
37
    gpsdata->qErr = (long)qErr;
751
752
    // FIXME: precision is currently parsed but discarded
753
37
    return status;
754
37
}
755
756
int json_oscillator_read(const char *buf, struct gps_data_t *gpsdata,
757
                         const char **endptr)
758
9
{
759
9
    bool running = false, reference = false, disciplined = false;
760
9
    int delta = 0;
761
9
    const struct json_attr_t json_attrs_osc[] = {
762
        // *INDENT-OFF*
763
9
        {"class",       t_check,   .dflt.check = "OSC"},
764
9
        {"device",      t_string,  .addr.string = gpsdata->dev.path,
765
9
                                   .len = sizeof(gpsdata->dev.path)},
766
9
        {"running",     t_boolean, .addr.boolean = &running,
767
9
                                   .dflt.boolean = false},
768
9
        {"reference",   t_boolean, .addr.boolean = &reference,
769
9
                                   .dflt.boolean = false},
770
9
        {"disciplined", t_boolean, .addr.boolean = &disciplined,
771
9
                                   .dflt.boolean = false},
772
9
        {"delta",       t_integer, .addr.integer = &delta,
773
9
                                   .dflt.integer = 0},
774
        // ignore unknown keys, for cross-version compatibility
775
9
        {"", t_ignore},
776
9
        {NULL},
777
        // *INDENT-ON*
778
9
    };
779
9
    int status;
780
781
9
    memset(&gpsdata->osc, 0, sizeof(gpsdata->osc));
782
9
    status = json_read_object(buf, json_attrs_osc, endptr);
783
784
9
    gpsdata->osc.running = running;
785
9
    gpsdata->osc.reference = reference;
786
9
    gpsdata->osc.disciplined = disciplined;
787
9
    gpsdata->osc.delta = delta;
788
789
9
    return status;
790
9
}
791
792
/* Test for JSON read status values that should be treated as a go-ahead
793
 * for further processing.  JSON_BADATTR - to allow JSON attributes unknown
794
 * to this version of the library, for forward compatibility, is an obvious
795
 * thing to go here.
796
 * Until microjson is fixed to allow t_array as t_ignore, mask that too.
797
 */
798
3.83k
#define FILTER(n) (((n) == JSON_ERR_BADATTR ||   \
799
3.83k
                    (n) == JSON_ERR_NOARRAY) ? 0 : n)
800
1.58k
#define PASS(n) (0 == FILTER(n))
801
802
/* the only entry point - unpack a JSON object into gpsdata_t substructures
803
 *
804
 * Returns: 0 if OK
805
 *          -1 on unknown
806
 *         JSON_ERR_xx code
807
 */
808
int libgps_json_unpack(const char *buf,
809
                       struct gps_data_t *gpsdata, const char **end)
810
2.86k
{
811
2.86k
    int status;
812
2.86k
    const char *classtag = strstr(buf, "\"class\":");
813
814
2.86k
    if (NULL == classtag) {
815
396
        return -1;
816
396
    }
817
818
2.47k
    if (str_starts_with(classtag, "\"class\":\"TPV\"")) {
819
476
        status = json_tpv_read(buf, gpsdata, end);
820
476
        gpsdata->set = STATUS_SET;
821
476
        if (0 != gpsdata->fix.time.tv_sec) {
822
291
            gpsdata->set |= TIME_SET;
823
291
        }
824
476
        if (0 != isfinite(gpsdata->fix.ept)) {
825
2
            gpsdata->set |= TIMERR_SET;
826
2
        }
827
476
        if (0 != isfinite(gpsdata->fix.longitude)) {
828
1
            gpsdata->set |= LATLON_SET;
829
1
        }
830
476
        if (0 != isfinite(gpsdata->fix.altitude) ||
831
475
            0 != isfinite(gpsdata->fix.altHAE) ||
832
474
            0 != isfinite(gpsdata->fix.depth) ||
833
473
            0 != isfinite(gpsdata->fix.altMSL)) {
834
4
            gpsdata->set |= ALTITUDE_SET;
835
4
        }
836
476
        if (0 != isfinite(gpsdata->fix.epx) &&
837
3
            0 != isfinite(gpsdata->fix.epy)) {
838
1
            gpsdata->set |= HERR_SET;
839
1
        }
840
476
        if (0 != isfinite(gpsdata->fix.epv)) {
841
2
            gpsdata->set |= VERR_SET;
842
2
        }
843
476
        if (0 != isfinite(gpsdata->fix.track)) {
844
1
            gpsdata->set |= TRACK_SET;
845
1
        }
846
476
        if (0 != isfinite(gpsdata->fix.magnetic_track) ||
847
475
            0 != isfinite(gpsdata->fix.magnetic_var)) {
848
2
            gpsdata->set |= MAGNETIC_TRACK_SET;
849
2
        }
850
476
        if (0 != isfinite(gpsdata->fix.speed)) {
851
1
            gpsdata->set |= SPEED_SET;
852
1
        }
853
476
        if (0 != isfinite(gpsdata->fix.climb)) {
854
1
            gpsdata->set |= CLIMB_SET;
855
1
        }
856
476
        if (0 != isfinite(gpsdata->fix.epd)) {
857
2
            gpsdata->set |= TRACKERR_SET;
858
2
        }
859
476
        if (0 != isfinite(gpsdata->fix.eps)) {
860
1
            gpsdata->set |= SPEEDERR_SET;
861
1
        }
862
476
        if (0 != isfinite(gpsdata->fix.epc)) {
863
1
            gpsdata->set |= CLIMBERR_SET;
864
1
        }
865
476
        if (MODE_NOT_SEEN != gpsdata->fix.mode) {
866
58
            gpsdata->set |= MODE_SET;
867
58
        }
868
476
        if (0 != isfinite(gpsdata->fix.wanglem) ||
869
475
            0 != isfinite(gpsdata->fix.wangler) ||
870
474
            0 != isfinite(gpsdata->fix.wanglet) ||
871
473
            0 != isfinite(gpsdata->fix.wspeedr) ||
872
472
            0 != isfinite(gpsdata->fix.wspeedt)) {
873
5
            gpsdata->set |= NAVDATA_SET;
874
5
        }
875
476
        if (0 != isfinite(gpsdata->fix.NED.relPosN) ||
876
475
            0 != isfinite(gpsdata->fix.NED.relPosE) ||
877
474
            0 != isfinite(gpsdata->fix.NED.relPosD) ||
878
473
            0 != isfinite(gpsdata->fix.NED.relPosH) ||
879
472
            0 != isfinite(gpsdata->fix.NED.relPosL) ||
880
471
            0 != isfinite(gpsdata->fix.NED.velN) ||
881
470
            0 != isfinite(gpsdata->fix.NED.velE) ||
882
469
            0 != isfinite(gpsdata->fix.NED.velD)) {
883
8
            gpsdata->set |= NED_SET;
884
8
        }
885
476
        if ((0 != isfinite(gpsdata->fix.ecef.x)) &&
886
4
            (0 != isfinite(gpsdata->fix.ecef.y)) &&
887
3
            (0 != isfinite(gpsdata->fix.ecef.z))) {
888
            // All, or none.  Clients can just do their own isfinite()s
889
1
            gpsdata->set |= ECEF_SET;
890
1
        }
891
476
        if ((0 != isfinite(gpsdata->fix.ecef.vx)) &&
892
3
            (0 != isfinite(gpsdata->fix.ecef.vy)) &&
893
2
            (0 != isfinite(gpsdata->fix.ecef.vz))) {
894
            // All, or none.  Clients can just do their own isfinite()s
895
1
            gpsdata->set |= VECEF_SET;
896
1
        }
897
476
        return FILTER(status);
898
476
    }
899
1.99k
    if (str_starts_with(classtag, "\"class\":\"GST\"")) {
900
314
        status = json_noise_read(buf, gpsdata, end);
901
314
        if (PASS(status)) {
902
292
            gpsdata->set &= ~UNION_SET;
903
292
            gpsdata->set |= GST_SET;
904
292
        }
905
314
        return FILTER(status);
906
314
    }
907
1.68k
    if (str_starts_with(classtag, "\"class\":\"SKY\"")) {
908
168
        status = json_sky_read(buf, gpsdata, end);
909
168
        return FILTER(status);
910
168
    }
911
1.51k
    if (str_starts_with(classtag, "\"class\":\"ATT\"")) {
912
68
        status = json_att_read(buf, gpsdata, end);
913
68
        if (PASS(status)) {
914
36
            gpsdata->set |= ATTITUDE_SET;
915
36
        }
916
68
        return FILTER(status);
917
68
    }
918
1.44k
    if (str_starts_with(classtag, "\"class\":\"IMU\"")) {
919
54
        status = json_imu_read(buf, gpsdata, end);
920
54
        if (PASS(status)) {
921
28
            gpsdata->set |= IMU_SET;
922
28
        }
923
54
        return FILTER(status);
924
54
    }
925
1.39k
    if (str_starts_with(classtag, "\"class\":\"DEVICES\"")) {
926
80
        status = json_devicelist_read(buf, gpsdata, end);
927
80
        if (PASS(status)) {
928
7
            gpsdata->set &= ~UNION_SET;
929
7
            gpsdata->set |= DEVICELIST_SET;
930
7
        }
931
80
        return FILTER(status);
932
80
    }
933
1.31k
    if (str_starts_with(classtag, "\"class\":\"DEVICE\"")) {
934
17
        status = json_device_read(buf, &gpsdata->dev, end);
935
17
        if (PASS(status))
936
4
            gpsdata->set |= DEVICE_SET;
937
17
        return FILTER(status);
938
17
    }
939
1.29k
    if (str_starts_with(classtag, "\"class\":\"WATCH\"")) {
940
53
        status = json_watch_read(buf, &gpsdata->policy, end);
941
53
        if (PASS(status)) {
942
49
            gpsdata->set &= ~UNION_SET;
943
49
            gpsdata->set |= POLICY_SET;
944
49
        }
945
53
        return FILTER(status);
946
53
    }
947
1.24k
    if (str_starts_with(classtag, "\"class\":\"VERSION\"")) {
948
16
        status = json_version_read(buf, gpsdata, end);
949
16
        if (status ==  0) {
950
3
            gpsdata->set &= ~UNION_SET;
951
3
            gpsdata->set |= VERSION_SET;
952
3
        }
953
16
        return FILTER(status);
954
16
    }
955
1.22k
    if (str_starts_with(classtag, "\"class\":\"RTCM2\"")) {
956
309
        status = json_rtcm2_read(buf,
957
309
                                 gpsdata->dev.path, sizeof(gpsdata->dev.path),
958
309
                                 &gpsdata->rtcm2, end);
959
309
        if (PASS(status)) {
960
128
            gpsdata->set &= ~UNION_SET;
961
128
            gpsdata->set |= RTCM2_SET;
962
128
        }
963
309
        return FILTER(status);
964
309
    }
965
917
    if (str_starts_with(classtag, "\"class\":\"RTCM3\"")) {
966
140
        status = json_rtcm3_read(buf,
967
140
                                 gpsdata->dev.path, sizeof(gpsdata->dev.path),
968
140
                                 &gpsdata->rtcm3, end);
969
140
        if (PASS(status)) {
970
47
            gpsdata->set &= ~UNION_SET;
971
47
            gpsdata->set |= RTCM3_SET;
972
47
        }
973
140
        return FILTER(status);
974
140
    }
975
777
#ifdef AIVDM_ENABLE
976
777
    if (str_starts_with(classtag, "\"class\":\"AIS\"")) {
977
332
        status = json_ais_read(buf,
978
332
                               gpsdata->dev.path, sizeof(gpsdata->dev.path),
979
332
                               &gpsdata->ais, end);
980
332
        if (PASS(status)) {
981
198
            gpsdata->set &= ~UNION_SET;
982
198
            gpsdata->set |= AIS_SET;
983
198
        }
984
332
        return FILTER(status);
985
332
    }
986
445
#endif  // AIVDM_ENABLE
987
445
    if (str_starts_with(classtag, "\"class\":\"ERROR\"")) {
988
10
        status = json_error_read(buf, gpsdata, end);
989
10
        if (PASS(status)) {
990
3
            gpsdata->set &= ~UNION_SET;
991
3
            gpsdata->set |= ERROR_SET;
992
3
        }
993
10
        return FILTER(status);
994
10
    }
995
435
    if (str_starts_with(classtag, "\"class\":\"TOFF\"")) {
996
31
        status = json_toff_read(buf, gpsdata, end);
997
31
        if (PASS(status)) {
998
18
            gpsdata->set &= ~UNION_SET;
999
18
            gpsdata->set |= TOFF_SET;
1000
18
        }
1001
31
        return FILTER(status);
1002
31
    }
1003
404
    if (str_starts_with(classtag, "\"class\":\"PPS\"")) {
1004
37
        status = json_pps_read(buf, gpsdata, end);
1005
37
        if (PASS(status)) {
1006
23
            gpsdata->set &= ~UNION_SET;
1007
23
            gpsdata->set |= PPS_SET;
1008
23
        }
1009
37
        return FILTER(status);
1010
37
    }
1011
367
    if (str_starts_with(classtag, "\"class\":\"OSC\"")) {
1012
9
        status = json_oscillator_read(buf, gpsdata, end);
1013
9
        if (PASS(status)) {
1014
3
            gpsdata->set &= ~UNION_SET;
1015
3
            gpsdata->set |= OSCILLATOR_SET;
1016
3
        }
1017
9
        return FILTER(status);
1018
9
    }
1019
358
    if (str_starts_with(classtag, "\"class\":\"RAW\"")) {
1020
134
        status = json_raw_read(buf, gpsdata, end);
1021
134
        if (PASS(status)) {
1022
21
            gpsdata->set &= ~UNION_SET;
1023
21
            gpsdata->set |= RAW_SET;
1024
21
        }
1025
134
        return FILTER(status);
1026
134
    }
1027
    // else, unknown class type
1028
224
    return -1;
1029
358
}
1030
1031
1032
1033
// vim: set expandtab shiftwidth=4