summaryrefslogtreecommitdiff
path: root/gpspipe.c
blob: 69dfcd9119c5ca093bef5339d75bd0e3aeafe411 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
/* $Id$ */
/*
 * gpspipe
 *
 * a simple program to connect to a gpsd daemon and dump the received data
 * to stdout
 *
 * This will dump the raw NMEA from gpsd to stdout
 *      gpspipe -r
 *
 * This will dump the super-raw data (gps binary) from gpsd to stdout
 *      gpspipe -R
 *
 * This will dump the GPSD sentences from gpsd to stdout
 *      gpspipe -w
 *
 * This will dump the GPSD and the NMEA sentences from gpsd to stdout
 *      gpspipe -wr
 *
 * Original code by: Gary E. Miller <gem@rellim.com>.  Cleanup by ESR.
 * All rights given to the gpsd project to release under whatever open source
 * license they use.  A thank you would be nice if you use this code.
 */

#include <stdlib.h>
#include "gpsd_config.h"
#include <sys/types.h>
#include <sys/stat.h>
#ifndef S_SPLINT_S
 #if HAVE_SYS_SOCKET_H
  #include <sys/socket.h>
 #endif /* HAVE_SYS_SOCKET_H */
#include <unistd.h>
#endif /* S_SPLINT_S */
#include <errno.h>
#include <stdio.h>
#include <string.h>
#include <stdbool.h>
#include <fcntl.h>
#if HAVE_TERMIOS
 #include <termios.h>
#endif /* HAVE_TERMIOS */
#include <assert.h>
#include "gpsd.h"
#include "gpsdclient.h"
#include "revision.h"

static struct gps_data_t *gpsdata;
static void spinner(unsigned int, unsigned int);

/* NMEA-0183 standard baud rate */
#define BAUDRATE B4800

/* Serial port variables */
static struct termios oldtio, newtio;
static int fd_out = 1;		/* output initially goes to standard output */ 
static char serbuf[255];
static int debug;

static void daemonize(void) 
/* Daemonize me. */
{
    int i;
    pid_t pid;

    /* Run as my child. */
    pid=fork();
    if (pid == -1) exit(1); /* fork error */
    if (pid>0) exit(0); /* parent exits */

    /* Obtain a new process group. */
    (void)setsid();

    /* Close all open descriptors. */
    for(i=getdtablesize();i>=0;--i)
	(void)close(i);

    /* Reopen STDIN, STDOUT, STDERR to /dev/null. */
    i=open("/dev/null",O_RDWR);	/* STDIN */
    /*@ -sefparams @*/
    assert(dup(i) != -1); 	/* STDOUT */
    assert(dup(i) != -1);		/* STDERR */

    /* Know thy mask. */
    (void)umask(0x033);

    /* Run from a known spot. */
    assert(chdir("/") != -1);
    /*@ +sefparams @*/

    /* Catch child sig */
    (void)signal(SIGCHLD,SIG_IGN);

    /* Ignore tty signals */
    (void)signal(SIGTSTP,SIG_IGN);
    (void)signal(SIGTTOU,SIG_IGN);
    (void)signal(SIGTTIN,SIG_IGN);
}

static void open_serial(char* device)
/* open the serial port and set it up */
{
    /* 
     * Open modem device for reading and writing and not as controlling
     * tty.
     */
    if ((fd_out = open(device, O_RDWR|O_NOCTTY)) == -1) {
	fprintf(stderr, "gpspipe: error opening serial port\n");
	exit(1);
    }

    /* Save current serial port settings for later */
    if (tcgetattr(fd_out, &oldtio) != 0) {
	fprintf(stderr, "gpspipe: error reading serial port settings\n");
	exit(1);
    }

    /* Clear struct for new port settings. */
    /*@i@*/bzero(&newtio, sizeof(newtio));

    /* make it raw */
    (void)cfmakeraw(&newtio);
    /* set speed */
    /*@i@*/(void)cfsetospeed(&newtio, BAUDRATE);

    /* Clear the modem line and activate the settings for the port. */
    (void)tcflush(fd_out,TCIFLUSH);
    if (tcsetattr(fd_out,TCSANOW,&newtio) != 0) {
	(void)fprintf(stderr, "gpspipe: error configuring serial port\n");
	exit(1);
    }
}

static void usage(void)
{
    (void)fprintf(stderr, "Usage: gpspipe [OPTIONS] [server[:port[:device]]]\n\n"
		  "-d Run as a daemon.\n"
		  "-f [file] Write output to file.\n"
		  "-h Show this help.\n"
		  "-r Dump raw NMEA.\n"
		  "-R Dump super-raw mode (GPS binary).\n"
		  "-w Dump gpsd native data.\n"
		  "-l Sleep for ten seconds before connecting to gpsd.\n"
		  "-t Time stamp the data.\n"
		  "-s [serial dev] emulate a 4800bps NMEA GPS on serial port (use with '-r').\n"
		  "-n [count] exit after count packets.\n"
		  "-v Print a little spinner.\n"
		  "-V Print version and exit.\n\n"
		  "You must specify one, or both, of -r/-w.\n"
		  "You must use -f if you use -d.\n"
	);
}

int main( int argc, char **argv)
{
    char buf[4096];
    bool timestamp = false;
    bool daemon = false;
    bool binary = false;
    bool sleepy = false;
    bool new_line = true;
    bool raw = false;
    bool watch = false;
    long count = -1;
    int option;
    unsigned int vflag = 0, l = 0;
    FILE * fp;
    unsigned int flags;

    struct fixsource_t source;
    char *port = DEFAULT_GPSD_PORT, *server = NULL;
    char *serialport = NULL;
    char *outfile = NULL;

    flags = WATCH_ENABLE;
    while ((option = getopt(argc, argv, "?dD:lhrRwtvVn:s:o:")) != -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':
	    daemon = true;
	    break;
	case 'l':
	    sleepy = true;
	    break;
	case 't':
	    timestamp = true;
	    break;
	case 'v':
	    vflag++;
	    break;
	case 'w':
	    flags |= WATCH_JSON;
	    watch = true;
	    break;
	case 'V':
	    (void)fprintf(stderr, "%s: %s (revision %s)\n", 
			  argv[0], VERSION, REVISION);
	    exit(0);
	case 's':
	    serialport = optarg;
	    break;
	case 'o':
	    outfile = optarg;
	    break;
	case '?':
	case 'h':
	default:
	    usage();
	    exit(1);
	}
    }

    /* 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(1);
    }

    if (outfile==NULL && daemon) {
	(void)fprintf(stderr, "gpspipe: use of '-d' requires '-f'.\n");
	exit(1);
    }

    if (!raw && !watch && !binary) {
	(void)fprintf(stderr, "gpspipe: one of '-R', '-r' or '-w' is required.\n");
	exit(1);
    }

    /* Daemonize if the user requested it. */
    if (daemon)
      daemonize();

    /* 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(1);
      }
    }

    /* Open the serial port and set it up. */
    if (serialport)
	open_serial(serialport);

    /*@ -nullpass -onlytrans @*/
    gpsdata = gps_open(server, port);
    if (gpsdata == NULL) {
	(void)fprintf(stderr,
		      "gpspipe: could not connect to gpsd %s:%s, %s(%d)\n",
		      server, port, strerror(errno), errno);
	exit(1);
    }
    /*@ +nullpass +onlytrans @*/

    if (source.device != NULL)
	flags |= WATCH_DEVICE;
    (void)gps_stream(gpsdata, flags, source.device);

    if ((isatty(STDERR_FILENO) == 0) || daemon)
	vflag = 0;

    for(;;) {
	int i = 0;
	int j = 0;
	int readbytes = 0;

	if (vflag)
	    spinner(vflag, l++);

	/* reading directly from the socket avoides decode overhead */
	readbytes = (int)read(gpsdata->gps_fd, buf, sizeof(buf));
	if (readbytes > 0) {
	    for (i = 0 ; i < readbytes ; i++) {
		char c = buf[i];
		if (j < (int)(sizeof(serbuf) - 1)) {
		    serbuf[j++] = buf[i];
		}
		if (new_line && timestamp) {
		    time_t now = time(NULL);

		    new_line = 0;
		    if (fprintf(fp, "%.24s :", ctime(&now)) <= 0) {
			(void)fprintf(stderr,
				      "gpspipe: write error, %s(%d)\n",
				      strerror(errno), errno);
			exit(1);
		    }
		}
		if (fputc(c, fp) == EOF) {
		    fprintf( stderr, "gpspipe: Write Error, %s(%d)\n",
			     strerror(errno), errno);
		    exit(1);
		}

		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(1);
			}
			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(1);
		    }
		    if (count > 0) {
			if (0 >= --count) {
			    /* completed count */
			    exit(0);
			}
		    }
		}
	    }
	} else {
	    if (readbytes == -1) {
		(void) fprintf(stderr, "gpspipe: read error %s(%d)\n",
			    strerror(errno), errno);
		exit(1);
	    } else {
		exit(0);
	    }
	}
    }

#ifdef __UNUSED__
    if (serialport != NULL) {
	/* Restore the old serial port settings. */
	if (tcsetattr(fd_out, TCSANOW, &oldtio) != 0) {
	    (void)fprintf(stderr, "Error restoring serial port settings\n");
	    exit(1);
	}
    }
#endif /* __UNUSED__ */

    exit(0);
}

static void spinner (unsigned int v, unsigned int num) {
    char *spin = "|/-\\";

    (void)fprintf(stderr, "\010%c", spin[(num/(1<<(v-1))) % 4]);
    (void)fflush(stderr);
    return;
}