/*
Converter for RTCM3 data to RINEX.
$Id: rtcm3torinex.c 9404 2021-04-14 12:51:04Z stoecker $
Copyright (C) 2005-2012 by Dirk StÃķcker <stoecker@alberding.eu>
This software is a complete NTRIP-RTCM3 to RINEX converter as well as
a module of the BNC tool for multiformat conversion. Contact Dirk
StÃķcker for suggestions and bug reports related to the RTCM3 to RINEX
conversion problems and the author of BNC for all the other problems.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
or read http://www.gnu.org/licenses/gpl.txt
*/
#include <ctype.h>
#include <errno.h>
#include <math.h>
#include <signal.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <time.h>
#include <unistd.h>
#ifndef NO_RTCM3_MAIN
#include <getopt.h>
#include <netdb.h>
#include <netinet/in.h>
#include <sys/socket.h>
#endif
#ifndef sparc
#include <stdint.h>
#endif
#ifndef isinf
#define isinf(x) 0
#endif
#include "rtcm3torinex.h"
/* CVS revision and version */
static char revisionstr[] = "$Revision: 9404 $";
#ifndef COMPILEDATE
#define COMPILEDATE " built " __DATE__
#endif
static uint32_t CRC24(long size, const unsigned char *buf)
{
uint32_t crc = 0;
int i;
while(size--)
{
crc ^= (*buf++) << (16);
for(i = 0; i < 8; i++)
{
crc <<= 1;
if(crc & 0x1000000)
crc ^= 0x01864cfb;
}
}
return crc;
}
static int GetMessage(struct RTCM3ParserData *handle)
{
unsigned char *m, *e;
int i;
m = handle->Message+handle->SkipBytes;
e = handle->Message+handle->MessageSize;
handle->NeedBytes = handle->SkipBytes = 0;
while(e-m >= 3)
{
if(m[0] == 0xD3)
{
handle->size = ((m[1]&3)<<8)|m[2];
if(e-m >= handle->size+6)
{
if((uint32_t)((m[3+handle->size]<<16)|(m[3+handle->size+1]<<8)
|(m[3+handle->size+2])) == CRC24(handle->size+3, m))
{
handle->SkipBytes = handle->size;
break;
}
else
++m;
}
else
{
handle->NeedBytes = handle->size+6;
break;
}
}
else
++m;
}
if(e-m < 3)
handle->NeedBytes = 3;
/* copy buffer to front */
i = m - handle->Message;
if(i && m < e)
memmove(handle->Message, m, (size_t)(handle->MessageSize-i));
handle->MessageSize -= i;
return !handle->NeedBytes;
}
#define LOADBITS(a) \
{ \
while((a) > numbits) \
{ \
if(!size--) break; \
bitfield = (bitfield<<8)|*(data++); \
numbits += 8; \
} \
}
/* extract bits from data stream
b = variable to store result, a = number of bits */
#define GETBITS64(b, a) \
{ \
if(((a) > 56) && ((a)-56) > numbits) \
{ \
uint64_t x; \
GETBITS(x, 56) \
LOADBITS((a)-56) \
b = ((x<<((a)-56)) | (bitfield<<(sizeof(bitfield)*8-numbits)) \
>>(sizeof(bitfield)*8-((a)-56))); \
numbits -= ((a)-56); \
} \
else \
{ \
GETBITS(b, a) \
} \
}
/* extract bits from data stream
b = variable to store result, a = number of bits */
#define GETBITS(b, a) \
{ \
LOADBITS(a) \
b = (bitfield<<(64-numbits))>>(64-(a)); \
numbits -= (a); \
}
/* extract bits from data stream
b = variable to store result, a = number of bits */
#define GETBITSFACTOR(b, a, c) \
{ \
LOADBITS(a) \
b = ((bitfield<<(sizeof(bitfield)*8-numbits))>>(sizeof(bitfield)*8-(a)))*(c); \
numbits -= (a); \
}
/* extract floating value from data stream
b = variable to store result, a = number of bits */
#define GETFLOAT(b, a, c) \
{ \
LOADBITS(a) \
b = ((double)((bitfield<<(64-numbits))>>(64-(a))))*(c); \
numbits -= (a); \
}
/* extract signed floating value from data stream
b = variable to store result, a = number of bits */
#define GETFLOATSIGN(b, a, c) \
{ \
LOADBITS(a) \
b = ((double)(((int64_t)(bitfield<<(64-numbits)))>>(64-(a))))*(c); \
numbits -= (a); \
}
/* extract bits from data stream
b = variable to store result, a = number of bits */
#define GETBITSSIGN(b, a) \
{ \
LOADBITS(a) \
b = ((int64_t)(bitfield<<(64-numbits)))>>(64-(a)); \
numbits -= (a); \
}
#define GETFLOATSIGNM(b, a, c) \
{ int l; \
LOADBITS(a) \
l = (bitfield<<(64-numbits))>>(64-1); \
b = ((double)(((bitfield<<(64-(numbits-1))))>>(64-(a-1))))*(c); \
numbits -= (a); \
if(l) b *= -1.0; \
}
#define SKIPBITS(b) { LOADBITS(b) numbits -= (b); }
/* extract byte-aligned byte from data stream,
b = variable to store size, s = variable to store string pointer */
#define GETSTRING(b, s) \
{ \
b = *(data++); \
s = (char *) data; \
data += b; \
size -= b+1; \
}
struct leapseconds { /* specify the day of leap second */
int day; /* this is the day, where 23:59:59 exists 2 times */
int month; /* not the next day! */
int year;
int taicount;
};
static const int months[13] = {0,31,28,31,30,31,30,31,31,30,31,30,31};
static const struct leapseconds leap[] = {
/*{31, 12, 1971, 10},*/
/*{30, 06, 1972, 11},*/
/*{31, 12, 1972, 12},*/
/*{31, 12, 1973, 13},*/
/*{31, 12, 1974, 14},*/
/*{31, 12, 1975, 15},*/
/*{31, 12, 1976, 16},*/
/*{31, 12, 1977, 17},*/
/*{31, 12, 1978, 18},*/
/*{31, 12, 1979, 19},*/
{30, 06, 1981,20},
{30, 06, 1982,21},
{30, 06, 1983,22},
{30, 06, 1985,23},
{31, 12, 1987,24},
{31, 12, 1989,25},
{31, 12, 1990,26},
{30, 06, 1992,27},
{30, 06, 1993,28},
{30, 06, 1994,29},
{31, 12, 1995,30},
{30, 06, 1997,31},
{31, 12, 1998,32},
{31, 12, 2005,33},
{31, 12, 2008,34},
{30, 06, 2012,35},
{30, 06, 2015,36},
{0,0,0,0} /* end marker */
};
#define LEAPSECONDS 17 /* only needed for approx. time */
#define GPSLEAPSTART 19 /* 19 leap seconds existed at 6.1.1980 */
static int longyear(int year, int month)
{
if(!(year % 4) && (!(year % 400) || (year % 100)))
{
if(!month || month == 2)
return 1;
}
return 0;
}
int gnumleap(int year, int month, int day)
{
int ls = 0;
const struct leapseconds *l;
for(l = leap; l->taicount && year >= l->year; ++l)
{
if(year > l->year || month > l->month || (month == l->month && day > l->day))
ls = l->taicount - GPSLEAPSTART;
}
return ls;
}
/* Convert Moscow time into UTC (fixnumleap == 1) or GPS (fixnumleap == 0) */
void updatetime(int *week, int *secOfWeek, int mSecOfWeek, int fixnumleap)
{
int y,m,d,k,l, nul;
unsigned int j = *week*(7*24*60*60) + *secOfWeek + 5*24*60*60+3*60*60;
int glo_daynumber = 0, glo_timeofday;
for(y = 1980; j >= (unsigned int)(k = (l = (365+longyear(y,0)))*24*60*60)
+ gnumleap(y+1,1,1); ++y)
{
j -= k; glo_daynumber += l;
}
for(m = 1; j >= (unsigned int)(k = (l = months[m]+longyear(y, m))*24*60*60)
+ gnumleap(y, m+1, 1); ++m)
{
j -= k; glo_daynumber += l;
}
for(d = 1; j >= 24UL*60UL*60UL + gnumleap(y, m, d+1); ++d)
j -= 24*60*60;
glo_daynumber -= 16*365+4-d;
nul = gnumleap(y, m, d);
glo_timeofday = j-nul;
// original version
// if(mSecOfWeek < 5*60*1000 && glo_timeofday > 23*60*60)
// *secOfWeek += 24*60*60;
// else if(glo_timeofday < 5*60 && mSecOfWeek > 23*60*60*1000)
// *secOfWeek -= 24*60*60;
// new version
if(mSecOfWeek < 4*60*60*1000 && glo_timeofday > 20*60*60)
*secOfWeek += 24*60*60;
else if(glo_timeofday < 4*60*60 && mSecOfWeek > 20*60*60*1000)
*secOfWeek -= 24*60*60;
*secOfWeek += mSecOfWeek/1000-glo_timeofday;
if(fixnumleap)
*secOfWeek -= nul;
if(*secOfWeek < 0) {*secOfWeek += 24*60*60*7; --*week; }
if(*secOfWeek >= 24*60*60*7) {*secOfWeek -= 24*60*60*7; ++*week; }
}
int RTCM3Parser(struct RTCM3ParserData *handle)
{
int ret=0;
#ifdef NO_RTCM3_MAIN
if(GetMessage(handle)) /* don't repeat */
#else
while(!ret && GetMessage(handle))
#endif /* NO_RTCM3_MAIN */
{
/* using 64 bit integer types, as it is much easier than handling
the long datatypes in 32 bit */
uint64_t numbits = 0, bitfield = 0;
int size = handle->size, type;
int syncf, old = 0;
unsigned char *data = handle->Message+3;
GETBITS(type,12)
#ifdef NO_RTCM3_MAIN
handle->blocktype = type;
#endif /* NO_RTCM3_MAIN */
switch(type)
{
#ifdef NO_RTCM3_MAIN
default:
ret = type;
break;
case 1005: case 1006:
{
SKIPBITS(22)
GETBITSSIGN(handle->antX, 38)
SKIPBITS(2)
GETBITSSIGN(handle->antY, 38)
SKIPBITS(2)
GETBITSSIGN(handle->antZ, 38)
if(type == 1006)
GETBITS(handle->antH, 16)
ret = type;
}
break;
case 1007: case 1008: case 1033:
{
char *antenna;
int antnum;
SKIPBITS(12)
GETSTRING(antnum,antenna)
memcpy(handle->antenna, antenna, antnum);
handle->antenna[antnum] = 0;
ret = type;
}
break;
case 1013:
{
SKIPBITS(12);
GETBITS(handle->modjulday, 16);
GETBITS(handle->secofday, 17);
SKIPBITS(5);
GETBITS(handle->leapsec, 8);
ret = 1013;
}
break;
#endif /* NO_RTCM3_MAIN */
case 1019:
if(size == 59)
{
struct gpsephemeris *ge;
int sv, i;
ge = &handle->ephemerisGPS;
memset(ge, 0, sizeof(*ge));
GETBITS(sv, 6)
ge->satellite = (sv < 40 ? sv : sv+80);
GETBITS(ge->GPSweek, 10)
ge->GPSweek += 1024;
GETBITS(ge->URAindex, 4)
GETBITS(sv, 2)
if(sv & 1)
ge->flags |= GPSEPHF_L2PCODE;
if(sv & 2)
ge->flags |= GPSEPHF_L2CACODE;
GETFLOATSIGN(ge->IDOT, 14, R2R_PI/(double)(1<<30)/(double)(1<<13))
GETBITS(ge->IODE, 8)
GETBITS(ge->TOC, 16)
ge->TOC <<= 4;
GETFLOATSIGN(ge->clock_driftrate, 8, 1.0/(double)(1<<30)/(double)(1<<25))
GETFLOATSIGN(ge->clock_drift, 16, 1.0/(double)(1<<30)/(double)(1<<13))
GETFLOATSIGN(ge->clock_bias, 22, 1.0/(double)(1<<30)/(double)(1<<1))
GETBITS(ge->IODC, 10)
GETFLOATSIGN(ge->Crs, 16, 1.0/(double)(1<<5))
GETFLOATSIGN(ge->Delta_n, 16, R2R_PI/(double)(1<<30)/(double)(1<<13))
GETFLOATSIGN(ge->M0, 32, R2R_PI/(double)(1<<30)/(double)(1<<1))
GETFLOATSIGN(ge->Cuc, 16, 1.0/(double)(1<<29))
GETFLOAT(ge->e, 32, 1.0/(double)(1<<30)/(double)(1<<3))
GETFLOATSIGN(ge->Cus, 16, 1.0/(double)(1<<29))
GETFLOAT(ge->sqrt_A, 32, 1.0/(double)(1<<19))
GETBITS(ge->TOE, 16)
ge->TOE <<= 4;
GETFLOATSIGN(ge->Cic, 16, 1.0/(double)(1<<29))
GETFLOATSIGN(ge->OMEGA0, 32, R2R_PI/(double)(1<<30)/(double)(1<<1))
GETFLOATSIGN(ge->Cis, 16, 1.0/(double)(1<<29))
GETFLOATSIGN(ge->i0, 32, R2R_PI/(double)(1<<30)/(double)(1<<1))
GETFLOATSIGN(ge->Crc, 16, 1.0/(double)(1<<5))
GETFLOATSIGN(ge->omega, 32, R2R_PI/(double)(1<<30)/(double)(1<<1))
GETFLOATSIGN(ge->OMEGADOT, 24, R2R_PI/(double)(1<<30)/(double)(1<<13))
GETFLOATSIGN(ge->TGD, 8, 1.0/(double)(1<<30)/(double)(1<<1))
GETBITS(ge->SVhealth, 6)
GETBITS(sv, 1)
if(sv)
ge->flags |= GPSEPHF_L2PCODEDATA;
GETBITS(sv, 1)
if(sv)
ge->flags |= GPSEPHF_6HOURSFIT;
i = ((int)ge->GPSweek - (int)handle->GPSWeek)*7*24*60*60
+ ((int)ge->TOE - (int)handle->GPSTOW) - 2*60*60;
if(i > 5*60*60 && i < 8*60*60)
{
handle->GPSTOW = ge->TOE;
handle->GPSWeek = ge->GPSweek;
}
ge->TOW = 0.9999E9;
ret = 1019;
}
break;
case RTCM3ID_BDS:
if(size == 62)
{
struct bdsephemeris *be;
int sv, i, week, tow;
be = &handle->ephemerisBDS;
memset(be, 0, sizeof(*be));
GETBITS(sv, 6)
be->satellite = sv+PRN_BDS_START-1;
GETBITS(be->BDSweek, 13)
GETBITS(be->URAI, 4)
GETFLOATSIGN(be->IDOT, 14, R2R_PI/(double)(1<<30)/(double)(1<<13))
GETBITS(be->AODE, 5)
GETBITS(be->TOC, 17)
be->TOC <<= 3;
GETFLOATSIGN(be->clock_driftrate, 11, 1.0/(double)(1<<30)/(double)(1<<30)/(double)(1<<6))
GETFLOATSIGN(be->clock_drift, 22, 1.0/(double)(1<<30)/(double)(1<<20))
GETFLOATSIGN(be->clock_bias, 24, 1.0/(double)(1<<30)/(double)(1<<3))
GETBITS(be->AODC, 5)
GETFLOATSIGN(be->Crs, 18, 1.0/(double)(1<<6))
GETFLOATSIGN(be->Delta_n, 16, R2R_PI/(double)(1<<30)/(double)(1<<13))
GETFLOATSIGN(be->M0, 32, R2R_PI/(double)(1<<30)/(double)(1<<1))
GETFLOATSIGN(be->Cuc, 18, 1.0/(double)(1<<30)/(double)(1<<1))
GETFLOAT(be->e, 32, 1.0/(double)(1<<30)/(double)(1<<3))
GETFLOATSIGN(be->Cus, 18, 1.0/(double)(1<<30)/(double)(1<<1))
GETFLOAT(be->sqrt_A, 32, 1.0/(double)(1<<19))
GETBITS(be->TOE, 17)
be->TOE <<= 3;
GETFLOATSIGN(be->Cic, 18, 1.0/(double)(1<<30)/(double)(1<<1))
GETFLOATSIGN(be->OMEGA0, 32, R2R_PI/(double)(1<<30)/(double)(1<<1))
GETFLOATSIGN(be->Cis, 18, 1.0/(double)(1<<30)/(double)(1<<1))
GETFLOATSIGN(be->i0, 32, R2R_PI/(double)(1<<30)/(double)(1<<1))
GETFLOATSIGN(be->Crc, 18, 1.0/(double)(1<<6))
GETFLOATSIGN(be->omega, 32, R2R_PI/(double)(1<<30)/(double)(1<<1))
GETFLOATSIGN(be->OMEGADOT, 24, R2R_PI/(double)(1<<30)/(double)(1<<13))
GETFLOATSIGN(be->TGD_B1_B3, 10, 0.0000000001)
GETFLOATSIGN(be->TGD_B2_B3, 10, 0.0000000001)
GETBITS(sv, 1)
if(sv)
be->flags |= BDSEPHF_SATH1;
week = 1356+be->BDSweek;
tow = 14+be->TOE;
if(tow > 7*24*60*60) /* overflow due to leap */
{
++week;
tow -= 7*24*60*60;
}
i = (week - (int)handle->GPSWeek)*7*24*60*60
+ (tow - (int)handle->GPSTOW) - 2*60*60;
if(i > 5*60*60 && i < 8*60*60)
{
handle->GPSTOW = tow;
handle->GPSWeek = week;
}
ret = RTCM3ID_BDS;
be->TOW = 0.9999E9;
}
break;
case 1043:
if(size == 27 && handle->GPSWeek)
{
struct sbasephemeris *gs;
int sv, i, time, tod, day;
gs = &handle->ephemerisSBAS;
memset(gs, 0, sizeof(*gs));
GETBITS(sv, 6)
gs->satellite = PRN_SBAS_START+sv;
GETBITS(gs->IODN, 8)
GETBITS(time, 13)
time <<= 4;
gs->GPSweek_TOE = handle->GPSWeek;
GETBITS(gs->URA, 4)
GETFLOATSIGN(gs->x_pos, 30, 0.08)
GETFLOATSIGN(gs->y_pos, 30, 0.08)
GETFLOATSIGN(gs->z_pos, 25, 0.4)
GETFLOATSIGN(gs->x_velocity, 17, 0.000625)
GETFLOATSIGN(gs->y_velocity, 17, 0.000625)
GETFLOATSIGN(gs->z_velocity, 18, 0.004)
GETFLOATSIGN(gs->x_acceleration, 10, 0.0000125)
GETFLOATSIGN(gs->y_acceleration, 10, 0.0000125)
GETFLOATSIGN(gs->z_acceleration, 10, 0.0000625)
GETFLOATSIGN(gs->agf0, 12, 1.0/(1<<30)/(1<<1))
GETFLOATSIGN(gs->agf1, 8, 1.0/(1<<30)/(1<<10))
/* calculate time */
tod = handle->GPSTOW%(24*60*60);
day = handle->GPSTOW/(24*60*60);
if(time > 19*60*60 && tod < 5*60*60)
--day;
else if(time < 5*60*60 && tod > 19*60*60)
++day;
time += day*24*60*60;
if(time > 7*24*60*60)
++gs->GPSweek_TOE;
else if(time < 0)
--gs->GPSweek_TOE;
gs->TOE = time;
i = (gs->GPSweek_TOE - handle->GPSWeek)*7*24*60*60
+ (gs->TOE - handle->GPSTOW) - 2*60*60;
if(i > 5*60*60 && i < 8*60*60)
{
handle->GPSTOW = gs->TOE;
handle->GPSWeek = gs->GPSweek_TOE;
}
gs->TOW = 0.9999E9;
ret = 1043;
}
break;
case 1044:
if(size == 59)
{
struct gpsephemeris *ge;
int sv, i;
ge = &handle->ephemerisGPS;
memset(ge, 0, sizeof(*ge));
GETBITS(sv, 4)
ge->satellite = PRN_QZSS_START+sv-1;
GETBITS(ge->TOC, 16)
ge->TOC <<= 4;
GETFLOATSIGN(ge->clock_driftrate, 8, 1.0/(double)(1<<30)/(double)(1<<25))
GETFLOATSIGN(ge->clock_drift, 16, 1.0/(double)(1<<30)/(double)(1<<13))
GETFLOATSIGN(ge->clock_bias, 22, 1.0/(double)(1<<30)/(double)(1<<1))
GETBITS(ge->IODE, 8)
GETFLOATSIGN(ge->Crs, 16, 1.0/(double)(1<<5))
GETFLOATSIGN(ge->Delta_n, 16, R2R_PI/(double)(1<<30)/(double)(1<<13))
GETFLOATSIGN(ge->M0, 32, R2R_PI/(double)(1<<30)/(double)(1<<1))
GETFLOATSIGN(ge->Cuc, 16, 1.0/(double)(1<<29))
GETFLOAT(ge->e, 32, 1.0/(double)(1<<30)/(double)(1<<3))
GETFLOATSIGN(ge->Cus, 16, 1.0/(double)(1<<29))
GETFLOAT(ge->sqrt_A, 32, 1.0/(double)(1<<19))
GETBITS(ge->TOE, 16)
ge->TOE <<= 4;
GETFLOATSIGN(ge->Cic, 16, 1.0/(double)(1<<29))
GETFLOATSIGN(ge->OMEGA0, 32, R2R_PI/(double)(1<<30)/(double)(1<<1))
GETFLOATSIGN(ge->Cis, 16, 1.0/(double)(1<<29))
GETFLOATSIGN(ge->i0, 32, R2R_PI/(double)(1<<30)/(double)(1<<1))
GETFLOATSIGN(ge->Crc, 16, 1.0/(double)(1<<5))
GETFLOATSIGN(ge->omega, 32, R2R_PI/(double)(1<<30)/(double)(1<<1))
GETFLOATSIGN(ge->OMEGADOT, 24, R2R_PI/(double)(1<<30)/(double)(1<<13))
GETFLOATSIGN(ge->IDOT, 14, R2R_PI/(double)(1<<30)/(double)(1<<13))
GETBITS(sv, 2)
if(sv & 1)
ge->flags |= GPSEPHF_L2PCODE;
if(sv & 2)
ge->flags |= GPSEPHF_L2CACODE;
GETBITS(ge->GPSweek, 10)
ge->GPSweek += 1024;
GETBITS(ge->URAindex, 4)
GETBITS(ge->SVhealth, 6)
GETFLOATSIGN(ge->TGD, 8, 1.0/(double)(1<<30)/(double)(1<<1))
GETBITS(ge->IODC, 10)
GETBITS(sv, 1)
if(sv)
ge->flags |= GPSEPHF_6HOURSFIT;
i = ((int)ge->GPSweek - (int)handle->GPSWeek)*7*24*60*60
+ ((int)ge->TOE - (int)handle->GPSTOW) - 2*60*60;
if(i > 5*60*60 && i < 8*60*60)
{
handle->GPSTOW = ge->TOE;
handle->GPSWeek = ge->GPSweek;
}
ge->TOW = 0.9999E9;
ret = 1044;
}
break;
case 1045: case 1046:
{
struct galileoephemeris *ge;
int sv;
ge = &handle->ephemerisGALILEO;
memset(ge, 0, sizeof(*ge));
GETBITS(sv, 6)
ge->satellite = sv;
GETBITS(ge->Week, 12)
ge->Week += 1024;
GETBITS(ge->IODnav, 10)
GETBITS(ge->SISA, 8)
GETFLOATSIGN(ge->IDOT, 14, R2R_PI/(double)(1<<30)/(double)(1<<13))
GETBITSFACTOR(ge->TOC, 14, 60)
GETFLOATSIGN(ge->clock_driftrate, 6, 1.0/(double)(1<<30)/(double)(1<<29))
GETFLOATSIGN(ge->clock_drift, 21, 1.0/(double)(1<<30)/(double)(1<<16))
GETFLOATSIGN(ge->clock_bias, 31, 1.0/(double)(1<<30)/(double)(1<<4))
GETFLOATSIGN(ge->Crs, 16, 1.0/(double)(1<<5))
GETFLOATSIGN(ge->Delta_n, 16, R2R_PI/(double)(1<<30)/(double)(1<<13))
GETFLOATSIGN(ge->M0, 32, R2R_PI/(double)(1<<30)/(double)(1<<1))
GETFLOATSIGN(ge->Cuc, 16, 1.0/(double)(1<<29))
GETFLOAT(ge->e, 32, 1.0/(double)(1<<30)/(double)(1<<3))
GETFLOATSIGN(ge->Cus, 16, 1.0/(double)(1<<29))
GETFLOAT(ge->sqrt_A, 32, 1.0/(double)(1<<19))
GETBITSFACTOR(ge->TOE, 14, 60)
GETFLOATSIGN(ge->Cic, 16, 1.0/(double)(1<<29))
GETFLOATSIGN(ge->OMEGA0, 32, R2R_PI/(double)(1<<30)/(double)(1<<1))
GETFLOATSIGN(ge->Cis, 16, 1.0/(double)(1<<29))
GETFLOATSIGN(ge->i0, 32, R2R_PI/(double)(1<<30)/(double)(1<<1))
GETFLOATSIGN(ge->Crc, 16, 1.0/(double)(1<<5))
GETFLOATSIGN(ge->omega, 32, R2R_PI/(double)(1<<30)/(double)(1<<1))
GETFLOATSIGN(ge->OMEGADOT, 24, R2R_PI/(double)(1<<30)/(double)(1<<13))
GETFLOATSIGN(ge->BGD_1_5A, 10, 1.0/(double)(1<<30)/(double)(1<<2))
if(type == 1046)
{
GETFLOATSIGN(ge->BGD_1_5B, 10, 1.0/(double)(1<<30)/(double)(1<<2))
GETBITS(ge->E5bHS, 2)
GETBITS(sv, 1)
ge->flags |= GALEPHF_INAV;
if(sv)
ge->flags |= GALEPHF_E5BDINVALID;
GETBITS(ge->E1_HS, 2)
GETBITS(sv, 1)
if(sv)
ge->flags |= GALEPHF_E1DINVALID;
}
else
{
ge->flags |= GALEPHF_FNAV;
GETBITS(ge->E5aHS, 2)
GETBITS(sv, 1)
if(sv)
ge->flags |= GALEPHF_E5ADINVALID;
}
ret = type;
}
break;
case 1020:
if(size == 43)
{
struct glonassephemeris *ge;
int i;
ge = &handle->ephemerisGLONASS;
memset(ge, 0, sizeof(*ge));
ge->flags |= GLOEPHF_PAVAILABLE;
GETBITS(ge->almanac_number, 6)
GETBITS(i, 5)
ge->frequency_number = i-7;
if(ge->almanac_number >= 1 && ge->almanac_number <= PRN_GLONASS_NUM)
handle->GLOFreq[ge->almanac_number-1] = 100+ge->frequency_number;
GETBITS(i, 1)
if(i)
ge->flags |= GLOEPHF_ALMANACHEALTHY;
GETBITS(i, 1)
if(i)
ge->flags |= GLOEPHF_ALMANACHEALTHOK;
GETBITS(i, 2)
if(i & 1)
ge->flags |= GLOEPHF_P10TRUE;
if(i & 2)
ge->flags |= GLOEPHF_P11TRUE;
GETBITS(i, 5)
ge->tk = i*60*60;
GETBITS(i, 6)
ge->tk += i*60;
GETBITS(i, 1)
ge->tk += i*30;
GETBITS(i, 1)
if(i)
ge->flags |= GLOEPHF_UNHEALTHY;
GETBITS(i, 1)
if(i)
ge->flags |= GLOEPHF_P2TRUE;
GETBITS(i, 7)
ge->tb = i*15*60;
GETFLOATSIGNM(ge->x_velocity, 24, 1.0/(double)(1<<20))
GETFLOATSIGNM(ge->x_pos, 27, 1.0/(double)(1<<11))
GETFLOATSIGNM(ge->x_acceleration, 5, 1.0/(double)(1<<30))
GETFLOATSIGNM(ge->y_velocity, 24, 1.0/(double)(1<<20))
GETFLOATSIGNM(ge->y_pos, 27, 1.0/(double)(1<<11))
GETFLOATSIGNM(ge->y_acceleration, 5, 1.0/(double)(1<<30))
GETFLOATSIGNM(ge->z_velocity, 24, 1.0/(double)(1<<20))
GETFLOATSIGNM(ge->z_pos, 27, 1.0/(double)(1<<11))
GETFLOATSIGNM(ge->z_acceleration, 5, 1.0/(double)(1<<30))
GETBITS(i, 1)
if(i)
ge->flags |= GLOEPHF_P3TRUE;
GETFLOATSIGNM(ge->gamma, 11, 1.0/(double)(1<<30)/(double)(1<<10))
SKIPBITS(3) /* GLONASS-M P, GLONASS-M ln (third string) */
GETFLOATSIGNM(ge->tau, 22, 1.0/(double)(1<<30)) /* GLONASS tau n(tb) */
SKIPBITS(5) /* GLONASS-M delta tau n(tb) */
GETBITS(ge->E, 5)
/* GETBITS(b, 1) / * GLONASS-M P4 */
/* GETBITS(b, 4) / * GLONASS-M Ft */
/* GETBITS(b, 11) / * GLONASS-M Nt */
/* GETBITS(b, 2) / * GLONASS-M M */
/* GETBITS(b, 1) / * GLONASS-M The Availability of Additional Data */
/* GETBITS(b, 11) / * GLONASS-M Na */
/* GETFLOATSIGNM(b, 32, 1.0/(double)(1<<30)/(double)(1<<1)) / * GLONASS tau c */
/* GETBITS(b, 5) / * GLONASS-M N4 */
/* GETFLOATSIGNM(b, 22, 1.0/(double)(1<<30)) / * GLONASS-M tau GPS */
/* GETBITS(b, 1) / * GLONASS-M ln (fifth string) */
ge->GPSWeek = handle->GPSWeek;
ge->GPSTOW = handle->GPSTOW;
ret = 1020;
}
break;
case 1001: case 1002: case 1003: case 1004:
if(handle->GPSWeek)
{
int lastlockl1[64];
int lastlockl2[64];
struct gnssdata *gnss;
int i, numsats, wasamb=0;
for(i = 0; i < 64; ++i)
lastlockl1[i] = lastlockl2[i] = 0;
gnss = &handle->DataNew;
SKIPBITS(12) /* id */
GETBITS(i,30)
if(i/1000 < (int)handle->GPSTOW - 86400)
++handle->GPSWeek;
handle->GPSTOW = i/1000;
if(gnss->week && (gnss->timeofweek != i || gnss->week
!= handle->GPSWeek))
{
handle->Data = *gnss;
memset(gnss, 0, sizeof(*gnss));
old = 1;
}
gnss->timeofweek = i;
gnss->week = handle->GPSWeek;
GETBITS(syncf,1) /* sync */
GETBITS(numsats,5)
SKIPBITS(4) /* smind, smint */
while(numsats-- && gnss->numsats < GNSS_MAXSATS)
{
int sv, code, l1range, c,l,s,ce,le,se,amb=0;
int fullsat, num;
GETBITS(sv, 6)
fullsat = sv < 40 ? sv : sv+80;
for(num = 0; num < gnss->numsats
&& fullsat != gnss->satellites[num]; ++num)
;
if(num == gnss->numsats)
gnss->satellites[gnss->numsats++] = fullsat;
/* L1 */
GETBITS(code, 1);
if(code)
{
c = GNSSDF_P1DATA; ce = GNSSENTRY_P1DATA;
l = GNSSDF_L1PDATA; le = GNSSENTRY_L1PDATA;
s = GNSSDF_S1PDATA; se = GNSSENTRY_S1PDATA;
gnss->codetype[num][se] =
gnss->codetype[num][ce] = gnss->codetype[num][le] = "1W";
}
else
{
c = GNSSDF_C1DATA; ce = GNSSENTRY_C1DATA;
l = GNSSDF_L1CDATA; le = GNSSENTRY_L1CDATA;
s = GNSSDF_S1CDATA; se = GNSSENTRY_S1CDATA;
gnss->codetype[num][se] =
gnss->codetype[num][ce] = gnss->codetype[num][le] = "1C";
}
if(!handle->info[RTCM3_MSM_GPS].type[ce])
{
handle->info[RTCM3_MSM_GPS].type[ce] =
handle->info[RTCM3_MSM_GPS].type[le] =
handle->info[RTCM3_MSM_GPS].type[se] = gnss->codetype[num][ce][1];
}
GETBITS(l1range, 24);
GETBITSSIGN(i, 20);
if((i&((1<<20)-1)) != 0x80000)
{
gnss->dataflags[num] |= (c|l);
gnss->measdata[num][ce] = l1range*0.02;
gnss->measdata[num][le] = l1range*0.02+i*0.0005;
}
GETBITS(i, 7);
lastlockl1[sv] = i;
if(handle->lastlockGPSl1[sv] > i || i == 0)
gnss->dataflags2[num] |= GNSSDF2_LOCKLOSSL1;
if(type == 1002 || type == 1004)
{
GETBITS(amb,8);
if(amb && (gnss->dataflags[num] & c))
{
gnss->measdata[num][ce] += amb*299792.458;
gnss->measdata[num][le] += amb*299792.458;
++wasamb;
}
GETBITS(i, 8);
if(i)
{
gnss->dataflags[num] |= s;
gnss->measdata[num][se] = i*0.25;
i /= 4*4;
if(i > 9) i = 9;
else if(i < 1) i = 1;
gnss->snrL1[num] = i;
}
}
gnss->measdata[num][le] /= GPS_WAVELENGTH_L1;
if(type == 1003 || type == 1004)
{
/* L2 */
GETBITS(code,2);
if(code)
{
c = GNSSDF_P2DATA; ce = GNSSENTRY_P2DATA;
l = GNSSDF_L2PDATA; le = GNSSENTRY_L2PDATA;
s = GNSSDF_S2PDATA; se = GNSSENTRY_S2PDATA;
if(code >= 2)
{
gnss->codetype[num][se] =
gnss->codetype[num][ce] = gnss->codetype[num][le] = "2W";
gnss->dataflags2[num] |= GNSSDF2_XCORRL2;
}
else
{
gnss->codetype[num][se] =
gnss->codetype[num][ce] = gnss->codetype[num][le] = "2P";
}
}
else
{
c = GNSSDF_C2DATA; ce = GNSSENTRY_C2DATA;
l = GNSSDF_L2CDATA; le = GNSSENTRY_L2CDATA;
s = GNSSDF_S2CDATA; se = GNSSENTRY_S2CDATA;
gnss->codetype[num][se] =
gnss->codetype[num][ce] = gnss->codetype[num][le] = "2 ";
}
if(!handle->info[RTCM3_MSM_GPS].type[ce])
{
handle->info[RTCM3_MSM_GPS].type[ce] =
handle->info[RTCM3_MSM_GPS].type[le] =
handle->info[RTCM3_MSM_GPS].type[se] = gnss->codetype[num][ce][1];
}
GETBITSSIGN(i,14);
if((i&((1<<14)-1)) != 0x2000)
{
gnss->dataflags[num] |= c;
gnss->measdata[num][ce] = l1range*0.02+i*0.02
+amb*299792.458;
}
GETBITSSIGN(i,20);
if((i&((1<<20)-1)) != 0x80000)
{
gnss->dataflags[num] |= l;
gnss->measdata[num][le] = l1range*0.02+i*0.0005
+amb*299792.458;
}
GETBITS(i,7);
lastlockl2[sv] = i;
if(handle->lastlockGPSl2[sv] > i || i == 0)
gnss->dataflags2[num] |= GNSSDF2_LOCKLOSSL2;
if(type == 1004)
{
GETBITS(i, 8);
if(i)
{
gnss->dataflags[num] |= s;
gnss->measdata[num][se] = i*0.25;
i /= 4*4;
if(i > 9) i = 9;
else if(i < 1) i = 1;
gnss->snrL2[num] = i;
}
}
gnss->measdata[num][le] /= GPS_WAVELENGTH_L2;
}
}
for(i = 0; i < 64; ++i)
{
handle->lastlockGPSl1[i] = lastlockl1[i];
handle->lastlockGPSl2[i] = lastlockl2[i];
}
if(!syncf && !old)
{
handle->Data = *gnss;
memset(gnss, 0, sizeof(*gnss));
}
if(!syncf || old)
{
if(wasamb) /* not RINEX compatible without */
ret = 1;
else
ret = 2;
}
#ifdef NO_RTCM3_MAIN
else
ret = type;
#endif /* NO_RTCM3_MAIN */
}
break;
case 1009: case 1010: case 1011: case 1012:
{
int lastlockl1[64];
int lastlockl2[64];
struct gnssdata *gnss;
int i, numsats;
int wasamb=0;
for(i = 0; i < 64; ++i)
lastlockl1[i] = lastlockl2[i] = 0;
gnss = &handle->DataNew;
SKIPBITS(12) /* id */;
GETBITS(i,27) /* tk */
updatetime(&handle->GPSWeek, &handle->GPSTOW, i, 0); /* Moscow -> GPS */
i = handle->GPSTOW*1000;
if(gnss->week && (gnss->timeofweek != i || gnss->week
!= handle->GPSWeek))
{
handle->Data = *gnss;
memset(gnss, 0, sizeof(*gnss));
old = 1;
}
gnss->timeofweek = i;
gnss->week = handle->GPSWeek;
GETBITS(syncf,1) /* sync */
GETBITS(numsats,5)
SKIPBITS(4) /* smind, smint */
while(numsats-- && gnss->numsats < GNSS_MAXSATS)
{
int sv, code, l1range, c,l,s,ce,le,se,amb=0;
int freq;
int fullsat, num;
GETBITS(sv, 6)
fullsat = sv-1 + PRN_GLONASS_START;
for(num = 0; num < gnss->numsats
&& fullsat != gnss->satellites[num]; ++num)
;
if(num == gnss->numsats)
gnss->satellites[gnss->numsats++] = fullsat;
/* L1 */
GETBITS(code, 1)
GETBITS(freq, 5)
if(sv >= 1 && sv <= PRN_GLONASS_NUM)
handle->GLOFreq[sv-1] = 100+freq-7;
if(code)
{
c = GNSSDF_P1DATA; ce = GNSSENTRY_P1DATA;
l = GNSSDF_L1PDATA; le = GNSSENTRY_L1PDATA;
s = GNSSDF_S1PDATA; se = GNSSENTRY_S1PDATA;
gnss->codetype[num][se] =
gnss->codetype[num][ce] = gnss->codetype[num][le] = "1P";
}
else
{
c = GNSSDF_C1DATA; ce = GNSSENTRY_C1DATA;
l = GNSSDF_L1CDATA; le = GNSSENTRY_L1CDATA;
s = GNSSDF_S1CDATA; se = GNSSENTRY_S1CDATA;
gnss->codetype[num][se] =
gnss->codetype[num][ce] = gnss->codetype[num][le] = "1C";
}
if(!handle->info[RTCM3_MSM_GLONASS].type[ce])
{
handle->info[RTCM3_MSM_GLONASS].type[ce] =
handle->info[RTCM3_MSM_GLONASS].type[le] =
handle->info[RTCM3_MSM_GLONASS].type[se] = gnss->codetype[num][ce][1];
}
GETBITS(l1range, 25)
GETBITSSIGN(i, 20)
if((i&((1<<20)-1)) != 0x80000)
{
/* Handle this like GPS. Actually for GLONASS L1 range is always
valid. To be on the save side, we handle it as invalid like we
do for GPS and also remove range in case of 0x80000. */
gnss->dataflags[num] |= (c|l);
gnss->measdata[num][ce] = l1range*0.02;
gnss->measdata[num][le] = l1range*0.02+i*0.0005;
}
GETBITS(i, 7)
lastlockl1[sv] = i;
if(handle->lastlockGLOl1[sv] > i || i == 0)
gnss->dataflags2[num] |= GNSSDF2_LOCKLOSSL1;
if(type == 1010 || type == 1012)
{
GETBITS(amb,7)
if(amb && (gnss->dataflags[num] & c))
{
gnss->measdata[num][ce] += amb*599584.916;
gnss->measdata[num][le] += amb*599584.916;
++wasamb;
}
GETBITS(i, 8)
if(i)
{
gnss->dataflags[num] |= s;
gnss->measdata[num][se] = i*0.25;
i /= 4*4;
if(i > 9) i = 9;
else if(i < 1) i = 1;
gnss->snrL1[num] = i;
}
}
gnss->measdata[num][le] /= GLO_WAVELENGTH_L1(freq-7);
if(type == 1011 || type == 1012)
{
/* L2 */
GETBITS(code,2)
if(code)
{
c = GNSSDF_P2DATA; ce = GNSSENTRY_P2DATA;
l = GNSSDF_L2PDATA; le = GNSSENTRY_L2PDATA;
s = GNSSDF_S2PDATA; se = GNSSENTRY_S2PDATA;
gnss->codetype[num][se] =
gnss->codetype[num][ce] = gnss->codetype[num][le] = "2P";
}
else
{
c = GNSSDF_C2DATA; ce = GNSSENTRY_C2DATA;
l = GNSSDF_L2CDATA; le = GNSSENTRY_L2CDATA;
s = GNSSDF_S2CDATA; se = GNSSENTRY_S2CDATA;
gnss->codetype[num][se] =
gnss->codetype[num][ce] = gnss->codetype[num][le] = "2C";
}
if(!handle->info[RTCM3_MSM_GLONASS].type[ce])
{
handle->info[RTCM3_MSM_GLONASS].type[ce] =
handle->info[RTCM3_MSM_GLONASS].type[le] =
handle->info[RTCM3_MSM_GLONASS].type[se] = gnss->codetype[num][ce][1];
}
GETBITSSIGN(i,14)
if((i&((1<<14)-1)) != 0x2000)
{
gnss->dataflags[num] |= c;
gnss->measdata[num][ce] = l1range*0.02+i*0.02
+amb*599584.916;
}
GETBITSSIGN(i,20)
if((i&((1<<20)-1)) != 0x80000)
{
gnss->dataflags[num] |= l;
gnss->measdata[num][le] = l1range*0.02+i*0.0005
+amb*599584.916;
}
GETBITS(i,7)
lastlockl2[sv] = i;
if(handle->lastlockGLOl2[sv] > i || i == 0)
gnss->dataflags2[num] |= GNSSDF2_LOCKLOSSL2;
if(type == 1012)
{
GETBITS(i, 8)
if(i)
{
gnss->dataflags[num] |= s;
gnss->measdata[num][se] = i*0.25;
i /= 4*4;
if(i > 9) i = 9;
else if(i < 1) i = 1;
gnss->snrL2[num] = i;
}
}
gnss->measdata[num][le] /= GLO_WAVELENGTH_L2(freq-7);
}
if(!sv || sv > 24) /* illegal, remove it again */
--gnss->numsats;
}
for(i = 0; i < 64; ++i)
{
handle->lastlockGLOl1[i] = lastlockl1[i];
handle->lastlockGLOl2[i] = lastlockl2[i];
}
if(!syncf && !old)
{
handle->Data = *gnss;
memset(gnss, 0, sizeof(*gnss));
}
if(!syncf || old)
{
if(wasamb) /* not RINEX compatible without */
ret = 1;
else
ret = 2;
}
#ifdef NO_RTCM3_MAIN
else
ret = type;
#endif /* NO_RTCM3_MAIN */
}
break;
case 1071: case 1081: case 1091: case 1101: case 1111: case 1121:
case 1072: case 1082: case 1092: case 1102: case 1112: case 1122:
case 1073: case 1083: case 1093: case 1103: case 1113: case 1123:
case 1074: case 1084: case 1094: case 1104: case 1114: case 1124:
case 1075: case 1085: case 1095: case 1105: case 1115: case 1125:
case 1076: case 1086: case 1096: case 1106: case 1116: case 1126:
case 1077: case 1087: case 1097: case 1107: case 1117: case 1127:
if(handle->GPSWeek)
{
struct CodeData {
int typeR;
int typeP;
int typeD;
int typeS;
int lock;
double wl;
const char *code; /* currently unused */
};
struct CodeData gps[RTCM3_MSM_NUMSIG] =
{
{0,0,0,0,0,0,0},
{GNSSENTRY_C1DATA,GNSSENTRY_L1CDATA,GNSSENTRY_D1CDATA,
GNSSENTRY_S1CDATA,GNSSDF2_LOCKLOSSL1,GPS_WAVELENGTH_L1,"1C"},
{GNSSENTRY_P1DATA,GNSSENTRY_L1PDATA,GNSSENTRY_D1PDATA,
GNSSENTRY_S1PDATA,GNSSDF2_LOCKLOSSL1,GPS_WAVELENGTH_L1,"1P"},
{GNSSENTRY_P1DATA,GNSSENTRY_L1PDATA,GNSSENTRY_D1PDATA,
GNSSENTRY_S1PDATA,GNSSDF2_LOCKLOSSL1,GPS_WAVELENGTH_L1,"1W"},
{0,0,0,0,0,0,0}/*{GNSSENTRY_P1DATA,GNSSENTRY_L1PDATA,GNSSENTRY_D1PDATA,
GNSSENTRY_S1PDATA,GNSSDF2_LOCKLOSSL1,GPS_WAVELENGTH_L1,"1Y"}*/,
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{GNSSENTRY_C2DATA,GNSSENTRY_L2CDATA,GNSSENTRY_D2CDATA,
GNSSENTRY_S2CDATA,GNSSDF2_LOCKLOSSL2,GPS_WAVELENGTH_L2,"2C"},
{GNSSENTRY_P2DATA,GNSSENTRY_L2PDATA,GNSSENTRY_D2PDATA,
GNSSENTRY_S2PDATA,GNSSDF2_LOCKLOSSL2,GPS_WAVELENGTH_L2,"2P"},
{GNSSENTRY_P2DATA,GNSSENTRY_L2PDATA,GNSSENTRY_D2PDATA,
GNSSENTRY_S2PDATA,GNSSDF2_LOCKLOSSL2,GPS_WAVELENGTH_L2,"2W"},
{0,0,0,0,0,0,0}/*{GNSSENTRY_P2DATA,GNSSENTRY_L2PDATA,GNSSENTRY_D2PDATA,
GNSSENTRY_S2PDATA,GNSSDF2_LOCKLOSSL2,GPS_WAVELENGTH_L2,"2Y"}*/,
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{GNSSENTRY_C2DATA,GNSSENTRY_L2CDATA,GNSSENTRY_D2CDATA,
GNSSENTRY_S2CDATA,GNSSDF2_LOCKLOSSL2,GPS_WAVELENGTH_L2,"2S"},
{GNSSENTRY_C2DATA,GNSSENTRY_L2CDATA,GNSSENTRY_D2CDATA,
GNSSENTRY_S2CDATA,GNSSDF2_LOCKLOSSL2,GPS_WAVELENGTH_L2,"2L"},
{GNSSENTRY_C2DATA,GNSSENTRY_L2CDATA,GNSSENTRY_D2CDATA,
GNSSENTRY_S2CDATA,GNSSDF2_LOCKLOSSL2,GPS_WAVELENGTH_L2,"2X"},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{GNSSENTRY_C5DATA,GNSSENTRY_L5DATA,GNSSENTRY_D5DATA,
GNSSENTRY_S5DATA,GNSSDF2_LOCKLOSSL5,GPS_WAVELENGTH_L5,"5I"},
{GNSSENTRY_C5DATA,GNSSENTRY_L5DATA,GNSSENTRY_D5DATA,
GNSSENTRY_S5DATA,GNSSDF2_LOCKLOSSL5,GPS_WAVELENGTH_L5,"5Q"},
{GNSSENTRY_C5DATA,GNSSENTRY_L5DATA,GNSSENTRY_D5DATA,
GNSSENTRY_S5DATA,GNSSDF2_LOCKLOSSL5,GPS_WAVELENGTH_L5,"5X"},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{GNSSENTRY_C1NDATA,GNSSENTRY_L1NDATA,GNSSENTRY_D1NDATA,
GNSSENTRY_S1NDATA,GNSSDF2_LOCKLOSSL1,GPS_WAVELENGTH_L1,"1S"},
{GNSSENTRY_C1NDATA,GNSSENTRY_L1NDATA,GNSSENTRY_D1NDATA,
GNSSENTRY_S1NDATA,GNSSDF2_LOCKLOSSL1,GPS_WAVELENGTH_L1,"1L"},
{GNSSENTRY_C1NDATA,GNSSENTRY_L1NDATA,GNSSENTRY_D1NDATA,
GNSSENTRY_S1NDATA,GNSSDF2_LOCKLOSSL1,GPS_WAVELENGTH_L1,"1X"}
};
/* NOTE: Uses 0.0, 1.0 for wavelength as sat index dependence is done later! */
struct CodeData glo[RTCM3_MSM_NUMSIG] =
{
{0,0,0,0,0,0,0},
{GNSSENTRY_C1DATA,GNSSENTRY_L1CDATA,GNSSENTRY_D1CDATA,
GNSSENTRY_S1CDATA,GNSSDF2_LOCKLOSSL1,0.0,"1C"},
{GNSSENTRY_P1DATA,GNSSENTRY_L1PDATA,GNSSENTRY_D1PDATA,
GNSSENTRY_S1PDATA,GNSSDF2_LOCKLOSSL1,0.0,"1P"},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{GNSSENTRY_C2DATA,GNSSENTRY_L2CDATA,GNSSENTRY_D2CDATA,
GNSSENTRY_S2CDATA,GNSSDF2_LOCKLOSSL2,1.0,"2C"},
{GNSSENTRY_P2DATA,GNSSENTRY_L2PDATA,GNSSENTRY_D2PDATA,
GNSSENTRY_S2PDATA,GNSSDF2_LOCKLOSSL2,1.0,"2P"},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0}
};
struct CodeData gal[RTCM3_MSM_NUMSIG] =
{
{0,0,0,0,0,0,0},
{GNSSENTRY_C1DATA,GNSSENTRY_L1CDATA,GNSSENTRY_D1CDATA,
GNSSENTRY_S1CDATA,GNSSDF2_LOCKLOSSL1,GAL_WAVELENGTH_E1,"1C"},
{GNSSENTRY_C1DATA,GNSSENTRY_L1CDATA,GNSSENTRY_D1CDATA,
GNSSENTRY_S1CDATA,GNSSDF2_LOCKLOSSL1,GAL_WAVELENGTH_E1,"1A"},
{GNSSENTRY_C1DATA,GNSSENTRY_L1CDATA,GNSSENTRY_D1CDATA,
GNSSENTRY_S1CDATA,GNSSDF2_LOCKLOSSL1,GAL_WAVELENGTH_E1,"1B"},
{GNSSENTRY_C1DATA,GNSSENTRY_L1CDATA,GNSSENTRY_D1CDATA,
GNSSENTRY_S1CDATA,GNSSDF2_LOCKLOSSL1,GAL_WAVELENGTH_E1,"1X"},
{GNSSENTRY_C1DATA,GNSSENTRY_L1CDATA,GNSSENTRY_D1CDATA,
GNSSENTRY_S1CDATA,GNSSDF2_LOCKLOSSL1,GAL_WAVELENGTH_E1,"1Z"},
{0,0,0,0,0,0,0},
{GNSSENTRY_C6DATA,GNSSENTRY_L6DATA,GNSSENTRY_D6DATA,
GNSSENTRY_S6DATA,GNSSDF2_LOCKLOSSE6,GAL_WAVELENGTH_E6,"6C"},
{GNSSENTRY_C6DATA,GNSSENTRY_L6DATA,GNSSENTRY_D6DATA,
GNSSENTRY_S6DATA,GNSSDF2_LOCKLOSSE6,GAL_WAVELENGTH_E6,"6A"},
{GNSSENTRY_C6DATA,GNSSENTRY_L6DATA,GNSSENTRY_D6DATA,
GNSSENTRY_S6DATA,GNSSDF2_LOCKLOSSE6,GAL_WAVELENGTH_E6,"6B"},
{GNSSENTRY_C6DATA,GNSSENTRY_L6DATA,GNSSENTRY_D6DATA,
GNSSENTRY_S6DATA,GNSSDF2_LOCKLOSSE6,GAL_WAVELENGTH_E6,"6X"},
{GNSSENTRY_C6DATA,GNSSENTRY_L6DATA,GNSSENTRY_D6DATA,
GNSSENTRY_S6DATA,GNSSDF2_LOCKLOSSE6,GAL_WAVELENGTH_E6,"6Z"},
{0,0,0,0,0,0,0},
{GNSSENTRY_C5BDATA,GNSSENTRY_L5BDATA,GNSSENTRY_D5BDATA,
GNSSENTRY_S5BDATA,GNSSDF2_LOCKLOSSE5B,GAL_WAVELENGTH_E5B,"7I"},
{GNSSENTRY_C5BDATA,GNSSENTRY_L5BDATA,GNSSENTRY_D5BDATA,
GNSSENTRY_S5BDATA,GNSSDF2_LOCKLOSSE5B,GAL_WAVELENGTH_E5B,"7Q"},
{GNSSENTRY_C5BDATA,GNSSENTRY_L5BDATA,GNSSENTRY_D5BDATA,
GNSSENTRY_S5BDATA,GNSSDF2_LOCKLOSSE5B,GAL_WAVELENGTH_E5B,"7X"},
{0,0,0,0,0,0,0},
{GNSSENTRY_C5ABDATA,GNSSENTRY_L5ABDATA,GNSSENTRY_D5ABDATA,
GNSSENTRY_S5ABDATA,GNSSDF2_LOCKLOSSE5AB,GAL_WAVELENGTH_E5AB,"8I"},
{GNSSENTRY_C5ABDATA,GNSSENTRY_L5ABDATA,GNSSENTRY_D5ABDATA,
GNSSENTRY_S5ABDATA,GNSSDF2_LOCKLOSSE5AB,GAL_WAVELENGTH_E5AB,"8Q"},
{GNSSENTRY_C5ABDATA,GNSSENTRY_L5ABDATA,GNSSENTRY_D5ABDATA,
GNSSENTRY_S5ABDATA,GNSSDF2_LOCKLOSSE5AB,GAL_WAVELENGTH_E5AB,"8X"},
{0,0,0,0,0,0,0},
{GNSSENTRY_C5DATA,GNSSENTRY_L5DATA,GNSSENTRY_D5DATA,
GNSSENTRY_S5DATA,GNSSDF2_LOCKLOSSL5,GAL_WAVELENGTH_E5A,"5I"},
{GNSSENTRY_C5DATA,GNSSENTRY_L5DATA,GNSSENTRY_D5DATA,
GNSSENTRY_S5DATA,GNSSDF2_LOCKLOSSL5,GAL_WAVELENGTH_E5A,"5Q"},
{GNSSENTRY_C5DATA,GNSSENTRY_L5DATA,GNSSENTRY_D5DATA,
GNSSENTRY_S5DATA,GNSSDF2_LOCKLOSSL5,GAL_WAVELENGTH_E5A,"5X"},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
};
struct CodeData qzss[RTCM3_MSM_NUMSIG] =
{
{0,0,0,0,0,0,0},
{GNSSENTRY_C1DATA,GNSSENTRY_L1CDATA,GNSSENTRY_D1CDATA,
GNSSENTRY_S1CDATA,GNSSDF2_LOCKLOSSL1,GPS_WAVELENGTH_L1,"1C"},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{GNSSENTRY_CSAIFDATA,GNSSENTRY_LSAIFDATA,GNSSENTRY_DSAIFDATA,
GNSSENTRY_SSAIFDATA,GNSSDF2_LOCKLOSSSAIF,GPS_WAVELENGTH_L1,"1Z"},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{GNSSENTRY_CLEXDATA,GNSSENTRY_LLEXDATA,GNSSENTRY_DLEXDATA,
GNSSENTRY_SLEXDATA,GNSSDF2_LOCKLOSSLEX,QZSS_WAVELENGTH_LEX,"6S"},
{GNSSENTRY_CLEXDATA,GNSSENTRY_LLEXDATA,GNSSENTRY_DLEXDATA,
GNSSENTRY_SLEXDATA,GNSSDF2_LOCKLOSSLEX,QZSS_WAVELENGTH_LEX,"6L"},
{GNSSENTRY_CLEXDATA,GNSSENTRY_LLEXDATA,GNSSENTRY_DLEXDATA,
GNSSENTRY_SLEXDATA,GNSSDF2_LOCKLOSSLEX,QZSS_WAVELENGTH_LEX,"6X"},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{GNSSENTRY_C2DATA,GNSSENTRY_L2CDATA,GNSSENTRY_D2CDATA,
GNSSENTRY_S2CDATA,GNSSDF2_LOCKLOSSL2,GPS_WAVELENGTH_L2,"2S"},
{GNSSENTRY_C2DATA,GNSSENTRY_L2CDATA,GNSSENTRY_D2CDATA,
GNSSENTRY_S2CDATA,GNSSDF2_LOCKLOSSL2,GPS_WAVELENGTH_L2,"2L"},
{GNSSENTRY_C2DATA,GNSSENTRY_L2CDATA,GNSSENTRY_D2CDATA,
GNSSENTRY_S2CDATA,GNSSDF2_LOCKLOSSL2,GPS_WAVELENGTH_L2,"2X"},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{GNSSENTRY_C5DATA,GNSSENTRY_L5DATA,GNSSENTRY_D5DATA,
GNSSENTRY_S5DATA,GNSSDF2_LOCKLOSSL5,GPS_WAVELENGTH_L5,"5I"},
{GNSSENTRY_C5DATA,GNSSENTRY_L5DATA,GNSSENTRY_D5DATA,
GNSSENTRY_S5DATA,GNSSDF2_LOCKLOSSL5,GPS_WAVELENGTH_L5,"5Q"},
{GNSSENTRY_C5DATA,GNSSENTRY_L5DATA,GNSSENTRY_D5DATA,
GNSSENTRY_S5DATA,GNSSDF2_LOCKLOSSL5,GPS_WAVELENGTH_L5,"5X"},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{GNSSENTRY_C1NDATA,GNSSENTRY_L1NDATA,GNSSENTRY_D1NDATA,
GNSSENTRY_S1NDATA,GNSSDF2_LOCKLOSSL1,GPS_WAVELENGTH_L1,"1D"},
{GNSSENTRY_C1NDATA,GNSSENTRY_L1NDATA,GNSSENTRY_D1NDATA,
GNSSENTRY_S1NDATA,GNSSDF2_LOCKLOSSL1,GPS_WAVELENGTH_L1,"1P"},
{GNSSENTRY_C1NDATA,GNSSENTRY_L1NDATA,GNSSENTRY_D1NDATA,
GNSSENTRY_S1NDATA,GNSSDF2_LOCKLOSSL1,GPS_WAVELENGTH_L1,"1X"}
};
struct CodeData bds[RTCM3_MSM_NUMSIG] =
{
{0,0,0,0,0,0,0},
{GNSSENTRY_CB1DATA,GNSSENTRY_LB1DATA,GNSSENTRY_DB1DATA,
GNSSENTRY_SB1DATA,GNSSDF2_LOCKLOSSB1,BDS_WAVELENGTH_B1,"1I"},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{GNSSENTRY_CB3DATA,GNSSENTRY_LB3DATA,GNSSENTRY_DB3DATA,
GNSSENTRY_SB3DATA,GNSSDF2_LOCKLOSSB3,BDS_WAVELENGTH_B3,"6I"},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{GNSSENTRY_CB2DATA,GNSSENTRY_LB2DATA,GNSSENTRY_DB2DATA,
GNSSENTRY_SB2DATA,GNSSDF2_LOCKLOSSB2,BDS_WAVELENGTH_B2,"7I"},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
};
int sys = RTCM3_MSM_GPS, i=0, count, j, old = 0, wasnoamb = 0,
start=PRN_GPS_START;
int syncf, sigmask, numsat = 0, numsig = 0, numcells;
uint64_t satmask, cellmask, ui;
double rrmod[RTCM3_MSM_NUMSAT];
int rrint[RTCM3_MSM_NUMSAT], rdop[RTCM3_MSM_NUMSAT],
extsat[RTCM3_MSM_NUMSAT];
int ll[RTCM3_MSM_NUMCELLS]/*, hc[RTCM3_MSM_NUMCELLS]*/;
double cnr[RTCM3_MSM_NUMCELLS];
double cp[RTCM3_MSM_NUMCELLS], psr[RTCM3_MSM_NUMCELLS],
dop[RTCM3_MSM_NUMCELLS];
struct gnssdata *gnss = &handle->DataNew;
SKIPBITS(12)
if(type >= 1121)
{
sys = RTCM3_MSM_BDS;
start = PRN_BDS_START;
}
else if(type >= 1111)
{
sys = RTCM3_MSM_QZSS;
start = PRN_QZSS_START;
}
else if(type >= 1101)
{
sys = RTCM3_MSM_SBAS;
start = PRN_SBAS_START;
}
else if(type >= 1091)
{
sys = RTCM3_MSM_GALILEO;
start = PRN_GALILEO_START;
}
else if(type >= 1081)
{
sys = RTCM3_MSM_GLONASS;
start = PRN_GLONASS_START;
}
for(i = 0; i < RTCM3_MSM_NUMSAT; ++i)
extsat[i] = 15;
switch(sys)
{
case RTCM3_MSM_BDS:
GETBITS(i,30)
i += 14000;
if(i >= 7*24*60*60*1000)
i -= 7*24*60*60*1000;
if(i/1000 < (int)handle->GPSTOW - 86400)
++handle->GPSWeek;
handle->GPSTOW = i/1000;
break;
case RTCM3_MSM_GALILEO: /* use DF004 instead of DF248 */
case RTCM3_MSM_QZSS:
case RTCM3_MSM_SBAS:
case RTCM3_MSM_GPS:
GETBITS(i,30)
if(i/1000 < (int)handle->GPSTOW - 86400)
++handle->GPSWeek;
handle->GPSTOW = i/1000;
break;
case RTCM3_MSM_GLONASS:
SKIPBITS(3)
GETBITS(i,27) /* tk */
updatetime(&handle->GPSWeek, &handle->GPSTOW, i, 0); /* Moscow -> GPS */
i = handle->GPSTOW*1000;
break;
}
if(gnss->week && (gnss->timeofweek != i || gnss->week
!= handle->GPSWeek))
{
handle->Data = *gnss;
memset(gnss, 0, sizeof(*gnss));
old = 1;
}
gnss->timeofweek = i;
gnss->week = handle->GPSWeek;
GETBITS(syncf, 1)
SKIPBITS(3+7+2+2+1+3)
GETBITS64(satmask, RTCM3_MSM_NUMSAT)
/* http://gurmeetsingh.wordpress.com/2008/08/05/fast-bit-counting-routines/ */
for(ui = satmask; ui; ui &= (ui - 1) /* remove rightmost bit */)
++numsat;
GETBITS(sigmask, RTCM3_MSM_NUMSIG)
for(i = sigmask; i; i &= (i - 1) /* remove rightmost bit */)
++numsig;
i = numsat*numsig;
GETBITS64(cellmask, (unsigned)i)
switch(type % 10)
{
case 1: case 2: case 3:
++wasnoamb;
for(j = numsat; j--;)
GETFLOAT(rrmod[j], 10, 1.0/1024.0)
break;
case 4: case 6:
for(j = numsat; j--;)
GETBITS(rrint[j], 8)
for(j = numsat; j--;)
GETFLOAT(rrmod[j], 10, 1.0/1024.0)
break;
case 5: case 7:
for(j = numsat; j--;)
GETBITS(rrint[j], 8)
for(j = numsat; j--;)
GETBITS(extsat[j], 4)
for(j = numsat; j--;)
GETFLOAT(rrmod[j], 10, 1.0/1024.0)
for(j = numsat; j--;)
GETBITSSIGN(rdop[j], 14)
break;
}
numcells = numsat*numsig;
if(numcells <= RTCM3_MSM_NUMCELLS)
{
switch(type % 10)
{
case 1:
for(count = numcells; count--;)
if(cellmask & (UINT64(1)<<count))
GETFLOATSIGN(psr[count], 15, 1.0/(1<<24))
break;
case 2:
for(count = numcells; count--;)
if(cellmask & (UINT64(1)<<count))
GETFLOATSIGN(cp[count], 22, 1.0/(1<<29))
for(count = numcells; count--;)
if(cellmask & (UINT64(1)<<count))
GETBITS(ll[count], 4)
for(count = numcells; count--;)
if(cellmask & (UINT64(1)<<count))
SKIPBITS(1)/*GETBITS(hc[count], 1)*/
break;
case 3:
for(count = numcells; count--;)
if(cellmask & (UINT64(1)<<count))
GETFLOATSIGN(psr[count], 15, 1.0/(1<<24))
for(count = numcells; count--;)
if(cellmask & (UINT64(1)<<count))
GETFLOATSIGN(cp[count], 22, 1.0/(1<<29))
for(count = numcells; count--;)
if(cellmask & (UINT64(1)<<count))
GETBITS(ll[count], 4)
for(count = numcells; count--;)
if(cellmask & (UINT64(1)<<count))
SKIPBITS(1)/*GETBITS(hc[count], 1)*/
break;
case 4:
for(count = numcells; count--;)
if(cellmask & (UINT64(1)<<count))
GETFLOATSIGN(psr[count], 15, 1.0/(1<<24))
for(count = numcells; count--;)
if(cellmask & (UINT64(1)<<count))
GETFLOATSIGN(cp[count], 22, 1.0/(1<<29))
for(count = numcells; count--;)
if(cellmask & (UINT64(1)<<count))
GETBITS(ll[count], 4)
for(count = numcells; count--;)
if(cellmask & (UINT64(1)<<count))
SKIPBITS(1)/*GETBITS(hc[count], 1)*/
for(count = numcells; count--;)
if(cellmask & (UINT64(1)<<count))
GETBITS(cnr[count], 6)
break;
case 5:
for(count = numcells; count--;)
if(cellmask & (UINT64(1)<<count))
GETFLOATSIGN(psr[count], 15, 1.0/(1<<24))
for(count = numcells; count--;)
if(cellmask & (UINT64(1)<<count))
GETFLOATSIGN(cp[count], 22, 1.0/(1<<29))
for(count = numcells; count--;)
if(cellmask & (UINT64(1)<<count))
GETBITS(ll[count], 4)
for(count = numcells; count--;)
if(cellmask & (UINT64(1)<<count))
SKIPBITS(1)/*GETBITS(hc[count], 1)*/
for(count = numcells; count--;)
if(cellmask & (UINT64(1)<<count))
GETFLOAT(cnr[count], 6, 1.0)
for(count = numcells; count--;)
if(cellmask & (UINT64(1)<<count))
GETFLOATSIGN(dop[count], 15, 0.0001)
break;
case 6:
for(count = numcells; count--;)
if(cellmask & (UINT64(1)<<count))
GETFLOATSIGN(psr[count], 20, 1.0/(1<<29))
for(count = numcells; count--;)
if(cellmask & (UINT64(1)<<count))
GETFLOATSIGN(cp[count], 24, 1.0/(1U<<31))
for(count = numcells; count--;)
if(cellmask & (UINT64(1)<<count))
GETBITS(ll[count], 10)
for(count = numcells; count--;)
if(cellmask & (UINT64(1)<<count))
SKIPBITS(1)/*GETBITS(hc[count], 1)*/
for(count = numcells; count--;)
if(cellmask & (UINT64(1)<<count))
GETFLOAT(cnr[count], 10, 1.0/(1<<4))
break;
case 7:
for(count = numcells; count--;)
if(cellmask & (UINT64(1)<<count))
GETFLOATSIGN(psr[count], 20, 1.0/(1<<29))
for(count = numcells; count--;)
if(cellmask & (UINT64(1)<<count))
GETFLOATSIGN(cp[count], 24, 1.0/(1U<<31))
for(count = numcells; count--;)
if(cellmask & (UINT64(1)<<count))
GETBITS(ll[count], 10)
for(count = numcells; count--;)
if(cellmask & (UINT64(1)<<count))
SKIPBITS(1)/*GETBITS(hc[count], 1)*/
for(count = numcells; count--;)
if(cellmask & (UINT64(1)<<count))
GETFLOAT(cnr[count], 10, 1.0/(1<<4))
for(count = numcells; count--;)
if(cellmask & (UINT64(1)<<count))
GETFLOATSIGN(dop[count], 15, 0.0001)
break;
}
i = RTCM3_MSM_NUMSAT;
j = -1;
for(count = numcells; count--;)
{
while(j >= 0 && !(sigmask&(1<<--j)))
;
if(j < 0)
{
while(!(satmask&(UINT64(1)<<(--i)))) /* next satellite */
;
j = RTCM3_MSM_NUMSIG;
while(!(sigmask&(1<<--j)))
;
--numsat;
}
if(cellmask & (UINT64(1)<<count))
{
struct CodeData cd = {0,0,0,0,0,0,0};
double wl = 0.0;
switch(sys)
{
case RTCM3_MSM_QZSS:
cd = qzss[RTCM3_MSM_NUMSIG-j-1];
wl = cd.wl;
break;
case RTCM3_MSM_BDS:
cd = bds[RTCM3_MSM_NUMSIG-j-1];
wl = cd.wl;
break;
case RTCM3_MSM_GPS: case RTCM3_MSM_SBAS:
cd = gps[RTCM3_MSM_NUMSIG-j-1];
wl = cd.wl;
break;
case RTCM3_MSM_GLONASS: cd = glo[RTCM3_MSM_NUMSIG-j-1];
{
int k = handle->GLOFreq[RTCM3_MSM_NUMSAT-i-1];
if(!k && extsat[numsat] < 14)
{
k = handle->GLOFreq[RTCM3_MSM_NUMSAT-i-1]
= 100+extsat[numsat]-7;
}
if(k)
{
if(cd.wl == 0.0)
wl = GLO_WAVELENGTH_L1(k-100);
else if(cd.wl == 1.0)
wl = GLO_WAVELENGTH_L2(k-100);
}
}
break;
case RTCM3_MSM_GALILEO: cd = gal[RTCM3_MSM_NUMSIG-j-1];
wl = cd.wl;
break;
}
if(cd.lock && wl) /* lock cannot have a valid zero value */
{
int fullsat = RTCM3_MSM_NUMSAT-i-1, num;
if(sys == RTCM3_MSM_GALILEO && fullsat >= 50 && fullsat <= 51)
fullsat += PRN_GIOVE_START-50;
else
fullsat += start;
for(num = 0; num < gnss->numsats
&& fullsat != gnss->satellites[num]; ++num)
;
if(num == gnss->numsats)
gnss->satellites[gnss->numsats++] = fullsat;
gnss->codetype[num][cd.typeR] =
gnss->codetype[num][cd.typeP] =
gnss->codetype[num][cd.typeD] =
gnss->codetype[num][cd.typeS] = cd.code;
if(!handle->info[sys].type[cd.typeR])
{
handle->info[sys].type[cd.typeR] =
handle->info[sys].type[cd.typeP] =
handle->info[sys].type[cd.typeD] =
handle->info[sys].type[cd.typeS] = cd.code[1];
}
switch(type % 10)
{
case 1:
if(psr[count] > -1.0/(1<<10))
{
gnss->measdata[num][cd.typeR] = psr[count]*LIGHTSPEED/1000.0
+(rrmod[numsat])*LIGHTSPEED/1000.0;
gnss->dataflags[num] |= (1LL<<cd.typeR);
}
break;
case 2:
if(wl && cp[count] > -1.0/(1<<8))
{
gnss->measdata[num][cd.typeP] = cp[count]*LIGHTSPEED/1000.0/wl
+(rrmod[numsat])*LIGHTSPEED/1000.0/wl;
if(handle->lastlockmsm[j][i] > ll[count])
gnss->dataflags2[num] |= cd.lock;
handle->lastlockmsm[j][i] = ll[count] > 255 ? 255 : ll[count];
gnss->dataflags[num] |= (1LL<<cd.typeP);
}
break;
case 3:
if(psr[count] > -1.0/(1<<10))
{
gnss->measdata[num][cd.typeR] = psr[count]*LIGHTSPEED/1000.0
+(rrmod[numsat])*LIGHTSPEED/1000.0;
gnss->dataflags[num] |= (1LL<<cd.typeR);
}
if(wl && cp[count] > -1.0/(1<<8))
{
gnss->measdata[num][cd.typeP] = cp[count]*LIGHTSPEED/1000.0/wl
+(rrmod[numsat]+rrint[numsat])*LIGHTSPEED/1000.0/wl;
if(handle->lastlockmsm[j][i] > ll[count])
gnss->dataflags2[num] |= cd.lock;
handle->lastlockmsm[j][i] = ll[count] > 255 ? 255 : ll[count];
gnss->dataflags[num] |= (1LL<<cd.typeP);
}
break;
case 4:
if(psr[count] > -1.0/(1<<10))
{
gnss->measdata[num][cd.typeR] = psr[count]*LIGHTSPEED/1000.0
+(rrmod[numsat]+rrint[numsat])*LIGHTSPEED/1000.0;
gnss->dataflags[num] |= (1LL<<cd.typeR);
}
if(wl && cp[count] > -1.0/(1<<8))
{
gnss->measdata[num][cd.typeP] = cp[count]*LIGHTSPEED/1000.0/wl
+(rrmod[numsat]+rrint[numsat])*LIGHTSPEED/1000.0/wl;
if(handle->lastlockmsm[j][i] > ll[count])
gnss->dataflags2[num] |= cd.lock;
handle->lastlockmsm[j][i] = ll[count] > 255 ? 255 : ll[count];
gnss->dataflags[num] |= (1LL<<cd.typeP);
}
gnss->measdata[num][cd.typeS] = cnr[count];
gnss->dataflags[num] |= (1LL<<cd.typeS);
break;
case 5:
if(psr[count] > -1.0/(1<<10))
{
gnss->measdata[num][cd.typeR] = psr[count]*LIGHTSPEED/1000.0
+(rrmod[numsat]+rrint[numsat])*LIGHTSPEED/1000.0;
gnss->dataflags[num] |= (1LL<<cd.typeR);
}
if(wl && cp[count] > -1.0/(1<<8))
{
gnss->measdata[num][cd.typeP] = cp[count]*LIGHTSPEED/1000.0/wl
+(rrmod[numsat]+rrint[numsat])*LIGHTSPEED/1000.0/wl;
if(handle->lastlockmsm[j][i] > ll[count])
gnss->dataflags2[num] |= cd.lock;
handle->lastlockmsm[j][i] = ll[count] > 255 ? 255 : ll[count];
gnss->dataflags[num] |= (1LL<<cd.typeP);
}
gnss->measdata[num][cd.typeS] = cnr[count];
gnss->dataflags[num] |= (1<<cd.typeS);
if(dop[count] > -1.6384)
{
gnss->measdata[num][cd.typeD] = -(dop[count]
+rdop[numsat])/wl;
gnss->dataflags[num] |= (1LL<<cd.typeD);
}
break;
case 6:
if(psr[count] > -1.0/(1<<10))
{
gnss->measdata[num][cd.typeR] = psr[count]*LIGHTSPEED/1000.0
+(rrmod[numsat]+rrint[numsat])*LIGHTSPEED/1000.0;
gnss->dataflags[num] |= (1LL<<cd.typeR);
}
if(wl && cp[count] > -1.0/(1<<8))
{
gnss->measdata[num][cd.typeP] = cp[count]*LIGHTSPEED/1000.0/wl
+(rrmod[numsat]+rrint[numsat])*LIGHTSPEED/1000.0/wl;
if(handle->lastlockmsm[j][i] > ll[count])
gnss->dataflags2[num] |= cd.lock;
handle->lastlockmsm[j][i] = ll[count] > 255 ? 255 : ll[count];
gnss->dataflags[num] |= (1LL<<cd.typeP);
}
gnss->measdata[num][cd.typeS] = cnr[count];
gnss->dataflags[num] |= (1LL<<cd.typeS);
break;
case 7:
if(psr[count] > -1.0/(1<<10))
{
gnss->measdata[num][cd.typeR] = psr[count]*LIGHTSPEED/1000.0
+(rrmod[numsat]+rrint[numsat])*LIGHTSPEED/1000.0;
gnss->dataflags[num] |= (1LL<<cd.typeR);
}
if(wl && cp[count] > -1.0/(1<<8))
{
gnss->measdata[num][cd.typeP] = cp[count]*LIGHTSPEED/1000.0/wl
+(rrmod[numsat]+rrint[numsat])*LIGHTSPEED/1000.0/wl;
if(handle->lastlockmsm[j][i] > ll[count])
gnss->dataflags2[num] |= cd.lock;
handle->lastlockmsm[j][i] = ll[count] > 255 ? 255 : ll[count];
gnss->dataflags[num] |= (1LL<<cd.typeP);
}
gnss->measdata[num][cd.typeS] = cnr[count];
gnss->dataflags[num] |= (1LL<<cd.typeS);
if(dop[count] > -1.6384)
{
gnss->measdata[num][cd.typeD] = -(dop[count]
+rdop[numsat])/wl;
gnss->dataflags[num] |= (1LL<<cd.typeD);
}
break;
}
}
}
}
}
if(!syncf && !old)
{
handle->Data = *gnss;
memset(gnss, 0, sizeof(*gnss));
}
if(!syncf || old)
{
if(!wasnoamb) /* not RINEX compatible without */
ret = 1;
else
ret = 2;
}
#ifdef NO_RTCM3_MAIN
else
ret = type;
#endif /* NO_RTCM3_MAIN */
}
break;
}
}
return ret;
}
struct Header
{
const char *version;
const char *pgm;
const char *marker;
const char *markertype;
const char *observer;
const char *receiver;
const char *antenna;
const char *position;
const char *antennaposition;
const char *wavelength;
const char *typesofobs; /* should not be modified outside */
const char *typesofobsG; /* should not be modified outside */
const char *typesofobsR; /* should not be modified outside */
const char *typesofobsS; /* should not be modified outside */
const char *typesofobsE; /* should not be modified outside */
const char *typesofobsC; /* should not be modified outside */
const char *typesofobsJ; /* should not be modified outside */
const char *timeoffirstobs; /* should not be modified outside */
};
#define MAXHEADERLINES 50
#define MAXHEADERBUFFERSIZE 4096
struct HeaderData
{
union
{
struct Header named;
const char *unnamed[MAXHEADERLINES];
} data;
int numheaders;
};
void converttime(struct converttimeinfo *c, int week, int tow)
{
int i, k, doy, j; /* temporary variables */
j = week*(7*24*60*60) + tow + 5*24*60*60;
for(i = 1980; j >= (k = (365+longyear(i,0))*24*60*60); ++i)
j -= k;
c->year = i;
doy = 1+ (j / (24*60*60));
j %= (24*60*60);
c->hour = j / (60*60);
j %= (60*60);
c->minute = j / 60;
c->second = j % 60;
j = 0;
for(i = 1; j + (k = months[i] + longyear(c->year,i)) < doy; ++i)
j += k;
c->month = i;
c->day = doy - j;
}
void converttimebds(struct converttimeinfo *c, int week, int tow)
{
int i, k, doy, j; /* temporary variables */
j = week*(7*24*60*60) + tow;
for(i = 2006; j >= (k = (365+longyear(i,0))*24*60*60); ++i)
j -= k;
c->year = i;
doy = 1+ (j / (24*60*60));
j %= (24*60*60);
c->hour = j / (60*60);
j %= (60*60);
c->minute = j / 60;
c->second = j % 60;
j = 0;
for(i = 1; j + (k = months[i] + longyear(c->year,i)) < doy; ++i)
j += k;
c->month = i;
c->day = doy - j;
}
#ifndef NO_RTCM3_MAIN
void RTCM3Error(const char *fmt, ...)
{
va_list v;
va_start(v, fmt);
vfprintf(stderr, fmt, v);
va_end(v);
}
#endif
void RTCM3Text(const char *fmt, ...)
{
va_list v;
va_start(v, fmt);
vprintf(fmt, v);
va_end(v);
}
static void fixrevision(void)
{
if(revisionstr[0] == '$')
{
char *a;
int i=sizeof(RTCM3TORINEX_VERSION); /* set version to 1.<revision> */
strcpy(revisionstr, RTCM3TORINEX_VERSION ".");
for(a = revisionstr+11; *a && *a != ' '; ++a)
revisionstr[i++] = *a;
revisionstr[i] = 0;
}
}
static int HandleRunBy(char *buffer, int buffersize, const char **u,
int rinex3)
{
const char *user;
time_t t;
struct tm * t2;
#ifdef NO_RTCM3_MAIN
fixrevision();
#endif
user= getenv("USER");
if(!user) user = "";
t = time(&t);
t2 = gmtime(&t);
if(u) *u = user;
if(rinex3)
{
return 1+snprintf(buffer, buffersize,
"RTCM3TORINEX %-7.7s%-20.20s%04d%02d%02d %02d%02d%02d UTC "
"PGM / RUN BY / DATE", revisionstr, user, 1900+t2->tm_year,
t2->tm_mon+1, t2->tm_mday, t2->tm_hour, t2->tm_min, t2->tm_sec);
}
else
{
return 1+snprintf(buffer, buffersize,
"RTCM3TORINEX %-7.7s%-20.20s%04d-%02d-%02d %02d:%02d "
"PGM / RUN BY / DATE", revisionstr, user, 1900+t2->tm_year,
t2->tm_mon+1, t2->tm_mday, t2->tm_hour, t2->tm_min);
}
}
#ifdef NO_RTCM3_MAIN
#define NUMSTARTSKIP 1
#else
#define NUMSTARTSKIP 3
#endif
int HandleObsHeader(struct RTCM3ParserData *Parser, char *buffer,
size_t buffersize, struct HeaderData *hdata)
{
int buffersizeold = buffersize;
int i, modified = 0;
if(Parser->rinex3)
{
int flags;
#define CHECKFLAGSNEW(a, b, c) \
if(flags & GNSSDF_##b##DATA) \
{ \
int new = hdata ? 1 : 0; \
if(!hdata) /* check if already known */ \
{ \
int ic; \
for(ic = 0; ic < Parser->info[RTCM3_MSM_##a].numtypes \
&& Parser->info[RTCM3_MSM_##a].flags[ic] != GNSSDF_##b##DATA; ++ic) \
; \
if(ic == Parser->info[RTCM3_MSM_##a].numtypes) \
new = 1; \
} \
if(new) \
{ \
Parser->info[RTCM3_MSM_##a].flags[Parser->info[RTCM3_MSM_##a].numtypes] \
= GNSSDF_##b##DATA; \
Parser->info[RTCM3_MSM_##a].pos[Parser->info[RTCM3_MSM_##a].numtypes] \
= GNSSENTRY_##b##DATA; \
if(Parser->info[RTCM3_MSM_##a].type[GNSSENTRY_##b##DATA]) \
{ \
snprintf(Parser->fieldbuffer##a+4*Parser->info[RTCM3_MSM_##a].numtypes, \
sizeof(Parser->fieldbuffer##a)-4*Parser->info[RTCM3_MSM_##a].numtypes, \
" %-2.2s%c", #c, Parser->info[RTCM3_MSM_##a].type[GNSSENTRY_##b##DATA]); \
} \
else \
{ \
snprintf(Parser->fieldbuffer##a+4*Parser->info[RTCM3_MSM_##a].numtypes, \
sizeof(Parser->fieldbuffer##a)-4*Parser->info[RTCM3_MSM_##a].numtypes, \
" %-3s", #c); \
} \
++Parser->info[RTCM3_MSM_##a].numtypes; \
++modified; \
} \
}
#define INITFLAGS(a) \
flags = Parser->startflags; \
modified = 0; \
for(i = 0; i < Parser->Data.numsats; ++i) \
{ \
if(Parser->Data.satellites[i] >= PRN_##a##_START \
&& Parser->Data.satellites[i] <= PRN_##a##_END) \
flags |= Parser->Data.dataflags[i]; \
}
INITFLAGS(SBAS)
CHECKFLAGSNEW(SBAS, C1, C1C)
CHECKFLAGSNEW(SBAS, L1C, L1C)
CHECKFLAGSNEW(SBAS, D1C, D1C)
CHECKFLAGSNEW(SBAS, S1C, S1C)
CHECKFLAGSNEW(SBAS, C5, C5)
CHECKFLAGSNEW(SBAS, L5, L5)
CHECKFLAGSNEW(SBAS, D5, D5)
CHECKFLAGSNEW(SBAS, S5, S5)
if(modified)
{
if(hdata)
hdata->data.named.typesofobsS = buffer;
i = 1+snprintf(buffer, buffersize,
"S %3d%-52.52s SYS / # / OBS TYPES",
Parser->info[RTCM3_MSM_SBAS].numtypes, Parser->fieldbufferSBAS);
buffer += i; buffersize -= i;
}
INITFLAGS(GPS)
CHECKFLAGSNEW(GPS, C1, C1C)
CHECKFLAGSNEW(GPS, L1C, L1C)
CHECKFLAGSNEW(GPS, D1C, D1C)
CHECKFLAGSNEW(GPS, S1C, S1C)
CHECKFLAGSNEW(GPS, P1, C1W)
CHECKFLAGSNEW(GPS, L1P, L1W)
CHECKFLAGSNEW(GPS, D1P, D1W)
CHECKFLAGSNEW(GPS, S1P, S1W)
CHECKFLAGSNEW(GPS, C5, C5)
CHECKFLAGSNEW(GPS, L5, L5)
CHECKFLAGSNEW(GPS, D5, D5)
CHECKFLAGSNEW(GPS, S5, S5)
CHECKFLAGSNEW(GPS, P2, C2W)
CHECKFLAGSNEW(GPS, L2P, L2W)
CHECKFLAGSNEW(GPS, D2P, D2W)
CHECKFLAGSNEW(GPS, S2P, S2W)
CHECKFLAGSNEW(GPS, C2, C2)
CHECKFLAGSNEW(GPS, L2C, L2)
CHECKFLAGSNEW(GPS, D2C, D2)
CHECKFLAGSNEW(GPS, S2C, S2)
CHECKFLAGSNEW(GPS, C1N, C1)
CHECKFLAGSNEW(GPS, L1N, L1)
CHECKFLAGSNEW(GPS, D1N, D1)
CHECKFLAGSNEW(GPS, S1N, S1)
if(modified)
{
if(hdata)
hdata->data.named.typesofobsG = buffer;
i = 1+snprintf(buffer, buffersize,
"G %3d%-52.52s SYS / # / OBS TYPES",
Parser->info[RTCM3_MSM_GPS].numtypes, Parser->fieldbufferGPS);
if(Parser->info[RTCM3_MSM_GPS].numtypes>13)
{
i += snprintf(buffer+i-1, buffersize,
"\n %-52.52s SYS / # / OBS TYPES", Parser->fieldbufferGPS+13*4);
}
buffer += i; buffersize -= i;
}
INITFLAGS(GLONASS)
CHECKFLAGSNEW(GLONASS, C1, C1C)
CHECKFLAGSNEW(GLONASS, L1C, L1C)
CHECKFLAGSNEW(GLONASS, D1C, D1C)
CHECKFLAGSNEW(GLONASS, S1C, S1C)
CHECKFLAGSNEW(GLONASS, P1, C1P)
CHECKFLAGSNEW(GLONASS, L1P, L1P)
CHECKFLAGSNEW(GLONASS, D1P, D1P)
CHECKFLAGSNEW(GLONASS, S1P, S1P)
CHECKFLAGSNEW(GLONASS, P2, C2P)
CHECKFLAGSNEW(GLONASS, L2P, L2P)
CHECKFLAGSNEW(GLONASS, D2P, D2P)
CHECKFLAGSNEW(GLONASS, S2P, S2P)
CHECKFLAGSNEW(GLONASS, C2, C2C)
CHECKFLAGSNEW(GLONASS, L2C, L2C)
CHECKFLAGSNEW(GLONASS, D2C, D2C)
CHECKFLAGSNEW(GLONASS, S2C, S2C)
if(modified)
{
if(hdata)
hdata->data.named.typesofobsR = buffer;
i = 1+snprintf(buffer, buffersize,
"R %3d%-52.52s SYS / # / OBS TYPES",
Parser->info[RTCM3_MSM_GLONASS].numtypes, Parser->fieldbufferGLONASS);
if(Parser->info[RTCM3_MSM_GLONASS].numtypes>13)
{
i += snprintf(buffer+i-1, buffersize,
"\n %-52.52s SYS / # / OBS TYPES", Parser->fieldbufferGLONASS+13*4);
}
buffer += i; buffersize -= i;
}
INITFLAGS(GALGIO)
CHECKFLAGSNEW(GALILEO, C1, C1)
CHECKFLAGSNEW(GALILEO, L1C, L1)
CHECKFLAGSNEW(GALILEO, D1C, D1)
CHECKFLAGSNEW(GALILEO, S1C, S1)
CHECKFLAGSNEW(GALILEO, C6, C6)
CHECKFLAGSNEW(GALILEO, L6, L6)
CHECKFLAGSNEW(GALILEO, D6, D6)
CHECKFLAGSNEW(GALILEO, S6, S6)
CHECKFLAGSNEW(GALILEO, C5, C5)
CHECKFLAGSNEW(GALILEO, L5, L5)
CHECKFLAGSNEW(GALILEO, D5, D5)
CHECKFLAGSNEW(GALILEO, S5, S5)
CHECKFLAGSNEW(GALILEO, C5B, C7)
CHECKFLAGSNEW(GALILEO, L5B, L7)
CHECKFLAGSNEW(GALILEO, D5B, D7)
CHECKFLAGSNEW(GALILEO, S5B, S7)
CHECKFLAGSNEW(GALILEO, C5AB, C8)
CHECKFLAGSNEW(GALILEO, L5AB, L8)
CHECKFLAGSNEW(GALILEO, D5AB, D8)
CHECKFLAGSNEW(GALILEO, S5AB, S8)
if(modified)
{
if(hdata)
hdata->data.named.typesofobsE = buffer;
i = 1+snprintf(buffer, buffersize,
"E %3d%-52.52s SYS / # / OBS TYPES",
Parser->info[RTCM3_MSM_GALILEO].numtypes, Parser->fieldbufferGALILEO);
if(Parser->info[RTCM3_MSM_GALILEO].numtypes>13)
{
i += snprintf(buffer+i-1, buffersize,
"\n %-52.52s SYS / # / OBS TYPES", Parser->fieldbufferGALILEO+13*4);
}
buffer += i; buffersize -= i;
}
INITFLAGS(BDS)
CHECKFLAGSNEW(BDS, CB1, C2I)
CHECKFLAGSNEW(BDS, LB1, L2I)
CHECKFLAGSNEW(BDS, DB1, D2I)
CHECKFLAGSNEW(BDS, SB1, S2I)
CHECKFLAGSNEW(BDS, CB2, C7I)
CHECKFLAGSNEW(BDS, LB2, L7I)
CHECKFLAGSNEW(BDS, DB2, D7I)
CHECKFLAGSNEW(BDS, SB2, S7I)
CHECKFLAGSNEW(BDS, CB3, C6I)
CHECKFLAGSNEW(BDS, LB3, L6I)
CHECKFLAGSNEW(BDS, DB3, D6I)
CHECKFLAGSNEW(BDS, SB3, S6I)
if(modified)
{
if(hdata)
hdata->data.named.typesofobsC = buffer;
i = 1+snprintf(buffer, buffersize,
"C %3d%-52.52s SYS / # / OBS TYPES",
Parser->info[RTCM3_MSM_BDS].numtypes, Parser->fieldbufferBDS);
if(Parser->info[RTCM3_MSM_BDS].numtypes>13)
{
i += snprintf(buffer+i-1, buffersize,
"\n %-52.52s SYS / # / OBS TYPES", Parser->fieldbufferBDS+13*4);
}
buffer += i; buffersize -= i;
}
INITFLAGS(QZSS)
CHECKFLAGSNEW(QZSS, C1, C1C)
CHECKFLAGSNEW(QZSS, L1C, L1C)
CHECKFLAGSNEW(QZSS, D1C, D1C)
CHECKFLAGSNEW(QZSS, S1C, S1C)
CHECKFLAGSNEW(QZSS, CSAIF, C1Z)
CHECKFLAGSNEW(QZSS, LSAIF, L1Z)
CHECKFLAGSNEW(QZSS, DSAIF, D1Z)
CHECKFLAGSNEW(QZSS, SSAIF, S1Z)
CHECKFLAGSNEW(QZSS, C1N, C1)
CHECKFLAGSNEW(QZSS, L1N, L1)
CHECKFLAGSNEW(QZSS, D1N, D1)
CHECKFLAGSNEW(QZSS, S1N, S1)
CHECKFLAGSNEW(QZSS, C6, C6)
CHECKFLAGSNEW(QZSS, L6, L6)
CHECKFLAGSNEW(QZSS, D6, D6)
CHECKFLAGSNEW(QZSS, S6, S6)
CHECKFLAGSNEW(QZSS, C2, C2)
CHECKFLAGSNEW(QZSS, L2C, L2)
CHECKFLAGSNEW(QZSS, D2C, D2)
CHECKFLAGSNEW(QZSS, S2C, S2)
CHECKFLAGSNEW(QZSS, C5, C5)
CHECKFLAGSNEW(QZSS, L5, L5)
CHECKFLAGSNEW(QZSS, D5, D5)
CHECKFLAGSNEW(QZSS, S5, S5)
if(modified)
{
if(hdata)
hdata->data.named.typesofobsJ = buffer;
i = 1+snprintf(buffer, buffersize,
"J %3d%-52.52s SYS / # / OBS TYPES",
Parser->info[RTCM3_MSM_QZSS].numtypes, Parser->fieldbufferQZSS);
if(Parser->info[RTCM3_MSM_QZSS].numtypes>13)
{
i += snprintf(buffer+i-1, buffersize,
"\n %-52.52s SYS / # / OBS TYPES", Parser->fieldbufferQZSS+13*4);
}
buffer += i; buffersize -= i;
}
}
else
{
#define CHECKFLAGS(a, b) \
if(flags & GNSSDF_##a##DATA) \
{ \
if(Parser->datafields[RINEXENTRY_##b##DATA]) \
{ \
Parser->info[RTCM3_MSM_GPS].flags[Parser->datafields[\
RINEXENTRY_##b##DATA]-1] = GNSSDF_##a##DATA; \
Parser->info[RTCM3_MSM_GPS].pos[Parser->datafields[\
RINEXENTRY_##b##DATA]-1] = GNSSENTRY_##a##DATA; \
} \
else \
{ \
Parser->flags[Parser->info[RTCM3_MSM_GPS].numtypes] = GNSSDF_##a##DATA; \
Parser->pos[Parser->info[RTCM3_MSM_GPS].numtypes] = GNSSENTRY_##a##DATA; \
Parser->datafields[RINEXENTRY_##b##DATA] = \
++Parser->info[RTCM3_MSM_GPS].numtypes; \
snprintf(Parser->fieldbuffer+6*Parser->numdatafields, \
sizeof(Parser->fieldbuffer)-6*Parser->numdatafields, " "#b); \
++Parser->numdatafields; \
++modified; \
} \
}
int flags = Parser->startflags;
for(i = 0; i < Parser->Data.numsats; ++i)
flags |= Parser->Data.dataflags[i];
CHECKFLAGS(C1,C1)
CHECKFLAGS(C2,C2)
CHECKFLAGS(P1,P1)
CHECKFLAGS(P2,P2)
CHECKFLAGS(L1C,L1)
CHECKFLAGS(L1P,L1)
CHECKFLAGS(L2C,L2)
CHECKFLAGS(L2P,L2)
CHECKFLAGS(D1C,D1)
CHECKFLAGS(D1P,D1)
CHECKFLAGS(D2C,D2)
CHECKFLAGS(D2P,D2)
CHECKFLAGS(S1C,S1)
CHECKFLAGS(S1P,S1)
CHECKFLAGS(S2C,S2)
CHECKFLAGS(S2P,S2)
CHECKFLAGS(C5,C5)
CHECKFLAGS(L5,L5)
CHECKFLAGS(D5,D5)
CHECKFLAGS(S5,S5)
CHECKFLAGS(C5AB,C8)
CHECKFLAGS(L5AB,L8)
CHECKFLAGS(D5AB,D8)
CHECKFLAGS(S5AB,S8)
CHECKFLAGS(C5B,C7)
CHECKFLAGS(L5B,L7)
CHECKFLAGS(D5B,D7)
CHECKFLAGS(S5B,S7)
CHECKFLAGS(C6,C6)
CHECKFLAGS(L6,L6)
CHECKFLAGS(D6,D6)
CHECKFLAGS(S6,S6)
/* Skip C1N and SAIF for RINEX2! */
if(hdata)
hdata->data.named.typesofobs = buffer;
if(modified)
{
i = 1+snprintf(buffer, buffersize,
"%6d%-54.54s# / TYPES OF OBSERV", Parser->info[RTCM3_MSM_GPS].numtypes,
Parser->fieldbuffer);
if(Parser->info[RTCM3_MSM_GPS].numtypes>9)
{
i += snprintf(buffer+i-1, buffersize,
"\n %-54.54s# / TYPES OF OBSERV", Parser->fieldbuffer+9*6);
}
if(Parser->info[RTCM3_MSM_GPS].numtypes>18)
{
i += snprintf(buffer+i-1, buffersize,
"\n %-54.54s# / TYPES OF OBSERV", Parser->fieldbuffer+18*6);
}
buffer += i; buffersize -= i;
}
}
return buffersizeold - buffersize;
}
void HandleHeader(struct RTCM3ParserData *Parser)
{
#ifdef NO_RTCM3_MAIN
int flags, modified = 0;
if(Parser->allflags == 0)
Parser->allflags = ~0;
flags = Parser->allflags;
if(Parser->rinex3)
{
struct HeaderData *hdata = 0;
CHECKFLAGSNEW(GPS, C1, C1C)
CHECKFLAGSNEW(GPS, L1C, L1C)
CHECKFLAGSNEW(GPS, D1C, D1C)
CHECKFLAGSNEW(GPS, S1C, S1C)
CHECKFLAGSNEW(GPS, P1, C1P)
CHECKFLAGSNEW(GPS, L1P, L1P)
CHECKFLAGSNEW(GPS, D1P, D1P)
CHECKFLAGSNEW(GPS, S1P, S1P)
CHECKFLAGSNEW(GPS, P2, C2P)
CHECKFLAGSNEW(GPS, L2P, L2P)
CHECKFLAGSNEW(GPS, D2P, D2P)
CHECKFLAGSNEW(GPS, S2P, S2P)
CHECKFLAGSNEW(GPS, C2, C2X)
CHECKFLAGSNEW(GPS, L2C, L2X)
CHECKFLAGSNEW(GPS, D2C, D2X)
CHECKFLAGSNEW(GPS, S2C, S2X)
CHECKFLAGSNEW(GLONASS, C1, C1C)
CHECKFLAGSNEW(GLONASS, L1C, L1C)
CHECKFLAGSNEW(GLONASS, D1C, D1C)
CHECKFLAGSNEW(GLONASS, S1C, S1C)
CHECKFLAGSNEW(GLONASS, P1, C1P)
CHECKFLAGSNEW(GLONASS, L1P, L1P)
CHECKFLAGSNEW(GLONASS, D1P, D1P)
CHECKFLAGSNEW(GLONASS, S1P, S1P)
CHECKFLAGSNEW(GLONASS, P2, C2P)
CHECKFLAGSNEW(GLONASS, L2P, L2P)
CHECKFLAGSNEW(GLONASS, D2P, D2P)
CHECKFLAGSNEW(GLONASS, S2P, S2P)
CHECKFLAGSNEW(GLONASS, C2, C2C)
CHECKFLAGSNEW(GLONASS, L2C, L2C)
CHECKFLAGSNEW(GLONASS, D2C, D2C)
CHECKFLAGSNEW(GLONASS, S2C, S2C)
}
else
{
CHECKFLAGS(C1,C1)
CHECKFLAGS(C2,C2)
CHECKFLAGS(P1,P1)
CHECKFLAGS(P2,P2)
CHECKFLAGS(L1C,L1)
CHECKFLAGS(L1P,L1)
CHECKFLAGS(L2C,L2)
CHECKFLAGS(L2P,L2)
CHECKFLAGS(D1C,D1)
CHECKFLAGS(D1P,D1)
CHECKFLAGS(D2C,D2)
CHECKFLAGS(D2P,D2)
CHECKFLAGS(S1C,S1)
CHECKFLAGS(S1P,S1)
CHECKFLAGS(S2C,S2)
CHECKFLAGS(S2P,S2)
CHECKFLAGS(C5,C5)
CHECKFLAGS(L5,L5)
CHECKFLAGS(D5,D5)
CHECKFLAGS(S5,S5)
CHECKFLAGS(C5AB,C8)
CHECKFLAGS(L5AB,L8)
CHECKFLAGS(D5AB,D8)
CHECKFLAGS(S5AB,S8)
CHECKFLAGS(C5B,C7)
CHECKFLAGS(L5B,L7)
CHECKFLAGS(D5B,D7)
CHECKFLAGS(S5B,S7)
CHECKFLAGS(C6,C6)
CHECKFLAGS(L6,L6)
CHECKFLAGS(D6,D6)
CHECKFLAGS(S6,S6)
}
#else /* NO_RTCM3_MAIN */
struct HeaderData hdata;
char thebuffer[MAXHEADERBUFFERSIZE];
char *buffer = thebuffer;
size_t buffersize = sizeof(thebuffer);
int i;
memset(&hdata, 0, sizeof(hdata));
hdata.data.named.version = buffer;
i = 1+snprintf(buffer, buffersize,
"%9.2f OBSERVATION DATA M (Mixed)"
" RINEX VERSION / TYPE", Parser->rinex3 ? 3.0 : 2.11);
buffer += i; buffersize -= i;
{
const char *str;
hdata.data.named.pgm = buffer;
i = HandleRunBy(buffer, buffersize, &str, Parser->rinex3);
buffer += i; buffersize -= i;
hdata.data.named.observer = buffer;
i = 1+snprintf(buffer, buffersize,
"%-20.20s "
"OBSERVER / AGENCY", str);
buffer += i; buffersize -= i;
}
hdata.data.named.marker =
"RTCM3TORINEX "
"MARKER NAME";
hdata.data.named.markertype = !Parser->rinex3 ? 0 :
"GEODETIC "
"MARKER TYPE";
hdata.data.named.receiver =
" "
"REC # / TYPE / VERS";
hdata.data.named.antenna =
" "
"ANT # / TYPE";
hdata.data.named.position =
" .0000 .0000 .0000 "
"APPROX POSITION XYZ";
hdata.data.named.antennaposition =
" .0000 .0000 .0000 "
"ANTENNA: DELTA H/E/N";
hdata.data.named.wavelength = Parser->rinex3 ? 0 :
" 1 1 "
"WAVELENGTH FACT L1/2";
hdata.numheaders = 18;
i = HandleObsHeader(Parser, buffer, buffersize, &hdata);
buffer += i; buffersize -= i;
{
struct converttimeinfo cti;
converttime(&cti, Parser->Data.week,
(int)floor(Parser->Data.timeofweek/1000.0));
hdata.data.named.timeoffirstobs = buffer;
i = 1+snprintf(buffer, buffersize,
" %4d %2d %2d %2d %2d %10.7f GPS "
"TIME OF FIRST OBS", cti.year, cti.month, cti.day, cti.hour,
cti.minute, cti.second + fmod(Parser->Data.timeofweek/1000.0,1.0));
buffer += i; buffersize -= i;
}
if(Parser->headerfile)
{
FILE *fh;
if((fh = fopen(Parser->headerfile, "r")))
{
size_t siz;
char *lastblockstart;
if((siz = fread(buffer, 1, buffersize-1, fh)) > 0)
{
buffer[siz] = '\n';
if(siz == buffersize)
{
RTCM3Error("Header file is too large. Only %d bytes read.",
(int)siz);
}
/* scan the file line by line and enter the entries in the list */
/* warn for "# / TYPES OF OBSERV" and "TIME OF FIRST OBS" */
/* overwrites entries, except for comments */
lastblockstart = buffer;
for(i = 0; i < (int)siz; ++i)
{
if(buffer[i] == '\n')
{ /* we found a line */
char *end;
while(buffer[i+1] == '\r')
++i; /* skip \r in case there are any */
end = buffer+i;
while(*end == '\t' || *end == ' ' || *end == '\r' || *end == '\n')
*(end--) = 0;
if(end-lastblockstart < 60+5) /* short line */
RTCM3Error("Short Header line '%s' ignored.\n", lastblockstart);
else
{
int pos;
if(!strcmp("COMMENT", lastblockstart+60))
pos = hdata.numheaders;
else
{
for(pos = 0; pos < hdata.numheaders; ++pos)
{
if(hdata.data.unnamed[pos] &&
!strcmp(hdata.data.unnamed[pos]+60, lastblockstart+60))
break;
}
if(!strcmp("# / TYPES OF OBSERV", lastblockstart+60)
|| !strcmp("SYS / # / OBS TYPES", lastblockstart+60)
|| !strcmp("TIME OF FIRST OBS", lastblockstart+60))
{
RTCM3Error("Overwriting header '%s' is dangerous.\n",
lastblockstart+60);
}
}
if(pos >= MAXHEADERLINES)
{
RTCM3Error("Maximum number of header lines of %d reached.\n",
MAXHEADERLINES);
}
else if(!strcmp("END OF HEADER", lastblockstart+60))
{
RTCM3Error("End of header ignored.\n");
}
else
{
hdata.data.unnamed[pos] = lastblockstart;
if(pos == hdata.numheaders)
++hdata.numheaders;
}
}
lastblockstart = buffer+i+1;
}
}
}
else
{
RTCM3Error("Could not read data from headerfile '%s'.\n",
Parser->headerfile);
}
fclose(fh);
}
else
{
RTCM3Error("Could not open header datafile '%s'.\n",
Parser->headerfile);
}
}
for(i = 0; i < hdata.numheaders; ++i)
{
if(hdata.data.unnamed[i] && hdata.data.unnamed[i][0])
RTCM3Text("%s\n", hdata.data.unnamed[i]);
}
RTCM3Text(" "
"END OF HEADER\n");
#endif
}
static void ConvLine(FILE *file, const char *fmt, ...)
{
char buffer[100], *b;
va_list v;
va_start(v, fmt);
vsnprintf(buffer, sizeof(buffer), fmt, v);
for(b = buffer; *b; ++b)
{
if(*b == 'e') *b = 'D';
}
fprintf(file, "%s", buffer);
va_end(v);
}
void HandleByte(struct RTCM3ParserData *Parser, unsigned int byte)
{
Parser->Message[Parser->MessageSize++] = byte;
if(Parser->MessageSize >= Parser->NeedBytes)
{
int r;
while((r = RTCM3Parser(Parser)))
{
double ver = Parser->rinex3 ? 3.02 : 2.11;
if(r == 1020 || r == RTCM3ID_BDS || r == 1019 || r == 1044 || r == 1043)
{
FILE *file = 0;
if(Parser->mixedephemeris)
{
if(Parser->mixedephemeris != (const char *)1)
{
if(!(Parser->mixedfile = fopen(Parser->mixedephemeris, "w")))
{
RTCM3Error("Could not open ephemeris output file.\n");
}
else
{
char buffer[100];
fprintf(Parser->mixedfile,
"%9.2f%11sN: GNSS NAV DATA M: Mixed%12sRINEX VERSION / TYPE\n", ver, "", "");
HandleRunBy(buffer, sizeof(buffer), 0, Parser->rinex3);
fprintf(Parser->mixedfile, "%s\n%60sEND OF HEADER\n", buffer, "");
}
Parser->mixedephemeris = (const char *)1;
}
file = Parser->mixedfile;
}
else
{
if(r == 1020)
{
if(Parser->glonassephemeris)
{
if(!(Parser->glonassfile = fopen(Parser->glonassephemeris, "w")))
{
RTCM3Error("Could not open GLONASS ephemeris output file.\n");
}
else
{
char buffer[100];
fprintf(Parser->glonassfile,
"%9.2f%11sG: GLONASS NAV DATA%21sRINEX VERSION / TYPE\n", ver, "", "");
HandleRunBy(buffer, sizeof(buffer), 0, Parser->rinex3);
fprintf(Parser->glonassfile, "%s\n%60sEND OF HEADER\n", buffer, "");
}
Parser->glonassephemeris = 0;
}
file = Parser->glonassfile;
}
else if(r == 1019)
{
if(Parser->gpsephemeris)
{
if(!(Parser->gpsfile = fopen(Parser->gpsephemeris, "w")))
{
RTCM3Error("Could not open GPS ephemeris output file.\n");
}
else
{
char buffer[100];
fprintf(Parser->gpsfile,
"%9.2f%11sN: GPS NAV DATA%25sRINEX VERSION / TYPE\n", ver, "", "");
HandleRunBy(buffer, sizeof(buffer), 0, Parser->rinex3);
fprintf(Parser->gpsfile, "%s\n%60sEND OF HEADER\n", buffer, "");
}
Parser->gpsephemeris = 0;
}
file = Parser->gpsfile;
}
else if(r == 1043)
{
if(Parser->sbasephemeris)
{
if(!(Parser->sbasfile = fopen(Parser->sbasephemeris, "w")))
{
RTCM3Error("Could not open SBAS ephemeris output file.\n");
}
else
{
char buffer[100];
fprintf(Parser->sbasfile,
"%9.2f%11sN: SBAS NAV DATA%24sRINEX VERSION / TYPE\n", ver, "", "");
HandleRunBy(buffer, sizeof(buffer), 0, Parser->rinex3);
fprintf(Parser->sbasfile, "%s\n%60sEND OF HEADER\n", buffer, "");
}
Parser->sbasephemeris = 0;
}
file = Parser->sbasfile;
}
else if(r == 1044)
{
if(Parser->qzssephemeris)
{
if(!(Parser->qzssfile = fopen(Parser->qzssephemeris, "w")))
{
RTCM3Error("Could not open QZSS ephemeris output file.\n");
}
else
{
char buffer[100];
fprintf(Parser->qzssfile,
"%9.2f%11sN: QZSS NAV DATA%24sRINEX VERSION / TYPE\n", ver, "", "");
HandleRunBy(buffer, sizeof(buffer), 0, Parser->rinex3);
fprintf(Parser->qzssfile, "%s\n%60sEND OF HEADER\n", buffer, "");
}
Parser->qzssephemeris = 0;
}
file = Parser->qzssfile;
}
else if(r == RTCM3ID_BDS)
{
if(Parser->bdsephemeris)
{
if(!(Parser->bdsfile = fopen(Parser->bdsephemeris, "w")))
{
RTCM3Error("Could not open BDS ephemeris output file.\n");
}
else
{
char buffer[100];
fprintf(Parser->bdsfile,
"%9.2f%11sN: BDS NAV DATA%25sRINEX VERSION / TYPE\n", ver, "", "");
HandleRunBy(buffer, sizeof(buffer), 0, Parser->rinex3);
fprintf(Parser->bdsfile, "%s\n%60sEND OF HEADER\n", buffer, "");
}
Parser->bdsephemeris = 0;
}
file = Parser->bdsfile;
}
}
if(file)
{
const char *sep = " ";
if(r == 1020)
{
struct glonassephemeris *e = &Parser->ephemerisGLONASS;
int w = e->GPSWeek, tow = e->GPSTOW, i;
struct converttimeinfo cti;
updatetime(&w, &tow, e->tb*1000, 1); /* Moscow - > UTC */
converttime(&cti, w, tow);
i = e->tk-3*60*60; if(i < 0) i += 86400;
if(Parser->rinex3)
{
ConvLine(file, "R%02d %04d %02d %02d %02d %02d %02d%19.12e%19.12e%19.12e\n",
e->almanac_number, cti.year, cti.month, cti.day, cti.hour, cti.minute,
cti.second, -e->tau, e->gamma, (double) i);
sep = " ";
}
else
{
ConvLine(file, "%02d %02d %02d %02d %02d %02d%5.1f%19.12e%19.12e%19.12e\n",
e->almanac_number, cti.year%100, cti.month, cti.day, cti.hour, cti.minute,
(double) cti.second, -e->tau, e->gamma, (double) i);
}
ConvLine(file, "%s%19.12e%19.12e%19.12e%19.12e\n", sep, e->x_pos,
e->x_velocity, e->x_acceleration, (e->flags & GLOEPHF_UNHEALTHY) ? 1.0 : 0.0);
ConvLine(file, "%s%19.12e%19.12e%19.12e%19.12e\n", sep, e->y_pos,
e->y_velocity, e->y_acceleration, (double) e->frequency_number);
ConvLine(file, "%s%19.12e%19.12e%19.12e%19.12e\n", sep, e->z_pos,
e->z_velocity, e->z_acceleration, (double) e->E);
}
else if(r == 1043)
{
struct sbasephemeris *e = &Parser->ephemerisSBAS;
struct converttimeinfo cti;
converttime(&cti, e->GPSweek_TOE, e->TOE);
if(Parser->rinex3)
{
ConvLine(file, "S%02d %04d %2d %2d %2d %2d %2d%19.12e%19.12e%19.12e\n",
e->satellite-100, cti.year, cti.month, cti.day, cti.hour, cti.minute,
cti.second, e->agf0, e->agf1, (double)e->TOW);
sep = " ";
}
else
{
ConvLine(file, "%02d %02d %02d %02d %02d %02d%5.1f%19.12e%19.12e%19.12e\n",
e->satellite-100, cti.year%100, cti.month, cti.day, cti.hour, cti.minute,
(double)cti.second, e->agf0, e->agf1, (double)e->TOW);
}
/* X, health */
ConvLine(file, "%s%19.12e%19.12e%19.12e%19.12e\n", sep, e->x_pos,
e->x_velocity, e->x_acceleration, e->URA == 15 ? 1.0 : 0.0);
/* Y, accuracy */
ConvLine(file, "%s%19.12e%19.12e%19.12e%19.12e\n", sep, e->y_pos,
e->y_velocity, e->y_acceleration, (double)e->URA);
/* Z */
ConvLine(file, "%s%19.12e%19.12e%19.12e%19.12e\n", sep, e->z_pos,
e->z_velocity, e->z_acceleration, (double)e->IODN);
}
else if(r == RTCM3ID_BDS)
{
struct bdsephemeris *e = &Parser->ephemerisBDS;
double d; /* temporary variable */
struct converttimeinfo cti;
converttimebds(&cti, e->BDSweek, e->TOC);
int num = e->satellite-PRN_BDS_START+1;
if(Parser->rinex3)
{
ConvLine(file,
"C%02d %04d %02d %02d %02d %02d %02d%19.12e%19.12e%19.12e\n",
num, cti.year, cti.month, cti.day, cti.hour,
cti.minute, cti.second, e->clock_bias, e->clock_drift,
e->clock_driftrate);
sep = " ";
}
else /* actually this is never used, as BDS is undefined for 2.x */
{
ConvLine(file,
"%02d %02d %02d %02d %02d %02d%05.1f%19.12e%19.12e%19.12e\n",
num, cti.year%100, cti.month, cti.day, cti.hour,
cti.minute, (double) cti.second, e->clock_bias, e->clock_drift,
e->clock_driftrate);
}
ConvLine(file, "%s%19.12e%19.12e%19.12e%19.12e\n", sep,
(double)e->AODE, e->Crs, e->Delta_n, e->M0);
ConvLine(file, "%s%19.12e%19.12e%19.12e%19.12e\n", sep, e->Cuc,
e->e, e->Cus, e->sqrt_A);
ConvLine(file, "%s%19.12e%19.12e%19.12e%19.12e\n", sep,
(double) e->TOE, e->Cic, e->OMEGA0, e->Cis);
ConvLine(file, "%s%19.12e%19.12e%19.12e%19.12e\n", sep, e->i0,
e->Crc, e->omega, e->OMEGADOT);
ConvLine(file, "%s%19.12e %19.12e\n", sep, e->IDOT,
(double) e->BDSweek);
if(e->URAI <= 6) /* URA index */
d = ceil(10.0*pow(2.0, 1.0+((double)e->URAI)/2.0))/10.0;
else
d = ceil(10.0*pow(2.0, ((double)e->URAI)/2.0))/10.0;
/* 15 indicates not to use satellite. We can't handle this special
case, so we create a high "non"-accuracy value. */
ConvLine(file, "%s%19.12e%19.12e%19.12e%19.12e\n", sep, d,
((double) (e->flags & BDSEPHF_SATH1)), e->TGD_B1_B3,
e->TGD_B2_B3);
ConvLine(file, "%s%19.12e%19.12e\n", sep, ((double)e->TOW),
(double) e->AODC);
/* TOW, AODC */
}
else /* if(r == 1019 || r == 1044) */
{
struct gpsephemeris *e = &Parser->ephemerisGPS;
double d; /* temporary variable */
unsigned long int i; /* temporary variable */
struct converttimeinfo cti;
converttime(&cti, e->GPSweek, e->TOC);
int qzss = 0;
int num = e->satellite;
if(num >= PRN_QZSS_START)
{
qzss = 1;
num -= PRN_QZSS_START-1;
}
if(Parser->rinex3)
{
ConvLine(file,
"%s%02d %04d %02d %02d %02d %02d %02d%19.12e%19.12e%19.12e\n",
qzss ? "J" : "G", num, cti.year, cti.month, cti.day, cti.hour,
cti.minute, cti.second, e->clock_bias, e->clock_drift,
e->clock_driftrate);
sep = " ";
}
else
{
ConvLine(file,
"%02d %02d %02d %02d %02d %02d%05.1f%19.12e%19.12e%19.12e\n",
num, cti.year%100, cti.month, cti.day, cti.hour,
cti.minute, (double) cti.second, e->clock_bias, e->clock_drift,
e->clock_driftrate);
}
ConvLine(file, "%s%19.12e%19.12e%19.12e%19.12e\n", sep,
(double)e->IODE, e->Crs, e->Delta_n, e->M0);
ConvLine(file, "%s%19.12e%19.12e%19.12e%19.12e\n", sep, e->Cuc,
e->e, e->Cus, e->sqrt_A);
ConvLine(file, "%s%19.12e%19.12e%19.12e%19.12e\n", sep,
(double) e->TOE, e->Cic, e->OMEGA0, e->Cis);
ConvLine(file, "%s%19.12e%19.12e%19.12e%19.12e\n", sep, e->i0,
e->Crc, e->omega, e->OMEGADOT);
d = 0;
i = e->flags;
if(i & GPSEPHF_L2CACODE)
d += 2.0;
if(i & GPSEPHF_L2PCODE)
d += 1.0;
ConvLine(file, "%s%19.12e%19.12e%19.12e%19.12e\n", sep, e->IDOT, d,
(double) e->GPSweek, i & GPSEPHF_L2PCODEDATA ? 1.0 : 0.0);
if(e->URAindex <= 6) /* URA index */
d = ceil(10.0*pow(2.0, 1.0+((double)e->URAindex)/2.0))/10.0;
else
d = ceil(10.0*pow(2.0, ((double)e->URAindex)/2.0))/10.0;
/* 15 indicates not to use satellite. We can't handle this special
case, so we create a high "non"-accuracy value. */
ConvLine(file, "%s%19.12e%19.12e%19.12e%19.12e\n", sep, d,
((double) e->SVhealth), e->TGD, ((double) e->IODC));
ConvLine(file, "%s%19.12e%19.12e\n", sep, ((double)e->TOW),
(i & GPSEPHF_6HOURSFIT) ? (Parser->rinex3 ? 1 : qzss ? 4.0 : 6.0)
: (Parser->rinex3 ? 0 : qzss ? 2.0 : 4.0));
/* TOW,Fit */
}
}
}
else if (r == 1 || r == 2)
{
int i, j, o, nh=0, hl=2;
char newheader[512];
struct converttimeinfo cti;
/* skip first epochs to detect correct data types */
if(Parser->init < (Parser->changeobs ? 1 : NUMSTARTSKIP))
{
++Parser->init;
if(Parser->init == (Parser->changeobs ? 1 : NUMSTARTSKIP))
HandleHeader(Parser);
else
{
for(i = 0; i < Parser->Data.numsats; ++i)
Parser->startflags |= Parser->Data.dataflags[i];
continue;
}
}
if(r == 2 && !Parser->validwarning)
{
RTCM3Text("No valid RINEX! All values are modulo 299792.458!"
" COMMENT\n");
Parser->validwarning = 1;
}
converttime(&cti, Parser->Data.week,
(int)floor(Parser->Data.timeofweek/1000.0));
newheader[0] = 0;
if(Parser->changeobs)
{
nh = HandleObsHeader(Parser, newheader, sizeof(newheader), 0);
for(i = 0; i < nh; ++i)
{
if(newheader[i] == '\n')
++hl;
}
}
if(Parser->rinex3)
{
if(nh)
{
RTCM3Text("> %04d %02d %02d %02d %02d%11.7f 4%3d\n",
cti.year, cti.month, cti.day, cti.hour, cti.minute, cti.second
+ fmod(Parser->Data.timeofweek/1000.0,1.0), hl);
RTCM3Text("%s\n "
" END OF HEADER\n", newheader);
}
RTCM3Text("> %04d %02d %02d %02d %02d%11.7f %d%3d\n",
cti.year, cti.month, cti.day, cti.hour, cti.minute, cti.second
+ fmod(Parser->Data.timeofweek/1000.0,1.0), 0,
Parser->Data.numsats);
for(i = 0; i < Parser->Data.numsats; ++i)
{
int sys[RTCM3_MSM_NUMSYS] = {0,0,0,0,0,0};
if(Parser->Data.satellites[i] <= PRN_GPS_END)
{
RTCM3Text("G%02d", Parser->Data.satellites[i]);
sys[RTCM3_MSM_GPS] = 1;
}
else if(Parser->Data.satellites[i] >= PRN_GLONASS_START
&& Parser->Data.satellites[i] <= PRN_GLONASS_END)
{
RTCM3Text("R%02d", Parser->Data.satellites[i] - (PRN_GLONASS_START-1));
sys[RTCM3_MSM_GLONASS] = 1;
}
else if(Parser->Data.satellites[i] >= PRN_GALILEO_START
&& Parser->Data.satellites[i] <= PRN_GALILEO_END)
{
RTCM3Text("E%02d", Parser->Data.satellites[i] - (PRN_GALILEO_START-1));
sys[RTCM3_MSM_GALILEO] = 1;
}
else if(Parser->Data.satellites[i] >= PRN_GIOVE_START
&& Parser->Data.satellites[i] <= PRN_GIOVE_END)
{
RTCM3Text("E%02d", Parser->Data.satellites[i] - (PRN_GIOVE_START-PRN_GIOVE_OFFSET));
sys[RTCM3_MSM_GALILEO] = 1;
}
else if(Parser->Data.satellites[i] >= PRN_QZSS_START
&& Parser->Data.satellites[i] <= PRN_QZSS_END)
{
RTCM3Text("J%02d", Parser->Data.satellites[i] - (PRN_QZSS_START-1));
sys[RTCM3_MSM_QZSS] = 1;
}
else if(Parser->Data.satellites[i] >= PRN_BDS_START
&& Parser->Data.satellites[i] <= PRN_BDS_END)
{
RTCM3Text("C%02d", Parser->Data.satellites[i] - (PRN_BDS_START-1));
sys[RTCM3_MSM_BDS] = 1;
}
else if(Parser->Data.satellites[i] >= PRN_SBAS_START
&& Parser->Data.satellites[i] <= PRN_SBAS_END)
{
RTCM3Text("S%02d", Parser->Data.satellites[i] - PRN_SBAS_START+20);
sys[RTCM3_MSM_SBAS] = 1;
}
else
{
RTCM3Text("%3d", Parser->Data.satellites[i]);
}
if(sys[RTCM3_MSM_GLONASS])
{
for(j = 0; j < Parser->info[RTCM3_MSM_GLONASS].numtypes; ++j)
{
long long df = Parser->info[RTCM3_MSM_GLONASS].flags[j];
int pos = Parser->info[RTCM3_MSM_GLONASS].pos[j];
if((Parser->Data.dataflags[i] & df)
&& !isnan(Parser->Data.measdata[i][pos])
&& !isinf(Parser->Data.measdata[i][pos])
&& (Parser->Data.codetype[i][pos]
&& Parser->info[RTCM3_MSM_GLONASS].type[pos]
&& Parser->info[RTCM3_MSM_GLONASS].type[pos]
== Parser->Data.codetype[i][pos][1]))
{
char lli = ' ';
char snr = ' ';
if(df & (GNSSDF_L1CDATA|GNSSDF_L1PDATA))
{
if(Parser->Data.dataflags2[i] & GNSSDF2_LOCKLOSSL1)
lli = '1';
snr = '0'+Parser->Data.snrL1[i];
}
if(df & (GNSSDF_L2CDATA|GNSSDF_L2PDATA))
{
if(Parser->Data.dataflags2[i] & GNSSDF2_LOCKLOSSL2)
lli = '1';
snr = '0'+Parser->Data.snrL2[i];
}
RTCM3Text("%14.3f%c%c",
Parser->Data.measdata[i][pos],lli,snr);
}
else
{ /* no or illegal data */
RTCM3Text(" ");
}
}
}
else if(sys[RTCM3_MSM_GALILEO])
{
for(j = 0; j < Parser->info[RTCM3_MSM_GALILEO].numtypes; ++j)
{
long long df = Parser->info[RTCM3_MSM_GALILEO].flags[j];
int pos = Parser->info[RTCM3_MSM_GALILEO].pos[j];
if((Parser->Data.dataflags[i] & df)
&& !isnan(Parser->Data.measdata[i][pos])
&& !isinf(Parser->Data.measdata[i][pos])
&& (Parser->Data.codetype[i][pos]
&& Parser->info[RTCM3_MSM_GALILEO].type[pos]
&& Parser->info[RTCM3_MSM_GALILEO].type[pos]
== Parser->Data.codetype[i][pos][1]))
{
char lli = ' ';
char snr = ' ';
if(df & (GNSSDF_L1CDATA|GNSSDF_L1PDATA))
{
if(Parser->Data.dataflags2[i] & GNSSDF2_LOCKLOSSL1)
lli = '1';
snr = '0'+Parser->Data.snrL1[i];
}
if(df & GNSSDF_L6DATA)
{
if(Parser->Data.dataflags2[i] & GNSSDF2_LOCKLOSSE6)
lli = '1';
snr = ' ';
}
if(df & GNSSDF_L5DATA)
{
if(Parser->Data.dataflags2[i] & GNSSDF2_LOCKLOSSL5)
lli = '1';
snr = ' ';
}
if(df & GNSSDF_L5BDATA)
{
if(Parser->Data.dataflags2[i] & GNSSDF2_LOCKLOSSE5B)
lli = '1';
snr = ' ';
}
if(df & GNSSDF_L5ABDATA)
{
if(Parser->Data.dataflags2[i] & GNSSDF2_LOCKLOSSE5AB)
lli = '1';
snr = ' ';
}
RTCM3Text("%14.3f%c%c",
Parser->Data.measdata[i][pos],lli,snr);
}
else
{ /* no or illegal data */
RTCM3Text(" ");
}
}
}
else if(sys[RTCM3_MSM_BDS])
{
for(j = 0; j < Parser->info[RTCM3_MSM_BDS].numtypes; ++j)
{
long long df = Parser->info[RTCM3_MSM_BDS].flags[j];
int pos = Parser->info[RTCM3_MSM_BDS].pos[j];
if((Parser->Data.dataflags[i] & df)
&& !isnan(Parser->Data.measdata[i][pos])
&& !isinf(Parser->Data.measdata[i][pos])
&& (Parser->Data.codetype[i][pos]
&& Parser->info[RTCM3_MSM_BDS].type[pos]
&& Parser->info[RTCM3_MSM_BDS].type[pos]
== Parser->Data.codetype[i][pos][1]))
{
char lli = ' ';
char snr = ' ';
if(df & GNSSDF_LB1DATA)
{
if(Parser->Data.dataflags2[i] & GNSSDF2_LOCKLOSSB1)
lli = '1';
}
if(df & GNSSDF_LB2DATA)
{
if(Parser->Data.dataflags2[i] & GNSSDF2_LOCKLOSSB2)
lli = '1';
}
if(df & GNSSDF_LB3DATA)
{
if(Parser->Data.dataflags2[i] & GNSSDF2_LOCKLOSSB3)
lli = '1';
}
RTCM3Text("%14.3f%c%c",
Parser->Data.measdata[i][pos],lli,snr);
}
else
{ /* no or illegal data */
RTCM3Text(" ");
}
}
}
else if(sys[RTCM3_MSM_QZSS])
{
for(j = 0; j < Parser->info[RTCM3_MSM_QZSS].numtypes; ++j)
{
long long df = Parser->info[RTCM3_MSM_QZSS].flags[j];
int pos = Parser->info[RTCM3_MSM_QZSS].pos[j];
if((Parser->Data.dataflags[i] & df)
&& !isnan(Parser->Data.measdata[i][pos])
&& !isinf(Parser->Data.measdata[i][pos])
&& (Parser->Data.codetype[i][pos]
&& Parser->info[RTCM3_MSM_QZSS].type[pos]
&& Parser->info[RTCM3_MSM_QZSS].type[pos]
== Parser->Data.codetype[i][pos][1]))
{
char lli = ' ';
char snr = ' ';
if(df & GNSSDF_L1CDATA)
{
if(Parser->Data.dataflags2[i] & GNSSDF2_LOCKLOSSL1)
lli = '1';
snr = '0'+Parser->Data.snrL1[i];
}
if(df & (GNSSDF_L2CDATA|GNSSDF_L2PDATA))
{
if(Parser->Data.dataflags2[i] & GNSSDF2_LOCKLOSSL2)
lli = '1';
snr = '0'+Parser->Data.snrL2[i];
}
if(df & GNSSDF_L5DATA)
{
if(Parser->Data.dataflags2[i] & GNSSDF2_LOCKLOSSL5)
lli = '1';
snr = ' ';
}
RTCM3Text("%14.3f%c%c",
Parser->Data.measdata[i][pos],lli,snr);
}
else
{ /* no or illegal data */
RTCM3Text(" ");
}
}
}
else if(sys[RTCM3_MSM_SBAS])
{
for(j = 0; j < Parser->info[RTCM3_MSM_SBAS].numtypes; ++j)
{
long long df = Parser->info[RTCM3_MSM_SBAS].flags[j];
int pos = Parser->info[RTCM3_MSM_SBAS].pos[j];
if((Parser->Data.dataflags[i] & df)
&& !isnan(Parser->Data.measdata[i][pos])
&& !isinf(Parser->Data.measdata[i][pos])
&& (Parser->Data.codetype[i][pos]
&& Parser->info[RTCM3_MSM_SBAS].type[pos]
&& Parser->info[RTCM3_MSM_SBAS].type[pos]
== Parser->Data.codetype[i][pos][1]))
{
char lli = ' ';
char snr = ' ';
if(df & (GNSSDF_L1CDATA|GNSSDF_L1PDATA))
{
if(Parser->Data.dataflags2[i] & GNSSDF2_LOCKLOSSL1)
lli = '1';
snr = '0'+Parser->Data.snrL1[i];
}
if(df & GNSSDF_L5DATA)
{
if(Parser->Data.dataflags2[i] & GNSSDF2_LOCKLOSSL5)
lli = '1';
snr = ' ';
}
RTCM3Text("%14.3f%c%c",
Parser->Data.measdata[i][pos],lli,snr);
}
else
{ /* no or illegal data */
RTCM3Text(" ");
}
}
}
else
{
for(j = 0; j < Parser->info[RTCM3_MSM_GPS].numtypes; ++j)
{
long long df = Parser->info[RTCM3_MSM_GPS].flags[j];
int pos = Parser->info[RTCM3_MSM_GPS].pos[j];
if((Parser->Data.dataflags[i] & df)
&& !isnan(Parser->Data.measdata[i][pos])
&& !isinf(Parser->Data.measdata[i][pos])
&& (Parser->Data.codetype[i][pos]
&& Parser->info[RTCM3_MSM_GPS].type[pos]
&& Parser->info[RTCM3_MSM_GPS].type[pos]
== Parser->Data.codetype[i][pos][1]))
{
char lli = ' ';
char snr = ' ';
if(df & (GNSSDF_L1CDATA|GNSSDF_L1PDATA))
{
if(Parser->Data.dataflags2[i] & GNSSDF2_LOCKLOSSL1)
lli = '1';
snr = '0'+Parser->Data.snrL1[i];
}
if(df & (GNSSDF_L2CDATA|GNSSDF_L2PDATA))
{
if(Parser->Data.dataflags2[i] & GNSSDF2_LOCKLOSSL2)
lli = '1';
snr = '0'+Parser->Data.snrL2[i];
}
if(df & GNSSDF_L5DATA)
{
if(Parser->Data.dataflags2[i] & GNSSDF2_LOCKLOSSL5)
lli = '1';
snr = ' ';
}
RTCM3Text("%14.3f%c%c",
Parser->Data.measdata[i][pos],lli,snr);
}
else
{ /* no or illegal data */
RTCM3Text(" ");
}
}
}
RTCM3Text("\n");
}
}
else
{
RTCM3Text(" %02d %2d %2d %2d %2d %10.7f %d%3d",
cti.year%100, cti.month, cti.day, cti.hour, cti.minute, cti.second
+ fmod(Parser->Data.timeofweek/1000.0,1.0), nh ? 4 : 0,
Parser->Data.numsats);
for(i = 0; i < 12 && i < Parser->Data.numsats; ++i)
{
if(Parser->Data.satellites[i] <= PRN_GPS_END)
RTCM3Text("G%02d", Parser->Data.satellites[i]);
else if(Parser->Data.satellites[i] >= PRN_GLONASS_START
&& Parser->Data.satellites[i] <= PRN_GLONASS_END)
RTCM3Text("R%02d", Parser->Data.satellites[i]
- (PRN_GLONASS_START-1));
else if(Parser->Data.satellites[i] >= PRN_SBAS_START
&& Parser->Data.satellites[i] <= PRN_SBAS_END)
RTCM3Text("S%02d", Parser->Data.satellites[i]
- PRN_SBAS_START+20);
else if(Parser->Data.satellites[i] >= PRN_GALILEO_START
&& Parser->Data.satellites[i] <= PRN_GALILEO_END)
RTCM3Text("E%02d", Parser->Data.satellites[i]
- (PRN_GALILEO_START-1));
else if(Parser->Data.satellites[i] >= PRN_GIOVE_START
&& Parser->Data.satellites[i] <= PRN_GIOVE_END)
RTCM3Text("E%02d", Parser->Data.satellites[i]
- (PRN_GIOVE_START-PRN_GIOVE_OFFSET));
else if(Parser->Data.satellites[i] >= PRN_QZSS_START
&& Parser->Data.satellites[i] <= PRN_QZSS_END)
RTCM3Text("J%02d", Parser->Data.satellites[i]
- (PRN_QZSS_START-1));
else if(Parser->Data.satellites[i] >= PRN_BDS_START
&& Parser->Data.satellites[i] <= PRN_BDS_END)
RTCM3Text("C%02d", Parser->Data.satellites[i]
- (PRN_BDS_START-1));
else
RTCM3Text("%3d", Parser->Data.satellites[i]);
}
RTCM3Text("\n");
o = 12;
j = Parser->Data.numsats - 12;
while(j > 0)
{
RTCM3Text(" ");
for(i = o; i < o+12 && i < Parser->Data.numsats; ++i)
{
if(Parser->Data.satellites[i] <= PRN_GPS_END)
RTCM3Text("G%02d", Parser->Data.satellites[i]);
else if(Parser->Data.satellites[i] >= PRN_GLONASS_START
&& Parser->Data.satellites[i] <= PRN_GLONASS_END)
RTCM3Text("R%02d", Parser->Data.satellites[i]
- (PRN_GLONASS_START-1));
else if(Parser->Data.satellites[i] >= PRN_SBAS_START
&& Parser->Data.satellites[i] <= PRN_SBAS_END)
RTCM3Text("S%02d", Parser->Data.satellites[i]
- PRN_SBAS_START+20);
else if(Parser->Data.satellites[i] >= PRN_GALILEO_START
&& Parser->Data.satellites[i] <= PRN_GALILEO_END)
RTCM3Text("E%02d", Parser->Data.satellites[i]
- (PRN_GALILEO_START-1));
else if(Parser->Data.satellites[i] >= PRN_GIOVE_START
&& Parser->Data.satellites[i] <= PRN_GIOVE_END)
RTCM3Text("E%02d", Parser->Data.satellites[i]
- (PRN_GIOVE_START-PRN_GIOVE_OFFSET));
else if(Parser->Data.satellites[i] >= PRN_QZSS_START
&& Parser->Data.satellites[i] <= PRN_QZSS_END)
RTCM3Text("J%02d", Parser->Data.satellites[i]
- (PRN_QZSS_START-1));
else if(Parser->Data.satellites[i] >= PRN_BDS_START
&& Parser->Data.satellites[i] <= PRN_BDS_END)
RTCM3Text("C%02d", Parser->Data.satellites[i]
- (PRN_BDS_START-1));
else
RTCM3Text("%3d", Parser->Data.satellites[i]);
}
RTCM3Text("\n");
j -= 12;
o += 12;
}
if(nh)
{
RTCM3Text("%s\n "
" END OF HEADER\n", newheader);
}
for(i = 0; i < Parser->Data.numsats; ++i)
{
for(j = 0; j < Parser->info[RTCM3_MSM_GPS].numtypes; ++j)
{
int v = 0;
long long df = Parser->flags[j];
int pos = Parser->pos[j];
if((Parser->Data.dataflags[i] & df)
&& !isnan(Parser->Data.measdata[i][pos])
&& !isinf(Parser->Data.measdata[i][pos]))
{
v = 1;
}
else
{
df = Parser->info[RTCM3_MSM_GPS].flags[j];
pos = Parser->info[RTCM3_MSM_GPS].pos[j];
if((Parser->Data.dataflags[i] & df)
&& !isnan(Parser->Data.measdata[i][pos])
&& !isinf(Parser->Data.measdata[i][pos]))
{
v = 1;
}
}
if(!v)
{ /* no or illegal data */
RTCM3Text(" ");
}
else
{
char lli = ' ';
char snr = ' ';
if(df & (GNSSDF_L1CDATA|GNSSDF_L1PDATA))
{
if(Parser->Data.dataflags2[i] & GNSSDF2_LOCKLOSSL1)
lli = '1';
snr = '0'+Parser->Data.snrL1[i];
}
if(df & (GNSSDF_L2CDATA|GNSSDF_L2PDATA))
{
if(Parser->Data.dataflags2[i]
& (GNSSDF2_LOCKLOSSL2|GNSSDF2_XCORRL2))
{
lli = '0';
if(Parser->Data.dataflags2[i] & GNSSDF2_LOCKLOSSL2)
lli += 1;
if(Parser->Data.dataflags2[i] & GNSSDF2_XCORRL2)
lli += 4;
}
snr = '0'+Parser->Data.snrL2[i];
}
if((df & GNSSDF_P2DATA) && (Parser->Data.dataflags2[i]
& GNSSDF2_XCORRL2))
lli = '4';
RTCM3Text("%14.3f%c%c",
Parser->Data.measdata[i][pos],lli,snr);
}
if(j%5 == 4 || j == Parser->info[RTCM3_MSM_GPS].numtypes-1)
RTCM3Text("\n");
}
}
}
}
}
}
}
#ifndef NO_RTCM3_MAIN
static char datestr[] = "$Date: 2021-04-14 12:51:04 +0000 (Wed, 14 Apr 2021) $";
/* The string, which is send as agent in HTTP request */
#define AGENTSTRING "NTRIP NtripRTCM3ToRINEX"
#define MAXDATASIZE 1000 /* max number of bytes we can get at once */
static const char encodingTable [64] = {
'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P',
'Q','R','S','T','U','V','W','X','Y','Z','a','b','c','d','e','f',
'g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v',
'w','x','y','z','0','1','2','3','4','5','6','7','8','9','+','/'
};
/* does not buffer overrun, but breaks directly after an error */
/* returns the number of required bytes */
static int encode(char *buf, int size, const char *user, const char *pwd)
{
unsigned char inbuf[3];
char *out = buf;
int i, sep = 0, fill = 0, bytes = 0;
while(*user || *pwd)
{
i = 0;
while(i < 3 && *user) inbuf[i++] = *(user++);
if(i < 3 && !sep) {inbuf[i++] = ':'; ++sep; }
while(i < 3 && *pwd) inbuf[i++] = *(pwd++);
while(i < 3) {inbuf[i++] = 0; ++fill; }
if(out-buf < size-1)
*(out++) = encodingTable[(inbuf [0] & 0xFC) >> 2];
if(out-buf < size-1)
*(out++) = encodingTable[((inbuf [0] & 0x03) << 4)
| ((inbuf [1] & 0xF0) >> 4)];
if(out-buf < size-1)
{
if(fill == 2)
*(out++) = '=';
else
*(out++) = encodingTable[((inbuf [1] & 0x0F) << 2)
| ((inbuf [2] & 0xC0) >> 6)];
}
if(out-buf < size-1)
{
if(fill >= 1)
*(out++) = '=';
else
*(out++) = encodingTable[inbuf [2] & 0x3F];
}
bytes += 4;
}
if(out-buf < size)
*out = 0;
return bytes;
}
static int stop = 0;
struct Args
{
const char *server;
const char *port;
int mode;
int timeout;
int rinex3;
int changeobs;
const char *user;
const char *password;
const char *proxyhost;
const char *proxyport;
const char *nmea;
const char *data;
const char *headerfile;
const char *sbasephemeris;
const char *gpsephemeris;
const char *qzssephemeris;
const char *glonassephemeris;
const char *bdsephemeris;
const char *mixedephemeris;
};
/* option parsing */
#ifdef NO_LONG_OPTS
#define LONG_OPT(a)
#else
#define LONG_OPT(a) a
static struct option opts[] = {
{ "data", required_argument, 0, 'd'},
{ "server", required_argument, 0, 's'},
{ "password", required_argument, 0, 'p'},
{ "port", required_argument, 0, 'r'},
{ "timeout", required_argument, 0, 't'},
{ "header", required_argument, 0, 'f'},
{ "user", required_argument, 0, 'u'},
{ "bdsephemeris", required_argument, 0, 'C'},
{ "gpsephemeris", required_argument, 0, 'E'},
{ "qzssephemeris", required_argument, 0, 'Q'},
{ "glonassephemeris", required_argument, 0, 'G'},
{ "sbasephemeris", required_argument, 0, 'B'},
{ "mixedephemeris", required_argument, 0, 'P'},
{ "rinex3", no_argument, 0, '3'},
{ "changeobs", no_argument, 0, 'O'},
{ "proxyport", required_argument, 0, 'R'},
{ "proxyhost", required_argument, 0, 'S'},
{ "nmea", required_argument, 0, 'n'},
{ "mode", required_argument, 0, 'M'},
{ "help", no_argument, 0, 'h'},
{0,0,0,0}};
#endif
#define ARGOPT "-d:s:p:r:t:f:u:E:C:G:B:P:Q:M:S:R:n:h3O"
enum MODE { HTTP = 1, RTSP = 2, NTRIP1 = 3, AUTO = 4, END };
static const char *geturl(const char *url, struct Args *args)
{
static char buf[1000];
static char *Buffer = buf;
static char *Bufend = buf+sizeof(buf);
if(strncmp("ntrip:", url, 6))
return "URL must start with 'ntrip:'.";
url += 6; /* skip ntrip: */
if(*url != '@' && *url != '/')
{
/* scan for mountpoint */
args->data = Buffer;
while(*url && *url != '@' && *url != ';' &&*url != '/' && Buffer != Bufend)
*(Buffer++) = *(url++);
if(Buffer == args->data)
return "Mountpoint required.";
else if(Buffer >= Bufend-1)
return "Parsing buffer too short.";
*(Buffer++) = 0;
}
if(*url == '/') /* username and password */
{
++url;
args->user = Buffer;
while(*url && *url != '@' && *url != ';' && *url != ':' && Buffer != Bufend)
*(Buffer++) = *(url++);
if(Buffer == args->user)
return "Username cannot be empty.";
else if(Buffer >= Bufend-1)
return "Parsing buffer too short.";
*(Buffer++) = 0;
if(*url == ':') ++url;
args->password = Buffer;
while(*url && *url != '@' && *url != ';' && Buffer != Bufend)
*(Buffer++) = *(url++);
if(Buffer == args->password)
return "Password cannot be empty.";
else if(Buffer >= Bufend-1)
return "Parsing buffer too short.";
*(Buffer++) = 0;
}
if(*url == '@') /* server */
{
++url;
if(*url != '@' && *url != ':')
{
args->server = Buffer;
while(*url && *url != '@' && *url != ':' && *url != ';' && Buffer != Bufend)
*(Buffer++) = *(url++);
if(Buffer == args->server)
return "Servername cannot be empty.";
else if(Buffer >= Bufend-1)
return "Parsing buffer too short.";
*(Buffer++) = 0;
}
if(*url == ':')
{
++url;
args->port = Buffer;
while(*url && *url != '@' && *url != ';' && Buffer != Bufend)
*(Buffer++) = *(url++);
if(Buffer == args->port)
return "Port cannot be empty.";
else if(Buffer >= Bufend-1)
return "Parsing buffer too short.";
*(Buffer++) = 0;
}
if(*url == '@') /* proxy */
{
++url;
args->proxyhost = Buffer;
while(*url && *url != ':' && *url != ';' && Buffer != Bufend)
*(Buffer++) = *(url++);
if(Buffer == args->proxyhost)
return "Proxy servername cannot be empty.";
else if(Buffer >= Bufend-1)
return "Parsing buffer too short.";
*(Buffer++) = 0;
if(*url == ':')
{
++url;
args->proxyport = Buffer;
while(*url && *url != ';' && Buffer != Bufend)
*(Buffer++) = *(url++);
if(Buffer == args->proxyport)
return "Proxy port cannot be empty.";
else if(Buffer >= Bufend-1)
return "Parsing buffer too short.";
*(Buffer++) = 0;
}
}
}
if(*url == ';') /* NMEA */
{
args->nmea = ++url;
while(*url)
++url;
}
return *url ? "Garbage at end of server string." : 0;
}
static int getargs(int argc, char **argv, struct Args *args)
{
int res = 1;
int getoptr;
int help = 0;
char *t;
args->server = "euref-ip.net";
args->port = "2101";
args->timeout = 60;
args->user = "";
args->password = "";
args->data = 0;
args->headerfile = 0;
args->gpsephemeris = 0;
args->qzssephemeris = 0;
args->sbasephemeris = 0;
args->glonassephemeris = 0;
args->bdsephemeris = 0;
args->mixedephemeris = 0;
args->rinex3 = 0;
args->nmea = 0;
args->changeobs = 0;
args->proxyhost = 0;
args->proxyport = "2101";
args->mode = AUTO;
help = 0;
do
{
#ifdef NO_LONG_OPTS
switch((getoptr = getopt(argc, argv, ARGOPT)))
#else
switch((getoptr = getopt_long(argc, argv, ARGOPT, opts, 0)))
#endif
{
case 's': args->server = optarg; break;
case 'u': args->user = optarg; break;
case 'p': args->password = optarg; break;
case 'd': args->data = optarg; break;
case 'f': args->headerfile = optarg; break;
case 'C': args->bdsephemeris = optarg; break;
case 'E': args->gpsephemeris = optarg; break;
case 'B': args->sbasephemeris = optarg; break;
case 'G': args->glonassephemeris = optarg; break;
case 'Q': args->qzssephemeris = optarg; break;
case 'P': args->mixedephemeris = optarg; break;
case 'r': args->port = optarg; break;
case '3': args->rinex3 = 1; break;
case 'S': args->proxyhost = optarg; break;
case 'n': args->nmea = optarg; break;
case 'R': args->proxyport = optarg; break;
case 'O': args->changeobs = 1; break;
case 'h': help=1; break;
case 'M':
args->mode = 0;
if (!strcmp(optarg,"n") || !strcmp(optarg,"ntrip1"))
args->mode = NTRIP1;
else if(!strcmp(optarg,"h") || !strcmp(optarg,"http"))
args->mode = HTTP;
else if(!strcmp(optarg,"r") || !strcmp(optarg,"rtsp"))
args->mode = RTSP;
else if(!strcmp(optarg,"a") || !strcmp(optarg,"auto"))
args->mode = AUTO;
else args->mode = atoi(optarg);
if((args->mode == 0) || (args->mode >= END))
{
fprintf(stderr, "Mode %s unknown\n", optarg);
res = 0;
}
break;
case 't':
args->timeout = strtoul(optarg, &t, 10);
if((t && *t) || args->timeout < 0)
res = 0;
break;
case 1:
{
const char *err;
if((err = geturl(optarg, args)))
{
RTCM3Error("%s\n\n", err);
res = 0;
}
}
break;
case -1: break;
}
} while(getoptr != -1 || !res);
datestr[0] = datestr[7];
datestr[1] = datestr[8];
datestr[2] = datestr[9];
datestr[3] = datestr[10];
datestr[5] = datestr[12];
datestr[6] = datestr[13];
datestr[8] = datestr[15];
datestr[9] = datestr[16];
datestr[4] = datestr[7] = '-';
datestr[10] = 0;
if(args->mixedephemeris && !args->rinex3)
{
RTCM3Error("RINEX2 cannot created combined ephemeris file.\n");
res = 0;
}
else if(args->mixedephemeris && (args->gpsephemeris || args->glonassephemeris
|| args->bdsephemeris || args->qzssephemeris || args->sbasephemeris))
{
RTCM3Error("Combined ephemeris file specified with another one.\n"
"Please specify only one navigation file.\n");
res = 0;
}
else if(args->bdsephemeris && !args->rinex3)
{
RTCM3Error("RINEX2 cannot produce BDS ephemeris.\n");
res = 0;
}
else if(!res || help)
{
RTCM3Error("Version %s (%s) GPL" COMPILEDATE
"\nUsage: %s -s server -u user ...\n"
" -d " LONG_OPT("--data ") "the requested data set\n"
" -f " LONG_OPT("--headerfile ") "file for RINEX header information\n"
" -s " LONG_OPT("--server ") "the server name or address\n"
" -p " LONG_OPT("--password ") "the login password\n"
" -r " LONG_OPT("--port ") "the server port number (default 2101)\n"
" -t " LONG_OPT("--timeout ") "timeout in seconds (default 60)\n"
" -u " LONG_OPT("--user ") "the user name\n"
" -C " LONG_OPT("--bdsephemeris ") "output file for BDS ephemeris data\n"
" -E " LONG_OPT("--gpsephemeris ") "output file for GPS ephemeris data\n"
" -G " LONG_OPT("--glonassephemeris ") "output file for GLONASS ephemeris data\n"
" -Q " LONG_OPT("--qzssephemeris ") "output file for QZSS ephemeris data\n"
" -B " LONG_OPT("--sbasephemeris ") "output file for SBAS ephemeris data\n"
" -P " LONG_OPT("--mixedephemeris ") "output file for all ephemeris data\n"
" -3 " LONG_OPT("--rinex3 ") "output RINEX type 3 data\n"
" -S " LONG_OPT("--proxyhost ") "proxy name or address\n"
" -R " LONG_OPT("--proxyport ") "proxy port, optional (default 2101)\n"
" -n " LONG_OPT("--nmea ") "NMEA string for sending to server\n"
" -O " LONG_OPT("--changeobs ") "Add observation type change header lines\n"
" -M " LONG_OPT("--mode ") "mode for data request\n"
" Valid modes are:\n"
" 1, h, http NTRIP Version 2.0 Caster in TCP/IP mode\n"
" 2, r, rtsp NTRIP Version 2.0 Caster in RTSP/RTP mode\n"
" 3, n, ntrip1 NTRIP Version 1.0 Caster\n"
" 4, a, auto automatic detection (default)\n"
"or using an URL:\n%s ntrip:data[/user[:password]][@[server][:port][@proxyhost[:proxyport]]][;nmea]\n"
, revisionstr, datestr, argv[0], argv[0]);
exit(1);
}
return res;
}
/* let the output complete a block if necessary */
static void signalhandler(int sig)
{
if(!stop)
{
RTCM3Error("Stop signal number %d received. "
"Trying to terminate gentle.\n", sig);
stop = 1;
alarm(1);
}
}
#ifndef WINDOWSVERSION
static void WaitMicro(int mic)
{
struct timeval tv;
tv.tv_sec = mic/1000000;
tv.tv_usec = mic%1000000;
#ifdef DEBUG
fprintf(stderr, "Waiting %d micro seconds\n", mic);
#endif
select(0, 0, 0, 0, &tv);
}
#else /* WINDOWSVERSION */
void WaitMicro(int mic)
{
Sleep(mic/1000);
}
#endif /* WINDOWSVERSION */
#define ALARMTIME (2*60)
/* for some reason we had to abort hard (maybe waiting for data */
#ifdef __GNUC__
static __attribute__ ((noreturn)) void signalhandler_alarm(
int sig __attribute__((__unused__)))
#else /* __GNUC__ */
static void signalhandler_alarm(int sig)
#endif /* __GNUC__ */
{
RTCM3Error("Programm forcefully terminated.\n");
exit(1);
}
int main(int argc, char **argv)
{
struct Args args;
struct RTCM3ParserData Parser;
setbuf(stdout, 0);
setbuf(stdin, 0);
setbuf(stderr, 0);
fixrevision();
signal(SIGINT, signalhandler);
signal(SIGALRM,signalhandler_alarm);
signal(SIGQUIT,signalhandler);
signal(SIGTERM,signalhandler);
signal(SIGPIPE,signalhandler);
memset(&Parser, 0, sizeof(Parser));
{
time_t tim;
tim = time(0) - ((10*365+2+5)*24*60*60+LEAPSECONDS);
Parser.GPSWeek = tim/(7*24*60*60);
Parser.GPSTOW = tim%(7*24*60*60);
}
if(getargs(argc, argv, &args))
{
int sockfd, numbytes;
char buf[MAXDATASIZE];
struct sockaddr_in their_addr; /* connector's address information */
struct hostent *he;
struct servent *se;
const char *server, *port, *proxyserver = 0;
char proxyport[6];
char *b;
long i;
struct timeval tv;
alarm(ALARMTIME);
Parser.headerfile = args.headerfile;
Parser.glonassephemeris = args.glonassephemeris;
Parser.gpsephemeris = args.gpsephemeris;
Parser.bdsephemeris = args.bdsephemeris;
Parser.qzssephemeris = args.qzssephemeris;
Parser.sbasephemeris = args.sbasephemeris;
Parser.mixedephemeris = args.mixedephemeris;
Parser.rinex3 = args.rinex3;
Parser.changeobs = args.changeobs;
if(args.proxyhost)
{
int p;
if((i = strtol(args.port, &b, 10)) && (!b || !*b))
p = i;
else if(!(se = getservbyname(args.port, 0)))
{
RTCM3Error("Can't resolve port %s.", args.port);
exit(1);
}
else
{
p = ntohs(se->s_port);
}
snprintf(proxyport, sizeof(proxyport), "%d", p);
port = args.proxyport;
proxyserver = args.server;
server = args.proxyhost;
}
else
{
server = args.server;
port = args.port;
}
memset(&their_addr, 0, sizeof(struct sockaddr_in));
if((i = strtol(port, &b, 10)) && (!b || !*b))
their_addr.sin_port = htons(i);
else if(!(se = getservbyname(port, 0)))
{
RTCM3Error("Can't resolve port %s.", port);
exit(1);
}
else
{
their_addr.sin_port = se->s_port;
}
if(!(he=gethostbyname(server)))
{
RTCM3Error("Server name lookup failed for '%s'.\n", server);
exit(1);
}
if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
{
perror("socket");
exit(1);
}
tv.tv_sec = args.timeout;
tv.tv_usec = 0;
if(setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, (struct timeval *)&tv, sizeof(struct timeval) ) == -1)
{
RTCM3Error("Function setsockopt: %s\n", strerror(errno));
exit(1);
}
their_addr.sin_family = AF_INET;
their_addr.sin_addr = *((struct in_addr *)he->h_addr);
if(args.data && args.mode == RTSP)
{
struct sockaddr_in local;
int sockudp, localport;
int cseq = 1;
socklen_t len;
if((sockudp = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
{
perror("socket");
exit(1);
}
/* fill structure with local address information for UDP */
memset(&local, 0, sizeof(local));
local.sin_family = AF_INET;
local.sin_port = htons(0);
local.sin_addr.s_addr = htonl(INADDR_ANY);
len = sizeof(local);
/* bind() in order to get a random RTP client_port */
if((bind(sockudp, (struct sockaddr *)&local, len)) < 0)
{
perror("bind");
exit(1);
}
if((getsockname(sockudp, (struct sockaddr*)&local, &len)) != -1)
{
localport = ntohs(local.sin_port);
}
else
{
perror("local access failed");
exit(1);
}
if(connect(sockfd, (struct sockaddr *)&their_addr,
sizeof(struct sockaddr)) == -1)
{
perror("connect");
exit(1);
}
i=snprintf(buf, MAXDATASIZE-40, /* leave some space for login */
"SETUP rtsp://%s%s%s/%s RTSP/1.0\r\n"
"CSeq: %d\r\n"
"Ntrip-Version: Ntrip/2.0\r\n"
"Ntrip-Component: Ntripclient\r\n"
"User-Agent: %s/%s\r\n"
"Transport: RTP/GNSS;unicast;client_port=%u\r\n"
"Authorization: Basic ",
args.server, proxyserver ? ":" : "", proxyserver ? args.port : "",
args.data, cseq++, AGENTSTRING, revisionstr, localport);
if(i > MAXDATASIZE-40 || i < 0) /* second check for old glibc */
{
RTCM3Error("Requested data too long\n");
exit(1);
}
i += encode(buf+i, MAXDATASIZE-i-4, args.user, args.password);
if(i > MAXDATASIZE-4)
{
RTCM3Error("Username and/or password too long\n");
exit(1);
}
buf[i++] = '\r';
buf[i++] = '\n';
buf[i++] = '\r';
buf[i++] = '\n';
if(args.nmea)
{
int j = snprintf(buf+i, MAXDATASIZE-i, "%s\r\n", args.nmea);
if(j >= 0 && j < MAXDATASIZE-i)
i += j;
else
{
RTCM3Error("NMEA string too long\n");
exit(1);
}
}
if(send(sockfd, buf, (size_t)i, 0) != i)
{
perror("send");
exit(1);
}
if((numbytes=recv(sockfd, buf, MAXDATASIZE-1, 0)) != -1)
{
if(numbytes >= 17 && !strncmp(buf, "RTSP/1.0 200 OK\r\n", 17))
{
int serverport = 0, session = 0;
const char *portcheck = "server_port=";
const char *sessioncheck = "session: ";
int l = strlen(portcheck)-1;
int j=0;
for(i = 0; j != l && i < numbytes-l; ++i)
{
for(j = 0; j < l && tolower(buf[i+j]) == portcheck[j]; ++j)
;
}
if(i == numbytes-l)
{
RTCM3Error("No server port number found\n");
exit(1);
}
else
{
i+=l;
while(i < numbytes && buf[i] >= '0' && buf[i] <= '9')
serverport = serverport * 10 + buf[i++]-'0';
if(buf[i] != '\r' && buf[i] != ';')
{
RTCM3Error("Could not extract server port\n");
exit(1);
}
}
l = strlen(sessioncheck)-1;
j=0;
for(i = 0; j != l && i < numbytes-l; ++i)
{
for(j = 0; j < l && tolower(buf[i+j]) == sessioncheck[j]; ++j)
;
}
if(i == numbytes-l)
{
RTCM3Error("No session number found\n");
exit(1);
}
else
{
i+=l;
while(i < numbytes && buf[i] >= '0' && buf[i] <= '9')
session = session * 10 + buf[i++]-'0';
if(buf[i] != '\r')
{
RTCM3Error("Could not extract session number\n");
exit(1);
}
}
i = snprintf(buf, MAXDATASIZE,
"PLAY rtsp://%s%s%s/%s RTSP/1.0\r\n"
"CSeq: %d\r\n"
"Session: %d\r\n"
"\r\n",
args.server, proxyserver ? ":" : "", proxyserver ? args.port : "",
args.data, cseq++, session);
if(i > MAXDATASIZE || i < 0) /* second check for old glibc */
{
RTCM3Error("Requested data too long\n");
exit(1);
}
if(send(sockfd, buf, (size_t)i, 0) != i)
{
perror("send");
exit(1);
}
if((numbytes=recv(sockfd, buf, MAXDATASIZE-1, 0)) != -1)
{
if(numbytes >= 17 && !strncmp(buf, "RTSP/1.0 200 OK\r\n", 17))
{
struct sockaddr_in addrRTP;
/* fill structure with caster address information for UDP */
memset(&addrRTP, 0, sizeof(addrRTP));
addrRTP.sin_family = AF_INET;
addrRTP.sin_port = htons(serverport);
their_addr.sin_addr = *((struct in_addr *)he->h_addr);
len = sizeof(addrRTP);
int ts = 0;
int sn = 0;
int ssrc = 0;
int init = 0;
int u, v, w;
while(!stop && (i = recvfrom(sockudp, buf, 1526, 0,
(struct sockaddr*) &addrRTP, &len)) > 0)
{
alarm(ALARMTIME);
if(i >= 12+1 && (unsigned char)buf[0] == (2 << 6) && buf[1] == 0x60)
{
u= ((unsigned char)buf[2]<<8)+(unsigned char)buf[3];
v = ((unsigned char)buf[4]<<24)+((unsigned char)buf[5]<<16)
+((unsigned char)buf[6]<<8)+(unsigned char)buf[7];
w = ((unsigned char)buf[8]<<24)+((unsigned char)buf[9]<<16)
+((unsigned char)buf[10]<<8)+(unsigned char)buf[11];
if(init)
{
int z;
if(u < -30000 && sn > 30000) sn -= 0xFFFF;
if(ssrc != w || ts > v)
{
RTCM3Error("Illegal UDP data received.\n");
exit(1);
}
if(u > sn) /* don't show out-of-order packets */
for(z = 12; z < i && !stop; ++z)
HandleByte(&Parser, (unsigned int) buf[z]);
}
sn = u; ts = v; ssrc = w; init = 1;
}
else
{
RTCM3Error("Illegal UDP header.\n");
exit(1);
}
}
}
i = snprintf(buf, MAXDATASIZE,
"TEARDOWN rtsp://%s%s%s/%s RTSP/1.0\r\n"
"CSeq: %d\r\n"
"Session: %d\r\n"
"\r\n",
args.server, proxyserver ? ":" : "", proxyserver ? args.port : "",
args.data, cseq++, session);
if(i > MAXDATASIZE || i < 0) /* second check for old glibc */
{
RTCM3Error("Requested data too long\n");
exit(1);
}
if(send(sockfd, buf, (size_t)i, 0) != i)
{
perror("send");
exit(1);
}
}
else
{
RTCM3Error("Could not start data stream.\n");
exit(1);
}
}
else
{
RTCM3Error("Could not setup initial control connection.\n");
exit(1);
}
}
else
{
perror("recv");
exit(1);
}
}
else
{
if(connect(sockfd, (struct sockaddr *)&their_addr,
sizeof(struct sockaddr)) == -1)
{
perror("connect");
exit(1);
}
if(!args.data)
{
i = snprintf(buf, MAXDATASIZE,
"GET %s%s%s%s/ HTTP/1.0\r\n"
"Host: %s\r\n%s"
"User-Agent: %s/%s\r\n"
"Connection: close\r\n"
"\r\n"
, proxyserver ? "http://" : "", proxyserver ? proxyserver : "",
proxyserver ? ":" : "", proxyserver ? proxyport : "",
args.server, args.mode == NTRIP1 ? "" : "Ntrip-Version: Ntrip/2.0\r\n",
AGENTSTRING, revisionstr);
}
else
{
i=snprintf(buf, MAXDATASIZE-40, /* leave some space for login */
"GET %s%s%s%s/%s HTTP/1.0\r\n"
"Host: %s\r\n%s"
"User-Agent: %s/%s\r\n"
"Connection: close\r\n"
"Authorization: Basic "
, proxyserver ? "http://" : "", proxyserver ? proxyserver : "",
proxyserver ? ":" : "", proxyserver ? proxyport : "",
args.data, args.server,
args.mode == NTRIP1 ? "" : "Ntrip-Version: Ntrip/2.0\r\n",
AGENTSTRING, revisionstr);
if(i > MAXDATASIZE-40 || i < 0) /* second check for old glibc */
{
RTCM3Error("Requested data too long\n");
exit(1);
}
i += encode(buf+i, MAXDATASIZE-i-4, args.user, args.password);
if(i > MAXDATASIZE-4)
{
RTCM3Error("Username and/or password too long\n");
exit(1);
}
buf[i++] = '\r';
buf[i++] = '\n';
buf[i++] = '\r';
buf[i++] = '\n';
if(args.nmea)
{
int j = snprintf(buf+i, MAXDATASIZE-i, "%s\r\n", args.nmea);
if(j >= 0 && j < MAXDATASIZE-i)
i += j;
else
{
RTCM3Error("NMEA string too long\n");
exit(1);
}
}
}
if(send(sockfd, buf, (size_t)i, 0) != i)
{
perror("send");
exit(1);
}
if(args.data)
{
int k = 0;
int chunkymode = 0;
int totalbytes = 0;
int chunksize = 0;
while(!stop && (numbytes=recv(sockfd, buf, MAXDATASIZE-1, 0)) != -1)
{
if(numbytes > 0)
alarm(ALARMTIME);
else
{
WaitMicro(100);
continue;
}
if(!k)
{
if(numbytes > 17 && (!strncmp(buf, "HTTP/1.1 200 OK\r\n", 17)
|| !strncmp(buf, "HTTP/1.0 200 OK\r\n", 17)))
{
const char *datacheck = "Content-Type: gnss/data\r\n";
const char *chunkycheck = "Transfer-Encoding: chunked\r\n";
int l = strlen(datacheck)-1;
int j=0;
for(i = 0; j != l && i < numbytes-l; ++i)
{
for(j = 0; j < l && buf[i+j] == datacheck[j]; ++j)
;
}
if(i == numbytes-l)
{
RTCM3Error("No 'Content-Type: gnss/data' found\n");
exit(1);
}
l = strlen(chunkycheck)-1;
j=0;
for(i = 0; j != l && i < numbytes-l; ++i)
{
for(j = 0; j < l && buf[i+j] == chunkycheck[j]; ++j)
;
}
if(i < numbytes-l)
chunkymode = 1;
}
else if(numbytes < 12 || strncmp("ICY 200 OK\r\n", buf, 12))
{
RTCM3Error("Could not get the requested data: ");
for(k = 0; k < numbytes && buf[k] != '\n' && buf[k] != '\r'; ++k)
{
RTCM3Error("%c", isprint(buf[k]) ? buf[k] : '.');
}
RTCM3Error("\n");
exit(1);
}
else if(args.mode != NTRIP1)
{
if(args.mode != AUTO)
{
RTCM3Error("NTRIP version 2 HTTP connection failed%s.\n",
args.mode == AUTO ? ", falling back to NTRIP1" : "");
}
if(args.mode == HTTP)
exit(1);
}
++k;
}
else
{
if(chunkymode)
{
int stop = 0;
int pos = 0;
while(!stop && pos < numbytes)
{
switch(chunkymode)
{
case 1: /* reading number starts */
chunksize = 0;
++chunkymode; /* no break */
case 2: /* during reading number */
i = buf[pos++];
if(i >= '0' && i <= '9') chunksize = chunksize*16+i-'0';
else if(i >= 'a' && i <= 'f') chunksize = chunksize*16+i-'a'+10;
else if(i >= 'A' && i <= 'F') chunksize = chunksize*16+i-'A'+10;
else if(i == '\r') ++chunkymode;
else if(i == ';') chunkymode = 5;
else stop = 1;
break;
case 3: /* scanning for return */
if(buf[pos++] == '\n') chunkymode = chunksize ? 4 : 1;
else stop = 1;
break;
case 4: /* output data */
i = numbytes-pos;
if(i > chunksize) i = chunksize;
{
int z;
for(z = 0; z < i && !stop; ++z)
HandleByte(&Parser, (unsigned int) buf[pos+z]);
}
totalbytes += i;
chunksize -= i;
pos += i;
if(!chunksize)
chunkymode = 1;
break;
case 5:
if(i == '\r') chunkymode = 3;
break;
}
}
if(stop)
{
RTCM3Error("Error in chunky transfer encoding\n");
break;
}
}
else
{
totalbytes += numbytes;
{
int z;
for(z = 0; z < numbytes && !stop; ++z)
HandleByte(&Parser, (unsigned int) buf[z]);
}
}
if(totalbytes < 0) /* overflow */
{
totalbytes = 0;
}
}
}
}
else
{
while(!stop && (numbytes=recv(sockfd, buf, MAXDATASIZE-1, 0)) > 0)
{
alarm(ALARMTIME);
fwrite(buf, (size_t)numbytes, 1, stdout);
}
}
close(sockfd);
}
}
return 0;
}
#endif /* NO_RTCM3_MAIN */