static bool garmin_bin_initialize(void)
{
unsigned int i;
#ifndef CONTROLSEND_ENABLE
if(serial) {
monitor_complain("Direct mode doesn't supported.");
return false;
}
#endif
miscwin = subwin(devicewin, 1, 80, 1, 0);
mid51win = subwin(devicewin, 12, 18, 2, 0);
mid114win = subwin(devicewin, GARMIN_CHANNELS + 3, 23, 2, 18);
if (miscwin == NULL || mid51win == NULL || mid114win == NULL)
return false;
(void)syncok(miscwin, true);
(void)syncok(mid51win, true);
(void)syncok(mid114win, true);
(void)wattrset(miscwin, A_BOLD);
display(miscwin, 0, 0, "Time:");
(void)wattrset(miscwin, A_NORMAL);
(void)wborder(mid51win, 0, 0, 0, 0, 0, 0, 0, 0),
(void)wattrset(mid51win, A_BOLD);
display(mid51win, 0, 4, " Position ");
display(mid51win, 1, 2, "Fix:");
display(mid51win, 2, 2, "Lat:");
(void)mvwaddch(mid51win, 2, 16, ACS_DEGREE);
display(mid51win, 3, 2, "Lon:");
(void)mvwaddch(mid51win, 3, 16, ACS_DEGREE);
display(mid51win, 4, 2, "Alt: m");
display(mid51win, 5, 2, "Speed: m/s");
display(mid51win, 6, 2, "Climb: m/s");
display(mid51win, 7, 2, "Leap: sec");
display(mid51win, 8, 2, "epe: m");
display(mid51win, 9, 2, "eph: m");
display(mid51win, 10, 2, "epv: m");
display(mid51win, 11, 3, " ID 51 (0x33) ");
(void)wattrset(mid51win, A_NORMAL);
(void)wborder(mid114win, 0, 0, 0, 0, 0, 0, 0, 0),
(void)wattrset(mid114win, A_BOLD);
display(mid114win, 1, 1, "Ch PRN Az El SNR ST");
for (i = 0; i < GARMIN_CHANNELS; i++) {
display(mid114win, (int)i + 2, 1, "%2d", i);
}
display(mid114win, 0, 5, " Satellite ");
display(mid114win, 14, 4, " ID 114 (0x72) ");
(void)wattrset(mid114win, A_NORMAL);
/* initialize the GPS context's time fields */
gpsd_time_init(session.context, time(NULL));
return true;
}
static bool sirf_initialize(void)
{
unsigned int i;
mid2win = subwin(devicewin, 6, 80, 1, 0);
mid4win = subwin(devicewin, SIRF_CHANNELS + 3, 30, 7, 0);
mid6win = subwin(devicewin, 3, 50, 7, 30);
mid7win = subwin(devicewin, 4, 50, 13, 30);
mid9win = subwin(devicewin, 3, 50, 10, 30);
mid13win = subwin(devicewin, 3, 50, 17, 30);
mid19win = newwin(16, 50, 7, 30);
mid27win = subwin(devicewin, 3, 50, 20, 30);
if (mid2win == NULL || mid4win == NULL || mid6win == NULL
|| mid9win == NULL || mid13win == NULL || mid19win == NULL
|| mid27win == NULL)
return false;
(void)syncok(mid2win, true);
(void)syncok(mid4win, true);
(void)syncok(mid6win, true);
(void)syncok(mid7win, true);
(void)syncok(mid9win, true);
(void)syncok(mid13win, true);
(void)syncok(mid27win, true);
(void)wborder(mid2win, 0, 0, 0, 0, 0, 0, 0, 0),
(void)wattrset(mid2win, A_BOLD);
(void)wmove(mid2win, 0, 1);
display(mid2win, 0, 12, " X ");
display(mid2win, 0, 21, " Y ");
display(mid2win, 0, 30, " Z ");
display(mid2win, 0, 43, " North ");
display(mid2win, 0, 54, " East ");
display(mid2win, 0, 65, " Alt ");
(void)wmove(mid2win, 1, 1);
(void)wprintw(mid2win,
"Pos: m m");
(void)wmove(mid2win, 2, 1);
(void)wprintw(mid2win,
"Vel: m/s climb m/s");
(void)wmove(mid2win, 3, 1);
(void)wprintw(mid2win,
"Time: Leap: Heading: speed m/s");
(void)wmove(mid2win, 4, 1);
(void)wprintw(mid2win,
"Fix: HDOP: M1: M2: ");
display(mid2win, 5, 24, " Packet type 2 (0x02) ");
(void)wattrset(mid2win, A_NORMAL);
(void)wborder(mid4win, 0, 0, 0, 0, 0, 0, 0, 0),
(void)wattrset(mid4win, A_BOLD);
display(mid4win, 1, 1, "Ch PRN Az El Stat C/N ? SF");
for (i = 0; i < SIRF_CHANNELS; i++) {
display(mid4win, (int)(i + 2), 1, "%2d", i);
}
display(mid4win, 0, 1, " Measured Tracker ");
display(mid4win, 14, 4, " Packet Type 4 (0x04) ");
(void)wattrset(mid4win, A_NORMAL);
(void)wborder(mid19win, 0, 0, 0, 0, 0, 0, 0, 0),
(void)wattrset(mid19win, A_BOLD);
display(mid19win, 1, 1, "Alt. hold mode:");
display(mid19win, 2, 1, "Alt. hold source:");
display(mid19win, 3, 1, "Alt. source input:");
display(mid19win, 4, 1, "Degraded timeout:");
display(mid19win, 5, 1, "DR timeout:");
display(mid19win, 6, 1, "Track smooth mode:");
display(mid19win, 7, 1, "Static Navigation:");
display(mid19win, 8, 1, "3SV Least Squares:");
display(mid19win, 9, 1, "DOP Mask mode:");
display(mid19win, 10, 1, "Nav. Elev. mask:");
display(mid19win, 11, 1, "Nav. Power mask:");
display(mid19win, 12, 1, "DGPS Source:");
display(mid19win, 13, 1, "DGPS Mode:");
display(mid19win, 14, 1, "DGPS Timeout:");
display(mid19win, 1, 26, "LP Push-to-Fix:");
display(mid19win, 2, 26, "LP On Time:");
display(mid19win, 3, 26, "LP Interval:");
display(mid19win, 4, 26, "U. Tasks Enab.:");
display(mid19win, 5, 26, "U. Task Inter.:");
display(mid19win, 6, 26, "LP Pwr Cyc En:");
display(mid19win, 7, 26, "LP Max Acq Srch:");
display(mid19win, 8, 26, "LP Max Off Time:");
display(mid19win, 9, 26, "APM enabled:");
display(mid19win, 10, 26, "# of Fixes:");
display(mid19win, 11, 26, "Time btw Fixes:");
display(mid19win, 12, 26, "H/V Error Max:");
display(mid19win, 13, 26, "Rsp Time Max:");
display(mid19win, 14, 26, "Time/Accu:");
display(mid19win, 15, 8, " Packet type 19 (0x13) ");
(void)wattrset(mid19win, A_NORMAL);
(void)wborder(mid6win, 0, 0, 0, 0, 0, 0, 0, 0),
(void)wattrset(mid6win, A_BOLD);
display(mid6win, 0, 1, " Firmware Version ");
display(mid6win, 2, 8, " Packet Type 6 (0x06) ");
(void)wattrset(mid6win, A_NORMAL);
(void)wborder(mid7win, 0, 0, 0, 0, 0, 0, 0, 0),
(void)wattrset(mid7win, A_BOLD);
display(mid7win, 0, 1, " Clock Status ");
display(mid7win, 1, 1, "SVs: ");
display(mid7win, 1, 9, "Drift: ");
display(mid7win, 1, 23, "Bias: ");
display(mid7win, 2, 1, "GPS Time: ");
display(mid7win, 2, 23, "PPS: ");
(void)syncok(mid7win, true);
#ifndef PPS_ENABLE
(void)mvwaddstr(mid7win, 2, 40, "N/A");
#endif /* PPS_ENABLE */
display(mid7win, 3, 8, " Packet type 7 (0x07) ");
(void)wattrset(mid7win, A_NORMAL);
(void)wborder(mid9win, 0, 0, 0, 0, 0, 0, 0, 0),
(void)wattrset(mid9win, A_BOLD);
display(mid9win, 0, 1, " CPU Throughput ");
display(mid9win, 1, 1, "Max: ");
display(mid9win, 1, 13, "Lat: ");
display(mid9win, 1, 25, "Time: ");
display(mid9win, 1, 39, "MS: ");
display(mid9win, 2, 8, " Packet type 9 (0x09) ");
(void)wattrset(mid9win, A_NORMAL);
(void)wborder(mid13win, 0, 0, 0, 0, 0, 0, 0, 0),
(void)wattrset(mid13win, A_BOLD);
display(mid13win, 0, 1, " Visible List ");
display(mid13win, 2, 8, " Packet type 13 (0x0D) ");
(void)wattrset(mid13win, A_NORMAL);
(void)wborder(mid27win, 0, 0, 0, 0, 0, 0, 0, 0),
(void)wattrset(mid27win, A_BOLD);
display(mid27win, 0, 1, " DGPS Status ");
display(mid27win, 2, 8, " Packet type 27 (0x1B) ");
(void)wattrset(mid27win, A_NORMAL);
#ifdef CONTROLSEND_ENABLE
/* probe for version */
(void)monitor_control_send((unsigned char *)"\x84\x00", 2);
#endif /* CONTROLSEND_ENABLE */
/* initialize the GPS context's time fields */
gpsd_time_init(session.context, time(NULL));
return true;
}
static bool gps_query(/*@out@*/struct gps_data_t *gpsdata,
gps_mask_t expect,
const int timeout,
const char *fmt, ... )
/* ship a command and wait on an expected response type */
{
static fd_set rfds;
char buf[BUFSIZ];
va_list ap;
time_t starttime;
#ifdef COMPAT_SELECT
struct timeval tv;
#else
struct timespec tv;
sigset_t oldset, blockset;
(void)sigemptyset(&blockset);
(void)sigaddset(&blockset, SIGHUP);
(void)sigaddset(&blockset, SIGINT);
(void)sigaddset(&blockset, SIGTERM);
(void)sigaddset(&blockset, SIGQUIT);
(void)sigprocmask(SIG_BLOCK, &blockset, &oldset);
#endif /* COMPAT_SELECT */
va_start(ap, fmt);
(void)vsnprintf(buf, sizeof(buf)-2, fmt, ap);
va_end(ap);
if (buf[strlen(buf)-1] != '\n')
(void)strlcat(buf, "\n", BUFSIZ);
/*@-usedef@*/
if (write(gpsdata->gps_fd, buf, strlen(buf)) <= 0) {
gpsd_report(&context.errout, LOG_ERROR, "gps_query(), write failed\n");
return false;
}
/*@+usedef@*/
gpsd_report(&context.errout, LOG_PROG, "gps_query(), wrote, %s\n", buf);
FD_ZERO(&rfds);
starttime = time(NULL);
for (;;) {
FD_CLR(gpsdata->gps_fd, &rfds);
gpsd_report(&context.errout, LOG_PROG, "waiting...\n");
/*@ -usedef -type -nullpass -compdef @*/
tv.tv_sec = 2;
#ifdef COMPAT_SELECT
tv.tv_usec = 0;
if (select(gpsdata->gps_fd + 1, &rfds, NULL, NULL, &tv) == -1) {
#else
tv.tv_nsec = 0;
if (pselect(gpsdata->gps_fd + 1, &rfds, NULL, NULL, &tv, &oldset) == -1) {
#endif
if (errno == EINTR || !FD_ISSET(gpsdata->gps_fd, &rfds))
continue;
gpsd_report(&context.errout, LOG_ERROR, "select %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
/*@ +usedef +type +nullpass +compdef @*/
gpsd_report(&context.errout, LOG_PROG, "reading...\n");
(void)gps_read(gpsdata);
if (ERROR_SET & gpsdata->set) {
gpsd_report(&context.errout, LOG_ERROR, "error '%s'\n", gpsdata->error);
return false;
}
/*@ +ignorequals @*/
if ((expect == NON_ERROR) || (expect & gpsdata->set) != 0)
return true;
else if (timeout > 0 && (time(NULL) - starttime > timeout)) {
gpsd_report(&context.errout, LOG_ERROR,
"timed out after %d seconds\n",
timeout);
return false;
}
/*@ -ignorequals @*/
}
return false;
}
static void onsig(int sig)
{
if (sig == SIGALRM) {
gpsd_report(&context.errout, LOG_ERROR, "packet recognition timed out.\n");
exit(EXIT_FAILURE);
} else {
gpsd_report(&context.errout, LOG_ERROR, "killed by signal %d\n", sig);
exit(EXIT_SUCCESS);
}
}
static char /*@observer@*/ *gpsd_id( /*@in@ */ struct gps_device_t *session)
/* full ID of the device for reports, including subtype */
{
static char buf[128];
if ((session == NULL) || (session->device_type == NULL) ||
(session->device_type->type_name == NULL))
return "unknown,";
(void)strlcpy(buf, session->device_type->type_name, sizeof(buf));
if (session->subtype[0] != '\0') {
(void)strlcat(buf, " ", sizeof(buf));
(void)strlcat(buf, session->subtype, sizeof(buf));
}
return (buf);
}
static void ctlhook(struct gps_device_t *device UNUSED, gps_mask_t changed UNUSED)
/* recognize when we've achieved sync */
{
static int packet_counter = 0;
/*
* If it's NMEA, go back around enough times for the type probes to
* reveal any secret identity (like SiRF or UBX) the chip might have.
* If it's not, getting more packets might fetch subtype information.
*/
if (packet_counter++ >= REDIRECT_SNIFF)
{
hunting = false;
(void) alarm(0);
}
}
int main(int argc, char **argv)
{
int option, status;
char *device = NULL, *devtype = NULL;
char *speed = NULL, *control = NULL, *rate = NULL;
bool to_binary = false, to_nmea = false, reset = false;
bool lowlevel=false, echo=false;
struct gps_data_t gpsdata;
const struct gps_type_t *forcetype = NULL;
const struct gps_type_t **dp;
#ifdef CONTROLSEND_ENABLE
char cooked[BUFSIZ];
ssize_t cooklen = 0;
#endif /* RECONFIGURE_ENABLE */
context.errout.label = "gpsctl";
#define USAGE "usage: gpsctl [-l] [-b | -n | -r] [-D n] [-s speed] [-c rate] [-T timeout] [-V] [-t devtype] [-x control] [-e] <device>\n"
while ((option = getopt(argc, argv, "bec:fhlnrs:t:x:D:T:V")) != -1) {
switch (option) {
case 'b': /* switch to vendor binary mode */
to_binary = true;
break;
case 'c':
#ifdef RECONFIGURE_ENABLE
rate = optarg;
#else
gpsd_report(&context.errout, LOG_ERROR,
"cycle-change capability has been conditioned out.\n");
#endif /* RECONFIGURE_ENABLE */
break;
case 'x': /* ship specified control string */
#ifdef CONTROLSEND_ENABLE
control = optarg;
lowlevel = true;
if ((cooklen = hex_escapes(cooked, control)) <= 0) {
gpsd_report(&context.errout, LOG_ERROR,
"invalid escape string (error %d)\n", (int)cooklen);
exit(EXIT_FAILURE);
}
#else
gpsd_report(&context.errout, LOG_ERROR,
"control_send capability has been conditioned out.\n");
#endif /* CONTROLSEND_ENABLE */
break;
case 'e': /* echo specified control string with wrapper */
lowlevel = true;
echo = true;
break;
case 'f': /* force direct access to the device */
lowlevel = true;
break;
case 'l': /* list known device types */
for (dp = gpsd_drivers; *dp; dp++) {
#ifdef RECONFIGURE_ENABLE
if ((*dp)->mode_switcher != NULL)
(void)fputs("-[bn]\t", stdout);
else
(void)fputc('\t', stdout);
if ((*dp)->speed_switcher != NULL)
(void)fputs("-s\t", stdout);
else
(void)fputc('\t', stdout);
if ((*dp)->rate_switcher != NULL)
(void)fputs("-c\t", stdout);
else
(void)fputc('\t', stdout);
#endif /* RECONFIGURE_ENABLE */
#ifdef CONTROLSEND_ENABLE
if ((*dp)->control_send != NULL)
(void)fputs("-x\t", stdout);
else
(void)fputc('\t', stdout);
#endif /* CONTROLSEND_ENABLE */
(void)puts((*dp)->type_name);
}
exit(EXIT_SUCCESS);
case 'n': /* switch to NMEA mode */
#ifdef RECONFIGURE_ENABLE
to_nmea = true;
#else
gpsd_report(&context.errout, LOG_ERROR,
"speed-change capability has been conditioned out.\n");
#endif /* RECONFIGURE_ENABLE */
break;
case 'r': /* force-switch to default mode */
#ifdef RECONFIGURE_ENABLE
reset = true;
lowlevel = false; /* so we'll abort if the daemon is running */
#else
gpsd_report(&context.errout, LOG_ERROR,
"reset capability has been conditioned out.\n");
#endif /* RECONFIGURE_ENABLE */
break;
case 's': /* change output baud rate */
#ifdef RECONFIGURE_ENABLE
speed = optarg;
#else
gpsd_report(&context.errout, LOG_ERROR,
"speed-change capability has been conditioned out.\n");
#endif /* RECONFIGURE_ENABLE */
break;
case 't': /* force the device type */
devtype = optarg;
break;
case 'T': /* set the timeout on packet recognition */
timeout = (unsigned)atoi(optarg);
explicit_timeout = true;
break;
case 'D': /* set debugging level */
debuglevel = atoi(optarg);
#ifdef CLIENTDEBUG_ENABLE
gps_enable_debug(debuglevel, stderr);
#endif /* CLIENTDEBUG_ENABLE */
break;
case 'V':
(void)fprintf(stderr, "version %s (revision %s)\n",
VERSION, REVISION);
exit(EXIT_SUCCESS);
case 'h':
default:
fprintf(stderr, USAGE);
break;
}
}
if (optind < argc)
device = argv[optind];
if (devtype != NULL) {
int matchcount = 0;
for (dp = gpsd_drivers; *dp; dp++) {
if (strstr((*dp)->type_name, devtype) != NULL) {
forcetype = *dp;
matchcount++;
}
}
if (matchcount == 0)
gpsd_report(&context.errout, LOG_ERROR,
"no driver type name matches '%s'.\n", devtype);
else if (matchcount == 1) {
assert(forcetype != NULL);
gpsd_report(&context.errout, LOG_PROG,
"%s driver selected.\n", forcetype->type_name);
} else {
forcetype = NULL;
gpsd_report(&context.errout, LOG_ERROR,
"%d driver type names match '%s'.\n",
matchcount, devtype);
}
}
if (((int)to_nmea + (int)to_binary + (int)reset) > 1) {
gpsd_report(&context.errout, LOG_ERROR, "make up your mind, would you?\n");
exit(EXIT_SUCCESS);
}
(void) signal(SIGINT, onsig);
(void) signal(SIGTERM, onsig);
(void) signal(SIGQUIT, onsig);
/*@-nullpass@*/ /* someday, add null annotation to the gpsopen() params */
if (!lowlevel) {
/* Try to open the stream to gpsd. */
if (gps_open(NULL, NULL, &gpsdata) != 0) {
gpsd_report(&context.errout, LOG_ERROR,
"no gpsd running or network error: %s.\n",
gps_errstr(errno));
lowlevel = true;
}
}
/*@-nullpass@*/
if (!lowlevel) {
int i, devcount;
if (!explicit_timeout)
timeout = HIGH_LEVEL_TIMEOUT;
/* what devices have we available? */
if (!gps_query(&gpsdata, DEVICELIST_SET, (int)timeout, "?DEVICES;\n")) {
gpsd_report(&context.errout, LOG_ERROR, "no DEVICES response received.\n");
(void)gps_close(&gpsdata);
exit(EXIT_FAILURE);
}
if (gpsdata.devices.ndevices == 0) {
gpsd_report(&context.errout, LOG_ERROR, "no devices connected.\n");
(void)gps_close(&gpsdata);
exit(EXIT_FAILURE);
} else if (gpsdata.devices.ndevices > 1 && device == NULL) {
gpsd_report(&context.errout, LOG_ERROR,
"multiple devices and no device specified.\n");
(void)gps_close(&gpsdata);
exit(EXIT_FAILURE);
}
gpsd_report(&context.errout, LOG_PROG,
"%d device(s) found.\n",gpsdata.devices.ndevices);
/* try to mine the devicelist return for the data we want */
if (gpsdata.devices.ndevices == 1 && device == NULL) {
device = gpsdata.dev.path;
i = 0;
} else {
assert(device != NULL);
for (i = 0; i < gpsdata.devices.ndevices; i++)
if (strcmp(device, gpsdata.devices.list[i].path) == 0) {
goto devicelist_entry_matches;
}
gpsd_report(&context.errout, LOG_ERROR,
"specified device not found in device list.\n");
(void)gps_close(&gpsdata);
exit(EXIT_FAILURE);
devicelist_entry_matches:;
}
(void)memcpy(&gpsdata.dev,
&gpsdata.devices.list[i],
sizeof(struct devconfig_t));
devcount = gpsdata.devices.ndevices;
/* if the device has not identified, watch it until it does so */
if (gpsdata.dev.driver[0] == '\0') {
if (gps_stream(&gpsdata, WATCH_ENABLE|WATCH_JSON, NULL) == -1) {
gpsd_report(&context.errout, LOG_ERROR, "stream set failed.\n");
(void)gps_close(&gpsdata);
exit(EXIT_FAILURE);
}
while (devcount > 0) {
errno = 0;
if (gps_read(&gpsdata) == -1) {
gpsd_report(&context.errout, LOG_ERROR, "data read failed.\n");
(void)gps_close(&gpsdata);
exit(EXIT_FAILURE);
}
if (gpsdata.set & DEVICE_SET) {
--devcount;
assert(gpsdata.dev.path[0]!='\0' && gpsdata.dev.driver[0]!='\0');
if (strcmp(gpsdata.dev.path, device) == 0) {
goto matching_device_seen;
}
}
}
gpsd_report(&context.errout, LOG_ERROR, "data read failed.\n");
(void)gps_close(&gpsdata);
exit(EXIT_FAILURE);
matching_device_seen:;
}
/* sanity check */
if (gpsdata.dev.driver[0] == '\0') {
gpsd_report(&context.errout, LOG_SHOUT, "%s can't be identified.\n",
gpsdata.dev.path);
(void)gps_close(&gpsdata);
exit(EXIT_SUCCESS);
}
/* if no control operation was specified, just ID the device */
if (speed==NULL && rate == NULL && !to_nmea && !to_binary && !reset) {
(void)printf("%s identified as a %s",
gpsdata.dev.path, gpsdata.dev.driver);
if (gpsdata.dev.subtype[0] != '\0') {
(void)fputc(' ', stdout);
(void)fputs(gpsdata.dev.subtype, stdout);
}
if (gpsdata.dev.baudrate > 0)
(void)printf(" at %u baud", gpsdata.dev.baudrate);
(void)fputc('.', stdout);
(void)fputc('\n', stdout);
}
status = 0;
#ifdef RECONFIGURE_ENABLE
if (reset)
{
gpsd_report(&context.errout, LOG_PROG,
"cannot reset with gpsd running.\n");
exit(EXIT_SUCCESS);
}
/*@-boolops@*/
/*
* We used to wait on DEVICE_SET here. That doesn't work
* anymore because when the demon generates its response it
* sets the mode bit in the response from the current packet
* type, which may not have changed (probably will not have
* changed) even though the command to switch modes has been
* sent and will shortly take effect.
*/
if (to_nmea) {
if (!gps_query(&gpsdata, NON_ERROR, (int)timeout,
"?DEVICE={\"path\":\"%s\",\"native\":0}\r\n",
device)) {
gpsd_report(&context.errout, LOG_ERROR,
"%s mode change to NMEA failed\n",
gpsdata.dev.path);
status = 1;
} else
gpsd_report(&context.errout, LOG_PROG,
"%s mode change succeeded\n", gpsdata.dev.path);
}
else if (to_binary) {
if (!gps_query(&gpsdata, NON_ERROR, (int)timeout,
"?DEVICE={\"path\":\"%s\",\"native\":1}\r\n",
device)) {
gpsd_report(&context.errout, LOG_ERROR,
"%s mode change to native mode failed\n",
gpsdata.dev.path);
status = 1;
} else
gpsd_report(&context.errout, LOG_PROG,
"%s mode change succeeded\n",
gpsdata.dev.path);
}
/*@+boolops@*/
if (speed != NULL) {
char parity = 'N';
char stopbits = '1';
if (strchr(speed, ':') == NULL)
(void)gps_query(&gpsdata,
DEVICE_SET, (int)timeout,
"?DEVICE={\"path\":\"%s\",\"bps\":%s}\r\n",
device, speed);
else {
char *modespec = strchr(speed, ':');
/*@ +charint @*/
status = 0;
if (modespec!=NULL) {
*modespec = '\0';
if (strchr("78", *++modespec) == NULL) {
gpsd_report(&context.errout, LOG_ERROR,
"No support for that word length.\n");
status = 1;
}
parity = *++modespec;
if (strchr("NOE", parity) == NULL) {
gpsd_report(&context.errout, LOG_ERROR,
"What parity is '%c'?\n", parity);
status = 1;
}
stopbits = *++modespec;
if (strchr("12", stopbits) == NULL) {
gpsd_report(&context.errout, LOG_ERROR,
"Stop bits must be 1 or 2.\n");
status = 1;
}
}
if (status == 0)
(void)gps_query(&gpsdata,
DEVICE_SET, (int)timeout,
"?DEVICE={\"path\":\"%s\",\"bps\":%s,\"parity\":\"%c\",\"stopbits\":%c}\r\n",
device, speed, parity, stopbits);
}
if (atoi(speed) != (int)gpsdata.dev.baudrate) {
gpsd_report(&context.errout, LOG_ERROR,
"%s driver won't support %s%c%c\n",
gpsdata.dev.path,
speed, parity, stopbits);
status = 1;
} else
gpsd_report(&context.errout, LOG_PROG,
"%s change to %s%c%c succeeded\n",
gpsdata.dev.path,
speed, parity, stopbits);
}
if (rate != NULL) {
(void)gps_query(&gpsdata,
DEVICE_SET, (int)timeout,
"?DEVICE={\"path\":\"%s\",\"cycle\":%s}\n",
device, rate);
}
#endif /* RECONFIGURE_ENABLE */
(void)gps_close(&gpsdata);
exit(status);
#ifdef RECONFIGURE_ENABLE
} else if (reset) {
/* hard reset will go through lower-level operations */
const int speeds[] = {2400, 4800, 9600, 19200, 38400, 57600, 115200};
static struct gps_device_t session; /* zero this too */
int i;
if (device == NULL || forcetype == NULL) {
gpsd_report(&context.errout, LOG_ERROR,
"device and type must be specified for the reset operation.\n");
exit(EXIT_FAILURE);
}
/*@ -mustfreeonly -immediatetrans @*/
gps_context_init(&context, "gpsctl");
context.errout.debug = debuglevel;
session.context = &context;
gpsd_tty_init(&session);
(void)strlcpy(session.gpsdata.dev.path, device, sizeof(session.gpsdata.dev.path));
session.device_type = forcetype;
(void)gpsd_open(&session);
(void)gpsd_set_raw(&session);
(void)session.device_type->speed_switcher(&session, 4800, 'N', 1);
(void)tcdrain(session.gpsdata.gps_fd);
for(i = 0; i < (int)(sizeof(speeds) / sizeof(speeds[0])); i++) {
(void)gpsd_set_speed(&session, speeds[i], 'N', 1);
(void)session.device_type->speed_switcher(&session, 4800, 'N', 1);
(void)tcdrain(session.gpsdata.gps_fd);
}
gpsd_set_speed(&session, 4800, 'N', 1);
for (i = 0; i < 3; i++)
if (session.device_type->mode_switcher)
session.device_type->mode_switcher(&session, MODE_NMEA);
gpsd_wrap(&session);
exit(EXIT_SUCCESS);
/*@ +mustfreeonly +immediatetrans @*/
#endif /* RECONFIGURE_ENABLE */
} else {
/* access to the daemon failed, use the low-level facilities */
static struct gps_device_t session; /* zero this too */
fd_set all_fds;
fd_set rfds;
/*
* Unless the user explicitly requested it, always run to end of
* hunt rather than timing out. Otherwise we can easily get messages
* that spuriously look like failure at high baud rates.
*/
/*@ -mustfreeonly -immediatetrans @*/
gps_context_init(&context, "gpsctl");
context.errout.debug = debuglevel;
session.context = &context; /* in case gps_init isn't called */
if (echo)
context.readonly = true;
if (timeout > 0) {
(void) alarm(timeout);
(void) signal(SIGALRM, onsig);
}
/*
* Unless the user has forced a type and only wants to see the
* string (not send it) we now need to try to open the device
* and find out what is actually there.
*/
if (!(forcetype != NULL && echo)) {
int maxfd = 0;
if (device == NULL) {
gpsd_report(&context.errout, LOG_ERROR,
"device must be specified for low-level access.\n");
exit(EXIT_FAILURE);
}
gpsd_init(&session, &context, device);
if (gpsd_activate(&session, O_PROBEONLY) < 0) {
gpsd_report(&context.errout, LOG_ERROR,
"initial GPS device %s open failed\n",
device);
exit(EXIT_FAILURE);
}
gpsd_report(&context.errout, LOG_INF,
"device %s activated\n", session.gpsdata.dev.path);
/*@i1@*/FD_SET(session.gpsdata.gps_fd, &all_fds);
if (session.gpsdata.gps_fd > maxfd)
maxfd = session.gpsdata.gps_fd;
/* initialize the GPS context's time fields */
gpsd_time_init(&context, time(NULL));
/*@-compdef@*/
/* grab packets until we time out, get sync, or fail sync */
for (hunting = true; hunting; )
{
fd_set efds;
switch(gpsd_await_data(&rfds, &efds, maxfd, &all_fds, &context.errout))
{
case AWAIT_GOT_INPUT:
break;
case AWAIT_NOT_READY:
/* no recovery from bad fd is possible */
if (FD_ISSET(session.gpsdata.gps_fd, &efds))
exit(EXIT_FAILURE);
continue;
case AWAIT_FAILED:
exit(EXIT_FAILURE);
}
switch(gpsd_multipoll(FD_ISSET(session.gpsdata.gps_fd, &rfds),
&session, ctlhook, 0))
{
case DEVICE_READY:
FD_SET(session.gpsdata.gps_fd, &all_fds);
break;
case DEVICE_UNREADY:
FD_CLR(session.gpsdata.gps_fd, &all_fds);
break;
case DEVICE_ERROR:
/* this is where a failure to sync lands */
gpsd_report(&context.errout, LOG_WARN,
"device error, bailing out.\n");
exit(EXIT_FAILURE);
case DEVICE_EOF:
gpsd_report(&context.errout, LOG_WARN,
"device signed off, bailing out.\n");
exit(EXIT_SUCCESS);
default:
break;
}
}
/*@+compdef@*/
gpsd_report(&context.errout, LOG_PROG,
"%s looks like a %s at %d.\n",
device, gpsd_id(&session),
session.gpsdata.dev.baudrate);
if (forcetype!=NULL && strcmp("NMEA0183", session.device_type->type_name) !=0 && strcmp(forcetype->type_name, session.device_type->type_name)!=0) {
gpsd_report(&context.errout, LOG_ERROR,
"'%s' doesn't match non-generic type '%s' of selected device.\n",
forcetype->type_name,
session.device_type->type_name);
}
}
(void)printf("%s identified as a %s at %u baud.\n",
device, gpsd_id(&session),
session.gpsdata.dev.baudrate);
/* if no control operation was specified, we're done */
if (speed==NULL && !to_nmea && !to_binary && control==NULL)
exit(EXIT_SUCCESS);
/* maybe user wants to see the packet rather than send it */
if (echo)
session.gpsdata.gps_fd = fileno(stdout);
/* control op specified; maybe we forced the type */
if (forcetype != NULL)
(void)gpsd_switch_driver(&session, forcetype->type_name);
/* now perform the actual control function */
status = 0;
#ifdef RECONFIGURE_ENABLE
/*@ -nullderef @*/
if (to_nmea || to_binary) {
bool write_enable = context.readonly;
context.readonly = false;
if (session.device_type->mode_switcher == NULL) {
gpsd_report(&context.errout, LOG_SHOUT,
"%s devices have no mode switch.\n",
session.device_type->type_name);
status = 1;
} else {
int target_mode = to_nmea ? MODE_NMEA : MODE_BINARY;
gpsd_report(&context.errout, LOG_SHOUT,
"switching to mode %s.\n",
to_nmea ? "NMEA" : "BINARY");
session.device_type->mode_switcher(&session, target_mode);
settle(&session);
}
context.readonly = write_enable;
}
if (speed) {
char parity = echo ? 'N': session.gpsdata.dev.parity;
int stopbits = echo ? 1 : session.gpsdata.dev.stopbits;
char *modespec;
modespec = strchr(speed, ':');
/*@ +charint @*/
status = 0;
if (modespec!=NULL) {
*modespec = '\0';
if (strchr("78", *++modespec) == NULL) {
gpsd_report(&context.errout, LOG_ERROR,
"No support for that word lengths.\n");
status = 1;
}
parity = *++modespec;
if (strchr("NOE", parity) == NULL) {
gpsd_report(&context.errout, LOG_ERROR,
"What parity is '%c'?\n", parity);
status = 1;
}
stopbits = *++modespec;
if (strchr("12", parity) == NULL) {
gpsd_report(&context.errout, LOG_ERROR,
"Stop bits must be 1 or 2.\n");
status = 1;
}
stopbits = (int)(stopbits-'0');
}
if (status == 0) {
if (session.device_type->speed_switcher == NULL) {
gpsd_report(&context.errout, LOG_ERROR,
"%s devices have no speed switch.\n",
session.device_type->type_name);
status = 1;
}
else if (session.device_type->speed_switcher(&session,
(speed_t)atoi(speed),
parity,
stopbits)) {
settle(&session);
gpsd_report(&context.errout, LOG_PROG,
"%s change to %s%c%d succeeded\n",
session.gpsdata.dev.path,
speed, parity, stopbits);
} else {
gpsd_report(&context.errout, LOG_ERROR,
"%s driver won't support %s%c%d.\n",
session.gpsdata.dev.path,
speed, parity, stopbits);
status = 1;
}
}
}
if (rate) {
bool write_enable = context.readonly;
context.readonly = false;
if (session.device_type->rate_switcher == NULL) {
gpsd_report(&context.errout, LOG_ERROR,
"%s devices have no rate switcher.\n",
session.device_type->type_name);
status = 1;
} else {
double rate_dbl = strtod(rate, NULL);
if (!session.device_type->rate_switcher(&session, rate_dbl)) {
gpsd_report(&context.errout, LOG_ERROR, "rate switch failed.\n");
status = 1;
}
settle(&session);
}
context.readonly = write_enable;
}
#endif /* RECONFIGURE_ENABLE */
#ifdef CONTROLSEND_ENABLE
/*@ -compdef @*/
if (control) {
bool write_enable = context.readonly;
context.readonly = false;
if (session.device_type->control_send == NULL) {
gpsd_report(&context.errout, LOG_ERROR,
"%s devices have no control sender.\n",
session.device_type->type_name);
status = 1;
} else {
if (session.device_type->control_send(&session,
cooked,
(size_t)cooklen) == -1) {
gpsd_report(&context.errout, LOG_ERROR,
"control transmission failed.\n");
status = 1;
}
settle(&session);
}
context.readonly = write_enable;
}
/*@ +compdef @*/
#endif /* CONTROLSEND_ENABLE */
exit(status);
/*@ +nullderef @*/
/*@ +mustfreeonly +immediatetrans @*/
}
}
