Skip to content

bpo-35021: Fixes assertion failures in _datetimemodule.c #10039

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Nov 20, 2018
Merged

bpo-35021: Fixes assertion failures in _datetimemodule.c #10039

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
43 changes: 37 additions & 6 deletions Lib/test/datetimetester.py
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -893,19 +893,50 @@ def test_issue31752(self):
class BadInt(int):
def __mul__(self, other):
return Prod()
def __rmul__(self, other):
return Prod()
def __floordiv__(self, other):
return Prod()
def __rfloordiv__(self, other):
return Prod()

class Prod:
def __add__(self, other):
return Sum()
def __radd__(self, other):
return Sum()

class Sum(int):
def __divmod__(self, other):
# negative remainder
return (0, -1)

timedelta(microseconds=BadInt(1))
timedelta(hours=BadInt(1))
timedelta(weeks=BadInt(1))
return divmodresult

for divmodresult in [None, (), (0, 1, 2), (0, -1)]:
with self.subTest(divmodresult=divmodresult):
# The following examples should not crash.
try:
timedelta(microseconds=BadInt(1))
except TypeError:
pass
try:
timedelta(hours=BadInt(1))
except TypeError:
pass
try:
timedelta(weeks=BadInt(1))
except (TypeError, ValueError):
pass
try:
timedelta(1) * BadInt(1)
except (TypeError, ValueError):
pass
try:
BadInt(1) * timedelta(1)
except TypeError:
pass
try:
timedelta(1) // BadInt(1)
except TypeError:
pass


#############################################################################
Expand Down
99 changes: 51 additions & 48 deletions Modules/_datetimemodule.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1772,6 +1772,29 @@ delta_to_microseconds(PyDateTime_Delta *self)
return result;
}

static PyObject *
checked_divmod(PyObject *a, PyObject *b)
{
PyObject *result = PyNumber_Divmod(a, b);
if (result != NULL) {
if (!PyTuple_Check(result)) {
PyErr_Format(PyExc_TypeError,
"divmod() returned non-tuple (type %.200s)",
result->ob_type->tp_name);
Py_DECREF(result);
return NULL;
}
if (PyTuple_GET_SIZE(result) != 2) {
PyErr_Format(PyExc_TypeError,
"divmod() returned a tuple of size %zd",
PyTuple_GET_SIZE(result));
Py_DECREF(result);
return NULL;
}
}
return result;
}

/* Convert a number of us (as a Python int) to a timedelta.
*/
static PyObject *
Expand All @@ -1780,70 +1803,49 @@ microseconds_to_delta_ex(PyObject *pyus, PyTypeObject *type)
int us;
int s;
int d;
long temp;

PyObject *tuple = NULL;
PyObject *num = NULL;
PyObject *result = NULL;

assert(PyLong_CheckExact(pyus));
tuple = PyNumber_Divmod(pyus, us_per_second);
if (tuple == NULL)
tuple = checked_divmod(pyus, us_per_second);
if (tuple == NULL) {
goto Done;
}

num = PyTuple_GetItem(tuple, 1); /* us */
if (num == NULL)
goto Done;
temp = PyLong_AsLong(num);
num = PyTuple_GET_ITEM(tuple, 1); /* us */
us = _PyLong_AsInt(num);
num = NULL;
if (temp == -1 && PyErr_Occurred())
goto Done;
assert(0 <= temp && temp < 1000000);
us = (int)temp;
if (us < 0) {
/* The divisor was positive, so this must be an error. */
assert(PyErr_Occurred());
if (us == -1 && PyErr_Occurred()) {
goto Done;
}
if (!(0 <= us && us < 1000000)) {
goto BadDivmod;
}

num = PyTuple_GetItem(tuple, 0); /* leftover seconds */
if (num == NULL)
goto Done;
num = PyTuple_GET_ITEM(tuple, 0); /* leftover seconds */
Py_INCREF(num);
Py_DECREF(tuple);

tuple = PyNumber_Divmod(num, seconds_per_day);
tuple = checked_divmod(num, seconds_per_day);
if (tuple == NULL)
goto Done;
Py_DECREF(num);

num = PyTuple_GetItem(tuple, 1); /* seconds */
if (num == NULL)
goto Done;
temp = PyLong_AsLong(num);
num = PyTuple_GET_ITEM(tuple, 1); /* seconds */
s = _PyLong_AsInt(num);
num = NULL;
if (temp == -1 && PyErr_Occurred())
goto Done;
assert(0 <= temp && temp < 24*3600);
s = (int)temp;

if (s < 0) {
/* The divisor was positive, so this must be an error. */
assert(PyErr_Occurred());
if (s == -1 && PyErr_Occurred()) {
goto Done;
}
if (!(0 <= s && s < 24*3600)) {
goto BadDivmod;
}

num = PyTuple_GetItem(tuple, 0); /* leftover days */
if (num == NULL)
goto Done;
num = PyTuple_GET_ITEM(tuple, 0); /* leftover days */
Py_INCREF(num);
temp = PyLong_AsLong(num);
if (temp == -1 && PyErr_Occurred())
goto Done;
d = (int)temp;
if ((long)d != temp) {
PyErr_SetString(PyExc_OverflowError, "normalized days too "
"large to fit in a C int");
d = _PyLong_AsInt(num);
if (d == -1 && PyErr_Occurred()) {
goto Done;
}
result = new_delta_ex(d, s, us, 0, type);
Expand All @@ -1852,6 +1854,11 @@ microseconds_to_delta_ex(PyObject *pyus, PyTypeObject *type)
Py_XDECREF(tuple);
Py_XDECREF(num);
return result;

BadDivmod:
PyErr_SetString(PyExc_TypeError,
"divmod() returned a value out of range");
goto Done;
}

#define microseconds_to_delta(pymicros) \
Expand All @@ -1868,7 +1875,7 @@ multiply_int_timedelta(PyObject *intobj, PyDateTime_Delta *delta)
if (pyus_in == NULL)
return NULL;

pyus_out = PyNumber_Multiply(pyus_in, intobj);
pyus_out = PyNumber_Multiply(intobj, pyus_in);
Py_DECREF(pyus_in);
if (pyus_out == NULL)
return NULL;
Expand Down Expand Up @@ -2272,13 +2279,12 @@ delta_divmod(PyObject *left, PyObject *right)
return NULL;
}

divmod = PyNumber_Divmod(pyus_left, pyus_right);
divmod = checked_divmod(pyus_left, pyus_right);
Py_DECREF(pyus_left);
Py_DECREF(pyus_right);
if (divmod == NULL)
return NULL;

assert(PyTuple_Size(divmod) == 2);
delta = microseconds_to_delta(PyTuple_GET_ITEM(divmod, 1));
if (delta == NULL) {
Py_DECREF(divmod);
Expand Down Expand Up @@ -2309,13 +2315,11 @@ accum(const char* tag, PyObject *sofar, PyObject *num, PyObject *factor,
assert(num != NULL);

if (PyLong_Check(num)) {
prod = PyNumber_Multiply(factor, num);
prod = PyNumber_Multiply(num, factor);
Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

same comment as the other PR: add a comment on the PyNumber_Multiply calls describing why the order might matter.

Copy link
Member Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

The order doesn't matter now. I just restore the order prior to bpo-31752 changes.

if (prod == NULL)
return NULL;
assert(PyLong_CheckExact(prod));
sum = PyNumber_Add(sofar, prod);
Py_DECREF(prod);
assert(sum == NULL || PyLong_CheckExact(sum));
return sum;
}

Expand Down Expand Up @@ -2373,7 +2377,6 @@ accum(const char* tag, PyObject *sofar, PyObject *num, PyObject *factor,
Py_DECREF(sum);
Py_DECREF(x);
*leftover += fracpart;
assert(y == NULL || PyLong_CheckExact(y));
return y;
}

Expand Down