[ViewVC] Diff of: cvs/CBOR-XS/XS.xs

Comparing CBOR-XS/XS.xs (file contents):
Revision 1.53 by root, Sun Apr 24 19:51:41 2016 UTC vs.
Revision 1.61 by root, Sat Nov 26 02:10:19 2016 UTC

…		…
6	#include <string.h>	6	#include <string.h>
7	#include <stdlib.h>	7	#include <stdlib.h>
8	#include <stdio.h>	8	#include <stdio.h>
9	#include <limits.h>	9	#include <limits.h>
10	#include <float.h>	10	#include <float.h>
		11	#include <inttypes.h>
11		12
12	#define ECB_NO_THREADS 1	13	#define ECB_NO_THREADS 1
13	#include "ecb.h"	14	#include "ecb.h"
14		15
15	// compatibility with perl <5.18	16	// compatibility with perl <5.18
…		…
99		100
100	#define F_SHRINK 0x00000001UL	101	#define F_SHRINK 0x00000001UL
101	#define F_ALLOW_UNKNOWN 0x00000002UL	102	#define F_ALLOW_UNKNOWN 0x00000002UL
102	#define F_ALLOW_SHARING 0x00000004UL	103	#define F_ALLOW_SHARING 0x00000004UL
103	#define F_ALLOW_CYCLES 0x00000008UL	104	#define F_ALLOW_CYCLES 0x00000008UL
		105	#define F_FORBID_OBJECTS 0x00000010UL
104	#define F_PACK_STRINGS 0x00000010UL	106	#define F_PACK_STRINGS 0x00000020UL
105	#define F_UTF8_STRINGS 0x00000020UL
106	#define F_UTF8_KEYS 0x00000040UL	107	#define F_TEXT_KEYS 0x00000040UL
		108	#define F_TEXT_STRINGS 0x00000080UL
107	#define F_VALIDATE_UTF8 0x00000080UL	109	#define F_VALIDATE_UTF8 0x00000100UL
108		110
109	#define INIT_SIZE 32 // initial scalar size to be allocated	111	#define INIT_SIZE 32 // initial scalar size to be allocated
110		112
111	#define SB do {	113	#define SB do {
112	#define SE } while (0)	114	#define SE } while (0)
…		…
185		187
186	// minimum length of a string to be registered for stringref	188	// minimum length of a string to be registered for stringref
187	ecb_inline int	189	ecb_inline int
188	minimum_string_length (UV idx)	190	minimum_string_length (UV idx)
189	{	191	{
190	return idx > 23	192
191	? idx > 0xffU	193	return idx <= 23 ? 3
192	? idx > 0xffffU	194	: idx <= 0xffU ? 4
		195	: idx <= 0xffffU ? 5
193	? idx > 0xffffffffU	196	: idx <= 0xffffffffU ? 7
194	? 11	197	: 11;
195	: 7
196	: 5
197	: 4
198	: 3;
199	}	198	}
200		199
201	/////////////////////////////////////////////////////////////////////////////	200	/////////////////////////////////////////////////////////////////////////////
202	// encoder	201	// encoder
203		202
…		…
216	} enc_t;	215	} enc_t;
217		216
218	ecb_inline void	217	ecb_inline void
219	need (enc_t *enc, STRLEN len)	218	need (enc_t *enc, STRLEN len)
220	{	219	{
221	if (ecb_expect_false (enc->cur + len >= enc->end))	220	if (ecb_expect_false ((uintptr_t)(enc->end - enc->cur) < len))
222	{	221	{
223	STRLEN cur = enc->cur - (char *)SvPVX (enc->sv);	222	STRLEN cur = enc->cur - (char *)SvPVX (enc->sv);
224	SvGROW (enc->sv, cur + (len < (cur >> 2) ? cur >> 2 : len) + 1);	223	SvGROW (enc->sv, cur + (len < (cur >> 2) ? cur >> 2 : len) + 1);
225	enc->cur = SvPVX (enc->sv) + cur;	224	enc->cur = SvPVX (enc->sv) + cur;
226	enc->end = SvPVX (enc->sv) + SvLEN (enc->sv) - 1;	225	enc->end = SvPVX (enc->sv) + SvLEN (enc->sv) - 1;
…		…
317	need (enc, len);	316	need (enc, len);
318	memcpy (enc->cur, str, len);	317	memcpy (enc->cur, str, len);
319	enc->cur += len;	318	enc->cur += len;
320	}	319	}
321		320
322	ecb_inline	321	ecb_inline void
323	encode_strref (enc_t enc, int upgrade_utf8, int utf8, char str, STRLEN len)	322	encode_strref (enc_t enc, int upgrade_utf8, int utf8, char str, STRLEN len)
324	{	323	{
325	if (ecb_expect_false (enc->cbor.flags & F_PACK_STRINGS))	324	if (ecb_expect_false (enc->cbor.flags & F_PACK_STRINGS))
326	{	325	{
327	SV **svp = hv_fetch (enc->stringref[!!utf8], str, len, 1);	326	SV **svp = hv_fetch (enc->stringref[!!utf8], str, len, 1);
…		…
395	while ((he = hv_iternext (hv)))	394	while ((he = hv_iternext (hv)))
396	{	395	{
397	if (HeKLEN (he) == HEf_SVKEY)	396	if (HeKLEN (he) == HEf_SVKEY)
398	encode_sv (enc, HeSVKEY (he));	397	encode_sv (enc, HeSVKEY (he));
399	else	398	else
400	encode_strref (enc, enc->cbor.flags & (F_UTF8_KEYS \| F_UTF8_STRINGS), HeKUTF8 (he), HeKEY (he), HeKLEN (he));	399	encode_strref (enc, enc->cbor.flags & (F_TEXT_KEYS \| F_TEXT_STRINGS), HeKUTF8 (he), HeKEY (he), HeKLEN (he));
401		400
402	encode_sv (enc, ecb_expect_false (mg) ? hv_iterval (hv, he) : HeVAL (he));	401	encode_sv (enc, ecb_expect_false (mg) ? hv_iterval (hv, he) : HeVAL (he));
403	}	402	}
404		403
405	if (mg)	404	if (mg)
…		…
477	if (ecb_expect_false (SvOBJECT (sv)))	476	if (ecb_expect_false (SvOBJECT (sv)))
478	{	477	{
479	HV *stash = SvSTASH (sv);	478	HV *stash = SvSTASH (sv);
480	GV *method;	479	GV *method;
481		480
		481	if (enc->cbor.flags & F_FORBID_OBJECTS)
		482	croak ("encountered object '%s', but forbid_objects is enabled",
		483	SvPV_nolen (sv_2mortal (newRV_inc (sv))));
482	if ((method = gv_fetchmethod_autoload (stash, "TO_CBOR", 0)))	484	else if ((method = gv_fetchmethod_autoload (stash, "TO_CBOR", 0)))
483	{	485	{
484	dSP;	486	dSP;
485		487
486	ENTER; SAVETMPS;	488	ENTER; SAVETMPS;
487	PUSHMARK (SP);	489	PUSHMARK (SP);
…		…
592		594
593	if (SvPOKp (sv))	595	if (SvPOKp (sv))
594	{	596	{
595	STRLEN len;	597	STRLEN len;
596	char *str = SvPV (sv, len);	598	char *str = SvPV (sv, len);
597	encode_strref (enc, enc->cbor.flags & F_UTF8_STRINGS, SvUTF8 (sv), str, len);	599	encode_strref (enc, enc->cbor.flags & F_TEXT_STRINGS, SvUTF8 (sv), str, len);
598	}	600	}
599	else if (SvNOKp (sv))	601	else if (SvNOKp (sv))
600	encode_nv (enc, sv);	602	encode_nv (enc, sv);
601	else if (SvIOKp (sv))	603	else if (SvIOKp (sv))
602	{	604	{
…		…
661	U32 depth; // recursion depth	663	U32 depth; // recursion depth
662	U32 maxdepth; // recursion depth limit	664	U32 maxdepth; // recursion depth limit
663	AV *shareable;	665	AV *shareable;
664	AV *stringref;	666	AV *stringref;
665	SV *decode_tagged;	667	SV *decode_tagged;
		668	SV *err_sv; // optional sv for error, needs to be freed
666	} dec_t;	669	} dec_t;
667		670
668	#define ERR(reason) SB if (!dec->err) dec->err = reason; goto fail; SE	671	// set dec->err to ERRSV
		672	ecb_cold static void
		673	err_errsv (dec_t *dec)
		674	{
		675	if (!dec->err)
		676	{
		677	dec->err_sv = newSVsv (ERRSV);
669		678
670	#define WANT(len) if (ecb_expect_false (dec->cur + len > dec->end)) ERR ("unexpected end of CBOR data")	679	// chop off the trailing \n
		680	SvCUR_set (dec->err_sv, SvCUR (dec->err_sv) - 1);
		681	*SvEND (dec->err_sv) = 0;
671		682
		683	dec->err = SvPVutf8_nolen (dec->err_sv);
		684	}
		685	}
		686
		687	// the following functions are used to reduce code size and help the compiler to optimise
		688	ecb_cold static void
		689	err_set (dec_t dec, const char reason)
		690	{
		691	if (!dec->err)
		692	dec->err = reason;
		693	}
		694
		695	ecb_cold static void
		696	err_unexpected_end (dec_t *dec)
		697	{
		698	err_set (dec, "unexpected end of CBOR data");
		699	}
		700
		701	ecb_cold static void
		702	err_nesting_exceeded (dec_t *dec)
		703	{
		704	err_set (dec, ERR_NESTING_EXCEEDED);
		705	}
		706
		707	#define ERR_DO(do) SB do; goto fail; SE
		708	#define ERR(reason) ERR_DO (err_set (dec, reason))
		709	#define ERR_ERRSV ERR_DO (err_errsv (dec))
		710
		711	#define WANT(len) if (ecb_expect_false ((uintptr_t)(dec->end - dec->cur) < (STRLEN)len)) ERR_DO (err_unexpected_end (dec))
		712
672	#define DEC_INC_DEPTH if (++dec->depth > dec->cbor.max_depth) ERR (ERR_NESTING_EXCEEDED)	713	#define DEC_INC_DEPTH if (ecb_expect_false (++dec->depth > dec->cbor.max_depth)) ERR (ERR_NESTING_EXCEEDED)
673	#define DEC_DEC_DEPTH --dec->depth	714	#define DEC_DEC_DEPTH --dec->depth
674		715
675	static UV	716	static UV
676	decode_uint (dec_t *dec)	717	decode_uint (dec_t *dec)
677	{	718	{
…		…
754	av_push (av, decode_sv (dec));	795	av_push (av, decode_sv (dec));
755	}	796	}
756	}	797	}
757	else	798	else
758	{	799	{
759	int i, len = decode_uint (dec);	800	UV i, len = decode_uint (dec);
760		801
761	WANT (len); // complexity check for av_fill - need at least one byte per value, do not allow supersize arrays	802	WANT (len); // complexity check for av_fill - need at least one byte per value, do not allow supersize arrays
762	av_fill (av, len - 1);	803	av_fill (av, len - 1);
763		804
764	for (i = 0; i < len; ++i)	805	for (i = 0; i < len; ++i)
…		…
781	// byte or utf-8 strings as keys, but only when !stringref	822	// byte or utf-8 strings as keys, but only when !stringref
782		823
783	if (ecb_expect_true (!dec->stringref))	824	if (ecb_expect_true (!dec->stringref))
784	if (ecb_expect_true ((U8)(*dec->cur - MAJOR_BYTES) <= LENGTH_EXT8))	825	if (ecb_expect_true ((U8)(*dec->cur - MAJOR_BYTES) <= LENGTH_EXT8))
785	{	826	{
786	I32 len = decode_uint (dec);	827	STRLEN len = decode_uint (dec);
787	char key = (char )dec->cur;	828	char key = (char )dec->cur;
788		829
789	WANT (len);	830	WANT (len);
790	dec->cur += len;	831	dec->cur += len;
791		832
…		…
793		834
794	return;	835	return;
795	}	836	}
796	else if (ecb_expect_true ((U8)(*dec->cur - MAJOR_TEXT) <= LENGTH_EXT8))	837	else if (ecb_expect_true ((U8)(*dec->cur - MAJOR_TEXT) <= LENGTH_EXT8))
797	{	838	{
798	I32 len = decode_uint (dec);	839	STRLEN len = decode_uint (dec);
799	char key = (char )dec->cur;	840	char key = (char )dec->cur;
800		841
801	WANT (len);	842	WANT (len);
802	dec->cur += len;	843	dec->cur += len;
803		844
…		…
810	return;	851	return;
811	}	852	}
812		853
813	SV *k = decode_sv (dec);	854	SV *k = decode_sv (dec);
814	SV *v = decode_sv (dec);	855	SV *v = decode_sv (dec);
		856
		857	// we leak memory if uncaught exceptions are thrown by random magical
		858	// methods, and this is hopefully the only place where it can happen,
		859	// so if there is a chance of an exception, take the very slow path.
		860	// since catching exceptions is "undocumented/internal/forbidden" by
		861	// the new p5p powers, we need to call out to a perl function :/
		862	if (ecb_expect_false (SvAMAGIC (k)))
		863	{
		864	dSP;
		865
		866	ENTER; SAVETMPS;
		867	PUSHMARK (SP);
		868	EXTEND (SP, 3);
		869	PUSHs (sv_2mortal (newRV_inc ((SV *)hv)));
		870	PUSHs (sv_2mortal (k));
		871	PUSHs (sv_2mortal (v));
		872
		873	PUTBACK;
		874	call_pv ("CBOR::XS::_hv_store", G_VOID \| G_DISCARD \| G_EVAL);
		875	SPAGAIN;
		876
		877	FREETMPS; LEAVE;
		878
		879	if (SvTRUE (ERRSV))
		880	ERR_ERRSV;
		881
		882	return;
		883	}
815		884
816	hv_store_ent (hv, k, v, 0);	885	hv_store_ent (hv, k, v, 0);
817	SvREFCNT_dec (k);	886	SvREFCNT_dec (k);
818		887
819	fail:	888	fail:
…		…
844	decode_he (dec, hv);	913	decode_he (dec, hv);
845	}	914	}
846	}	915	}
847	else	916	else
848	{	917	{
849	int pairs = decode_uint (dec);	918	UV pairs = decode_uint (dec);
		919
		920	WANT (pairs); // complexity check - need at least one byte per value, do not allow supersize hashes
850		921
851	while (pairs--)	922	while (pairs--)
852	decode_he (dec, hv);	923	decode_he (dec, hv);
853	}	924	}
854		925
…		…
942	sv = newRV_noinc (decode_sv (dec));	1013	sv = newRV_noinc (decode_sv (dec));
943	break;	1014	break;
944		1015
945	case CBOR_TAG_STRINGREF_NAMESPACE:	1016	case CBOR_TAG_STRINGREF_NAMESPACE:
946	{	1017	{
		1018	// do nmot use SAVETMPS/FREETMPS, as these will
		1019	// erase mortalised caches, e.g. "shareable"
947	ENTER; SAVETMPS;	1020	ENTER;
948		1021
949	SAVESPTR (dec->stringref);	1022	SAVESPTR (dec->stringref);
950	dec->stringref = (AV )sv_2mortal ((SV )newAV ());	1023	dec->stringref = (AV )sv_2mortal ((SV )newAV ());
951		1024
952	sv = decode_sv (dec);	1025	sv = decode_sv (dec);
953		1026
954	FREETMPS; LEAVE;	1027	LEAVE;
955	}	1028	}
956	break;	1029	break;
957		1030
958	case CBOR_TAG_STRINGREF:	1031	case CBOR_TAG_STRINGREF:
959	{	1032	{
…		…
1010	}	1083	}
1011	break;	1084	break;
1012		1085
1013	case CBOR_TAG_PERL_OBJECT:	1086	case CBOR_TAG_PERL_OBJECT:
1014	{	1087	{
		1088	if (dec->cbor.flags & F_FORBID_OBJECTS)
		1089	goto filter;
		1090
1015	sv = decode_sv (dec);	1091	sv = decode_sv (dec);
1016		1092
1017	if (!SvROK (sv) \|\| SvTYPE (SvRV (sv)) != SVt_PVAV)	1093	if (!SvROK (sv) \|\| SvTYPE (SvRV (sv)) != SVt_PVAV)
1018	ERR ("corrupted CBOR data (non-array perl object)");	1094	ERR ("corrupted CBOR data (non-array perl object)");
1019		1095
…		…
1048	SPAGAIN;	1124	SPAGAIN;
1049		1125
1050	if (SvTRUE (ERRSV))	1126	if (SvTRUE (ERRSV))
1051	{	1127	{
1052	FREETMPS; LEAVE;	1128	FREETMPS; LEAVE;
1053	ERR (SvPVutf8_nolen (sv_2mortal (SvREFCNT_inc (ERRSV))));	1129	ERR_ERRSV;
1054	}	1130	}
1055		1131
1056	SvREFCNT_dec (sv);	1132	SvREFCNT_dec (sv);
1057	sv = SvREFCNT_inc (POPs);	1133	sv = SvREFCNT_inc (POPs);
1058		1134
…		…
1061	FREETMPS; LEAVE;	1137	FREETMPS; LEAVE;
1062	}	1138	}
1063	break;	1139	break;
1064		1140
1065	default:	1141	default:
		1142	filter:
1066	{	1143	{
		1144	SV *tag_sv = newSVuv (tag);
		1145
1067	sv = decode_sv (dec);	1146	sv = decode_sv (dec);
1068		1147
1069	dSP;	1148	dSP;
1070	ENTER; SAVETMPS;	1149	ENTER; SAVETMPS;
1071	SAVESTACK_POS ();	1150	SAVESTACK_POS ();
1072	PUSHMARK (SP);	1151	PUSHMARK (SP);
1073	EXTEND (SP, 2);	1152	EXTEND (SP, 2);
1074	PUSHs (newSVuv (tag));	1153	PUSHs (tag_sv);
1075	PUSHs (sv);	1154	PUSHs (sv);
1076		1155
1077	PUTBACK;	1156	PUTBACK;
1078	int count = call_sv (dec->cbor.filter ? dec->cbor.filter : default_filter, G_ARRAY \| G_EVAL);	1157	int count = call_sv (dec->cbor.filter ? dec->cbor.filter : default_filter, G_ARRAY \| G_EVAL);
1079	SPAGAIN;	1158	SPAGAIN;
1080		1159
1081	if (SvTRUE (ERRSV))	1160	if (SvTRUE (ERRSV))
1082	{	1161	{
		1162	SvREFCNT_dec (tag_sv);
1083	FREETMPS; LEAVE;	1163	FREETMPS; LEAVE;
1084	ERR (SvPVutf8_nolen (sv_2mortal (SvREFCNT_inc (ERRSV))));	1164	ERR_ERRSV;
1085	}	1165	}
1086		1166
1087	if (count)	1167	if (count)
1088	{	1168	{
		1169	SvREFCNT_dec (tag_sv);
1089	SvREFCNT_dec (sv);	1170	SvREFCNT_dec (sv);
1090	sv = SvREFCNT_inc (POPs);	1171	sv = SvREFCNT_inc (POPs);
1091	}	1172	}
1092	else	1173	else
1093	{	1174	{
1094	AV *av = newAV ();	1175	AV *av = newAV ();
1095	av_push (av, newSVuv (tag));	1176	av_push (av, tag_sv);
1096	av_push (av, sv);	1177	av_push (av, sv);
1097		1178
1098	HV *tagged_stash = !CBOR_SLOW \|\| cbor_tagged_stash	1179	HV *tagged_stash = !CBOR_SLOW \|\| cbor_tagged_stash
1099	? cbor_tagged_stash	1180	? cbor_tagged_stash
1100	: gv_stashpv ("CBOR::XS::Tagged" , 1);	1181	: gv_stashpv ("CBOR::XS::Tagged" , 1);
…		…
1229		1310
1230	if (dec.err)	1311	if (dec.err)
1231	{	1312	{
1232	if (dec.shareable)	1313	if (dec.shareable)
1233	{	1314	{
1234	// need to break cyclic links, which whould all be in shareable	1315	// need to break cyclic links, which would all be in shareable
1235	int i;	1316	int i;
1236	SV **svp;	1317	SV **svp;
1237		1318
1238	for (i = av_len (dec.shareable) + 1; i--; )	1319	for (i = av_len (dec.shareable) + 1; i--; )
1239	if ((svp = av_fetch (dec.shareable, i, 0)))	1320	if ((svp = av_fetch (dec.shareable, i, 0)))
1240	sv_setsv (*svp, &PL_sv_undef);	1321	sv_setsv (*svp, &PL_sv_undef);
1241	}	1322	}
1242		1323
1243	SvREFCNT_dec (sv);	1324	SvREFCNT_dec (sv);
		1325
		1326	if (dec.err_sv)
		1327	sv_2mortal (dec.err_sv);
		1328
1244	croak ("%s, at offset %d (octet 0x%02x)", dec.err, dec.cur - (U8 )data, (int)(uint8_t)dec.cur);	1329	croak ("%s, at offset %d (octet 0x%02x)", dec.err, dec.cur - (U8 )data, (int)(uint8_t)dec.cur);
1245	}	1330	}
1246		1331
1247	sv = sv_2mortal (sv);	1332	sv = sv_2mortal (sv);
1248		1333
…		…
1392		1477
1393	default_filter = newSVpv ("CBOR::XS::default_filter", 0);	1478	default_filter = newSVpv ("CBOR::XS::default_filter", 0);
1394		1479
1395	sv_cbor = newSVpv ("CBOR", 0);	1480	sv_cbor = newSVpv ("CBOR", 0);
1396	SvREADONLY_on (sv_cbor);	1481	SvREADONLY_on (sv_cbor);
		1482
		1483	assert (("STRLEN must be an unsigned type", 0 <= (STRLEN)-1));
1397	}	1484	}
1398		1485
1399	PROTOTYPES: DISABLE	1486	PROTOTYPES: DISABLE
1400		1487
1401	void CLONE (...)	1488	void CLONE (...)
…		…
1421	ALIAS:	1508	ALIAS:
1422	shrink = F_SHRINK	1509	shrink = F_SHRINK
1423	allow_unknown = F_ALLOW_UNKNOWN	1510	allow_unknown = F_ALLOW_UNKNOWN
1424	allow_sharing = F_ALLOW_SHARING	1511	allow_sharing = F_ALLOW_SHARING
1425	allow_cycles = F_ALLOW_CYCLES	1512	allow_cycles = F_ALLOW_CYCLES
		1513	forbid_objects = F_FORBID_OBJECTS
1426	pack_strings = F_PACK_STRINGS	1514	pack_strings = F_PACK_STRINGS
		1515	text_keys = F_TEXT_KEYS
1427	utf8_strings = F_UTF8_STRINGS	1516	text_strings = F_TEXT_STRINGS
1428	validate_utf8 = F_VALIDATE_UTF8	1517	validate_utf8 = F_VALIDATE_UTF8
1429	PPCODE:	1518	PPCODE:
1430	{	1519	{
1431	if (enable)	1520	if (enable)
1432	self->flags \|= ix;	1521	self->flags \|= ix;
…		…
1440	ALIAS:	1529	ALIAS:
1441	get_shrink = F_SHRINK	1530	get_shrink = F_SHRINK
1442	get_allow_unknown = F_ALLOW_UNKNOWN	1531	get_allow_unknown = F_ALLOW_UNKNOWN
1443	get_allow_sharing = F_ALLOW_SHARING	1532	get_allow_sharing = F_ALLOW_SHARING
1444	get_allow_cycles = F_ALLOW_CYCLES	1533	get_allow_cycles = F_ALLOW_CYCLES
		1534	get_forbid_objects = F_FORBID_OBJECTS
1445	get_pack_strings = F_PACK_STRINGS	1535	get_pack_strings = F_PACK_STRINGS
		1536	get_text_keys = F_TEXT_KEYS
		1537	get_text_strings = F_TEXT_STRINGS
1446	get_validate_utf8 = F_VALIDATE_UTF8	1538	get_validate_utf8 = F_VALIDATE_UTF8
1447	PPCODE:	1539	PPCODE:
1448	XPUSHs (boolSV (self->flags & ix));	1540	XPUSHs (boolSV (self->flags & ix));
1449		1541
1450	void max_depth (CBOR *self, U32 max_depth = 0x80000000UL)	1542	void max_depth (CBOR *self, U32 max_depth = 0x80000000UL)

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing CBOR-XS/XS.xs (file contents): Revision 1.53 by root, Sun Apr 24 19:51:41 2016 UTC vs. Revision 1.61 by root, Sat Nov 26 02:10:19 2016 UTC

Diff Legend

Comparing CBOR-XS/XS.xs (file contents):
Revision 1.53 by root, Sun Apr 24 19:51:41 2016 UTC vs.
Revision 1.61 by root, Sat Nov 26 02:10:19 2016 UTC