/*

 * liblognorm - a fast samples-based log normalization library

 * Copyright 2010-2018 by Rainer Gerhards and Adiscon GmbH.

 *

 * Modified by Pavel Levshin (pavel@levshin.spb.ru) in 2013

 *

 * This file is part of liblognorm.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

 *

 * A copy of the LGPL v2.1 can be found in the file "COPYING" in this distribution.

 */

#include "config.h"

#include <stdlib.h>

#include <stdio.h>

#include <stdarg.h>

#include <assert.h>

#include <ctype.h>

#include <sys/types.h>

#include <string.h>

#include <strings.h>

#include <errno.h>

#include <inttypes.h>

#include <time.h>

#include "liblognorm.h"

#include "lognorm.h"

#include "internal.h"

#include "parser.h"

#include "samp.h"

#include "helpers.h"

#ifdef FEATURE_REGEXP

#include <pcre.h>

#include <errno.h>

#endif

/* how should output values be formatted? */

enum FMT_MODE {

	FMT_AS_STRING = 0,

	FMT_AS_NUMBER = 1,

	FMT_AS_TIMESTAMP_UX = 2,

	FMT_AS_TIMESTAMP_UX_MS = 3

	};

/* some helpers */

static inline int

hParseInt(const unsigned char **buf, size_t *lenBuf)

{

	const unsigned char *p = *buf;

	size_t len = *lenBuf;

	int i = 0;

	while(len > 0 && myisdigit(*p)) {

		i = i * 10 + *p - '0';

		++p;

		--len;

	}

	*buf = p;

	*lenBuf = len;

	return i;

}

/* parser _parse interface

 *

 * All parsers receive

 *

 * @param[in] npb->str the to-be-parsed string

 * @param[in] npb->strLen length of the to-be-parsed string

 * @param[in] offs an offset into the string

 * @param[in] pointer to parser data block

 * @param[out] parsed bytes

 * @param[out] value ptr to json object containing parsed data

 *             (can be unused, but if used *value MUST be NULL on entry)

 *

 * They will try to parse out "their" object from the string. If they

 * succeed, they:

 *

 * return 0 on success and LN_WRONGPARSER if this parser could

 *           not successfully parse (but all went well otherwise) and something

 *           else in case of an error.

 */

#define PARSER_Parse(ParserName) \

int ln_v2_parse##ParserName( \

	npb_t *const npb, \

	size_t *const offs,       \

	__attribute__((unused)) void *const pdata, \

	size_t *parsed,                                      \

	struct json_object **value) \

{ \

	int r = LN_WRONGPARSER; \

	*parsed = 0;

#define FAILParser \

	goto parserdone; /* suppress warnings */ \

parserdone: \

	r = 0; \

	goto done; /* suppress warnings */ \

done:

#define ENDFailParser \

	return r; \

}

/* Return printable representation of parser content for

 * display purposes. This must not be 100% exact, but provide

 * a good indication of what it contains for a human.

 * @param[data] data parser data block

 * @return pointer to c string, NOT to be freed

 */

#define PARSER_DataForDisplay(ParserName) \

const char * ln_DataForDisplay##ParserName(__attribute__((unused)) ln_ctx ctx, void *const pdata)

/* Return JSON parser config. This is primarily for comparison

 * of parser equalness.

 * @param[data] data parser data block

 * @return pointer to c string, NOT to be freed

 */

#define PARSER_JsonConf(ParserName) \

const char * ln_JsonConf##ParserName(__attribute__((unused)) ln_ctx ctx, void *const pdata)

/* parser constructor

 * @param[in] json config json items

 * @param[out] data parser data block (to be allocated)

 * At minimum, *data must be set to NULL

 * @return error status (0 == OK)

 */

#define PARSER_Construct(ParserName) \

int ln_construct##ParserName( \

	__attribute__((unused)) ln_ctx ctx, \

	__attribute__((unused)) json_object *const json, \

	void **pdata)

/* parser destructor

 * @param[data] data parser data block (to be de-allocated)

 */

#define PARSER_Destruct(ParserName) \

void ln_destruct##ParserName(__attribute__((unused)) ln_ctx ctx, void *const pdata)

/* the following table saves us from computing an additional date to get

 * the ordinal day of the year - at least from 1967-2099

 * Note: non-2038+ compliant systems (Solaris) will generate compiler

 * warnings on the post 2038-rollover years.

 */

static const int yearInSec_startYear = 1967;

/* for x in $(seq 1967 2099) ; do

 *   printf %s', ' $(date --date="Dec 31 ${x} UTC 23:59:59" +%s)

 * done |fold -w 70 -s */

static const time_t yearInSecs[] = {

	-63158401, -31536001, -1, 31535999, 63071999, 94694399, 126230399,

	157766399, 189302399, 220924799, 252460799, 283996799, 315532799,

	347155199, 378691199, 410227199, 441763199, 473385599, 504921599,

	536457599, 567993599, 599615999, 631151999, 662687999, 694223999,

	725846399, 757382399, 788918399, 820454399, 852076799, 883612799,

	915148799, 946684799, 978307199, 1009843199, 1041379199, 1072915199,

	1104537599, 1136073599, 1167609599, 1199145599, 1230767999,

	1262303999, 1293839999, 1325375999, 1356998399, 1388534399,

	1420070399, 1451606399, 1483228799, 1514764799, 1546300799,

	1577836799, 1609459199, 1640995199, 1672531199, 1704067199,

	1735689599, 1767225599, 1798761599, 1830297599, 1861919999,

	1893455999, 1924991999, 1956527999, 1988150399, 2019686399,

	2051222399, 2082758399, 2114380799, 2145916799, 2177452799,

	2208988799, 2240611199, 2272147199, 2303683199, 2335219199,

	2366841599, 2398377599, 2429913599, 2461449599, 2493071999,

	2524607999, 2556143999, 2587679999, 2619302399, 2650838399,

	2682374399, 2713910399, 2745532799, 2777068799, 2808604799,

	2840140799, 2871763199, 2903299199, 2934835199, 2966371199,

	2997993599, 3029529599, 3061065599, 3092601599, 3124223999,

	3155759999, 3187295999, 3218831999, 3250454399, 3281990399,

	3313526399, 3345062399, 3376684799, 3408220799, 3439756799,

	3471292799, 3502915199, 3534451199, 3565987199, 3597523199,

	3629145599, 3660681599, 3692217599, 3723753599, 3755375999,

	3786911999, 3818447999, 3849983999, 3881606399, 3913142399,

	3944678399, 3976214399, 4007836799, 4039372799, 4070908799,

	4102444799};

/**

 * convert syslog timestamp to time_t

 * Note: it would be better to use something similar to mktime() here.

 * Unfortunately, mktime() semantics are problematic: first of all, it

 * works on local time, on the machine's time zone. In syslog, we have

 * to deal with multiple time zones at once, so we cannot plainly rely

 * on the local zone, and so we cannot rely on mktime(). One solution would

 * be to refactor all time-related functions so that they are all guarded

 * by a mutex to ensure TZ consistency (which would also enable us to

 * change the TZ at will for specific function calls). But that would

 * potentially mean a lot of overhead.

 * Also, mktime() has some side effects, at least setting of tzname. With

 * a refactoring as described above that should probably not be a problem,

 * but would also need more work. For some more thoughts on this topic,

 * have a look here:

 * http://stackoverflow.com/questions/18355101/is-standard-c-mktime-thread-safe-on-linux

 * In conclusion, we keep our own code for generating the unix timestamp.

 * rgerhards, 2016-03-02 (taken from rsyslog sources)

 */

static time_t

syslogTime2time_t(const int year, const int month, const int day,

	const int hour, const int minute, const int second,

	const int OffsetHour, const int OffsetMinute, const char OffsetMode)

{

	long MonthInDays, NumberOfYears, NumberOfDays;

	int utcOffset;

	time_t TimeInUnixFormat;

	if(year < 1970 || year > 2100) {

		TimeInUnixFormat = 0;

		goto done;

	}

	/* Counting how many Days have passed since the 01.01 of the

	 * selected Year (Month level), according to the selected Month*/

	switch(month)

	{

		case 1:

			MonthInDays = 0;         //until 01 of January

			break;

		case 2:

			MonthInDays = 31;        //until 01 of February - leap year handling down below!

			break;

		case 3:

			MonthInDays = 59;        //until 01 of March

			break;

		case 4:

			MonthInDays = 90;        //until 01 of April

			break;

		case 5:

			MonthInDays = 120;       //until 01 of Mai

			break;

		case 6:

			MonthInDays = 151;       //until 01 of June

			break;

		case 7:

			MonthInDays = 181;       //until 01 of July

			break;

		case 8:

			MonthInDays = 212;       //until 01 of August

			break;

		case 9:

			MonthInDays = 243;       //until 01 of September

			break;

		case 10:

			MonthInDays = 273;       //until 01 of Oktober

			break;

		case 11:

			MonthInDays = 304;       //until 01 of November

			break;

		case 12:

			MonthInDays = 334;       //until 01 of December

			break;

		default: /* this cannot happen (and would be a program error)

		          * but we need the code to keep the compiler silent.

			  */

			MonthInDays = 0;	/* any value fits ;) */

			break;

	}

	/* adjust for leap years */

	if((year % 100 != 0 && year % 4 == 0) || (year == 2000)) {

		if(month > 2)

			MonthInDays++;

	}

	/*	1) Counting how many Years have passed since 1970

		2) Counting how many Days have passed since the 01.01 of the selected Year

			(Day level) according to the Selected Month and Day. Last day doesn't count,

			it should be until last day

		3) Calculating this period (NumberOfDays) in seconds*/

	NumberOfYears = year - yearInSec_startYear - 1;

	NumberOfDays = MonthInDays + day - 1;

	TimeInUnixFormat = (yearInSecs[NumberOfYears] + 1) + NumberOfDays * 86400;

	/*Add Hours, minutes and seconds */

	TimeInUnixFormat += hour*60*60;

	TimeInUnixFormat += minute*60;

	TimeInUnixFormat += second;

	/* do UTC offset */

	utcOffset = OffsetHour*3600 + OffsetMinute*60;

	if(OffsetMode == '+')

		utcOffset *= -1; /* if timestamp is ahead, we need to "go back" to UTC */

	TimeInUnixFormat += utcOffset;

done:

	return TimeInUnixFormat;

}

struct data_RFC5424Date {

	enum FMT_MODE fmt_mode;

};

/**

 * Parse a TIMESTAMP as specified in RFC5424 (subset of RFC3339).

 */

PARSER_Parse(RFC5424Date)

	const unsigned char *pszTS;

	struct data_RFC5424Date *const data = (struct data_RFC5424Date*) pdata;

	/* variables to temporarily hold time information while we parse */

	int year;

	int month;

	int day;

	int hour; /* 24 hour clock */

	int minute;

	int second;

	int secfrac;	/* fractional seconds (must be 32 bit!) */

	int secfracPrecision;

	int OffsetHour;		/* UTC offset in hours */

	int OffsetMinute;	/* UTC offset in minutes */

	char OffsetMode;

	size_t len;

	size_t orglen;

	/* end variables to temporarily hold time information while we parse */

	pszTS = (unsigned char*) npb->str + *offs;

	len = orglen = npb->strLen - *offs;

	year = hParseInt(&pszTS, &len;;

	/* We take the liberty to accept slightly malformed timestamps e.g. in

	 * the format of 2003-9-1T1:0:0.  */

	if(len == 0 || *pszTS++ != '-') goto done;

	--len;

	month = hParseInt(&pszTS, &len;;

	if(month < 1 || month > 12) goto done;

	if(len == 0 || *pszTS++ != '-')

		goto done;

	--len;

	day = hParseInt(&pszTS, &len;;

	if(day < 1 || day > 31) goto done;

	if(len == 0 || *pszTS++ != 'T') goto done;

	--len;

	hour = hParseInt(&pszTS, &len;;

	if(hour < 0 || hour > 23) goto done;

	if(len == 0 || *pszTS++ != ':')

		goto done;

	--len;

	minute = hParseInt(&pszTS, &len;;

	if(minute < 0 || minute > 59) goto done;

	if(len == 0 || *pszTS++ != ':') goto done;

	--len;

	second = hParseInt(&pszTS, &len;;

	if(second < 0 || second > 60) goto done;

	/* Now let's see if we have secfrac */

	if(len > 0 && *pszTS == '.') {

		--len;

		const unsigned char *pszStart = ++pszTS;

		secfrac = hParseInt(&pszTS, &len;;

		secfracPrecision = (int) (pszTS - pszStart);

	} else {

		secfracPrecision = 0;

		secfrac = 0;

	}

	/* check the timezone */

	if(len == 0) goto done;

	if(*pszTS == 'Z') {

		OffsetHour = 0;

		OffsetMinute = 0;

		OffsetMode = '+';

		--len;

		pszTS++; /* eat Z */

	} else if((*pszTS == '+') || (*pszTS == '-')) {

		OffsetMode = *pszTS;

		--len;

		pszTS++;

		OffsetHour = hParseInt(&pszTS, &len;;

		if(OffsetHour < 0 || OffsetHour > 23)

			goto done;

		if(len == 0 || *pszTS++ != ':')

			goto done;

		--len;

		OffsetMinute = hParseInt(&pszTS, &len;;

		if(OffsetMinute < 0 || OffsetMinute > 59)

			goto done;

	} else {

		/* there MUST be TZ information */

		goto done;

	}

	if(len > 0) {

		if(*pszTS != ' ') /* if it is not a space, it can not be a "good" time */

			goto done;

	}

	/* we had success, so update parse pointer */

	*parsed = orglen - len;

	if(value != NULL) {

		if(data->fmt_mode == FMT_AS_STRING) {

			*value = json_object_new_string_len(npb->str+(*offs), *parsed);

		} else {

			int64_t timestamp = syslogTime2time_t(year, month, day,

				hour, minute, second, OffsetHour, OffsetMinute, OffsetMode);

			if(data->fmt_mode == FMT_AS_TIMESTAMP_UX_MS) {

				timestamp *= 1000;

				/* simulate pow(), do not use math lib! */

				int div = 1;

				if(secfracPrecision == 1) {

					secfrac *= 100;

				} else if(secfracPrecision == 2) {

					secfrac *= 10;

				} else if(secfracPrecision > 3) {

					for(int i = 0 ; i < (secfracPrecision - 3) ; ++i)

						div *= 10;

				}

				timestamp += secfrac / div;

			}

			*value = json_object_new_int64(timestamp);

		}

	}

	r = 0; /* success */

done:

	return r;

}

PARSER_Construct(RFC5424Date)

{

	int r = 0;

	struct data_RFC5424Date *data =

		(struct data_RFC5424Date*) calloc(1, sizeof(struct data_RFC5424Date));

	data->fmt_mode = FMT_AS_STRING;

	if(json == NULL)

		goto done;

	struct json_object_iterator it = json_object_iter_begin(json);

	struct json_object_iterator itEnd = json_object_iter_end(json);

	while (!json_object_iter_equal(&it, &itEnd)) {

		const char *key = json_object_iter_peek_name(&it);

		struct json_object *const val = json_object_iter_peek_value(&it);

		if(!strcmp(key, "format")) {

			const char *fmtmode = json_object_get_string(val);

			if(!strcmp(fmtmode, "timestamp-unix")) {

				data->fmt_mode = FMT_AS_TIMESTAMP_UX;

			} else if(!strcmp(fmtmode, "timestamp-unix-ms")) {

				data->fmt_mode = FMT_AS_TIMESTAMP_UX_MS;

			} else if(!strcmp(fmtmode, "string")) {

				data->fmt_mode = FMT_AS_STRING;

			} else {

				ln_errprintf(ctx, 0, "invalid value for date-rfc5424:format %s",

					fmtmode);

			}

		} else {

			ln_errprintf(ctx, 0, "invalid param for date-rfc5424 %s", key);

		}

		json_object_iter_next(&it);

	}

done:

	*pdata = data;

	return r;

}

PARSER_Destruct(RFC5424Date)

{

	free(pdata);

}

struct data_RFC3164Date {

	enum FMT_MODE fmt_mode;

};

/**

 * Parse a RFC3164 Date.

 */

PARSER_Parse(RFC3164Date)

	const unsigned char *p;

	size_t len, orglen;

	struct data_RFC3164Date *const data = (struct data_RFC3164Date*) pdata;

	/* variables to temporarily hold time information while we parse */

	int year;

	int month;

	int day;

	int hour; /* 24 hour clock */

	int minute;

	int second;

	p = (unsigned char*) npb->str + *offs;

	orglen = len = npb->strLen - *offs;

	/* If we look at the month (Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec),

	 * we may see the following character sequences occur:

	 *

	 * J(an/u(n/l)), Feb, Ma(r/y), A(pr/ug), Sep, Oct, Nov, Dec

	 *

	 * We will use this for parsing, as it probably is the

	 * fastest way to parse it.

	 */

	if(len < 3)

		goto done;

	switch(*p++)

	{

	case 'j':

	case 'J':

		if(*p == 'a' || *p == 'A') {

			++p;

			if(*p == 'n' || *p == 'N') {

				++p;

				month = 1;

			} else

				goto done;

		} else if(*p == 'u' || *p == 'U') {

			++p;

			if(*p == 'n' || *p == 'N') {

				++p;

				month = 6;

			} else if(*p == 'l' || *p == 'L') {

				++p;

				month = 7;

			} else

				goto done;

		} else

			goto done;

		break;

	case 'f':

	case 'F':

		if(*p == 'e' || *p == 'E') {

			++p;

			if(*p == 'b' || *p == 'B') {

				++p;

				month = 2;

			} else

				goto done;

		} else

			goto done;

		break;

	case 'm':

	case 'M':

		if(*p == 'a' || *p == 'A') {

			++p;

			if(*p == 'r' || *p == 'R') {

				++p;

				month = 3;

			} else if(*p == 'y' || *p == 'Y') {

				++p;

				month = 5;

			} else

				goto done;

		} else

			goto done;

		break;

	case 'a':

	case 'A':

		if(*p == 'p' || *p == 'P') {

			++p;

			if(*p == 'r' || *p == 'R') {

				++p;

				month = 4;

			} else

				goto done;

		} else if(*p == 'u' || *p == 'U') {

			++p;

			if(*p == 'g' || *p == 'G') {

				++p;

				month = 8;

			} else

				goto done;

		} else

			goto done;

		break;

	case 's':

	case 'S':

		if(*p == 'e' || *p == 'E') {

			++p;

			if(*p == 'p' || *p == 'P') {

				++p;

				month = 9;

			} else

				goto done;

		} else

			goto done;

		break;

	case 'o':

	case 'O':

		if(*p == 'c' || *p == 'C') {

			++p;

			if(*p == 't' || *p == 'T') {

				++p;

				month = 10;

			} else

				goto done;

		} else

			goto done;

		break;

	case 'n':

	case 'N':

		if(*p == 'o' || *p == 'O') {

			++p;

			if(*p == 'v' || *p == 'V') {

				++p;

				month = 11;

			} else

				goto done;

		} else

			goto done;

		break;

	case 'd':

	case 'D':

		if(*p == 'e' || *p == 'E') {

			++p;

			if(*p == 'c' || *p == 'C') {

				++p;

				month = 12;

			} else

				goto done;

		} else

			goto done;

		break;

	default:

		goto done;

	}

	len -= 3;

	/* done month */

	if(len == 0 || *p++ != ' ')

		goto done;

	--len;

	/* we accept a slightly malformed timestamp with one-digit days. */

	if(*p == ' ') {

		--len;

		++p;

	}

	day = hParseInt(&p, &len;;

	if(day < 1 || day > 31)

		goto done;

	if(len == 0 || *p++ != ' ')

		goto done;

	--len;

	/* time part */

	hour = hParseInt(&p, &len;;

	if(hour > 1970 && hour < 2100) {

		/* if so, we assume this actually is a year. This is a format found

		 * e.g. in Cisco devices.

		 *

		year = hour;

		*/

		/* re-query the hour, this time it must be valid */

		if(len == 0 || *p++ != ' ')

			goto done;

		--len;

		hour = hParseInt(&p, &len;;

	}

	if(hour < 0 || hour > 23)

		goto done;

	if(len == 0 || *p++ != ':')

		goto done;

	--len;

	minute = hParseInt(&p, &len;;

	if(minute < 0 || minute > 59)

		goto done;

	if(len == 0 || *p++ != ':')

		goto done;

	--len;

	second = hParseInt(&p, &len;;

	if(second < 0 || second > 60)

		goto done;

	/* we provide support for an extra ":" after the date. While this is an

	 * invalid format, it occurs frequently enough (e.g. with Cisco devices)

	 * to permit it as a valid case. -- rgerhards, 2008-09-12

	 */

	if(len > 0 && *p == ':') {

		++p; /* just skip past it */

		--len;

	}

	/* we had success, so update parse pointer */

	*parsed = orglen - len;

	if(value != NULL) {

		if(data->fmt_mode == FMT_AS_STRING) {

			*value = json_object_new_string_len(npb->str+(*offs), *parsed);

		} else {

			/* we assume year == current year, so let's obtain current year */

			struct tm tm;

			const time_t curr = time(NULL);

			gmtime_r(&curr, &tm;;

			year = tm.tm_year + 1900;

			int64_t timestamp = syslogTime2time_t(year, month, day,

				hour, minute, second, 0, 0, '+');

			if(data->fmt_mode == FMT_AS_TIMESTAMP_UX_MS) {

				/* we do not have more precise info, just bring

				 * into common format!

				 */

				timestamp *= 1000;

			}

			*value = json_object_new_int64(timestamp);

		}

	}

	r = 0; /* success */

done:

	return r;

}

PARSER_Construct(RFC3164Date)

{

	int r = 0;

	struct data_RFC3164Date *data = (struct data_RFC3164Date*) calloc(1, sizeof(struct data_RFC3164Date));

	data->fmt_mode = FMT_AS_STRING;

	if(json == NULL)

		goto done;

	struct json_object_iterator it = json_object_iter_begin(json);

	struct json_object_iterator itEnd = json_object_iter_end(json);

	while (!json_object_iter_equal(&it, &itEnd)) {

		const char *key = json_object_iter_peek_name(&it);

		struct json_object *const val = json_object_iter_peek_value(&it);

		if(!strcmp(key, "format")) {

			const char *fmtmode = json_object_get_string(val);

			if(!strcmp(fmtmode, "timestamp-unix")) {

				data->fmt_mode = FMT_AS_TIMESTAMP_UX;

			} else if(!strcmp(fmtmode, "timestamp-unix-ms")) {

				data->fmt_mode = FMT_AS_TIMESTAMP_UX_MS;

			} else if(!strcmp(fmtmode, "string")) {

				data->fmt_mode = FMT_AS_STRING;

			} else {

				ln_errprintf(ctx, 0, "invalid value for date-rfc3164:format %s",

					fmtmode);

			}

		} else {

			ln_errprintf(ctx, 0, "invalid param for date-rfc3164 %s", key);

		}

		json_object_iter_next(&it);

	}

done:

	*pdata = data;

	return r;

}

PARSER_Destruct(RFC3164Date)

{

	free(pdata);

}

struct data_Number {

	int64_t maxval;

	enum FMT_MODE fmt_mode;

};

/**

 * Parse a Number.

 * Note that a number is an abstracted concept. We always represent it

 * as 64 bits (but may later change our mind if performance dictates so).

 */

PARSER_Parse(Number)

	const char *c;

	size_t i;

	int64_t val = 0;

	struct data_Number *const data = (struct data_Number*) pdata;

	enum FMT_MODE fmt_mode = FMT_AS_STRING;

	int64_t maxval = 0;

	if(data != NULL) {

		fmt_mode = data->fmt_mode;

		maxval = data->maxval;

	}

	assert(npb->str != NULL);

	assert(offs != NULL);

	assert(parsed != NULL);

	c = npb->str;

	for (i = *offs; i < npb->strLen && myisdigit(c[i]); i++)

		val = val * 10 + c[i] - '0';

	if(maxval > 0 && val > maxval) {

		LN_DBGPRINTF(npb->ctx, "number parser: val too large (max %" PRIu64

			     ", actual %" PRIu64 ")",

			     maxval, val);

		goto done;

	}

	if (i == *offs)

		goto done;

	/* success, persist */

	*parsed = i - *offs;

	if(value != NULL) {

		if(fmt_mode == FMT_AS_STRING) {

			*value = json_object_new_string_len(npb->str+(*offs), *parsed);

		} else {

			*value = json_object_new_int64(val);

		}

	}

	r = 0; /* success */

done:

	return r;

}

PARSER_Construct(Number)

{

	int r = 0;

	struct data_Number *data = (struct data_Number*) calloc(1, sizeof(struct data_Number));

	data->fmt_mode = FMT_AS_STRING;

	if(json == NULL)

		goto done;

	struct json_object_iterator it = json_object_iter_begin(json);

	struct json_object_iterator itEnd = json_object_iter_end(json);

	while (!json_object_iter_equal(&it, &itEnd)) {

		const char *key = json_object_iter_peek_name(&it);

		struct json_object *const val = json_object_iter_peek_value(&it);

		if(!strcmp(key, "maxval")) {

			errno = 0;

			data->maxval = json_object_get_int64(val);

			if(errno != 0) {

				ln_errprintf(ctx, errno, "param 'maxval' must be integer but is: %s",

					 json_object_to_json_string(val));

			}

		} else if(!strcmp(key, "format")) {

			const char *fmtmode = json_object_get_string(val);

			if(!strcmp(fmtmode, "number")) {

				data->fmt_mode = FMT_AS_NUMBER;

			} else if(!strcmp(fmtmode, "string")) {

				data->fmt_mode = FMT_AS_STRING;

			} else {

				ln_errprintf(ctx, 0, "invalid value for number:format %s",

					fmtmode);

			}

		} else {

			ln_errprintf(ctx, 0, "invalid param for number: %s", key);

		}

		json_object_iter_next(&it);

	}

done:

	*pdata = data;

	return r;

}

PARSER_Destruct(Number)

{

	free(pdata);

}

struct data_Float {

	enum FMT_MODE fmt_mode;

};

/**

 * Parse a Real-number in floating-pt form.

 */

PARSER_Parse(Float)

	const char *c;

	size_t i;

	const struct data_Float *const data = (struct data_Float*) pdata;