source: ntrip/trunk/ntripserver/ntripserver.c

Last change on this file was 9109, checked in by stuerze, 5 months ago

minor changes in Ntrip HTTP upload part

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