organicmaps/icu
13
Fork 0
mirror of https://github.com/unicode-org/icu.git synced 2025-04-06 22:15:31 +00:00
Code Issues 1 Projects Releases Wiki Activity Actions 8

ICU-22633 Fix integer overflow inside Calendar code

Browse source 
See #2806
This commit is contained in:
Frank Yung-Fong Tang 2024-02-06 02:30:44 +00:00
parent a6efa924ad
commit 0b66fada30
24 changed files with 179 additions and 130 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

13
icu4c/source/i18n/calendar.cpp
View file

@ -3412,11 +3412,20 @@ int32_t Calendar::handleComputeJulianDay(UCalendarDateFields bestField, UErrorCo
} else {
dayOfMonth = getDefaultDayInMonth(year, month);
}
return julianDay + dayOfMonth;
if (uprv_add32_overflow(dayOfMonth, julianDay, &dayOfMonth)) {
status = U_ILLEGAL_ARGUMENT_ERROR;
return 0;
}
return dayOfMonth;
}
if (bestField == UCAL_DAY_OF_YEAR) {
return julianDay + internalGet(UCAL_DAY_OF_YEAR);
int32_t result;
if (uprv_add32_overflow(internalGet(UCAL_DAY_OF_YEAR), julianDay, &result)) {
status = U_ILLEGAL_ARGUMENT_ERROR;
return 0;
}
return result;
}
int32_t firstDayOfWeek = getFirstDayOfWeek(); // Localized fdw

41
icu4c/source/i18n/cecal.cpp
View file

@ -76,10 +76,27 @@ CECalendar::operator=(const CECalendar& right)
// Calendar framework
//-------------------------------------------------------------------------
int32_t
int64_t
CECalendar::handleComputeMonthStart(int32_t eyear,int32_t emonth, UBool /*useMonth*/) const
{
return ceToJD(eyear, emonth, 0, getJDEpochOffset());
int64_t year64 = eyear;
// handle month > 12, < 0 (e.g. from add/set)
if ( emonth >= 0 ) {
year64 += emonth/13;
emonth %= 13;
} else {
++emonth;
year64 += emonth/13 - 1;
emonth = emonth%13 + 12;
}
return (
getJDEpochOffset() // difference from Julian epoch to 1,1,1
+ 365LL * year64 // number of days from years
+ ClockMath::floorDivide(year64, 4LL) // extra day of leap year
+ 30 * emonth // number of days from months (months are 0-based)
- 1 // number of days for present month (1 based)
);
}
int32_t
@ -97,26 +114,6 @@ CECalendar::haveDefaultCentury() const
//-------------------------------------------------------------------------
// Calendar system Conversion methods...
//-------------------------------------------------------------------------
int32_t
CECalendar::ceToJD(int32_t year, int32_t month, int32_t date, int32_t jdEpochOffset)
{
// handle month > 12, < 0 (e.g. from add/set)
if ( month >= 0 ) {
year += month/13;
month %= 13;
} else {
++month;
year += month/13 - 1;
month = month%13 + 12;
}
return (int32_t) (
jdEpochOffset // difference from Julian epoch to 1,1,1
+ 365 * year // number of days from years
+ ClockMath::floorDivide(year, 4) // extra day of leap year
+ 30 * month // number of days from months (months are 0-based)
+ date - 1 // number of days for present month (1 based)
);
}
void
CECalendar::jdToCE(int32_t julianDay, int32_t jdEpochOffset, int32_t& year, int32_t& month, int32_t& day)

15
icu4c/source/i18n/cecal.h
View file

@ -98,7 +98,7 @@ protected:
* Return JD of start of given month/extended year
* @internal
*/
virtual int32_t handleComputeMonthStart(int32_t eyear, int32_t month, UBool useMonth) const override;
virtual int64_t handleComputeMonthStart(int32_t eyear, int32_t month, UBool useMonth) const override;
/**
* Calculate the limit for a specified type of limit and field
@ -121,19 +121,6 @@ protected:
*/
virtual int32_t getJDEpochOffset() const = 0;
/**
* Convert an Coptic/Ethiopic year, month, and day to a Julian day.
*
* @param year the extended year
* @param month the month
* @param day the day
* @param jdEpochOffset the epoch offset from Julian epoch
* @return Julian day
* @internal
*/
static int32_t ceToJD(int32_t year, int32_t month, int32_t date,
int32_t jdEpochOffset);
/**
* Convert a Julian day to an Coptic/Ethiopic year, month and day
*

11
icu4c/source/i18n/chnsecal.cpp
View file

@ -324,7 +324,7 @@ const UFieldResolutionTable* ChineseCalendar::getFieldResolutionTable() const {
* day of the given month and year
* @stable ICU 2.8
*/
int32_t ChineseCalendar::handleComputeMonthStart(int32_t eyear, int32_t month, UBool useMonth) const {
int64_t ChineseCalendar::handleComputeMonthStart(int32_t eyear, int32_t month, UBool useMonth) const {
// If the month is out of range, adjust it into range, and
// modify the extended year value accordingly.
if (month < 0 || month > 11) {
@ -337,7 +337,7 @@ int32_t ChineseCalendar::handleComputeMonthStart(int32_t eyear, int32_t month, U
int32_t theNewYear = newYear(gyear);
int32_t newMoon = newMoonNear(theNewYear + month * 29, true);
int32_t julianDay = newMoon + kEpochStartAsJulianDay;
int64_t julianDay = newMoon + kEpochStartAsJulianDay;
// Ignore IS_LEAP_MONTH field if useMonth is false
int32_t isLeapMonth = useMonth ? internalGet(UCAL_IS_LEAP_MONTH) : 0;
@ -546,7 +546,12 @@ int32_t ChineseCalendar::winterSolstice(int32_t gyear) const {
umtx_unlock(&astroLock);
// Winter solstice is 270 degrees solar longitude aka Dongzhi
cacheValue = (int32_t)millisToDays(solarLong);
double days = millisToDays(solarLong);
if (days < INT32_MIN || days > INT32_MAX) {
status = U_ILLEGAL_ARGUMENT_ERROR;
return 0;
}
cacheValue = (int32_t) days;
CalendarCache::put(&gChineseCalendarWinterSolsticeCache, gyear, cacheValue, status);
}
if(U_FAILURE(status)) {

2
icu4c/source/i18n/chnsecal.h
View file

@ -208,7 +208,7 @@ class U_I18N_API ChineseCalendar : public Calendar {
protected:
virtual int32_t handleGetLimit(UCalendarDateFields field, ELimitType limitType) const override;
virtual int32_t handleGetMonthLength(int32_t extendedYear, int32_t month) const override;
virtual int32_t handleComputeMonthStart(int32_t eyear, int32_t month, UBool useMonth) const override;
virtual int64_t handleComputeMonthStart(int32_t eyear, int32_t month, UBool useMonth) const override;
virtual int32_t handleGetExtendedYear() override;
virtual void handleComputeFields(int32_t julianDay, UErrorCode &status) override;
virtual const UFieldResolutionTable* getFieldResolutionTable() const override;

15
icu4c/source/i18n/coptccal.cpp
View file

@ -161,21 +161,6 @@ CopticCalendar::getJDEpochOffset() const
}
#if 0
// We do not want to introduce this API in ICU4C.
// It was accidentally introduced in ICU4J as a public API.
//-------------------------------------------------------------------------
// Calendar system Conversion methods...
//-------------------------------------------------------------------------
int32_t
CopticCalendar::copticToJD(int32_t year, int32_t month, int32_t day)
{
return CECalendar::ceToJD(year, month, day, COPTIC_JD_EPOCH_OFFSET);
}
#endif
U_NAMESPACE_END
#endif /* #if !UCONFIG_NO_FORMATTING */

15
icu4c/source/i18n/ethpccal.cpp
View file

@ -150,21 +150,6 @@ EthiopicCalendar::getJDEpochOffset() const
}
#if 0
// We do not want to introduce this API in ICU4C.
// It was accidentally introduced in ICU4J as a public API.
//-------------------------------------------------------------------------
// Calendar system Conversion methods...
//-------------------------------------------------------------------------
int32_t
EthiopicCalendar::ethiopicToJD(int32_t year, int32_t month, int32_t date)
{
return ceToJD(year, month, date, JD_EPOCH_OFFSET_AMETE_MIHRET);
}
#endif
//-------------------------------------------------------------------------
// Constructors...
//-------------------------------------------------------------------------

4
icu4c/source/i18n/gregocal.cpp
View file

@ -536,7 +536,7 @@ int32_t GregorianCalendar::handleComputeJulianDay(UCalendarDateFields bestField,
return jd;
}
int32_t GregorianCalendar::handleComputeMonthStart(int32_t eyear, int32_t month,
int64_t GregorianCalendar::handleComputeMonthStart(int32_t eyear, int32_t month,
UBool /* useMonth */) const
{
@ -580,7 +580,7 @@ int32_t GregorianCalendar::handleComputeMonthStart(int32_t eyear, int32_t month,
julianDay += isLeap?kLeapNumDays[month]:kNumDays[month];
}
return static_cast<int32_t>(julianDay);
return julianDay;
}
int32_t GregorianCalendar::handleGetMonthLength(int32_t extendedYear, int32_t month) const

12
icu4c/source/i18n/gregoimp.cpp
View file

@ -41,7 +41,7 @@ int32_t ClockMath::floorDivide(int32_t numerator, int32_t denominator,
return quotient;
}
int32_t ClockMath::floorDivide(double numerator, int32_t denominator,
double ClockMath::floorDivide(double numerator, int32_t denominator,
int32_t* remainder) {
// For an integer n and representable ⌊x/n⌋, ⌊RN(x/n)⌋=⌊x/n⌋, where RN is
// rounding to nearest.
@ -53,7 +53,7 @@ int32_t ClockMath::floorDivide(double numerator, int32_t denominator,
// n+⌈x⌉ = ⌊x+n⌋ + 1. Rewriting it as ⌊x⌋+n makes the addition exact.
*remainder = (int32_t) (uprv_floor(numerator) - (quotient * denominator));
}
return (int32_t) quotient;
return quotient;
}
double ClockMath::floorDivide(double dividend, double divisor,
@ -104,12 +104,12 @@ const int8_t Grego::MONTH_LENGTH[24] =
{31,28,31,30,31,30,31,31,30,31,30,31,
31,29,31,30,31,30,31,31,30,31,30,31};
double Grego::fieldsToDay(int32_t year, int32_t month, int32_t dom) {
int64_t Grego::fieldsToDay(int32_t year, int32_t month, int32_t dom) {
int32_t y = year - 1;
int64_t y = year - 1;
double julian = 365 * y + ClockMath::floorDivide(y, 4) + (JULIAN_1_CE - 3) + // Julian cal
ClockMath::floorDivide(y, 400) - ClockMath::floorDivide(y, 100) + 2 + // => Gregorian cal
int64_t julian = 365LL * y + ClockMath::floorDivide(y, 4LL) + (JULIAN_1_CE - 3) + // Julian cal
ClockMath::floorDivide(y, 400LL) - ClockMath::floorDivide(y, 100LL) + 2 + // => Gregorian cal
DAYS_BEFORE[month + (isLeapYear(year) ? 12 : 0)] + dom; // => month/dom
return julian - JULIAN_1970_CE; // JD => epoch day

4
icu4c/source/i18n/gregoimp.h
View file

@ -95,7 +95,7 @@ class ClockMath {
* |denominator|)</code>.
* @return the floor of the quotient
*/
static int32_t floorDivide(double numerator, int32_t denominator,
static double floorDivide(double numerator, int32_t denominator,
int32_t* remainder);
/**
@ -196,7 +196,7 @@ class Grego {
* @param dom 1-based day of month
* @return the day number, with day 0 == Jan 1 1970
*/
static double fieldsToDay(int32_t year, int32_t month, int32_t dom);
static int64_t fieldsToDay(int32_t year, int32_t month, int32_t dom);
/**
* Convert a 1970-epoch day number to proleptic Gregorian year,

24
icu4c/source/i18n/hebrwcal.cpp
View file

@ -394,14 +394,14 @@ static const int32_t BAHARAD = 11*HOUR_PARTS + 204;
int32_t HebrewCalendar::startOfYear(int32_t year, UErrorCode &status)
{
ucln_i18n_registerCleanup(UCLN_I18N_HEBREW_CALENDAR, calendar_hebrew_cleanup);
int32_t day = CalendarCache::get(&gCache, year, status);
int64_t day = CalendarCache::get(&gCache, year, status);
if (day == 0) {
// # of months before year
int32_t months = (int32_t)ClockMath::floorDivide((235 * (int64_t)year - 234), (int64_t)19);
int64_t months = ClockMath::floorDivide((235 * (int64_t)year - 234), (int64_t)19);
int64_t frac = (int64_t)months * MONTH_FRACT + BAHARAD; // Fractional part of day #
day = months * 29 + (int32_t)(frac / DAY_PARTS); // Whole # part of calculation
int64_t frac = months * MONTH_FRACT + BAHARAD; // Fractional part of day #
day = months * 29LL + frac / DAY_PARTS; // Whole # part of calculation
frac = frac % DAY_PARTS; // Time of day
int32_t wd = (day % 7); // Day of week (0 == Monday)
@ -423,8 +423,14 @@ int32_t HebrewCalendar::startOfYear(int32_t year, UErrorCode &status)
// Prevents 382-day years.
day += 1;
}
CalendarCache::put(&gCache, year, day, status);
if (day > INT32_MAX || day < INT32_MIN) {
status = U_ILLEGAL_ARGUMENT_ERROR;
return 0;
}
CalendarCache::put(&gCache, year, static_cast<int32_t>(day), status);
}
// Out of range value is alread rejected before putting into cache.
U_ASSERT(INT32_MIN <= day && day <= INT32_MAX);
return day;
}
@ -478,7 +484,7 @@ int32_t HebrewCalendar::yearType(int32_t year) const
*/
UBool HebrewCalendar::isLeapYear(int32_t year) {
//return (year * 12 + 17) % 19 >= 12;
int32_t x = (year*12 + 17) % 19;
int64_t x = (year*12LL + 17) % 19;
return x >= ((x < 0) ? -7 : 12);
}
@ -643,7 +649,7 @@ int32_t HebrewCalendar::handleGetExtendedYear() {
* Return JD of start of given month/year.
* @internal
*/
int32_t HebrewCalendar::handleComputeMonthStart(int32_t eyear, int32_t month, UBool /*useMonth*/) const {
int64_t HebrewCalendar::handleComputeMonthStart(int32_t eyear, int32_t month, UBool /*useMonth*/) const {
UErrorCode status = U_ZERO_ERROR;
// Resolve out-of-range months. This is necessary in order to
// obtain the correct year. We correct to
@ -659,7 +665,7 @@ int32_t HebrewCalendar::handleComputeMonthStart(int32_t eyear, int32_t month, UB
month -= monthsInYear(eyear++);
}
int32_t day = startOfYear(eyear, status);
int64_t day = startOfYear(eyear, status);
if(U_FAILURE(status)) {
return 0;
@ -673,7 +679,7 @@ int32_t HebrewCalendar::handleComputeMonthStart(int32_t eyear, int32_t month, UB
}
}
return (int) (day + 347997);
return day + 347997LL;
}
constexpr uint32_t kHebrewRelatedYearDiff = -3760;

2
icu4c/source/i18n/hebrwcal.h
View file

@ -367,7 +367,7 @@ public:
* day of the given month and year
* @internal
*/
virtual int32_t handleComputeMonthStart(int32_t eyear, int32_t month,
virtual int64_t handleComputeMonthStart(int32_t eyear, int32_t month,
UBool useMonth) const override;

6
icu4c/source/i18n/indiancal.cpp
View file

@ -203,7 +203,7 @@ static double IndianToJD(int32_t year, int32_t month, int32_t date) {
* @param eyear The year in Indian Calendar measured from Saka Era (78 AD).
* @param month The month in Indian calendar
*/
int32_t IndianCalendar::handleComputeMonthStart(int32_t eyear, int32_t month, UBool /* useMonth */ ) const {
int64_t IndianCalendar::handleComputeMonthStart(int32_t eyear, int32_t month, UBool /* useMonth */ ) const {
//month is 0 based; converting it to 1-based
int32_t imonth;
@ -219,9 +219,9 @@ int32_t IndianCalendar::handleComputeMonthStart(int32_t eyear, int32_t month, UB
imonth = month + 1;
}
double jd = IndianToJD(eyear ,imonth, 1);
int64_t jd = IndianToJD(eyear ,imonth, 1);
return (int32_t)jd;
return jd;
}
//-------------------------------------------------------------------------

2
icu4c/source/i18n/indiancal.h
View file

@ -225,7 +225,7 @@ public:
/**
* @internal
*/
virtual int32_t handleComputeMonthStart(int32_t eyear, int32_t month, UBool useMonth) const override;
virtual int64_t handleComputeMonthStart(int32_t eyear, int32_t month, UBool useMonth) const override;
//-------------------------------------------------------------------------
// Functions for converting from milliseconds to field values

67
icu4c/source/i18n/islamcal.cpp
View file

@ -320,7 +320,7 @@ UBool IslamicCalendar::civilLeapYear(int32_t year)
* Return the day # on which the given year starts. Days are counted
* from the Hijri epoch, origin 0.
*/
int32_t IslamicCalendar::yearStart(int32_t year) const{
int64_t IslamicCalendar::yearStart(int32_t year) const{
return trueMonthStart(12*(year-1));
}
@ -331,7 +331,7 @@ int32_t IslamicCalendar::yearStart(int32_t year) const{
* @param year The hijri year
* @param month The hijri month, 0-based (assumed to be in range 0..11)
*/
int32_t IslamicCalendar::monthStart(int32_t year, int32_t month) const {
int64_t IslamicCalendar::monthStart(int32_t year, int32_t month) const {
return trueMonthStart(12*(year-1) + month);
}
@ -463,7 +463,7 @@ int32_t IslamicCalendar::handleGetYearLength(int32_t extendedYear) const {
/**
* @draft ICU 2.4
*/
int32_t IslamicCalendar::handleComputeMonthStart(int32_t eyear, int32_t month, UBool /* useMonth */) const {
int64_t IslamicCalendar::handleComputeMonthStart(int32_t eyear, int32_t month, UBool /* useMonth */) const {
// This may be called by Calendar::handleComputeJulianDay with months out of the range
// 0..11. Need to handle that here since monthStart requires months in the range 0.11.
if (month > 11) {
@ -538,10 +538,18 @@ void IslamicCalendar::handleComputeFields(int32_t julianDay, UErrorCode &status)
int32_t year = month >= 0 ? ((month / 12) + 1) : ((month + 1 ) / 12);
month = ((month % 12) + 12 ) % 12;
int32_t dayOfMonth = (days - monthStart(year, month)) + 1;
int64_t dayOfMonth = (days - monthStart(year, month)) + 1;
if (dayOfMonth > INT32_MAX || dayOfMonth < INT32_MIN) {
status = U_ILLEGAL_ARGUMENT_ERROR;
return;
}
// Now figure out the day of the year.
int32_t dayOfYear = (days - monthStart(year, 0)) + 1;
int64_t dayOfYear = (days - monthStart(year, 0)) + 1;
if (dayOfYear > INT32_MAX || dayOfYear < INT32_MIN) {
status = U_ILLEGAL_ARGUMENT_ERROR;
return;
}
internalSet(UCAL_ERA, 0);
internalSet(UCAL_YEAR, year);
@ -685,9 +693,9 @@ IslamicCivilCalendar* IslamicCivilCalendar::clone() const {
* Return the day # on which the given year starts. Days are counted
* from the Hijri epoch, origin 0.
*/
int32_t IslamicCivilCalendar::yearStart(int32_t year) const{
return static_cast<int32_t>(
(year-1)*354 + ClockMath::floorDivide((3+11*static_cast<int64_t>(year)),
int64_t IslamicCivilCalendar::yearStart(int32_t year) const{
return static_cast<int64_t>(
(year-1)*354LL + ClockMath::floorDivide((3+11*static_cast<int64_t>(year)),
static_cast<int64_t>(30)));
}
@ -698,10 +706,10 @@ int32_t IslamicCivilCalendar::yearStart(int32_t year) const{
* @param year The hijri year
* @param month The hijri month, 0-based (assumed to be in range 0..11)
*/
int32_t IslamicCivilCalendar::monthStart(int32_t year, int32_t month) const {
int64_t IslamicCivilCalendar::monthStart(int32_t year, int32_t month) const {
// This does not handle months out of the range 0..11
return static_cast<int32_t>(
uprv_ceil(29.5*month) + (year-1)*354 +
return static_cast<int64_t>(
uprv_ceil(29.5*month) + (year-1)*354LL +
static_cast<int32_t>(ClockMath::floorDivide(
3+11*static_cast<int64_t>(year),
static_cast<int64_t>(30))));
@ -758,10 +766,18 @@ void IslamicCivilCalendar::handleComputeFields(int32_t julianDay, UErrorCode &st
uprv_ceil((days - 29 - yearStart(year)) / 29.5 ));
month = month<11?month:11;
int32_t dayOfMonth = (days - monthStart(year, month)) + 1;
int64_t dayOfMonth = (days - monthStart(year, month)) + 1;
if (dayOfMonth > INT32_MAX || dayOfMonth < INT32_MIN) {
status = U_ILLEGAL_ARGUMENT_ERROR;
return;
}
// Now figure out the day of the year.
int32_t dayOfYear = (days - monthStart(year, 0)) + 1;
int64_t dayOfYear = (days - monthStart(year, 0)) + 1;
if (dayOfYear > INT32_MAX || dayOfYear < INT32_MIN) {
status = U_ILLEGAL_ARGUMENT_ERROR;
return;
}
internalSet(UCAL_ERA, 0);
internalSet(UCAL_YEAR, year);
@ -819,15 +835,15 @@ IslamicUmalquraCalendar* IslamicUmalquraCalendar::clone() const {
* Return the day # on which the given year starts. Days are counted
* from the Hijri epoch, origin 0.
*/
int32_t IslamicUmalquraCalendar::yearStart(int32_t year) const {
int64_t IslamicUmalquraCalendar::yearStart(int32_t year) const {
if (year < UMALQURA_YEAR_START || year > UMALQURA_YEAR_END) {
return static_cast<int32_t>(
(year-1)*354 + ClockMath::floorDivide((3+11*static_cast<int64_t>(year)),
return static_cast<int64_t>(
(year-1)*354LL + ClockMath::floorDivide((3+11*static_cast<int64_t>(year)),
static_cast<int64_t>(30)));
}
year -= UMALQURA_YEAR_START;
// rounded least-squares fit of the dates previously calculated from UMALQURA_MONTHLENGTH iteration
int32_t yrStartLinearEstimate = static_cast<int32_t>(
int64_t yrStartLinearEstimate = static_cast<int64_t>(
(354.36720 * (double)year) + 460322.05 + 0.5);
// need a slight correction to some
return yrStartLinearEstimate + umAlQuraYrStartEstimateFix[year];
@ -840,8 +856,8 @@ int32_t IslamicUmalquraCalendar::yearStart(int32_t year) const {
* @param year The hijri year
* @param month The hijri month, 0-based (assumed to be in range 0..11)
*/
int32_t IslamicUmalquraCalendar::monthStart(int32_t year, int32_t month) const {
int32_t ms = yearStart(year);
int64_t IslamicUmalquraCalendar::monthStart(int32_t year, int32_t month) const {
int64_t ms = yearStart(year);
for(int i=0; i< month; i++){
ms+= handleGetMonthLength(year, i);
}
@ -899,10 +915,11 @@ int32_t IslamicUmalquraCalendar::handleGetYearLength(int32_t extendedYear) const
*/
void IslamicUmalquraCalendar::handleComputeFields(int32_t julianDay, UErrorCode &status) {
if (U_FAILURE(status)) return;
int32_t year, month, dayOfMonth, dayOfYear;
int32_t year, month, dayOfYear;
int64_t dayOfMonth;
int32_t days = julianDay - getEpoc();
int32_t umalquraStartdays = yearStart(UMALQURA_YEAR_START) ;
int64_t umalquraStartdays = yearStart(UMALQURA_YEAR_START) ;
if (days < umalquraStartdays) {
//Use Civil calculation
year = (int32_t)ClockMath::floorDivide(
@ -935,9 +952,17 @@ void IslamicUmalquraCalendar::handleComputeFields(int32_t julianDay, UErrorCode
}
dayOfMonth = (days - monthStart(year, month)) + 1;
if (dayOfMonth > INT32_MAX || dayOfMonth < INT32_MIN) {
status = U_ILLEGAL_ARGUMENT_ERROR;
return;
}
// Now figure out the day of the year.
dayOfYear = (days - monthStart(year, 0)) + 1;
if (dayOfYear > INT32_MAX || dayOfYear < INT32_MIN) {
status = U_ILLEGAL_ARGUMENT_ERROR;
return;
}
internalSet(UCAL_ERA, 0);
internalSet(UCAL_YEAR, year);

14
icu4c/source/i18n/islamcal.h
View file

@ -206,7 +206,7 @@ class U_I18N_API IslamicCalendar : public Calendar {
* Return the day # on which the given year starts. Days are counted
* from the Hijri epoch, origin 0.
*/
virtual int32_t yearStart(int32_t year) const;
virtual int64_t yearStart(int32_t year) const;
/**
* Return the day # on which the given month starts. Days are counted
@ -215,7 +215,7 @@ class U_I18N_API IslamicCalendar : public Calendar {
* @param year The hijri year
* @param year The hijri month, 0-based
*/
virtual int32_t monthStart(int32_t year, int32_t month) const;
virtual int64_t monthStart(int32_t year, int32_t month) const;
/**
* Find the day number on which a particular month of the true/lunar
@ -271,7 +271,7 @@ class U_I18N_API IslamicCalendar : public Calendar {
/**
* @internal
*/
virtual int32_t handleComputeMonthStart(int32_t eyear, int32_t month, UBool useMonth) const override;
virtual int64_t handleComputeMonthStart(int32_t eyear, int32_t month, UBool useMonth) const override;
//-------------------------------------------------------------------------
// Functions for converting from milliseconds to field values
@ -463,7 +463,7 @@ class U_I18N_API IslamicCivilCalendar : public IslamicCalendar {
* from the Hijri epoch, origin 0.
* @internal
*/
virtual int32_t yearStart(int32_t year) const override;
virtual int64_t yearStart(int32_t year) const override;
/**
* Return the day # on which the given month starts. Days are counted
@ -473,7 +473,7 @@ class U_I18N_API IslamicCivilCalendar : public IslamicCalendar {
* @param year The hijri month, 0-based
* @internal
*/
virtual int32_t monthStart(int32_t year, int32_t month) const override;
virtual int64_t monthStart(int32_t year, int32_t month) const override;
/**
* Return the length (in days) of the given month.
@ -646,7 +646,7 @@ class U_I18N_API IslamicUmalquraCalendar : public IslamicCalendar {
* from the Hijri epoch, origin 0.
* @internal
*/
virtual int32_t yearStart(int32_t year) const override;
virtual int64_t yearStart(int32_t year) const override;
/**
* Return the day # on which the given month starts. Days are counted
@ -656,7 +656,7 @@ class U_I18N_API IslamicUmalquraCalendar : public IslamicCalendar {
* @param year The hijri month, 0-based
* @internal
*/
virtual int32_t monthStart(int32_t year, int32_t month) const override;
virtual int64_t monthStart(int32_t year, int32_t month) const override;
/**
* Return the length (in days) of the given month.

4
icu4c/source/i18n/persncal.cpp
View file

@ -166,14 +166,14 @@ int32_t PersianCalendar::handleGetYearLength(int32_t extendedYear) const {
//-------------------------------------------------------------------------
// Return JD of start of given month/year
int32_t PersianCalendar::handleComputeMonthStart(int32_t eyear, int32_t month, UBool /*useMonth*/) const {
int64_t PersianCalendar::handleComputeMonthStart(int32_t eyear, int32_t month, UBool /*useMonth*/) const {
// If the month is out of range, adjust it into range, and
// modify the extended year value accordingly.
if (month < 0 || month > 11) {
eyear += ClockMath::floorDivide(month, 12, &month);
}
int32_t julianDay = PERSIAN_EPOCH - 1 + 365 * (eyear - 1) + ClockMath::floorDivide(8 * eyear + 21, 33);
int64_t julianDay = PERSIAN_EPOCH - 1 + 365LL * (eyear - 1) + ClockMath::floorDivide(8 * eyear + 21, 33);
if (month != 0) {
julianDay += kPersianNumDays[month];

2
icu4c/source/i18n/persncal.h
View file

@ -219,7 +219,7 @@ class PersianCalendar : public Calendar {
/**
* @internal
*/
virtual int32_t handleComputeMonthStart(int32_t eyear, int32_t month, UBool useMonth) const override;
virtual int64_t handleComputeMonthStart(int32_t eyear, int32_t month, UBool useMonth) const override;
//-------------------------------------------------------------------------
// Functions for converting from milliseconds to field values

5
icu4c/source/i18n/timezone.cpp
View file

@ -733,6 +733,11 @@ void TimeZone::getOffset(UDate date, UBool local, int32_t& rawOffset,
int32_t year, month, dom, dow, millis;
double day = ClockMath::floorDivide(date, U_MILLIS_PER_DAY, &millis);
// out of the range
if (day < INT32_MIN || day > INT32_MAX) {
ec = U_ILLEGAL_ARGUMENT_ERROR;
return;
}
Grego::dayToFields(day, year, month, dom, dow);
dstOffset = getOffset(GregorianCalendar::AD, year, month, dom,

2
icu4c/source/i18n/unicode/calendar.h
View file

@ -1667,7 +1667,7 @@ protected:
* day of the given month and year
* @internal
*/
virtual int32_t handleComputeMonthStart(int32_t eyear, int32_t month,
virtual int64_t handleComputeMonthStart(int32_t eyear, int32_t month,
UBool useMonth) const = 0;
/**

2
icu4c/source/i18n/unicode/gregocal.h
View file

@ -487,7 +487,7 @@ public:
* day of the given month and year
* @internal
*/
virtual int32_t handleComputeMonthStart(int32_t eyear, int32_t month,
virtual int64_t handleComputeMonthStart(int32_t eyear, int32_t month,
UBool useMonth) const override;
/**

1
icu4c/source/test/fuzzer/calendar_fuzzer.cpp
View file

@ -79,6 +79,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
if (U_FAILURE(status)) return 0;
std::unique_ptr<icu::Calendar> cal(
icu::Calendar::createInstance(*timeZone, locale, status));
printf("locale = %s\n", locale.getName());
if (U_FAILURE(status)) return 0;
cal->clear();

42
icu4c/source/test/intltest/caltest.cpp
View file

@ -190,8 +190,15 @@ void CalendarTest::runIndexedTest( int32_t index, UBool exec, const char* &name,
TESTCASE_AUTO(TestDangiOverflowIsLeapMonthBetween22507);
TESTCASE_AUTO(TestRollWeekOfYear);
TESTCASE_AUTO(TestFirstDayOfWeek);
TESTCASE_AUTO(Test22633ChineseOverflow);
TESTCASE_AUTO(Test22633IndianOverflow);
TESTCASE_AUTO(Test22633IslamicUmalquraOverflow);
TESTCASE_AUTO(Test22633PersianOverflow);
TESTCASE_AUTO(TestAddOverflow);
TESTCASE_AUTO(TestChineseCalendarComputeMonthStart);
TESTCASE_AUTO_END;
@ -5632,12 +5639,45 @@ void CalendarTest::TestFirstDayOfWeek() {
verifyFirstDayOfWeek("zxx", UCAL_MONDAY);
}
void CalendarTest::Test22633ChineseOverflow() {
UErrorCode status = U_ZERO_ERROR;
LocalPointer<Calendar> cal(Calendar::createInstance(Locale("en@calendar=chinese"), status), status);
U_ASSERT(U_SUCCESS(status));
cal->setTime(2043071457431218011677338081118001787485161156097100985923226601036925437809699842362992455895409920480414647512899096575018732258582416938813614617757317338664031880042592085084690242819214720523061081124318514531466365480449329351434046537728.000000, status);
U_ASSERT(U_SUCCESS(status));
cal->set(UCAL_EXTENDED_YEAR, -1594662558);
cal->get(UCAL_YEAR, status);
assertTrue("Should return success", U_SUCCESS(status));
}
void CalendarTest::Test22633IndianOverflow() {
UErrorCode status = U_ZERO_ERROR;
LocalPointer<Calendar> cal(Calendar::createInstance(Locale("en@calendar=indian"), status), status);
U_ASSERT(U_SUCCESS(status));
cal->roll(UCAL_EXTENDED_YEAR, -2120158417, status);
assertTrue("Should return success", U_SUCCESS(status));
}
void CalendarTest::Test22633IslamicUmalquraOverflow() {
UErrorCode status = U_ZERO_ERROR;
LocalPointer<Calendar> cal(Calendar::createInstance(Locale("en@calendar=islamic-umalqura"), status), status);
U_ASSERT(U_SUCCESS(status));
cal->roll(UCAL_YEAR, -134404585, status);
assertTrue("Should return success", U_SUCCESS(status));
}
void CalendarTest::Test22633PersianOverflow() {
UErrorCode status = U_ZERO_ERROR;
LocalPointer<Calendar> cal(Calendar::createInstance(Locale("en@calendar=persian"), status), status);
U_ASSERT(U_SUCCESS(status));
cal->add(UCAL_ORDINAL_MONTH, 1594095615, status);
assertTrue("Should return success", U_SUCCESS(status));
}
void CalendarTest::TestChineseCalendarComputeMonthStart() { // ICU-22639
UErrorCode status = U_ZERO_ERROR;
// An extended year for which hasLeapMonthBetweenWinterSolstices is true.
constexpr int32_t eyear = 4643;
constexpr int32_t monthStart = 2453764;
constexpr int64_t monthStart = 2453764;
LocalPointer<Calendar> calendar(
Calendar::createInstance(Locale("en_US@calendar=chinese"), status),

4
icu4c/source/test/intltest/caltest.h
View file

@ -334,6 +334,10 @@ public: // package
void TestFWWithISO8601();
void TestAddOverflow();
void TestRollWeekOfYear();
void Test22633ChineseOverflow();
void Test22633IndianOverflow();
void Test22633IslamicUmalquraOverflow();
void Test22633PersianOverflow();
void verifyFirstDayOfWeek(const char* locale, UCalendarDaysOfWeek expected);
void TestFirstDayOfWeek();