static PyObject * m_timerfd_gettime(PyObject *self, PyObject *args)
{
long fd = 0;
int t_res;
struct itimerspec g_time;
PyObject* resp;
if (!PyArg_ParseTuple(args, "l", &fd)) {
PyErr_SetString(
PyExc_TypeError,
"fd is not a valid type or the argument is missing");
return NULL;
}
t_res = timerfd_gettime(fd, &g_time);
if (t_res == -1) {
return PyErr_SetFromErrno(PyExc_IOError);
}
resp = PyTuple_New(2);
if (resp == NULL) {
/* printf("bad tuple\n"); */
return NULL;
}
PyTuple_SetItem(resp, 0,
PyDelta_FromDSU(0, g_time.it_value.tv_sec, NANO2MICRO(g_time.it_value.tv_nsec)));
PyTuple_SetItem(resp, 1,
PyDelta_FromDSU(0, g_time.it_interval.tv_sec, NANO2MICRO(g_time.it_interval.tv_nsec)));
return resp;
}//m_timerfd_gettime()
static PyObject *PyKAdminPrincipal_get_maxlife(PyKAdminPrincipalObject *self, void *closure) {
PyDateTime_IMPORT;
PyObject *delta = PyDelta_FromDSU(0, self->entry.max_life, 0);
if (!delta) { PyErr_SetString(PyExc_AttributeError, NULL); }
return delta;
}
static
PyObject* from_second_kobject(K x){
PyDateTime_IMPORT;
PyObject* result;
Py_ssize_t i, length ;
length = (Py_ssize_t)(x->n);
if(scalar(x)) {
int value = (x->i);
result = PyDelta_FromDSU(0, value, 0);
}
else {
result = PyList_New(length);
for(i = 0; i != length; ++i) {
int value = xI[i];
PyList_SetItem(result, i, PyDelta_FromDSU(0, value, 0));
}
}
return result;
}
static
PyObject* from_minute_kobject(K x){
/* 99:10 is a valid minute object whatever that means
likewise the parser seems to take 10000:10 */
PyDateTime_IMPORT;
PyObject* result;
Py_ssize_t i, length ;
length = (Py_ssize_t)(x->n);
if(scalar(x)) {
int value = (x->i) * 60 ;
result = PyDelta_FromDSU(0, value, 0);
}
else {
result = PyList_New(length);
for(i = 0; i!= length ; ++i) {
int value = 60 * (xI[i]);
PyList_SetItem(result, i, PyDelta_FromDSU(0, value, 0)) ;
}
}
return result;
}
static
PyObject* from_timespan_kobject(K x){
PyDateTime_IMPORT;
PyObject* result ;
Py_ssize_t i, length ;
length = (Py_ssize_t)(x->n);
int /*year, month, */ day, /*hour, minute,*/ second, usecond;
if(scalar(x)) {
double value = (x->j) / 1e9;
timespan_helper(value, &day, &second, &usecond);
result = PyDelta_FromDSU(day, second, usecond) ;
}
else {
result = PyList_New(length);
for(i = 0; i != length; ++i) {
double value = xJ[i] / 1e9;
timespan_helper(value, &day, &second, &usecond);
PyList_SetItem(result, i, PyDelta_FromDSU(day, second, usecond));
}
}
return result;
}
PyTypeObject *
init_fixed_offset_type(void)
{
PyDateTime_IMPORT;
zero_delta = PyDelta_FromDSU(0, 0, 0);
if(! zero_delta) {
return NULL;
}
FixedOffsetType.tp_base = PyDateTimeAPI->TZInfoType;
if(PyType_Ready(&FixedOffsetType)) {
return NULL;
}
return &FixedOffsetType;
}
/**
Convert a TIME MySQL value to Python datetime.timedelta.
Convert a TIME MySQL value to a Python datetime.timedelta returned
as PyDelta_FromDSU object.
@param data string to be converted
@param length length of data
@return datetime.timedelta object.
@retval PyDelta_FromDSU OK
*/
PyObject*
mytopy_time(const char *data, const unsigned long length)
{
int hr= 0, min= 0, sec= 0, usec= 0;
int days= 0, hours= 0, seconds= 0;
int negative= 0;
int value= 0;
int parts[4]= {0};
int part= 0;
const char *end= data + length;
PyDateTime_IMPORT;
// Negative times
if (*data == '-')
{
negative= 1;
data++;
}
/* Parse hours, minutes and seconds */
for (;;)
{
for (value= 0; data != end && isdigit(*data) ; data++)
{
value= (value * 10) + (unsigned int)(*data - '0');
}
parts[part++]= (unsigned int)value;
if (part == 4 || (end-data) < 2 || *data != ':' || !isdigit(data[1]))
{
break;
}
data++; // skip time separator ':'
}
if (data != end && end - data >= 2 && *data == '.')
{
// Fractional part
int field_length= 5;
data++;
value= (unsigned int)(*data - '0');
while (data++ != end && isdigit(*data))
{
if (field_length-- > 0)
{
value= (value * 10) + (unsigned int)(*data - '0');
}
}
if (field_length >= 0)
{
while (field_length-- > 0)
{
value*= 10;
}
}
parts[3]= value;
}
hr= parts[0];
min= parts[1];
sec= parts[2];
usec= parts[3];
// negative time
if (negative) {
hr= hr * -1;
min= min * -1;
sec= sec * -1;
usec= usec * -1;
}
days= hr / 24;
hours= hr % 24;
seconds= (hours * 3600) + (min * 60) + sec;
return PyDelta_FromDSU(days, seconds, usec);
}
static PyObject *m_timerfd_settime(PyObject *self, PyObject *args, PyObject *kwargs)
{
/* printf("m_timerfd_settime\n"); */
/* XXX We don't accept flags at this time and we only take relatvie times.
*/
/* char *kw[] = {"fd", "deadline", "interval", "flags", NULL}; */
char *kw[] = {"fd", "deadline", "interval", NULL};
long fd = 0;
/* long flags = 0; */
long msec = 0; // microseconds
int t_res;
PyObject *deadline = NULL;
PyObject *interval = NULL;
struct itimerspec new_val;
struct itimerspec old_val;
memset(&new_val, 0, sizeof(struct itimerspec));
memset(&old_val, 0, sizeof(struct itimerspec));
if (!PyArg_ParseTupleAndKeywords(
args, kwargs, "l|OO:timerfd_settime", kw,
&fd, &deadline, &interval)) {
return NULL;
}
printf("fd %ld, deadline %p interval %p\n", fd, deadline, interval);
if (deadline != NULL) {
/* printf("deadline is set\n"); */
if (PyDelta_Check(deadline)) {
/* printf("deadline is Delta\n"); */
if(pydelta_to_timespec(deadline, &new_val.it_value) == NULL) {
return NULL;
}
} else if (PyLong_Check(deadline)) {
/* printf("deadline is long\n"); */
msec = PyLong_AsLong(deadline);
new_val.it_value.tv_sec = msec / MICROSEC;
/* new_val.it_value.tv_nsec = (msec % MICROSEC) * 1000; */
new_val.it_value.tv_nsec = MICRO2NANO(msec);
} else {
/* printf("deadline is UK\n"); */
PyErr_SetString(
PyExc_TypeError,
"deadline is not a valid type. Must be a timedelta object or integer");
return NULL;
}
}
/* printf("deadline sec %ld nsec %ld\n", new_val.it_value.tv_sec, new_val.it_value.tv_nsec); */
if (interval != NULL) {
/* printf("interval is set\n"); */
/* Py_INCREF(interval); */
if (PyDelta_Check(interval)) {
/* printf("interval is Delta\n"); */
if(pydelta_to_timespec(interval, &new_val.it_interval) == NULL) {
return NULL;
}
} else if (PyLong_Check(interval)) {
/* printf("interval is long\n"); */
msec = PyLong_AsLong(interval);
new_val.it_interval.tv_sec = msec / MICROSEC;
/* new_val.it_interval.tv_nsec = (msec % MICROSEC) * 1000; */
new_val.it_interval.tv_nsec = MICRO2NANO(msec);
} else {
PyErr_SetString(
PyExc_TypeError,
"interval is not a valid type. Must be a timedelta object or integer");
return NULL;
}
}
/* printf("interval is %ld\n", msec); */
/* [> printf("interval sec %ld nsec %ld\n", <] */
/* [> new_val.it_interval.tv_sec, <] */
/* [> new_val.it_interval.tv_nsec); <] */
/* printf("settime fd %ld, new_val %p old_val %p\n", fd, &new_val, &old_val); */
t_res = timerfd_settime(fd, 0, &new_val, &old_val);
/* printf("timerfd_settime response %d\n", t_res); */
if (t_res != 0) {
/* printf("error out\n"); */
return PyErr_SetFromErrno(PyExc_IOError);
}
/* printf("create tuple\n"); */
PyObject *resp = PyTuple_New(2);
if (resp == NULL) {
/* printf("bad tuple\n"); */
return NULL;
}
printf("settime fd %ld, old_sec %ld old_nsec %ld\n",
fd, old_val.it_value.tv_sec, old_val.it_value.tv_nsec);
PyTuple_SetItem(
resp,
0,
PyDelta_FromDSU(0, old_val.it_value.tv_sec,
NANO2MICRO(old_val.it_value.tv_nsec)));
if (PyErr_Occurred() != NULL) {
Py_XDECREF(resp);
return NULL;
}
printf("settime fd %ld, old_int_sec %ld old_int_nsec %ld\n",
fd, old_val.it_interval.tv_sec, old_val.it_interval.tv_nsec);
PyTuple_SetItem(
resp,
1,
PyDelta_FromDSU(0, old_val.it_interval.tv_sec,
NANO2MICRO(old_val.it_interval.tv_nsec)));
if (PyErr_Occurred() != NULL) {
Py_XDECREF(resp);
return NULL;
}
/* printf("return %p\n", resp); */
return (PyObject *)resp;
}//m_timerfd_settime()
static PyObject*
decode_datetime(JSONData *jsondata)
{
PyObject *object;
char c = 0;
int n = 0;
char *ptr = NULL,
*tinfo_str = NULL;
int year = 0,
month = 0,
day = 0,
hour = 0,
minute = 0,
second = 0,
usecond = 0;
int is_tdelta = False,
tinfo_len;
// look for the closing quote
ptr = jsondata->ptr + 2; // Skip the type hint and the opening quote
while (True) {
c = *ptr;
if (c == 0) {
PyErr_Format(JSON_DecodeError,
"unterminated datetime string starting at position " SSIZE_T_F,
(Py_ssize_t)(jsondata->ptr - jsondata->str));
goto failure;
}
if (c == '"') {
break;
}
if (ptr - jsondata->ptr - 2 == 0 ) { // first character
switch (c) {
case '-':
case '+':
is_tdelta = True;
}
}
ptr++;
}
// get only the actual datetime information
skipSpaces(jsondata);
tinfo_len = ptr - (jsondata->ptr + 2);
if (tinfo_len) {
tinfo_str = (char*) malloc(tinfo_len);
strncpy(tinfo_str, jsondata->ptr + 2, tinfo_len);
}
if (is_tdelta) {
n = sscanf(tinfo_str, "%d:%u:%u:%u.%u", &day, &hour, &minute, &second, &usecond);
if (n != 3) {
PyErr_Format(JSON_DecodeError, "bad timedelta format at position " SSIZE_T_F ": %s",
(Py_ssize_t)(jsondata->ptr - jsondata->str),
tinfo_str);
goto failure;
} else {
second += minute * 60;
second += hour * 60 * 60;
object = PyDelta_FromDSU(day, second, usecond);
}
} else {
char* is_datetime = strchr(tinfo_str, ' ');
if (is_datetime == NULL) {
switch (tinfo_len) {
case 10:
n = sscanf(tinfo_str, "%u-%u-%u", &year, &month, &day);
object = PyDate_FromDate(year, month, day);
break;
case 8:
n = sscanf(tinfo_str, "%u:%u:%u", &hour, &minute, &second);
object = PyTime_FromTime(hour, minute, second, 0);
break;
case 15:
n = sscanf(tinfo_str, "%u:%u:%u.%u", &hour, &minute, &second, &usecond);
object = PyTime_FromTime(hour, minute, second, usecond);
break;
}
} else {
switch (tinfo_len) {
case 19:
n = sscanf(tinfo_str, "%u-%u-%u %u:%u:%u", &year, &month, &day, &hour, &minute, &second);
object = PyDateTime_FromDateAndTime(year, month, day, hour, minute, second, 0);
break;
case 26:
n = sscanf(tinfo_str, "%u-%u-%u %u:%u:%u.%u", &year, &month, &day, &hour, &minute, &second, &usecond);
object = PyDateTime_FromDateAndTime(year, month, day, hour, minute, second, usecond);
break;
}
}
}
if (object == NULL) {
PyErr_Format(JSON_DecodeError, "bad format for time, date, or datetime at position " SSIZE_T_F ": %s",
(Py_ssize_t)(jsondata->ptr - jsondata->str),
tinfo_str);
goto failure;
}
jsondata->ptr = jsondata->ptr + tinfo_len + 3;
return object;
failure:
free(tinfo_str);
Py_XDECREF(object);
return NULL;
}
static PyObject *
fixedoffset_utcoffset(FixedOffset *self, PyObject *args)
{
return PyDelta_FromDSU(0, self->offset_secs, 0);
}
/*
* def dst(self, dt):
* return timedelta(seconds=self.offset * 60)
*/
static PyObject *FixedOffset_dst(FixedOffset *self, PyObject *args) {
return PyDelta_FromDSU(0, self->offset, 0);
}
PyObject* PyDeltaFromMIInterval(const MI_Interval& interval)
{
return PyDelta_FromDSU(interval.days, interval.hours * 3600 + interval.minutes * 60 + interval.seconds, interval.microseconds);
}
