int gps_unpack(char *buf, struct gps_data_t *gpsdata)
/* unpack a gpsd response into a status structure, buf must be writeable.
* gps_unpack() currently returns 0 in all cases, but should it ever need to
* return an error status, it must be < 0.
*/
{
libgps_debug_trace((DEBUG_CALLS, "gps_unpack(%s)\n", buf));
/* detect and process a JSON response */
if (buf[0] == '{') {
const char *jp = buf, **next = &jp;
while (next != NULL && *next != NULL && next[0][0] != '\0') {
libgps_debug_trace((DEBUG_CALLS,"gps_unpack() segment parse '%s'\n", *next));
if (libgps_json_unpack(*next, gpsdata, next) == -1)
break;
#ifdef LIBGPS_DEBUG
if (libgps_debuglevel >= 1)
libgps_dump_state(gpsdata);
#endif /* LIBGPS_DEBUG */
}
}
#ifndef USE_QT
libgps_debug_trace((DEBUG_CALLS, "final flags: (0x%04x) %s\n", gpsdata->set,gps_maskdump(gpsdata->set)));
#endif
return 0;
}
int gps_sock_stream(struct gps_data_t *gpsdata, unsigned int flags, void *d)
/* ask gpsd to stream reports at you, hiding the command details */
{
char buf[GPS_JSON_COMMAND_MAX];
if ((flags & (WATCH_JSON | WATCH_NMEA | WATCH_RAW)) == 0) {
flags |= WATCH_JSON;
}
if ((flags & WATCH_DISABLE) != 0) {
(void)strlcpy(buf, "?WATCH={\"enable\":false,", sizeof(buf));
if (flags & WATCH_JSON)
(void)strlcat(buf, "\"json\":false,", sizeof(buf));
if (flags & WATCH_NMEA)
(void)strlcat(buf, "\"nmea\":false,", sizeof(buf));
if (flags & WATCH_RAW)
(void)strlcat(buf, "\"raw\":1,", sizeof(buf));
if (flags & WATCH_RARE)
(void)strlcat(buf, "\"raw\":0,", sizeof(buf));
if (flags & WATCH_SCALED)
(void)strlcat(buf, "\"scaled\":false,", sizeof(buf));
if (flags & WATCH_TIMING)
(void)strlcat(buf, "\"timing\":false,", sizeof(buf));
if (flags & WATCH_SPLIT24)
(void)strlcat(buf, "\"split24\":false,", sizeof(buf));
if (flags & WATCH_PPS)
(void)strlcat(buf, "\"pps\":false,", sizeof(buf));
str_rstrip_char(buf, ',');
(void)strlcat(buf, "};", sizeof(buf));
libgps_debug_trace((DEBUG_CALLS, "gps_stream() disable command: %s\n", buf));
return gps_send(gpsdata, buf);
} else { /* if ((flags & WATCH_ENABLE) != 0) */
(void)strlcpy(buf, "?WATCH={\"enable\":true,", sizeof(buf));
if (flags & WATCH_JSON)
(void)strlcat(buf, "\"json\":true,", sizeof(buf));
if (flags & WATCH_NMEA)
(void)strlcat(buf, "\"nmea\":true,", sizeof(buf));
if (flags & WATCH_RARE)
(void)strlcat(buf, "\"raw\":1,", sizeof(buf));
if (flags & WATCH_RAW)
(void)strlcat(buf, "\"raw\":2,", sizeof(buf));
if (flags & WATCH_SCALED)
(void)strlcat(buf, "\"scaled\":true,", sizeof(buf));
if (flags & WATCH_TIMING)
(void)strlcat(buf, "\"timing\":true,", sizeof(buf));
if (flags & WATCH_SPLIT24)
(void)strlcat(buf, "\"split24\":true,", sizeof(buf));
if (flags & WATCH_PPS)
(void)strlcat(buf, "\"pps\":true,", sizeof(buf));
if (flags & WATCH_DEVICE)
str_appendf(buf, sizeof(buf), "\"device\":\"%s\",", (char *)d);
str_rstrip_char(buf, ',');
(void)strlcat(buf, "};", sizeof(buf));
libgps_debug_trace((DEBUG_CALLS, "gps_stream() enable command: %s\n", buf));
return gps_send(gpsdata, buf);
}
}
int gps_shm_open(/*@out@*/struct gps_data_t *gpsdata)
/* open a shared-memory connection to the daemon */
{
int shmid;
libgps_debug_trace((DEBUG_CALLS, "gps_shm_open()\n"));
gpsdata->privdata = NULL;
shmid = shmget((key_t)GPSD_KEY, sizeof(struct gps_data_t), 0);
if (shmid == -1) {
/* daemon isn't running or failed to create shared segment */
return -1;
}
gpsdata->privdata = (void *)malloc(sizeof(struct privdata_t));
if (gpsdata->privdata == NULL)
return -1;
PRIVATE(gpsdata)->shmseg = shmat(shmid, 0, 0);
if ((int)(long)gpsdata->privdata == -1) {
/* attach failed for sume unknown reason */
return -2;
}
#ifndef USE_QT
gpsdata->gps_fd = SHM_PSEUDO_FD;
#else
gpsdata->gps_fd = (void *)(intptr_t)SHM_PSEUDO_FD;
#endif /* USE_QT */
return 0;
}
bool gps_sock_waiting(const struct gps_data_t *gpsdata, int timeout)
/* is there input waiting from the GPS? */
/* timeout is in uSec */
{
#ifndef USE_QT
fd_set rfds;
struct timeval tv;
libgps_debug_trace((DEBUG_CALLS, "gps_waiting(%d): %d\n", timeout, PRIVATE(gpsdata)->waitcount++));
if (PRIVATE(gpsdata)->waiting > 0)
return true;
/* we might want to check for EINTR if this returns false */
errno = 0;
FD_ZERO(&rfds);
FD_SET(gpsdata->gps_fd, &rfds);
tv.tv_sec = timeout / 1000000;
tv.tv_usec = timeout % 1000000;
/* all error conditions return "not waiting" -- crude but effective */
return (select(gpsdata->gps_fd + 1, &rfds, NULL, NULL, &tv) == 1);
#else
return ((QTcpSocket *) (gpsdata->gps_fd))->waitForReadyRead(timeout / 1000);
#endif
}
int gps_sock_open(const char *host, const char *port,
struct gps_data_t *gpsdata)
{
if (!host)
host = "localhost";
if (!port)
port = DEFAULT_GPSD_PORT;
libgps_debug_trace((DEBUG_CALLS, "gps_sock_open(%s, %s)\n", host, port));
#ifndef USE_QT
if ((gpsdata->gps_fd =
netlib_connectsock(AF_UNSPEC, host, port, "tcp")) < 0) {
errno = gpsdata->gps_fd;
libgps_debug_trace((DEBUG_CALLS, "netlib_connectsock() returns error %d\n", errno));
return -1;
}
else
libgps_debug_trace((DEBUG_CALLS, "netlib_connectsock() returns socket on fd %d\n", gpsdata->gps_fd));
#else
QTcpSocket *sock = new QTcpSocket();
gpsdata->gps_fd = sock;
sock->connectToHost(host, QString(port).toInt());
if (!sock->waitForConnected())
qDebug() << "libgps::connect error: " << sock->errorString();
else
qDebug() << "libgps::connected!";
#endif /* USE_QT */
/* set up for line-buffered I/O over the daemon socket */
gpsdata->privdata = (void *)malloc(sizeof(struct privdata_t));
if (gpsdata->privdata == NULL)
return -1;
PRIVATE(gpsdata)->newstyle = false;
PRIVATE(gpsdata)->waiting = 0;
PRIVATE(gpsdata)->buffer[0] = 0;
#ifdef LIBGPS_DEBUG
PRIVATE(gpsdata)->waitcount = 0;
#endif /* LIBGPS_DEBUG */
return 0;
}
int gps_stream(struct gps_data_t *gpsdata, unsigned int flags,
/*@null@*/ void *d)
/* ask gpsd to stream reports at you, hiding the command details */
{
char buf[GPS_JSON_COMMAND_MAX];
if ((flags & (WATCH_JSON | WATCH_OLDSTYLE | WATCH_NMEA | WATCH_RAW)) == 0) {
flags |= WATCH_JSON;
}
if ((flags & WATCH_DISABLE) != 0) {
if ((flags & WATCH_OLDSTYLE) != 0) {
(void)strlcpy(buf, "w-", sizeof(buf));
if ((flags & WATCH_NMEA) != 0)
(void)strlcat(buf, "r-", sizeof(buf));
} else {
(void)strlcpy(buf, "?WATCH={\"enable\":false,", sizeof(buf));
if (flags & WATCH_JSON)
(void)strlcat(buf, "\"json\":false,", sizeof(buf));
if (flags & WATCH_NMEA)
(void)strlcat(buf, "\"nmea\":false,", sizeof(buf));
if (flags & WATCH_RAW)
(void)strlcat(buf, "\"raw\":1,", sizeof(buf));
if (flags & WATCH_RARE)
(void)strlcat(buf, "\"raw\":0,", sizeof(buf));
if (flags & WATCH_SCALED)
(void)strlcat(buf, "\"scaled\":false,", sizeof(buf));
if (flags & WATCH_TIMING)
(void)strlcat(buf, "\"timing\":false,", sizeof(buf));
if (buf[strlen(buf) - 1] == ',')
buf[strlen(buf) - 1] = '\0';
(void)strlcat(buf, "};", sizeof(buf));
}
libgps_debug_trace((DEBUG_CALLS, "gps_stream() disable command: %s\n", buf));
return gps_send(gpsdata, buf);
} else { /* if ((flags & WATCH_ENABLE) != 0) */
if ((flags & WATCH_OLDSTYLE) != 0) {
(void)strlcpy(buf, "w+x", sizeof(buf));
if ((flags & WATCH_NMEA) != 0)
(void)strlcat(buf, "r+", sizeof(buf));
} else {
(void)strlcpy(buf, "?WATCH={\"enable\":true,", sizeof(buf));
if (flags & WATCH_JSON)
(void)strlcat(buf, "\"json\":true,", sizeof(buf));
if (flags & WATCH_NMEA)
(void)strlcat(buf, "\"nmea\":true,", sizeof(buf));
if (flags & WATCH_RARE)
(void)strlcat(buf, "\"raw\":1,", sizeof(buf));
if (flags & WATCH_RAW)
(void)strlcat(buf, "\"raw\":2,", sizeof(buf));
if (flags & WATCH_SCALED)
(void)strlcat(buf, "\"scaled\":true,", sizeof(buf));
if (flags & WATCH_TIMING)
(void)strlcat(buf, "\"timing\":true,", sizeof(buf));
/*@-nullpass@*//* shouldn't be needed, splint has a bug */
if (flags & WATCH_DEVICE)
(void)snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
"\"device\":\"%s\",", (char *)d);
/*@+nullpass@*/
if (buf[strlen(buf) - 1] == ',')
buf[strlen(buf) - 1] = '\0';
(void)strlcat(buf, "};", sizeof(buf));
}
libgps_debug_trace((DEBUG_CALLS, "gps_stream() enable command: %s\n", buf));
return gps_send(gpsdata, buf);
}
}
/*@ -branchstate -usereleased -mustfreefresh -nullstate -usedef @*/
int gps_unpack(char *buf, struct gps_data_t *gpsdata)
/* unpack a gpsd response into a status structure, buf must be writeable.
* gps_unpack() currently returns 0 in all cases, but should it ever need to
* return an error status, it must be < 0.
*/
{
libgps_debug_trace((DEBUG_CALLS, "gps_unpack(%s)\n", buf));
/* detect and process a JSON response */
if (buf[0] == '{') {
const char *jp = buf, **next = &jp;
while (next != NULL && *next != NULL && next[0][0] != '\0') {
libgps_debug_trace((DEBUG_CALLS,"gps_unpack() segment parse '%s'\n", *next));
if (libgps_json_unpack(*next, gpsdata, next) == -1)
break;
#ifdef LIBGPS_DEBUG
if (libgps_debuglevel >= 1)
libgps_dump_state(gpsdata);
#endif /* LIBGPS_DEBUG */
}
#ifdef OLDSTYLE_ENABLE
if (PRIVATE(gpsdata) != NULL)
PRIVATE(gpsdata)->newstyle = true;
#endif /* OLDSTYLE_ENABLE */
}
#ifdef OLDSTYLE_ENABLE
else {
/*
* Get the decimal separator for the current application locale.
* This looks thread-unsafe, but it's not. The key is that
* character assignment is atomic.
*/
char *ns, *sp, *tp;
static char decimal_point = '\0';
if (decimal_point == '\0') {
struct lconv *locale_data = localeconv();
if (locale_data != NULL && locale_data->decimal_point[0] != '.')
decimal_point = locale_data->decimal_point[0];
}
for (ns = buf; ns; ns = strstr(ns + 1, "GPSD")) {
if ( /*@i1@*/ strncmp(ns, "GPSD", 4) == 0) {
bool eol = false;
/* the following should execute each time we have a good next sp */
for (sp = ns + 5; *sp != '\0'; sp = tp + 1) {
tp = sp + strcspn(sp, ",\r\n");
eol = *tp == '\r' || *tp == '\n';
if (*tp == '\0')
tp--;
else
*tp = '\0';
/*
* The daemon always emits the Anglo-American and SI
* decimal point. Hack these into whatever the
* application locale requires if it's not the same.
* This has to happen *after* we grab the next
* comma-delimited response, or we'll lose horribly
* in locales where the decimal separator is comma.
*/
if (decimal_point != '\0') {
char *cp;
for (cp = sp; cp < tp; cp++)
if (*cp == '.')
*cp = decimal_point;
}
/* note, there's a bit of skip logic after the switch */
switch (*sp) {
case 'F': /*@ -mustfreeonly */
if (sp[2] == '?')
gpsdata->dev.path[0] = '\0';
else {
/*@ -mayaliasunique @*/
(void)strlcpy(gpsdata->dev.path, sp + 2,
sizeof(gpsdata->dev.path));
/*@ +mayaliasunique @*/
gpsdata->set |= DEVICE_SET;
}
/*@ +mustfreeonly */
break;
case 'I':
/*@ -mustfreeonly */
if (sp[2] == '?')
gpsdata->dev.subtype[0] = '\0';
else {
(void)strlcpy(gpsdata->dev.subtype, sp + 2,
sizeof(gpsdata->dev.subtype));
gpsdata->set |= DEVICEID_SET;
}
/*@ +mustfreeonly */
break;
case 'O':
if (sp[2] == '?') {
gpsdata->set = MODE_SET | STATUS_SET;
gpsdata->status = STATUS_NO_FIX;
gps_clear_fix(&gpsdata->fix);
} else {
struct gps_fix_t nf;
char tag[MAXTAGLEN + 1], alt[20];
char eph[20], epv[20], track[20], speed[20],
climb[20];
char epd[20], eps[20], epc[20], mode[2];
char timestr[20], ept[20], lat[20], lon[20];
int st = sscanf(sp + 2,
"%8s %19s %19s %19s %19s %19s %19s %19s %19s %19s %19s %19s %19s %19s %1s",
tag, timestr, ept, lat, lon,
alt, eph, epv, track, speed,
climb,
epd, eps, epc, mode);
if (st >= 14) {
#define DEFAULT(val) (val[0] == '?') ? NAN : atof(val)
/*@ +floatdouble @*/
nf.time = DEFAULT(timestr);
nf.latitude = DEFAULT(lat);
nf.longitude = DEFAULT(lon);
nf.ept = DEFAULT(ept);
nf.altitude = DEFAULT(alt);
/* designed before we split eph into epx+epy */
nf.epx = nf.epy = DEFAULT(eph) / sqrt(2);
nf.epv = DEFAULT(epv);
nf.track = DEFAULT(track);
nf.speed = DEFAULT(speed);
nf.climb = DEFAULT(climb);
nf.epd = DEFAULT(epd);
nf.eps = DEFAULT(eps);
nf.epc = DEFAULT(epc);
/*@ -floatdouble @*/
#undef DEFAULT
if (st >= 15)
nf.mode =
(mode[0] ==
'?') ? MODE_NOT_SEEN : atoi(mode);
else
nf.mode =
(alt[0] == '?') ? MODE_2D : MODE_3D;
if (alt[0] != '?')
gpsdata->set |= ALTITUDE_SET | CLIMB_SET;
if (isnan(nf.epx) == 0 && isnan(nf.epy) == 0)
gpsdata->set |= HERR_SET;
if (isnan(nf.epv) == 0)
gpsdata->set |= VERR_SET;
if (isnan(nf.track) == 0)
gpsdata->set |= TRACK_SET | SPEED_SET;
if (isnan(nf.eps) == 0)
gpsdata->set |= SPEEDERR_SET;
if (isnan(nf.epc) == 0)
gpsdata->set |= CLIMBERR_SET;
gpsdata->fix = nf;
(void)strlcpy(gpsdata->tag, tag,
MAXTAGLEN + 1);
gpsdata->set |=
TIME_SET | TIMERR_SET | LATLON_SET |
MODE_SET;
gpsdata->status = STATUS_FIX;
gpsdata->set |= STATUS_SET;
}
}
break;
case 'X':
if (sp[2] == '?')
gpsdata->online = (timestamp_t)-1;
else {
(void)sscanf(sp, "X=%lf", &gpsdata->online);
gpsdata->set |= ONLINE_SET;
}
break;
case 'Y':
if (sp[2] == '?') {
gpsdata->satellites_visible = 0;
} else {
int j, i1, i2, i3, i5;
int PRN[MAXCHANNELS];
int elevation[MAXCHANNELS], azimuth[MAXCHANNELS];
int used[MAXCHANNELS];
double ss[MAXCHANNELS], f4;
char tag[MAXTAGLEN + 1], timestamp[21];
(void)sscanf(sp, "Y=%8s %20s %d ",
tag, timestamp,
&gpsdata->satellites_visible);
(void)strlcpy(gpsdata->tag, tag, MAXTAGLEN);
if (timestamp[0] != '?') {
gpsdata->set |= TIME_SET;
}
for (j = 0; j < gpsdata->satellites_visible; j++) {
PRN[j] = elevation[j] = azimuth[j] = used[j] =
0;
ss[j] = 0.0;
}
for (j = 0, gpsdata->satellites_used = 0;
j < gpsdata->satellites_visible; j++) {
if ((sp != NULL)
&& ((sp = strchr(sp, ':')) != NULL)) {
sp++;
(void)sscanf(sp, "%d %d %d %lf %d", &i1,
&i2, &i3, &f4, &i5);
PRN[j] = i1;
elevation[j] = i2;
azimuth[j] = i3;
ss[j] = f4;
used[j] = i5;
if (i5 == 1)
gpsdata->satellites_used++;
}
}
/*@ -compdef @*/
memcpy(gpsdata->PRN, PRN, sizeof(PRN));
memcpy(gpsdata->elevation, elevation,
sizeof(elevation));
memcpy(gpsdata->azimuth, azimuth,
sizeof(azimuth));
memcpy(gpsdata->ss, ss, sizeof(ss));
memcpy(gpsdata->used, used, sizeof(used));
/*@ +compdef @*/
}
gpsdata->set |= SATELLITE_SET;
break;
}
#ifdef LIBGPS_DEBUG
if (libgps_debuglevel >= 1)
libgps_dump_state(gpsdata);
#endif /* LIBGPS_DEBUG */
/*
* Skip to next GPSD when we see \r or \n;
* we don't want to try interpreting stuff
* in between that might be raw mode data.
*/
if (eol)
break;
}
}
}
}
#endif /* OLDSTYLE_ENABLE */
#ifndef USE_QT
libgps_debug_trace((DEBUG_CALLS, "final flags: (0x%04x) %s\n", gpsdata->set,gps_maskdump(gpsdata->set)));
#endif
return 0;
}
