Commit 9cc80b55 authored by Yann Garcia's avatar Yann Garcia
Browse files

Merge branch 'STF525' of https://forge.etsi.org/gitlab/ITS/ITS into STF525

parents 7fe37cfe 8336936b
Loading
Loading
Loading
Loading
+2 −0
Original line number Original line Diff line number Diff line
@@ -234,6 +234,7 @@
      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">false</ExcludedFromBuild>
      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">false</ExcludedFromBuild>
      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">false</ExcludedFromBuild>
      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">false</ExcludedFromBuild>
    </ClCompile>
    </ClCompile>
    <ClCompile Include="mkgmtime.c" />
  </ItemGroup>
  </ItemGroup>
  <ItemGroup>
  <ItemGroup>
    <ClInclude Include="asncodec\AaEntry.h" />
    <ClInclude Include="asncodec\AaEntry.h" />
@@ -440,6 +441,7 @@
    <ClInclude Include="asncodec\xer_encoder.h" />
    <ClInclude Include="asncodec\xer_encoder.h" />
    <ClInclude Include="asncodec\xer_support.h" />
    <ClInclude Include="asncodec\xer_support.h" />
    <ClInclude Include="ecc_api.h" />
    <ClInclude Include="ecc_api.h" />
    <ClInclude Include="mkgmtime.h" />
  </ItemGroup>
  </ItemGroup>
  <ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\cshared\cshared.vcxproj">
    <ProjectReference Include="..\cshared\cshared.vcxproj">
+43 −1
Original line number Original line Diff line number Diff line
@@ -6,6 +6,7 @@
 */
 */


#include "Time32.h"
#include "Time32.h"
#include "../mkgmtime.h"


int
int
Time32_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
Time32_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
@@ -33,10 +34,37 @@ static asn_oer_constraints_t asn_OER_type_Time32_constr_1 CC_NOTUSED = {
static const ber_tlv_tag_t asn_DEF_Time32_tags_1[] = {
static const ber_tlv_tag_t asn_DEF_Time32_tags_1[] = {
	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
};
};

asn_TYPE_operation_t asn_OP_Time32 = {
	NativeInteger_free,
	Time32_print,
	NativeInteger_compare,
	NativeInteger_decode_ber,
	NativeInteger_encode_der,
	NativeInteger_decode_xer,
	NativeInteger_encode_xer,
#ifdef	ASN_DISABLE_OER_SUPPORT
	0,
	0,
#else
	NativeInteger_decode_oer,	/* OER decoder */
	NativeInteger_encode_oer,	/* Canonical OER encoder */
#endif  /* ASN_DISABLE_OER_SUPPORT */
#ifdef	ASN_DISABLE_PER_SUPPORT
	0,
	0,
#else
	NativeInteger_decode_uper,	/* Unaligned PER decoder */
	NativeInteger_encode_uper,	/* Unaligned PER encoder */
#endif	/* ASN_DISABLE_PER_SUPPORT */
	NativeInteger_random_fill,
	0	/* Use generic outmost tag fetcher */
};

asn_TYPE_descriptor_t asn_DEF_Time32 = {
asn_TYPE_descriptor_t asn_DEF_Time32 = {
	"Time32",
	"Time32",
	"Time32",
	"Time32",
	&asn_OP_NativeInteger,
	&asn_OP_Time32,
	asn_DEF_Time32_tags_1,
	asn_DEF_Time32_tags_1,
	sizeof(asn_DEF_Time32_tags_1)
	sizeof(asn_DEF_Time32_tags_1)
		/sizeof(asn_DEF_Time32_tags_1[0]), /* 1 */
		/sizeof(asn_DEF_Time32_tags_1[0]), /* 1 */
@@ -48,3 +76,17 @@ asn_TYPE_descriptor_t asn_DEF_Time32 = {
	&asn_SPC_Uint32_specs_1	/* Additional specs */
	&asn_SPC_Uint32_specs_1	/* Additional specs */
};
};


int Time32_print(const asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
	asn_app_consume_bytes_f *cb, void *app_key) {

	const asn_INTEGER_specifics_t *specs =
		(const asn_INTEGER_specifics_t *)td->specifics;
	int ret = NativeInteger_print(td, sptr, ilevel, cb, app_key);
	if (ret == 0){
		const long *native = (const long *)sptr;
		const char * s = stritsdate32(*native);
		if (cb(" -- ", 4, app_key) < 0) return -1;
		if (cb(s, strlen(s), app_key) < 0) return -1;
	}
	return ret;
}
+51 −1
Original line number Original line Diff line number Diff line
@@ -6,6 +6,7 @@
 */
 */


#include "Time64.h"
#include "Time64.h"
#include "../mkgmtime.h"


int
int
Time64_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
Time64_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
@@ -48,10 +49,37 @@ static asn_oer_constraints_t asn_OER_type_Time64_constr_1 CC_NOTUSED = {
static const ber_tlv_tag_t asn_DEF_Time64_tags_1[] = {
static const ber_tlv_tag_t asn_DEF_Time64_tags_1[] = {
	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
};
};

asn_TYPE_operation_t asn_OP_Time64 = {
	INTEGER_free,
	Time64_print,
	INTEGER_compare,
	ber_decode_primitive,
	INTEGER_encode_der,
	INTEGER_decode_xer,
	INTEGER_encode_xer,
#ifdef  ASN_DISABLE_OER_SUPPORT
	0,
	0,
#else
	INTEGER_decode_oer,     /* OER decoder */
	INTEGER_encode_oer,     /* Canonical OER encoder */
#endif  /* ASN_DISABLE_OER_SUPPORT */
#ifdef	ASN_DISABLE_PER_SUPPORT
	0,
	0,
#else
	INTEGER_decode_uper,	/* Unaligned PER decoder */
	INTEGER_encode_uper,	/* Unaligned PER encoder */
#endif	/* ASN_DISABLE_PER_SUPPORT */
	INTEGER_random_fill,
	0	/* Use generic outmost tag fetcher */
};

asn_TYPE_descriptor_t asn_DEF_Time64 = {
asn_TYPE_descriptor_t asn_DEF_Time64 = {
	"Time64",
	"Time64",
	"Time64",
	"Time64",
	&asn_OP_INTEGER,
	&asn_OP_Time64,
	asn_DEF_Time64_tags_1,
	asn_DEF_Time64_tags_1,
	sizeof(asn_DEF_Time64_tags_1)
	sizeof(asn_DEF_Time64_tags_1)
		/sizeof(asn_DEF_Time64_tags_1[0]), /* 1 */
		/sizeof(asn_DEF_Time64_tags_1[0]), /* 1 */
@@ -63,3 +91,25 @@ asn_TYPE_descriptor_t asn_DEF_Time64 = {
	0	/* No specifics */
	0	/* No specifics */
};
};


int Time64_print(const asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
                 asn_app_consume_bytes_f *cb, void *app_key) {
	const asn_INTEGER_specifics_t *specs =
		(const asn_INTEGER_specifics_t *)td->specifics;
	const INTEGER_t *st = (const INTEGER_t *)sptr;
	int ret = INTEGER_print(td, sptr, ilevel, cb, app_key);
	if (ret == 0){
		if (st && st->buf){
			intmax_t value;
			if (specs && specs->field_unsigned)
				ret = asn_INTEGER2umax(st, (uintmax_t *)&value);
			else
				ret = asn_INTEGER2imax(st, &value);
			if (ret == 0) {
				const char * s = stritsdate32(value);
				if (cb(" -- ", 4, app_key) < 0) return -1;
				if (cb(s, strlen(s), app_key) < 0) return -1;
			}
		}
	}
	return ret;
}
+4 −6
Original line number Original line Diff line number Diff line
@@ -1039,14 +1039,12 @@ CHOICE_print(const asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
		}
		}


		/* Print member's name and stuff */
		/* Print member's name and stuff */
		if(0) {
		if(cb(elm->name, strlen(elm->name), app_key) < 0
		if(cb(elm->name, strlen(elm->name), app_key) < 0
			|| cb(": ", 2, app_key) < 0)
			|| cb(" : ", 3, app_key) < 0)
				return -1;
				return -1;
		}
		
		
		return elm->type->op->print_struct(elm->type, memb_ptr, ilevel,
		return elm->type->op->print_struct(elm->type, memb_ptr, ilevel, cb, app_key);
			cb, app_key);

	} else {
	} else {
		return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;
		return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;
	}
	}
+360 −0
Original line number Original line Diff line number Diff line
// Found in DeSmuME
// Alexis modified it a tad bit so it would compile as C (opposed to C++)

/*  lib/mkgmtime.c

    Copyright (C) 2010 DeSmuME team

    This file is part of DeSmuME

    DeSmuME is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    DeSmuME is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with DeSmuME; if not, write to the Free Software
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
*/

//Taken from newlib 1.18.0 which is licensed under GPL 2 and modified for desmume

/*
 * mktime.c
 * Original Author:  G. Haley
 *
 * Converts the broken-down time, expressed as local time, in the structure
 * pointed to by tim_p into a calendar time value. The original values of the
 * tm_wday and tm_yday fields of the structure are ignored, and the original
 * values of the other fields have no restrictions. On successful completion
 * the fields of the structure are set to represent the specified calendar
 * time. Returns the specified calendar time. If the calendar time can not be
 * represented, returns the value (time_t) -1.
 *
 * Modifications:  Fixed tm_isdst usage - 27 August 2008 Craig Howland.
 */

#ifdef _MSC_VER
#define _CRT_SECURE_NO_WARNINGS
#endif

#include <stdlib.h>
#include <time.h>
#include <stdio.h>
#include "mkgmtime.h"

#define _SEC_IN_MINUTE 60L
#define _SEC_IN_HOUR 3600L
#define _SEC_IN_DAY 86400L

static const int DAYS_IN_MONTH[12] =
{31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

#define _DAYS_IN_MONTH(x) ((x == 1) ? days_in_feb : DAYS_IN_MONTH[x])

static const int _DAYS_BEFORE_MONTH[12] =
{0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334};

#define _ISLEAP(y) (((y) % 4) == 0 && (((y) % 100) != 0 || (((y)+1900) % 400) == 0))
#define _DAYS_IN_YEAR(year) (_ISLEAP(year) ? 366 : 365)

static void validate_structure(struct tm *tim_p)
{
  div_t res;
  int days_in_feb = 28;

  /* calculate time & date to account for out of range values */
  if (tim_p->tm_sec < 0 || tim_p->tm_sec > 59)
    {
      res = div (tim_p->tm_sec, 60);
      tim_p->tm_min += res.quot;
      if ((tim_p->tm_sec = res.rem) < 0)
        {
          tim_p->tm_sec += 60;
          --tim_p->tm_min;
        }
    }

  if (tim_p->tm_min < 0 || tim_p->tm_min > 59)
    {
      res = div (tim_p->tm_min, 60);
      tim_p->tm_hour += res.quot;
      if ((tim_p->tm_min = res.rem) < 0)
        {
          tim_p->tm_min += 60;
          --tim_p->tm_hour;
        }
    }

  if (tim_p->tm_hour < 0 || tim_p->tm_hour > 23)
    {
      res = div (tim_p->tm_hour, 24);
      tim_p->tm_mday += res.quot;
      if ((tim_p->tm_hour = res.rem) < 0)
        {
          tim_p->tm_hour += 24;
          --tim_p->tm_mday;
        }
    }

  if (tim_p->tm_mon > 11)
    {
      res = div (tim_p->tm_mon, 12);
      tim_p->tm_year += res.quot;
      if ((tim_p->tm_mon = res.rem) < 0)
        {
          tim_p->tm_mon += 12;
          --tim_p->tm_year;
        }
    }

  if (_DAYS_IN_YEAR (tim_p->tm_year) == 366)
    days_in_feb = 29;

  if (tim_p->tm_mday <= 0)
    {
      while (tim_p->tm_mday <= 0)
        {
          if (--tim_p->tm_mon == -1)
            {
              tim_p->tm_year--;
              tim_p->tm_mon = 11;
              days_in_feb =
                ((_DAYS_IN_YEAR (tim_p->tm_year) == 366) ?
                 29 : 28);
            }
          tim_p->tm_mday += _DAYS_IN_MONTH (tim_p->tm_mon);
        }
    }
  else
    {
      while (tim_p->tm_mday > _DAYS_IN_MONTH (tim_p->tm_mon))
        {
          tim_p->tm_mday -= _DAYS_IN_MONTH (tim_p->tm_mon);
          if (++tim_p->tm_mon == 12)
            {
              tim_p->tm_year++;
              tim_p->tm_mon = 0;
              days_in_feb =
                ((_DAYS_IN_YEAR (tim_p->tm_year) == 366) ?
                 29 : 28);
            }
        }
    }
}


static const unsigned long _leap_moments[] = {
	1136073600,
	1230768000,
	1341100800,
	1435708800,
};

time_t addleapseconds(time_t t)
{
	int i;
	for (i = 0; i < sizeof(_leap_moments) / sizeof(_leap_moments[0]); i++){
		if (t < _leap_moments[i]) break;
	}
	return t + i;
}

time_t removeleapseconds(time_t t)
{
	int i;
	for (i = 0; i < sizeof(_leap_moments) / sizeof(_leap_moments[0]); i++){
		if (t < _leap_moments[i]) break;
		t--;
	}
	return t;
}

#define ITS_UTC_EPOCH 1072915200

unsigned long mkitstime32(struct tm *tim_p)
{
	time_t ret = mktaitime(tim_p);
	if (ret > 0){
		ret -= ITS_UTC_EPOCH;
	}
	return (unsigned long)ret;
}

unsigned long long mkitstime64(struct tm *tim_p)
{
	unsigned long long ret = mktaitime64(tim_p);
	if (ret > 0){
		ret -= ((unsigned long long)ITS_UTC_EPOCH) * 1000;
	}
	return ret;
}

time_t mktaitime(struct tm *tim_p)
{
	time_t t = mkgmtime(tim_p);
	if (t >= 0){
		t = addleapseconds(t);
	}
	return t;
}

unsigned long long mktaitime64(struct tm *tim_p)
{
	time_t t = mkgmtime(tim_p);
	if (t >= 0){
		t = addleapseconds(t);
	}
	return ((unsigned long long)t)*1000;
}

unsigned long unix2itstime32(time_t t)
{
	return ((unsigned long) addleapseconds(t)) - ITS_UTC_EPOCH;
}

unsigned long long unix2itstime64(time_t t)
{
	return (((unsigned long long) addleapseconds(t)) - ITS_UTC_EPOCH) * 1000;
}

static char _datebuf[8][16];
static int _datebufidx = 0;
const char * strgmtdate(time_t t)
{
	struct tm * tm;
	char * b = _datebuf[_datebufidx];
	_datebufidx = (_datebufidx + 1) & 7;

	tm = gmtime(&t);
	sprintf(b, "%u-%02u-%02u", 1900 + tm->tm_year, tm->tm_mon + 1, tm->tm_mday);
	return b;
}

const char * strtaidate(time_t t)
{
	return strgmtdate(removeleapseconds(t));
}

const char * stritsdate32(time_t t)
{
	return strtaidate(t + ITS_UTC_EPOCH);
}

time_t mkgmtime(struct tm *tim_p)
{
  time_t tim = 0;
  long days = 0;
  int year, isdst, tm_isdst;

  /* validate structure */
  validate_structure (tim_p);

  /* compute hours, minutes, seconds */
  tim += tim_p->tm_sec + (tim_p->tm_min * _SEC_IN_MINUTE) +
    (tim_p->tm_hour * _SEC_IN_HOUR);

  /* compute days in year */
  days += tim_p->tm_mday - 1;
  days += _DAYS_BEFORE_MONTH[tim_p->tm_mon];
  if (tim_p->tm_mon > 1 && _DAYS_IN_YEAR (tim_p->tm_year) == 366)
    days++;

  /* compute day of the year */
  tim_p->tm_yday = days;

  if (tim_p->tm_year > 10000
      || tim_p->tm_year < -10000)
    {
      return (time_t) -1;
    }

  /* compute days in other years */
  if (tim_p->tm_year > 70)
    {
      for (year = 70; year < tim_p->tm_year; year++)
        days += _DAYS_IN_YEAR (year);
    }
  else if (tim_p->tm_year < 70)
    {
      for (year = 69; year > tim_p->tm_year; year--)
        days -= _DAYS_IN_YEAR (year);
      days -= _DAYS_IN_YEAR (year);
    }

  /* compute day of the week */
  if ((tim_p->tm_wday = (days + 4) % 7) < 0)
    tim_p->tm_wday += 7;

  /* compute total seconds */
  tim += (days * _SEC_IN_DAY);

  /* Convert user positive into 1 */
  tm_isdst = tim_p->tm_isdst > 0  ?  1 : tim_p->tm_isdst;
  isdst = tm_isdst;

  //screw this!

 // if (_daylight)
 //   {
 //     int y = tim_p->tm_year + YEAR_BASE;
 //     if (y == tz->__tzyear || __tzcalc_limits (y))
        //{
        //  /* calculate start of dst in dst local time and 
        //     start of std in both std local time and dst local time */
 //         time_t startdst_dst = tz->__tzrule[0].change
        //    - (time_t) tz->__tzrule[1].offset;
        //  time_t startstd_dst = tz->__tzrule[1].change
        //    - (time_t) tz->__tzrule[1].offset;
        //  time_t startstd_std = tz->__tzrule[1].change
        //    - (time_t) tz->__tzrule[0].offset;
        //  /* if the time is in the overlap between dst and std local times */
        //  if (tim >= startstd_std && tim < startstd_dst)
        //    ; /* we let user decide or leave as -1 */
 //         else
        //    {
        //      isdst = (tz->__tznorth
        //               ? (tim >= startdst_dst && tim < startstd_std)
        //               : (tim >= startdst_dst || tim < startstd_std));
 //              /* if user committed and was wrong, perform correction, but not
 //               * if the user has given a negative value (which
 //               * asks mktime() to determine if DST is in effect or not) */
 //              if (tm_isdst >= 0  &&  (isdst ^ tm_isdst) == 1)
        //        {
        //          /* we either subtract or add the difference between
        //             time zone offsets, depending on which way the user got it
        //             wrong. The diff is typically one hour, or 3600 seconds,
        //             and should fit in a 16-bit int, even though offset
        //             is a long to accomodate 12 hours. */
        //          int diff = (int) (tz->__tzrule[0].offset
        //                            - tz->__tzrule[1].offset);
        //          if (!isdst)
        //            diff = -diff;
        //          tim_p->tm_sec += diff;
        //          validate_structure (tim_p);
        //          tim += diff;  /* we also need to correct our current time calculation */
        //        }
        //    }
        //}
 //   }

  //screw this also 
  /* add appropriate offset to put time in gmt format */
  //if (isdst == 1)
  //  tim += (time_t) tz->__tzrule[1].offset;
  //else /* otherwise assume std time */
  //  tim += (time_t) tz->__tzrule[0].offset;

  //and screw this too
  /* reset isdst flag to what we have calculated */
  tim_p->tm_isdst = isdst;

  return tim;
}

// vim: ts=2 sw=2 et
Loading