Context Navigation

source: ntrip/trunk/rtcm3torinex/lib/rtcm3torinex.c@ 6360

Last change on this file since 6360 was 6329, checked in by stoecker, 10 years ago
support type 1043 sbas ephemeris
Property svn:keywords set to `Id Revision Date`
File size: 140.8 KB

Rev	Line
[27]	1	/*
	2	Converter for RTCM3 data to RINEX.
[2487]	3	$Id: rtcm3torinex.c 6329 2014-11-20 13:07:01Z stoecker $
[4417]	4	Copyright (C) 2005-2012 by Dirk Stöcker <stoecker@alberding.eu>
[27]	5
[268]	6	This software is a complete NTRIP-RTCM3 to RINEX converter as well as
	7	a module of the BNC tool for multiformat conversion. Contact Dirk
[744]	8	Stöcker for suggestions and bug reports related to the RTCM3 to RINEX
[268]	9	conversion problems and the author of BNC for all the other problems.
	10
[27]	11	This program is free software; you can redistribute it and/or modify
	12	it under the terms of the GNU General Public License as published by
	13	the Free Software Foundation; either version 2 of the License, or
	14	(at your option) any later version.
	15
	16	This program is distributed in the hope that it will be useful,
	17	but WITHOUT ANY WARRANTY; without even the implied warranty of
	18	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	19	GNU General Public License for more details.
	20
	21	You should have received a copy of the GNU General Public License
	22	along with this program; if not, write to the Free Software
	23	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	24	or read http://www.gnu.org/licenses/gpl.txt
	25	*/
	26
	27	#include <ctype.h>
	28	#include <errno.h>
	29	#include <math.h>
	30	#include <signal.h>
[318]	31	#include <stdarg.h>
[27]	32	#include <stdio.h>
	33	#include <stdlib.h>
	34	#include <string.h>
	35	#include <sys/types.h>
	36	#include <time.h>
	37	#include <unistd.h>
	38
[268]	39	#ifndef NO_RTCM3_MAIN
	40	#include <getopt.h>
	41	#include <netdb.h>
	42	#include <netinet/in.h>
	43	#include <sys/socket.h>
	44	#endif
[27]	45
[269]	46	#ifndef sparc
	47	#include <stdint.h>
	48	#endif
	49
[2346]	50	#ifndef isinf
	51	#define isinf(x) 0
	52	#endif
	53
[268]	54	#include "rtcm3torinex.h"
[27]	55
	56	/* CVS revision and version */
[2487]	57	static char revisionstr[] = "$Revision: 6329 $";
[27]	58
[439]	59	#ifndef COMPILEDATE
	60	#define COMPILEDATE " built " __DATE__
	61	#endif
	62
[27]	63	static uint32_t CRC24(long size, const unsigned char *buf)
	64	{
	65	uint32_t crc = 0;
	66	int i;
	67
	68	while(size--)
	69	{
	70	crc ^= (*buf++) << (16);
	71	for(i = 0; i < 8; i++)
	72	{
	73	crc <<= 1;
	74	if(crc & 0x1000000)
	75	crc ^= 0x01864cfb;
	76	}
	77	}
	78	return crc;
	79	}
	80
	81	static int GetMessage(struct RTCM3ParserData *handle)
	82	{
	83	unsigned char m, e;
	84	int i;
	85
	86	m = handle->Message+handle->SkipBytes;
	87	e = handle->Message+handle->MessageSize;
	88	handle->NeedBytes = handle->SkipBytes = 0;
	89	while(e-m >= 3)
	90	{
	91	if(m[0] == 0xD3)
	92	{
	93	handle->size = ((m[1]&3)<<8)\|m[2];
	94	if(e-m >= handle->size+6)
	95	{
	96	if((uint32_t)((m[3+handle->size]<<16)\|(m[3+handle->size+1]<<8)
	97	\|(m[3+handle->size+2])) == CRC24(handle->size+3, m))
	98	{
	99	handle->SkipBytes = handle->size;
	100	break;
	101	}
	102	else
	103	++m;
	104	}
	105	else
	106	{
	107	handle->NeedBytes = handle->size+6;
	108	break;
	109	}
	110	}
	111	else
	112	++m;
	113	}
	114	if(e-m < 3)
	115	handle->NeedBytes = 3;
[744]	116
[27]	117	/* copy buffer to front */
	118	i = m - handle->Message;
	119	if(i && m < e)
[318]	120	memmove(handle->Message, m, (size_t)(handle->MessageSize-i));
[27]	121	handle->MessageSize -= i;
	122
	123	return !handle->NeedBytes;
	124	}
	125
	126	#define LOADBITS(a) \
	127	{ \
	128	while((a) > numbits) \
	129	{ \
	130	if(!size--) break; \
	131	bitfield = (bitfield<<8)\|*(data++); \
	132	numbits += 8; \
	133	} \
	134	}
	135
	136	/* extract bits from data stream
	137	b = variable to store result, a = number of bits */
[2860]	138	#define GETBITS64(b, a) \
	139	{ \
	140	if(((a) > 56) && ((a)-56) > numbits) \
	141	{ \
	142	uint64_t x; \
	143	GETBITS(x, 56) \
	144	LOADBITS((a)-56) \
	145	b = ((x<<((a)-56)) \| (bitfield<<(sizeof(bitfield)*8-numbits)) \
	146	>>(sizeof(bitfield)*8-((a)-56))); \
	147	numbits -= ((a)-56); \
	148	} \
	149	else \
	150	{ \
	151	GETBITS(b, a) \
	152	} \
	153	}
	154
	155	/* extract bits from data stream
	156	b = variable to store result, a = number of bits */
[27]	157	#define GETBITS(b, a) \
	158	{ \
	159	LOADBITS(a) \
	160	b = (bitfield<<(64-numbits))>>(64-(a)); \
	161	numbits -= (a); \
	162	}
	163
[2756]	164	/* extract bits from data stream
	165	b = variable to store result, a = number of bits */
	166	#define GETBITSFACTOR(b, a, c) \
	167	{ \
	168	LOADBITS(a) \
	169	b = ((bitfield<<(sizeof(bitfield)8-numbits))>>(sizeof(bitfield)8-(a)))*(c); \
	170	numbits -= (a); \
	171	}
	172
[502]	173	/* extract floating value from data stream
	174	b = variable to store result, a = number of bits */
	175	#define GETFLOAT(b, a, c) \
	176	{ \
	177	LOADBITS(a) \
	178	b = ((double)((bitfield<<(64-numbits))>>(64-(a))))*(c); \
	179	numbits -= (a); \
	180	}
	181
	182	/* extract signed floating value from data stream
	183	b = variable to store result, a = number of bits */
	184	#define GETFLOATSIGN(b, a, c) \
	185	{ \
	186	LOADBITS(a) \
	187	b = ((double)(((int64_t)(bitfield<<(64-numbits)))>>(64-(a))))*(c); \
	188	numbits -= (a); \
	189	}
	190
[27]	191	/* extract bits from data stream
	192	b = variable to store result, a = number of bits */
	193	#define GETBITSSIGN(b, a) \
	194	{ \
	195	LOADBITS(a) \
	196	b = ((int64_t)(bitfield<<(64-numbits)))>>(64-(a)); \
	197	numbits -= (a); \
	198	}
	199
[502]	200	#define GETFLOATSIGNM(b, a, c) \
	201	{ int l; \
	202	LOADBITS(a) \
	203	l = (bitfield<<(64-numbits))>>(64-1); \
	204	b = ((double)(((bitfield<<(64-(numbits-1))))>>(64-(a-1))))*(c); \
	205	numbits -= (a); \
	206	if(l) b *= -1.0; \
	207	}
	208
[27]	209	#define SKIPBITS(b) { LOADBITS(b) numbits -= (b); }
	210
[1237]	211	/* extract byte-aligned byte from data stream,
	212	b = variable to store size, s = variable to store string pointer */
	213	#define GETSTRING(b, s) \
	214	{ \
	215	b = *(data++); \
	216	s = (char *) data; \
	217	data += b; \
	218	size -= b+1; \
	219	}
	220
[270]	221	struct leapseconds { /* specify the day of leap second */
	222	int day; /* this is the day, where 23:59:59 exists 2 times */
	223	int month; /* not the next day! */
	224	int year;
	225	int taicount;
[744]	226	};
[270]	227	static const int months[13] = {0,31,28,31,30,31,30,31,31,30,31,30,31};
	228	static const struct leapseconds leap[] = {
[4367]	229	/{31, 12, 1971, 10},/
	230	/{30, 06, 1972, 11},/
[270]	231	/{31, 12, 1972, 12},/
	232	/{31, 12, 1973, 13},/
	233	/{31, 12, 1974, 14},/
	234	/{31, 12, 1975, 15},/
	235	/{31, 12, 1976, 16},/
	236	/{31, 12, 1977, 17},/
	237	/{31, 12, 1978, 18},/
	238	/{31, 12, 1979, 19},/
	239	{30, 06, 1981,20},
	240	{30, 06, 1982,21},
	241	{30, 06, 1983,22},
	242	{30, 06, 1985,23},
	243	{31, 12, 1987,24},
	244	{31, 12, 1989,25},
	245	{31, 12, 1990,26},
	246	{30, 06, 1992,27},
	247	{30, 06, 1993,28},
	248	{30, 06, 1994,29},
	249	{31, 12, 1995,30},
	250	{30, 06, 1997,31},
	251	{31, 12, 1998,32},
	252	{31, 12, 2005,33},
[959]	253	{31, 12, 2008,34},
[4365]	254	{30, 06, 2012,35},
[270]	255	{0,0,0,0} /* end marker */
	256	};
[4370]	257	#define LEAPSECONDS 16 /* only needed for approx. time */
[270]	258	#define GPSLEAPSTART 19 /* 19 leap seconds existed at 6.1.1980 */
	259
	260	static int longyear(int year, int month)
	261	{
	262	if(!(year % 4) && (!(year % 400) \|\| (year % 100)))
	263	{
	264	if(!month \|\| month == 2)
	265	return 1;
	266	}
	267	return 0;
	268	}
	269
[2346]	270	int gnumleap(int year, int month, int day)
[270]	271	{
	272	int ls = 0;
	273	const struct leapseconds *l;
	274
	275	for(l = leap; l->taicount && year >= l->year; ++l)
	276	{
[1824]	277	if(year > l->year \|\| month > l->month \|\| (month == l->month && day > l->day))
[270]	278	ls = l->taicount - GPSLEAPSTART;
	279	}
	280	return ls;
	281	}
	282
[2346]	283	/* Convert Moscow time into UTC (fixnumleap == 1) or GPS (fixnumleap == 0) */
	284	void updatetime(int week, int secOfWeek, int mSecOfWeek, int fixnumleap)
[270]	285	{
[502]	286	int y,m,d,k,l, nul;
[2346]	287	unsigned int j = week(7246060) + secOfWeek + 5246060+360*60;
[270]	288	int glo_daynumber = 0, glo_timeofday;
	289	for(y = 1980; j >= (unsigned int)(k = (l = (365+longyear(y,0)))2460*60)
	290	+ gnumleap(y+1,1,1); ++y)
	291	{
	292	j -= k; glo_daynumber += l;
	293	}
	294	for(m = 1; j >= (unsigned int)(k = (l = months[m]+longyear(y, m))2460*60)
	295	+ gnumleap(y, m+1, 1); ++m)
	296	{
	297	j -= k; glo_daynumber += l;
	298	}
	299	for(d = 1; j >= 24UL60UL60UL + gnumleap(y, m, d+1); ++d)
	300	j -= 246060;
	301	glo_daynumber -= 16*365+4-d;
[502]	302	nul = gnumleap(y, m, d);
	303	glo_timeofday = j-nul;
[270]	304
[3270]	305	// original version
	306	// if(mSecOfWeek < 5601000 && glo_timeofday > 236060)
	307	// secOfWeek += 2460*60;
	308	// else if(glo_timeofday < 560 && mSecOfWeek > 2360601000)
	309	// secOfWeek -= 2460*60;
	310
	311	// new version
	312	if(mSecOfWeek < 460601000 && glo_timeofday > 2060*60)
[2346]	313	secOfWeek += 2460*60;
[3270]	314	else if(glo_timeofday < 46060 && mSecOfWeek > 206060*1000)
[2346]	315	secOfWeek -= 2460*60;
[3270]	316
[2346]	317	*secOfWeek += mSecOfWeek/1000-glo_timeofday;
[502]	318	if(fixnumleap)
[2346]	319	*secOfWeek -= nul;
	320	if(secOfWeek < 0) {secOfWeek += 2460607; --week; }
	321	if(secOfWeek >= 2460607) {secOfWeek -= 2460607; ++*week; }
[270]	322	}
	323
[268]	324	int RTCM3Parser(struct RTCM3ParserData *handle)
[27]	325	{
	326	int ret=0;
	327
[1237]	328	#ifdef NO_RTCM3_MAIN
	329	if(GetMessage(handle)) /* don't repeat */
	330	#else
[27]	331	while(!ret && GetMessage(handle))
[1237]	332	#endif /* NO_RTCM3_MAIN */
[27]	333	{
	334	/* using 64 bit integer types, as it is much easier than handling
	335	the long datatypes in 32 bit */
	336	uint64_t numbits = 0, bitfield = 0;
	337	int size = handle->size, type;
[270]	338	int syncf, old = 0;
[27]	339	unsigned char *data = handle->Message+3;
	340
	341	GETBITS(type,12)
[1097]	342	#ifdef NO_RTCM3_MAIN
[1237]	343	handle->blocktype = type;
[1092]	344	#endif /* NO_RTCM3_MAIN */
[27]	345	switch(type)
	346	{
[1237]	347	#ifdef NO_RTCM3_MAIN
	348	default:
	349	ret = type;
	350	break;
	351	case 1005: case 1006:
	352	{
	353	SKIPBITS(22)
	354	GETBITSSIGN(handle->antX, 38)
	355	SKIPBITS(2)
	356	GETBITSSIGN(handle->antY, 38)
	357	SKIPBITS(2)
	358	GETBITSSIGN(handle->antZ, 38)
	359	if(type == 1006)
	360	GETBITS(handle->antH, 16)
	361	ret = type;
	362	}
	363	break;
	364	case 1007: case 1008: case 1033:
	365	{
	366	char *antenna;
	367	int antnum;
	368
	369	SKIPBITS(12)
	370	GETSTRING(antnum,antenna)
	371	memcpy(handle->antenna, antenna, antnum);
	372	handle->antenna[antnum] = 0;
	373	ret = type;
	374	}
	375	break;
[2501]	376	case 1013:
	377	{
	378	SKIPBITS(12);
	379	GETBITS(handle->modjulday, 16);
	380	GETBITS(handle->secofday, 17);
	381	SKIPBITS(5);
	382	GETBITS(handle->leapsec, 8);
	383	ret = 1013;
	384	}
	385	break;
[1237]	386	#endif /* NO_RTCM3_MAIN */
[502]	387	case 1019:
	388	{
	389	struct gpsephemeris *ge;
[2764]	390	int sv, i;
[502]	391
	392	ge = &handle->ephemerisGPS;
	393	memset(ge, 0, sizeof(*ge));
	394
	395	GETBITS(sv, 6)
	396	ge->satellite = (sv < 40 ? sv : sv+80);
	397	GETBITS(ge->GPSweek, 10)
	398	ge->GPSweek += 1024;
	399	GETBITS(ge->URAindex, 4)
	400	GETBITS(sv, 2)
	401	if(sv & 1)
	402	ge->flags \|= GPSEPHF_L2PCODE;
	403	if(sv & 2)
	404	ge->flags \|= GPSEPHF_L2CACODE;
[1092]	405	GETFLOATSIGN(ge->IDOT, 14, R2R_PI/(double)(1<<30)/(double)(1<<13))
[502]	406	GETBITS(ge->IODE, 8)
	407	GETBITS(ge->TOC, 16)
	408	ge->TOC <<= 4;
	409	GETFLOATSIGN(ge->clock_driftrate, 8, 1.0/(double)(1<<30)/(double)(1<<25))
	410	GETFLOATSIGN(ge->clock_drift, 16, 1.0/(double)(1<<30)/(double)(1<<13))
	411	GETFLOATSIGN(ge->clock_bias, 22, 1.0/(double)(1<<30)/(double)(1<<1))
	412	GETBITS(ge->IODC, 10)
	413	GETFLOATSIGN(ge->Crs, 16, 1.0/(double)(1<<5))
[1092]	414	GETFLOATSIGN(ge->Delta_n, 16, R2R_PI/(double)(1<<30)/(double)(1<<13))
	415	GETFLOATSIGN(ge->M0, 32, R2R_PI/(double)(1<<30)/(double)(1<<1))
[502]	416	GETFLOATSIGN(ge->Cuc, 16, 1.0/(double)(1<<29))
	417	GETFLOAT(ge->e, 32, 1.0/(double)(1<<30)/(double)(1<<3))
	418	GETFLOATSIGN(ge->Cus, 16, 1.0/(double)(1<<29))
	419	GETFLOAT(ge->sqrt_A, 32, 1.0/(double)(1<<19))
	420	GETBITS(ge->TOE, 16)
	421	ge->TOE <<= 4;
	422
	423	GETFLOATSIGN(ge->Cic, 16, 1.0/(double)(1<<29))
[1092]	424	GETFLOATSIGN(ge->OMEGA0, 32, R2R_PI/(double)(1<<30)/(double)(1<<1))
[502]	425	GETFLOATSIGN(ge->Cis, 16, 1.0/(double)(1<<29))
[1092]	426	GETFLOATSIGN(ge->i0, 32, R2R_PI/(double)(1<<30)/(double)(1<<1))
[502]	427	GETFLOATSIGN(ge->Crc, 16, 1.0/(double)(1<<5))
[1092]	428	GETFLOATSIGN(ge->omega, 32, R2R_PI/(double)(1<<30)/(double)(1<<1))
	429	GETFLOATSIGN(ge->OMEGADOT, 24, R2R_PI/(double)(1<<30)/(double)(1<<13))
[502]	430	GETFLOATSIGN(ge->TGD, 8, 1.0/(double)(1<<30)/(double)(1<<1))
	431	GETBITS(ge->SVhealth, 6)
	432	GETBITS(sv, 1)
	433	if(sv)
	434	ge->flags \|= GPSEPHF_L2PCODEDATA;
[5332]	435	GETBITS(sv, 1)
	436	if(sv)
	437	ge->flags \|= GPSEPHF_6HOURSFIT;
[502]	438
[2764]	439	i = ((int)ge->GPSweek - (int)handle->GPSWeek)7246060
	440	+ ((int)ge->TOE - (int)handle->GPSTOW) - 26060;
	441	if(i > 56060 && i < 86060)
	442	{
	443	handle->GPSTOW = ge->TOE;
	444	handle->GPSWeek = ge->GPSweek;
	445	}
[2994]	446	ge->TOW = 0.9999E9;
[502]	447	ret = 1019;
	448	}
	449	break;
[6329]	450	case 1043:
	451	if(handle->GPSWeek)
	452	{
	453	struct sbasephemeris *gs;
	454	int sv, i, time, tod, day;
	455	gs = &handle->ephemerisSBAS;
	456	memset(gs, 0, sizeof(*gs));
	457
	458	GETBITS(sv, 6)
	459	gs->satellite = PRN_SBAS_START+sv;
	460	GETBITS(gs->IODN, 8)
	461	GETBITS(time, 13)
	462	time <<= 4;
	463	gs->GPSweek_TOE = handle->GPSWeek;
	464	GETBITS(gs->URA, 4)
	465	GETFLOATSIGN(gs->x_pos, 30, 0.08)
	466	GETFLOATSIGN(gs->y_pos, 30, 0.08)
	467	GETFLOATSIGN(gs->z_pos, 25, 0.4)
	468	GETFLOATSIGN(gs->x_velocity, 17, 0.000625)
	469	GETFLOATSIGN(gs->y_velocity, 17, 0.000625)
	470	GETFLOATSIGN(gs->z_velocity, 18, 0.004)
	471	GETFLOATSIGN(gs->x_acceleration, 10, 0.0000125)
	472	GETFLOATSIGN(gs->y_acceleration, 10, 0.0000125)
	473	GETFLOATSIGN(gs->z_acceleration, 10, 0.0000625)
	474	GETFLOATSIGN(gs->agf0, 12, 1.0/(1<<30)/(1<<1))
	475	GETFLOATSIGN(gs->agf1, 8, 1.0/(1<<30)/(1<<10))
	476
	477	/* calculate time */
	478	tod = handle->GPSTOW%(246060);
	479	day = handle->GPSTOW/(246060);
	480	if(time > 196060 && tod < 56060)
	481	--day;
	482	else if(time < 56060 && tod > 196060)
	483	++day;
	484	time += day2460*60;
	485	if(time > 72460*60)
	486	++gs->GPSweek_TOE;
	487	else if(time < 0)
	488	--gs->GPSweek_TOE;
	489	gs->TOE = time;
	490
	491	i = (gs->GPSweek_TOE - handle->GPSWeek)7246060
	492	+ (gs->TOE - handle->GPSTOW) - 26060;
	493	if(i > 56060 && i < 86060)
	494	{
	495	handle->GPSTOW = gs->TOE;
	496	handle->GPSWeek = gs->GPSweek_TOE;
	497	}
	498	gs->TOW = 0.9999E9;
	499	ret = 1043;
	500	}
	501	break;
[5595]	502	case 1044:
	503	{
	504	struct gpsephemeris *ge;
	505	int sv, i;
	506
	507	ge = &handle->ephemerisGPS;
	508	memset(ge, 0, sizeof(*ge));
	509
	510	GETBITS(sv, 4)
	511	ge->satellite = PRN_QZSS_START+sv-1;
	512	GETBITS(ge->TOC, 16)
	513	ge->TOC <<= 4;
	514	GETFLOATSIGN(ge->clock_driftrate, 8, 1.0/(double)(1<<30)/(double)(1<<25))
	515	GETFLOATSIGN(ge->clock_drift, 16, 1.0/(double)(1<<30)/(double)(1<<13))
	516	GETFLOATSIGN(ge->clock_bias, 22, 1.0/(double)(1<<30)/(double)(1<<1))
	517	GETBITS(ge->IODE, 8)
	518	GETFLOATSIGN(ge->Crs, 16, 1.0/(double)(1<<5))
	519	GETFLOATSIGN(ge->Delta_n, 16, R2R_PI/(double)(1<<30)/(double)(1<<13))
	520	GETFLOATSIGN(ge->M0, 32, R2R_PI/(double)(1<<30)/(double)(1<<1))
	521	GETFLOATSIGN(ge->Cuc, 16, 1.0/(double)(1<<29))
	522	GETFLOAT(ge->e, 32, 1.0/(double)(1<<30)/(double)(1<<3))
	523	GETFLOATSIGN(ge->Cus, 16, 1.0/(double)(1<<29))
	524	GETFLOAT(ge->sqrt_A, 32, 1.0/(double)(1<<19))
	525	GETBITS(ge->TOE, 16)
	526	ge->TOE <<= 4;
	527	GETFLOATSIGN(ge->Cic, 16, 1.0/(double)(1<<29))
	528	GETFLOATSIGN(ge->OMEGA0, 32, R2R_PI/(double)(1<<30)/(double)(1<<1))
	529	GETFLOATSIGN(ge->Cis, 16, 1.0/(double)(1<<29))
	530	GETFLOATSIGN(ge->i0, 32, R2R_PI/(double)(1<<30)/(double)(1<<1))
	531	GETFLOATSIGN(ge->Crc, 16, 1.0/(double)(1<<5))
	532	GETFLOATSIGN(ge->omega, 32, R2R_PI/(double)(1<<30)/(double)(1<<1))
	533	GETFLOATSIGN(ge->OMEGADOT, 24, R2R_PI/(double)(1<<30)/(double)(1<<13))
	534	GETFLOATSIGN(ge->IDOT, 14, R2R_PI/(double)(1<<30)/(double)(1<<13))
	535	GETBITS(sv, 2)
	536	if(sv & 1)
	537	ge->flags \|= GPSEPHF_L2PCODE;
	538	if(sv & 2)
	539	ge->flags \|= GPSEPHF_L2CACODE;
	540	GETBITS(ge->GPSweek, 10)
	541	ge->GPSweek += 1024;
	542	GETBITS(ge->URAindex, 4)
	543	GETBITS(ge->SVhealth, 6)
	544	GETFLOATSIGN(ge->TGD, 8, 1.0/(double)(1<<30)/(double)(1<<1))
	545	GETBITS(ge->IODC, 10)
	546	GETBITS(sv, 1)
	547	if(sv)
	548	ge->flags \|= GPSEPHF_6HOURSFIT;
	549
	550	i = ((int)ge->GPSweek - (int)handle->GPSWeek)7246060
	551	+ ((int)ge->TOE - (int)handle->GPSTOW) - 26060;
	552	if(i > 56060 && i < 86060)
	553	{
	554	handle->GPSTOW = ge->TOE;
	555	handle->GPSWeek = ge->GPSweek;
	556	}
	557	ge->TOW = 0.9999E9;
	558	ret = 1044;
	559	}
	560	break;
[5318]	561	case 1045: case 1046:
[2756]	562	{
	563	struct galileoephemeris *ge;
	564	int sv;
	565
	566	ge = &handle->ephemerisGALILEO;
	567	memset(ge, 0, sizeof(*ge));
	568
	569	GETBITS(sv, 6)
	570	ge->satellite = sv;
	571	GETBITS(ge->Week, 12)
	572	GETBITS(ge->IODnav, 10)
	573	GETBITS(ge->SISA, 8)
	574	GETFLOATSIGN(ge->IDOT, 14, R2R_PI/(double)(1<<30)/(double)(1<<13))
	575	GETBITSFACTOR(ge->TOC, 14, 60)
	576	GETFLOATSIGN(ge->clock_driftrate, 6, 1.0/(double)(1<<30)/(double)(1<<29))
	577	GETFLOATSIGN(ge->clock_drift, 21, 1.0/(double)(1<<30)/(double)(1<<16))
	578	GETFLOATSIGN(ge->clock_bias, 31, 1.0/(double)(1<<30)/(double)(1<<4))
	579	GETFLOATSIGN(ge->Crs, 16, 1.0/(double)(1<<5))
	580	GETFLOATSIGN(ge->Delta_n, 16, R2R_PI/(double)(1<<30)/(double)(1<<13))
	581	GETFLOATSIGN(ge->M0, 32, R2R_PI/(double)(1<<30)/(double)(1<<1))
	582	GETFLOATSIGN(ge->Cuc, 16, 1.0/(double)(1<<29))
	583	GETFLOAT(ge->e, 32, 1.0/(double)(1<<30)/(double)(1<<3))
	584	GETFLOATSIGN(ge->Cus, 16, 1.0/(double)(1<<29))
	585	GETFLOAT(ge->sqrt_A, 32, 1.0/(double)(1<<19))
	586	GETBITSFACTOR(ge->TOE, 14, 60)
	587	GETFLOATSIGN(ge->Cic, 16, 1.0/(double)(1<<29))
	588	GETFLOATSIGN(ge->OMEGA0, 32, R2R_PI/(double)(1<<30)/(double)(1<<1))
	589	GETFLOATSIGN(ge->Cis, 16, 1.0/(double)(1<<29))
	590	GETFLOATSIGN(ge->i0, 32, R2R_PI/(double)(1<<30)/(double)(1<<1))
	591	GETFLOATSIGN(ge->Crc, 16, 1.0/(double)(1<<5))
	592	GETFLOATSIGN(ge->omega, 32, R2R_PI/(double)(1<<30)/(double)(1<<1))
	593	GETFLOATSIGN(ge->OMEGADOT, 24, R2R_PI/(double)(1<<30)/(double)(1<<13))
	594	GETFLOATSIGN(ge->BGD_1_5A, 10, 1.0/(double)(1<<30)/(double)(1<<2))
[5318]	595	if(type == 1046)
	596	{
	597	GETFLOATSIGN(ge->BGD_1_5B, 10, 1.0/(double)(1<<30)/(double)(1<<2))
	598	GETBITS(ge->E5aHS, 2)
	599	GETBITS(sv, 1)
[5533]	600	ge->flags \|= GALEPHF_INAV;
[5318]	601	if(sv)
	602	ge->flags \|= GALEPHF_E5ADINVALID;
	603	GETFLOATSIGN(ge->BGD_1_5B, 10, 1.0/(double)(1<<30)/(double)(1<<2))
	604	}
	605	else
	606	{
[5533]	607	ge->flags \|= GALEPHF_FNAV;
[5318]	608	GETBITS(ge->E5bHS, 2)
	609	GETBITS(sv, 1)
	610	if(sv)
	611	ge->flags \|= GALEPHF_E5BDINVALID;
	612	}
	613	ret = type;
[2756]	614	}
	615	break;
[502]	616	case 1020:
	617	{
	618	struct glonassephemeris *ge;
	619	int i;
	620
	621	ge = &handle->ephemerisGLONASS;
	622	memset(ge, 0, sizeof(*ge));
	623
	624	ge->flags \|= GLOEPHF_PAVAILABLE;
	625	GETBITS(ge->almanac_number, 6)
	626	GETBITS(i, 5)
	627	ge->frequency_number = i-7;
[2659]	628	if(ge->almanac_number >= 1 && ge->almanac_number <= PRN_GLONASS_NUM)
	629	handle->GLOFreq[ge->almanac_number-1] = 100+ge->frequency_number;
[502]	630	GETBITS(i, 1)
	631	if(i)
	632	ge->flags \|= GLOEPHF_ALMANACHEALTHY;
	633	GETBITS(i, 1)
	634	if(i)
	635	ge->flags \|= GLOEPHF_ALMANACHEALTHOK;
	636	GETBITS(i, 2)
	637	if(i & 1)
	638	ge->flags \|= GLOEPHF_P10TRUE;
	639	if(i & 2)
	640	ge->flags \|= GLOEPHF_P11TRUE;
	641	GETBITS(i, 5)
	642	ge->tk = i6060;
	643	GETBITS(i, 6)
	644	ge->tk += i*60;
	645	GETBITS(i, 1)
	646	ge->tk += i*30;
	647	GETBITS(i, 1)
	648	if(i)
	649	ge->flags \|= GLOEPHF_UNHEALTHY;
	650	GETBITS(i, 1)
	651	if(i)
	652	ge->flags \|= GLOEPHF_P2TRUE;
	653	GETBITS(i, 7)
	654	ge->tb = i1560;
	655	GETFLOATSIGNM(ge->x_velocity, 24, 1.0/(double)(1<<20))
	656	GETFLOATSIGNM(ge->x_pos, 27, 1.0/(double)(1<<11))
	657	GETFLOATSIGNM(ge->x_acceleration, 5, 1.0/(double)(1<<30))
	658	GETFLOATSIGNM(ge->y_velocity, 24, 1.0/(double)(1<<20))
	659	GETFLOATSIGNM(ge->y_pos, 27, 1.0/(double)(1<<11))
	660	GETFLOATSIGNM(ge->y_acceleration, 5, 1.0/(double)(1<<30))
	661	GETFLOATSIGNM(ge->z_velocity, 24, 1.0/(double)(1<<20))
	662	GETFLOATSIGNM(ge->z_pos, 27, 1.0/(double)(1<<11))
	663	GETFLOATSIGNM(ge->z_acceleration, 5, 1.0/(double)(1<<30))
	664	GETBITS(i, 1)
	665	if(i)
	666	ge->flags \|= GLOEPHF_P3TRUE;
	667	GETFLOATSIGNM(ge->gamma, 11, 1.0/(double)(1<<30)/(double)(1<<10))
	668	SKIPBITS(3) /* GLONASS-M P, GLONASS-M ln (third string) */
	669	GETFLOATSIGNM(ge->tau, 22, 1.0/(double)(1<<30)) /* GLONASS tau n(tb) */
	670	SKIPBITS(5) /* GLONASS-M delta tau n(tb) */
	671	GETBITS(ge->E, 5)
	672	/* GETBITS(b, 1) / * GLONASS-M P4 */
	673	/* GETBITS(b, 4) / * GLONASS-M Ft */
	674	/* GETBITS(b, 11) / * GLONASS-M Nt */
	675	/* GETBITS(b, 2) / * GLONASS-M M */
	676	/* GETBITS(b, 1) / * GLONASS-M The Availability of Additional Data */
	677	/* GETBITS(b, 11) / * GLONASS-M Na */
	678	/* GETFLOATSIGNM(b, 32, 1.0/(double)(1<<30)/(double)(1<<1)) / * GLONASS tau c */
	679	/* GETBITS(b, 5) / * GLONASS-M N4 */
	680	/* GETFLOATSIGNM(b, 22, 1.0/(double)(1<<30)/(double)(1<<1)) / * GLONASS-M tau GPS */
	681	/* GETBITS(b, 1) / * GLONASS-M ln (fifth string) */
	682	ge->GPSWeek = handle->GPSWeek;
	683	ge->GPSTOW = handle->GPSTOW;
	684	ret = 1020;
	685	}
	686	break;
[33]	687	case 1001: case 1002: case 1003: case 1004:
[27]	688	if(handle->GPSWeek)
	689	{
	690	int lastlockl1[64];
	691	int lastlockl2[64];
	692	struct gnssdata *gnss;
[1270]	693	int i, numsats, wasamb=0;
[27]	694
	695	for(i = 0; i < 64; ++i)
	696	lastlockl1[i] = lastlockl2[i] = 0;
	697
[270]	698	gnss = &handle->DataNew;
[27]	699
	700	SKIPBITS(12) /* id */
	701	GETBITS(i,30)
	702	if(i/1000 < (int)handle->GPSTOW - 86400)
	703	++handle->GPSWeek;
	704	handle->GPSTOW = i/1000;
[270]	705	if(gnss->week && (gnss->timeofweek != i \|\| gnss->week
	706	!= handle->GPSWeek))
	707	{
	708	handle->Data = *gnss;
	709	memset(gnss, 0, sizeof(*gnss));
	710	old = 1;
	711	}
[27]	712	gnss->timeofweek = i;
	713	gnss->week = handle->GPSWeek;
	714
[270]	715	GETBITS(syncf,1) /* sync */
[1270]	716	GETBITS(numsats,5)
[27]	717	SKIPBITS(4) /* smind, smint */
	718
[2352]	719	while(numsats-- && gnss->numsats < GNSS_MAXSATS)
[27]	720	{
[33]	721	int sv, code, l1range, c,l,s,ce,le,se,amb=0;
[1270]	722	int fullsat, num;
[27]	723
[1270]	724	GETBITS(sv, 6)
	725	fullsat = sv < 40 ? sv : sv+80;
	726	for(num = 0; num < gnss->numsats
	727	&& fullsat != gnss->satellites[num]; ++num)
	728	;
	729
	730	if(num == gnss->numsats)
	731	gnss->satellites[gnss->numsats++] = fullsat;
	732
[27]	733	/* L1 */
	734	GETBITS(code, 1);
	735	if(code)
	736	{
	737	c = GNSSDF_P1DATA; ce = GNSSENTRY_P1DATA;
	738	l = GNSSDF_L1PDATA; le = GNSSENTRY_L1PDATA;
	739	s = GNSSDF_S1PDATA; se = GNSSENTRY_S1PDATA;
[4796]	740	gnss->codetype[num][se] =
[5156]	741	gnss->codetype[num][ce] = gnss->codetype[num][le] = "1W";
[27]	742	}
	743	else
	744	{
	745	c = GNSSDF_C1DATA; ce = GNSSENTRY_C1DATA;
	746	l = GNSSDF_L1CDATA; le = GNSSENTRY_L1CDATA;
	747	s = GNSSDF_S1CDATA; se = GNSSENTRY_S1CDATA;
[4796]	748	gnss->codetype[num][se] =
[4430]	749	gnss->codetype[num][ce] = gnss->codetype[num][le] = "1C";
[27]	750	}
[4959]	751	if(!handle->info[RTCM3_MSM_GPS].type[ce])
	752	{
	753	handle->info[RTCM3_MSM_GPS].type[ce] =
	754	handle->info[RTCM3_MSM_GPS].type[le] =
	755	handle->info[RTCM3_MSM_GPS].type[se] = gnss->codetype[num][ce][1];
	756	}
[27]	757	GETBITS(l1range, 24);
	758	GETBITSSIGN(i, 20);
[325]	759	if((i&((1<<20)-1)) != 0x80000)
[27]	760	{
[744]	761	gnss->dataflags[num] \|= (c\|l);
	762	gnss->measdata[num][ce] = l1range*0.02;
[27]	763	gnss->measdata[num][le] = l1range0.02+i0.0005;
	764	}
	765	GETBITS(i, 7);
	766	lastlockl1[sv] = i;
[2500]	767	if(handle->lastlockGPSl1[sv] > i \|\| i == 0)
[2659]	768	gnss->dataflags2[num] \|= GNSSDF2_LOCKLOSSL1;
[33]	769	if(type == 1002 \|\| type == 1004)
[27]	770	{
[33]	771	GETBITS(amb,8);
	772	if(amb && (gnss->dataflags[num] & c))
	773	{
	774	gnss->measdata[num][ce] += amb*299792.458;
	775	gnss->measdata[num][le] += amb*299792.458;
	776	++wasamb;
	777	}
	778	GETBITS(i, 8);
	779	if(i)
	780	{
	781	gnss->dataflags[num] \|= s;
	782	gnss->measdata[num][se] = i*0.25;
	783	i /= 4*4;
	784	if(i > 9) i = 9;
	785	else if(i < 1) i = 1;
	786	gnss->snrL1[num] = i;
	787	}
[27]	788	}
[81]	789	gnss->measdata[num][le] /= GPS_WAVELENGTH_L1;
[33]	790	if(type == 1003 \|\| type == 1004)
[27]	791	{
[33]	792	/* L2 */
	793	GETBITS(code,2);
	794	if(code)
	795	{
	796	c = GNSSDF_P2DATA; ce = GNSSENTRY_P2DATA;
	797	l = GNSSDF_L2PDATA; le = GNSSENTRY_L2PDATA;
	798	s = GNSSDF_S2PDATA; se = GNSSENTRY_S2PDATA;
[2422]	799	if(code >= 2)
[4430]	800	{
[4796]	801	gnss->codetype[num][se] =
[4430]	802	gnss->codetype[num][ce] = gnss->codetype[num][le] = "2W";
[2659]	803	gnss->dataflags2[num] \|= GNSSDF2_XCORRL2;
[4430]	804	}
	805	else
	806	{
[4796]	807	gnss->codetype[num][se] =
[4430]	808	gnss->codetype[num][ce] = gnss->codetype[num][le] = "2P";
	809	}
[33]	810	}
	811	else
	812	{
	813	c = GNSSDF_C2DATA; ce = GNSSENTRY_C2DATA;
	814	l = GNSSDF_L2CDATA; le = GNSSENTRY_L2CDATA;
	815	s = GNSSDF_S2CDATA; se = GNSSENTRY_S2CDATA;
[4796]	816	gnss->codetype[num][se] =
[5521]	817	gnss->codetype[num][ce] = gnss->codetype[num][le] = "2 ";
[33]	818	}
[4959]	819	if(!handle->info[RTCM3_MSM_GPS].type[ce])
	820	{
	821	handle->info[RTCM3_MSM_GPS].type[ce] =
	822	handle->info[RTCM3_MSM_GPS].type[le] =
	823	handle->info[RTCM3_MSM_GPS].type[se] = gnss->codetype[num][ce][1];
	824	}
[33]	825	GETBITSSIGN(i,14);
[325]	826	if((i&((1<<14)-1)) != 0x2000)
[33]	827	{
	828	gnss->dataflags[num] \|= c;
	829	gnss->measdata[num][ce] = l1range0.02+i0.02
	830	+amb*299792.458;
	831	}
	832	GETBITSSIGN(i,20);
[325]	833	if((i&((1<<20)-1)) != 0x80000)
[33]	834	{
	835	gnss->dataflags[num] \|= l;
	836	gnss->measdata[num][le] = l1range0.02+i0.0005
	837	+amb*299792.458;
	838	}
	839	GETBITS(i,7);
	840	lastlockl2[sv] = i;
[2500]	841	if(handle->lastlockGPSl2[sv] > i \|\| i == 0)
[2659]	842	gnss->dataflags2[num] \|= GNSSDF2_LOCKLOSSL2;
[33]	843	if(type == 1004)
	844	{
	845	GETBITS(i, 8);
	846	if(i)
	847	{
	848	gnss->dataflags[num] \|= s;
	849	gnss->measdata[num][se] = i*0.25;
	850	i /= 4*4;
	851	if(i > 9) i = 9;
	852	else if(i < 1) i = 1;
	853	gnss->snrL2[num] = i;
	854	}
	855	}
[81]	856	gnss->measdata[num][le] /= GPS_WAVELENGTH_L2;
[27]	857	}
	858	}
	859	for(i = 0; i < 64; ++i)
	860	{
[2490]	861	handle->lastlockGPSl1[i] = lastlockl1[i];
	862	handle->lastlockGPSl2[i] = lastlockl2[i];
[27]	863	}
[270]	864	if(!syncf && !old)
	865	{
	866	handle->Data = *gnss;
	867	memset(gnss, 0, sizeof(*gnss));
	868	}
	869	if(!syncf \|\| old)
	870	{
	871	if(wasamb) /* not RINEX compatible without */
	872	ret = 1;
	873	else
	874	ret = 2;
	875	}
[1265]	876	#ifdef NO_RTCM3_MAIN
	877	else
	878	ret = type;
	879	#endif /* NO_RTCM3_MAIN */
[27]	880	}
	881	break;
[270]	882	case 1009: case 1010: case 1011: case 1012:
	883	{
	884	int lastlockl1[64];
	885	int lastlockl2[64];
	886	struct gnssdata *gnss;
[1270]	887	int i, numsats;
[270]	888	int wasamb=0;
	889
	890	for(i = 0; i < 64; ++i)
	891	lastlockl1[i] = lastlockl2[i] = 0;
	892
	893	gnss = &handle->DataNew;
	894
	895	SKIPBITS(12) /* id */;
	896	GETBITS(i,27) /* tk */
	897
[2346]	898	updatetime(&handle->GPSWeek, &handle->GPSTOW, i, 0); /* Moscow -> GPS */
[270]	899	i = handle->GPSTOW*1000;
	900	if(gnss->week && (gnss->timeofweek != i \|\| gnss->week
	901	!= handle->GPSWeek))
	902	{
	903	handle->Data = *gnss;
	904	memset(gnss, 0, sizeof(*gnss));
	905	old = 1;
	906	}
	907
	908	gnss->timeofweek = i;
	909	gnss->week = handle->GPSWeek;
	910
	911	GETBITS(syncf,1) /* sync */
[1270]	912	GETBITS(numsats,5)
[270]	913
	914	SKIPBITS(4) /* smind, smint */
	915
[2352]	916	while(numsats-- && gnss->numsats < GNSS_MAXSATS)
[270]	917	{
	918	int sv, code, l1range, c,l,s,ce,le,se,amb=0;
[325]	919	int freq;
[1270]	920	int fullsat, num;
[270]	921
	922	GETBITS(sv, 6)
[1270]	923	fullsat = sv-1 + PRN_GLONASS_START;
	924	for(num = 0; num < gnss->numsats
	925	&& fullsat != gnss->satellites[num]; ++num)
	926	;
	927
	928	if(num == gnss->numsats)
	929	gnss->satellites[gnss->numsats++] = fullsat;
	930
[325]	931	/* L1 */
	932	GETBITS(code, 1)
	933	GETBITS(freq, 5)
[2346]	934
[2660]	935	if(sv >= 1 && sv <= PRN_GLONASS_NUM)
	936	handle->GLOFreq[sv-1] = 100+freq-7;
[2346]	937
[325]	938	if(code)
[270]	939	{
[325]	940	c = GNSSDF_P1DATA; ce = GNSSENTRY_P1DATA;
	941	l = GNSSDF_L1PDATA; le = GNSSENTRY_L1PDATA;
	942	s = GNSSDF_S1PDATA; se = GNSSENTRY_S1PDATA;
[4796]	943	gnss->codetype[num][se] =
[4430]	944	gnss->codetype[num][ce] = gnss->codetype[num][le] = "1P";
[270]	945	}
	946	else
	947	{
[325]	948	c = GNSSDF_C1DATA; ce = GNSSENTRY_C1DATA;
	949	l = GNSSDF_L1CDATA; le = GNSSENTRY_L1CDATA;
	950	s = GNSSDF_S1CDATA; se = GNSSENTRY_S1CDATA;
[4796]	951	gnss->codetype[num][se] =
[4430]	952	gnss->codetype[num][ce] = gnss->codetype[num][le] = "1C";
[325]	953	}
[4959]	954	if(!handle->info[RTCM3_MSM_GLONASS].type[ce])
	955	{
	956	handle->info[RTCM3_MSM_GLONASS].type[ce] =
	957	handle->info[RTCM3_MSM_GLONASS].type[le] =
	958	handle->info[RTCM3_MSM_GLONASS].type[se] = gnss->codetype[num][ce][1];
	959	}
[325]	960	GETBITS(l1range, 25)
	961	GETBITSSIGN(i, 20)
	962	if((i&((1<<20)-1)) != 0x80000)
	963	{
[744]	964	/* Handle this like GPS. Actually for GLONASS L1 range is always
	965	valid. To be on the save side, we handle it as invalid like we
	966	do for GPS and also remove range in case of 0x80000. */
	967	gnss->dataflags[num] \|= (c\|l);
	968	gnss->measdata[num][ce] = l1range*0.02;
[325]	969	gnss->measdata[num][le] = l1range0.02+i0.0005;
	970	}
	971	GETBITS(i, 7)
	972	lastlockl1[sv] = i;
[2500]	973	if(handle->lastlockGLOl1[sv] > i \|\| i == 0)
[2659]	974	gnss->dataflags2[num] \|= GNSSDF2_LOCKLOSSL1;
[325]	975	if(type == 1010 \|\| type == 1012)
	976	{
	977	GETBITS(amb,7)
	978	if(amb && (gnss->dataflags[num] & c))
	979	{
	980	gnss->measdata[num][ce] += amb*599584.916;
	981	gnss->measdata[num][le] += amb*599584.916;
	982	++wasamb;
	983	}
	984	GETBITS(i, 8)
	985	if(i)
	986	{
	987	gnss->dataflags[num] \|= s;
	988	gnss->measdata[num][se] = i*0.25;
	989	i /= 4*4;
	990	if(i > 9) i = 9;
	991	else if(i < 1) i = 1;
	992	gnss->snrL1[num] = i;
	993	}
	994	}
	995	gnss->measdata[num][le] /= GLO_WAVELENGTH_L1(freq-7);
	996	if(type == 1011 \|\| type == 1012)
	997	{
	998	/* L2 */
	999	GETBITS(code,2)
[270]	1000	if(code)
	1001	{
[325]	1002	c = GNSSDF_P2DATA; ce = GNSSENTRY_P2DATA;
	1003	l = GNSSDF_L2PDATA; le = GNSSENTRY_L2PDATA;
	1004	s = GNSSDF_S2PDATA; se = GNSSENTRY_S2PDATA;
[4796]	1005	gnss->codetype[num][se] =
[4430]	1006	gnss->codetype[num][ce] = gnss->codetype[num][le] = "2P";
[270]	1007	}
	1008	else
	1009	{
[325]	1010	c = GNSSDF_C2DATA; ce = GNSSENTRY_C2DATA;
	1011	l = GNSSDF_L2CDATA; le = GNSSENTRY_L2CDATA;
	1012	s = GNSSDF_S2CDATA; se = GNSSENTRY_S2CDATA;
[4796]	1013	gnss->codetype[num][se] =
[4430]	1014	gnss->codetype[num][ce] = gnss->codetype[num][le] = "2C";
[270]	1015	}
[4959]	1016	if(!handle->info[RTCM3_MSM_GLONASS].type[ce])
	1017	{
	1018	handle->info[RTCM3_MSM_GLONASS].type[ce] =
	1019	handle->info[RTCM3_MSM_GLONASS].type[le] =
	1020	handle->info[RTCM3_MSM_GLONASS].type[se] = gnss->codetype[num][ce][1];
	1021	}
[325]	1022	GETBITSSIGN(i,14)
	1023	if((i&((1<<14)-1)) != 0x2000)
[270]	1024	{
	1025	gnss->dataflags[num] \|= c;
[325]	1026	gnss->measdata[num][ce] = l1range0.02+i0.02
	1027	+amb*599584.916;
[270]	1028	}
[325]	1029	GETBITSSIGN(i,20)
	1030	if((i&((1<<20)-1)) != 0x80000)
[270]	1031	{
	1032	gnss->dataflags[num] \|= l;
[325]	1033	gnss->measdata[num][le] = l1range0.02+i0.0005
[949]	1034	+amb*599584.916;
[270]	1035	}
[325]	1036	GETBITS(i,7)
	1037	lastlockl2[sv] = i;
[2500]	1038	if(handle->lastlockGLOl2[sv] > i \|\| i == 0)
[2659]	1039	gnss->dataflags2[num] \|= GNSSDF2_LOCKLOSSL2;
[325]	1040	if(type == 1012)
[270]	1041	{
	1042	GETBITS(i, 8)
	1043	if(i)
	1044	{
	1045	gnss->dataflags[num] \|= s;
	1046	gnss->measdata[num][se] = i*0.25;
	1047	i /= 4*4;
	1048	if(i > 9) i = 9;
	1049	else if(i < 1) i = 1;
[325]	1050	gnss->snrL2[num] = i;
[270]	1051	}
	1052	}
[325]	1053	gnss->measdata[num][le] /= GLO_WAVELENGTH_L2(freq-7);
[270]	1054	}
[1270]	1055	if(!sv \|\| sv > 24) /* illegal, remove it again */
	1056	--gnss->numsats;
[270]	1057	}
	1058	for(i = 0; i < 64; ++i)
	1059	{
[2490]	1060	handle->lastlockGLOl1[i] = lastlockl1[i];
	1061	handle->lastlockGLOl2[i] = lastlockl2[i];
[270]	1062	}
	1063	if(!syncf && !old)
	1064	{
	1065	handle->Data = *gnss;
	1066	memset(gnss, 0, sizeof(*gnss));
	1067	}
	1068	if(!syncf \|\| old)
	1069	{
	1070	if(wasamb) /* not RINEX compatible without */
	1071	ret = 1;
	1072	else
	1073	ret = 2;
	1074	}
[1265]	1075	#ifdef NO_RTCM3_MAIN
	1076	else
	1077	ret = type;
	1078	#endif /* NO_RTCM3_MAIN */
[270]	1079	}
	1080	break;
[4367]	1081	case 1071: case 1081: case 1091: case 1101: case 1111: case 1121:
	1082	case 1072: case 1082: case 1092: case 1102: case 1112: case 1122:
	1083	case 1073: case 1083: case 1093: case 1103: case 1113: case 1123:
	1084	case 1074: case 1084: case 1094: case 1104: case 1114: case 1124:
	1085	case 1075: case 1085: case 1095: case 1105: case 1115: case 1125:
	1086	case 1076: case 1086: case 1096: case 1106: case 1116: case 1126:
	1087	case 1077: case 1087: case 1097: case 1107: case 1117: case 1127:
[2659]	1088	if(handle->GPSWeek)
	1089	{
	1090	struct CodeData {
	1091	int typeR;
	1092	int typeP;
	1093	int typeD;
	1094	int typeS;
	1095	int lock;
	1096	double wl;
	1097	const char code; / currently unused */
	1098	};
	1099	struct CodeData gps[RTCM3_MSM_NUMSIG] =
	1100	{
	1101	{0,0,0,0,0,0,0},
	1102	{GNSSENTRY_C1DATA,GNSSENTRY_L1CDATA,GNSSENTRY_D1CDATA,
	1103	GNSSENTRY_S1CDATA,GNSSDF2_LOCKLOSSL1,GPS_WAVELENGTH_L1,"1C"},
	1104	{GNSSENTRY_P1DATA,GNSSENTRY_L1PDATA,GNSSENTRY_D1PDATA,
	1105	GNSSENTRY_S1PDATA,GNSSDF2_LOCKLOSSL1,GPS_WAVELENGTH_L1,"1P"},
	1106	{GNSSENTRY_P1DATA,GNSSENTRY_L1PDATA,GNSSENTRY_D1PDATA,
	1107	GNSSENTRY_S1PDATA,GNSSDF2_LOCKLOSSL1,GPS_WAVELENGTH_L1,"1W"},
[3581]	1108	{0,0,0,0,0,0,0}/*{GNSSENTRY_P1DATA,GNSSENTRY_L1PDATA,GNSSENTRY_D1PDATA,
	1109	GNSSENTRY_S1PDATA,GNSSDF2_LOCKLOSSL1,GPS_WAVELENGTH_L1,"1Y"}*/,
[2659]	1110	{0,0,0,0,0,0,0},
	1111	{0,0,0,0,0,0,0},
	1112	{GNSSENTRY_C2DATA,GNSSENTRY_L2CDATA,GNSSENTRY_D2CDATA,
	1113	GNSSENTRY_S2CDATA,GNSSDF2_LOCKLOSSL2,GPS_WAVELENGTH_L2,"2C"},
	1114	{GNSSENTRY_P2DATA,GNSSENTRY_L2PDATA,GNSSENTRY_D2PDATA,
	1115	GNSSENTRY_S2PDATA,GNSSDF2_LOCKLOSSL2,GPS_WAVELENGTH_L2,"2P"},
	1116	{GNSSENTRY_P2DATA,GNSSENTRY_L2PDATA,GNSSENTRY_D2PDATA,
	1117	GNSSENTRY_S2PDATA,GNSSDF2_LOCKLOSSL2,GPS_WAVELENGTH_L2,"2W"},
[3581]	1118	{0,0,0,0,0,0,0}/*{GNSSENTRY_P2DATA,GNSSENTRY_L2PDATA,GNSSENTRY_D2PDATA,
	1119	GNSSENTRY_S2PDATA,GNSSDF2_LOCKLOSSL2,GPS_WAVELENGTH_L2,"2Y"}*/,
[2659]	1120	{0,0,0,0,0,0,0},
	1121	{0,0,0,0,0,0,0},
	1122	{0,0,0,0,0,0,0},
	1123	{GNSSENTRY_C2DATA,GNSSENTRY_L2CDATA,GNSSENTRY_D2CDATA,
	1124	GNSSENTRY_S2CDATA,GNSSDF2_LOCKLOSSL2,GPS_WAVELENGTH_L2,"2S"},
	1125	{GNSSENTRY_C2DATA,GNSSENTRY_L2CDATA,GNSSENTRY_D2CDATA,
	1126	GNSSENTRY_S2CDATA,GNSSDF2_LOCKLOSSL2,GPS_WAVELENGTH_L2,"2L"},
	1127	{GNSSENTRY_C2DATA,GNSSENTRY_L2CDATA,GNSSENTRY_D2CDATA,
	1128	GNSSENTRY_S2CDATA,GNSSDF2_LOCKLOSSL2,GPS_WAVELENGTH_L2,"2X"},
	1129	{0,0,0,0,0,0,0},
	1130	{0,0,0,0,0,0,0},
	1131	{0,0,0,0,0,0,0},
	1132	{0,0,0,0,0,0,0},
	1133	{GNSSENTRY_C5DATA,GNSSENTRY_L5DATA,GNSSENTRY_D5DATA,
	1134	GNSSENTRY_S5DATA,GNSSDF2_LOCKLOSSL5,GPS_WAVELENGTH_L5,"5I"},
	1135	{GNSSENTRY_C5DATA,GNSSENTRY_L5DATA,GNSSENTRY_D5DATA,
	1136	GNSSENTRY_S5DATA,GNSSDF2_LOCKLOSSL5,GPS_WAVELENGTH_L5,"5Q"},
	1137	{GNSSENTRY_C5DATA,GNSSENTRY_L5DATA,GNSSENTRY_D5DATA,
[3581]	1138	GNSSENTRY_S5DATA,GNSSDF2_LOCKLOSSL5,GPS_WAVELENGTH_L5,"5X"},
	1139	{0,0,0,0,0,0,0},
	1140	{0,0,0,0,0,0,0},
	1141	{0,0,0,0,0,0,0},
	1142	{0,0,0,0,0,0,0},
	1143	{0,0,0,0,0,0,0},
[4367]	1144	{GNSSENTRY_C1NDATA,GNSSENTRY_L1NDATA,GNSSENTRY_D1NDATA,
	1145	GNSSENTRY_S1NDATA,GNSSDF2_LOCKLOSSL1,GPS_WAVELENGTH_L1,"1S"},
	1146	{GNSSENTRY_C1NDATA,GNSSENTRY_L1NDATA,GNSSENTRY_D1NDATA,
	1147	GNSSENTRY_S1NDATA,GNSSDF2_LOCKLOSSL1,GPS_WAVELENGTH_L1,"1L"},
	1148	{GNSSENTRY_C1NDATA,GNSSENTRY_L1NDATA,GNSSENTRY_D1NDATA,
	1149	GNSSENTRY_S1NDATA,GNSSDF2_LOCKLOSSL1,GPS_WAVELENGTH_L1,"1X"}
[2659]	1150	};
	1151	/* NOTE: Uses 0.0, 1.0 for wavelength as sat index dependence is done later! */
	1152	struct CodeData glo[RTCM3_MSM_NUMSIG] =
	1153	{
	1154	{0,0,0,0,0,0,0},
	1155	{GNSSENTRY_C1DATA,GNSSENTRY_L1CDATA,GNSSENTRY_D1CDATA,
	1156	GNSSENTRY_S1CDATA,GNSSDF2_LOCKLOSSL1,0.0,"1C"},
	1157	{GNSSENTRY_P1DATA,GNSSENTRY_L1PDATA,GNSSENTRY_D1PDATA,
	1158	GNSSENTRY_S1PDATA,GNSSDF2_LOCKLOSSL1,0.0,"1P"},
	1159	{0,0,0,0,0,0,0},
	1160	{0,0,0,0,0,0,0},
	1161	{0,0,0,0,0,0,0},
	1162	{0,0,0,0,0,0,0},
	1163	{GNSSENTRY_C2DATA,GNSSENTRY_L2CDATA,GNSSENTRY_D2CDATA,
	1164	GNSSENTRY_S2CDATA,GNSSDF2_LOCKLOSSL2,1.0,"2C"},
	1165	{GNSSENTRY_P2DATA,GNSSENTRY_L2PDATA,GNSSENTRY_D2PDATA,
	1166	GNSSENTRY_S2PDATA,GNSSDF2_LOCKLOSSL2,1.0,"2P"},
	1167	{0,0,0,0,0,0,0},
	1168	{0,0,0,0,0,0,0},
	1169	{0,0,0,0,0,0,0},
	1170	{0,0,0,0,0,0,0},
	1171	{0,0,0,0,0,0,0},
	1172	{0,0,0,0,0,0,0},
	1173	{0,0,0,0,0,0,0},
	1174	{0,0,0,0,0,0,0},
	1175	{0,0,0,0,0,0,0},
	1176	{0,0,0,0,0,0,0},
	1177	{0,0,0,0,0,0,0},
	1178	{0,0,0,0,0,0,0},
	1179	{0,0,0,0,0,0,0},
	1180	{0,0,0,0,0,0,0},
[3581]	1181	{0,0,0,0,0,0,0},
	1182	{0,0,0,0,0,0,0},
	1183	{0,0,0,0,0,0,0},
	1184	{0,0,0,0,0,0,0},
	1185	{0,0,0,0,0,0,0},
	1186	{0,0,0,0,0,0,0},
	1187	{0,0,0,0,0,0,0},
	1188	{0,0,0,0,0,0,0},
[2659]	1189	{0,0,0,0,0,0,0}
	1190	};
	1191	struct CodeData gal[RTCM3_MSM_NUMSIG] =
	1192	{
	1193	{0,0,0,0,0,0,0},
	1194	{GNSSENTRY_C1DATA,GNSSENTRY_L1CDATA,GNSSENTRY_D1CDATA,
	1195	GNSSENTRY_S1CDATA,GNSSDF2_LOCKLOSSL1,GAL_WAVELENGTH_E1,"1C"},
[4958]	1196	{GNSSENTRY_C1DATA,GNSSENTRY_L1CDATA,GNSSENTRY_D1CDATA,
[4955]	1197	GNSSENTRY_S1CDATA,GNSSDF2_LOCKLOSSL1,GAL_WAVELENGTH_E1,"1A"},
[2659]	1198	{GNSSENTRY_C1DATA,GNSSENTRY_L1CDATA,GNSSENTRY_D1CDATA,
	1199	GNSSENTRY_S1CDATA,GNSSDF2_LOCKLOSSL1,GAL_WAVELENGTH_E1,"1B"},
[4228]	1200	{GNSSENTRY_C1DATA,GNSSENTRY_L1CDATA,GNSSENTRY_D1CDATA,
[4955]	1201	GNSSENTRY_S1CDATA,GNSSDF2_LOCKLOSSL1,GAL_WAVELENGTH_E1,"1X"},
[4958]	1202	{GNSSENTRY_C1DATA,GNSSENTRY_L1CDATA,GNSSENTRY_D1CDATA,
[4955]	1203	GNSSENTRY_S1CDATA,GNSSDF2_LOCKLOSSL1,GAL_WAVELENGTH_E1,"1Z"},
[2659]	1204	{0,0,0,0,0,0,0},
	1205	{GNSSENTRY_C6DATA,GNSSENTRY_L6DATA,GNSSENTRY_D6DATA,
[3581]	1206	GNSSENTRY_S6DATA,GNSSDF2_LOCKLOSSE6,GAL_WAVELENGTH_E6,"6C"},
[4958]	1207	{GNSSENTRY_C6DATA,GNSSENTRY_L6DATA,GNSSENTRY_D6DATA,
[4955]	1208	GNSSENTRY_S6DATA,GNSSDF2_LOCKLOSSE6,GAL_WAVELENGTH_E6,"6A"},
[2659]	1209	{GNSSENTRY_C6DATA,GNSSENTRY_L6DATA,GNSSENTRY_D6DATA,
[3581]	1210	GNSSENTRY_S6DATA,GNSSDF2_LOCKLOSSE6,GAL_WAVELENGTH_E6,"6B"},
[4958]	1211	{GNSSENTRY_C6DATA,GNSSENTRY_L6DATA,GNSSENTRY_D6DATA,
[4955]	1212	GNSSENTRY_S6DATA,GNSSDF2_LOCKLOSSE6,GAL_WAVELENGTH_E6,"6X"},
[4958]	1213	{GNSSENTRY_C6DATA,GNSSENTRY_L6DATA,GNSSENTRY_D6DATA,
[4955]	1214	GNSSENTRY_S6DATA,GNSSDF2_LOCKLOSSE6,GAL_WAVELENGTH_E6,"6Z"},
[2659]	1215	{0,0,0,0,0,0,0},
	1216	{GNSSENTRY_C5BDATA,GNSSENTRY_L5BDATA,GNSSENTRY_D5BDATA,
	1217	GNSSENTRY_S5BDATA,GNSSDF2_LOCKLOSSE5B,GAL_WAVELENGTH_E5B,"7I"},
	1218	{GNSSENTRY_C5BDATA,GNSSENTRY_L5BDATA,GNSSENTRY_D5BDATA,
	1219	GNSSENTRY_S5BDATA,GNSSDF2_LOCKLOSSE5B,GAL_WAVELENGTH_E5B,"7Q"},
[4228]	1220	{GNSSENTRY_C5BDATA,GNSSENTRY_L5BDATA,GNSSENTRY_D5BDATA,
[4955]	1221	GNSSENTRY_S5BDATA,GNSSDF2_LOCKLOSSE5B,GAL_WAVELENGTH_E5B,"7X"},
[2659]	1222	{0,0,0,0,0,0,0},
	1223	{GNSSENTRY_C5ABDATA,GNSSENTRY_L5ABDATA,GNSSENTRY_D5ABDATA,
	1224	GNSSENTRY_S5ABDATA,GNSSDF2_LOCKLOSSE5AB,GAL_WAVELENGTH_E5AB,"8I"},
	1225	{GNSSENTRY_C5ABDATA,GNSSENTRY_L5ABDATA,GNSSENTRY_D5ABDATA,
	1226	GNSSENTRY_S5ABDATA,GNSSDF2_LOCKLOSSE5AB,GAL_WAVELENGTH_E5AB,"8Q"},
[4228]	1227	{GNSSENTRY_C5ABDATA,GNSSENTRY_L5ABDATA,GNSSENTRY_D5ABDATA,
[4955]	1228	GNSSENTRY_S5ABDATA,GNSSDF2_LOCKLOSSE5AB,GAL_WAVELENGTH_E5AB,"8X"},
[2659]	1229	{0,0,0,0,0,0,0},
	1230	{GNSSENTRY_C5DATA,GNSSENTRY_L5DATA,GNSSENTRY_D5DATA,
	1231	GNSSENTRY_S5DATA,GNSSDF2_LOCKLOSSL5,GAL_WAVELENGTH_E5A,"5I"},
	1232	{GNSSENTRY_C5DATA,GNSSENTRY_L5DATA,GNSSENTRY_D5DATA,
	1233	GNSSENTRY_S5DATA,GNSSDF2_LOCKLOSSL5,GAL_WAVELENGTH_E5A,"5Q"},
[4228]	1234	{GNSSENTRY_C5DATA,GNSSENTRY_L5DATA,GNSSENTRY_D5DATA,
[4955]	1235	GNSSENTRY_S5DATA,GNSSDF2_LOCKLOSSL5,GAL_WAVELENGTH_E5A,"5X"},
[3581]	1236	{0,0,0,0,0,0,0},
	1237	{0,0,0,0,0,0,0},
	1238	{0,0,0,0,0,0,0},
	1239	{0,0,0,0,0,0,0},
	1240	{0,0,0,0,0,0,0},
	1241	{0,0,0,0,0,0,0},
	1242	{0,0,0,0,0,0,0},
	1243	{0,0,0,0,0,0,0},
[2659]	1244	};
[4367]	1245	struct CodeData qzss[RTCM3_MSM_NUMSIG] =
	1246	{
	1247	{0,0,0,0,0,0,0},
	1248	{GNSSENTRY_C1DATA,GNSSENTRY_L1CDATA,GNSSENTRY_D1CDATA,
	1249	GNSSENTRY_S1CDATA,GNSSDF2_LOCKLOSSL1,GPS_WAVELENGTH_L1,"1C"},
	1250	{0,0,0,0,0,0,0},
	1251	{0,0,0,0,0,0,0},
	1252	{0,0,0,0,0,0,0},
	1253	{GNSSENTRY_CSAIFDATA,GNSSENTRY_LSAIFDATA,GNSSENTRY_DSAIFDATA,
	1254	GNSSENTRY_SSAIFDATA,GNSSDF2_LOCKLOSSSAIF,GPS_WAVELENGTH_L1,"1Z"},
	1255	{0,0,0,0,0,0,0},
	1256	{0,0,0,0,0,0,0},
	1257	{GNSSENTRY_CLEXDATA,GNSSENTRY_LLEXDATA,GNSSENTRY_DLEXDATA,
	1258	GNSSENTRY_SLEXDATA,GNSSDF2_LOCKLOSSLEX,QZSS_WAVELENGTH_LEX,"6S"},
	1259	{GNSSENTRY_CLEXDATA,GNSSENTRY_LLEXDATA,GNSSENTRY_DLEXDATA,
	1260	GNSSENTRY_SLEXDATA,GNSSDF2_LOCKLOSSLEX,QZSS_WAVELENGTH_LEX,"6L"},
	1261	{GNSSENTRY_CLEXDATA,GNSSENTRY_LLEXDATA,GNSSENTRY_DLEXDATA,
	1262	GNSSENTRY_SLEXDATA,GNSSDF2_LOCKLOSSLEX,QZSS_WAVELENGTH_LEX,"6X"},
[4498]	1263	{0,0,0,0,0,0,0},
	1264	{0,0,0,0,0,0,0},
	1265	{0,0,0,0,0,0,0},
[4367]	1266	{GNSSENTRY_C2DATA,GNSSENTRY_L2CDATA,GNSSENTRY_D2CDATA,
	1267	GNSSENTRY_S2CDATA,GNSSDF2_LOCKLOSSL2,GPS_WAVELENGTH_L2,"2S"},
	1268	{GNSSENTRY_C2DATA,GNSSENTRY_L2CDATA,GNSSENTRY_D2CDATA,
	1269	GNSSENTRY_S2CDATA,GNSSDF2_LOCKLOSSL2,GPS_WAVELENGTH_L2,"2L"},
	1270	{GNSSENTRY_C2DATA,GNSSENTRY_L2CDATA,GNSSENTRY_D2CDATA,
	1271	GNSSENTRY_S2CDATA,GNSSDF2_LOCKLOSSL2,GPS_WAVELENGTH_L2,"2X"},
	1272	{0,0,0,0,0,0,0},
	1273	{0,0,0,0,0,0,0},
	1274	{0,0,0,0,0,0,0},
	1275	{0,0,0,0,0,0,0},
	1276	{GNSSENTRY_C5DATA,GNSSENTRY_L5DATA,GNSSENTRY_D5DATA,
	1277	GNSSENTRY_S5DATA,GNSSDF2_LOCKLOSSL5,GPS_WAVELENGTH_L5,"5I"},
	1278	{GNSSENTRY_C5DATA,GNSSENTRY_L5DATA,GNSSENTRY_D5DATA,
	1279	GNSSENTRY_S5DATA,GNSSDF2_LOCKLOSSL5,GPS_WAVELENGTH_L5,"5Q"},
	1280	{GNSSENTRY_C5DATA,GNSSENTRY_L5DATA,GNSSENTRY_D5DATA,
	1281	GNSSENTRY_S5DATA,GNSSDF2_LOCKLOSSL5,GPS_WAVELENGTH_L5,"5X"},
	1282	{0,0,0,0,0,0,0},
	1283	{0,0,0,0,0,0,0},
	1284	{0,0,0,0,0,0,0},
	1285	{0,0,0,0,0,0,0},
[4535]	1286	{0,0,0,0,0,0,0},
[4498]	1287	{GNSSENTRY_C1NDATA,GNSSENTRY_L1NDATA,GNSSENTRY_D1NDATA,
	1288	GNSSENTRY_S1NDATA,GNSSDF2_LOCKLOSSL1,GPS_WAVELENGTH_L1,"1D"},
	1289	{GNSSENTRY_C1NDATA,GNSSENTRY_L1NDATA,GNSSENTRY_D1NDATA,
	1290	GNSSENTRY_S1NDATA,GNSSDF2_LOCKLOSSL1,GPS_WAVELENGTH_L1,"1P"},
	1291	{GNSSENTRY_C1NDATA,GNSSENTRY_L1NDATA,GNSSENTRY_D1NDATA,
	1292	GNSSENTRY_S1NDATA,GNSSDF2_LOCKLOSSL1,GPS_WAVELENGTH_L1,"1X"}
[4367]	1293	};
	1294	struct CodeData compass[RTCM3_MSM_NUMSIG] =
	1295	{
	1296	{0,0,0,0,0,0,0},
	1297	{GNSSENTRY_CB1DATA,GNSSENTRY_LB1DATA,GNSSENTRY_DB1DATA,
[5372]	1298	GNSSENTRY_SB1DATA,GNSSDF2_LOCKLOSSB1,COMPASS_WAVELENGTH_B1,"1I"},
[4367]	1299	{0,0,0,0,0,0,0},
	1300	{0,0,0,0,0,0,0},
	1301	{0,0,0,0,0,0,0},
	1302	{0,0,0,0,0,0,0},
	1303	{0,0,0,0,0,0,0},
	1304	{GNSSENTRY_CB3DATA,GNSSENTRY_LB3DATA,GNSSENTRY_DB3DATA,
	1305	GNSSENTRY_SB3DATA,GNSSDF2_LOCKLOSSB3,COMPASS_WAVELENGTH_B3,"6I"},
	1306	{0,0,0,0,0,0,0},
	1307	{0,0,0,0,0,0,0},
	1308	{0,0,0,0,0,0,0},
	1309	{0,0,0,0,0,0,0},
	1310	{0,0,0,0,0,0,0},
	1311	{GNSSENTRY_CB2DATA,GNSSENTRY_LB2DATA,GNSSENTRY_DB2DATA,
	1312	GNSSENTRY_SB2DATA,GNSSDF2_LOCKLOSSB2,COMPASS_WAVELENGTH_B2,"7I"},
	1313	{0,0,0,0,0,0,0},
	1314	{0,0,0,0,0,0,0},
	1315	{0,0,0,0,0,0,0},
	1316	{0,0,0,0,0,0,0},
	1317	{0,0,0,0,0,0,0},
	1318	{0,0,0,0,0,0,0},
	1319	{0,0,0,0,0,0,0},
	1320	{0,0,0,0,0,0,0},
	1321	{0,0,0,0,0,0,0},
	1322	{0,0,0,0,0,0,0},
	1323	{0,0,0,0,0,0,0},
	1324	{0,0,0,0,0,0,0},
	1325	{0,0,0,0,0,0,0},
	1326	{0,0,0,0,0,0,0},
	1327	{0,0,0,0,0,0,0},
	1328	{0,0,0,0,0,0,0},
	1329	{0,0,0,0,0,0,0},
	1330	{0,0,0,0,0,0,0},
	1331	};
[2659]	1332
[4371]	1333	int sys = RTCM3_MSM_GPS, i=0, count, j, old = 0, wasnoamb = 0,
	1334	start=PRN_GPS_START;
[2659]	1335	int syncf, sigmask, numsat = 0, numsig = 0, numcells;
	1336	uint64_t satmask, cellmask, ui;
	1337	double rrmod[RTCM3_MSM_NUMSAT];
[3581]	1338	int rrint[RTCM3_MSM_NUMSAT], rdop[RTCM3_MSM_NUMSAT],
	1339	extsat[RTCM3_MSM_NUMSAT];
[5358]	1340	int ll[RTCM3_MSM_NUMCELLS]/, hc[RTCM3_MSM_NUMCELLS]/;
[2659]	1341	double cnr[RTCM3_MSM_NUMCELLS];
	1342	double cp[RTCM3_MSM_NUMCELLS], psr[RTCM3_MSM_NUMCELLS],
	1343	dop[RTCM3_MSM_NUMCELLS];
	1344	struct gnssdata *gnss = &handle->DataNew;
	1345
	1346	SKIPBITS(12)
[4367]	1347	if(type >= 1121)
[4371]	1348	{
[4367]	1349	sys = RTCM3_MSM_COMPASS;
[4371]	1350	start = PRN_COMPASS_START;
	1351	}
[4367]	1352	else if(type >= 1111)
[4371]	1353	{
[4367]	1354	sys = RTCM3_MSM_QZSS;
[4371]	1355	start = PRN_QZSS_START;
	1356	}
[4367]	1357	else if(type >= 1101)
[4371]	1358	{
[4367]	1359	sys = RTCM3_MSM_SBAS;
[4371]	1360	start = PRN_SBAS_START;
	1361	}
[4367]	1362	else if(type >= 1091)
[4371]	1363	{
[2659]	1364	sys = RTCM3_MSM_GALILEO;
[4371]	1365	start = PRN_GALILEO_START;
	1366	}
[2659]	1367	else if(type >= 1081)
[4371]	1368	{
[2659]	1369	sys = RTCM3_MSM_GLONASS;
[4371]	1370	start = PRN_GLONASS_START;
	1371	}
[2659]	1372
[4383]	1373	for(i = 0; i < RTCM3_MSM_NUMSAT; ++i)
	1374	extsat[i] = 15;
	1375
[2659]	1376	switch(sys)
	1377	{
[4367]	1378	case RTCM3_MSM_COMPASS:
[5152]	1379	GETBITS(i,30)
	1380	i += 14000;
	1381	if(i >= 72460601000)
	1382	i -= 72460601000;
	1383	if(i/1000 < (int)handle->GPSTOW - 86400)
	1384	++handle->GPSWeek;
	1385	handle->GPSTOW = i/1000;
	1386	break;
[2659]	1387	case RTCM3_MSM_GALILEO: /* use DF004 instead of DF248 */
[4367]	1388	case RTCM3_MSM_QZSS:
	1389	case RTCM3_MSM_SBAS:
[2659]	1390	case RTCM3_MSM_GPS:
	1391	GETBITS(i,30)
	1392	if(i/1000 < (int)handle->GPSTOW - 86400)
	1393	++handle->GPSWeek;
	1394	handle->GPSTOW = i/1000;
	1395	break;
	1396	case RTCM3_MSM_GLONASS:
	1397	SKIPBITS(3)
	1398	GETBITS(i,27) /* tk */
	1399
	1400	updatetime(&handle->GPSWeek, &handle->GPSTOW, i, 0); /* Moscow -> GPS */
	1401	i = handle->GPSTOW*1000;
	1402	break;
	1403	}
	1404
	1405	if(gnss->week && (gnss->timeofweek != i \|\| gnss->week
	1406	!= handle->GPSWeek))
	1407	{
	1408	handle->Data = *gnss;
	1409	memset(gnss, 0, sizeof(*gnss));
	1410	old = 1;
	1411	}
	1412	gnss->timeofweek = i;
	1413	gnss->week = handle->GPSWeek;
	1414
	1415	GETBITS(syncf, 1)
[3581]	1416	SKIPBITS(3+7+2+2+1+3)
[2860]	1417	GETBITS64(satmask, RTCM3_MSM_NUMSAT)
[2659]	1418
	1419	/* http://gurmeetsingh.wordpress.com/2008/08/05/fast-bit-counting-routines/ */
	1420	for(ui = satmask; ui; ui &= (ui - 1) /* remove rightmost bit */)
	1421	++numsat;
	1422	GETBITS(sigmask, RTCM3_MSM_NUMSIG)
	1423	for(i = sigmask; i; i &= (i - 1) /* remove rightmost bit */)
	1424	++numsig;
	1425	i = numsat*numsig;
[2860]	1426	GETBITS64(cellmask, (unsigned)i)
[2659]	1427
	1428	switch(type % 10)
	1429	{
	1430	case 1: case 2: case 3:
[2668]	1431	++wasnoamb;
[2659]	1432	for(j = numsat; j--;)
[3581]	1433	GETFLOAT(rrmod[j], 10, 1.0/1024.0)
[2659]	1434	break;
	1435	case 4: case 6:
	1436	for(j = numsat; j--;)
	1437	GETBITS(rrint[j], 8)
	1438	for(j = numsat; j--;)
[3581]	1439	GETFLOAT(rrmod[j], 10, 1.0/1024.0)
[2659]	1440	break;
	1441	case 5: case 7:
	1442	for(j = numsat; j--;)
	1443	GETBITS(rrint[j], 8)
	1444	for(j = numsat; j--;)
[3581]	1445	GETBITS(extsat[j], 4)
[2659]	1446	for(j = numsat; j--;)
[3581]	1447	GETFLOAT(rrmod[j], 10, 1.0/1024.0)
	1448	for(j = numsat; j--;)
[2659]	1449	GETBITSSIGN(rdop[j], 14)
	1450	break;
	1451	}
	1452
	1453	numcells = numsat*numsig;
	1454	if(numcells <= RTCM3_MSM_NUMCELLS)
	1455	{
	1456	switch(type % 10)
	1457	{
	1458	case 1:
	1459	for(count = numcells; count--;)
	1460	if(cellmask & (UINT64(1)<<count))
[3581]	1461	GETFLOATSIGN(psr[count], 15, 1.0/(1<<24))
[2659]	1462	break;
	1463	case 2:
	1464	for(count = numcells; count--;)
	1465	if(cellmask & (UINT64(1)<<count))
[3581]	1466	GETFLOATSIGN(cp[count], 22, 1.0/(1<<29))
[2659]	1467	for(count = numcells; count--;)
	1468	if(cellmask & (UINT64(1)<<count))
	1469	GETBITS(ll[count], 4)
[3712]	1470	for(count = numcells; count--;)
	1471	if(cellmask & (UINT64(1)<<count))
[5358]	1472	SKIPBITS(1)/GETBITS(hc[count], 1)/
[2659]	1473	break;
	1474	case 3:
	1475	for(count = numcells; count--;)
	1476	if(cellmask & (UINT64(1)<<count))
[3581]	1477	GETFLOATSIGN(psr[count], 15, 1.0/(1<<24))
[2659]	1478	for(count = numcells; count--;)
	1479	if(cellmask & (UINT64(1)<<count))
[3581]	1480	GETFLOATSIGN(cp[count], 22, 1.0/(1<<29))
[2659]	1481	for(count = numcells; count--;)
	1482	if(cellmask & (UINT64(1)<<count))
	1483	GETBITS(ll[count], 4)
[3712]	1484	for(count = numcells; count--;)
	1485	if(cellmask & (UINT64(1)<<count))
[5358]	1486	SKIPBITS(1)/GETBITS(hc[count], 1)/
[2659]	1487	break;
	1488	case 4:
	1489	for(count = numcells; count--;)
	1490	if(cellmask & (UINT64(1)<<count))
[3581]	1491	GETFLOATSIGN(psr[count], 15, 1.0/(1<<24))
[2659]	1492	for(count = numcells; count--;)
	1493	if(cellmask & (UINT64(1)<<count))
[3581]	1494	GETFLOATSIGN(cp[count], 22, 1.0/(1<<29))
[2659]	1495	for(count = numcells; count--;)
	1496	if(cellmask & (UINT64(1)<<count))
	1497	GETBITS(ll[count], 4)
	1498	for(count = numcells; count--;)
	1499	if(cellmask & (UINT64(1)<<count))
[5358]	1500	SKIPBITS(1)/GETBITS(hc[count], 1)/
[3712]	1501	for(count = numcells; count--;)
	1502	if(cellmask & (UINT64(1)<<count))
[2659]	1503	GETBITS(cnr[count], 6)
	1504	break;
	1505	case 5:
	1506	for(count = numcells; count--;)
	1507	if(cellmask & (UINT64(1)<<count))
[3581]	1508	GETFLOATSIGN(psr[count], 15, 1.0/(1<<24))
[2659]	1509	for(count = numcells; count--;)
	1510	if(cellmask & (UINT64(1)<<count))
[3581]	1511	GETFLOATSIGN(cp[count], 22, 1.0/(1<<29))
[2659]	1512	for(count = numcells; count--;)
	1513	if(cellmask & (UINT64(1)<<count))
	1514	GETBITS(ll[count], 4)
	1515	for(count = numcells; count--;)
	1516	if(cellmask & (UINT64(1)<<count))
[5358]	1517	SKIPBITS(1)/GETBITS(hc[count], 1)/
[3712]	1518	for(count = numcells; count--;)
	1519	if(cellmask & (UINT64(1)<<count))
[2659]	1520	GETFLOAT(cnr[count], 6, 1.0)
	1521	for(count = numcells; count--;)
	1522	if(cellmask & (UINT64(1)<<count))
	1523	GETFLOATSIGN(dop[count], 15, 0.0001)
	1524	break;
	1525	case 6:
	1526	for(count = numcells; count--;)
	1527	if(cellmask & (UINT64(1)<<count))
[3581]	1528	GETFLOATSIGN(psr[count], 20, 1.0/(1<<29))
[2659]	1529	for(count = numcells; count--;)
	1530	if(cellmask & (UINT64(1)<<count))
[3581]	1531	GETFLOATSIGN(cp[count], 24, 1.0/(1U<<31))
[2659]	1532	for(count = numcells; count--;)
	1533	if(cellmask & (UINT64(1)<<count))
	1534	GETBITS(ll[count], 10)
	1535	for(count = numcells; count--;)
	1536	if(cellmask & (UINT64(1)<<count))
[5358]	1537	SKIPBITS(1)/GETBITS(hc[count], 1)/
[3712]	1538	for(count = numcells; count--;)
	1539	if(cellmask & (UINT64(1)<<count))
[3724]	1540	GETFLOAT(cnr[count], 10, 1.0/(1<<4))
[3581]	1541	break;
[2659]	1542	case 7:
	1543	for(count = numcells; count--;)
	1544	if(cellmask & (UINT64(1)<<count))
[3581]	1545	GETFLOATSIGN(psr[count], 20, 1.0/(1<<29))
[2659]	1546	for(count = numcells; count--;)
	1547	if(cellmask & (UINT64(1)<<count))
[3581]	1548	GETFLOATSIGN(cp[count], 24, 1.0/(1U<<31))
[2659]	1549	for(count = numcells; count--;)
	1550	if(cellmask & (UINT64(1)<<count))
	1551	GETBITS(ll[count], 10)
	1552	for(count = numcells; count--;)
	1553	if(cellmask & (UINT64(1)<<count))
[5358]	1554	SKIPBITS(1)/GETBITS(hc[count], 1)/
[3712]	1555	for(count = numcells; count--;)
	1556	if(cellmask & (UINT64(1)<<count))
[3724]	1557	GETFLOAT(cnr[count], 10, 1.0/(1<<4))
[2659]	1558	for(count = numcells; count--;)
	1559	if(cellmask & (UINT64(1)<<count))
	1560	GETFLOATSIGN(dop[count], 15, 0.0001)
	1561	break;
	1562	}
	1563	i = RTCM3_MSM_NUMSAT;
	1564	j = -1;
	1565	for(count = numcells; count--;)
	1566	{
	1567	while(j >= 0 && !(sigmask&(1<<--j)))
	1568	;
	1569	if(j < 0)
	1570	{
	1571	while(!(satmask&(UINT64(1)<<(--i)))) /* next satellite */
	1572	;
	1573	j = RTCM3_MSM_NUMSIG;
	1574	while(!(sigmask&(1<<--j)))
	1575	;
	1576	--numsat;
	1577	}
	1578	if(cellmask & (UINT64(1)<<count))
	1579	{
	1580	struct CodeData cd = {0,0,0,0,0,0,0};
	1581	double wl = 0.0;
	1582	switch(sys)
	1583	{
[4367]	1584	case RTCM3_MSM_QZSS:
	1585	cd = qzss[RTCM3_MSM_NUMSIG-j-1];
[2659]	1586	wl = cd.wl;
	1587	break;
[4367]	1588	case RTCM3_MSM_COMPASS:
	1589	cd = compass[RTCM3_MSM_NUMSIG-j-1];
	1590	wl = cd.wl;
	1591	break;
	1592	case RTCM3_MSM_GPS: case RTCM3_MSM_SBAS:
	1593	cd = gps[RTCM3_MSM_NUMSIG-j-1];
	1594	wl = cd.wl;
	1595	break;
[2659]	1596	case RTCM3_MSM_GLONASS: cd = glo[RTCM3_MSM_NUMSIG-j-1];
	1597	{
	1598	int k = handle->GLOFreq[RTCM3_MSM_NUMSAT-i-1];
[5535]	1599	if(!k && extsat[numsat] < 14)
[3653]	1600	{
[3654]	1601	k = handle->GLOFreq[RTCM3_MSM_NUMSAT-i-1]
[5535]	1602	= 100+extsat[numsat]-7;
[3653]	1603	}
[2659]	1604	if(k)
	1605	{
	1606	if(cd.wl == 0.0)
	1607	wl = GLO_WAVELENGTH_L1(k-100);
	1608	else if(cd.wl == 1.0)
	1609	wl = GLO_WAVELENGTH_L2(k-100);
	1610	}
	1611	}
	1612	break;
	1613	case RTCM3_MSM_GALILEO: cd = gal[RTCM3_MSM_NUMSIG-j-1];
	1614	wl = cd.wl;
	1615	break;
	1616	}
	1617	if(cd.lock && wl) /* lock cannot have a valid zero value */
	1618	{
[2996]	1619	int fullsat = RTCM3_MSM_NUMSAT-i-1, num;
	1620
	1621	if(sys == RTCM3_MSM_GALILEO && fullsat >= 50 && fullsat <= 51)
	1622	fullsat += PRN_GIOVE_START-50;
	1623	else
[4371]	1624	fullsat += start;
[2996]	1625
[2659]	1626	for(num = 0; num < gnss->numsats
	1627	&& fullsat != gnss->satellites[num]; ++num)
	1628	;
	1629
	1630	if(num == gnss->numsats)
	1631	gnss->satellites[gnss->numsats++] = fullsat;
	1632
[4374]	1633	gnss->codetype[num][cd.typeR] =
	1634	gnss->codetype[num][cd.typeP] =
	1635	gnss->codetype[num][cd.typeD] =
	1636	gnss->codetype[num][cd.typeS] = cd.code;
[4371]	1637	if(!handle->info[sys].type[cd.typeR])
	1638	{
	1639	handle->info[sys].type[cd.typeR] =
	1640	handle->info[sys].type[cd.typeP] =
	1641	handle->info[sys].type[cd.typeD] =
	1642	handle->info[sys].type[cd.typeS] = cd.code[1];
	1643	}
[4367]	1644
[2659]	1645	switch(type % 10)
	1646	{
	1647	case 1:
[3581]	1648	if(psr[count] > -1.0/(1<<10))
[2659]	1649	{
[3581]	1650	gnss->measdata[num][cd.typeR] = psr[count]*LIGHTSPEED/1000.0
[2668]	1651	+(rrmod[numsat])*LIGHTSPEED/1000.0;
[4383]	1652	gnss->dataflags[num] \|= (1LL<<cd.typeR);
[2659]	1653	}
	1654	break;
	1655	case 2:
[3581]	1656	if(wl && cp[count] > -1.0/(1<<8))
[2659]	1657	{
[3725]	1658	gnss->measdata[num][cd.typeP] = cp[count]*LIGHTSPEED/1000.0/wl
[2668]	1659	+(rrmod[numsat])*LIGHTSPEED/1000.0/wl;
[5660]	1660	if(handle->lastlockmsm[j][i] > ll[count])
[2659]	1661	gnss->dataflags2[num] \|= cd.lock;
[5660]	1662	handle->lastlockmsm[j][i] = ll[count] > 255 ? 255 : ll[count];
[4383]	1663	gnss->dataflags[num] \|= (1LL<<cd.typeP);
[2659]	1664	}
	1665	break;
	1666	case 3:
[3581]	1667	if(psr[count] > -1.0/(1<<10))
[2659]	1668	{
[3581]	1669	gnss->measdata[num][cd.typeR] = psr[count]*LIGHTSPEED/1000.0
[2668]	1670	+(rrmod[numsat])*LIGHTSPEED/1000.0;
[4383]	1671	gnss->dataflags[num] \|= (1LL<<cd.typeR);
[2659]	1672	}
	1673
[3581]	1674	if(wl && cp[count] > -1.0/(1<<8))
[2659]	1675	{
[3725]	1676	gnss->measdata[num][cd.typeP] = cp[count]*LIGHTSPEED/1000.0/wl
[2659]	1677	+(rrmod[numsat]+rrint[numsat])*LIGHTSPEED/1000.0/wl;
[5660]	1678	if(handle->lastlockmsm[j][i] > ll[count])
[2659]	1679	gnss->dataflags2[num] \|= cd.lock;
[5660]	1680	handle->lastlockmsm[j][i] = ll[count] > 255 ? 255 : ll[count];
[4383]	1681	gnss->dataflags[num] \|= (1LL<<cd.typeP);
[2659]	1682	}
	1683	break;
	1684	case 4:
[3581]	1685	if(psr[count] > -1.0/(1<<10))
[2659]	1686	{
[3581]	1687	gnss->measdata[num][cd.typeR] = psr[count]*LIGHTSPEED/1000.0
[2659]	1688	+(rrmod[numsat]+rrint[numsat])*LIGHTSPEED/1000.0;
[4383]	1689	gnss->dataflags[num] \|= (1LL<<cd.typeR);
[2659]	1690	}
	1691
[3581]	1692	if(wl && cp[count] > -1.0/(1<<8))
[2659]	1693	{
[3725]	1694	gnss->measdata[num][cd.typeP] = cp[count]*LIGHTSPEED/1000.0/wl
[2659]	1695	+(rrmod[numsat]+rrint[numsat])*LIGHTSPEED/1000.0/wl;
[5660]	1696	if(handle->lastlockmsm[j][i] > ll[count])
[2659]	1697	gnss->dataflags2[num] \|= cd.lock;
[5660]	1698	handle->lastlockmsm[j][i] = ll[count] > 255 ? 255 : ll[count];
[4383]	1699	gnss->dataflags[num] \|= (1LL<<cd.typeP);
[2659]	1700	}
	1701
	1702	gnss->measdata[num][cd.typeS] = cnr[count];
[4383]	1703	gnss->dataflags[num] \|= (1LL<<cd.typeS);
[2659]	1704	break;
	1705	case 5:
[3581]	1706	if(psr[count] > -1.0/(1<<10))
[2659]	1707	{
[3581]	1708	gnss->measdata[num][cd.typeR] = psr[count]*LIGHTSPEED/1000.0
[2659]	1709	+(rrmod[numsat]+rrint[numsat])*LIGHTSPEED/1000.0;
[4383]	1710	gnss->dataflags[num] \|= (1LL<<cd.typeR);
[2659]	1711	}
	1712
[3581]	1713	if(wl && cp[count] > -1.0/(1<<8))
[2659]	1714	{
[3725]	1715	gnss->measdata[num][cd.typeP] = cp[count]*LIGHTSPEED/1000.0/wl
[2659]	1716	+(rrmod[numsat]+rrint[numsat])*LIGHTSPEED/1000.0/wl;
[5660]	1717	if(handle->lastlockmsm[j][i] > ll[count])
[2659]	1718	gnss->dataflags2[num] \|= cd.lock;
[5660]	1719	handle->lastlockmsm[j][i] = ll[count] > 255 ? 255 : ll[count];
[4383]	1720	gnss->dataflags[num] \|= (1LL<<cd.typeP);
[2659]	1721	}
	1722
	1723	gnss->measdata[num][cd.typeS] = cnr[count];
	1724	gnss->dataflags[num] \|= (1<<cd.typeS);
	1725
	1726	if(dop[count] > -1.6384)
	1727	{
[2873]	1728	gnss->measdata[num][cd.typeD] = -(dop[count]
[2849]	1729	+rdop[numsat])/wl;
[4383]	1730	gnss->dataflags[num] \|= (1LL<<cd.typeD);
[2659]	1731	}
	1732	break;
	1733	case 6:
[3581]	1734	if(psr[count] > -1.0/(1<<10))
[2659]	1735	{
[3581]	1736	gnss->measdata[num][cd.typeR] = psr[count]*LIGHTSPEED/1000.0
[2659]	1737	+(rrmod[numsat]+rrint[numsat])*LIGHTSPEED/1000.0;
[4383]	1738	gnss->dataflags[num] \|= (1LL<<cd.typeR);
[2659]	1739	}
	1740
[3581]	1741	if(wl && cp[count] > -1.0/(1<<8))
[2659]	1742	{
[3725]	1743	gnss->measdata[num][cd.typeP] = cp[count]*LIGHTSPEED/1000.0/wl
[2659]	1744	+(rrmod[numsat]+rrint[numsat])*LIGHTSPEED/1000.0/wl;
[5660]	1745	if(handle->lastlockmsm[j][i] > ll[count])
[2659]	1746	gnss->dataflags2[num] \|= cd.lock;
[5660]	1747	handle->lastlockmsm[j][i] = ll[count] > 255 ? 255 : ll[count];
[4383]	1748	gnss->dataflags[num] \|= (1LL<<cd.typeP);
[2659]	1749	}
	1750
	1751	gnss->measdata[num][cd.typeS] = cnr[count];
[4383]	1752	gnss->dataflags[num] \|= (1LL<<cd.typeS);
[2659]	1753	break;
	1754	case 7:
[3581]	1755	if(psr[count] > -1.0/(1<<10))
[2659]	1756	{
[3581]	1757	gnss->measdata[num][cd.typeR] = psr[count]*LIGHTSPEED/1000.0
[2659]	1758	+(rrmod[numsat]+rrint[numsat])*LIGHTSPEED/1000.0;
[4383]	1759	gnss->dataflags[num] \|= (1LL<<cd.typeR);
[2659]	1760	}
	1761
[3581]	1762	if(wl && cp[count] > -1.0/(1<<8))
[2659]	1763	{
[3725]	1764	gnss->measdata[num][cd.typeP] = cp[count]*LIGHTSPEED/1000.0/wl
[2659]	1765	+(rrmod[numsat]+rrint[numsat])*LIGHTSPEED/1000.0/wl;
[5660]	1766	if(handle->lastlockmsm[j][i] > ll[count])
[2659]	1767	gnss->dataflags2[num] \|= cd.lock;
[5660]	1768	handle->lastlockmsm[j][i] = ll[count] > 255 ? 255 : ll[count];
[4383]	1769	gnss->dataflags[num] \|= (1LL<<cd.typeP);
[2659]	1770	}
	1771
	1772	gnss->measdata[num][cd.typeS] = cnr[count];
[4383]	1773	gnss->dataflags[num] \|= (1LL<<cd.typeS);
[2659]	1774
	1775	if(dop[count] > -1.6384)
	1776	{
[2873]	1777	gnss->measdata[num][cd.typeD] = -(dop[count]
[2849]	1778	+rdop[numsat])/wl;
[4383]	1779	gnss->dataflags[num] \|= (1LL<<cd.typeD);
[2659]	1780	}
	1781	break;
	1782	}
	1783	}
	1784	}
	1785	}
	1786	}
	1787	if(!syncf && !old)
	1788	{
	1789	handle->Data = *gnss;
	1790	memset(gnss, 0, sizeof(*gnss));
	1791	}
	1792	if(!syncf \|\| old)
	1793	{
[2668]	1794	if(!wasnoamb) /* not RINEX compatible without */
[2659]	1795	ret = 1;
	1796	else
	1797	ret = 2;
	1798	}
	1799	#ifdef NO_RTCM3_MAIN
	1800	else
	1801	ret = type;
	1802	#endif /* NO_RTCM3_MAIN */
	1803	}
	1804	break;
[27]	1805	}
	1806	}
	1807	return ret;
	1808	}
	1809
	1810	struct Header
	1811	{
	1812	const char *version;
	1813	const char *pgm;
	1814	const char *marker;
[503]	1815	const char *markertype;
[27]	1816	const char *observer;
	1817	const char *receiver;
	1818	const char *antenna;
	1819	const char *position;
	1820	const char *antennaposition;
	1821	const char *wavelength;
	1822	const char typesofobs; / should not be modified outside */
[502]	1823	const char typesofobsG; / should not be modified outside */
	1824	const char typesofobsR; / should not be modified outside */
	1825	const char typesofobsS; / should not be modified outside */
[2699]	1826	const char typesofobsE; / should not be modified outside */
[4367]	1827	const char typesofobsC; / should not be modified outside */
	1828	const char typesofobsJ; / should not be modified outside */
[27]	1829	const char timeoffirstobs; / should not be modified outside */
	1830	};
	1831
	1832	#define MAXHEADERLINES 50
	1833	#define MAXHEADERBUFFERSIZE 4096
	1834	struct HeaderData
	1835	{
	1836	union
	1837	{
	1838	struct Header named;
	1839	const char *unnamed[MAXHEADERLINES];
	1840	} data;
	1841	int numheaders;
	1842	};
	1843
[1092]	1844	void converttime(struct converttimeinfo *c, int week, int tow)
[270]	1845	{
	1846	int i, k, doy, j; /* temporary variables */
	1847	j = week(7246060) + tow + 52460*60;
	1848	for(i = 1980; j >= (k = (365+longyear(i,0))2460*60); ++i)
	1849	j -= k;
	1850	c->year = i;
	1851	doy = 1+ (j / (246060));
	1852	j %= (246060);
	1853	c->hour = j / (60*60);
	1854	j %= (60*60);
	1855	c->minute = j / 60;
	1856	c->second = j % 60;
	1857	j = 0;
	1858	for(i = 1; j + (k = months[i] + longyear(c->year,i)) < doy; ++i)
	1859	j += k;
	1860	c->month = i;
	1861	c->day = doy - j;
	1862	}
	1863
[318]	1864	#ifndef NO_RTCM3_MAIN
	1865	void RTCM3Error(const char *fmt, ...)
	1866	{
	1867	va_list v;
	1868	va_start(v, fmt);
	1869	vfprintf(stderr, fmt, v);
	1870	va_end(v);
	1871	}
	1872	#endif
	1873
	1874	void RTCM3Text(const char *fmt, ...)
	1875	{
	1876	va_list v;
	1877	va_start(v, fmt);
	1878	vprintf(fmt, v);
	1879	va_end(v);
	1880	}
	1881
[2487]	1882	static void fixrevision(void)
	1883	{
	1884	if(revisionstr[0] == '$')
	1885	{
	1886	char *a;
	1887	int i=sizeof(RTCM3TORINEX_VERSION); /* set version to 1.<revision> */
	1888	strcpy(revisionstr, RTCM3TORINEX_VERSION ".");
	1889	for(a = revisionstr+11; a && a != ' '; ++a)
	1890	revisionstr[i++] = *a;
	1891	revisionstr[i] = 0;
	1892	}
	1893	}
	1894
[503]	1895	static int HandleRunBy(char buffer, int buffersize, const char *u,
	1896	int rinex3)
[502]	1897	{
	1898	const char *user;
	1899	time_t t;
	1900	struct tm * t2;
	1901
	1902	#ifdef NO_RTCM3_MAIN
[2487]	1903	fixrevision();
[502]	1904	#endif
	1905
	1906	user= getenv("USER");
	1907	if(!user) user = "";
	1908	t = time(&t);
	1909	t2 = gmtime(&t);
	1910	if(u) *u = user;
	1911	return 1+snprintf(buffer, buffersize,
[1088]	1912	rinex3 ?
[4371]	1913	"RTCM3TORINEX %-7.7s%-20.20s%04d%02d%02d %02d%02d%02d UTC "
[503]	1914	"PGM / RUN BY / DATE" :
[4371]	1915	"RTCM3TORINEX %-7.7s%-20.20s%04d-%02d-%02d %02d:%02d "
[502]	1916	"PGM / RUN BY / DATE", revisionstr, user, 1900+t2->tm_year,
[503]	1917	t2->tm_mon+1, t2->tm_mday, t2->tm_hour, t2->tm_min, t2->tm_sec);
[502]	1918	}
	1919
[1092]	1920	#ifdef NO_RTCM3_MAIN
	1921	#define NUMSTARTSKIP 1
	1922	#else
[318]	1923	#define NUMSTARTSKIP 3
[1092]	1924	#endif
	1925
[5358]	1926	int HandleObsHeader(struct RTCM3ParserData Parser, char buffer,
	1927	size_t buffersize, struct HeaderData *hdata)
[27]	1928	{
[5358]	1929	int buffersizeold = buffersize;
	1930	int i, modified = 0;
	1931
[1092]	1932	if(Parser->rinex3)
	1933	{
[5358]	1934	int flags;
[1092]	1935	#define CHECKFLAGSNEW(a, b, c) \
[5358]	1936	if(flags & GNSSDF_##b##DATA) \
[1092]	1937	{ \
[5358]	1938	int new = hdata ? 1 : 0; \
	1939	if(!hdata) /* check if already known */ \
[1092]	1940	{ \
[5358]	1941	int ic; \
	1942	for(ic = 0; ic < Parser->info[RTCM3_MSM_##a].numtypes \
	1943	&& Parser->info[RTCM3_MSM_##a].flags[ic] != GNSSDF_##b##DATA; ++ic) \
	1944	; \
	1945	if(ic == Parser->info[RTCM3_MSM_##a].numtypes) \
	1946	new = 1; \
[1092]	1947	} \
[5358]	1948	if(new) \
[1092]	1949	{ \
[5358]	1950	Parser->info[RTCM3_MSM_##a].flags[Parser->info[RTCM3_MSM_##a].numtypes] \
	1951	= GNSSDF_##b##DATA; \
	1952	Parser->info[RTCM3_MSM_##a].pos[Parser->info[RTCM3_MSM_##a].numtypes] \
	1953	= GNSSENTRY_##b##DATA; \
	1954	if(Parser->info[RTCM3_MSM_##a].type[GNSSENTRY_##b##DATA]) \
	1955	{ \
	1956	snprintf(Parser->fieldbuffer##a+4*Parser->info[RTCM3_MSM_##a].numtypes, \
	1957	sizeof(Parser->fieldbuffer##a)-4*Parser->info[RTCM3_MSM_##a].numtypes, \
	1958	" %-2.2s%c", #c, Parser->info[RTCM3_MSM_##a].type[GNSSENTRY_##b##DATA]); \
	1959	} \
	1960	else \
	1961	{ \
	1962	snprintf(Parser->fieldbuffer##a+4*Parser->info[RTCM3_MSM_##a].numtypes, \
	1963	sizeof(Parser->fieldbuffer##a)-4*Parser->info[RTCM3_MSM_##a].numtypes, \
	1964	" %-3s", #c); \
	1965	} \
	1966	++Parser->info[RTCM3_MSM_##a].numtypes; \
	1967	++modified; \
[1092]	1968	} \
	1969	}
	1970
[5358]	1971	#define INITFLAGS(a) \
	1972	flags = Parser->startflags; \
	1973	modified = 0; \
	1974	for(i = 0; i < Parser->Data.numsats; ++i) \
[502]	1975	{ \
[5358]	1976	if(Parser->Data.satellites[i] >= PRN_##a##_START \
	1977	&& Parser->Data.satellites[i] <= PRN_##a##_END) \
	1978	flags \|= Parser->Data.dataflags[i]; \
[502]	1979	}
	1980
[5358]	1981	INITFLAGS(SBAS)
[4371]	1982	CHECKFLAGSNEW(SBAS, C1, C1C)
	1983	CHECKFLAGSNEW(SBAS, L1C, L1C)
	1984	CHECKFLAGSNEW(SBAS, D1C, D1C)
	1985	CHECKFLAGSNEW(SBAS, S1C, S1C)
	1986	CHECKFLAGSNEW(SBAS, C5, C5)
	1987	CHECKFLAGSNEW(SBAS, L5, L5)
	1988	CHECKFLAGSNEW(SBAS, D5, D5)
	1989	CHECKFLAGSNEW(SBAS, S5, S5)
	1990
[5358]	1991	if(modified)
	1992	{
	1993	if(hdata)
	1994	hdata->data.named.typesofobsS = buffer;
	1995	i = 1+snprintf(buffer, buffersize,
	1996	"S %3d%-52.52s SYS / # / OBS TYPES",
	1997	Parser->info[RTCM3_MSM_SBAS].numtypes, Parser->fieldbufferSBAS);
	1998	buffer += i; buffersize -= i;
	1999	}
[4371]	2000
[5358]	2001	INITFLAGS(GPS)
[502]	2002	CHECKFLAGSNEW(GPS, C1, C1C)
	2003	CHECKFLAGSNEW(GPS, L1C, L1C)
	2004	CHECKFLAGSNEW(GPS, D1C, D1C)
	2005	CHECKFLAGSNEW(GPS, S1C, S1C)
[2699]	2006	CHECKFLAGSNEW(GPS, P1, C1W)
	2007	CHECKFLAGSNEW(GPS, L1P, L1W)
	2008	CHECKFLAGSNEW(GPS, D1P, D1W)
	2009	CHECKFLAGSNEW(GPS, S1P, S1W)
[4367]	2010	CHECKFLAGSNEW(GPS, C5, C5)
	2011	CHECKFLAGSNEW(GPS, L5, L5)
	2012	CHECKFLAGSNEW(GPS, D5, D5)
	2013	CHECKFLAGSNEW(GPS, S5, S5)
[4383]	2014	CHECKFLAGSNEW(GPS, P2, C2W)
	2015	CHECKFLAGSNEW(GPS, L2P, L2W)
	2016	CHECKFLAGSNEW(GPS, D2P, D2W)
	2017	CHECKFLAGSNEW(GPS, S2P, S2W)
	2018	CHECKFLAGSNEW(GPS, C2, C2)
	2019	CHECKFLAGSNEW(GPS, L2C, L2)
	2020	CHECKFLAGSNEW(GPS, D2C, D2)
	2021	CHECKFLAGSNEW(GPS, S2C, S2)
[4371]	2022	CHECKFLAGSNEW(GPS, C1N, C1)
	2023	CHECKFLAGSNEW(GPS, L1N, L1)
	2024	CHECKFLAGSNEW(GPS, D1N, D1)
	2025	CHECKFLAGSNEW(GPS, S1N, S1)
[502]	2026
[5358]	2027	if(modified)
[502]	2028	{
[5358]	2029	if(hdata)
	2030	hdata->data.named.typesofobsG = buffer;
	2031	i = 1+snprintf(buffer, buffersize,
	2032	"G %3d%-52.52s SYS / # / OBS TYPES",
	2033	Parser->info[RTCM3_MSM_GPS].numtypes, Parser->fieldbufferGPS);
	2034	if(Parser->info[RTCM3_MSM_GPS].numtypes>13)
	2035	{
	2036	i += snprintf(buffer+i-1, buffersize,
	2037	"\n %-52.52s SYS / # / OBS TYPES", Parser->fieldbufferGPS+13*4);
	2038	}
	2039	buffer += i; buffersize -= i;
[502]	2040	}
	2041
[5358]	2042	INITFLAGS(GLONASS)
[4371]	2043	CHECKFLAGSNEW(GLONASS, C1, C1C)
	2044	CHECKFLAGSNEW(GLONASS, L1C, L1C)
	2045	CHECKFLAGSNEW(GLONASS, D1C, D1C)
	2046	CHECKFLAGSNEW(GLONASS, S1C, S1C)
	2047	CHECKFLAGSNEW(GLONASS, P1, C1P)
	2048	CHECKFLAGSNEW(GLONASS, L1P, L1P)
	2049	CHECKFLAGSNEW(GLONASS, D1P, D1P)
	2050	CHECKFLAGSNEW(GLONASS, S1P, S1P)
	2051	CHECKFLAGSNEW(GLONASS, P2, C2P)
	2052	CHECKFLAGSNEW(GLONASS, L2P, L2P)
	2053	CHECKFLAGSNEW(GLONASS, D2P, D2P)
	2054	CHECKFLAGSNEW(GLONASS, S2P, S2P)
	2055	CHECKFLAGSNEW(GLONASS, C2, C2C)
	2056	CHECKFLAGSNEW(GLONASS, L2C, L2C)
	2057	CHECKFLAGSNEW(GLONASS, D2C, D2C)
	2058	CHECKFLAGSNEW(GLONASS, S2C, S2C)
[502]	2059
[5358]	2060	if(modified)
[502]	2061	{
[5358]	2062	if(hdata)
	2063	hdata->data.named.typesofobsR = buffer;
	2064	i = 1+snprintf(buffer, buffersize,
	2065	"R %3d%-52.52s SYS / # / OBS TYPES",
	2066	Parser->info[RTCM3_MSM_GLONASS].numtypes, Parser->fieldbufferGLONASS);
	2067	if(Parser->info[RTCM3_MSM_GLONASS].numtypes>13)
	2068	{
	2069	i += snprintf(buffer+i-1, buffersize,
	2070	"\n %-52.52s SYS / # / OBS TYPES", Parser->fieldbufferGLONASS+13*4);
	2071	}
	2072	buffer += i; buffersize -= i;
[502]	2073	}
[2699]	2074
[5358]	2075	INITFLAGS(GALGIO)
[4371]	2076	CHECKFLAGSNEW(GALILEO, C1, C1)
	2077	CHECKFLAGSNEW(GALILEO, L1C, L1)
	2078	CHECKFLAGSNEW(GALILEO, D1C, D1)
	2079	CHECKFLAGSNEW(GALILEO, S1C, S1)
	2080	CHECKFLAGSNEW(GALILEO, C6, C6)
	2081	CHECKFLAGSNEW(GALILEO, L6, L6)
	2082	CHECKFLAGSNEW(GALILEO, D6, D6)
	2083	CHECKFLAGSNEW(GALILEO, S6, S6)
	2084	CHECKFLAGSNEW(GALILEO, C5, C5)
	2085	CHECKFLAGSNEW(GALILEO, L5, L5)
	2086	CHECKFLAGSNEW(GALILEO, D5, D5)
	2087	CHECKFLAGSNEW(GALILEO, S5, S5)
	2088	CHECKFLAGSNEW(GALILEO, C5B, C7)
	2089	CHECKFLAGSNEW(GALILEO, L5B, L7)
	2090	CHECKFLAGSNEW(GALILEO, D5B, D7)
	2091	CHECKFLAGSNEW(GALILEO, S5B, S7)
	2092	CHECKFLAGSNEW(GALILEO, C5AB, C8)
	2093	CHECKFLAGSNEW(GALILEO, L5AB, L8)
	2094	CHECKFLAGSNEW(GALILEO, D5AB, D8)
	2095	CHECKFLAGSNEW(GALILEO, S5AB, S8)
[2699]	2096
[5358]	2097	if(modified)
[2699]	2098	{
[5358]	2099	if(hdata)
	2100	hdata->data.named.typesofobsE = buffer;
	2101	i = 1+snprintf(buffer, buffersize,
	2102	"E %3d%-52.52s SYS / # / OBS TYPES",
	2103	Parser->info[RTCM3_MSM_GALILEO].numtypes, Parser->fieldbufferGALILEO);
	2104	if(Parser->info[RTCM3_MSM_GALILEO].numtypes>13)
	2105	{
	2106	i += snprintf(buffer+i-1, buffersize,
	2107	"\n %-52.52s SYS / # / OBS TYPES", Parser->fieldbufferGALILEO+13*4);
	2108	}
	2109	buffer += i; buffersize -= i;
[2699]	2110	}
[4367]	2111
[5358]	2112	INITFLAGS(COMPASS)
[4371]	2113	CHECKFLAGSNEW(COMPASS, CB1, C2I)
	2114	CHECKFLAGSNEW(COMPASS, LB1, L2I)
	2115	CHECKFLAGSNEW(COMPASS, DB1, D2I)
	2116	CHECKFLAGSNEW(COMPASS, SB1, S2I)
	2117	CHECKFLAGSNEW(COMPASS, CB2, C7I)
	2118	CHECKFLAGSNEW(COMPASS, LB2, L7I)
	2119	CHECKFLAGSNEW(COMPASS, DB2, D7I)
	2120	CHECKFLAGSNEW(COMPASS, SB2, S7I)
	2121	CHECKFLAGSNEW(COMPASS, CB3, C6I)
	2122	CHECKFLAGSNEW(COMPASS, LB3, L6I)
	2123	CHECKFLAGSNEW(COMPASS, DB3, D6I)
	2124	CHECKFLAGSNEW(COMPASS, SB3, S6I)
[4367]	2125
[5358]	2126	if(modified)
[4367]	2127	{
[5358]	2128	if(hdata)
	2129	hdata->data.named.typesofobsC = buffer;
	2130	i = 1+snprintf(buffer, buffersize,
	2131	"C %3d%-52.52s SYS / # / OBS TYPES",
	2132	Parser->info[RTCM3_MSM_COMPASS].numtypes, Parser->fieldbufferCOMPASS);
	2133	if(Parser->info[RTCM3_MSM_COMPASS].numtypes>13)
	2134	{
	2135	i += snprintf(buffer+i-1, buffersize,
	2136	"\n %-52.52s SYS / # / OBS TYPES", Parser->fieldbufferCOMPASS+13*4);
	2137	}
	2138	buffer += i; buffersize -= i;
[4367]	2139	}
	2140
[5358]	2141	INITFLAGS(QZSS)
[4367]	2142
[4371]	2143	CHECKFLAGSNEW(QZSS, C1, C1C)
	2144	CHECKFLAGSNEW(QZSS, L1C, L1C)
	2145	CHECKFLAGSNEW(QZSS, D1C, D1C)
	2146	CHECKFLAGSNEW(QZSS, S1C, S1C)
[4367]	2147
[4371]	2148	CHECKFLAGSNEW(QZSS, CSAIF, C1Z)
	2149	CHECKFLAGSNEW(QZSS, LSAIF, L1Z)
	2150	CHECKFLAGSNEW(QZSS, DSAIF, D1Z)
	2151	CHECKFLAGSNEW(QZSS, SSAIF, S1Z)
[4367]	2152
[4371]	2153	CHECKFLAGSNEW(QZSS, C1N, C1)
	2154	CHECKFLAGSNEW(QZSS, L1N, L1)
	2155	CHECKFLAGSNEW(QZSS, D1N, D1)
	2156	CHECKFLAGSNEW(QZSS, S1N, S1)
[4367]	2157
[4371]	2158	CHECKFLAGSNEW(QZSS, C6, C6)
	2159	CHECKFLAGSNEW(QZSS, L6, L6)
	2160	CHECKFLAGSNEW(QZSS, D6, D6)
	2161	CHECKFLAGSNEW(QZSS, S6, S6)
[4367]	2162
[4371]	2163	CHECKFLAGSNEW(QZSS, C2, C2)
	2164	CHECKFLAGSNEW(QZSS, L2C, L2)
	2165	CHECKFLAGSNEW(QZSS, D2C, D2)
	2166	CHECKFLAGSNEW(QZSS, S2C, S2)
[4367]	2167
[4371]	2168	CHECKFLAGSNEW(QZSS, C5, C5)
	2169	CHECKFLAGSNEW(QZSS, L5, L5)
	2170	CHECKFLAGSNEW(QZSS, D5, D5)
	2171	CHECKFLAGSNEW(QZSS, S5, S5)
[4367]	2172
[5358]	2173	if(modified)
[4367]	2174	{
[5358]	2175	if(hdata)
	2176	hdata->data.named.typesofobsJ = buffer;
	2177	i = 1+snprintf(buffer, buffersize,
	2178	"J %3d%-52.52s SYS / # / OBS TYPES",
	2179	Parser->info[RTCM3_MSM_QZSS].numtypes, Parser->fieldbufferQZSS);
	2180	if(Parser->info[RTCM3_MSM_QZSS].numtypes>13)
	2181	{
	2182	i += snprintf(buffer+i-1, buffersize,
	2183	"\n %-52.52s SYS / # / OBS TYPES", Parser->fieldbufferQZSS+13*4);
	2184	}
	2185	buffer += i; buffersize -= i;
[4367]	2186	}
[502]	2187	}
	2188	else
	2189	{
[27]	2190	#define CHECKFLAGS(a, b) \
[363]	2191	if(flags & GNSSDF_##a##DATA) \
[27]	2192	{ \
[5358]	2193	if(Parser->datafields[RINEXENTRY_##b##DATA]) \
[363]	2194	{ \
[5358]	2195	Parser->info[RTCM3_MSM_GPS].flags[Parser->datafields[\
	2196	RINEXENTRY_##b##DATA]-1] = GNSSDF_##a##DATA; \
	2197	Parser->info[RTCM3_MSM_GPS].pos[Parser->datafields[\
	2198	RINEXENTRY_##b##DATA]-1] = GNSSENTRY_##a##DATA; \
[363]	2199	} \
	2200	else \
	2201	{ \
[4371]	2202	Parser->flags[Parser->info[RTCM3_MSM_GPS].numtypes] = GNSSDF_##a##DATA; \
	2203	Parser->pos[Parser->info[RTCM3_MSM_GPS].numtypes] = GNSSENTRY_##a##DATA; \
[5358]	2204	Parser->datafields[RINEXENTRY_##b##DATA] = \
	2205	++Parser->info[RTCM3_MSM_GPS].numtypes; \
	2206	snprintf(Parser->fieldbuffer+6*Parser->numdatafields, \
	2207	sizeof(Parser->fieldbuffer)-6*Parser->numdatafields, " "#b); \
	2208	++Parser->numdatafields; \
	2209	++modified; \
[363]	2210	} \
[27]	2211	}
	2212
[318]	2213	int flags = Parser->startflags;
[27]	2214	for(i = 0; i < Parser->Data.numsats; ++i)
	2215	flags \|= Parser->Data.dataflags[i];
	2216
	2217	CHECKFLAGS(C1,C1)
	2218	CHECKFLAGS(C2,C2)
	2219	CHECKFLAGS(P1,P1)
	2220	CHECKFLAGS(P2,P2)
	2221	CHECKFLAGS(L1C,L1)
	2222	CHECKFLAGS(L1P,L1)
	2223	CHECKFLAGS(L2C,L2)
	2224	CHECKFLAGS(L2P,L2)
	2225	CHECKFLAGS(D1C,D1)
	2226	CHECKFLAGS(D1P,D1)
	2227	CHECKFLAGS(D2C,D2)
	2228	CHECKFLAGS(D2P,D2)
	2229	CHECKFLAGS(S1C,S1)
	2230	CHECKFLAGS(S1P,S1)
	2231	CHECKFLAGS(S2C,S2)
	2232	CHECKFLAGS(S2P,S2)
[2659]	2233	CHECKFLAGS(C5,C5)
	2234	CHECKFLAGS(L5,L5)
	2235	CHECKFLAGS(D5,D5)
	2236	CHECKFLAGS(S5,S5)
[4367]	2237	CHECKFLAGS(C5AB,C8)
	2238	CHECKFLAGS(L5AB,L8)
	2239	CHECKFLAGS(D5AB,D8)
	2240	CHECKFLAGS(S5AB,S8)
	2241	CHECKFLAGS(C5B,C7)
	2242	CHECKFLAGS(L5B,L7)
	2243	CHECKFLAGS(D5B,D7)
	2244	CHECKFLAGS(S5B,S7)
[2659]	2245	CHECKFLAGS(C6,C6)
	2246	CHECKFLAGS(L6,L6)
	2247	CHECKFLAGS(D6,D6)
	2248	CHECKFLAGS(S6,S6)
[4369]	2249	/* Skip C1N and SAIF for RINEX2! */
[27]	2250
[5358]	2251	if(hdata)
	2252	hdata->data.named.typesofobs = buffer;
	2253	if(modified)
[27]	2254	{
[5358]	2255	i = 1+snprintf(buffer, buffersize,
	2256	"%6d%-54.54s# / TYPES OF OBSERV", Parser->info[RTCM3_MSM_GPS].numtypes,
	2257	Parser->fieldbuffer);
	2258	if(Parser->info[RTCM3_MSM_GPS].numtypes>9)
	2259	{
	2260	i += snprintf(buffer+i-1, buffersize,
	2261	"\n %-54.54s# / TYPES OF OBSERV", Parser->fieldbuffer+9*6);
	2262	}
	2263	if(Parser->info[RTCM3_MSM_GPS].numtypes>18)
	2264	{
	2265	i += snprintf(buffer+i-1, buffersize,
	2266	"\n %-54.54s# / TYPES OF OBSERV", Parser->fieldbuffer+18*6);
	2267	}
	2268	buffer += i; buffersize -= i;
[27]	2269	}
[5358]	2270	}
	2271	return buffersizeold - buffersize;
	2272	}
	2273
	2274	void HandleHeader(struct RTCM3ParserData *Parser)
	2275	{
	2276	#ifdef NO_RTCM3_MAIN
[5363]	2277	int flags, modified = 0;
[5358]	2278	if(Parser->allflags == 0)
	2279	Parser->allflags = ~0;
[5363]	2280	flags = Parser->allflags;
[5358]	2281	if(Parser->rinex3)
	2282	{
[5360]	2283	struct HeaderData *hdata = 0;
[5358]	2284	CHECKFLAGSNEW(GPS, C1, C1C)
	2285	CHECKFLAGSNEW(GPS, L1C, L1C)
	2286	CHECKFLAGSNEW(GPS, D1C, D1C)
	2287	CHECKFLAGSNEW(GPS, S1C, S1C)
	2288	CHECKFLAGSNEW(GPS, P1, C1P)
	2289	CHECKFLAGSNEW(GPS, L1P, L1P)
	2290	CHECKFLAGSNEW(GPS, D1P, D1P)
	2291	CHECKFLAGSNEW(GPS, S1P, S1P)
	2292	CHECKFLAGSNEW(GPS, P2, C2P)
	2293	CHECKFLAGSNEW(GPS, L2P, L2P)
	2294	CHECKFLAGSNEW(GPS, D2P, D2P)
	2295	CHECKFLAGSNEW(GPS, S2P, S2P)
	2296	CHECKFLAGSNEW(GPS, C2, C2X)
	2297	CHECKFLAGSNEW(GPS, L2C, L2X)
	2298	CHECKFLAGSNEW(GPS, D2C, D2X)
	2299	CHECKFLAGSNEW(GPS, S2C, S2X)
	2300	CHECKFLAGSNEW(GLONASS, C1, C1C)
	2301	CHECKFLAGSNEW(GLONASS, L1C, L1C)
	2302	CHECKFLAGSNEW(GLONASS, D1C, D1C)
	2303	CHECKFLAGSNEW(GLONASS, S1C, S1C)
	2304	CHECKFLAGSNEW(GLONASS, P1, C1P)
	2305	CHECKFLAGSNEW(GLONASS, L1P, L1P)
	2306	CHECKFLAGSNEW(GLONASS, D1P, D1P)
	2307	CHECKFLAGSNEW(GLONASS, S1P, S1P)
	2308	CHECKFLAGSNEW(GLONASS, P2, C2P)
	2309	CHECKFLAGSNEW(GLONASS, L2P, L2P)
	2310	CHECKFLAGSNEW(GLONASS, D2P, D2P)
	2311	CHECKFLAGSNEW(GLONASS, S2P, S2P)
	2312	CHECKFLAGSNEW(GLONASS, C2, C2C)
	2313	CHECKFLAGSNEW(GLONASS, L2C, L2C)
	2314	CHECKFLAGSNEW(GLONASS, D2C, D2C)
	2315	CHECKFLAGSNEW(GLONASS, S2C, S2C)
	2316	}
	2317	else
	2318	{
	2319	CHECKFLAGS(C1,C1)
	2320	CHECKFLAGS(C2,C2)
	2321	CHECKFLAGS(P1,P1)
	2322	CHECKFLAGS(P2,P2)
	2323	CHECKFLAGS(L1C,L1)
	2324	CHECKFLAGS(L1P,L1)
	2325	CHECKFLAGS(L2C,L2)
	2326	CHECKFLAGS(L2P,L2)
	2327	CHECKFLAGS(D1C,D1)
	2328	CHECKFLAGS(D1P,D1)
	2329	CHECKFLAGS(D2C,D2)
	2330	CHECKFLAGS(D2P,D2)
	2331	CHECKFLAGS(S1C,S1)
	2332	CHECKFLAGS(S1P,S1)
	2333	CHECKFLAGS(S2C,S2)
	2334	CHECKFLAGS(S2P,S2)
	2335	CHECKFLAGS(C5,C5)
	2336	CHECKFLAGS(L5,L5)
	2337	CHECKFLAGS(D5,D5)
	2338	CHECKFLAGS(S5,S5)
	2339	CHECKFLAGS(C5AB,C8)
	2340	CHECKFLAGS(L5AB,L8)
	2341	CHECKFLAGS(D5AB,D8)
	2342	CHECKFLAGS(S5AB,S8)
	2343	CHECKFLAGS(C5B,C7)
	2344	CHECKFLAGS(L5B,L7)
	2345	CHECKFLAGS(D5B,D7)
	2346	CHECKFLAGS(S5B,S7)
	2347	CHECKFLAGS(C6,C6)
	2348	CHECKFLAGS(L6,L6)
	2349	CHECKFLAGS(D6,D6)
	2350	CHECKFLAGS(S6,S6)
	2351	}
	2352	#else /* NO_RTCM3_MAIN */
	2353	struct HeaderData hdata;
	2354	char thebuffer[MAXHEADERBUFFERSIZE];
	2355	char *buffer = thebuffer;
	2356	size_t buffersize = sizeof(thebuffer);
	2357	int i;
	2358
	2359	memset(&hdata, 0, sizeof(hdata));
	2360
	2361	hdata.data.named.version = buffer;
	2362	i = 1+snprintf(buffer, buffersize,
	2363	"%9.2f OBSERVATION DATA M (Mixed)"
	2364	" RINEX VERSION / TYPE", Parser->rinex3 ? 3.0 : 2.11);
	2365	buffer += i; buffersize -= i;
	2366
	2367	{
	2368	const char *str;
	2369	hdata.data.named.pgm = buffer;
	2370	i = HandleRunBy(buffer, buffersize, &str, Parser->rinex3);
[27]	2371	buffer += i; buffersize -= i;
[5358]	2372	hdata.data.named.observer = buffer;
	2373	i = 1+snprintf(buffer, buffersize,
	2374	"%-20.20s "
	2375	"OBSERVER / AGENCY", str);
	2376	buffer += i; buffersize -= i;
[27]	2377	}
	2378
[5358]	2379	hdata.data.named.marker =
	2380	"RTCM3TORINEX "
	2381	"MARKER NAME";
	2382
	2383	hdata.data.named.markertype = !Parser->rinex3 ? 0 :
	2384	"GEODETIC "
	2385	"MARKER TYPE";
	2386
	2387	hdata.data.named.receiver =
	2388	" "
	2389	"REC # / TYPE / VERS";
	2390
	2391	hdata.data.named.antenna =
	2392	" "
	2393	"ANT # / TYPE";
	2394
	2395	hdata.data.named.position =
	2396	" .0000 .0000 .0000 "
	2397	"APPROX POSITION XYZ";
	2398
	2399	hdata.data.named.antennaposition =
	2400	" .0000 .0000 .0000 "
	2401	"ANTENNA: DELTA H/E/N";
	2402
	2403	hdata.data.named.wavelength = Parser->rinex3 ? 0 :
	2404	" 1 1 "
	2405	"WAVELENGTH FACT L1/2";
	2406
	2407	hdata.numheaders = 18;
	2408
	2409	i = HandleObsHeader(Parser, buffer, buffersize, &hdata);
	2410	buffer += i; buffersize -= i;
	2411
[27]	2412	{
	2413	struct converttimeinfo cti;
	2414	converttime(&cti, Parser->Data.week,
[268]	2415	(int)floor(Parser->Data.timeofweek/1000.0));
[27]	2416	hdata.data.named.timeoffirstobs = buffer;
[502]	2417	i = 1+snprintf(buffer, buffersize,
[27]	2418	" %4d %2d %2d %2d %2d %10.7f GPS "
[378]	2419	"TIME OF FIRST OBS", cti.year, cti.month, cti.day, cti.hour,
[27]	2420	cti.minute, cti.second + fmod(Parser->Data.timeofweek/1000.0,1.0));
	2421
	2422	buffer += i; buffersize -= i;
	2423	}
	2424
	2425	if(Parser->headerfile)
	2426	{
	2427	FILE *fh;
	2428	if((fh = fopen(Parser->headerfile, "r")))
	2429	{
[318]	2430	size_t siz;
[27]	2431	char *lastblockstart;
	2432	if((siz = fread(buffer, 1, buffersize-1, fh)) > 0)
	2433	{
	2434	buffer[siz] = '\n';
	2435	if(siz == buffersize)
	2436	{
[318]	2437	RTCM3Error("Header file is too large. Only %d bytes read.",
[364]	2438	(int)siz);
[27]	2439	}
	2440	/* scan the file line by line and enter the entries in the list */
	2441	/* warn for "# / TYPES OF OBSERV" and "TIME OF FIRST OBS" */
	2442	/* overwrites entries, except for comments */
	2443	lastblockstart = buffer;
[318]	2444	for(i = 0; i < (int)siz; ++i)
[27]	2445	{
	2446	if(buffer[i] == '\n')
	2447	{ /* we found a line */
	2448	char *end;
	2449	while(buffer[i+1] == '\r')
	2450	++i; /* skip \r in case there are any */
	2451	end = buffer+i;
	2452	while(end == '\t' \|\| end == ' ' \|\| end == '\r' \|\| end == '\n')
	2453	*(end--) = 0;
	2454	if(end-lastblockstart < 60+5) /* short line */
[318]	2455	RTCM3Error("Short Header line '%s' ignored.\n", lastblockstart);
[27]	2456	else
	2457	{
	2458	int pos;
	2459	if(!strcmp("COMMENT", lastblockstart+60))
	2460	pos = hdata.numheaders;
	2461	else
	2462	{
	2463	for(pos = 0; pos < hdata.numheaders; ++pos)
	2464	{
[5658]	2465	if(hdata.data.unnamed[pos] &&
	2466	!strcmp(hdata.data.unnamed[pos]+60, lastblockstart+60))
[27]	2467	break;
	2468	}
	2469	if(!strcmp("# / TYPES OF OBSERV", lastblockstart+60)
[5658]	2470	\|\| !strcmp("SYS / # / OBS TYPES", lastblockstart+60)
[27]	2471	\|\| !strcmp("TIME OF FIRST OBS", lastblockstart+60))
	2472	{
[318]	2473	RTCM3Error("Overwriting header '%s' is dangerous.\n",
[27]	2474	lastblockstart+60);
	2475	}
	2476	}
	2477	if(pos >= MAXHEADERLINES)
	2478	{
[318]	2479	RTCM3Error("Maximum number of header lines of %d reached.\n",
[27]	2480	MAXHEADERLINES);
	2481	}
	2482	else if(!strcmp("END OF HEADER", lastblockstart+60))
	2483	{
[318]	2484	RTCM3Error("End of header ignored.\n");
[27]	2485	}
	2486	else
	2487	{
	2488	hdata.data.unnamed[pos] = lastblockstart;
	2489	if(pos == hdata.numheaders)
	2490	++hdata.numheaders;
	2491	}
	2492	}
	2493	lastblockstart = buffer+i+1;
	2494	}
	2495	}
	2496	}
	2497	else
	2498	{
[318]	2499	RTCM3Error("Could not read data from headerfile '%s'.\n",
[27]	2500	Parser->headerfile);
	2501	}
	2502	fclose(fh);
	2503	}
	2504	else
	2505	{
[318]	2506	RTCM3Error("Could not open header datafile '%s'.\n",
[27]	2507	Parser->headerfile);
	2508	}
	2509	}
	2510
	2511	for(i = 0; i < hdata.numheaders; ++i)
[502]	2512	{
	2513	if(hdata.data.unnamed[i] && hdata.data.unnamed[i][0])
	2514	RTCM3Text("%s\n", hdata.data.unnamed[i]);
	2515	}
[318]	2516	RTCM3Text(" "
[27]	2517	"END OF HEADER\n");
[287]	2518	#endif
[27]	2519	}
	2520
[502]	2521	static void ConvLine(FILE file, const char fmt, ...)
	2522	{
	2523	char buffer[100], *b;
	2524	va_list v;
	2525	va_start(v, fmt);
	2526	vsnprintf(buffer, sizeof(buffer), fmt, v);
	2527	for(b = buffer; *b; ++b)
	2528	{
	2529	if(b == 'e') b = 'D';
	2530	}
	2531	fprintf(file, "%s", buffer);
	2532	va_end(v);
	2533	}
	2534
[268]	2535	void HandleByte(struct RTCM3ParserData *Parser, unsigned int byte)
[27]	2536	{
	2537	Parser->Message[Parser->MessageSize++] = byte;
	2538	if(Parser->MessageSize >= Parser->NeedBytes)
	2539	{
	2540	int r;
	2541	while((r = RTCM3Parser(Parser)))
	2542	{
[6329]	2543	if(r == 1020 \|\| r == 1019 \|\| r == 1044 \|\| r == 1043)
[27]	2544	{
[502]	2545	FILE *file = 0;
[318]	2546
[502]	2547	if(Parser->rinex3 && !(file = Parser->gpsfile))
	2548	{
[5595]	2549	const char *n = Parser->gpsephemeris ? Parser->gpsephemeris
	2550	: Parser->qzssephemeris ? Parser->qzssephemeris : Parser->glonassephemeris;
[502]	2551	if(n)
	2552	{
	2553	if(!(Parser->gpsfile = fopen(n, "w")))
	2554	{
	2555	RTCM3Error("Could not open ephemeris output file.\n");
	2556	}
	2557	else
	2558	{
	2559	char buffer[100];
	2560	fprintf(Parser->gpsfile,
	2561	"%9.2f%11sN: GNSS NAV DATA M: Mixed%12sRINEX VERSION / TYPE\n", 3.0, "", "");
[503]	2562	HandleRunBy(buffer, sizeof(buffer), 0, Parser->rinex3);
[502]	2563	fprintf(Parser->gpsfile, "%s\n%60sEND OF HEADER\n", buffer, "");
	2564	}
[5595]	2565	Parser->qzssephemeris = 0;
[502]	2566	Parser->gpsephemeris = 0;
	2567	Parser->glonassephemeris = 0;
[6329]	2568	Parser->sbasephemeris = 0;
[502]	2569	file = Parser->gpsfile;
	2570	}
	2571	}
[318]	2572	else
	2573	{
[502]	2574	if(r == 1020)
	2575	{
	2576	if(Parser->glonassephemeris)
	2577	{
	2578	if(!(Parser->glonassfile = fopen(Parser->glonassephemeris, "w")))
	2579	{
	2580	RTCM3Error("Could not open GLONASS ephemeris output file.\n");
	2581	}
	2582	else
	2583	{
	2584	char buffer[100];
	2585	fprintf(Parser->glonassfile,
	2586	"%9.2f%11sG: GLONASS NAV DATA%21sRINEX VERSION / TYPE\n", 2.1, "", "");
[503]	2587	HandleRunBy(buffer, sizeof(buffer), 0, Parser->rinex3);
[502]	2588	fprintf(Parser->glonassfile, "%s\n%60sEND OF HEADER\n", buffer, "");
	2589	}
	2590	Parser->glonassephemeris = 0;
	2591	}
	2592	file = Parser->glonassfile;
	2593	}
	2594	else if(r == 1019)
	2595	{
	2596	if(Parser->gpsephemeris)
	2597	{
	2598	if(!(Parser->gpsfile = fopen(Parser->gpsephemeris, "w")))
	2599	{
	2600	RTCM3Error("Could not open GPS ephemeris output file.\n");
	2601	}
	2602	else
	2603	{
	2604	char buffer[100];
	2605	fprintf(Parser->gpsfile,
	2606	"%9.2f%11sN: GPS NAV DATA%25sRINEX VERSION / TYPE\n", 2.1, "", "");
[503]	2607	HandleRunBy(buffer, sizeof(buffer), 0, Parser->rinex3);
[502]	2608	fprintf(Parser->gpsfile, "%s\n%60sEND OF HEADER\n", buffer, "");
	2609	}
	2610	Parser->gpsephemeris = 0;
	2611	}
	2612	file = Parser->gpsfile;
	2613	}
[6329]	2614	else if(r == 1043)
	2615	{
	2616	if(Parser->sbasephemeris)
	2617	{
	2618	if(!(Parser->sbasfile = fopen(Parser->sbasephemeris, "w")))
	2619	{
	2620	RTCM3Error("Could not open SBAS ephemeris output file.\n");
	2621	}
	2622	else
	2623	{
	2624	char buffer[100];
	2625	fprintf(Parser->sbasfile,
	2626	"%9.2f%11sN: SBAS NAV DATA%24sRINEX VERSION / TYPE\n", 2.1, "", "");
	2627	HandleRunBy(buffer, sizeof(buffer), 0, Parser->rinex3);
	2628	fprintf(Parser->sbasfile, "%s\n%60sEND OF HEADER\n", buffer, "");
	2629	}
	2630	Parser->sbasephemeris = 0;
	2631	}
	2632	file = Parser->sbasfile;
	2633	}
[5595]	2634	else if(r == 1044)
	2635	{
	2636	if(Parser->qzssephemeris)
	2637	{
	2638	if(!(Parser->qzssfile = fopen(Parser->qzssephemeris, "w")))
	2639	{
	2640	RTCM3Error("Could not open QZSS ephemeris output file.\n");
	2641	}
	2642	else
	2643	{
	2644	char buffer[100];
	2645	fprintf(Parser->qzssfile,
	2646	"%9.2f%11sN: QZSS NAV DATA%24sRINEX VERSION / TYPE\n", 2.1, "", "");
	2647	HandleRunBy(buffer, sizeof(buffer), 0, Parser->rinex3);
	2648	fprintf(Parser->qzssfile, "%s\n%60sEND OF HEADER\n", buffer, "");
	2649	}
	2650	Parser->qzssephemeris = 0;
	2651	}
	2652	file = Parser->qzssfile;
	2653	}
[318]	2654	}
[502]	2655	if(file)
	2656	{
[6329]	2657	const char *sep = " ";
[502]	2658	if(r == 1020)
	2659	{
	2660	struct glonassephemeris *e = &Parser->ephemerisGLONASS;
	2661	int w = e->GPSWeek, tow = e->GPSTOW, i;
	2662	struct converttimeinfo cti;
	2663
[2346]	2664	updatetime(&w, &tow, e->tb1000, 1); / Moscow - > UTC */
[502]	2665	converttime(&cti, w, tow);
	2666
	2667	i = e->tk-36060; if(i < 0) i += 86400;
	2668
	2669	if(Parser->rinex3)
[6329]	2670	{
[502]	2671	ConvLine(file, "R%02d %04d %02d %02d %02d %02d %02d%19.12e%19.12e%19.12e\n",
	2672	e->almanac_number, cti.year, cti.month, cti.day, cti.hour, cti.minute,
	2673	cti.second, -e->tau, e->gamma, (double) i);
[6329]	2674	sep = " ";
	2675	}
[502]	2676	else
[6329]	2677	{
[502]	2678	ConvLine(file, "%02d %02d %02d %02d %02d %02d%5.1f%19.12e%19.12e%19.12e\n",
	2679	e->almanac_number, cti.year%100, cti.month, cti.day, cti.hour, cti.minute,
	2680	(double) cti.second, -e->tau, e->gamma, (double) i);
[6329]	2681	}
	2682	ConvLine(file, "%s%19.12e%19.12e%19.12e%19.12e\n", sep, e->x_pos,
[502]	2683	e->x_velocity, e->x_acceleration, (e->flags & GLOEPHF_UNHEALTHY) ? 1.0 : 0.0);
[6329]	2684	ConvLine(file, "%s%19.12e%19.12e%19.12e%19.12e\n", sep, e->y_pos,
[502]	2685	e->y_velocity, e->y_acceleration, (double) e->frequency_number);
[6329]	2686	ConvLine(file, "%s%19.12e%19.12e%19.12e%19.12e\n", sep, e->z_pos,
[502]	2687	e->z_velocity, e->z_acceleration, (double) e->E);
	2688	}
[6329]	2689	else if(r == 1043)
	2690	{
	2691	struct sbasephemeris *e = &Parser->ephemerisSBAS;
	2692	struct converttimeinfo cti;
	2693	converttime(&cti, e->GPSweek_TOE, e->TOE);
	2694	if(Parser->rinex3)
	2695	{
	2696	ConvLine(file, "S%02d %04d %2d %2d %2d %2d %2d%19.12e%19.12e%19.12e\n",
	2697	e->satellite-100, cti.year, cti.month, cti.day, cti.hour, cti.minute,
	2698	cti.second, e->agf0, e->agf1, (double)e->TOW);
	2699	sep = " ";
	2700	}
	2701	else
	2702	{
	2703	ConvLine(file, "%02d %02d %02d %02d %02d %02d%5.1f%19.12e%19.12e%19.12e\n",
	2704	e->satellite-100, cti.year%100, cti.month, cti.day, cti.hour, cti.minute,
	2705	(double)cti.second, e->agf0, e->agf1, (double)e->TOW);
	2706	}
	2707	/* X, health */
	2708	ConvLine(file, "%s%19.12e%19.12e%19.12e%19.12e\n", sep, e->x_pos,
	2709	e->x_velocity, e->x_acceleration, e->URA == 15 ? 1.0 : 0.0);
	2710	/* Y, accuracy */
	2711	ConvLine(file, "%s%19.12e%19.12e%19.12e%19.12e\n", sep, e->y_pos,
	2712	e->y_velocity, e->y_acceleration, (double)e->URA);
	2713	/* Z */
	2714	ConvLine(file, "%s%19.12e%19.12e%19.12e%19.12e\n", sep, e->z_pos,
	2715	e->z_velocity, e->z_acceleration, (double)e->IODN);
	2716	}
[5595]	2717	else /* if(r == 1019 \|\| r == 1044) */
[502]	2718	{
	2719	struct gpsephemeris *e = &Parser->ephemerisGPS;
	2720	double d; /* temporary variable */
	2721	unsigned long int i; /* temporary variable */
	2722	struct converttimeinfo cti;
	2723	converttime(&cti, e->GPSweek, e->TOC);
[5595]	2724	int qzss = 0;
	2725	int num = e->satellite;
[502]	2726
[5595]	2727	if(num >= PRN_QZSS_START)
	2728	{
	2729	qzss = 1;
	2730	num -= PRN_QZSS_START-1;
	2731	}
[502]	2732	if(Parser->rinex3)
[5595]	2733	{
	2734	ConvLine(file,
	2735	"%s%02d %04d %02d %02d %02d %02d %02d%19.12e%19.12e%19.12e\n",
	2736	qzss ? "J" : "G", num, cti.year, cti.month, cti.day, cti.hour,
[502]	2737	cti.minute, cti.second, e->clock_bias, e->clock_drift,
	2738	e->clock_driftrate);
[5595]	2739	sep = " ";
	2740	}
[502]	2741	else
[5595]	2742	{
	2743	ConvLine(file,
	2744	"%02d %02d %02d %02d %02d %02d%05.1f%19.12e%19.12e%19.12e\n",
	2745	num, cti.year%100, cti.month, cti.day, cti.hour,
[502]	2746	cti.minute, (double) cti.second, e->clock_bias, e->clock_drift,
	2747	e->clock_driftrate);
[5595]	2748	}
	2749	ConvLine(file, "%s%19.12e%19.12e%19.12e%19.12e\n", sep,
	2750	(double)e->IODE, e->Crs, e->Delta_n, e->M0);
	2751	ConvLine(file, "%s%19.12e%19.12e%19.12e%19.12e\n", sep, e->Cuc,
[502]	2752	e->e, e->Cus, e->sqrt_A);
[5595]	2753	ConvLine(file, "%s%19.12e%19.12e%19.12e%19.12e\n", sep,
[502]	2754	(double) e->TOE, e->Cic, e->OMEGA0, e->Cis);
[5595]	2755	ConvLine(file, "%s%19.12e%19.12e%19.12e%19.12e\n", sep, e->i0,
[502]	2756	e->Crc, e->omega, e->OMEGADOT);
	2757	d = 0;
	2758	i = e->flags;
	2759	if(i & GPSEPHF_L2CACODE)
	2760	d += 2.0;
	2761	if(i & GPSEPHF_L2PCODE)
	2762	d += 1.0;
[5595]	2763	ConvLine(file, "%s%19.12e%19.12e%19.12e%19.12e\n", sep, e->IDOT, d,
[502]	2764	(double) e->GPSweek, i & GPSEPHF_L2PCODEDATA ? 1.0 : 0.0);
	2765	if(e->URAindex <= 6) /* URA index */
	2766	d = ceil(10.0*pow(2.0, 1.0+((double)e->URAindex)/2.0))/10.0;
	2767	else
	2768	d = ceil(10.0*pow(2.0, ((double)e->URAindex)/2.0))/10.0;
	2769	/* 15 indicates not to use satellite. We can't handle this special
	2770	case, so we create a high "non"-accuracy value. */
[5595]	2771	ConvLine(file, "%s%19.12e%19.12e%19.12e%19.12e\n", sep, d,
[502]	2772	((double) e->SVhealth), e->TGD, ((double) e->IODC));
	2773
[5595]	2774	ConvLine(file, "%s%19.12e%19.12e\n", sep, ((double)e->TOW),
	2775	(i & GPSEPHF_6HOURSFIT) ? (Parser->rinex3 ? 1 : qzss ? 4.0 : 6.0)
	2776	: (Parser->rinex3 ? 0 : qzss ? 2.0 : 4.0));
[502]	2777	/* TOW */
	2778	}
	2779	}
[27]	2780	}
[2507]	2781	else if (r == 1 \|\| r == 2)
[27]	2782	{
[5553]	2783	int i, j, o, nh=0, hl=2;
[5358]	2784	char newheader[512];
[502]	2785	struct converttimeinfo cti;
[27]	2786
[5358]	2787	/* skip first epochs to detect correct data types */
	2788	if(Parser->init < (Parser->changeobs ? 1 : NUMSTARTSKIP))
[27]	2789	{
[502]	2790	++Parser->init;
	2791
[5358]	2792	if(Parser->init == (Parser->changeobs ? 1 : NUMSTARTSKIP))
[502]	2793	HandleHeader(Parser);
[27]	2794	else
[502]	2795	{
	2796	for(i = 0; i < Parser->Data.numsats; ++i)
	2797	Parser->startflags \|= Parser->Data.dataflags[i];
	2798	continue;
	2799	}
[27]	2800	}
[502]	2801	if(r == 2 && !Parser->validwarning)
[27]	2802	{
[502]	2803	RTCM3Text("No valid RINEX! All values are modulo 299792.458!"
	2804	" COMMENT\n");
	2805	Parser->validwarning = 1;
	2806	}
	2807
	2808	converttime(&cti, Parser->Data.week,
	2809	(int)floor(Parser->Data.timeofweek/1000.0));
[5358]	2810	newheader[0] = 0;
	2811	if(Parser->changeobs)
	2812	{
	2813	nh = HandleObsHeader(Parser, newheader, sizeof(newheader), 0);
[5553]	2814	for(i = 0; i < nh; ++i)
	2815	{
	2816	if(newheader[i] == '\n')
	2817	++hl;
	2818	}
[5358]	2819	}
[502]	2820	if(Parser->rinex3)
	2821	{
[5358]	2822	if(nh)
	2823	{
[5553]	2824	RTCM3Text("> %04d %02d %02d %02d %02d%11.7f 4%3d\n",
	2825	cti.year, cti.month, cti.day, cti.hour, cti.minute, cti.second
	2826	+ fmod(Parser->Data.timeofweek/1000.0,1.0), hl);
[5358]	2827	RTCM3Text("%s\n "
	2828	" END OF HEADER\n", newheader);
	2829	}
[5553]	2830	RTCM3Text("> %04d %02d %02d %02d %02d%11.7f %d%3d\n",
	2831	cti.year, cti.month, cti.day, cti.hour, cti.minute, cti.second
	2832	+ fmod(Parser->Data.timeofweek/1000.0,1.0), 0,
	2833	Parser->Data.numsats);
[502]	2834	for(i = 0; i < Parser->Data.numsats; ++i)
[363]	2835	{
[4371]	2836	int sys[RTCM3_MSM_NUMSYS] = {0,0,0,0,0,0};
[502]	2837	if(Parser->Data.satellites[i] <= PRN_GPS_END)
[4371]	2838	{
[502]	2839	RTCM3Text("G%02d", Parser->Data.satellites[i]);
[4371]	2840	sys[RTCM3_MSM_GPS] = 1;
	2841	}
[502]	2842	else if(Parser->Data.satellites[i] >= PRN_GLONASS_START
	2843	&& Parser->Data.satellites[i] <= PRN_GLONASS_END)
	2844	{
	2845	RTCM3Text("R%02d", Parser->Data.satellites[i] - (PRN_GLONASS_START-1));
[4371]	2846	sys[RTCM3_MSM_GLONASS] = 1;
[502]	2847	}
[2699]	2848	else if(Parser->Data.satellites[i] >= PRN_GALILEO_START
	2849	&& Parser->Data.satellites[i] <= PRN_GALILEO_END)
	2850	{
	2851	RTCM3Text("E%02d", Parser->Data.satellites[i] - (PRN_GALILEO_START-1));
[4371]	2852	sys[RTCM3_MSM_GALILEO] = 1;
[2699]	2853	}
	2854	else if(Parser->Data.satellites[i] >= PRN_GIOVE_START
	2855	&& Parser->Data.satellites[i] <= PRN_GIOVE_END)
	2856	{
	2857	RTCM3Text("E%02d", Parser->Data.satellites[i] - (PRN_GIOVE_START-PRN_GIOVE_OFFSET));
[4371]	2858	sys[RTCM3_MSM_GALILEO] = 1;
[2699]	2859	}
[4367]	2860	else if(Parser->Data.satellites[i] >= PRN_QZSS_START
	2861	&& Parser->Data.satellites[i] <= PRN_QZSS_END)
	2862	{
	2863	RTCM3Text("J%02d", Parser->Data.satellites[i] - (PRN_QZSS_START-1));
[4371]	2864	sys[RTCM3_MSM_QZSS] = 1;
[4367]	2865	}
	2866	else if(Parser->Data.satellites[i] >= PRN_COMPASS_START
	2867	&& Parser->Data.satellites[i] <= PRN_COMPASS_END)
	2868	{
	2869	RTCM3Text("C%02d", Parser->Data.satellites[i] - (PRN_COMPASS_START-1));
[4371]	2870	sys[RTCM3_MSM_COMPASS] = 1;
[4367]	2871	}
	2872	else if(Parser->Data.satellites[i] >= PRN_SBAS_START
	2873	&& Parser->Data.satellites[i] <= PRN_SBAS_END)
[4371]	2874	{
[4367]	2875	RTCM3Text("S%02d", Parser->Data.satellites[i] - PRN_SBAS_START+20);
[4371]	2876	sys[RTCM3_MSM_SBAS] = 1;
	2877	}
[502]	2878	else
[4371]	2879	{
[502]	2880	RTCM3Text("%3d", Parser->Data.satellites[i]);
[4371]	2881	}
[363]	2882
[4371]	2883	if(sys[RTCM3_MSM_GLONASS])
[363]	2884	{
[4371]	2885	for(j = 0; j < Parser->info[RTCM3_MSM_GLONASS].numtypes; ++j)
[502]	2886	{
[4383]	2887	long long df = Parser->info[RTCM3_MSM_GLONASS].flags[j];
[4371]	2888	int pos = Parser->info[RTCM3_MSM_GLONASS].pos[j];
[502]	2889	if((Parser->Data.dataflags[i] & df)
	2890	&& !isnan(Parser->Data.measdata[i][pos])
[4374]	2891	&& !isinf(Parser->Data.measdata[i][pos])
	2892	&& (Parser->Data.codetype[i][pos]
	2893	&& Parser->info[RTCM3_MSM_GLONASS].type[pos]
	2894	&& Parser->info[RTCM3_MSM_GLONASS].type[pos]
	2895	== Parser->Data.codetype[i][pos][1]))
[502]	2896	{
	2897	char lli = ' ';
	2898	char snr = ' ';
	2899	if(df & (GNSSDF_L1CDATA\|GNSSDF_L1PDATA))
	2900	{
[2659]	2901	if(Parser->Data.dataflags2[i] & GNSSDF2_LOCKLOSSL1)
[502]	2902	lli = '1';
	2903	snr = '0'+Parser->Data.snrL1[i];
	2904	}
	2905	if(df & (GNSSDF_L2CDATA\|GNSSDF_L2PDATA))
	2906	{
[2659]	2907	if(Parser->Data.dataflags2[i] & GNSSDF2_LOCKLOSSL2)
[502]	2908	lli = '1';
	2909	snr = '0'+Parser->Data.snrL2[i];
	2910	}
	2911	RTCM3Text("%14.3f%c%c",
	2912	Parser->Data.measdata[i][pos],lli,snr);
	2913	}
	2914	else
	2915	{ /* no or illegal data */
	2916	RTCM3Text(" ");
	2917	}
	2918	}
[363]	2919	}
[4371]	2920	else if(sys[RTCM3_MSM_GALILEO])
[2699]	2921	{
[4371]	2922	for(j = 0; j < Parser->info[RTCM3_MSM_GALILEO].numtypes; ++j)
[2699]	2923	{
[4383]	2924	long long df = Parser->info[RTCM3_MSM_GALILEO].flags[j];
[4371]	2925	int pos = Parser->info[RTCM3_MSM_GALILEO].pos[j];
[2699]	2926	if((Parser->Data.dataflags[i] & df)
	2927	&& !isnan(Parser->Data.measdata[i][pos])
[4374]	2928	&& !isinf(Parser->Data.measdata[i][pos])
	2929	&& (Parser->Data.codetype[i][pos]
	2930	&& Parser->info[RTCM3_MSM_GALILEO].type[pos]
	2931	&& Parser->info[RTCM3_MSM_GALILEO].type[pos]
	2932	== Parser->Data.codetype[i][pos][1]))
[2699]	2933	{
	2934	char lli = ' ';
	2935	char snr = ' ';
	2936	if(df & (GNSSDF_L1CDATA\|GNSSDF_L1PDATA))
	2937	{
	2938	if(Parser->Data.dataflags2[i] & GNSSDF2_LOCKLOSSL1)
	2939	lli = '1';
	2940	snr = '0'+Parser->Data.snrL1[i];
	2941	}
	2942	if(df & GNSSDF_L6DATA)
	2943	{
	2944	if(Parser->Data.dataflags2[i] & GNSSDF2_LOCKLOSSE6)
	2945	lli = '1';
	2946	snr = ' ';
	2947	}
	2948	if(df & GNSSDF_L5DATA)
	2949	{
	2950	if(Parser->Data.dataflags2[i] & GNSSDF2_LOCKLOSSL5)
	2951	lli = '1';
	2952	snr = ' ';
	2953	}
	2954	if(df & GNSSDF_L5BDATA)
	2955	{
	2956	if(Parser->Data.dataflags2[i] & GNSSDF2_LOCKLOSSE5B)
	2957	lli = '1';
	2958	snr = ' ';
	2959	}
	2960	if(df & GNSSDF_L5ABDATA)
	2961	{
	2962	if(Parser->Data.dataflags2[i] & GNSSDF2_LOCKLOSSE5AB)
	2963	lli = '1';
	2964	snr = ' ';
	2965	}
	2966	RTCM3Text("%14.3f%c%c",
	2967	Parser->Data.measdata[i][pos],lli,snr);
	2968	}
	2969	else
	2970	{ /* no or illegal data */
	2971	RTCM3Text(" ");
	2972	}
	2973	}
	2974	}
[4371]	2975	else if(sys[RTCM3_MSM_COMPASS])
[4367]	2976	{
[4371]	2977	for(j = 0; j < Parser->info[RTCM3_MSM_COMPASS].numtypes; ++j)
[4367]	2978	{
[4383]	2979	long long df = Parser->info[RTCM3_MSM_COMPASS].flags[j];
[4371]	2980	int pos = Parser->info[RTCM3_MSM_COMPASS].pos[j];
[4367]	2981	if((Parser->Data.dataflags[i] & df)
	2982	&& !isnan(Parser->Data.measdata[i][pos])
[4374]	2983	&& !isinf(Parser->Data.measdata[i][pos])
	2984	&& (Parser->Data.codetype[i][pos]
	2985	&& Parser->info[RTCM3_MSM_COMPASS].type[pos]
	2986	&& Parser->info[RTCM3_MSM_COMPASS].type[pos]
	2987	== Parser->Data.codetype[i][pos][1]))
[4367]	2988	{
	2989	char lli = ' ';
	2990	char snr = ' ';
	2991	if(df & GNSSDF_LB1DATA)
	2992	{
	2993	if(Parser->Data.dataflags2[i] & GNSSDF2_LOCKLOSSB1)
	2994	lli = '1';
	2995	}
	2996	if(df & GNSSDF_LB2DATA)
	2997	{
	2998	if(Parser->Data.dataflags2[i] & GNSSDF2_LOCKLOSSB2)
	2999	lli = '1';
	3000	}
	3001	if(df & GNSSDF_LB3DATA)
	3002	{
	3003	if(Parser->Data.dataflags2[i] & GNSSDF2_LOCKLOSSB3)
	3004	lli = '1';
	3005	}
	3006	RTCM3Text("%14.3f%c%c",
	3007	Parser->Data.measdata[i][pos],lli,snr);
	3008	}
	3009	else
	3010	{ /* no or illegal data */
	3011	RTCM3Text(" ");
	3012	}
	3013	}
	3014	}
[4371]	3015	else if(sys[RTCM3_MSM_QZSS])
[4367]	3016	{
[4371]	3017	for(j = 0; j < Parser->info[RTCM3_MSM_QZSS].numtypes; ++j)
[4367]	3018	{
[4383]	3019	long long df = Parser->info[RTCM3_MSM_QZSS].flags[j];
[4371]	3020	int pos = Parser->info[RTCM3_MSM_QZSS].pos[j];
[4367]	3021	if((Parser->Data.dataflags[i] & df)
	3022	&& !isnan(Parser->Data.measdata[i][pos])
[4371]	3023	&& !isinf(Parser->Data.measdata[i][pos])
[4374]	3024	&& (Parser->Data.codetype[i][pos]
[4371]	3025	&& Parser->info[RTCM3_MSM_QZSS].type[pos]
	3026	&& Parser->info[RTCM3_MSM_QZSS].type[pos]
[4374]	3027	== Parser->Data.codetype[i][pos][1]))
[4367]	3028	{
	3029	char lli = ' ';
	3030	char snr = ' ';
	3031	if(df & GNSSDF_L1CDATA)
	3032	{
	3033	if(Parser->Data.dataflags2[i] & GNSSDF2_LOCKLOSSL1)
	3034	lli = '1';
	3035	snr = '0'+Parser->Data.snrL1[i];
	3036	}
	3037	if(df & (GNSSDF_L2CDATA\|GNSSDF_L2PDATA))
	3038	{
	3039	if(Parser->Data.dataflags2[i] & GNSSDF2_LOCKLOSSL2)
	3040	lli = '1';
	3041	snr = '0'+Parser->Data.snrL2[i];
	3042	}
	3043	if(df & GNSSDF_L5DATA)
	3044	{
	3045	if(Parser->Data.dataflags2[i] & GNSSDF2_LOCKLOSSL5)
	3046	lli = '1';
	3047	snr = ' ';
	3048	}
	3049	RTCM3Text("%14.3f%c%c",
	3050	Parser->Data.measdata[i][pos],lli,snr);
	3051	}
	3052	else
	3053	{ /* no or illegal data */
	3054	RTCM3Text(" ");
	3055	}
	3056	}
	3057	}
[4371]	3058	else if(sys[RTCM3_MSM_SBAS])
	3059	{
	3060	for(j = 0; j < Parser->info[RTCM3_MSM_SBAS].numtypes; ++j)
	3061	{
[4383]	3062	long long df = Parser->info[RTCM3_MSM_SBAS].flags[j];
[4371]	3063	int pos = Parser->info[RTCM3_MSM_SBAS].pos[j];
	3064	if((Parser->Data.dataflags[i] & df)
	3065	&& !isnan(Parser->Data.measdata[i][pos])
[4374]	3066	&& !isinf(Parser->Data.measdata[i][pos])
	3067	&& (Parser->Data.codetype[i][pos]
	3068	&& Parser->info[RTCM3_MSM_SBAS].type[pos]
	3069	&& Parser->info[RTCM3_MSM_SBAS].type[pos]
	3070	== Parser->Data.codetype[i][pos][1]))
[4371]	3071	{
	3072	char lli = ' ';
	3073	char snr = ' ';
	3074	if(df & (GNSSDF_L1CDATA\|GNSSDF_L1PDATA))
	3075	{
	3076	if(Parser->Data.dataflags2[i] & GNSSDF2_LOCKLOSSL1)
	3077	lli = '1';
	3078	snr = '0'+Parser->Data.snrL1[i];
	3079	}
	3080	if(df & GNSSDF_L5DATA)
	3081	{
	3082	if(Parser->Data.dataflags2[i] & GNSSDF2_LOCKLOSSL5)
	3083	lli = '1';
	3084	snr = ' ';
	3085	}
	3086	RTCM3Text("%14.3f%c%c",
	3087	Parser->Data.measdata[i][pos],lli,snr);
	3088	}
	3089	else
	3090	{ /* no or illegal data */
	3091	RTCM3Text(" ");
	3092	}
	3093	}
	3094	}
[502]	3095	else
	3096	{
[4371]	3097	for(j = 0; j < Parser->info[RTCM3_MSM_GPS].numtypes; ++j)
[502]	3098	{
[4383]	3099	long long df = Parser->info[RTCM3_MSM_GPS].flags[j];
[4371]	3100	int pos = Parser->info[RTCM3_MSM_GPS].pos[j];
[4383]	3101	if((Parser->Data.dataflags[i] & df)
[502]	3102	&& !isnan(Parser->Data.measdata[i][pos])
[4374]	3103	&& !isinf(Parser->Data.measdata[i][pos])
	3104	&& (Parser->Data.codetype[i][pos]
	3105	&& Parser->info[RTCM3_MSM_GPS].type[pos]
	3106	&& Parser->info[RTCM3_MSM_GPS].type[pos]
	3107	== Parser->Data.codetype[i][pos][1]))
[502]	3108	{
	3109	char lli = ' ';
	3110	char snr = ' ';
	3111	if(df & (GNSSDF_L1CDATA\|GNSSDF_L1PDATA))
	3112	{
[2659]	3113	if(Parser->Data.dataflags2[i] & GNSSDF2_LOCKLOSSL1)
[502]	3114	lli = '1';
	3115	snr = '0'+Parser->Data.snrL1[i];
	3116	}
	3117	if(df & (GNSSDF_L2CDATA\|GNSSDF_L2PDATA))
	3118	{
[2659]	3119	if(Parser->Data.dataflags2[i] & GNSSDF2_LOCKLOSSL2)
[502]	3120	lli = '1';
	3121	snr = '0'+Parser->Data.snrL2[i];
	3122	}
[2699]	3123	if(df & GNSSDF_L5DATA)
	3124	{
	3125	if(Parser->Data.dataflags2[i] & GNSSDF2_LOCKLOSSL5)
	3126	lli = '1';
	3127	snr = ' ';
	3128	}
[502]	3129	RTCM3Text("%14.3f%c%c",
	3130	Parser->Data.measdata[i][pos],lli,snr);
	3131	}
	3132	else
	3133	{ /* no or illegal data */
	3134	RTCM3Text(" ");
	3135	}
	3136	}
	3137	}
	3138	RTCM3Text("\n");
[363]	3139	}
[502]	3140	}
	3141	else
	3142	{
[5358]	3143	RTCM3Text(" %02d %2d %2d %2d %2d %10.7f %d%3d",
[502]	3144	cti.year%100, cti.month, cti.day, cti.hour, cti.minute, cti.second
[5358]	3145	+ fmod(Parser->Data.timeofweek/1000.0,1.0), nh ? 4 : 0,
	3146	Parser->Data.numsats);
[502]	3147	for(i = 0; i < 12 && i < Parser->Data.numsats; ++i)
	3148	{
	3149	if(Parser->Data.satellites[i] <= PRN_GPS_END)
	3150	RTCM3Text("G%02d", Parser->Data.satellites[i]);
	3151	else if(Parser->Data.satellites[i] >= PRN_GLONASS_START
	3152	&& Parser->Data.satellites[i] <= PRN_GLONASS_END)
[2659]	3153	RTCM3Text("R%02d", Parser->Data.satellites[i]
	3154	- (PRN_GLONASS_START-1));
[4367]	3155	else if(Parser->Data.satellites[i] >= PRN_SBAS_START
	3156	&& Parser->Data.satellites[i] <= PRN_SBAS_END)
[2659]	3157	RTCM3Text("S%02d", Parser->Data.satellites[i]
[4367]	3158	- PRN_SBAS_START+20);
[2659]	3159	else if(Parser->Data.satellites[i] >= PRN_GALILEO_START
	3160	&& Parser->Data.satellites[i] <= PRN_GALILEO_END)
	3161	RTCM3Text("E%02d", Parser->Data.satellites[i]
	3162	- (PRN_GALILEO_START-1));
	3163	else if(Parser->Data.satellites[i] >= PRN_GIOVE_START
	3164	&& Parser->Data.satellites[i] <= PRN_GIOVE_END)
	3165	RTCM3Text("E%02d", Parser->Data.satellites[i]
	3166	- (PRN_GIOVE_START-PRN_GIOVE_OFFSET));
[4367]	3167	else if(Parser->Data.satellites[i] >= PRN_QZSS_START
	3168	&& Parser->Data.satellites[i] <= PRN_QZSS_END)
	3169	RTCM3Text("J%02d", Parser->Data.satellites[i]
	3170	- (PRN_QZSS_START-1));
	3171	else if(Parser->Data.satellites[i] >= PRN_COMPASS_START
	3172	&& Parser->Data.satellites[i] <= PRN_COMPASS_END)
	3173	RTCM3Text("C%02d", Parser->Data.satellites[i]
	3174	- (PRN_COMPASS_START-1));
[502]	3175	else
	3176	RTCM3Text("%3d", Parser->Data.satellites[i]);
[27]	3177	}
[502]	3178	RTCM3Text("\n");
	3179	o = 12;
	3180	j = Parser->Data.numsats - 12;
	3181	while(j > 0)
[27]	3182	{
[502]	3183	RTCM3Text(" ");
	3184	for(i = o; i < o+12 && i < Parser->Data.numsats; ++i)
[27]	3185	{
[502]	3186	if(Parser->Data.satellites[i] <= PRN_GPS_END)
	3187	RTCM3Text("G%02d", Parser->Data.satellites[i]);
	3188	else if(Parser->Data.satellites[i] >= PRN_GLONASS_START
	3189	&& Parser->Data.satellites[i] <= PRN_GLONASS_END)
[2659]	3190	RTCM3Text("R%02d", Parser->Data.satellites[i]
	3191	- (PRN_GLONASS_START-1));
[4367]	3192	else if(Parser->Data.satellites[i] >= PRN_SBAS_START
	3193	&& Parser->Data.satellites[i] <= PRN_SBAS_END)
[2659]	3194	RTCM3Text("S%02d", Parser->Data.satellites[i]
[4367]	3195	- PRN_SBAS_START+20);
[2659]	3196	else if(Parser->Data.satellites[i] >= PRN_GALILEO_START
	3197	&& Parser->Data.satellites[i] <= PRN_GALILEO_END)
	3198	RTCM3Text("E%02d", Parser->Data.satellites[i]
	3199	- (PRN_GALILEO_START-1));
	3200	else if(Parser->Data.satellites[i] >= PRN_GIOVE_START
	3201	&& Parser->Data.satellites[i] <= PRN_GIOVE_END)
	3202	RTCM3Text("E%02d", Parser->Data.satellites[i]
	3203	- (PRN_GIOVE_START-PRN_GIOVE_OFFSET));
[4367]	3204	else if(Parser->Data.satellites[i] >= PRN_QZSS_START
	3205	&& Parser->Data.satellites[i] <= PRN_QZSS_END)
	3206	RTCM3Text("J%02d", Parser->Data.satellites[i]
	3207	- (PRN_QZSS_START-1));
	3208	else if(Parser->Data.satellites[i] >= PRN_COMPASS_START
	3209	&& Parser->Data.satellites[i] <= PRN_COMPASS_END)
	3210	RTCM3Text("C%02d", Parser->Data.satellites[i]
	3211	- (PRN_COMPASS_START-1));
[502]	3212	else
	3213	RTCM3Text("%3d", Parser->Data.satellites[i]);
[27]	3214	}
[502]	3215	RTCM3Text("\n");
	3216	j -= 12;
	3217	o += 12;
	3218	}
[5358]	3219	if(nh)
	3220	{
	3221	RTCM3Text("%s\n "
	3222	" END OF HEADER\n", newheader);
	3223	}
[502]	3224	for(i = 0; i < Parser->Data.numsats; ++i)
	3225	{
[4371]	3226	for(j = 0; j < Parser->info[RTCM3_MSM_GPS].numtypes; ++j)
[27]	3227	{
[502]	3228	int v = 0;
[4383]	3229	long long df = Parser->flags[j];
[4371]	3230	int pos = Parser->pos[j];
[502]	3231	if((Parser->Data.dataflags[i] & df)
	3232	&& !isnan(Parser->Data.measdata[i][pos])
	3233	&& !isinf(Parser->Data.measdata[i][pos]))
	3234	{
	3235	v = 1;
	3236	}
	3237	else
	3238	{
[4371]	3239	df = Parser->info[RTCM3_MSM_GPS].flags[j];
	3240	pos = Parser->info[RTCM3_MSM_GPS].pos[j];
[502]	3241
	3242	if((Parser->Data.dataflags[i] & df)
	3243	&& !isnan(Parser->Data.measdata[i][pos])
	3244	&& !isinf(Parser->Data.measdata[i][pos]))
	3245	{
	3246	v = 1;
	3247	}
	3248	}
	3249
	3250	if(!v)
	3251	{ /* no or illegal data */
	3252	RTCM3Text(" ");
	3253	}
	3254	else
	3255	{
	3256	char lli = ' ';
	3257	char snr = ' ';
	3258	if(df & (GNSSDF_L1CDATA\|GNSSDF_L1PDATA))
	3259	{
[2659]	3260	if(Parser->Data.dataflags2[i] & GNSSDF2_LOCKLOSSL1)
[502]	3261	lli = '1';
	3262	snr = '0'+Parser->Data.snrL1[i];
	3263	}
	3264	if(df & (GNSSDF_L2CDATA\|GNSSDF_L2PDATA))
	3265	{
[2659]	3266	if(Parser->Data.dataflags2[i]
	3267	& (GNSSDF2_LOCKLOSSL2\|GNSSDF2_XCORRL2))
[2422]	3268	{
	3269	lli = '0';
[2659]	3270	if(Parser->Data.dataflags2[i] & GNSSDF2_LOCKLOSSL2)
[2422]	3271	lli += 1;
[2659]	3272	if(Parser->Data.dataflags2[i] & GNSSDF2_XCORRL2)
[2422]	3273	lli += 4;
	3274	}
[502]	3275	snr = '0'+Parser->Data.snrL2[i];
	3276	}
[2659]	3277	if((df & GNSSDF_P2DATA) && (Parser->Data.dataflags2[i]
	3278	& GNSSDF2_XCORRL2))
[2422]	3279	lli = '4';
[502]	3280	RTCM3Text("%14.3f%c%c",
	3281	Parser->Data.measdata[i][pos],lli,snr);
	3282	}
[4371]	3283	if(j%5 == 4 \|\| j == Parser->info[RTCM3_MSM_GPS].numtypes-1)
[502]	3284	RTCM3Text("\n");
[27]	3285	}
	3286	}
	3287	}
	3288	}
	3289	}
	3290	}
	3291	}
	3292
[268]	3293	#ifndef NO_RTCM3_MAIN
[2487]	3294	static char datestr[] = "$Date: 2014-11-20 13:07:01 +0000 (Thu, 20 Nov 2014) $";
[269]	3295
[268]	3296	/* The string, which is send as agent in HTTP request */
	3297	#define AGENTSTRING "NTRIP NtripRTCM3ToRINEX"
	3298
	3299	#define MAXDATASIZE 1000 /* max number of bytes we can get at once */
	3300
[269]	3301	static const char encodingTable [64] = {
	3302	'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P',
	3303	'Q','R','S','T','U','V','W','X','Y','Z','a','b','c','d','e','f',
	3304	'g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v',
	3305	'w','x','y','z','0','1','2','3','4','5','6','7','8','9','+','/'
	3306	};
	3307
	3308	/* does not buffer overrun, but breaks directly after an error */
	3309	/* returns the number of required bytes */
	3310	static int encode(char buf, int size, const char user, const char *pwd)
	3311	{
	3312	unsigned char inbuf[3];
	3313	char *out = buf;
	3314	int i, sep = 0, fill = 0, bytes = 0;
	3315
	3316	while(user \|\| pwd)
	3317	{
	3318	i = 0;
	3319	while(i < 3 && user) inbuf[i++] = (user++);
	3320	if(i < 3 && !sep) {inbuf[i++] = ':'; ++sep; }
	3321	while(i < 3 && pwd) inbuf[i++] = (pwd++);
	3322	while(i < 3) {inbuf[i++] = 0; ++fill; }
	3323	if(out-buf < size-1)
	3324	*(out++) = encodingTable[(inbuf [0] & 0xFC) >> 2];
	3325	if(out-buf < size-1)
	3326	*(out++) = encodingTable[((inbuf [0] & 0x03) << 4)
	3327	\| ((inbuf [1] & 0xF0) >> 4)];
	3328	if(out-buf < size-1)
	3329	{
	3330	if(fill == 2)
	3331	*(out++) = '=';
	3332	else
	3333	*(out++) = encodingTable[((inbuf [1] & 0x0F) << 2)
	3334	\| ((inbuf [2] & 0xC0) >> 6)];
	3335	}
	3336	if(out-buf < size-1)
	3337	{
	3338	if(fill >= 1)
	3339	*(out++) = '=';
	3340	else
	3341	*(out++) = encodingTable[inbuf [2] & 0x3F];
	3342	}
	3343	bytes += 4;
	3344	}
	3345	if(out-buf < size)
	3346	*out = 0;
	3347	return bytes;
	3348	}
	3349
[268]	3350	static int stop = 0;
	3351
	3352	struct Args
	3353	{
	3354	const char *server;
[502]	3355	const char *port;
	3356	int mode;
[477]	3357	int timeout;
[502]	3358	int rinex3;
[5358]	3359	int changeobs;
[268]	3360	const char *user;
	3361	const char *password;
[502]	3362	const char *proxyhost;
	3363	const char *proxyport;
	3364	const char *nmea;
[268]	3365	const char *data;
	3366	const char *headerfile;
[6329]	3367	const char *sbasephemeris;
[502]	3368	const char *gpsephemeris;
[5595]	3369	const char *qzssephemeris;
[502]	3370	const char *glonassephemeris;
[268]	3371	};
	3372
	3373	/* option parsing */
	3374	#ifdef NO_LONG_OPTS
	3375	#define LONG_OPT(a)
	3376	#else
	3377	#define LONG_OPT(a) a
	3378	static struct option opts[] = {
[502]	3379	{ "data", required_argument, 0, 'd'},
	3380	{ "server", required_argument, 0, 's'},
	3381	{ "password", required_argument, 0, 'p'},
	3382	{ "port", required_argument, 0, 'r'},
	3383	{ "timeout", required_argument, 0, 't'},
	3384	{ "header", required_argument, 0, 'f'},
	3385	{ "user", required_argument, 0, 'u'},
	3386	{ "gpsephemeris", required_argument, 0, 'E'},
[5595]	3387	{ "qzssephemeris", required_argument, 0, 'Q'},
[502]	3388	{ "glonassephemeris", required_argument, 0, 'G'},
[6329]	3389	{ "sbasephemeris", required_argument, 0, 'B'},
[502]	3390	{ "rinex3", no_argument, 0, '3'},
[5358]	3391	{ "changeobs", no_argument, 0, 'O'},
[502]	3392	{ "proxyport", required_argument, 0, 'R'},
	3393	{ "proxyhost", required_argument, 0, 'S'},
	3394	{ "nmea", required_argument, 0, 'n'},
	3395	{ "mode", required_argument, 0, 'M'},
	3396	{ "help", no_argument, 0, 'h'},
[268]	3397	{0,0,0,0}};
	3398	#endif
[6329]	3399	#define ARGOPT "-d:s:p:r:t:f:u:E:G:B:Q:M:S:R:n:h3O"
[268]	3400
[502]	3401	enum MODE { HTTP = 1, RTSP = 2, NTRIP1 = 3, AUTO = 4, END };
	3402
[270]	3403	static const char geturl(const char url, struct Args *args)
	3404	{
	3405	static char buf[1000];
	3406	static char *Buffer = buf;
	3407	static char *Bufend = buf+sizeof(buf);
	3408
	3409	if(strncmp("ntrip:", url, 6))
	3410	return "URL must start with 'ntrip:'.";
	3411	url += 6; /* skip ntrip: */
	3412
	3413	if(url != '@' && url != '/')
	3414	{
	3415	/* scan for mountpoint */
	3416	args->data = Buffer;
[502]	3417	while(url && url != '@' && url != ';' &&url != '/' && Buffer != Bufend)
[270]	3418	(Buffer++) = (url++);
	3419	if(Buffer == args->data)
	3420	return "Mountpoint required.";
	3421	else if(Buffer >= Bufend-1)
	3422	return "Parsing buffer too short.";
	3423	*(Buffer++) = 0;
	3424	}
	3425
	3426	if(url == '/') / username and password */
	3427	{
	3428	++url;
	3429	args->user = Buffer;
[502]	3430	while(url && url != '@' && url != ';' && url != ':' && Buffer != Bufend)
[270]	3431	(Buffer++) = (url++);
	3432	if(Buffer == args->user)
	3433	return "Username cannot be empty.";
	3434	else if(Buffer >= Bufend-1)
	3435	return "Parsing buffer too short.";
	3436	*(Buffer++) = 0;
	3437
	3438	if(*url == ':') ++url;
	3439
	3440	args->password = Buffer;
[502]	3441	while(url && url != '@' && *url != ';' && Buffer != Bufend)
[270]	3442	(Buffer++) = (url++);
	3443	if(Buffer == args->password)
	3444	return "Password cannot be empty.";
	3445	else if(Buffer >= Bufend-1)
	3446	return "Parsing buffer too short.";
	3447	*(Buffer++) = 0;
	3448	}
	3449
	3450	if(url == '@') / server */
	3451	{
	3452	++url;
[502]	3453	if(url != '@' && url != ':')
	3454	{
	3455	args->server = Buffer;
	3456	while(url && url != '@' && url != ':' && url != ';' && Buffer != Bufend)
	3457	(Buffer++) = (url++);
	3458	if(Buffer == args->server)
	3459	return "Servername cannot be empty.";
	3460	else if(Buffer >= Bufend-1)
	3461	return "Parsing buffer too short.";
	3462	*(Buffer++) = 0;
	3463	}
[270]	3464
	3465	if(*url == ':')
	3466	{
[502]	3467	++url;
	3468	args->port = Buffer;
	3469	while(url && url != '@' && *url != ';' && Buffer != Bufend)
	3470	(Buffer++) = (url++);
	3471	if(Buffer == args->port)
	3472	return "Port cannot be empty.";
	3473	else if(Buffer >= Bufend-1)
	3474	return "Parsing buffer too short.";
	3475	*(Buffer++) = 0;
[270]	3476	}
[502]	3477
	3478	if(url == '@') / proxy */
	3479	{
	3480	++url;
	3481	args->proxyhost = Buffer;
	3482	while(url && url != ':' && *url != ';' && Buffer != Bufend)
	3483	(Buffer++) = (url++);
	3484	if(Buffer == args->proxyhost)
	3485	return "Proxy servername cannot be empty.";
	3486	else if(Buffer >= Bufend-1)
	3487	return "Parsing buffer too short.";
	3488	*(Buffer++) = 0;
	3489
	3490	if(*url == ':')
	3491	{
	3492	++url;
	3493	args->proxyport = Buffer;
	3494	while(url && url != ';' && Buffer != Bufend)
	3495	(Buffer++) = (url++);
	3496	if(Buffer == args->proxyport)
	3497	return "Proxy port cannot be empty.";
	3498	else if(Buffer >= Bufend-1)
	3499	return "Parsing buffer too short.";
	3500	*(Buffer++) = 0;
	3501	}
	3502	}
[270]	3503	}
[502]	3504	if(url == ';') / NMEA */
	3505	{
	3506	args->nmea = ++url;
	3507	while(*url)
	3508	++url;
	3509	}
[270]	3510
	3511	return *url ? "Garbage at end of server string." : 0;
	3512	}
	3513
[268]	3514	static int getargs(int argc, char *argv, struct Args args)
	3515	{
	3516	int res = 1;
	3517	int getoptr;
	3518	int help = 0;
	3519	char *t;
	3520
	3521	args->server = "www.euref-ip.net";
[502]	3522	args->port = "2101";
[477]	3523	args->timeout = 60;
[268]	3524	args->user = "";
	3525	args->password = "";
	3526	args->data = 0;
	3527	args->headerfile = 0;
[502]	3528	args->gpsephemeris = 0;
[5595]	3529	args->qzssephemeris = 0;
[6329]	3530	args->sbasephemeris = 0;
[502]	3531	args->glonassephemeris = 0;
	3532	args->rinex3 = 0;
	3533	args->nmea = 0;
[5358]	3534	args->changeobs = 0;
[502]	3535	args->proxyhost = 0;
	3536	args->proxyport = "2101";
	3537	args->mode = AUTO;
[268]	3538	help = 0;
	3539
	3540	do
	3541	{
[477]	3542
[268]	3543	#ifdef NO_LONG_OPTS
	3544	switch((getoptr = getopt(argc, argv, ARGOPT)))
	3545	#else
	3546	switch((getoptr = getopt_long(argc, argv, ARGOPT, opts, 0)))
	3547	#endif
	3548	{
	3549	case 's': args->server = optarg; break;
	3550	case 'u': args->user = optarg; break;
	3551	case 'p': args->password = optarg; break;
	3552	case 'd': args->data = optarg; break;
	3553	case 'f': args->headerfile = optarg; break;
[502]	3554	case 'E': args->gpsephemeris = optarg; break;
[6329]	3555	case 'B': args->sbasephemeris = optarg; break;
[502]	3556	case 'G': args->glonassephemeris = optarg; break;
[5595]	3557	case 'Q': args->qzssephemeris = optarg; break;
[502]	3558	case 'r': args->port = optarg; break;
	3559	case '3': args->rinex3 = 1; break;
	3560	case 'S': args->proxyhost = optarg; break;
	3561	case 'n': args->nmea = optarg; break;
	3562	case 'R': args->proxyport = optarg; break;
[5358]	3563	case 'O': args->changeobs = 1; break;
[268]	3564	case 'h': help=1; break;
[502]	3565	case 'M':
	3566	args->mode = 0;
	3567	if (!strcmp(optarg,"n") \|\| !strcmp(optarg,"ntrip1"))
	3568	args->mode = NTRIP1;
	3569	else if(!strcmp(optarg,"h") \|\| !strcmp(optarg,"http"))
	3570	args->mode = HTTP;
	3571	else if(!strcmp(optarg,"r") \|\| !strcmp(optarg,"rtsp"))
	3572	args->mode = RTSP;
	3573	else if(!strcmp(optarg,"a") \|\| !strcmp(optarg,"auto"))
	3574	args->mode = AUTO;
	3575	else args->mode = atoi(optarg);
	3576	if((args->mode == 0) \|\| (args->mode >= END))
	3577	{
	3578	fprintf(stderr, "Mode %s unknown\n", optarg);
[268]	3579	res = 0;
[502]	3580	}
[268]	3581	break;
[502]	3582	case 't':
[477]	3583	args->timeout = strtoul(optarg, &t, 10);
	3584	if((t && *t) \|\| args->timeout < 0)
	3585	res = 0;
	3586	break;
	3587
[270]	3588	case 1:
	3589	{
	3590	const char *err;
	3591	if((err = geturl(optarg, args)))
	3592	{
[318]	3593	RTCM3Error("%s\n\n", err);
[270]	3594	res = 0;
	3595	}
	3596	}
	3597	break;
[268]	3598	case -1: break;
	3599	}
	3600	} while(getoptr != -1 \|\| !res);
	3601
	3602	datestr[0] = datestr[7];
	3603	datestr[1] = datestr[8];
	3604	datestr[2] = datestr[9];
	3605	datestr[3] = datestr[10];
	3606	datestr[5] = datestr[12];
	3607	datestr[6] = datestr[13];
	3608	datestr[8] = datestr[15];
	3609	datestr[9] = datestr[16];
	3610	datestr[4] = datestr[7] = '-';
	3611	datestr[10] = 0;
	3612
[502]	3613	if(args->gpsephemeris && args->glonassephemeris && args->rinex3)
[268]	3614	{
[503]	3615	RTCM3Error("RINEX3 produces a combined ephemeris file, but 2 files were specified.\n"
	3616	"Please specify only one navigation file.\n");
[502]	3617	res = 0;
	3618	}
	3619	else if(!res \|\| help)
	3620	{
[439]	3621	RTCM3Error("Version %s (%s) GPL" COMPILEDATE
	3622	"\nUsage: %s -s server -u user ...\n"
[502]	3623	" -d " LONG_OPT("--data ") "the requested data set\n"
	3624	" -f " LONG_OPT("--headerfile ") "file for RINEX header information\n"
	3625	" -s " LONG_OPT("--server ") "the server name or address\n"
	3626	" -p " LONG_OPT("--password ") "the login password\n"
	3627	" -r " LONG_OPT("--port ") "the server port number (default 2101)\n"
	3628	" -t " LONG_OPT("--timeout ") "timeout in seconds (default 60)\n"
	3629	" -u " LONG_OPT("--user ") "the user name\n"
	3630	" -E " LONG_OPT("--gpsephemeris ") "output file for GPS ephemeris data\n"
	3631	" -G " LONG_OPT("--glonassephemeris ") "output file for GLONASS ephemeris data\n"
[5595]	3632	" -Q " LONG_OPT("--qzssephemeris ") "output file for QZSS ephemeris data\n"
[6329]	3633	" -B " LONG_OPT("--sbasephemeris ") "output file for SBAS ephemeris data\n"
[502]	3634	" -3 " LONG_OPT("--rinex3 ") "output RINEX type 3 data\n"
	3635	" -S " LONG_OPT("--proxyhost ") "proxy name or address\n"
	3636	" -R " LONG_OPT("--proxyport ") "proxy port, optional (default 2101)\n"
	3637	" -n " LONG_OPT("--nmea ") "NMEA string for sending to server\n"
[5358]	3638	" -O " LONG_OPT("--changeobs ") "Add observation type change header lines\n"
[502]	3639	" -M " LONG_OPT("--mode ") "mode for data request\n"
	3640	" Valid modes are:\n"
	3641	" 1, h, http NTRIP Version 2.0 Caster in TCP/IP mode\n"
	3642	" 2, r, rtsp NTRIP Version 2.0 Caster in RTSP/RTP mode\n"
	3643	" 3, n, ntrip1 NTRIP Version 1.0 Caster\n"
	3644	" 4, a, auto automatic detection (default)\n"
	3645	"or using an URL:\n%s ntrip:data[/user[:password]][@[server][:port][@proxyhost[:proxyport]]][;nmea]\n"
[270]	3646	, revisionstr, datestr, argv[0], argv[0]);
[268]	3647	exit(1);
	3648	}
	3649	return res;
	3650	}
	3651
	3652	/* let the output complete a block if necessary */
	3653	static void signalhandler(int sig)
	3654	{
	3655	if(!stop)
	3656	{
[318]	3657	RTCM3Error("Stop signal number %d received. "
[268]	3658	"Trying to terminate gentle.\n", sig);
	3659	stop = 1;
	3660	alarm(1);
	3661	}
	3662	}
	3663
[1091]	3664	#ifndef WINDOWSVERSION
	3665	static void WaitMicro(int mic)
	3666	{
	3667	struct timeval tv;
	3668	tv.tv_sec = mic/1000000;
	3669	tv.tv_usec = mic%1000000;
	3670	#ifdef DEBUG
	3671	fprintf(stderr, "Waiting %d micro seconds\n", mic);
	3672	#endif
	3673	select(0, 0, 0, 0, &tv);
	3674	}
	3675	#else /* WINDOWSVERSION */
	3676	void WaitMicro(int mic)
	3677	{
	3678	Sleep(mic/1000);
	3679	}
	3680	#endif /* WINDOWSVERSION */
	3681
[502]	3682	#define ALARMTIME (2*60)
	3683
[268]	3684	/* for some reason we had to abort hard (maybe waiting for data */
	3685	#ifdef __GNUC__
	3686	static __attribute__ ((noreturn)) void signalhandler_alarm(
	3687	int sig __attribute__((__unused__)))
	3688	#else /* __GNUC__ */
	3689	static void signalhandler_alarm(int sig)
	3690	#endif /* __GNUC__ */
	3691	{
[318]	3692	RTCM3Error("Programm forcefully terminated.\n");
[268]	3693	exit(1);
	3694	}
	3695
[27]	3696	int main(int argc, char **argv)
	3697	{
	3698	struct Args args;
	3699	struct RTCM3ParserData Parser;
	3700
	3701	setbuf(stdout, 0);
	3702	setbuf(stdin, 0);
	3703	setbuf(stderr, 0);
	3704
[2487]	3705	fixrevision();
[27]	3706
	3707	signal(SIGINT, signalhandler);
	3708	signal(SIGALRM,signalhandler_alarm);
	3709	signal(SIGQUIT,signalhandler);
	3710	signal(SIGTERM,signalhandler);
	3711	signal(SIGPIPE,signalhandler);
	3712	memset(&Parser, 0, sizeof(Parser));
	3713	{
	3714	time_t tim;
	3715	tim = time(0) - ((10365+2+5)246060+LEAPSECONDS);
	3716	Parser.GPSWeek = tim/(72460*60);
	3717	Parser.GPSTOW = tim%(72460*60);
	3718	}
	3719
	3720	if(getargs(argc, argv, &args))
	3721	{
[1088]	3722	int sockfd, numbytes;
[27]	3723	char buf[MAXDATASIZE];
[502]	3724	struct sockaddr_in their_addr; /* connector's address information */
[27]	3725	struct hostent *he;
[502]	3726	struct servent *se;
	3727	const char server, port, *proxyserver = 0;
	3728	char proxyport[6];
	3729	char *b;
	3730	long i;
	3731	struct timeval tv;
[27]	3732
[502]	3733	alarm(ALARMTIME);
	3734
[27]	3735	Parser.headerfile = args.headerfile;
[502]	3736	Parser.glonassephemeris = args.glonassephemeris;
	3737	Parser.gpsephemeris = args.gpsephemeris;
[5595]	3738	Parser.qzssephemeris = args.qzssephemeris;
[6329]	3739	Parser.sbasephemeris = args.sbasephemeris;
[502]	3740	Parser.rinex3 = args.rinex3;
[5358]	3741	Parser.changeobs = args.changeobs;
[27]	3742
[502]	3743	if(args.proxyhost)
[27]	3744	{
[502]	3745	int p;
	3746	if((i = strtol(args.port, &b, 10)) && (!b \|\| !*b))
	3747	p = i;
	3748	else if(!(se = getservbyname(args.port, 0)))
	3749	{
	3750	RTCM3Error("Can't resolve port %s.", args.port);
	3751	exit(1);
	3752	}
	3753	else
	3754	{
	3755	p = ntohs(se->s_port);
	3756	}
	3757	snprintf(proxyport, sizeof(proxyport), "%d", p);
	3758	port = args.proxyport;
	3759	proxyserver = args.server;
	3760	server = args.proxyhost;
	3761	}
	3762	else
	3763	{
	3764	server = args.server;
	3765	port = args.port;
	3766	}
	3767
	3768	memset(&their_addr, 0, sizeof(struct sockaddr_in));
	3769	if((i = strtol(port, &b, 10)) && (!b \|\| !*b))
	3770	their_addr.sin_port = htons(i);
	3771	else if(!(se = getservbyname(port, 0)))
	3772	{
	3773	RTCM3Error("Can't resolve port %s.", port);
[27]	3774	exit(1);
	3775	}
[502]	3776	else
	3777	{
	3778	their_addr.sin_port = se->s_port;
	3779	}
	3780	if(!(he=gethostbyname(server)))
	3781	{
	3782	RTCM3Error("Server name lookup failed for '%s'.\n", server);
	3783	exit(1);
	3784	}
[27]	3785	if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
	3786	{
[502]	3787	perror("socket");
[27]	3788	exit(1);
	3789	}
[477]	3790
	3791	tv.tv_sec = args.timeout;
	3792	tv.tv_usec = 0;
	3793	if(setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, (struct timeval *)&tv, sizeof(struct timeval) ) == -1)
	3794	{
	3795	RTCM3Error("Function setsockopt: %s\n", strerror(errno));
	3796	exit(1);
	3797	}
	3798
[502]	3799	their_addr.sin_family = AF_INET;
[27]	3800	their_addr.sin_addr = ((struct in_addr )he->h_addr);
[502]	3801
	3802	if(args.data && args.mode == RTSP)
[27]	3803	{
[502]	3804	struct sockaddr_in local;
	3805	int sockudp, localport;
	3806	int cseq = 1;
	3807	socklen_t len;
[27]	3808
[502]	3809	if((sockudp = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
	3810	{
	3811	perror("socket");
	3812	exit(1);
	3813	}
	3814	/* fill structure with local address information for UDP */
	3815	memset(&local, 0, sizeof(local));
[1088]	3816	local.sin_family = AF_INET;
[502]	3817	local.sin_port = htons(0);
[1088]	3818	local.sin_addr.s_addr = htonl(INADDR_ANY);
[502]	3819	len = sizeof(local);
[1088]	3820	/* bind() in order to get a random RTP client_port */
[502]	3821	if((bind(sockudp, (struct sockaddr *)&local, len)) < 0)
	3822	{
	3823	perror("bind");
	3824	exit(1);
	3825	}
[1088]	3826	if((getsockname(sockudp, (struct sockaddr*)&local, &len)) != -1)
[502]	3827	{
[1088]	3828	localport = ntohs(local.sin_port);
[502]	3829	}
	3830	else
	3831	{
[1088]	3832	perror("local access failed");
[502]	3833	exit(1);
	3834	}
	3835	if(connect(sockfd, (struct sockaddr *)&their_addr,
	3836	sizeof(struct sockaddr)) == -1)
	3837	{
	3838	perror("connect");
	3839	exit(1);
	3840	}
[27]	3841	i=snprintf(buf, MAXDATASIZE-40, /* leave some space for login */
[1088]	3842	"SETUP rtsp://%s%s%s/%s RTSP/1.0\r\n"
	3843	"CSeq: %d\r\n"
[502]	3844	"Ntrip-Version: Ntrip/2.0\r\n"
	3845	"Ntrip-Component: Ntripclient\r\n"
[27]	3846	"User-Agent: %s/%s\r\n"
[502]	3847	"Transport: RTP/GNSS;unicast;client_port=%u\r\n"
	3848	"Authorization: Basic ",
	3849	args.server, proxyserver ? ":" : "", proxyserver ? args.port : "",
	3850	args.data, cseq++, AGENTSTRING, revisionstr, localport);
[479]	3851	if(i > MAXDATASIZE-40 \|\| i < 0) /* second check for old glibc */
[27]	3852	{
[318]	3853	RTCM3Error("Requested data too long\n");
[27]	3854	exit(1);
	3855	}
[339]	3856	i += encode(buf+i, MAXDATASIZE-i-4, args.user, args.password);
	3857	if(i > MAXDATASIZE-4)
[27]	3858	{
[318]	3859	RTCM3Error("Username and/or password too long\n");
[27]	3860	exit(1);
	3861	}
[339]	3862	buf[i++] = '\r';
	3863	buf[i++] = '\n';
	3864	buf[i++] = '\r';
	3865	buf[i++] = '\n';
[502]	3866	if(args.nmea)
[27]	3867	{
[502]	3868	int j = snprintf(buf+i, MAXDATASIZE-i, "%s\r\n", args.nmea);
	3869	if(j >= 0 && j < MAXDATASIZE-i)
	3870	i += j;
	3871	else
[27]	3872	{
[502]	3873	RTCM3Error("NMEA string too long\n");
	3874	exit(1);
	3875	}
	3876	}
	3877	if(send(sockfd, buf, (size_t)i, 0) != i)
	3878	{
	3879	perror("send");
	3880	exit(1);
	3881	}
	3882	if((numbytes=recv(sockfd, buf, MAXDATASIZE-1, 0)) != -1)
	3883	{
	3884	if(numbytes >= 17 && !strncmp(buf, "RTSP/1.0 200 OK\r\n", 17))
[744]	3885	{
[502]	3886	int serverport = 0, session = 0;
	3887	const char *portcheck = "server_port=";
	3888	const char *sessioncheck = "session: ";
	3889	int l = strlen(portcheck)-1;
	3890	int j=0;
	3891	for(i = 0; j != l && i < numbytes-l; ++i)
[27]	3892	{
[502]	3893	for(j = 0; j < l && tolower(buf[i+j]) == portcheck[j]; ++j)
	3894	;
	3895	}
	3896	if(i == numbytes-l)
	3897	{
	3898	RTCM3Error("No server port number found\n");
	3899	exit(1);
	3900	}
	3901	else
	3902	{
	3903	i+=l;
	3904	while(i < numbytes && buf[i] >= '0' && buf[i] <= '9')
	3905	serverport = serverport * 10 + buf[i++]-'0';
	3906	if(buf[i] != '\r' && buf[i] != ';')
[27]	3907	{
[502]	3908	RTCM3Error("Could not extract server port\n");
	3909	exit(1);
[27]	3910	}
[502]	3911	}
	3912	l = strlen(sessioncheck)-1;
	3913	j=0;
	3914	for(i = 0; j != l && i < numbytes-l; ++i)
	3915	{
	3916	for(j = 0; j < l && tolower(buf[i+j]) == sessioncheck[j]; ++j)
	3917	;
	3918	}
	3919	if(i == numbytes-l)
	3920	{
	3921	RTCM3Error("No session number found\n");
[27]	3922	exit(1);
	3923	}
[502]	3924	else
	3925	{
	3926	i+=l;
	3927	while(i < numbytes && buf[i] >= '0' && buf[i] <= '9')
	3928	session = session * 10 + buf[i++]-'0';
	3929	if(buf[i] != '\r')
	3930	{
	3931	RTCM3Error("Could not extract session number\n");
	3932	exit(1);
	3933	}
	3934	}
	3935
	3936	i = snprintf(buf, MAXDATASIZE,
[1088]	3937	"PLAY rtsp://%s%s%s/%s RTSP/1.0\r\n"
[502]	3938	"CSeq: %d\r\n"
	3939	"Session: %d\r\n"
[1088]	3940	"\r\n",
[502]	3941	args.server, proxyserver ? ":" : "", proxyserver ? args.port : "",
	3942	args.data, cseq++, session);
	3943
	3944	if(i > MAXDATASIZE \|\| i < 0) /* second check for old glibc */
	3945	{
	3946	RTCM3Error("Requested data too long\n");
	3947	exit(1);
	3948	}
	3949	if(send(sockfd, buf, (size_t)i, 0) != i)
	3950	{
	3951	perror("send");
	3952	exit(1);
	3953	}
	3954	if((numbytes=recv(sockfd, buf, MAXDATASIZE-1, 0)) != -1)
	3955	{
	3956	if(numbytes >= 17 && !strncmp(buf, "RTSP/1.0 200 OK\r\n", 17))
	3957	{
	3958	struct sockaddr_in addrRTP;
	3959	/* fill structure with caster address information for UDP */
	3960	memset(&addrRTP, 0, sizeof(addrRTP));
[1088]	3961	addrRTP.sin_family = AF_INET;
[502]	3962	addrRTP.sin_port = htons(serverport);
	3963	their_addr.sin_addr = ((struct in_addr )he->h_addr);
	3964	len = sizeof(addrRTP);
	3965	int ts = 0;
	3966	int sn = 0;
	3967	int ssrc = 0;
	3968	int init = 0;
	3969	int u, v, w;
	3970	while(!stop && (i = recvfrom(sockudp, buf, 1526, 0,
	3971	(struct sockaddr*) &addrRTP, &len)) > 0)
	3972	{
	3973	alarm(ALARMTIME);
	3974	if(i >= 12+1 && (unsigned char)buf[0] == (2 << 6) && buf[1] == 0x60)
	3975	{
	3976	u= ((unsigned char)buf[2]<<8)+(unsigned char)buf[3];
	3977	v = ((unsigned char)buf[4]<<24)+((unsigned char)buf[5]<<16)
	3978	+((unsigned char)buf[6]<<8)+(unsigned char)buf[7];
	3979	w = ((unsigned char)buf[8]<<24)+((unsigned char)buf[9]<<16)
	3980	+((unsigned char)buf[10]<<8)+(unsigned char)buf[11];
	3981
	3982	if(init)
	3983	{
[1091]	3984	int z;
[502]	3985	if(u < -30000 && sn > 30000) sn -= 0xFFFF;
	3986	if(ssrc != w \|\| ts > v)
	3987	{
	3988	RTCM3Error("Illegal UDP data received.\n");
	3989	exit(1);
	3990	}
	3991	if(u > sn) /* don't show out-of-order packets */
[1091]	3992	for(z = 12; z < i && !stop; ++z)
	3993	HandleByte(&Parser, (unsigned int) buf[z]);
[502]	3994	}
	3995	sn = u; ts = v; ssrc = w; init = 1;
	3996	}
	3997	else
	3998	{
	3999	RTCM3Error("Illegal UDP header.\n");
	4000	exit(1);
	4001	}
	4002	}
	4003	}
	4004	i = snprintf(buf, MAXDATASIZE,
[1088]	4005	"TEARDOWN rtsp://%s%s%s/%s RTSP/1.0\r\n"
[502]	4006	"CSeq: %d\r\n"
	4007	"Session: %d\r\n"
[1088]	4008	"\r\n",
[502]	4009	args.server, proxyserver ? ":" : "", proxyserver ? args.port : "",
	4010	args.data, cseq++, session);
	4011
	4012	if(i > MAXDATASIZE \|\| i < 0) /* second check for old glibc */
	4013	{
	4014	RTCM3Error("Requested data too long\n");
	4015	exit(1);
	4016	}
	4017	if(send(sockfd, buf, (size_t)i, 0) != i)
	4018	{
	4019	perror("send");
	4020	exit(1);
	4021	}
	4022	}
	4023	else
	4024	{
	4025	RTCM3Error("Could not start data stream.\n");
	4026	exit(1);
	4027	}
[27]	4028	}
	4029	else
	4030	{
[502]	4031	RTCM3Error("Could not setup initial control connection.\n");
	4032	exit(1);
[27]	4033	}
	4034	}
[502]	4035	else
	4036	{
	4037	perror("recv");
	4038	exit(1);
	4039	}
[27]	4040	}
	4041	else
	4042	{
[502]	4043	if(connect(sockfd, (struct sockaddr *)&their_addr,
	4044	sizeof(struct sockaddr)) == -1)
[27]	4045	{
[502]	4046	perror("connect");
	4047	exit(1);
[27]	4048	}
[502]	4049	if(!args.data)
	4050	{
	4051	i = snprintf(buf, MAXDATASIZE,
	4052	"GET %s%s%s%s/ HTTP/1.0\r\n"
	4053	"Host: %s\r\n%s"
	4054	"User-Agent: %s/%s\r\n"
[646]	4055	"Connection: close\r\n"
[502]	4056	"\r\n"
	4057	, proxyserver ? "http://" : "", proxyserver ? proxyserver : "",
	4058	proxyserver ? ":" : "", proxyserver ? proxyport : "",
	4059	args.server, args.mode == NTRIP1 ? "" : "Ntrip-Version: Ntrip/2.0\r\n",
	4060	AGENTSTRING, revisionstr);
	4061	}
	4062	else
	4063	{
	4064	i=snprintf(buf, MAXDATASIZE-40, /* leave some space for login */
	4065	"GET %s%s%s%s/%s HTTP/1.0\r\n"
	4066	"Host: %s\r\n%s"
	4067	"User-Agent: %s/%s\r\n"
[646]	4068	"Connection: close\r\n"
[502]	4069	"Authorization: Basic "
	4070	, proxyserver ? "http://" : "", proxyserver ? proxyserver : "",
	4071	proxyserver ? ":" : "", proxyserver ? proxyport : "",
	4072	args.data, args.server,
	4073	args.mode == NTRIP1 ? "" : "Ntrip-Version: Ntrip/2.0\r\n",
	4074	AGENTSTRING, revisionstr);
	4075	if(i > MAXDATASIZE-40 \|\| i < 0) /* second check for old glibc */
	4076	{
	4077	RTCM3Error("Requested data too long\n");
	4078	exit(1);
	4079	}
	4080	i += encode(buf+i, MAXDATASIZE-i-4, args.user, args.password);
	4081	if(i > MAXDATASIZE-4)
	4082	{
	4083	RTCM3Error("Username and/or password too long\n");
	4084	exit(1);
	4085	}
	4086	buf[i++] = '\r';
	4087	buf[i++] = '\n';
	4088	buf[i++] = '\r';
	4089	buf[i++] = '\n';
	4090	if(args.nmea)
	4091	{
	4092	int j = snprintf(buf+i, MAXDATASIZE-i, "%s\r\n", args.nmea);
	4093	if(j >= 0 && j < MAXDATASIZE-i)
	4094	i += j;
	4095	else
	4096	{
	4097	RTCM3Error("NMEA string too long\n");
	4098	exit(1);
	4099	}
	4100	}
	4101	}
	4102	if(send(sockfd, buf, (size_t)i, 0) != i)
	4103	{
	4104	perror("send");
	4105	exit(1);
	4106	}
	4107	if(args.data)
	4108	{
	4109	int k = 0;
	4110	int chunkymode = 0;
	4111	int totalbytes = 0;
	4112	int chunksize = 0;
	4113
	4114	while(!stop && (numbytes=recv(sockfd, buf, MAXDATASIZE-1, 0)) != -1)
	4115	{
[1091]	4116	if(numbytes > 0)
	4117	alarm(ALARMTIME);
	4118	else
	4119	{
	4120	WaitMicro(100);
	4121	continue;
	4122	}
[502]	4123	if(!k)
	4124	{
	4125	if(numbytes > 17 && (!strncmp(buf, "HTTP/1.1 200 OK\r\n", 17)
	4126	\|\| !strncmp(buf, "HTTP/1.0 200 OK\r\n", 17)))
[744]	4127	{
[502]	4128	const char *datacheck = "Content-Type: gnss/data\r\n";
	4129	const char *chunkycheck = "Transfer-Encoding: chunked\r\n";
	4130	int l = strlen(datacheck)-1;
	4131	int j=0;
	4132	for(i = 0; j != l && i < numbytes-l; ++i)
	4133	{
	4134	for(j = 0; j < l && buf[i+j] == datacheck[j]; ++j)
	4135	;
	4136	}
	4137	if(i == numbytes-l)
	4138	{
	4139	RTCM3Error("No 'Content-Type: gnss/data' found\n");
	4140	exit(1);
	4141	}
	4142	l = strlen(chunkycheck)-1;
	4143	j=0;
	4144	for(i = 0; j != l && i < numbytes-l; ++i)
	4145	{
	4146	for(j = 0; j < l && buf[i+j] == chunkycheck[j]; ++j)
	4147	;
	4148	}
	4149	if(i < numbytes-l)
	4150	chunkymode = 1;
[1091]	4151	}
[502]	4152	else if(numbytes < 12 \|\| strncmp("ICY 200 OK\r\n", buf, 12))
	4153	{
	4154	RTCM3Error("Could not get the requested data: ");
	4155	for(k = 0; k < numbytes && buf[k] != '\n' && buf[k] != '\r'; ++k)
	4156	{
	4157	RTCM3Error("%c", isprint(buf[k]) ? buf[k] : '.');
	4158	}
	4159	RTCM3Error("\n");
	4160	exit(1);
	4161	}
	4162	else if(args.mode != NTRIP1)
	4163	{
	4164	if(args.mode != AUTO)
	4165	{
	4166	RTCM3Error("NTRIP version 2 HTTP connection failed%s.\n",
	4167	args.mode == AUTO ? ", falling back to NTRIP1" : "");
	4168	}
	4169	if(args.mode == HTTP)
	4170	exit(1);
	4171	}
	4172	++k;
	4173	}
	4174	else
	4175	{
	4176	if(chunkymode)
	4177	{
	4178	int stop = 0;
	4179	int pos = 0;
	4180	while(!stop && pos < numbytes)
	4181	{
	4182	switch(chunkymode)
	4183	{
	4184	case 1: /* reading number starts */
	4185	chunksize = 0;
	4186	++chunkymode; /* no break */
	4187	case 2: /* during reading number */
	4188	i = buf[pos++];
	4189	if(i >= '0' && i <= '9') chunksize = chunksize*16+i-'0';
	4190	else if(i >= 'a' && i <= 'f') chunksize = chunksize*16+i-'a'+10;
	4191	else if(i >= 'A' && i <= 'F') chunksize = chunksize*16+i-'A'+10;
	4192	else if(i == '\r') ++chunkymode;
[646]	4193	else if(i == ';') chunkymode = 5;
[502]	4194	else stop = 1;
	4195	break;
	4196	case 3: /* scanning for return */
	4197	if(buf[pos++] == '\n') chunkymode = chunksize ? 4 : 1;
	4198	else stop = 1;
	4199	break;
	4200	case 4: /* output data */
	4201	i = numbytes-pos;
	4202	if(i > chunksize) i = chunksize;
	4203	{
	4204	int z;
	4205	for(z = 0; z < i && !stop; ++z)
	4206	HandleByte(&Parser, (unsigned int) buf[pos+z]);
	4207	}
	4208	totalbytes += i;
	4209	chunksize -= i;
	4210	pos += i;
	4211	if(!chunksize)
	4212	chunkymode = 1;
	4213	break;
[646]	4214	case 5:
	4215	if(i == '\r') chunkymode = 3;
	4216	break;
[502]	4217	}
	4218	}
	4219	if(stop)
	4220	{
	4221	RTCM3Error("Error in chunky transfer encoding\n");
	4222	break;
	4223	}
	4224	}
	4225	else
	4226	{
	4227	totalbytes += numbytes;
	4228	{
	4229	int z;
	4230	for(z = 0; z < numbytes && !stop; ++z)
	4231	HandleByte(&Parser, (unsigned int) buf[z]);
	4232	}
	4233	}
	4234	if(totalbytes < 0) /* overflow */
	4235	{
	4236	totalbytes = 0;
	4237	}
	4238	}
	4239	}
	4240	}
	4241	else
	4242	{
	4243	while(!stop && (numbytes=recv(sockfd, buf, MAXDATASIZE-1, 0)) > 0)
	4244	{
	4245	alarm(ALARMTIME);
	4246	fwrite(buf, (size_t)numbytes, 1, stdout);
	4247	}
	4248	}
	4249	close(sockfd);
[27]	4250	}
	4251	}
	4252	return 0;
	4253	}
[268]	4254	#endif /* NO_RTCM3_MAIN */

Note: See TracBrowser for help on using the repository browser.

Download in other formats: