source: ntrip/trunk/ntripserver/ntripserver.c@ 6949

Last change on this file since 6949 was 2276, checked in by stoecker, 15 years ago

fixed debug stuff
File size: 72.0 KB
Line 
1/*
2 * $Id: ntripserver.c,v 1.50 2010/01/21 09:00:49 stoecker Exp $
3 *
4 * Copyright (c) 2003...2007
5 * German Federal Agency for Cartography and Geodesy (BKG)
6 *
7 * Developed for Networked Transport of RTCM via Internet Protocol (NTRIP)
8 * for streaming GNSS data over the Internet.
9 *
10 * Designed by Informatik Centrum Dortmund http://www.icd.de
11 *
12 * The BKG disclaims any liability nor responsibility to any person or
13 * entity with respect to any loss or damage caused, or alleged to be
14 * caused, directly or indirectly by the use and application of the NTRIP
15 * technology.
16 *
17 * For latest information and updates, access:
18 * http://igs.bkg.bund.de/index_ntrip_down.htm
19 *
20 * BKG, Frankfurt, Germany, February 2007
21 * E-mail: euref-ip@bkg.bund.de
22 *
23 * This program is free software; you can redistribute it and/or
24 * modify it under the terms of the GNU General Public License
25 * as published by the Free Software Foundation; either version 2
26 * of the License, or (at your option) any later version.
27 *
28 * This program is distributed in the hope that it will be useful,
29 * but WITHOUT ANY WARRANTY; without even the implied warranty of
30 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
31 * GNU General Public License for more details.
32 *
33 * You should have received a copy of the GNU General Public License
34 * along with this program; if not, write to the Free Software
35 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
36 */
37
38/* CVS revision and version */
39static char revisionstr[] = "$Revision: 1.50 $";
40static char datestr[] = "$Date: 2010/01/21 09:00:49 $";
41
42#include <ctype.h>
43#include <errno.h>
44#include <fcntl.h>
45#include <getopt.h>
46#include <stdio.h>
47#include <stdlib.h>
48#include <string.h>
49#include <sys/time.h>
50#include <sys/types.h>
51#include <time.h>
52#include <signal.h>
53#include <unistd.h>
54
55#ifdef WINDOWSVERSION
56 #include <winsock2.h>
57 #include <io.h>
58 #include <sys/stat.h>
59 #include <windows.h>
60 typedef SOCKET sockettype;
61 typedef u_long in_addr_t;
62 typedef size_t socklen_t;
63 typedef u_short uint16_t;
64#else
65 typedef int sockettype;
66 #include <arpa/inet.h>
67 #include <sys/socket.h>
68 #include <netinet/in.h>
69 #include <netdb.h>
70 #include <sys/termios.h>
71 #define closesocket(sock) close(sock)
72 #define INVALID_HANDLE_VALUE -1
73 #define INVALID_SOCKET -1
74#endif
75
76#ifndef COMPILEDATE
77#define COMPILEDATE " built " __DATE__
78#endif
79
80#define ALARMTIME (2*60)
81
82#ifndef MSG_DONTWAIT
83#define MSG_DONTWAIT 0 /* prevent compiler errors */
84#endif
85#ifndef O_EXLOCK
86#define O_EXLOCK 0 /* prevent compiler errors */
87#endif
88
89enum MODE { SERIAL = 1, TCPSOCKET = 2, INFILE = 3, SISNET = 4, UDPSOCKET = 5,
90CASTER = 6, LAST };
91
92enum OUTMODE { HTTP = 1, RTSP = 2, NTRIP1 = 3, UDP = 4, END };
93
94#define AGENTSTRING "NTRIP NtripServerPOSIX"
95#define BUFSZ 1024
96#define SZ 64
97
98/* default socket source */
99#define SERV_HOST_ADDR "localhost"
100#define SERV_TCP_PORT 2101
101
102/* default destination */
103#define NTRIP_CASTER "www.euref-ip.net"
104#define NTRIP_PORT 2101
105
106#define SISNET_SERVER "131.176.49.142"
107#define SISNET_PORT 7777
108
109#define RTP_VERSION 2
110#define TIME_RESOLUTION 125
111
112static int ttybaud = 19200;
113#ifndef WINDOWSVERSION
114static const char *ttyport = "/dev/gps";
115#else
116static const char *ttyport = "COM1";
117#endif
118static const char *filepath = "/dev/stdin";
119static enum MODE inputmode = INFILE;
120static int sisnet = 31;
121static int gps_file = -1;
122static sockettype gps_socket = INVALID_SOCKET;
123static sockettype socket_tcp = INVALID_SOCKET;
124static sockettype socket_udp = INVALID_SOCKET;
125#ifndef WINDOWSVERSION
126static int gps_serial = INVALID_HANDLE_VALUE;
127static int sigpipe_received = 0;
128#else
129HANDLE gps_serial = INVALID_HANDLE_VALUE;
130#endif
131static int sigalarm_received = 0;
132static int sigint_received = 0;
133static int reconnect_sec = 1;
134static const char * casterouthost = NTRIP_CASTER;
135static char rtsp_extension[SZ] = "";
136static const char * mountpoint = NULL;
137static int udp_cseq = 1;
138static int udp_tim, udp_seq, udp_init;
139
140/* Forward references */
141static void send_receive_loop(sockettype sock, int outmode,
142 struct sockaddr * pcasterRTP, socklen_t length, unsigned int rtpssrc);
143static void usage(int, char *);
144static int encode(char *buf, int size, const char *user, const char *pwd);
145static int send_to_caster(char *input, sockettype socket, int input_size);
146static void close_session(const char *caster_addr, const char *mountpoint,
147 int session, char *rtsp_ext, int fallback);
148static int reconnect(int rec_sec, int rec_sec_max);
149static void handle_sigint(int sig);
150static void setup_signal_handler(int sig, void (*handler)(int));
151#ifndef WINDOWSVERSION
152static int openserial(const char * tty, int blocksz, int baud);
153static void handle_sigpipe(int sig);
154static void handle_alarm(int sig);
155#else
156static HANDLE openserial(const char * tty, int baud);
157#endif
158
159
160/*
161* main
162*
163* Main entry point for the program. Processes command-line arguments and
164* prepares for action.
165*
166* Parameters:
167* argc : integer : Number of command-line arguments.
168* argv : array of char : Command-line arguments as an array of
169* zero-terminated pointers to strings.
170*
171* Return Value:
172* The function does not return a value (although its return type is int).
173*
174* Remarks:
175*
176*/
177int main(int argc, char **argv)
178{
179 int c;
180 int size = 2048; /* for setting send buffer size */
181 struct sockaddr_in caster;
182 const char * proxyhost = "";
183 unsigned int proxyport = 0;
184 /*** INPUT ***/
185 const char * casterinhost = 0;
186 unsigned int casterinport = 0;
187 const char * inhost = 0;
188 unsigned int inport = 0;
189
190 char get_extension[SZ] = "";
191
192 struct hostent * he;
193
194 const char * sisnetpassword = "";
195 const char * sisnetuser = "";
196
197 const char * stream_name = 0;
198 const char * stream_user = 0;
199 const char * stream_password = 0;
200
201 const char * recvrid= 0;
202 const char * recvrpwd = 0;
203
204 const char * initfile = NULL;
205
206 int bindmode = 0;
207
208 /*** OUTPUT ***/
209 unsigned int casteroutport = NTRIP_PORT;
210 const char * outhost = 0;
211 unsigned int outport = 0;
212 char post_extension[SZ] = "";
213
214 const char * ntrip_str = "";
215
216 const char * user = "";
217 const char * password = "";
218
219 int outputmode = NTRIP1;
220
221 struct sockaddr_in casterRTP;
222 struct sockaddr_in local;
223 int client_port = 0;
224 int server_port = 0;
225 unsigned int session = 0;
226 socklen_t len = 0;
227 int i = 0;
228
229 char szSendBuffer[BUFSZ];
230 char authorization[SZ];
231 int nBufferBytes = 0;
232 char * dlim = " \r\n=";
233 char * token;
234 char * tok_buf[BUFSZ];
235
236 int reconnect_sec_max = 0;
237
238 setbuf(stdout, 0);
239 setbuf(stdin, 0);
240 setbuf(stderr, 0);
241
242 {
243 char *a;
244 int i = 0;
245 for(a = revisionstr+11; *a && *a != ' '; ++a)
246 revisionstr[i++] = *a;
247 revisionstr[i] = 0;
248 datestr[0] = datestr[7];
249 datestr[1] = datestr[8];
250 datestr[2] = datestr[9];
251 datestr[3] = datestr[10];
252 datestr[5] = datestr[12];
253 datestr[6] = datestr[13];
254 datestr[8] = datestr[15];
255 datestr[9] = datestr[16];
256 datestr[4] = datestr[7] = '-';
257 datestr[10] = 0;
258 }
259
260 /* setup signal handler for CTRL+C */
261 setup_signal_handler(SIGINT, handle_sigint);
262#ifndef WINDOWSVERSION
263 /* setup signal handler for boken pipe */
264 setup_signal_handler(SIGPIPE, handle_sigpipe);
265 /* setup signal handler for timeout */
266 setup_signal_handler(SIGALRM, handle_alarm);
267 alarm(ALARMTIME);
268#else
269 /* winsock initialization */
270 WSADATA wsaData;
271 if (WSAStartup(MAKEWORD(1,1), &wsaData))
272 {
273 fprintf(stderr, "Could not init network access.\n");
274 return 20;
275 }
276#endif
277
278 /* get and check program arguments */
279 if(argc <= 1)
280 {
281 usage(2, argv[0]);
282 exit(1);
283 }
284 while((c = getopt(argc, argv,
285 "M:i:h:b:p:s:a:m:c:H:P:f:x:y:l:u:V:D:U:W:O:E:F:R:N:n:B")) != EOF)
286 {
287 switch (c)
288 {
289 case 'M': /*** InputMode ***/
290 if(!strcmp(optarg, "serial")) inputmode = SERIAL;
291 else if(!strcmp(optarg, "tcpsocket")) inputmode = TCPSOCKET;
292 else if(!strcmp(optarg, "file")) inputmode = INFILE;
293 else if(!strcmp(optarg, "sisnet")) inputmode = SISNET;
294 else if(!strcmp(optarg, "udpsocket")) inputmode = UDPSOCKET;
295 else if(!strcmp(optarg, "caster")) inputmode = CASTER;
296 else inputmode = atoi(optarg);
297 if((inputmode == 0) || (inputmode >= LAST))
298 {
299 fprintf(stderr, "ERROR: can't convert <%s> to a valid InputMode\n",
300 optarg);
301 usage(-1, argv[0]);
302 }
303 break;
304 case 'i': /* serial input device */
305 ttyport = optarg;
306 break;
307 case 'B': /* bind to incoming UDP stream */
308 bindmode = 1;
309 break;
310 case 'V': /* Sisnet data server version number */
311 if(!strcmp("3.0", optarg)) sisnet = 30;
312 else if(!strcmp("3.1", optarg)) sisnet = 31;
313 else if(!strcmp("2.1", optarg)) sisnet = 21;
314 else
315 {
316 fprintf(stderr, "ERROR: unknown SISNeT version <%s>\n", optarg);
317 usage(-2, argv[0]);
318 }
319 break;
320 case 'b': /* serial input baud rate */
321 ttybaud = atoi(optarg);
322 if(ttybaud <= 1)
323 {
324 fprintf(stderr, "ERROR: can't convert <%s> to valid serial baud rate\n",
325 optarg);
326 usage(1, argv[0]);
327 }
328 break;
329 case 'a': /* Destination caster address */
330 casterouthost = optarg;
331 break;
332 case 'p': /* Destination caster port */
333 casteroutport = atoi(optarg);
334 if(casteroutport <= 1 || casteroutport > 65535)
335 {
336 fprintf(stderr,
337 "ERROR: can't convert <%s> to a valid HTTP server port\n", optarg);
338 usage(1, argv[0]);
339 }
340 break;
341 case 'm': /* Destination caster mountpoint for stream upload */
342 mountpoint = optarg;
343 break;
344 case 's': /* File name for input data simulation from file */
345 filepath = optarg;
346 break;
347 case 'f': /* name of an initialization file */
348 initfile = optarg;
349 break;
350 case 'x': /* user ID to access incoming stream */
351 recvrid = optarg;
352 break;
353 case 'y': /* password to access incoming stream */
354 recvrpwd = optarg;
355 break;
356 case 'u': /* Sisnet data server user ID */
357 sisnetuser = optarg;
358 break;
359 case 'l': /* Sisnet data server password */
360 sisnetpassword = optarg;
361 break;
362 case 'c': /* DestinationCaster password for stream upload to mountpoint */
363 password = optarg;
364 break;
365 case 'H': /* Input host address*/
366 casterinhost = optarg;
367 break;
368 case 'P': /* Input port */
369 casterinport = atoi(optarg);
370 if(casterinport <= 1 || casterinport > 65535)
371 {
372 fprintf(stderr, "ERROR: can't convert <%s> to a valid port number\n",
373 optarg);
374 usage(1, argv[0]);
375 }
376 break;
377 case 'D': /* Source caster mountpoint for stream input */
378 stream_name = optarg;
379 break;
380 case 'U': /* Source caster user ID for input stream access */
381 stream_user = optarg;
382 break;
383 case 'W': /* Source caster password for input stream access */
384 stream_password = optarg;
385 break;
386 case 'E': /* Proxy Server */
387 proxyhost = optarg;
388 break;
389 case 'F': /* Proxy port */
390 proxyport = atoi(optarg);
391 break;
392 case 'R': /* maximum delay between reconnect attempts in seconds */
393 reconnect_sec_max = atoi(optarg);
394 break;
395 case 'O': /* OutputMode */
396 outputmode = 0;
397 if (!strcmp(optarg,"n") || !strcmp(optarg,"ntrip1"))
398 outputmode = NTRIP1;
399 else if(!strcmp(optarg,"h") || !strcmp(optarg,"http"))
400 outputmode = HTTP;
401 else if(!strcmp(optarg,"r") || !strcmp(optarg,"rtsp"))
402 outputmode = RTSP;
403 else if(!strcmp(optarg,"u") || !strcmp(optarg,"udp"))
404 outputmode = UDP;
405 else outputmode = atoi(optarg);
406 if((outputmode == 0) || (outputmode >= END))
407 {
408 fprintf(stderr, "ERROR: can't convert <%s> to a valid OutputMode\n",
409 optarg);
410 usage(-1, argv[0]);
411 }
412 break;
413 case 'n': /* Destination caster user ID for stream upload to mountpoint */
414 user = optarg;
415 break;
416 case 'N': /* Ntrip-STR, optional for Ntrip Version 2.0 */
417 ntrip_str = optarg;
418 break;
419 case 'h': /* print help screen */
420 case '?':
421 usage(0, argv[0]);
422 break;
423 default:
424 usage(2, argv[0]);
425 break;
426 }
427 }
428
429 argc -= optind;
430 argv += optind;
431
432 /*** argument analysis ***/
433 if(argc > 0)
434 {
435 fprintf(stderr, "ERROR: Extra args on command line: ");
436 for(; argc > 0; argc--)
437 {
438 fprintf(stderr, " %s", *argv++);
439 }
440 fprintf(stderr, "\n");
441 usage(1, argv[0]); /* never returns */
442 }
443
444 if((reconnect_sec_max > 0) && (reconnect_sec_max < 256))
445 {
446 fprintf(stderr,
447 "WARNING: maximum delay between reconnect attemts changed from %d to 256 seconds\n"
448 , reconnect_sec_max);
449 reconnect_sec_max = 256;
450 }
451
452 if(!mountpoint)
453 {
454 fprintf(stderr, "ERROR: Missing mountpoint argument for stream upload\n");
455 exit(1);
456 }
457
458 if(!password[0])
459 {
460 fprintf(stderr, "WARNING: Missing password argument for stream upload - "
461 "are you really sure?\n");
462 }
463 else
464 {
465 nBufferBytes += encode(authorization, sizeof(authorization), user,
466 password);
467 if(nBufferBytes > (int)sizeof(authorization))
468 {
469 fprintf(stderr, "ERROR: user ID and/or password too long: %d (%d)\n"
470 " user ID: %s \npassword: <%s>\n",
471 nBufferBytes, (int)sizeof(authorization), user, password);
472 exit(1);
473 }
474 }
475
476 if(stream_name && stream_user && !stream_password)
477 {
478 fprintf(stderr, "WARNING: Missing password argument for stream download"
479 " - are you really sure?\n");
480 }
481
482 /*** proxy server handling ***/
483 if(*proxyhost)
484 {
485 outhost = inhost = proxyhost;
486 outport = inport = proxyport;
487 i = snprintf(szSendBuffer, sizeof(szSendBuffer),"http://%s:%d",
488 casterouthost, casteroutport);
489 if((i > SZ) || (i < 0))
490 {
491 fprintf(stderr, "ERROR: Destination caster name/port to long - "
492 "length = %d (max: %d)\n", i, SZ);
493 exit(0);
494 }
495 else
496 {
497 strncpy(post_extension, szSendBuffer, (size_t)i);
498 strcpy(szSendBuffer, "");
499 i = snprintf(szSendBuffer, sizeof(szSendBuffer),":%d", casteroutport);
500 strncpy(rtsp_extension, szSendBuffer, SZ);
501 strcpy(szSendBuffer,""); i = 0;
502 }
503 i = snprintf(szSendBuffer, sizeof(szSendBuffer),"http://%s:%d", casterinhost, casterinport);
504 if((i > SZ) || (i < 0))
505 {
506 fprintf(stderr,"ERROR: Destination caster name/port to long - length = %d (max: %d)\n", i, SZ);
507 exit(0);
508 }
509 else
510 {
511 strncpy(get_extension, szSendBuffer, (size_t)i);
512 strcpy(szSendBuffer, "");
513 i = 0;
514 }
515 }
516 else
517 {
518 outhost = casterouthost; outport = casteroutport;
519 inhost = casterinhost; inport = casterinport;
520 }
521
522 while(inputmode != LAST)
523 {
524 int input_init = 1;
525 if(sigint_received) break;
526 /*** InputMode handling ***/
527 switch(inputmode)
528 {
529 case INFILE:
530 {
531 if((gps_file = open(filepath, O_RDONLY)) < 0)
532 {
533 perror("ERROR: opening input file");
534 exit(1);
535 }
536#ifndef WINDOWSVERSION
537 /* set blocking inputmode in case it was not set
538 (seems to be sometimes for fifo's) */
539 fcntl(gps_file, F_SETFL, 0);
540#endif
541 printf("file input: file = %s\n", filepath);
542 }
543 break;
544 case SERIAL: /* open serial port */
545 {
546#ifndef WINDOWSVERSION
547 gps_serial = openserial(ttyport, 1, ttybaud);
548#else
549 gps_serial = openserial(ttyport, ttybaud);
550#endif
551 if(gps_serial == INVALID_HANDLE_VALUE) exit(1);
552 printf("serial input: device = %s, speed = %d\n", ttyport, ttybaud);
553
554 if(initfile)
555 {
556 char buffer[1024];
557 FILE *fh;
558 int i;
559
560 if((fh = fopen(initfile, "r")))
561 {
562 while((i = fread(buffer, 1, sizeof(buffer), fh)) > 0)
563 {
564#ifndef WINDOWSVERSION
565 if((write(gps_serial, buffer, i)) != i)
566 {
567 perror("WARNING: sending init file");
568 input_init = 0;
569 break;
570 }
571#else
572 DWORD nWrite = -1;
573 if(!WriteFile(gps_serial, buffer, sizeof(buffer), &nWrite, NULL))
574 {
575 fprintf(stderr,"ERROR: sending init file \n");
576 input_init = 0;
577 break;
578 }
579 i = (int)nWrite;
580#endif
581 }
582 if(i < 0)
583 {
584 perror("ERROR: reading init file");
585 reconnect_sec_max = 0;
586 input_init = 0;
587 break;
588 }
589 fclose(fh);
590 }
591 else
592 {
593 fprintf(stderr, "ERROR: can't read init file <%s>\n", initfile);
594 reconnect_sec_max = 0;
595 input_init = 0;
596 break;
597 }
598 }
599 }
600 break;
601 case TCPSOCKET: case UDPSOCKET: case SISNET: case CASTER:
602 {
603 if(inputmode == SISNET)
604 {
605 if(!inhost) inhost = SISNET_SERVER;
606 if(!inport) inport = SISNET_PORT;
607 }
608 else if(inputmode == CASTER)
609 {
610 if(!inport) inport = NTRIP_PORT;
611 if(!inhost) inhost = NTRIP_CASTER;
612 }
613 else if((inputmode == TCPSOCKET) || (inputmode == UDPSOCKET))
614 {
615 if(!inport) inport = SERV_TCP_PORT;
616 if(!inhost) inhost = SERV_HOST_ADDR;
617 }
618
619 if(!(he = gethostbyname(inhost)))
620 {
621 fprintf(stderr, "ERROR: Input host <%s> unknown\n", inhost);
622 usage(-2, argv[0]);
623 }
624
625 if((gps_socket = socket(AF_INET, inputmode == UDPSOCKET
626 ? SOCK_DGRAM : SOCK_STREAM, 0)) == INVALID_SOCKET)
627 {
628 fprintf(stderr,
629 "ERROR: can't create socket for incoming data stream\n");
630 exit(1);
631 }
632
633 memset((char *) &caster, 0x00, sizeof(caster));
634 if(!bindmode)
635 memcpy(&caster.sin_addr, he->h_addr, (size_t)he->h_length);
636 caster.sin_family = AF_INET;
637 caster.sin_port = htons(inport);
638
639 fprintf(stderr, "%s input: host = %s, port = %d, %s%s%s%s%s\n",
640 inputmode == CASTER ? "caster" : inputmode == SISNET ? "sisnet" :
641 inputmode == TCPSOCKET ? "tcp socket" : "udp socket",
642 bindmode ? "127.0.0.1" : inet_ntoa(caster.sin_addr),
643 inport, stream_name ? "stream = " : "", stream_name ? stream_name : "",
644 initfile ? ", initfile = " : "", initfile ? initfile : "",
645 bindmode ? "binding mode" : "");
646
647 if(bindmode)
648 {
649 if(bind(gps_socket, (struct sockaddr *) &caster, sizeof(caster)) < 0)
650 {
651 fprintf(stderr, "ERROR: can't bind input to port %d\n", inport);
652 reconnect_sec_max = 0;
653 input_init = 0;
654 break;
655 }
656 } /* connect to input-caster or proxy server*/
657 else if(connect(gps_socket, (struct sockaddr *)&caster, sizeof(caster)) < 0)
658 {
659 fprintf(stderr, "WARNING: can't connect input to %s at port %d\n",
660 inet_ntoa(caster.sin_addr), inport);
661 input_init = 0;
662 break;
663 }
664
665 if(stream_name) /* input from Ntrip Version 1.0 caster*/
666 {
667 int init = 0;
668
669 /* set socket buffer size */
670 setsockopt(gps_socket, SOL_SOCKET, SO_SNDBUF, (const char *) &size,
671 sizeof(const char *));
672 if(stream_user && stream_password)
673 {
674 /* leave some space for login */
675 nBufferBytes=snprintf(szSendBuffer, sizeof(szSendBuffer)-40,
676 "GET %s/%s HTTP/1.0\r\n"
677 "User-Agent: %s/%s\r\n"
678 "Connection: close\r\n"
679 "Authorization: Basic ", get_extension, stream_name,
680 AGENTSTRING, revisionstr);
681 /* second check for old glibc */
682 if(nBufferBytes > (int)sizeof(szSendBuffer)-40 || nBufferBytes < 0)
683 {
684 fprintf(stderr, "ERROR: Source caster request too long\n");
685 input_init = 0;
686 reconnect_sec_max =0;
687 break;
688 }
689 nBufferBytes += encode(szSendBuffer+nBufferBytes,
690 sizeof(szSendBuffer)-nBufferBytes-4, stream_user, stream_password);
691 if(nBufferBytes > (int)sizeof(szSendBuffer)-4)
692 {
693 fprintf(stderr,
694 "ERROR: Source caster user ID and/or password too long\n");
695 input_init = 0;
696 reconnect_sec_max =0;
697 break;
698 }
699 szSendBuffer[nBufferBytes++] = '\r';
700 szSendBuffer[nBufferBytes++] = '\n';
701 szSendBuffer[nBufferBytes++] = '\r';
702 szSendBuffer[nBufferBytes++] = '\n';
703 }
704 else
705 {
706 nBufferBytes = snprintf(szSendBuffer, sizeof(szSendBuffer),
707 "GET %s/%s HTTP/1.0\r\n"
708 "User-Agent: %s/%s\r\n"
709 "Connection: close\r\n"
710 "\r\n", get_extension, stream_name, AGENTSTRING, revisionstr);
711 }
712 if((send(gps_socket, szSendBuffer, (size_t)nBufferBytes, 0))
713 != nBufferBytes)
714 {
715 fprintf(stderr, "WARNING: could not send Source caster request\n");
716 input_init = 0;
717 break;
718 }
719 nBufferBytes = 0;
720 /* check Source caster's response */
721 while(!init && nBufferBytes < (int)sizeof(szSendBuffer)
722 && (nBufferBytes += recv(gps_socket, szSendBuffer,
723 sizeof(szSendBuffer)-nBufferBytes, 0)) > 0)
724 {
725 if(strstr(szSendBuffer, "\r\n"))
726 {
727 if(!strstr(szSendBuffer, "ICY 200 OK"))
728 {
729 int k;
730 fprintf(stderr,
731 "ERROR: could not get requested data from Source caster: ");
732 for(k = 0; k < nBufferBytes && szSendBuffer[k] != '\n'
733 && szSendBuffer[k] != '\r'; ++k)
734 {
735 fprintf(stderr, "%c", isprint(szSendBuffer[k])
736 ? szSendBuffer[k] : '.');
737 }
738 fprintf(stderr, "\n");
739 if(!strstr(szSendBuffer, "SOURCETABLE 200 OK"))
740 {
741 reconnect_sec_max =0;
742 }
743 input_init = 0;
744 break;
745 }
746 else init = 1;
747 }
748 }
749 } /* end input from Ntrip Version 1.0 caster */
750
751 if(initfile && inputmode != SISNET)
752 {
753 char buffer[1024];
754 FILE *fh;
755 int i;
756
757 if((fh = fopen(initfile, "r")))
758 {
759 while((i = fread(buffer, 1, sizeof(buffer), fh)) > 0)
760 {
761 if((send(gps_socket, buffer, (size_t)i, 0)) != i)
762 {
763 perror("WARNING: sending init file");
764 input_init = 0;
765 break;
766 }
767 }
768 if(i < 0)
769 {
770 perror("ERROR: reading init file");
771 reconnect_sec_max = 0;
772 input_init = 0;
773 break;
774 }
775 fclose(fh);
776 }
777 else
778 {
779 fprintf(stderr, "ERROR: can't read init file <%s>\n", initfile);
780 reconnect_sec_max = 0;
781 input_init = 0;
782 break;
783 }
784 }
785 }
786 if(inputmode == SISNET)
787 {
788 int i, j;
789 char buffer[1024];
790
791 i = snprintf(buffer, sizeof(buffer), sisnet >= 30 ? "AUTH,%s,%s\r\n"
792 : "AUTH,%s,%s", sisnetuser, sisnetpassword);
793 if((send(gps_socket, buffer, (size_t)i, 0)) != i)
794 {
795 perror("WARNING: sending authentication for SISNeT data server");
796 input_init = 0;
797 break;
798 }
799 i = sisnet >= 30 ? 7 : 5;
800 if((j = recv(gps_socket, buffer, i, 0)) != i && strncmp("*AUTH", buffer, 5))
801 {
802 fprintf(stderr, "WARNING: SISNeT connect failed:");
803 for(i = 0; i < j; ++i)
804 {
805 if(buffer[i] != '\r' && buffer[i] != '\n')
806 {
807 fprintf(stderr, "%c", isprint(buffer[i]) ? buffer[i] : '.');
808 }
809 }
810 fprintf(stderr, "\n");
811 input_init = 0;
812 break;
813 }
814 if(sisnet >= 31)
815 {
816 if((send(gps_socket, "START\r\n", 7, 0)) != i)
817 {
818 perror("WARNING: sending Sisnet start command");
819 input_init = 0;
820 break;
821 }
822 }
823 }
824 /*** receiver authentication ***/
825 if (recvrid && recvrpwd && ((inputmode == TCPSOCKET)
826 || (inputmode == UDPSOCKET)))
827 {
828 if (strlen(recvrid) > (BUFSZ-3))
829 {
830 fprintf(stderr, "ERROR: Receiver ID too long\n");
831 reconnect_sec_max = 0;
832 input_init = 0;
833 break;
834 }
835 else
836 {
837 fprintf(stderr, "Sending user ID for receiver...\n");
838 nBufferBytes = recv(gps_socket, szSendBuffer, BUFSZ, 0);
839 strcpy(szSendBuffer, recvrid);
840 strcat(szSendBuffer,"\r\n");
841 if(send(gps_socket,szSendBuffer, strlen(szSendBuffer), MSG_DONTWAIT) < 0)
842 {
843 perror("WARNING: sending user ID for receiver");
844 input_init = 0;
845 break;
846 }
847 }
848
849 if (strlen(recvrpwd) > (BUFSZ-3))
850 {
851 fprintf(stderr, "ERROR: Receiver password too long\n");
852 reconnect_sec_max = 0;
853 input_init = 0;
854 break;
855 }
856 else
857 {
858 fprintf(stderr, "Sending user password for receiver...\n");
859 nBufferBytes = recv(gps_socket, szSendBuffer, BUFSZ, 0);
860 strcpy(szSendBuffer, recvrpwd);
861 strcat(szSendBuffer,"\r\n");
862 if(send(gps_socket, szSendBuffer, strlen(szSendBuffer), MSG_DONTWAIT) < 0)
863 {
864 perror("WARNING: sending user password for receiver");
865 input_init = 0;
866 break;
867 }
868 }
869 }
870 break;
871 default:
872 usage(-1, argv[0]);
873 break;
874 }
875
876 /* ----- main part ----- */
877 int output_init = 1, fallback = 0;
878
879 while((input_init) && (output_init))
880 {
881#ifndef WINDOWSVERSION
882 if((sigalarm_received) || (sigint_received) || (sigpipe_received)) break;
883#else
884 if((sigalarm_received) || (sigint_received)) break;
885#endif
886 if(!(he = gethostbyname(outhost)))
887 {
888 fprintf(stderr, "ERROR: Destination caster or proxy host <%s> unknown\n",
889 outhost);
890 close_session(casterouthost, mountpoint, session, rtsp_extension, 0);
891 usage(-2, argv[0]);
892 }
893
894 /* create socket */
895 if((socket_tcp = socket(AF_INET, (outputmode == UDP ? SOCK_DGRAM
896 : SOCK_STREAM), 0)) == INVALID_SOCKET)
897 {
898 perror("ERROR: tcp socket");
899 reconnect_sec_max = 0;
900 break;
901 }
902
903 memset((char *) &caster, 0x00, sizeof(caster));
904 memcpy(&caster.sin_addr, he->h_addr, (size_t)he->h_length);
905 caster.sin_family = AF_INET;
906 caster.sin_port = htons(outport);
907
908 /* connect to Destination caster or Proxy server*/
909 fprintf(stderr, "caster output: host = %s, port = %d, mountpoint = %s"
910 ", mode = %s\n\n", inet_ntoa(caster.sin_addr), outport, mountpoint,
911 outputmode == NTRIP1 ? "ntrip1" : outputmode == HTTP ? "http" :
912 outputmode == UDP ? "udp" : "rtsp");
913
914 if(connect(socket_tcp, (struct sockaddr *) &caster, sizeof(caster)) < 0)
915 {
916 fprintf(stderr, "WARNING: can't connect output to %s at port %d\n",
917 inet_ntoa(caster.sin_addr), outport);
918 break;
919 }
920
921 /*** OutputMode handling ***/
922 switch(outputmode)
923 {
924 case UDP:
925 {
926 unsigned int session;
927 char rtpbuf[1526];
928 int i=12, j;
929
930 udp_init = time(0);
931 srand(udp_init);
932 session = rand();
933 udp_tim = rand();
934 udp_seq = rand();
935
936 rtpbuf[0] = (2<<6);
937 /* padding, extension, csrc are empty */
938 rtpbuf[1] = 97;
939 /* marker is empty */
940 rtpbuf[2] = (udp_seq>>8)&0xFF;
941 rtpbuf[3] = (udp_seq)&0xFF;
942 rtpbuf[4] = (udp_tim>>24)&0xFF;
943 rtpbuf[5] = (udp_tim>>16)&0xFF;
944 rtpbuf[6] = (udp_tim>>8)&0xFF;
945 rtpbuf[7] = (udp_tim)&0xFF;
946 /* sequence and timestamp are empty */
947 rtpbuf[8] = (session>>24)&0xFF;
948 rtpbuf[9] = (session>>16)&0xFF;
949 rtpbuf[10] = (session>>8)&0xFF;
950 rtpbuf[11] = (session)&0xFF;
951 ++udp_seq;
952
953 j = snprintf(rtpbuf+i, sizeof(rtpbuf)-i-40, /* leave some space for login */
954 "POST /%s HTTP/1.1\r\n"
955 "Host: %s\r\n"
956 "Ntrip-Version: Ntrip/2.0\r\n"
957 "User-Agent: %s/%s\r\n"
958 "Authorization: Basic %s%s%s\r\n"
959 "Connection: close\r\n"
960 "Transfer-Encoding: chunked\r\n\r\n",
961 mountpoint, casterouthost, AGENTSTRING,
962 revisionstr, authorization, ntrip_str ? (outputmode == NTRIP1 ? "\r\nSTR: " : "\r\nNtrip-STR: ") : "",
963 ntrip_str);
964 i += j;
965 if(i > (int)sizeof(rtpbuf)-40 || j < 0) /* second check for old glibc */
966 {
967 fprintf(stderr, "Requested data too long\n");
968 reconnect_sec_max = 0;
969 output_init = 0;
970 break;
971 }
972 else
973 {
974 rtpbuf[i++] = '\r';
975 rtpbuf[i++] = '\n';
976 rtpbuf[i++] = '\r';
977 rtpbuf[i++] = '\n';
978
979 if(send(socket_tcp, rtpbuf, i, 0) != i)
980 {
981 perror("Could not send UDP packet");
982 reconnect_sec_max = 0;
983 output_init = 0;
984 break;
985 }
986 else
987 {
988 int stop = 0;
989 int numbytes;
990 if((numbytes=recv(socket_tcp, rtpbuf, sizeof(rtpbuf)-1, 0)) > 0)
991 {
992 /* we don't expect message longer than 1513, so we cut the last
993 byte for security reasons to prevent buffer overrun */
994 rtpbuf[numbytes] = 0;
995 if(numbytes > 17+12 &&
996 (!strncmp(rtpbuf+12, "HTTP/1.1 200 OK\r\n", 17) ||
997 !strncmp(rtpbuf+12, "HTTP/1.0 200 OK\r\n", 17)))
998 {
999 const char *sessioncheck = "session: ";
1000 int l = strlen(sessioncheck)-1;
1001 int j=0;
1002 for(i = 12; j != l && i < numbytes-l; ++i)
1003 {
1004 for(j = 0; j < l && tolower(rtpbuf[i+j]) == sessioncheck[j]; ++j)
1005 ;
1006 }
1007 if(i != numbytes-l) /* found a session number */
1008 {
1009 i+=l;
1010 session = 0;
1011 while(i < numbytes && rtpbuf[i] >= '0' && rtpbuf[i] <= '9')
1012 session = session * 10 + rtpbuf[i++]-'0';
1013 if(rtpbuf[i] != '\r')
1014 {
1015 fprintf(stderr, "Could not extract session number\n");
1016 stop = 1;
1017 }
1018 }
1019 }
1020 else
1021 {
1022 int k;
1023 fprintf(stderr, "Could not access mountpoint: ");
1024 for(k = 12; k < numbytes && rtpbuf[k] != '\n' && rtpbuf[k] != '\r'; ++k)
1025 {
1026 fprintf(stderr, "%c", isprint(rtpbuf[k]) ? rtpbuf[k] : '.');
1027 }
1028 fprintf(stderr, "\n");
1029 stop = 1;
1030 }
1031 }
1032 if(!stop)
1033 {
1034 send_receive_loop(socket_tcp, outputmode, NULL, 0, session);
1035 input_init = output_init = 0;
1036 /* send connection close always to allow nice session closing */
1037 udp_tim += (time(0)-udp_init)*1000000/TIME_RESOLUTION;
1038 rtpbuf[0] = (2<<6);
1039 /* padding, extension, csrc are empty */
1040 rtpbuf[1] = 98;
1041 /* marker is empty */
1042 rtpbuf[2] = (udp_seq>>8)&0xFF;
1043 rtpbuf[3] = (udp_seq)&0xFF;
1044 rtpbuf[4] = (udp_tim>>24)&0xFF;
1045 rtpbuf[5] = (udp_tim>>16)&0xFF;
1046 rtpbuf[6] = (udp_tim>>8)&0xFF;
1047 rtpbuf[7] = (udp_tim)&0xFF;
1048 /* sequence and timestamp are empty */
1049 rtpbuf[8] = (session>>24)&0xFF;
1050 rtpbuf[9] = (session>>16)&0xFF;
1051 rtpbuf[10] = (session>>8)&0xFF;
1052 rtpbuf[11] = (session)&0xFF;
1053
1054 send(socket_tcp, rtpbuf, 12, 0); /* cleanup */
1055 }
1056 else
1057 {
1058 reconnect_sec_max = 600;
1059 output_init = 0;
1060 }
1061 }
1062 }
1063 }
1064 break;
1065 case NTRIP1: /*** OutputMode Ntrip Version 1.0 ***/
1066 fallback = 0;
1067 nBufferBytes = snprintf(szSendBuffer, sizeof(szSendBuffer),
1068 "SOURCE %s %s/%s\r\n"
1069 "Source-Agent: %s/%s\r\n\r\n",
1070 password, post_extension, mountpoint, AGENTSTRING, revisionstr);
1071 if((nBufferBytes > (int)sizeof(szSendBuffer)) || (nBufferBytes < 0))
1072 {
1073 fprintf(stderr, "ERROR: Destination caster request to long\n");
1074 reconnect_sec_max = 0;
1075 output_init = 0;
1076 break;
1077 }
1078 if(!send_to_caster(szSendBuffer, socket_tcp, nBufferBytes))
1079 {
1080 output_init = 0;
1081 break;
1082 }
1083 /* check Destination caster's response */
1084 nBufferBytes = recv(socket_tcp, szSendBuffer, sizeof(szSendBuffer), 0);
1085 szSendBuffer[nBufferBytes] = '\0';
1086 if(!strstr(szSendBuffer, "OK"))
1087 {
1088 char *a;
1089 fprintf(stderr,
1090 "ERROR: Destination caster's or Proxy's reply is not OK: ");
1091 for(a = szSendBuffer; *a && *a != '\n' && *a != '\r'; ++a)
1092 {
1093 fprintf(stderr, "%.1s", isprint(*a) ? a : ".");
1094 }
1095 fprintf(stderr, "\n");
1096 if((strstr(szSendBuffer,"ERROR - Bad Password"))
1097 || (strstr(szSendBuffer,"400 Bad Request")))
1098 reconnect_sec_max = 0;
1099 output_init = 0;
1100 break;
1101 }
1102#ifndef NDEBUG
1103 else
1104 {
1105 fprintf(stderr, "Destination caster response:\n%s\n",
1106 szSendBuffer);
1107 }
1108#endif
1109 send_receive_loop(socket_tcp, outputmode, NULL, 0, 0);
1110 input_init = output_init = 0;
1111 break;
1112 case HTTP: /*** Ntrip-Version 2.0 HTTP/1.1 ***/
1113 nBufferBytes = snprintf(szSendBuffer, sizeof(szSendBuffer),
1114 "POST %s/%s HTTP/1.1\r\n"
1115 "Host: %s\r\n"
1116 "Ntrip-Version: Ntrip/2.0\r\n"
1117 "User-Agent: %s/%s\r\n"
1118 "Authorization: Basic %s%s%s\r\n"
1119 "Connection: close\r\n"
1120 "Transfer-Encoding: chunked\r\n\r\n",
1121 post_extension, mountpoint, casterouthost, AGENTSTRING,
1122 revisionstr, authorization, ntrip_str ? "\r\nNtrip-STR: " : "",
1123 ntrip_str);
1124 if((nBufferBytes > (int)sizeof(szSendBuffer)) || (nBufferBytes < 0))
1125 {
1126 fprintf(stderr, "ERROR: Destination caster request to long\n");
1127 reconnect_sec_max = 0;
1128 output_init = 0;
1129 break;
1130 }
1131 if(!send_to_caster(szSendBuffer, socket_tcp, nBufferBytes))
1132 {
1133 output_init = 0;
1134 break;
1135 }
1136 /* check Destination caster's response */
1137 nBufferBytes = recv(socket_tcp, szSendBuffer, sizeof(szSendBuffer), 0);
1138 szSendBuffer[nBufferBytes] = '\0';
1139 if(!strstr(szSendBuffer, "HTTP/1.1 200 OK"))
1140 {
1141 char *a;
1142 fprintf(stderr,
1143 "ERROR: Destination caster's%s reply is not OK: ",
1144 *proxyhost ? " or Proxy's" : "");
1145 for(a = szSendBuffer; *a && *a != '\n' && *a != '\r'; ++a)
1146 {
1147 fprintf(stderr, "%.1s", isprint(*a) ? a : ".");
1148 }
1149 fprintf(stderr, "\n");
1150 /* fallback if necessary */
1151 if(!strstr(szSendBuffer,"Ntrip-Version: Ntrip/2.0\r\n"))
1152 {
1153 fprintf(stderr,
1154 " Ntrip Version 2.0 not implemented at Destination caster"
1155 " <%s>%s%s%s\n%s\n"
1156 "ntripserver falls back to Ntrip Version 1.0\n\n",
1157 casterouthost,
1158 *proxyhost ? " or Proxy <" : "", proxyhost, *proxyhost ? ">" : "",
1159 *proxyhost ? " or HTTP/1.1 not implemented at Proxy\n" : "");
1160 close_session(casterouthost, mountpoint, session, rtsp_extension, 1);
1161 outputmode = NTRIP1;
1162 break;
1163 }
1164 else if((strstr(szSendBuffer,"HTTP/1.1 401 Unauthorized"))
1165 || (strstr(szSendBuffer,"501 Not Implemented")))
1166 {
1167 reconnect_sec_max = 0;
1168 }
1169 output_init = 0;
1170 break;
1171 }
1172#ifndef NDEBUG
1173 else
1174 {
1175 fprintf(stderr, "Destination caster response:\n%s\n",szSendBuffer);
1176 }
1177#endif
1178 send_receive_loop(socket_tcp, outputmode, NULL, 0, 0);
1179 input_init = output_init = 0;
1180 break;
1181 case RTSP: /*** Ntrip-Version 2.0 RTSP / RTP ***/
1182 if((socket_udp = socket(AF_INET, SOCK_DGRAM,0)) == INVALID_SOCKET)
1183 {
1184 perror("ERROR: udp socket");
1185 exit(4);
1186 }
1187 /* fill structure with local address information for UDP */
1188 memset(&local, 0, sizeof(local));
1189 local.sin_family = AF_INET;
1190 local.sin_port = htons(0);
1191 local.sin_addr.s_addr = htonl(INADDR_ANY);
1192 len = (socklen_t)sizeof(local);
1193 /* bind() in order to get a random RTP client_port */
1194 if((bind(socket_udp,(struct sockaddr *)&local, len)) < 0)
1195 {
1196 perror("ERROR: udp bind");
1197 reconnect_sec_max = 0;
1198 output_init = 0;
1199 break;
1200 }
1201 if((getsockname(socket_udp, (struct sockaddr*)&local, &len)) != -1)
1202 {
1203 client_port = (unsigned int)ntohs(local.sin_port);
1204 }
1205 else
1206 {
1207 perror("ERROR: getsockname(localhost)");
1208 reconnect_sec_max = 0;
1209 output_init = 0;
1210 break;
1211 }
1212 nBufferBytes = snprintf(szSendBuffer, sizeof(szSendBuffer),
1213 "SETUP rtsp://%s%s/%s RTSP/1.0\r\n"
1214 "CSeq: %d\r\n"
1215 "Ntrip-Version: Ntrip/2.0\r\n"
1216 "Ntrip-Component: Ntripserver\r\n"
1217 "User-Agent: %s/%s\r\n"
1218 "Transport: RTP/GNSS;unicast;client_port=%u\r\n"
1219 "Authorization: Basic %s%s%s\r\n\r\n",
1220 casterouthost, rtsp_extension, mountpoint, udp_cseq++, AGENTSTRING,
1221 revisionstr, client_port, authorization, ntrip_str
1222 ? "\r\nNtrip-STR: " : "", ntrip_str);
1223 if((nBufferBytes > (int)sizeof(szSendBuffer)) || (nBufferBytes < 0))
1224 {
1225 fprintf(stderr, "ERROR: Destination caster request to long\n");
1226 reconnect_sec_max = 0;
1227 output_init = 0;
1228 break;
1229 }
1230 if(!send_to_caster(szSendBuffer, socket_tcp, nBufferBytes))
1231 {
1232 output_init = 0;
1233 break;
1234 }
1235 while((nBufferBytes = recv(socket_tcp, szSendBuffer,
1236 sizeof(szSendBuffer), 0)) > 0)
1237 {
1238 /* check Destination caster's response */
1239 szSendBuffer[nBufferBytes] = '\0';
1240 if(!strstr(szSendBuffer, "RTSP/1.0 200 OK"))
1241 {
1242 char *a;
1243 fprintf(stderr,
1244 "ERROR: Destination caster's%s reply is not OK: ",
1245 *proxyhost ? " or Proxy's" : "");
1246 for(a = szSendBuffer; *a && *a != '\n' && *a != '\r'; ++a)
1247 {
1248 fprintf(stderr, "%c", isprint(*a) ? *a : '.');
1249 }
1250 fprintf(stderr, "\n");
1251 /* fallback if necessary */
1252 if(strncmp(szSendBuffer, "RTSP",4) != 0)
1253 {
1254 if(strstr(szSendBuffer,"Ntrip-Version: Ntrip/2.0\r\n"))
1255 {
1256 fprintf(stderr,
1257 " RTSP not implemented at Destination caster <%s>%s%s%s\n\n"
1258 "ntripserver falls back to Ntrip Version 2.0 in TCP/IP"
1259 " mode\n\n", casterouthost,
1260 *proxyhost ? " or Proxy <" :"", proxyhost, *proxyhost ? ">":"");
1261 close_session(casterouthost, mountpoint, session, rtsp_extension, 1);
1262 outputmode = HTTP;
1263 fallback = 1;
1264 break;
1265 }
1266 else
1267 {
1268 fprintf(stderr,
1269 " Ntrip-Version 2.0 not implemented at Destination caster"
1270 "<%s>%s%s%s\n%s"
1271 " or RTSP/1.0 not implemented at Destination caster%s\n\n"
1272 "ntripserver falls back to Ntrip Version 1.0\n\n",
1273 casterouthost, *proxyhost ? " or Proxy <" :"", proxyhost,
1274 *proxyhost ? ">":"",
1275 *proxyhost ? " or HTTP/1.1 not implemented at Proxy\n" : "",
1276 *proxyhost ? " or Proxy" :"");
1277 close_session(casterouthost, mountpoint, session, rtsp_extension, 1);
1278 outputmode = NTRIP1;
1279 fallback = 1;
1280 break;
1281 }
1282 }
1283 else if((strstr(szSendBuffer, "RTSP/1.0 401 Unauthorized"))
1284 || (strstr(szSendBuffer, "RTSP/1.0 501 Not Implemented")))
1285 {
1286 reconnect_sec_max = 0;
1287 }
1288 output_init = 0;
1289 break;
1290 }
1291#ifndef NDEBUG
1292 else
1293 {
1294 fprintf(stderr, "Destination caster response:\n%s\n",szSendBuffer);
1295 }
1296#endif
1297 if((strstr(szSendBuffer,"RTSP/1.0 200 OK\r\n"))
1298 && (strstr(szSendBuffer,"CSeq: 1\r\n")))
1299 {
1300 for(token = strtok(szSendBuffer, dlim); token != NULL;
1301 token = strtok(NULL, dlim))
1302 {
1303 tok_buf[i] = token; i++;
1304 }
1305 session = atoi(tok_buf[6]);
1306 server_port = atoi(tok_buf[10]);
1307 nBufferBytes = snprintf(szSendBuffer, sizeof(szSendBuffer),
1308 "RECORD rtsp://%s%s/%s RTSP/1.0\r\n"
1309 "CSeq: %d\r\n"
1310 "Session: %u\r\n"
1311 "\r\n",
1312 casterouthost, rtsp_extension, mountpoint, udp_cseq++,
1313 session);
1314 if((nBufferBytes >= (int)sizeof(szSendBuffer))
1315 || (nBufferBytes < 0))
1316 {
1317 fprintf(stderr, "ERROR: Destination caster request to long\n");
1318 reconnect_sec_max = 0;
1319 output_init = 0;
1320 break;
1321 }
1322 if(!send_to_caster(szSendBuffer, socket_tcp, nBufferBytes))
1323 {
1324 output_init = 0;
1325 break;
1326 }
1327 }
1328 else if((strstr(szSendBuffer,"RTSP/1.0 200 OK\r\n")) && (strstr(szSendBuffer,
1329 "CSeq: 2\r\n")))
1330 {
1331 /* fill structure with caster address information for UDP */
1332 memset(&casterRTP, 0, sizeof(casterRTP));
1333 casterRTP.sin_family = AF_INET;
1334 casterRTP.sin_port = htons(((uint16_t)server_port));
1335 if((he = gethostbyname(outhost))== NULL)
1336 {
1337 fprintf(stderr, "ERROR: Destination caster unknown\n");
1338 reconnect_sec_max = 0;
1339 output_init = 0;
1340 break;
1341 }
1342 else
1343 {
1344 memcpy((char *)&casterRTP.sin_addr.s_addr,
1345 he->h_addr_list[0], (size_t)he->h_length);
1346 }
1347 len = (socklen_t)sizeof(casterRTP);
1348 send_receive_loop(socket_udp, outputmode, (struct sockaddr *)&casterRTP,
1349 (socklen_t)len, session);
1350 break;
1351 }
1352 else{break;}
1353 }
1354 input_init = output_init = 0;
1355 break;
1356 }
1357 }
1358 close_session(casterouthost, mountpoint, session, rtsp_extension, 0);
1359 if( (reconnect_sec_max || fallback) && !sigint_received )
1360 reconnect_sec = reconnect(reconnect_sec, reconnect_sec_max);
1361 else inputmode = LAST;
1362 }
1363 return 0;
1364}
1365
1366static void send_receive_loop(sockettype sock, int outmode, struct sockaddr* pcasterRTP,
1367socklen_t length, unsigned int rtpssrc)
1368{
1369 int nodata = 0;
1370 char buffer[BUFSZ] = { 0 };
1371 char sisnetbackbuffer[200];
1372 char szSendBuffer[BUFSZ] = "";
1373 int nBufferBytes = 0;
1374
1375 /* RTSP / RTP Mode */
1376 int isfirstpacket = 1;
1377 struct timeval now;
1378 struct timeval last = {0,0};
1379 long int sendtimediff;
1380 int rtpseq = 0;
1381 int rtptime = 0;
1382 time_t laststate = time(0);
1383
1384 if(outmode == UDP)
1385 {
1386 rtptime = time(0);
1387#ifdef WINDOWSVERSION
1388 u_long blockmode = 1;
1389 if(ioctlsocket(socket_tcp, FIONBIO, &blockmode))
1390#else /* WINDOWSVERSION */
1391 if(fcntl(socket_tcp, F_SETFL, O_NONBLOCK) < 0)
1392#endif /* WINDOWSVERSION */
1393 {
1394 fprintf(stderr, "Could not set nonblocking mode\n");
1395 return;
1396 }
1397 }
1398 else if(outmode == RTSP)
1399 {
1400#ifdef WINDOWSVERSION
1401 u_long blockmode = 1;
1402 if(ioctlsocket(socket_tcp, FIONBIO, &blockmode))
1403#else /* WINDOWSVERSION */
1404 if(fcntl(socket_tcp, F_SETFL, O_NONBLOCK) < 0)
1405#endif /* WINDOWSVERSION */
1406 {
1407 fprintf(stderr, "Could not set nonblocking mode\n");
1408 return;
1409 }
1410 }
1411
1412 /* data transmission */
1413 fprintf(stderr,"transfering data ...\n");
1414 int send_recv_success = 0;
1415#ifdef WINDOWSVERSION
1416 time_t nodata_begin = 0, nodata_current = 0;
1417#endif
1418 while(1)
1419 {
1420 if(send_recv_success < 3) send_recv_success++;
1421 if(!nodata)
1422 {
1423#ifndef WINDOWSVERSION
1424 alarm(ALARMTIME);
1425#else
1426 time(&nodata_begin);
1427#endif
1428 }
1429 else
1430 {
1431 nodata = 0;
1432#ifdef WINDOWSVERSION
1433 time(&nodata_current);
1434 if(difftime(nodata_current, nodata_begin) >= ALARMTIME)
1435 {
1436 sigalarm_received = 1;
1437 fprintf(stderr, "ERROR: more than %d seconds no activity\n", ALARMTIME);
1438 }
1439#endif
1440 }
1441 /* signal handling*/
1442#ifdef WINDOWSVERSION
1443 if((sigalarm_received) || (sigint_received)) break;
1444#else
1445 if((sigalarm_received) || (sigint_received) || (sigpipe_received)) break;
1446#endif
1447 if(!nBufferBytes)
1448 {
1449 if(inputmode == SISNET && sisnet <= 30)
1450 {
1451 int i;
1452 /* a somewhat higher rate than 1 second to get really each block */
1453 /* means we need to skip double blocks sometimes */
1454 struct timeval tv = {0,700000};
1455 select(0, 0, 0, 0, &tv);
1456 memcpy(sisnetbackbuffer, buffer, sizeof(sisnetbackbuffer));
1457 i = (sisnet >= 30 ? 5 : 3);
1458 if((send(gps_socket, "MSG\r\n", i, 0)) != i)
1459 {
1460 perror("WARNING: sending SISNeT data request failed");
1461 return;
1462 }
1463 }
1464 /*** receiving data ****/
1465 if(inputmode == INFILE)
1466 nBufferBytes = read(gps_file, buffer, sizeof(buffer));
1467 else if(inputmode == SERIAL)
1468 {
1469#ifndef WINDOWSVERSION
1470 nBufferBytes = read(gps_serial, buffer, sizeof(buffer));
1471#else
1472 DWORD nRead = 0;
1473 if(!ReadFile(gps_serial, buffer, sizeof(buffer), &nRead, NULL))
1474 {
1475 fprintf(stderr,"ERROR: reading serial input failed\n");
1476 return;
1477 }
1478 nBufferBytes = (int)nRead;
1479#endif
1480 }
1481 else
1482#ifdef WINDOWSVERSION
1483 nBufferBytes = recv(gps_socket, buffer, sizeof(buffer), 0);
1484#else
1485 nBufferBytes = read(gps_socket, buffer, sizeof(buffer));
1486#endif
1487 if(!nBufferBytes)
1488 {
1489 fprintf(stderr, "WARNING: no data received from input\n");
1490 nodata = 1;
1491#ifndef WINDOWSVERSION
1492 sleep(3);
1493#else
1494 Sleep(3*1000);
1495#endif
1496 continue;
1497 }
1498 else if((nBufferBytes < 0) && (!sigint_received))
1499 {
1500 perror("WARNING: reading input failed");
1501 return;
1502 }
1503 /* we can compare the whole buffer, as the additional bytes
1504 remain unchanged */
1505 if(inputmode == SISNET && sisnet <= 30 &&
1506 !memcmp(sisnetbackbuffer, buffer, sizeof(sisnetbackbuffer)))
1507 {
1508 nBufferBytes = 0;
1509 }
1510 }
1511 if(nBufferBytes < 0)
1512 return;
1513 /** send data ***/
1514 if((nBufferBytes) && (outmode == NTRIP1)) /*** Ntrip-Version 1.0 ***/
1515 {
1516 int i;
1517 if((i = send(sock, buffer, (size_t)nBufferBytes, MSG_DONTWAIT))
1518 != nBufferBytes)
1519 {
1520 if(i < 0)
1521 {
1522 if(errno != EAGAIN)
1523 {
1524 perror("WARNING: could not send data to Destination caster");
1525 return;
1526 }
1527 }
1528 else if(i)
1529 {
1530 memmove(buffer, buffer+i, (size_t)(nBufferBytes-i));
1531 nBufferBytes -= i;
1532 }
1533 }else
1534 {
1535 nBufferBytes = 0;
1536 }
1537 }
1538 else if((nBufferBytes) && (outmode == UDP))
1539 {
1540 char rtpbuf[1592];
1541 int i;
1542 int ct = time(0);
1543 udp_tim += (ct-udp_init)*1000000/TIME_RESOLUTION;
1544 udp_init = ct;
1545 rtpbuf[0] = (2<<6);
1546 rtpbuf[1] = 96;
1547 rtpbuf[2] = (udp_seq>>8)&0xFF;
1548 rtpbuf[3] = (udp_seq)&0xFF;
1549 rtpbuf[4] = (udp_tim>>24)&0xFF;
1550 rtpbuf[5] = (udp_tim>>16)&0xFF;
1551 rtpbuf[6] = (udp_tim>>8)&0xFF;
1552 rtpbuf[7] = (udp_tim)&0xFF;
1553 rtpbuf[8] = (rtpssrc>>24)&0xFF;
1554 rtpbuf[9] = (rtpssrc>>16)&0xFF;
1555 rtpbuf[10] = (rtpssrc>>8)&0xFF;
1556 rtpbuf[11] = (rtpssrc)&0xFF;
1557 ++udp_seq;
1558 memcpy(rtpbuf+12, buffer, nBufferBytes);
1559 if((i = send(socket_tcp, rtpbuf, (size_t)nBufferBytes+12, MSG_DONTWAIT))
1560 != nBufferBytes+12)
1561 {
1562 if(errno != EAGAIN)
1563 {
1564 perror("WARNING: could not send data to Destination caster");
1565 return;
1566 }
1567 }
1568 else
1569 nBufferBytes = 0;
1570 i = recv(socket_tcp, rtpbuf, sizeof(rtpbuf), 0);
1571 if(i >= 12 && (unsigned char)rtpbuf[0] == (2 << 6) && rtpssrc ==
1572 (unsigned int)(((unsigned char)rtpbuf[8]<<24)+((unsigned char)rtpbuf[9]<<16)
1573 +((unsigned char)rtpbuf[10]<<8)+(unsigned char)rtpbuf[11]))
1574 {
1575 if(rtpbuf[1] == 96)
1576 rtptime = time(0);
1577 else if(rtpbuf[1] == 98)
1578 {
1579 fprintf(stderr, "Connection end\n");
1580 return;
1581 }
1582 }
1583 else if(time(0) > rtptime+60)
1584 {
1585 fprintf(stderr, "Timeout\n");
1586 return;
1587 }
1588 }
1589 /*** Ntrip-Version 2.0 HTTP/1.1 ***/
1590 else if((nBufferBytes) && (outmode == HTTP))
1591 {
1592 int i, nChunkBytes, j = 1;
1593 nChunkBytes = snprintf(szSendBuffer, sizeof(szSendBuffer),"%x\r\n",
1594 nBufferBytes);
1595 send(sock, szSendBuffer, nChunkBytes, MSG_DONTWAIT);
1596 if((i = send(sock, buffer, (size_t)nBufferBytes, MSG_DONTWAIT))
1597 != nBufferBytes)
1598 {
1599 if(i < 0)
1600 {
1601 if(errno != EAGAIN)
1602 {
1603 perror("WARNING: could not send data to Destination caster");
1604 return;
1605 }
1606 }
1607 else if(i)
1608 {
1609 while(j>0)
1610 {
1611 j = send(sock, buffer, (size_t)BUFSZ, MSG_DONTWAIT);
1612 }
1613 }
1614 }
1615 else
1616 {
1617 send(sock, "\r\n", strlen("\r\n"), MSG_DONTWAIT);
1618 nBufferBytes = 0;
1619 }
1620 }
1621 /*** Ntrip-Version 2.0 RTSP(TCP) / RTP(UDP) ***/
1622 else if((nBufferBytes) && (outmode == RTSP))
1623 {
1624 time_t ct;
1625 int r;
1626 char rtpbuffer[BUFSZ+12];
1627 int i, j;
1628 gettimeofday(&now, NULL);
1629 /* RTP data packet generation*/
1630 if(isfirstpacket){
1631 rtpseq = rand();
1632 rtptime = rand();
1633 last = now;
1634 isfirstpacket = 0;
1635 }
1636 else
1637 {
1638 ++rtpseq;
1639 sendtimediff = (((now.tv_sec - last.tv_sec)*1000000)
1640 + (now.tv_usec - last.tv_usec));
1641 rtptime += sendtimediff/TIME_RESOLUTION;
1642 }
1643 rtpbuffer[0] = (RTP_VERSION<<6);
1644 /* padding, extension, csrc are empty */
1645 rtpbuffer[1] = 96;
1646 /* marker is empty */
1647 rtpbuffer[2] = rtpseq>>8;
1648 rtpbuffer[3] = rtpseq;
1649 rtpbuffer[4] = rtptime>>24;
1650 rtpbuffer[5] = rtptime>>16;
1651 rtpbuffer[6] = rtptime>>8;
1652 rtpbuffer[7] = rtptime;
1653 rtpbuffer[8] = rtpssrc>>24;
1654 rtpbuffer[9] = rtpssrc>>16;
1655 rtpbuffer[10] = rtpssrc>>8;
1656 rtpbuffer[11] = rtpssrc;
1657 for(j=0; j<nBufferBytes; j++) {rtpbuffer[12+j] = buffer[j];}
1658 last.tv_sec = now.tv_sec;
1659 last.tv_usec = now.tv_usec;
1660 if ((i = sendto(sock, rtpbuffer, 12 + nBufferBytes, 0, pcasterRTP,
1661 length)) != (nBufferBytes + 12))
1662 {
1663 if(i < 0)
1664 {
1665 if(errno != EAGAIN)
1666 {
1667 perror("WARNING: could not send data to Destination caster");
1668 return;
1669 }
1670 }
1671 else if(i)
1672 {
1673 memmove(buffer, buffer+(i-12), (size_t)(nBufferBytes-(i-12)));
1674 nBufferBytes -= i-12;
1675 }
1676 }
1677 else
1678 {
1679 nBufferBytes = 0;
1680 }
1681 ct = time(0);
1682 if(ct-laststate > 15)
1683 {
1684 i = snprintf(buffer, sizeof(buffer),
1685 "GET_PARAMETER rtsp://%s%s/%s RTSP/1.0\r\n"
1686 "CSeq: %d\r\n"
1687 "Session: %u\r\n"
1688 "\r\n",
1689 casterouthost, rtsp_extension, mountpoint, udp_cseq++, rtpssrc);
1690 if(i > (int)sizeof(buffer) || i < 0)
1691 {
1692 fprintf(stderr, "Requested data too long\n");
1693 return;
1694 }
1695 else if(send(socket_tcp, buffer, (size_t)i, 0) != i)
1696 {
1697 perror("send");
1698 return;
1699 }
1700 laststate = ct;
1701 }
1702 /* ignore RTSP server replies */
1703 if((r=recv(socket_tcp, buffer, sizeof(buffer), 0)) < 0)
1704 {
1705#ifdef WINDOWSVERSION
1706 if(WSAGetLastError() != WSAEWOULDBLOCK)
1707#else /* WINDOWSVERSION */
1708 if(errno != EAGAIN)
1709#endif /* WINDOWSVERSION */
1710 {
1711 fprintf(stderr, "Control connection closed\n");
1712 return;
1713 }
1714 }
1715 else if(!r)
1716 {
1717 fprintf(stderr, "Control connection read error\n");
1718 return;
1719 }
1720 }
1721 if(send_recv_success == 3) reconnect_sec = 1;
1722 }
1723 return;
1724}
1725
1726
1727/********************************************************************
1728 * openserial
1729 *
1730 * Open the serial port with the given device name and configure it for
1731 * reading NMEA data from a GPS receiver.
1732 *
1733 * Parameters:
1734 * tty : pointer to : A zero-terminated string containing the device
1735 * unsigned char name of the appropriate serial port.
1736 * blocksz : integer : Block size for port I/O (ifndef WINDOWSVERSION)
1737 * baud : integer : Baud rate for port I/O
1738 *
1739 * Return Value:
1740 * The function returns a file descriptor for the opened port if successful.
1741 * The function returns -1 / INVALID_HANDLE_VALUE in the event of an error.
1742 *
1743 * Remarks:
1744 *
1745 ********************************************************************/
1746#ifndef WINDOWSVERSION
1747static int openserial(const char * tty, int blocksz, int baud)
1748{
1749 struct termios termios;
1750
1751/*** opening the serial port ***/
1752 gps_serial = open(tty, O_RDWR | O_NONBLOCK | O_EXLOCK);
1753 if(gps_serial < 0)
1754 {
1755 perror("ERROR: opening serial connection");
1756 return (-1);
1757 }
1758
1759/*** configuring the serial port ***/
1760 if(tcgetattr(gps_serial, &termios) < 0)
1761 {
1762 perror("ERROR: get serial attributes");
1763 return (-1);
1764 }
1765 termios.c_iflag = 0;
1766 termios.c_oflag = 0; /* (ONLRET) */
1767 termios.c_cflag = CS8 | CLOCAL | CREAD;
1768 termios.c_lflag = 0;
1769 {
1770 int cnt;
1771 for(cnt = 0; cnt < NCCS; cnt++)
1772 termios.c_cc[cnt] = -1;
1773 }
1774 termios.c_cc[VMIN] = blocksz;
1775 termios.c_cc[VTIME] = 2;
1776
1777#if (B4800 != 4800)
1778/* Not every system has speed settings equal to absolute speed value. */
1779 switch (baud)
1780 {
1781 case 300:
1782 baud = B300;
1783 break;
1784 case 1200:
1785 baud = B1200;
1786 break;
1787 case 2400:
1788 baud = B2400;
1789 break;
1790 case 4800:
1791 baud = B4800;
1792 break;
1793 case 9600:
1794 baud = B9600;
1795 break;
1796 case 19200:
1797 baud = B19200;
1798 break;
1799 case 38400:
1800 baud = B38400;
1801 break;
1802#ifdef B57600
1803 case 57600:
1804 baud = B57600;
1805 break;
1806#endif
1807#ifdef B115200
1808 case 115200:
1809 baud = B115200;
1810 break;
1811#endif
1812#ifdef B230400
1813 case 230400:
1814 baud = B230400;
1815 break;
1816#endif
1817 default:
1818 fprintf(stderr, "WARNING: Baud settings not useful, using 19200\n");
1819 baud = B19200;
1820 break;
1821 }
1822#endif
1823
1824 if(cfsetispeed(&termios, baud) != 0)
1825 {
1826 perror("ERROR: setting serial speed with cfsetispeed");
1827 return (-1);
1828 }
1829 if(cfsetospeed(&termios, baud) != 0)
1830 {
1831 perror("ERROR: setting serial speed with cfsetospeed");
1832 return (-1);
1833 }
1834 if(tcsetattr(gps_serial, TCSANOW, &termios) < 0)
1835 {
1836 perror("ERROR: setting serial attributes");
1837 return (-1);
1838 }
1839 if(fcntl(gps_serial, F_SETFL, 0) == -1)
1840 {
1841 perror("WARNING: setting blocking inputmode failed");
1842 }
1843 return (gps_serial);
1844}
1845#else
1846static HANDLE openserial(const char * tty, int baud)
1847{
1848 char compath[15] = "";
1849
1850 snprintf(compath, sizeof(compath), "\\\\.\\%s", tty);
1851 if((gps_serial = CreateFile(compath, GENERIC_WRITE|GENERIC_READ
1852 , 0, 0, OPEN_EXISTING, 0, 0)) == INVALID_HANDLE_VALUE)
1853 {
1854 fprintf(stderr, "ERROR: opening serial connection\n");
1855 return (INVALID_HANDLE_VALUE);
1856 }
1857
1858 DCB dcb;
1859 memset(&dcb, 0, sizeof(dcb));
1860 char str[100];
1861 snprintf(str,sizeof(str),
1862 "baud=%d parity=N data=8 stop=1 xon=off octs=off rts=off",
1863 baud);
1864
1865 COMMTIMEOUTS ct = {1000, 1, 0, 0, 0};
1866
1867 if(!BuildCommDCB(str, &dcb))
1868 {
1869 fprintf(stderr, "ERROR: get serial attributes\n");
1870 return (INVALID_HANDLE_VALUE);
1871 }
1872 else if(!SetCommState(gps_serial, &dcb))
1873 {
1874 fprintf(stderr, "ERROR: set serial attributes\n");
1875 return (INVALID_HANDLE_VALUE);
1876 }
1877 else if(!SetCommTimeouts(gps_serial, &ct))
1878 {
1879 fprintf(stderr, "ERROR: set serial timeouts\n");
1880 return (INVALID_HANDLE_VALUE);
1881 }
1882
1883 return (gps_serial);
1884}
1885#endif
1886
1887/********************************************************************
1888* usage
1889*
1890* Send a usage message to standard error and quit the program.
1891*
1892* Parameters:
1893* None.
1894*
1895* Return Value:
1896* The function does not return a value.
1897*
1898* Remarks:
1899*
1900*********************************************************************/
1901#ifdef __GNUC__
1902__attribute__ ((noreturn))
1903#endif /* __GNUC__ */
1904void usage(int rc, char *name)
1905{
1906 fprintf(stderr, "Version %s (%s) GPL" COMPILEDATE "\nUsage:\n%s [OPTIONS]\n",
1907 revisionstr, datestr, name);
1908 fprintf(stderr, "PURPOSE\n");
1909 fprintf(stderr, " The purpose of this program is to pick up a GNSS data stream (Input, Source)\n");
1910 fprintf(stderr, " from either\n\n");
1911 fprintf(stderr, " 1. a Serial port, or\n");
1912 fprintf(stderr, " 2. an IP server, or\n");
1913 fprintf(stderr, " 3. a File, or\n");
1914 fprintf(stderr, " 4. a SISNeT Data Server, or\n");
1915 fprintf(stderr, " 5. a UDP server, or\n");
1916 fprintf(stderr, " 6. an NTRIP Version 1.0 Caster\n\n");
1917 fprintf(stderr, " and forward that incoming stream (Output, Destination) to either\n\n");
1918 fprintf(stderr, " - an NTRIP Version 1.0 Caster, or\n");
1919 fprintf(stderr, " - an NTRIP Version 2.0 Caster via TCP/IP or RTSP/RTP.\n\n\n");
1920 fprintf(stderr, "OPTIONS\n");
1921 fprintf(stderr, " -h|? print this help screen\n\n");
1922 fprintf(stderr, " -E <ProxyHost> Proxy server host name or address, required i.e. when\n");
1923 fprintf(stderr, " running the program in a proxy server protected LAN,\n");
1924 fprintf(stderr, " optional\n");
1925 fprintf(stderr, " -F <ProxyPort> Proxy server IP port, required i.e. when running\n");
1926 fprintf(stderr, " the program in a proxy server protected LAN, optional\n");
1927 fprintf(stderr, " -R <maxDelay> Reconnect mechanism with maximum delay between reconnect\n");
1928 fprintf(stderr, " attemts in seconds, default: no reconnect activated,\n");
1929 fprintf(stderr, " optional\n\n");
1930 fprintf(stderr, " -M <InputMode> Sets the input mode (1 = Serial Port, 2 = IP server,\n");
1931 fprintf(stderr, " 3 = File, 4 = SISNeT Data Server, 5 = UDP server, 6 = NTRIP Caster),\n");
1932 fprintf(stderr, " mandatory\n\n");
1933 fprintf(stderr, " <InputMode> = 1 (Serial Port):\n");
1934 fprintf(stderr, " -i <Device> Serial input device, default: %s, mandatory if\n", ttyport);
1935 fprintf(stderr, " <InputMode>=1\n");
1936 fprintf(stderr, " -b <BaudRate> Serial input baud rate, default: 19200 bps, mandatory\n");
1937 fprintf(stderr, " if <InputMode>=1\n");
1938 fprintf(stderr, " -f <InitFile> Name of initialization file to be send to input device,\n");
1939 fprintf(stderr, " optional\n\n");
1940 fprintf(stderr, " <InputMode> = 2|5 (IP port | UDP port):\n");
1941 fprintf(stderr, " -H <ServerHost> Input host name or address, default: 127.0.0.1,\n");
1942 fprintf(stderr, " mandatory if <InputMode> = 2|5\n");
1943 fprintf(stderr, " -P <ServerPort> Input port, default: 1025, mandatory if <InputMode>= 2|5\n");
1944 fprintf(stderr, " -f <ServerFile> Name of initialization file to be send to server,\n");
1945 fprintf(stderr, " optional\n");
1946 fprintf(stderr, " -x <ServerUser> User ID to access incoming stream, optional\n");
1947 fprintf(stderr, " -y <ServerPass> Password, to access incoming stream, optional\n");
1948 fprintf(stderr, " -B Bind to incoming UDP stream, optional for <InputMode> = 5\n\n");
1949 fprintf(stderr, " <InputMode> = 3 (File):\n");
1950 fprintf(stderr, " -s <File> File name to simulate stream by reading data from (log)\n");
1951 fprintf(stderr, " file, default is %s, mandatory for <InputMode> = 3\n\n", filepath);
1952 fprintf(stderr, " <InputMode> = 4 (SISNeT Data Server):\n");
1953 fprintf(stderr, " -H <SisnetHost> SISNeT Data Server name or address,\n");
1954 fprintf(stderr, " default: 131.176.49.142, mandatory if <InputMode> = 4\n");
1955 fprintf(stderr, " -P <SisnetPort> SISNeT Data Server port, default: 7777, mandatory if\n");
1956 fprintf(stderr, " <InputMode> = 4\n");
1957 fprintf(stderr, " -u <SisnetUser> SISNeT Data Server user ID, mandatory if <InputMode> = 4\n");
1958 fprintf(stderr, " -l <SisnetPass> SISNeT Data Server password, mandatory if <InputMode> = 4\n");
1959 fprintf(stderr, " -V <SisnetVers> SISNeT Data Server Version number, options are 2.1, 3.0\n");
1960 fprintf(stderr, " or 3.1, default: 3.1, mandatory if <InputMode> = 4\n\n");
1961 fprintf(stderr, " <InputMode> = 6 (NTRIP Version 1.0 Caster):\n");
1962 fprintf(stderr, " -H <SourceHost> Source caster name or address, default: 127.0.0.1,\n");
1963 fprintf(stderr, " mandatory if <InputMode> = 6\n");
1964 fprintf(stderr, " -P <SourcePort> Source caster port, default: 2101, mandatory if\n");
1965 fprintf(stderr, " <InputMode> = 6\n");
1966 fprintf(stderr, " -D <SourceMount> Source caster mountpoint for stream input, mandatory if\n");
1967 fprintf(stderr, " <InputMode> = 6\n");
1968 fprintf(stderr, " -U <SourceUser> Source caster user Id for input stream access, mandatory\n");
1969 fprintf(stderr, " for protected streams if <InputMode> = 6\n");
1970 fprintf(stderr, " -W <SourcePass> Source caster password for input stream access, mandatory\n");
1971 fprintf(stderr, " for protected streams if <InputMode> = 6\n\n");
1972 fprintf(stderr, " -O <OutputMode> Sets output mode for communatation with destination caster\n");
1973 fprintf(stderr, " 1 = http: NTRIP Version 2.0 Caster in TCP/IP mode\n");
1974 fprintf(stderr, " 2 = rtsp: NTRIP Version 2.0 Caster in RTSP/RTP mode\n");
1975 fprintf(stderr, " 3 = ntrip1: NTRIP Version 1.0 Caster\n");
1976 fprintf(stderr, " 4 = udp: NTRIP Version 2.0 Caster in Plain UDP mode\n");
1977 fprintf(stderr, " optional\n\n");
1978 fprintf(stderr, " Defaults to NTRIP1.0, but will change to 2.0 in future versions\n");
1979 fprintf(stderr, " Note that the program automatically falls back from mode rtsp to mode http and\n");
1980 fprintf(stderr, " further to mode ntrip1 if necessary.\n\n");
1981 fprintf(stderr, " -a <DestHost> Destination caster name or address, default: 127.0.0.1,\n");
1982 fprintf(stderr, " mandatory\n");
1983 fprintf(stderr, " -p <DestPort> Destination caster port, default: 2101, mandatory\n");
1984 fprintf(stderr, " -m <DestMount> Destination caster mountpoint for stream upload,\n");
1985 fprintf(stderr, " mandatory\n");
1986 fprintf(stderr, " -n <DestUser> Destination caster user ID for stream upload to\n");
1987 fprintf(stderr, " mountpoint, only for NTRIP Version 2.0 destination\n");
1988 fprintf(stderr, " casters, mandatory\n");
1989 fprintf(stderr, " -c <DestPass> Destination caster password for stream upload to\n");
1990 fprintf(stderr, " mountpoint, mandatory\n");
1991 fprintf(stderr, " -N <STR-record> Sourcetable STR-record\n");
1992 fprintf(stderr, " optional for NTRIP Version 2.0 in RTSP/RTP and TCP/IP mode\n\n");
1993 exit(rc);
1994} /* usage */
1995
1996
1997/********************************************************************/
1998/* signal handling */
1999/********************************************************************/
2000#ifdef __GNUC__
2001static void handle_sigint(int sig __attribute__((__unused__)))
2002#else /* __GNUC__ */
2003static void handle_sigint(int sig)
2004#endif /* __GNUC__ */
2005{
2006 sigint_received = 1;
2007 fprintf(stderr, "WARNING: SIGINT received - ntripserver terminates\n");
2008}
2009
2010#ifndef WINDOWSVERSION
2011#ifdef __GNUC__
2012static void handle_alarm(int sig __attribute__((__unused__)))
2013#else /* __GNUC__ */
2014static void handle_alarm(int sig)
2015#endif /* __GNUC__ */
2016{
2017 sigalarm_received = 1;
2018 fprintf(stderr, "ERROR: more than %d seconds no activity\n", ALARMTIME);
2019}
2020
2021#ifdef __GNUC__
2022static void handle_sigpipe(int sig __attribute__((__unused__)))
2023#else /* __GNUC__ */
2024static void handle_sigpipe(int sig)
2025#endif /* __GNUC__ */
2026{
2027 sigpipe_received = 1;
2028}
2029#endif /* WINDOWSVERSION */
2030
2031static void setup_signal_handler(int sig, void (*handler)(int))
2032{
2033#if _POSIX_VERSION > 198800L
2034 struct sigaction action;
2035
2036 action.sa_handler = handler;
2037 sigemptyset(&(action.sa_mask));
2038 sigaddset(&(action.sa_mask), sig);
2039 action.sa_flags = 0;
2040 sigaction(sig, &action, 0);
2041#else
2042 signal(sig, handler);
2043#endif
2044 return;
2045} /* setupsignal_handler */
2046
2047
2048/********************************************************************
2049 * base64-encoding *
2050*******************************************************************/
2051static const char encodingTable [64] =
2052{
2053 'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P',
2054 'Q','R','S','T','U','V','W','X','Y','Z','a','b','c','d','e','f',
2055 'g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v',
2056 'w','x','y','z','0','1','2','3','4','5','6','7','8','9','+','/'
2057};
2058
2059/* does not buffer overrun, but breaks directly after an error */
2060/* returns the number of required bytes */
2061static int encode(char *buf, int size, const char *user, const char *pwd)
2062{
2063 unsigned char inbuf[3];
2064 char *out = buf;
2065 int i, sep = 0, fill = 0, bytes = 0;
2066
2067 while(*user || *pwd)
2068 {
2069 i = 0;
2070 while(i < 3 && *user) inbuf[i++] = *(user++);
2071 if(i < 3 && !sep) {inbuf[i++] = ':'; ++sep; }
2072 while(i < 3 && *pwd) inbuf[i++] = *(pwd++);
2073 while(i < 3) {inbuf[i++] = 0; ++fill; }
2074 if(out-buf < size-1)
2075 *(out++) = encodingTable[(inbuf [0] & 0xFC) >> 2];
2076 if(out-buf < size-1)
2077 *(out++) = encodingTable[((inbuf [0] & 0x03) << 4)
2078 | ((inbuf [1] & 0xF0) >> 4)];
2079 if(out-buf < size-1)
2080 {
2081 if(fill == 2)
2082 *(out++) = '=';
2083 else
2084 *(out++) = encodingTable[((inbuf [1] & 0x0F) << 2)
2085 | ((inbuf [2] & 0xC0) >> 6)];
2086 }
2087 if(out-buf < size-1)
2088 {
2089 if(fill >= 1)
2090 *(out++) = '=';
2091 else
2092 *(out++) = encodingTable[inbuf [2] & 0x3F];
2093 }
2094 bytes += 4;
2095 }
2096 if(out-buf < size)
2097 *out = 0;
2098 return bytes;
2099}/* base64 Encoding */
2100
2101
2102/********************************************************************
2103 * send message to caster *
2104*********************************************************************/
2105static int send_to_caster(char *input, sockettype socket, int input_size)
2106{
2107 int send_error = 1;
2108
2109 if((send(socket, input, (size_t)input_size, 0)) != input_size)
2110 {
2111 fprintf(stderr, "WARNING: could not send full header to Destination caster\n");
2112 send_error = 0;
2113 }
2114#ifndef NDEBUG
2115 else
2116 {
2117 fprintf(stderr, "\nDestination caster request:\n");
2118 fprintf(stderr, "%s", input);
2119 }
2120#endif
2121 return send_error;
2122}/* send_to_caster */
2123
2124
2125/********************************************************************
2126 * reconnect *
2127*********************************************************************/
2128int reconnect(int rec_sec, int rec_sec_max)
2129{
2130 fprintf(stderr,"reconnect in <%d> seconds\n\n", rec_sec);
2131 rec_sec *= 2;
2132 if (rec_sec > rec_sec_max) rec_sec = rec_sec_max;
2133#ifndef WINDOWSVERSION
2134 sleep(rec_sec);
2135 sigpipe_received = 0;
2136#else
2137 Sleep(rec_sec*1000);
2138#endif
2139 sigalarm_received = 0;
2140 return rec_sec;
2141} /* reconnect */
2142
2143
2144/********************************************************************
2145 * close session *
2146*********************************************************************/
2147static void close_session(const char *caster_addr, const char *mountpoint,
2148int session, char *rtsp_ext, int fallback)
2149{
2150 int size_send_buf;
2151 char send_buf[BUFSZ];
2152
2153 if(!fallback)
2154 {
2155 if((gps_socket != INVALID_SOCKET) &&
2156 ((inputmode == TCPSOCKET) || (inputmode == UDPSOCKET) ||
2157 (inputmode == CASTER) || (inputmode == SISNET)))
2158 {
2159 if(closesocket(gps_socket) == -1)
2160 {
2161 perror("ERROR: close input device ");
2162 exit(0);
2163 }
2164 else
2165 {
2166 gps_socket = -1;
2167#ifndef NDEBUG
2168 fprintf(stderr, "close input device: successful\n");
2169#endif
2170 }
2171 }
2172 else if((gps_serial != INVALID_HANDLE_VALUE) && (inputmode == SERIAL))
2173 {
2174#ifndef WINDOWSVERSION
2175 if(close(gps_serial) == INVALID_HANDLE_VALUE)
2176 {
2177 perror("ERROR: close input device ");
2178 exit(0);
2179 }
2180#else
2181 if(!CloseHandle(gps_serial))
2182 {
2183 fprintf(stderr, "ERROR: close input device ");
2184 exit(0);
2185 }
2186#endif
2187 else
2188 {
2189 gps_serial = INVALID_HANDLE_VALUE;
2190#ifndef NDEBUG
2191 fprintf(stderr, "close input device: successful\n");
2192#endif
2193 }
2194 }
2195 else if((gps_file != -1) && (inputmode == INFILE))
2196 {
2197 if(close(gps_file) == -1)
2198 {
2199 perror("ERROR: close input device ");
2200 exit(0);
2201 }
2202 else
2203 {
2204 gps_file = -1;
2205#ifndef NDEBUG
2206 fprintf(stderr, "close input device: successful\n");
2207#endif
2208 }
2209 }
2210 }
2211
2212 if(socket_udp != INVALID_SOCKET)
2213 {
2214 if(udp_cseq > 2)
2215 {
2216 size_send_buf = snprintf(send_buf, sizeof(send_buf),
2217 "TEARDOWN rtsp://%s%s/%s RTSP/1.0\r\n"
2218 "CSeq: %d\r\n"
2219 "Session: %u\r\n"
2220 "\r\n",
2221 caster_addr, rtsp_ext, mountpoint, udp_cseq++, session);
2222 if((size_send_buf >= (int)sizeof(send_buf)) || (size_send_buf < 0))
2223 {
2224 fprintf(stderr, "ERROR: Destination caster request to long\n");
2225 exit(0);
2226 }
2227 send_to_caster(send_buf, socket_tcp, size_send_buf); strcpy(send_buf,"");
2228 size_send_buf = recv(socket_tcp, send_buf, sizeof(send_buf), 0);
2229 send_buf[size_send_buf] = '\0';
2230#ifndef NDEBUG
2231 fprintf(stderr, "Destination caster response:\n%s", send_buf);
2232#endif
2233 }
2234 if(closesocket(socket_udp)==-1)
2235 {
2236 perror("ERROR: close udp socket");
2237 exit(0);
2238 }
2239 else
2240 {
2241 socket_udp = -1;
2242#ifndef NDEBUG
2243 fprintf(stderr, "close udp socket: successful\n");
2244#endif
2245 }
2246 }
2247
2248 if(socket_tcp != INVALID_SOCKET)
2249 {
2250 if(closesocket(socket_tcp) == -1)
2251 {
2252 perror("ERROR: close tcp socket");
2253 exit(0);
2254 }
2255 else
2256 {
2257 socket_tcp = -1;
2258#ifndef NDEBUG
2259 fprintf(stderr, "close tcp socket: successful\n");
2260#endif
2261 }
2262 }
2263} /* close_session */
Note: See TracBrowser for help on using the repository browser.