gps_mask_t generic_parse_input(struct gps_device_t *session)
{
const struct gps_type_t **dp;
if (session->packet.type == COMMENT_PACKET) {
gpsd_set_century(session);
return 0;
#ifdef NMEA_ENABLE
} else if (session->packet.type == NMEA_PACKET) {
gps_mask_t st = 0;
char *sentence = (char *)session->packet.outbuffer;
if (sentence[strlen(sentence)-1] != '\n')
gpsd_report(LOG_IO, "<= GPS: %s\n", sentence);
else
gpsd_report(LOG_IO, "<= GPS: %s", sentence);
if ((st=nmea_parse(sentence, session)) == 0) {
gpsd_report(LOG_WARN, "unknown sentence: \"%s\"\n", sentence);
}
for (dp = gpsd_drivers; *dp; dp++) {
char *trigger = (*dp)->trigger;
if (trigger!=NULL && strncmp(sentence,trigger,strlen(trigger))==0) {
gpsd_report(LOG_PROG, "found trigger string %s.\n", trigger);
if (*dp != session->device_type) {
(void)gpsd_switch_driver(session, (*dp)->type_name);
if (session->device_type != NULL
&& session->device_type->event_hook != NULL)
session->device_type->event_hook(session,
event_triggermatch);
st |= DEVICEID_SET;
}
}
}
return st;
#endif /* NMEA_ENABLE */
} else {
for (dp = gpsd_drivers; *dp; dp++) {
if (session->packet.type == (*dp)->packet_type) {
(void)gpsd_switch_driver(session, (*dp)->type_name);
return (*dp)->parse_packet(session);
}
}
return 0;
}
}
static void earthmate_event_hook(struct gps_device_t *session, event_t event)
{
if (session->context->readonly)
return;
if (event == event_identified) {
(void)gpsd_write(session, "EARTHA\r\n", 8);
(void)usleep(10000);
(void)gpsd_switch_driver(session, "Zodiac Binary");
}
}
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;
unsigned int timeout = 4;
#ifdef ALLOW_CONTROLSEND
char cooked[BUFSIZ];
ssize_t cooklen = 0;
#endif /* ALLOW_RECONFIGURE */
#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 ALLOW_RECONFIGURE
rate = optarg;
#else
gpsd_report(LOG_ERROR, "cycle-change capability has been conditioned out.\n");
#endif /* ALLOW_RECONFIGURE */
break;
case 'x': /* ship specified control string */
#ifdef ALLOW_CONTROLSEND
control = optarg;
lowlevel = true;
if ((cooklen = hex_escapes(cooked, control)) <= 0) {
gpsd_report(LOG_ERROR,
"invalid escape string (error %d)\n", (int)cooklen);
exit(1);
}
#else
gpsd_report(LOG_ERROR, "control_send capability has been conditioned out.\n");
#endif /* ALLOW_CONTROLSEND */
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 ALLOW_RECONFIGURE
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 /* ALLOW_RECONFIGURE */
#ifdef ALLOW_CONTROLSEND
if ((*dp)->control_send != NULL)
(void)fputs("-x\t", stdout);
else
(void)fputc('\t', stdout);
#endif /* ALLOW_CONTROLSEND */
(void)puts((*dp)->type_name);
}
exit(0);
case 'n': /* switch to NMEA mode */
#ifdef ALLOW_RECONFIGURE
to_nmea = true;
#else
gpsd_report(LOG_ERROR, "speed-change capability has been conditioned out.\n");
#endif /* ALLOW_RECONFIGURE */
break;
case 'r': /* force-switch to default mode */
#ifdef ALLOW_RECONFIGURE
reset = true;
lowlevel = false; /* so we'll abort if the daemon is running */
#else
gpsd_report(LOG_ERROR, "reset capability has been conditioned out.\n");
#endif /* ALLOW_RECONFIGURE */
break;
case 's': /* change output baud rate */
#ifdef ALLOW_RECONFIGURE
speed = optarg;
#else
gpsd_report(LOG_ERROR, "speed-change capability has been conditioned out.\n");
#endif /* ALLOW_RECONFIGURE */
break;
case 't': /* force the device type */
devtype = optarg;
break;
case 'T': /* set the timeout on packet recognition */
timeout = (unsigned)atoi(optarg);
break;
case 'D': /* set debugging level */
debuglevel = atoi(optarg);
gpsd_hexdump_level = debuglevel;
#ifdef CLIENTDEBUG_ENABLE
gps_enable_debug(debuglevel, stderr);
#endif /* CLIENTDEBUG_ENABLE */
break;
case 'V':
(void)fprintf(stderr, "gpsctl: version %s (revision %s)\n",
VERSION, REVISION);
break;
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(LOG_ERROR, "no driver type name matches '%s'.\n", devtype);
else if (matchcount == 1) {
assert(forcetype != NULL);
gpsd_report(LOG_PROG, "%s driver selected.\n", forcetype->type_name);
} else {
forcetype = NULL;
gpsd_report(LOG_ERROR, "%d driver type names match '%s'.\n",
matchcount, devtype);
}
}
if ((int)to_nmea + (int)to_binary + (int)reset > 1) {
gpsd_report(LOG_ERROR, "make up your mind, would you?\n");
exit(0);
}
(void) signal(SIGINT, onsig);
(void) signal(SIGTERM, onsig);
(void) signal(SIGQUIT, onsig);
/*@-nullpass@*/ /* someday, add null annotation to the gpsopen_r() params */
if (!lowlevel) {
/* Try to open the stream to gpsd. */
if (gps_open_r(NULL, NULL, &gpsdata) != 0) {
gpsd_report(LOG_ERROR, "no gpsd running or network error: %s.\n",
netlib_errstr(errno));
lowlevel = true;
}
}
/*@-nullpass@*/
/* ^ someday, add out annotation to the gpspoll() param and remove */
if (!lowlevel) {
/* OK, there's a daemon instance running. Do things the easy way */
struct devconfig_t *devlistp;
(void)gps_read(&gpsdata);
if ((gpsdata.set & DEVICELIST_SET) != 0) {
gpsd_report(LOG_ERROR, "no VERSION response received; update your gpsd.\n");
(void)gps_close(&gpsdata);
exit(1);
}
(void)gps_query(&gpsdata, "?DEVICES;\n");
if ((gpsdata.set & DEVICELIST_SET) == 0) {
gpsd_report(LOG_ERROR, "no DEVICES response received.\n");
(void)gps_close(&gpsdata);
exit(1);
}
if (gpsdata.devices.ndevices == 0) {
gpsd_report(LOG_ERROR, "no devices connected.\n");
(void)gps_close(&gpsdata);
exit(1);
} else if (gpsdata.devices.ndevices > 1 && device == NULL) {
gpsd_report(LOG_ERROR,
"multiple devices and no device specified.\n");
(void)gps_close(&gpsdata);
exit(1);
}
gpsd_report(LOG_PROG,"%d device(s) found.\n",gpsdata.devices.ndevices);
if (gpsdata.devices.ndevices == 1) {
devlistp = &gpsdata.devices.list[0];
device = devlistp->path;
} else {
int i;
assert(device != NULL);
for (i = 0; i < gpsdata.devices.ndevices; i++)
if (strcmp(device, gpsdata.devices.list[i].path) == 0)
goto foundit;
gpsd_report(LOG_ERROR, "specified device not found.\n");
(void)gps_close(&gpsdata);
exit(1);
foundit:
devlistp = &gpsdata.devices.list[i];
}
/* if no control operation was specified, just ID the device */
if (speed==NULL && rate == NULL && !to_nmea && !to_binary && !reset) {
gpsd_report(LOG_SHOUT, "%s identified as %s at %d\n",
devlistp->path, devlistp->driver, devlistp->baudrate);
exit(0);
}
status = 0;
#ifdef ALLOW_RECONFIGURE
if (reset)
{
gpsd_report(LOG_PROG, "cannot reset with gpsd running.\n");
exit(0);
}
/*@-boolops@*/
if (to_nmea) {
(void)gps_query(&gpsdata, "?DEVICE={\"path\":\"%s\",\"native\":0}\r\n", device);
if ((gpsdata.set & ERROR_SET) || (gpsdata.dev.driver_mode != MODE_NMEA)) {
gpsd_report(LOG_ERROR, "%s mode change to NMEA failed\n", gpsdata.dev.path);
status = 1;
} else
gpsd_report(LOG_PROG, "%s mode change succeeded\n", gpsdata.dev.path);
}
else if (to_binary) {
(void)gps_query(&gpsdata, "?DEVICE={\"path\":\"%s\",\"native\":1}\r\n", device);
if ((gpsdata.set & ERROR_SET) || (gpsdata.dev.driver_mode != MODE_BINARY)) {
gpsd_report(LOG_ERROR, "%s mode change to native mode failed\n", gpsdata.dev.path);
status = 1;
} else
gpsd_report(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={\"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(LOG_ERROR, "No support for that word lengths.\n");
status = 1;
}
parity = *++modespec;
if (strchr("NOE", parity) == NULL) {
gpsd_report(LOG_ERROR, "What parity is '%c'?\n", parity);
status = 1;
}
stopbits = *++modespec;
if (strchr("12", stopbits) == NULL) {
gpsd_report(LOG_ERROR, "Stop bits must be 1 or 2.\n");
status = 1;
}
}
if (status == 0)
(void)gps_query(&gpsdata,
"?DEVICE={\"path\":\"%s\",\"bps\":%s,\"parity\":\"%c\",\"stopbits\":%c}\r\n",
device, speed, parity, stopbits);
}
if (atoi(speed) != (int)gpsdata.dev.baudrate) {
gpsd_report(LOG_ERROR, "%s driver won't support %s%c%c\n",
gpsdata.dev.path,
speed, parity, stopbits);
status = 1;
} else
gpsd_report(LOG_PROG, "%s change to %s%c%c succeeded\n",
gpsdata.dev.path,
speed, parity, stopbits);
}
if (rate != NULL) {
(void)gps_query(&gpsdata,
"?DEVICE={\"path\":\"%s\",\"cycle\":%s}\n",
device, rate);
}
#endif /* ALLOW_RECONFIGURE */
(void)gps_close(&gpsdata);
exit(status);
#ifdef ALLOW_RECONFIGURE
} else if (reset) {
/* hard reset will go through lower-level operations */
const int speeds[] = {2400, 4800, 9600, 19200, 38400, 57600, 115200};
static struct gps_context_t context; /* start it zeroed */
static struct gps_device_t session; /* zero this too */
int i;
if (device == NULL || forcetype == NULL) {
gpsd_report(LOG_ERROR, "device and type must be specified for the reset operation.\n");
exit(1);
}
/*@ -mustfreeonly -immediatetrans @*/
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(0);
/*@ +mustfreeonly +immediatetrans @*/
#endif /* ALLOW_RECONFIGURE */
} else {
/* access to the daemon failed, use the low-level facilities */
static struct gps_context_t context; /* start it zeroed */
static struct gps_device_t session; /* zero this too */
/*@ -mustfreeonly -immediatetrans @*/
session.context = &context; /* in case gps_init isn't called */
if (echo)
context.readonly = true;
(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 seq;
if (device == NULL) {
gpsd_report(LOG_ERROR, "device must be specified for low-level access.\n");
exit(1);
}
gpsd_init(&session, &context, device);
gpsd_report(LOG_PROG, "initialization passed.\n");
if (gpsd_activate(&session) == -1) {
gpsd_report(LOG_ERROR,
"activation of device %s failed, errno=%d\n",
device, errno);
exit(2);
}
/* hunt for packet type and serial parameters */
for (seq = 0; session.device_type == NULL; seq++) {
if (get_packet(&session) == ERROR_SET) {
gpsd_report(LOG_ERROR,
"autodetection failed.\n");
exit(2);
} else {
gpsd_report(LOG_IO,
"autodetection after %d reads.\n", seq);
(void) alarm(0);
break;
}
}
gpsd_report(LOG_PROG, "%s looks like a %s at %d.\n",
device, gpsd_id(&session), session.gpsdata.dev.baudrate);
if (forcetype!=NULL && strcmp("Generic NMEA", session.device_type->type_name) !=0 && strcmp(forcetype->type_name, session.device_type->type_name)!=0) {
gpsd_report(LOG_ERROR, "'%s' doesn't match non-generic type '%s' of selected device.\n", forcetype->type_name, session.device_type->type_name);
}
/*
* If we've identified this as an NMEA device, we have to eat
* packets for a while to see if one of our probes elicits an
* ID response telling us that it's really a SiRF or
* something. If so, the libgpsd(3) layer will automatically
* redispatch to the correct driver type.
*/
if (strcmp(session.device_type->type_name, "Generic NMEA") == 0) {
int dummy;
for (dummy = 0; dummy < REDIRECT_SNIFF; dummy++) {
if ((get_packet(&session) & DEVICEID_SET)!=0)
break;
}
}
gpsd_report(LOG_SHOUT, "%s identified as a %s at %d.\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(0);
/* 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 ALLOW_RECONFIGURE
/*@ -nullderef @*/
if (to_nmea || to_binary) {
if (session.device_type->mode_switcher == NULL) {
gpsd_report(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;
int target_type = to_nmea ? NMEA_PACKET : session.device_type->packet_type;
gpsd_report(LOG_SHOUT,
"switching to mode %s.\n",
to_nmea ? "NMEA" : "BINARY");
session.device_type->mode_switcher(&session, target_mode);
/*
* Hunt for packet type again (mode might have
* changed). We've found by experiment that you can't
* close the connection to the device after a mode
* change but before you see a packet of the right
* type come back from it - otherwise you can hit a
* timing window where the mode-change control message
* gets ignored or flushed.
*/
if (!echo) {
/* suppresses probing for subtypes */
context.readonly = true;
(void)sleep(1);
(void) alarm(timeout);
for (;;) {
if (get_packet(&session) == ERROR_SET) {
continue;
} else if (session.packet.type == target_type) {
(void)alarm(0);
break;
}
}
context.readonly = false;
}
/*@ -nullpass @*/
gpsd_report(LOG_SHOUT, "after mode change, %s looks like a %s at %d.\n",
device, gpsd_id(&session), session.gpsdata.dev.baudrate);
/*@ +nullpass @*/
}
}
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(LOG_ERROR, "No support for that word lengths.\n");
status = 1;
}
parity = *++modespec;
if (strchr("NOE", parity) == NULL) {
gpsd_report(LOG_ERROR, "What parity is '%c'?\n", parity);
status = 1;
}
stopbits = *++modespec;
if (strchr("12", parity) == NULL) {
gpsd_report(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(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)) {
/*
* See the 'deep black magic' comment in
* gpsd.c:set_serial() Probably not needed here,
* but it can't hurt.
*/
(void)tcdrain(session.gpsdata.gps_fd);
(void)usleep(50000);
gpsd_report(LOG_PROG, "%s change to %s%c%d succeeded\n",
session.gpsdata.dev.path,
speed, parity, stopbits);
} else {
gpsd_report(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(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(LOG_ERROR, "rate switch failed.\n");
status = 1;
}
}
context.readonly = write_enable;
}
#endif /* ALLOW_RECONFIGURE */
#ifdef ALLOW_CONTROLSEND
/*@ -compdef @*/
if (control) {
bool write_enable = context.readonly;
context.readonly = false;
if (session.device_type->control_send == NULL) {
gpsd_report(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(LOG_ERROR, "control transmission failed.\n");
status = 1;
}
}
context.readonly = write_enable;
}
/*@ +compdef @*/
#endif /* ALLOW_CONTROLSEND */
if (forcetype == NULL || !echo) {
/*
* Give the device time to settle before closing it. Alas, this is
* voodoo programming; we don't know it will have any effect, but
* GPSes are notoriously prone to timing-dependent errors.
*/
(void)usleep(300000);
gpsd_wrap(&session);
}
exit(status);
/*@ +nullderef @*/
/*@ +mustfreeonly +immediatetrans @*/
}
}
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 @*/
}
}
int gpsd_serial_open(struct gps_device_t *session)
/* open a device for access to its data
* return: the opened file descriptor
* PLACEHOLDING_FD - for /dev/ppsX
* UNALLOCATED_FD - for open failure
*/
{
mode_t mode = (mode_t) O_RDWR;
session->sourcetype = gpsd_classify(session->gpsdata.dev.path);
session->servicetype = service_sensor;
/* we may need to hold on to this slot without opening the device */
if (source_pps == session->sourcetype) {
(void)gpsd_switch_driver(session, "PPS");
return PLACEHOLDING_FD;
}
if (session->context->readonly
|| (session->sourcetype <= source_blockdev)) {
mode = (mode_t) O_RDONLY;
gpsd_log(&session->context->errout, LOG_INF,
"opening read-only GPS data source type %d and at '%s'\n",
(int)session->sourcetype, session->gpsdata.dev.path);
} else {
gpsd_log(&session->context->errout, LOG_INF,
"opening GPS data source type %d at '%s'\n",
(int)session->sourcetype, session->gpsdata.dev.path);
}
#ifdef ENABLE_BLUEZ
if (bachk(session->gpsdata.dev.path) == 0) {
struct sockaddr_rc addr = { 0, *BDADDR_ANY, 0};
session->gpsdata.gps_fd = socket(AF_BLUETOOTH,
SOCK_STREAM,
BTPROTO_RFCOMM);
addr.rc_family = AF_BLUETOOTH;
addr.rc_channel = (uint8_t) 1;
(void) str2ba(session->gpsdata.dev.path, &addr.rc_bdaddr);
if (connect(session->gpsdata.gps_fd, (struct sockaddr *) &addr, sizeof (addr)) == -1) {
if (errno != EINPROGRESS && errno != EAGAIN) {
(void)close(session->gpsdata.gps_fd);
gpsd_log(&session->context->errout, LOG_ERROR,
"bluetooth socket connect failed: %s\n",
strerror(errno));
return UNALLOCATED_FD;
}
gpsd_log(&session->context->errout, LOG_ERROR,
"bluetooth socket connect in progress or again : %s\n",
strerror(errno));
}
(void)fcntl(session->gpsdata.gps_fd, F_SETFL, (int)mode);
gpsd_log(&session->context->errout, LOG_PROG,
"bluez device open success: %s %s\n",
session->gpsdata.dev.path, strerror(errno));
} else
#endif /* BLUEZ */
{
/*
* We open with O_NONBLOCK because we want to now get hung if
* the clocal flag is off, but we don't want to stay in that mode.
*/
if ((session->gpsdata.gps_fd =
open(session->gpsdata.dev.path, (int)(mode | O_NONBLOCK | O_NOCTTY))) == -1) {
gpsd_log(&session->context->errout, LOG_ERROR,
"device open of %s failed: %s - retrying read-only\n",
session->gpsdata.dev.path,
strerror(errno));
if ((session->gpsdata.gps_fd =
open(session->gpsdata.dev.path, O_RDONLY | O_NONBLOCK | O_NOCTTY)) == -1) {
gpsd_log(&session->context->errout, LOG_ERROR,
"read-only device open of %s failed: %s\n",
session->gpsdata.dev.path,
strerror(errno));
return UNALLOCATED_FD;
}
gpsd_log(&session->context->errout, LOG_PROG,
"file device open of %s succeeded: %s\n",
session->gpsdata.dev.path,
strerror(errno));
}
}
/*
* Ideally we want to exclusion-lock the device before doing any reads.
* It would have been best to do this at open(2) time, but O_EXCL
* doesn't work without O_CREAT.
*
* We have to make an exception for ptys, which are intentionally
* opened by another process on the master side, otherwise we'll
* break all our regression tests.
*
* We also exclude bluetooth device because the bluetooth daemon opens them.
*/
if (!(session->sourcetype == source_pty || session->sourcetype == source_bluetooth)) {
#ifdef TIOCEXCL
/*
* Try to block other processes from using this device while we
* have it open (later opens should return EBUSY). Won't work
* against anything with root privileges, alas.
*/
(void)ioctl(session->gpsdata.gps_fd, (unsigned long)TIOCEXCL);
#endif /* TIOCEXCL */
#ifdef __linux__
/*
* Don't touch devices already opened by another process.
*/
if (fusercount(session->gpsdata.dev.path) > 1) {
gpsd_log(&session->context->errout, LOG_ERROR,
"%s already opened by another process\n",
session->gpsdata.dev.path);
(void)close(session->gpsdata.gps_fd);
session->gpsdata.gps_fd = UNALLOCATED_FD;
return UNALLOCATED_FD;
}
#endif /* __linux__ */
}
#ifdef FIXED_PORT_SPEED
session->saved_baud = FIXED_PORT_SPEED;
#endif
if (session->saved_baud != -1) {
(void)cfsetispeed(&session->ttyset, (speed_t)session->saved_baud);
(void)cfsetospeed(&session->ttyset, (speed_t)session->saved_baud);
(void)tcsetattr(session->gpsdata.gps_fd, TCSANOW, &session->ttyset);
(void)tcflush(session->gpsdata.gps_fd, TCIOFLUSH);
}
session->lexer.type = BAD_PACKET;
if (isatty(session->gpsdata.gps_fd) != 0) {
/* Save original terminal parameters */
if (tcgetattr(session->gpsdata.gps_fd, &session->ttyset_old) != 0)
return UNALLOCATED_FD;
session->ttyset = session->ttyset_old;
memset(session->ttyset.c_cc, 0, sizeof(session->ttyset.c_cc));
//session->ttyset.c_cc[VTIME] = 1;
/*
* Tip from Chris Kuethe: the FIDI chip used in the Trip-Nav
* 200 (and possibly other USB GPSes) gets completely hosed
* in the presence of flow control. Thus, turn off CRTSCTS.
*
* This is not ideal. Setting no parity here will mean extra
* initialization time for some devices, like certain Trimble
* boards, that want 7O2 or other non-8N1 settings. But starting
* the hunt loop at 8N1 will minimize the average sync time
* over all devices.
*/
session->ttyset.c_cflag &= ~(PARENB | PARODD | CRTSCTS | CSTOPB);
session->ttyset.c_cflag |= CREAD | CLOCAL;
session->ttyset.c_iflag = session->ttyset.c_oflag =
session->ttyset.c_lflag = (tcflag_t) 0;
#ifndef FIXED_PORT_SPEED
session->baudindex = 0;
#endif /* FIXED_PORT_SPEED */
gpsd_set_speed(session,
#ifdef FIXED_PORT_SPEED
FIXED_PORT_SPEED,
#else
gpsd_get_speed_old(session),
#endif /* FIXED_PORT_SPEED */
'N',
#ifdef FIXED_STOP_BITS
FIXED_STOP_BITS
#else
1
#endif /* FIXED_STOP_BITS */
);
}
/* Switch back to blocking I/O now that CLOCAL is set. */
{
int oldfl = fcntl(session->gpsdata.gps_fd, F_GETFL);
if (oldfl != -1)
(void)fcntl(session->gpsdata.gps_fd, F_SETFL, oldfl & ~O_NONBLOCK);
}
/* required so parity field won't be '\0' if saved speed matches */
if (session->sourcetype <= source_blockdev) {
session->gpsdata.dev.parity = 'N';
session->gpsdata.dev.stopbits = 1;
}
gpsd_log(&session->context->errout, LOG_SPIN,
"open(%s) -> %d in gpsd_serial_open()\n",
session->gpsdata.dev.path, session->gpsdata.gps_fd);
return session->gpsdata.gps_fd;
}
