static struct globals *gpsd_init(int argc, char *argv[])
{
bool have_source = false;
int opt, opt_ind;
struct globals *globals;
struct option long_options[] = {
{"server", no_argument, NULL, 's'},
{"location", required_argument, NULL, 'l'},
{"gpsd", required_argument, NULL, 'g'},
{"unix-path", required_argument, NULL, 'u'},
{"help", no_argument, NULL, 'h'},
{"version", no_argument, NULL, 'v'},
{NULL, 0, NULL, 0},
};
globals = &gpsd_globals;
memset(globals, 0, sizeof(*globals));
globals->opmode = OPMODE_CLIENT;
globals->source = SOURCE_GPSD;
globals->gpsd_format = FORMAT_JSON;
globals->unix_path = ALFRED_SOCK_PATH_DEFAULT;
while ((opt = getopt_long(argc, argv, "shl:g:vu:", long_options,
&opt_ind)) != -1) {
switch (opt) {
case 's':
globals->opmode = OPMODE_SERVER;
break;
case 'l':
globals->source = SOURCE_CMDLINE;
gpsd_parse_location(globals, optarg);
break;
case 'g':
gpsd_source_spec(optarg, &globals->gpsdsource);
have_source = true;
break;
case 'u':
globals->unix_path = optarg;
break;
case 'v':
printf("%s %s\n", argv[0], SOURCE_VERSION);
printf("GPSD alfred client\n");
return NULL;
case 'h':
default:
gpsd_usage();
return NULL;
}
}
if (globals->source == SOURCE_GPSD && !have_source)
gpsd_source_spec(NULL, &globals->gpsdsource);
if (signal(SIGPIPE, SIG_IGN) == SIG_ERR)
perror("could not register SIGPIPE handler");
return globals;
}
int startLocationServices()
{
if (working) { return 0.0; }
gpsdata.status = STATUS_NO_FIX;
gpsdata.satellites_used = 0;
gps_clear_fix(&(gpsdata.fix));
gps_clear_dop(&(gpsdata.dop));
gpsdata.fix.latitude=0;
gpsdata.fix.longitude=0;
logfile=stdout;
gpsd_source_spec(NULL, &source);
unsigned int flags = WATCH_ENABLE;
if (gps_open("127.0.0.1" , "2947", &gpsdata) != 0)
{ fprintf(stderr,"LoacationService : no gpsd running or network error: %d, %s\n", errno, gps_errstr(errno)); return 0; }
if (source.device != NULL)
flags |= WATCH_DEVICE;
gps_stream(&gpsdata, flags, source.device);
fprintf(stderr,MAGENTA "Polling location services to determine if they will be used in this run : \n" NORMAL);
fprintf(stderr,MAGENTA "If you don't want to wait use `sudo service gpsd stop`\n" NORMAL);
unsigned int tries=3;
unsigned int success=0;
unsigned int i=0;
working=1; //lets assume that we are working so that pollLocationServices will work
for (i=0; i<tries; i++)
{
success+=pollLocationServices();
usleep(1000*1000);
}
if (success==0)
{
fprintf(stderr,RED "Location services failed to provide gps coordinates beeing switched off\n" NORMAL);
working=0;
} else
if (success<tries)
{
fprintf(stderr,YELLOW "Location services failed to provide gps coordinates beeing switched off\n" NORMAL);
working=1;
} else
if (success==tries)
{
fprintf(stderr,GREEN "Location services working fine.. :) \n" NORMAL);
working=1;
}
return working;
}
// Open the stream with the GPSd socket
int gpsdOpenStream() {
// ... to verify what version
gpsd_source_spec(NULL, &source); // GPSD_SERVERPORT, &source);
// gpsd_source_spec(FCD_GPSD_SERVERPORT, &source);
//
// Open the stream
if (gps_open(source.server, source.port, &gpsdata) != 0) {
fcdLogErr("No GPSD daemon running or network !",(char *)gps_errstr(errno));
__recordStringValue("NO LINK", "GPSstatus");
return(false);
}
// If the device is defined then add a flag
if (source.device != NULL) flags |= WATCH_DEVICE;
// Finally connect the device to the stream
(void)gps_stream(&gpsdata, flags, source.device);
__recordStringValue("LINK", "GPSstatus");
return(true);
}
/*@-mustfreefresh -mustfreeonly -branchstate -globstate@*/
int main(int argc, char **argv)
{
int ch;
bool daemonize = false;
unsigned int flags = WATCH_ENABLE;
struct exportmethod_t *method = NULL;
progname = argv[0];
if (export_default() == NULL) {
(void)fprintf(stderr, "%s: no export methods.\n", progname);
exit(1);
}
logfile = stdout;
while ((ch = getopt(argc, argv, "dD:e:f:hi:lm:V")) != -1) {
switch (ch) {
case 'd':
openlog(basename(progname), LOG_PID | LOG_PERROR, LOG_DAEMON);
daemonize = true;
break;
#ifdef CLIENTDEBUG_ENABLE
case 'D':
debug = atoi(optarg);
gps_enable_debug(debug, logfile);
break;
#endif /* CLIENTDEBUG_ENABLE */
case 'e':
method = export_lookup(optarg);
if (method == NULL) {
(void)fprintf(stderr,
"%s: %s is not a known export method.\n",
progname, optarg);
exit(1);
}
break;
case 'f': /* Output file name. */
{
char fname[PATH_MAX];
time_t t;
size_t s;
t = time(NULL);
s = strftime(fname, sizeof(fname), optarg, localtime(&t));
if (s == 0) {
syslog(LOG_ERR,
"Bad template \"%s\", logging to stdout.", optarg);
break;
}
logfile = fopen(fname, "w");
if (logfile == NULL)
syslog(LOG_ERR,
"Failed to open %s: %s, logging to stdout.",
fname, strerror(errno));
break;
}
case 'i': /* set polling interfal */
timeout = (time_t) atoi(optarg);
if (timeout < 1)
timeout = 1;
if (timeout >= 3600)
fprintf(stderr,
"WARNING: track timeout is an hour or more!\n");
break;
case 'l':
export_list(stderr);
exit(0);
case 'm':
minmove = (double )atoi(optarg);
break;
case 'V':
(void)fprintf(stderr, "%s revision " REVISION "\n", progname);
exit(0);
default:
usage();
/* NOTREACHED */
}
}
if (daemonize && logfile == stdout) {
syslog(LOG_ERR, "Daemon mode with no valid logfile name - exiting.");
exit(1);
}
if (method != NULL)
if (method->magic != NULL) {
source.server = (char *)method->magic;
source.port = NULL;
}
if (optind < argc) {
gpsd_source_spec(argv[optind], &source);
} else
gpsd_source_spec(NULL, &source);
#if 0
(void)fprintf(logfile,"<!-- server: %s port: %s device: %s -->\n",
source.server, source.port, source.device);
#endif
/* catch all interesting signals */
(void)signal(SIGTERM, quit_handler);
(void)signal(SIGQUIT, quit_handler);
(void)signal(SIGINT, quit_handler);
/*@-unrecog@*/
/* might be time to daemonize */
if (daemonize) {
/* not SuS/POSIX portable, but we have our own fallback version */
if (daemon(0, 0) != 0)
(void) fprintf(stderr,"demonization failed: %s\n", strerror(errno));
}
/*@+unrecog@*/
//syslog (LOG_INFO, "---------- STARTED ----------");
if (gps_open(source.server, source.port, &gpsdata) != 0) {
(void)fprintf(stderr,
"%s: no gpsd running or network error: %d, %s\n",
progname, errno, gps_errstr(errno));
exit(1);
}
if (source.device != NULL)
flags |= WATCH_DEVICE;
(void)gps_stream(&gpsdata, flags, source.device);
print_gpx_header();
(int)gps_mainloop(&gpsdata, 5000000, conditionally_log_fix);
print_gpx_footer();
(void)gps_close(&gpsdata);
exit(0);
}
int main(int argc, char *argv[])
{
int option, rc;
struct sockaddr_in localAddr, servAddr;
struct hostent *h;
int n;
for(n=0;n<CLIMB;n++) climb[n]=0.0;
switch (gpsd_units())
{
case imperial:
altfactor = METERS_TO_FEET;
altunits = "ft";
speedfactor = MPS_TO_MPH;
speedunits = "mph";
break;
case nautical:
altfactor = METERS_TO_FEET;
altunits = "ft";
speedfactor = MPS_TO_KNOTS;
speedunits = "knots";
break;
case metric:
altfactor = 1;
altunits = "m";
speedfactor = MPS_TO_KPH;
speedunits = "kph";
break;
default:
/* leave the default alone */
break;
}
/* Process the options. Print help if requested. */
while ((option = getopt(argc, argv, "Vhl:su:")) != -1) {
switch (option) {
case 'V':
(void)fprintf(stderr, "lcdgs revision " REVISION "\n");
exit(EXIT_SUCCESS);
case 'h':
default:
usage(argv[0]);
break;
case 'l':
switch ( optarg[0] ) {
case 'd':
deg_type = deg_dd;
continue;
case 'm':
deg_type = deg_ddmm;
continue;
case 's':
deg_type = deg_ddmmss;
continue;
default:
(void)fprintf(stderr, "Unknown -l argument: %s\n", optarg);
}
break;
case 's':
sleep(10);
continue;
case 'u':
switch ( optarg[0] ) {
case 'i':
altfactor = METERS_TO_FEET;
altunits = "ft";
speedfactor = MPS_TO_MPH;
speedunits = "mph";
continue;
case 'n':
altfactor = METERS_TO_FEET;
altunits = "ft";
speedfactor = MPS_TO_KNOTS;
speedunits = "knots";
continue;
case 'm':
altfactor = 1;
altunits = "m";
speedfactor = MPS_TO_KPH;
speedunits = "kph";
continue;
default:
(void)fprintf(stderr, "Unknown -u argument: %s\n", optarg);
}
}
}
/* Grok the server, port, and device. */
if (optind < argc) {
gpsd_source_spec(argv[optind], &source);
} else
gpsd_source_spec(NULL, &source);
/* Daemonize... */
if (daemon(0, 0) != 0)
(void)fprintf(stderr,
"lcdgps: demonization failed: %s\n",
strerror(errno));
/* Open the stream to gpsd. */
if (gps_open(source.server, source.port, &gpsdata) != 0) {
(void)fprintf( stderr,
"lcdgps: no gpsd running or network error: %d, %s\n",
errno, gps_errstr(errno));
exit(EXIT_FAILURE);
}
/* Connect to LCDd */
h = gethostbyname(LCDDHOST);
if (h==NULL) {
printf("%s: unknown host '%s'\n",argv[0],LCDDHOST);
exit(EXIT_FAILURE);
}
servAddr.sin_family = h->h_addrtype;
memcpy((char *) &servAddr.sin_addr.s_addr, h->h_addr_list[0], h->h_length);
servAddr.sin_port = htons(LCDDPORT);
/* create socket */
sd = socket(AF_INET, SOCK_STREAM, 0);
if (BAD_SOCKET(sd)) {
perror("cannot open socket ");
exit(EXIT_FAILURE);
}
/* bind any port number */
localAddr.sin_family = AF_INET;
localAddr.sin_addr.s_addr = htonl(INADDR_ANY);
localAddr.sin_port = htons(0);
/* coverity[uninit_use_in_call] */
rc = bind(sd, (struct sockaddr *) &localAddr, sizeof(localAddr));
if (rc == -1) {
printf("%s: cannot bind port TCP %u\n",argv[0],LCDDPORT);
perror("error ");
exit(EXIT_FAILURE);
}
/* connect to server */
/* coverity[uninit_use_in_call] */
rc = connect(sd, (struct sockaddr *) &servAddr, sizeof(servAddr));
if (rc == -1) {
perror("cannot connect ");
exit(EXIT_FAILURE);
}
/* Do the initial field label setup. */
reset_lcd();
/* Here's where updates go. */
unsigned int flags = WATCH_ENABLE;
if (source.device != NULL)
flags |= WATCH_DEVICE;
(void)gps_stream(&gpsdata, flags, source.device);
for (;;) { /* heart of the client */
if (!gps_waiting(&gpsdata, 50000000)) {
fprintf( stderr, "lcdgps: error while waiting\n");
exit(EXIT_FAILURE);
} else {
(void)gps_read(&gpsdata);
update_lcd(&gpsdata);
}
}
}
/*@-mustfreefresh -globstate@*/
int main(int argc, char **argv)
{
int ch;
bool daemonize = false;
struct method_t *mp, *method = NULL;
progname = argv[0];
logfile = stdout;
while ((ch = getopt(argc, argv, "dD:e:f:hi:lm:V")) != -1) {
switch (ch) {
case 'd':
openlog(basename(progname), LOG_PID | LOG_PERROR, LOG_DAEMON);
daemonize = true;
break;
#ifdef CLIENTDEBUG_ENABLE
case 'D':
debug = atoi(optarg);
gps_enable_debug(debug, logfile);
break;
#endif /* CLIENTDEBUG_ENABLE */
case 'e':
for (mp = methods;
mp < methods + NITEMS(methods);
mp++)
if (strcmp(mp->name, optarg) == 0)
method = mp;
if (method == NULL) {
(void)fprintf(stderr,
"%s: %s is not a known export method.\n",
progname, optarg);
exit(1);
}
break;
case 'f': /* Output file name. */
{
char fname[PATH_MAX];
time_t t;
size_t s;
t = time(NULL);
s = strftime(fname, sizeof(fname), optarg, localtime(&t));
if (s == 0) {
syslog(LOG_ERR,
"Bad template \"%s\", logging to stdout.", optarg);
break;
}
logfile = fopen(fname, "w");
if (logfile == NULL)
syslog(LOG_ERR,
"Failed to open %s: %s, logging to stdout.",
fname, strerror(errno));
break;
}
case 'i': /* set polling interfal */
timeout = (time_t) atoi(optarg);
if (timeout < 1)
timeout = 1;
if (timeout >= 3600)
fprintf(stderr,
"WARNING: track timeout is an hour or more!\n");
break;
case 'l':
for (method = methods;
method < methods + NITEMS(methods);
method++)
(void)printf("%s: %s\n", method->name, method->description);
exit(0);
case 'm':
minmove = (double )atoi(optarg);
break;
case 'V':
(void)fprintf(stderr, "gpxlogger revision " REVISION "\n");
exit(0);
default:
usage();
/* NOTREACHED */
}
}
if (daemonize && logfile == stdout) {
syslog(LOG_ERR, "Daemon mode with no valid logfile name - exiting.");
exit(1);
}
if (optind < argc) {
gpsd_source_spec(argv[optind], &source);
} else
gpsd_source_spec(NULL, &source);
#if 0
(void)fprintf(logfile,"<!-- server: %s port: %s device: %s -->\n",
source.server, source.port, source.device);
#endif
/* initializes the some gpsdata data structure */
gpsdata.status = STATUS_NO_FIX;
gpsdata.satellites_used = 0;
gps_clear_fix(&(gpsdata.fix));
gps_clear_dop(&(gpsdata.dop));
/* catch all interesting signals */
(void)signal(SIGTERM, quit_handler);
(void)signal(SIGQUIT, quit_handler);
(void)signal(SIGINT, quit_handler);
/*@-unrecog@*/
/* might be time to daemonize */
if (daemonize) {
/* not SuS/POSIX portable, but we have our own fallback version */
if (daemon(0, 0) != 0)
(void) fprintf(stderr,"demonization failed: %s\n", strerror(errno));
}
/*@+unrecog@*/
//syslog (LOG_INFO, "---------- STARTED ----------");
if (method != NULL) {
exit((*method->method)());
} else if (NITEMS(methods)) {
exit((methods[0].method)());
} else {
(void)fprintf(stderr, "%s: no export methods.\n", progname);
exit(1);
}
}
int main(int argc, char *argv[])
{
struct gps_data_t collect;
struct fixsource_t source;
char buf[BUFSIZ];
int option;
bool batchmode = false;
bool forwardmode = false;
char *fmsg = NULL;
#ifdef CLIENTDEBUG_ENABLE
int debug = 0;
#endif
(void)signal(SIGSEGV, onsig);
(void)signal(SIGBUS, onsig);
while ((option = getopt(argc, argv, "bf:hsD:?")) != -1) {
switch (option) {
case 'b':
batchmode = true;
break;
case 'f':
forwardmode = true;
fmsg = optarg;
break;
case 's':
(void)
printf
("Sizes: fix=%zd gpsdata=%zd rtcm2=%zd rtcm3=%zd ais=%zd compass=%zd raw=%zd devices=%zd policy=%zd version=%zd, noise=%zd\n",
sizeof(struct gps_fix_t),
sizeof(struct gps_data_t), sizeof(struct rtcm2_t),
sizeof(struct rtcm3_t), sizeof(struct ais_t),
sizeof(struct attitude_t), sizeof(struct rawdata_t),
sizeof(collect.devices), sizeof(struct policy_t),
sizeof(struct version_t), sizeof(struct gst_t));
exit(EXIT_SUCCESS);
#ifdef CLIENTDEBUG_ENABLE
case 'D':
debug = atoi(optarg);
break;
#endif
case '?':
case 'h':
default:
(void)fputs("usage: test_libgps [-b] [-f fwdmsg] [-D lvl] [-s] [server[:port:[device]]]\n", stderr);
exit(EXIT_FAILURE);
}
}
/* Grok the server, port, and device. */
if (optind < argc) {
gpsd_source_spec(argv[optind], &source);
} else
gpsd_source_spec(NULL, &source);
#ifdef CLIENTDEBUG_ENABLE
gps_enable_debug(debug, stdout);
#endif
if (batchmode) {
#ifdef SOCKET_EXPORT_ENABLE
while (fgets(buf, sizeof(buf), stdin) != NULL) {
if (buf[0] == '{' || isalpha(buf[0])) {
gps_unpack(buf, &gpsdata);
libgps_dump_state(&gpsdata);
}
}
#endif
} else if (gps_open(source.server, source.port, &collect) != 0) {
(void)fprintf(stderr,
"test_libgps: no gpsd running or network error: %d, %s\n",
errno, gps_errstr(errno));
exit(EXIT_FAILURE);
} else if (forwardmode) {
(void)gps_send(&collect, fmsg);
(void)gps_read(&collect);
#ifdef SOCKET_EXPORT_ENABLE
libgps_dump_state(&collect);
#endif
(void)gps_close(&collect);
} else {
int tty = isatty(0);
if (tty)
(void)fputs("This is the gpsd exerciser.\n", stdout);
for (;;) {
if (tty)
(void)fputs("> ", stdout);
if (fgets(buf, sizeof(buf), stdin) == NULL) {
if (tty)
putchar('\n');
break;
}
collect.set = 0;
(void)gps_send(&collect, buf);
(void)gps_read(&collect);
#ifdef SOCKET_EXPORT_ENABLE
libgps_dump_state(&collect);
#endif
}
(void)gps_close(&collect);
}
return 0;
}
int main(int argc, char **argv)
{
char buf[4096];
bool timestamp = false;
char *format = "%F %T";
char tmstr[200];
bool daemonize = false;
bool binary = false;
bool sleepy = false;
bool new_line = true;
bool raw = false;
bool watch = false;
bool profile = false;
int option_u = 0; // option to show uSeconds
long count = -1;
int option;
unsigned int vflag = 0, l = 0;
FILE *fp;
unsigned int flags;
fd_set fds;
struct fixsource_t source;
char *serialport = NULL;
char *outfile = NULL;
flags = WATCH_ENABLE;
while ((option = getopt(argc, argv, "?dD:lhrRwStT:vVn:s:o:pPu2")) != -1) {
switch (option) {
case 'D':
debug = atoi(optarg);
#ifdef CLIENTDEBUG_ENABLE
gps_enable_debug(debug, stderr);
#endif /* CLIENTDEBUG_ENABLE */
break;
case 'n':
count = strtol(optarg, 0, 0);
break;
case 'r':
raw = true;
/*
* Yes, -r invokes NMEA mode rather than proper raw mode.
* This emulates the behavior under the old protocol.
*/
flags |= WATCH_NMEA;
break;
case 'R':
flags |= WATCH_RAW;
binary = true;
break;
case 'd':
daemonize = true;
break;
case 'l':
sleepy = true;
break;
case 't':
timestamp = true;
break;
case 'T':
timestamp = true;
format = optarg;
break;
case 'u':
timestamp = true;
option_u++;
break;
case 'v':
vflag++;
break;
case 'w':
flags |= WATCH_JSON;
watch = true;
break;
case 'S':
flags |= WATCH_SCALED;
break;
case 'p':
profile = true;
break;
case 'P':
flags |= WATCH_PPS;
break;
case 'V':
(void)fprintf(stderr, "%s: %s (revision %s)\n",
argv[0], VERSION, REVISION);
exit(EXIT_SUCCESS);
case 's':
serialport = optarg;
break;
case 'o':
outfile = optarg;
break;
case '2':
flags |= WATCH_SPLIT24;
break;
case '?':
case 'h':
default:
usage();
exit(EXIT_FAILURE);
}
}
/* Grok the server, port, and device. */
if (optind < argc) {
gpsd_source_spec(argv[optind], &source);
} else
gpsd_source_spec(NULL, &source);
if (serialport != NULL && !raw) {
(void)fprintf(stderr, "gpspipe: use of '-s' requires '-r'.\n");
exit(EXIT_FAILURE);
}
if (outfile == NULL && daemonize) {
(void)fprintf(stderr, "gpspipe: use of '-d' requires '-o'.\n");
exit(EXIT_FAILURE);
}
if (!raw && !watch && !binary) {
(void)fprintf(stderr,
"gpspipe: one of '-R', '-r', or '-w' is required.\n");
exit(EXIT_FAILURE);
}
/* Daemonize if the user requested it. */
if (daemonize)
if (daemon(0, 0) != 0)
(void)fprintf(stderr,
"gpspipe: demonization failed: %s\n",
strerror(errno));
/* Sleep for ten seconds if the user requested it. */
if (sleepy)
(void)sleep(10);
/* Open the output file if the user requested it. If the user
* requested '-R', we use the 'b' flag in fopen() to "do the right
* thing" in non-linux/unix OSes. */
if (outfile == NULL) {
fp = stdout;
} else {
if (binary)
fp = fopen(outfile, "wb");
else
fp = fopen(outfile, "w");
if (fp == NULL) {
(void)fprintf(stderr,
"gpspipe: unable to open output file: %s\n",
outfile);
exit(EXIT_FAILURE);
}
}
/* Open the serial port and set it up. */
if (serialport)
open_serial(serialport);
if (gps_open(source.server, source.port, &gpsdata) != 0) {
(void)fprintf(stderr,
"gpspipe: could not connect to gpsd %s:%s, %s(%d)\n",
source.server, source.port, gps_errstr(errno), errno);
exit(EXIT_FAILURE);
}
if (profile)
flags |= WATCH_TIMING;
if (source.device != NULL)
flags |= WATCH_DEVICE;
(void)gps_stream(&gpsdata, flags, source.device);
if ((isatty(STDERR_FILENO) == 0) || daemonize)
vflag = 0;
for (;;) {
int r = 0;
struct timeval tv;
tv.tv_sec = 0;
tv.tv_usec = 100000;
FD_ZERO(&fds);
FD_SET(gpsdata.gps_fd, &fds);
errno = 0;
r = select(gpsdata.gps_fd+1, &fds, NULL, NULL, &tv);
if (r == -1 && errno != EINTR) {
(void)fprintf(stderr, "gpspipe: select error %s(%d)\n",
strerror(errno), errno);
exit(EXIT_FAILURE);
} else if (r == 0)
continue;
if (vflag)
spinner(vflag, l++);
/* reading directly from the socket avoids decode overhead */
errno = 0;
r = (int)read(gpsdata.gps_fd, buf, sizeof(buf));
if (r > 0) {
int i = 0;
int j = 0;
for (i = 0; i < r; i++) {
char c = buf[i];
if (j < (int)(sizeof(serbuf) - 1)) {
serbuf[j++] = buf[i];
}
if (new_line && timestamp) {
char tmstr_u[20]; // time with "usec" resolution
struct timespec now;
struct tm *tmp_now;
(void)clock_gettime(CLOCK_REALTIME, &now);
tmp_now = localtime((time_t *)&(now.tv_sec));
(void)strftime(tmstr, sizeof(tmstr), format, tmp_now);
new_line = 0;
switch( option_u ) {
case 2:
(void)snprintf(tmstr_u, sizeof(tmstr_u),
" %ld.%06ld",
(long)now.tv_sec,
(long)now.tv_nsec/1000);
break;
case 1:
(void)snprintf(tmstr_u, sizeof(tmstr_u),
".%06ld", (long)now.tv_nsec/1000);
break;
default:
*tmstr_u = '\0';
break;
}
if (fprintf(fp, "%.24s%s: ", tmstr, tmstr_u) <= 0) {
(void)fprintf(stderr,
"gpspipe: write error, %s(%d)\n",
strerror(errno), errno);
exit(EXIT_FAILURE);
}
}
if (fputc(c, fp) == EOF) {
fprintf(stderr, "gpspipe: write error, %s(%d)\n",
strerror(errno), errno);
exit(EXIT_FAILURE);
}
if (c == '\n') {
if (serialport != NULL) {
if (write(fd_out, serbuf, (size_t) j) == -1) {
fprintf(stderr,
"gpspipe: serial port write error, %s(%d)\n",
strerror(errno), errno);
exit(EXIT_FAILURE);
}
j = 0;
}
new_line = true;
/* flush after every good line */
if (fflush(fp)) {
(void)fprintf(stderr,
"gpspipe: fflush error, %s(%d)\n",
strerror(errno), errno);
exit(EXIT_FAILURE);
}
if (count > 0) {
if (0 >= --count) {
/* completed count */
exit(EXIT_SUCCESS);
}
}
}
}
} else {
if (r == -1) {
if (errno == EAGAIN)
continue;
else
(void)fprintf(stderr, "gpspipe: read error %s(%d)\n",
strerror(errno), errno);
exit(EXIT_FAILURE);
} else {
exit(EXIT_SUCCESS);
}
}
}
#ifdef __UNUSED__
if (serialport != NULL) {
/* Restore the old serial port settings. */
if (tcsetattr(fd_out, TCSANOW, &oldtio) != 0) {
(void)fprintf(stderr, "gpsipe: error restoring serial port settings\n");
exit(EXIT_FAILURE);
}
}
#endif /* __UNUSED__ */
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
int option;
unsigned int flags = WATCH_ENABLE;
/*@ -observertrans @*/
switch (gpsd_units()) {
case imperial:
altfactor = METERS_TO_FEET;
altunits = "ft";
speedfactor = MPS_TO_MPH;
speedunits = "mph";
break;
case nautical:
altfactor = METERS_TO_FEET;
altunits = "ft";
speedfactor = MPS_TO_KNOTS;
speedunits = "knots";
break;
case metric:
altfactor = 1;
altunits = "m";
speedfactor = MPS_TO_KPH;
speedunits = "kph";
break;
default:
/* leave the default alone */
break;
}
/*@ +observertrans @*/
/* Process the options. Print help if requested. */
while ((option = getopt(argc, argv, "hVl:smu:D:")) != -1) {
switch (option) {
#ifdef CLIENTDEBUG_ENABLE
case 'D':
debug = atoi(optarg);
gps_enable_debug(debug, stderr);
break;
#endif /* CLIENTDEBUG_ENABLE */
case 'm':
magnetic_flag = true;
break;
case 's':
silent_flag = true;
break;
case 'u':
/*@ -observertrans @*/
switch (optarg[0]) {
case 'i':
altfactor = METERS_TO_FEET;
altunits = "ft";
speedfactor = MPS_TO_MPH;
speedunits = "mph";
continue;
case 'n':
altfactor = METERS_TO_FEET;
altunits = "ft";
speedfactor = MPS_TO_KNOTS;
speedunits = "knots";
continue;
case 'm':
altfactor = 1;
altunits = "m";
speedfactor = MPS_TO_KPH;
speedunits = "kph";
continue;
default:
(void)fprintf(stderr, "Unknown -u argument: %s\n", optarg);
}
break;
/*@ +observertrans @*/
case 'V':
(void)fprintf(stderr, "cgps: %s (revision %s)\n",
VERSION, REVISION);
exit(EXIT_SUCCESS);
case 'l':
switch (optarg[0]) {
case 'd':
deg_type = deg_dd;
continue;
case 'm':
deg_type = deg_ddmm;
continue;
case 's':
deg_type = deg_ddmmss;
continue;
default:
(void)fprintf(stderr, "Unknown -l argument: %s\n", optarg);
/*@ -casebreak @*/
}
break;
case 'h':
default:
usage(argv[0]);
break;
}
}
/* Grok the server, port, and device. */
if (optind < argc) {
gpsd_source_spec(argv[optind], &source);
} else
gpsd_source_spec(NULL, &source);
/* Open the stream to gpsd. */
if (gps_open(source.server, source.port, &gpsdata) != 0) {
(void)fprintf(stderr,
"cgps: no gpsd running or network error: %d, %s\n",
errno, gps_errstr(errno));
exit(EXIT_FAILURE);
}
/* note: we're assuming BSD-style reliable signals here */
(void)signal(SIGINT, die);
(void)signal(SIGHUP, die);
(void)signal(SIGWINCH, resize);
windowsetup();
status_timer = time(NULL);
if (source.device != NULL)
flags |= WATCH_DEVICE;
(void)gps_stream(&gpsdata, flags, source.device);
/* heart of the client */
for (;;) {
int c;
if (!gps_waiting(&gpsdata, 5000000)) {
die(GPS_TIMEOUT);
} else {
errno = 0;
if (gps_read(&gpsdata) == -1) {
fprintf(stderr, "cgps: socket error 4\n");
die(errno == 0 ? GPS_GONE : GPS_ERROR);
} else {
/* Here's where updates go now that things are established. */
#ifdef TRUENORTH
if (compass_flag)
update_compass_panel(&gpsdata);
else
#endif /* TRUENORTH */
update_gps_panel(&gpsdata);
}
}
/* Check for user input. */
c = wgetch(datawin);
switch (c) {
/* Quit */
case 'q':
die(CGPS_QUIT);
break;
/* Toggle spewage of raw gpsd data. */
case 's':
silent_flag = !silent_flag;
break;
/* Clear the spewage area. */
case 'c':
(void)werase(messages);
break;
default:
break;
}
}
}
int main(int argc, char **argv)
{
int ch;
bool daemonize = false;
unsigned int flags = WATCH_ENABLE;
struct exportmethod_t *method = NULL;
progname = argv[0];
method = export_default();
if (method == NULL) {
(void)fprintf(stderr, "%s: no export methods.\n", progname);
exit(EXIT_FAILURE);
}
logfile = stdout;
while ((ch = getopt(argc, argv, "dD:e:f:hi:lm:V")) != -1) {
switch (ch) {
case 'd':
openlog(basename(progname), LOG_PID | LOG_PERROR, LOG_DAEMON);
daemonize = true;
break;
#ifdef CLIENTDEBUG_ENABLE
case 'D':
debug = atoi(optarg);
gps_enable_debug(debug, logfile);
break;
#endif /* CLIENTDEBUG_ENABLE */
case 'e':
method = export_lookup(optarg);
if (method == NULL) {
(void)fprintf(stderr,
"%s: %s is not a known export method.\n",
progname, optarg);
exit(EXIT_FAILURE);
}
break;
case 'f': /* Output file name. */
{
char *fname = NULL;
time_t t;
size_t s = 0;
size_t fnamesize = strlen(optarg);
t = time(NULL);
while (s == 0) {
char *newfname = realloc(fname, fnamesize);
if (newfname == NULL) {
syslog(LOG_ERR, "realloc failed.");
goto bailout;
} else {
fnamesize += 1024;
fname = newfname;
}
s = strftime(fname, fnamesize-1, optarg, localtime(&t));
}
fname[s] = '\0';;
logfile = fopen(fname, "w");
if (logfile == NULL)
syslog(LOG_ERR,
"Failed to open %s: %s, logging to stdout.",
fname, strerror(errno));
bailout:
free(fname);
break;
}
case 'i': /* set polling interfal */
timeout = (time_t) atoi(optarg);
if (timeout < 1)
timeout = 1;
if (timeout >= 3600)
fprintf(stderr,
"WARNING: track timeout is an hour or more!\n");
break;
case 'l':
export_list(stderr);
exit(EXIT_SUCCESS);
case 'm':
minmove = (double )atoi(optarg);
break;
case 'V':
(void)fprintf(stderr, "%s: version %s (revision %s)\n",
progname, VERSION, REVISION);
exit(EXIT_SUCCESS);
default:
usage();
/* NOTREACHED */
}
}
if (daemonize && logfile == stdout) {
syslog(LOG_ERR, "Daemon mode with no valid logfile name - exiting.");
exit(EXIT_FAILURE);
}
if (method->magic != NULL) {
source.server = (char *)method->magic;
source.port = NULL;
source.device = NULL;
} else {
source.server = (char *)"localhost";
source.port = (char *)DEFAULT_GPSD_PORT;
source.device = NULL;
}
if (optind < argc) {
/* in this case, switch to the method "socket" always */
gpsd_source_spec(argv[optind], &source);
}
#if 0
(void)fprintf(logfile,"<!-- server: %s port: %s device: %s -->\n",
source.server, source.port, source.device);
#endif
/* catch all interesting signals */
(void)signal(SIGTERM, quit_handler);
(void)signal(SIGQUIT, quit_handler);
(void)signal(SIGINT, quit_handler);
/* might be time to daemonize */
if (daemonize) {
/* not SuS/POSIX portable, but we have our own fallback version */
if (daemon(0, 0) != 0)
(void) fprintf(stderr,"demonization failed: %s\n", strerror(errno));
}
//syslog (LOG_INFO, "---------- STARTED ----------");
if (gps_open(source.server, source.port, &gpsdata) != 0) {
(void)fprintf(stderr,
"%s: no gpsd running or network error: %d, %s\n",
progname, errno, gps_errstr(errno));
exit(EXIT_FAILURE);
}
if (source.device != NULL)
flags |= WATCH_DEVICE;
(void)gps_stream(&gpsdata, flags, source.device);
print_gpx_header();
(void)gps_mainloop(&gpsdata, 5000000, conditionally_log_fix);
print_gpx_footer();
(void)gps_close(&gpsdata);
exit(EXIT_SUCCESS);
}
