rrdtoolmodule.c

Bug Summary

File:	rrdtoolmodule.c
Warning:	line 459, column 9 Calling function 'PyTuple_SetItem' with a PyObject argument whose ownership has been released (with stolen reference)

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name rrdtoolmodule.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -analyzer-output=html -analyzer-checker=python -analyzer-disable-checker=deadcode -analyzer-config prune-paths=true,suppress-c++-stdlib=true,suppress-inlined-defensive-checks=false,suppress-null-return-paths=false,crosscheck-with-z3=true,model-path=/opt/pyrefcon/lib/pyrefcon/models/models -analyzer-config experimental-enable-naive-ctu-analysis=true,ctu-dir=/tmp/pyrefcon/python-rrdtool/csa-scan,ctu-index-name=/tmp/pyrefcon/python-rrdtool/csa-scan/externalDefMap.txt,ctu-invocation-list=/tmp/pyrefcon/python-rrdtool/csa-scan/invocations.yaml,display-ctu-progress=false -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=none -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debug-info-kind=limited -dwarf-version=4 -debugger-tuning=gdb -fcoverage-compilation-dir=/tmp/pyrefcon/python-rrdtool -resource-dir /opt/pyrefcon/lib/clang/13.0.0 -isystem /opt/pyrefcon/lib/pyrefcon/models/python3.8 -D NDEBUG -D _FORTIFY_SOURCE=2 -D PACKAGE_VERSION="0.1.15" -D WITH_FETCH_CB=1 -I /tmp/pyrefcon/python-rrdtool -I /usr/local/include -internal-isystem /opt/pyrefcon/lib/clang/13.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-result -Wsign-compare -Wall -Wformat -Wformat -Wdate-time -fdebug-compilation-dir=/tmp/pyrefcon/python-rrdtool -ferror-limit 19 -fwrapv -pthread -stack-protector 2 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/pyrefcon/python-rrdtool/csa-scan/reports -x c rrdtoolmodule.c

rrdtoolmodule.c

→

1/*
* python-rrdtool, Python bindings for rrdtool.
* Based on the rrdtool Python bindings for Python 2 from
* Hye-Shik Chang <perky@fallin.lv>.
*
* Copyright 2012 Christian Kroeger <commx@commx.ws>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of the
* License, or (at your option) any later version.
*
* This program 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 Lesser General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
* MA 02110-1301, USA.
*
*/

25#include <Python.h>
26#include <datetime.h>
27#include "rrdtoolmodule.h"

29/* Some macros to maintain compatibility between Python 2.x and 3.x */
30#if PY_MAJOR_VERSION3 >= 3
31#define HAVE_PY3K
32#define PyRRD_String_Check(x)((((((PyObject*)(x))->ob_type))->tp_flags & ((1UL <<
 28))) != 0)                 PyUnicode_Check(x)((((((PyObject*)(x))->ob_type))->tp_flags & ((1UL <<
 28))) != 0)
33#define PyRRD_String_FromString(x)PyUnicode_FromString(x)            PyUnicode_FromString(x)
34#define PyRRD_String_AS_STRING(x)PyUnicode_AsUTF8(x)             PyUnicode_AsUTF8(x)
35#define PyRRD_String_FromStringAndSize(x, y)PyBytes_FromStringAndSize(x, y)  PyBytes_FromStringAndSize(x, y)
36#define PyRRD_String_Size(x)PyUnicode_Size(x)                  PyUnicode_Size(x)
37#define PyRRD_Int_FromLong(x)PyLong_FromLong(x)                 PyLong_FromLong(x)
38#define PyRRD_Int_FromString(x, y, z)PyLong_FromString(x,y,z)         PyLong_FromString(x,y,z)
39#define PyRRD_Long_Check(x)((((((PyObject*)(x))->ob_type))->tp_flags & ((1UL <<
 24))) != 0)                   PyLong_Check(x)((((((PyObject*)(x))->ob_type))->tp_flags & ((1UL <<
 24))) != 0)
40#else
41#define PyRRD_String_Check(x)((((((PyObject*)(x))->ob_type))->tp_flags & ((1UL <<
 28))) != 0)                 PyString_Check(x)
42#define PyRRD_String_FromString(x)PyUnicode_FromString(x)            PyString_FromString(x)
43#define PyRRD_String_AS_STRING(x)PyUnicode_AsUTF8(x)             PyString_AS_STRING(x)
44#define PyRRD_String_FromStringAndSize(x, y)PyBytes_FromStringAndSize(x, y)  PyString_FromStringAndSize(x, y)
45#define PyRRD_String_Size(x)PyUnicode_Size(x)                  PyString_Size(x)
46#define PyRRD_Int_FromLong(x)PyLong_FromLong(x)                 PyInt_FromLong(x)
47#define PyRRD_Int_FromString(x, y, z)PyLong_FromString(x,y,z)         PyInt_FromString(x,y,z)
48#define PyRRD_Long_Check(x)((((((PyObject*)(x))->ob_type))->tp_flags & ((1UL <<
 24))) != 0)                   (PyInt_Check(x) || PyLong_Check(x)((((((PyObject*)(x))->ob_type))->tp_flags & ((1UL <<
 24))) != 0))
49#endif

51#ifndef Py_UNUSED
52#ifdef __GNUC__4
#define Py_UNUSED(name)_unused_name __attribute__((unused)) _unused_ ## name __attribute__((unused))
54#else
#define Py_UNUSED(name)_unused_name __attribute__((unused)) _unused_ ## -name
56#endif
57#endif

59#ifndef DS_NAM_SIZE20
60#define DS_NAM_SIZE20 20
61#endif

63/** Binding version. */
64static const char *_version = PACKAGE_VERSION"0.1.15";

66/** Exception types. */
67static PyObject *rrdtool_OperationalError;
68static PyObject *rrdtool_ProgrammingError;

70/**
* PyRRD_DateTime_FromTS: convert UNIX timestamp (time_t)
* to Python datetime object.
*
* @param ts UNIX timestamp (time_t)
* @return Pointer to new PyObject (New Reference)
*/
77static PyObject *
78PyRRD_DateTime_FromTS(time_t ts)
79{
  PyObject *ret;
  struct tm lt;

  localtime_r(&ts, &lt);

  ret = PyDateTime_FromDateAndTime(PyDateTimeAPI->DateTime_FromDateAndTime(lt.tm_year + 1900,
 lt.tm_mon + 1, lt.tm_mday, lt.tm_hour, lt.tm_min, lt.tm_sec,
 0, (&_Py_NoneStruct), PyDateTimeAPI->DateTimeType)
      lt.tm_year + 1900,PyDateTimeAPI->DateTime_FromDateAndTime(lt.tm_year + 1900,
 lt.tm_mon + 1, lt.tm_mday, lt.tm_hour, lt.tm_min, lt.tm_sec,
 0, (&_Py_NoneStruct), PyDateTimeAPI->DateTimeType)
      lt.tm_mon + 1,PyDateTimeAPI->DateTime_FromDateAndTime(lt.tm_year + 1900,
 lt.tm_mon + 1, lt.tm_mday, lt.tm_hour, lt.tm_min, lt.tm_sec,
 0, (&_Py_NoneStruct), PyDateTimeAPI->DateTimeType)
      lt.tm_mday,PyDateTimeAPI->DateTime_FromDateAndTime(lt.tm_year + 1900,
 lt.tm_mon + 1, lt.tm_mday, lt.tm_hour, lt.tm_min, lt.tm_sec,
 0, (&_Py_NoneStruct), PyDateTimeAPI->DateTimeType)
      lt.tm_hour,PyDateTimeAPI->DateTime_FromDateAndTime(lt.tm_year + 1900,
 lt.tm_mon + 1, lt.tm_mday, lt.tm_hour, lt.tm_min, lt.tm_sec,
 0, (&_Py_NoneStruct), PyDateTimeAPI->DateTimeType)
      lt.tm_min,PyDateTimeAPI->DateTime_FromDateAndTime(lt.tm_year + 1900,
 lt.tm_mon + 1, lt.tm_mday, lt.tm_hour, lt.tm_min, lt.tm_sec,
 0, (&_Py_NoneStruct), PyDateTimeAPI->DateTimeType)
      lt.tm_sec,PyDateTimeAPI->DateTime_FromDateAndTime(lt.tm_year + 1900,
 lt.tm_mon + 1, lt.tm_mday, lt.tm_hour, lt.tm_min, lt.tm_sec,
 0, (&_Py_NoneStruct), PyDateTimeAPI->DateTimeType)
      0)PyDateTimeAPI->DateTime_FromDateAndTime(lt.tm_year + 1900,
 lt.tm_mon + 1, lt.tm_mday, lt.tm_hour, lt.tm_min, lt.tm_sec,
 0, (&_Py_NoneStruct), PyDateTimeAPI->DateTimeType);

  return ret;
95}

97/**
* PyRRD_String_FromCF: get string representation of CF enum index
*
* @param cf enum cf_en
* @return Null-terminated string
*/
103const char *
104PyRRD_String_FromCF(enum cf_en cf)
105{
  switch (cf) {
      case CF_AVERAGE:
          return "AVERAGE";
      case CF_MINIMUM:
          return "MIN";
      case CF_MAXIMUM:
          return "MAX";
      case CF_LAST:
          return "LAST";
      default:
          return "INVALID";
  }
118}

120/**
* Helper function to convert Python objects into a representation that the
* rrdtool functions can work with.
*
* @param command RRDtool command name
* @param args Command arguments
* @return Zero if the function succeeds, otherwise -1
*/
128static int
129convert_args(char *command, PyObject *args, char ***rrdtool_argv, int *rrdtool_argc)
130{
  PyObject *o, *lo;
  int i, j, args_count, argv_count, element_count;

  argv_count = element_count = 0;
  args_count = PyTuple_Size(args);

  for (i = 0; i < args_count; i++) {
      o = PyTuple_GET_ITEM(args, i)((((void) (0)), (PyTupleObject *)(args))->ob_item[i]);

      if (PyRRD_String_Check(o)((((((PyObject*)(o))->ob_type))->tp_flags & ((1UL <<
 28))) != 0))
          element_count++;
      else if (PyList_CheckExact(o)((((PyObject*)(o))->ob_type) == &PyList_Type))
          element_count += PyList_Size(o);
      else {
          PyErr_Format(PyExc_TypeError,
                       "Argument %d must be str or a list of str", i);
          return -1;
      }
  }

  *rrdtool_argv = PyMem_New(char *, element_count + 1)( ((size_t)(element_count + 1) > ((Py_ssize_t)(((size_t)-1
)>>1)) / sizeof(char *)) ? ((void*)0) : ( (char * *) PyMem_Malloc
((element_count + 1) * sizeof(char *)) ) );

  if (*rrdtool_argv == NULL((void*)0))
      return -1;

  for (i = 0; i < args_count; i++) {
      o = PyTuple_GET_ITEM(args, i)((((void) (0)), (PyTupleObject *)(args))->ob_item[i]);

      if (PyRRD_String_Check(o)((((((PyObject*)(o))->ob_type))->tp_flags & ((1UL <<
 28))) != 0))
          (*rrdtool_argv)[++argv_count] = (char *)PyRRD_String_AS_STRING(o)PyUnicode_AsUTF8(o);
      else if (PyList_CheckExact(o)((((PyObject*)(o))->ob_type) == &PyList_Type)) {
          for (j = 0; j < PyList_Size(o); j++) {
              lo = PyList_GetItem(o, j);

              if (PyRRD_String_Check(lo)((((((PyObject*)(lo))->ob_type))->tp_flags & ((1UL <<
 28))) != 0))
                  (*rrdtool_argv)[++argv_count] = (char *)PyRRD_String_AS_STRING(lo)PyUnicode_AsUTF8(lo);
              else {
                  PyMem_DelPyMem_Free(*rrdtool_argv);
                  PyErr_Format(PyExc_TypeError,
                    "Element %d in argument %d must be str", j, i);
                  return -1;
              }
          }
      } else {
          PyMem_DelPyMem_Free(*rrdtool_argv);
          PyErr_Format(rrdtool_ProgrammingError,
            "Argument %d must be str or list of str", i);
          return -1;
      }
  }

  (*rrdtool_argv)[0] = command;
  *rrdtool_argc = element_count + 1;

  return 0;
186}

188/**
* Destroy argument vector.
*/
191static void
192destroy_args(char ***rrdtool_argv)
193{
  PyMem_DelPyMem_Free(*rrdtool_argv);
  *rrdtool_argv = NULL((void*)0);
196}

198/**
* Convert RRDtool info to dict.
*
* @param data RRDtool info object
* @return Python dict object
*/
204static PyObject *
205_rrdtool_util_info2dict(const rrd_info_t *data)
206{
  PyObject *dict, *val;

  dict = PyDict_New();

  while (data) {
      val = NULL((void*)0);

      switch (data->type) {
          case RD_I_VAL:
              if (isnan(data->value.u_val)__builtin_isnan (data->value.u_val)) {
                  Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
                  val = Py_None(&_Py_NoneStruct);
              } else
                  val = PyFloat_FromDouble(data->value.u_val);
              break;

          case RD_I_CNT:
              val = PyLong_FromUnsignedLong(data->value.u_cnt);
              break;

          case RD_I_INT:
              val = PyLong_FromLong(data->value.u_int);
              break;

          case RD_I_STR:
              val = PyRRD_String_FromString(data->value.u_str)PyUnicode_FromString(data->value.u_str);
              break;

          case RD_I_BLO:
              val = PyRRD_String_FromStringAndSize(PyBytes_FromStringAndSize((char *)data->value.u_blo.ptr, data
->value.u_blo.size)
                  (char *)data->value.u_blo.ptr,PyBytes_FromStringAndSize((char *)data->value.u_blo.ptr, data
->value.u_blo.size)
                  data->value.u_blo.size)PyBytes_FromStringAndSize((char *)data->value.u_blo.ptr, data
->value.u_blo.size);
              break;
          default:
              break;
      }

      if (val != NULL((void*)0)) {
          PyDict_SetItemString(dict, data->key, val);
          Py_DECREF(val)_Py_DECREF(((PyObject*)(val)));
      }

      data = data->next;
  }

  return dict;
253}

255static char _rrdtool_create__doc__[] = "Create a new Round Robin Database.\n\n\
Usage: create(args...)\n\
Arguments:\n\n\
  filename\n\
  [-b|--start start time]\n\
  [-s|--step step]\n\
  [-t|--template template-file]\n\
  [-r|--source source-file]\n\
  [-O|--no-overwrite]\n\
  [-d|--daemon address]\n\
  [DS:ds-name[=mapped-ds-name[source-index]]:DST:heartbeat:min:max]\n\
  [RRA:CF:xff:steps:rows]\n\n\
Full documentation can be found at:\n\
https://oss.oetiker.ch/rrdtool/doc/rrdcreate.en.html";

270static PyObject *
271_rrdtool_create(PyObject *Py_UNUSED(self)_unused_self __attribute__((unused)), PyObject *args)
272{
  char **rrdtool_argv = NULL((void*)0);
  int    rrdtool_argc = 0;
  PyObject *ret;
  int status;

  if (convert_args("create", args, &rrdtool_argv, &rrdtool_argc) == -1)
      return NULL((void*)0);

  Py_BEGIN_ALLOW_THREADS{ PyThreadState *_save; _save = PyEval_SaveThread();
  status = rrd_create(rrdtool_argc, rrdtool_argv);
  Py_END_ALLOW_THREADSPyEval_RestoreThread(_save); }

  if (status == -1) {
      PyErr_SetString(rrdtool_OperationalError, rrd_get_error());
      rrd_clear_error();
      ret = NULL((void*)0);
  } else {
      Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
      ret = Py_None(&_Py_NoneStruct);
  }

  destroy_args(&rrdtool_argv);
  return ret;
296}

298static char _rrdtool_dump__doc__[] = "Dump an RRD to XML.\n\n\
Usage: dump(args..)\n\
Arguments:\n\n\
  [-h|--header {none,xsd,dtd}\n\
  [-n|--no-header]\n\
  [-d|--daemon address]\n\
  file.rrd\n\
  [file.xml]\n\n\
Full documentation can be found at:\n\
https://oss.oetiker.ch/rrdtool/doc/rrddump.en.html";

309static PyObject *
310_rrdtool_dump(PyObject *Py_UNUSED(self)_unused_self __attribute__((unused)), PyObject *args)
311{
  char **rrdtool_argv = NULL((void*)0);
  int    rrdtool_argc = 0;
  PyObject *ret;
  int status;

  if (convert_args("dump", args, &rrdtool_argv, &rrdtool_argc) == -1)
      return NULL((void*)0);

  Py_BEGIN_ALLOW_THREADS{ PyThreadState *_save; _save = PyEval_SaveThread();
  status = rrd_dump(rrdtool_argc, rrdtool_argv);
  Py_END_ALLOW_THREADSPyEval_RestoreThread(_save); }

  if (status != 0) {
      PyErr_SetString(rrdtool_OperationalError, rrd_get_error());
      rrd_clear_error();
      ret = NULL((void*)0);
  } else {
      Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
      ret = Py_None(&_Py_NoneStruct);
  }

  destroy_args(&rrdtool_argv);
  return ret;
335}

337static char _rrdtool_update__doc__[] = "Store a new set of values into\
the RRD.\n\n\
Usage: update(args..)\n\
Arguments:\n\n\
 filename\n\
 [--template|-t ds-name[:ds-name]...]\n\
 N|timestamp:value[:value...]\n\
 [timestamp:value[:value...] ...]\n\n\
Full documentation can be found at:\n\
https://oss.oetiker.ch/rrdtool/doc/rrdupdate.en.html";

348static PyObject *
349_rrdtool_update(PyObject *Py_UNUSED(self)_unused_self __attribute__((unused)), PyObject *args)
350{
  char **rrdtool_argv = NULL((void*)0);
  int    rrdtool_argc = 0;
  PyObject *ret;
  int status;

  if (convert_args("update", args, &rrdtool_argv, &rrdtool_argc) == -1)
      return NULL((void*)0);

  Py_BEGIN_ALLOW_THREADS{ PyThreadState *_save; _save = PyEval_SaveThread();
  status = rrd_update(rrdtool_argc, rrdtool_argv);
  Py_END_ALLOW_THREADSPyEval_RestoreThread(_save); }

  if (status == -1) {
      PyErr_SetString(rrdtool_OperationalError, rrd_get_error());
      rrd_clear_error();
      ret = NULL((void*)0);
  } else {
      Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
      ret = Py_None(&_Py_NoneStruct);
  }

  destroy_args(&rrdtool_argv);
  return ret;
374}

376static char _rrdtool_updatev__doc__[] = "Store a new set of values into "\
"the Round Robin Database and return an info dictionary.\n\n\
This function works in the same manner as 'update', but will return an\n\
info dictionary instead of None.";

381static PyObject *
382_rrdtool_updatev(PyObject *Py_UNUSED(self)_unused_self __attribute__((unused)), PyObject *args)
383{
  char **rrdtool_argv = NULL((void*)0);
  int    rrdtool_argc = 0;
  PyObject *ret;
  rrd_info_t *data;

  if (convert_args("updatev", args, &rrdtool_argv, &rrdtool_argc) == -1)
      return NULL((void*)0);

  Py_BEGIN_ALLOW_THREADS{ PyThreadState *_save; _save = PyEval_SaveThread();
  data = rrd_update_v(rrdtool_argc, rrdtool_argv);
  Py_END_ALLOW_THREADSPyEval_RestoreThread(_save); }

  if (data == NULL((void*)0)) {
      PyErr_SetString(rrdtool_OperationalError, rrd_get_error());
      rrd_clear_error();
      ret = NULL((void*)0);
  } else {
      ret = _rrdtool_util_info2dict(data);
      rrd_info_free(data);
  }

  destroy_args(&rrdtool_argv);
  return ret;
407}

409static char _rrdtool_fetch__doc__[] = "Fetch data from an RRD.\n\n\
Usage: fetch(args..)\n\
Arguments:\n\n\
  filename\n\
  CF\n\
  [-r|--resolution resolution]\n\
  [-s|--start start]\n\
  [-e|--end end]\n\
  [-a|--align-start]\n\
  [-d|--daemon address]\n\n\
Full documentation can be found at:\n\
https://oss.oetiker.ch/rrdtool/doc/rrdfetch.en.html";

422static PyObject *
423_rrdtool_fetch(PyObject *Py_UNUSED(self)_unused_self __attribute__((unused)), PyObject *args)
424{
  char **rrdtool_argv = NULL((void*)0);
  int    rrdtool_argc = 0;
  PyObject *ret, *range_tup, *dsnam_tup, *data_list, *t;
  rrd_value_t *data, *datai, dv;
  unsigned long step, ds_cnt, i, j, row;
  time_t start, end;
  char **ds_namv;
  int status;

  if (convert_args("fetch", args, &rrdtool_argv, &rrdtool_argc) == -1)
1
Assuming the condition is false→
2
←
Taking false branch→
      return NULL((void*)0);

  Py_BEGIN_ALLOW_THREADS{ PyThreadState *_save; _save = PyEval_SaveThread();
  status = rrd_fetch(rrdtool_argc, rrdtool_argv, &start, &end, &step,
                     &ds_cnt, &ds_namv, &data);
  Py_END_ALLOW_THREADSPyEval_RestoreThread(_save); }

  if (status == -1) {
3
←
Assuming the condition is false→
4
←
Taking false branch→
      PyErr_SetString(rrdtool_OperationalError, rrd_get_error());
      rrd_clear_error();
      ret = NULL((void*)0);
  } else {
      row = (end - start) / step;
      ret = PyTuple_New(3);
      range_tup = PyTuple_New(3);
5
←
Calling 'PyTuple_New'→
7
←
Returning from 'PyTuple_New'→
      dsnam_tup = PyTuple_New(ds_cnt);
      data_list = PyList_New(row);

      PyTuple_SET_ITEM(ret, 0, range_tup)PyTuple_SetItem(ret, 0, range_tup);
8
←
Calling 'PyTuple_SetItem'→
10
←
Returning from 'PyTuple_SetItem'→
      PyTuple_SET_ITEM(ret, 1, dsnam_tup)PyTuple_SetItem(ret, 1, dsnam_tup);
      PyTuple_SET_ITEM(ret, 2, data_list)PyTuple_SetItem(ret, 2, data_list);

      datai = data;

      PyTuple_SET_ITEM(range_tup, 0, PyRRD_Int_FromLong((long) start))PyTuple_SetItem(range_tup, 0, PyLong_FromLong((long) start));
11
←
Calling function 'PyTuple_SetItem' with a PyObject argument whose ownership has been released (with stolen reference)
      PyTuple_SET_ITEM(range_tup, 1, PyRRD_Int_FromLong((long) end))PyTuple_SetItem(range_tup, 1, PyLong_FromLong((long) end));
      PyTuple_SET_ITEM(range_tup, 2, PyRRD_Int_FromLong((long) step))PyTuple_SetItem(range_tup, 2, PyLong_FromLong((long) step));

      for (i = 0; i < ds_cnt; i++)
          PyTuple_SET_ITEM(dsnam_tup, i, PyRRD_String_FromString(ds_namv[i]))PyTuple_SetItem(dsnam_tup, i, PyUnicode_FromString(ds_namv[i]
));

      for (i = 0; i < row; i++) {
          t = PyTuple_New(ds_cnt);
          PyList_SET_ITEM(data_list, i, t)PyList_SetItem(data_list, i, t);

          for (j = 0; j < ds_cnt; j++) {
              dv = *(datai++);
              if (isnan(dv)__builtin_isnan (dv)) {
                  PyTuple_SET_ITEM(t, j, Py_None)PyTuple_SetItem(t, j, (&_Py_NoneStruct));
                  Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
              } else
                  PyTuple_SET_ITEM(t, j, PyFloat_FromDouble((double) dv))PyTuple_SetItem(t, j, PyFloat_FromDouble((double) dv));
          }
      }

      for (i = 0; i < ds_cnt; i++)
          rrd_freemem(ds_namv[i]);

      rrd_freemem(ds_namv);
      rrd_freemem(data);
  }

  destroy_args(&rrdtool_argv);
  return ret;
489}

491static char _rrdtool_flushcached__doc__[] = "Flush RRD files from memory.\n\n\
Usage: flushcached(args..)\n\
Arguments:\n\n\
  [-d|--daemon address]\n\
  filename\n\
  [filename ...]\n\n\
Full documentation can be found at:\n\
https://oss.oetiker.ch/rrdtool/doc/rrdflushcached.en.html";

500static PyObject *
501_rrdtool_flushcached(PyObject *Py_UNUSED(self)_unused_self __attribute__((unused)), PyObject *args)
502{
  char **rrdtool_argv = NULL((void*)0);
  int    rrdtool_argc = 0;
  PyObject *ret;
  int status;

  if (convert_args("flushcached", args, &rrdtool_argv, &rrdtool_argc) == -1)
      return NULL((void*)0);

  Py_BEGIN_ALLOW_THREADS{ PyThreadState *_save; _save = PyEval_SaveThread();
  status = rrd_flushcached(rrdtool_argc, rrdtool_argv);
  Py_END_ALLOW_THREADSPyEval_RestoreThread(_save); }

  if (status != 0) {
      PyErr_SetString(rrdtool_OperationalError, rrd_get_error());
      rrd_clear_error();
      ret = NULL((void*)0);
  } else {
      Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
      ret = Py_None(&_Py_NoneStruct);
  }

  destroy_args(&rrdtool_argv);
  return ret;
526}

528static char _rrdtool_graph__doc__[] = "Create a graph based on one or more " \
"RRDs.\n\n\
Usage: graph(args..)\n\
Arguments:\n\n\
  filename | -\n\
  [-s|--start start]\n\
  [-e|--end end]\n\
  [-S|--step step]\n\
  [-t|--title string]\n\
  [-v|--vertical-label string]\n\
  [-w|--width pixels]\n\
  [-h|--height pixels]\n\
  [-j|--only-graph]\n\
  [-D|--full-size-mode]\n\
  [-u|--upper-limit value]\n\
  [-l|--lower-limit value]\n\
  [-r|--rigid]\n\
  [-A|--alt-autoscale]\n\
  [-J|--alt-autoscale-min]\n\
  [-M|--alt-autoscale-max]\n\
  [-N|--no-gridfit]\n\
  [-x|--x-grid (GTM:GST:MTM:MST:LTM:LST:LPR:LFM|none)]\n\
  [-y|--y-grid (grid step:label factor|none)]\n\
  [--week-fmt strftime format string]\n\
  [--left-axis-formatter formatter-name]\n\
  [--left-axis-format format-string]\n\
  [-Y|--alt-y-grid]\n\
  [-o|--logarithmic]\n\
  [-X|--units-exponent value]\n\
  [-L|--units-length value]\n\
  [--units=si]\n\
  [--right-axis scale:shift]\n\
  [--right-axis-label label]\n\
  [--right-axis-format format-string]\n\
  [-g|--no-legend]\n\
  [-F|--force-rules-legend]\n\
  [--legend-position=(north|south|west|east)]\n\
  [--legend-direction=(topdown|bottomup)]\n\
  [-z|--lazy]\n\
  [-d|--daemon address]\n\
  [-f|--imginfo printfstr]\n\
  [-c|--color COLORTAG#rrggbb[aa]]\n\
  [--grid-dash on:off]\n\
  [--border width]\n\
  [--dynamic-labels]\n\
  [-m|--zoom factor]\n\
  [-n|--font FONTTAG:size:[font]]\n\
  [-R|--font-render-mode {normal,light,mono}]\n\
  [-B|--font-smoothing-threshold size]\n\
  [-P|--pango-markup]\n\
  [-G|--graph-render-mode {normal,mono}]\n\
  [-E|--slope-mode]\n\
  [-a|--imgformat {PNG,SVG,EPS,PDF,XML,XMLENUM,JSON,JSONTIME,CSV,TSV,SSV}]\n\
  [-i|--interlaced]\n\
  [-T|--tabwidth value]\n\
  [-b|--base value]\n\
  [-W|--watermark string]\n\
  [-Z|--use-nan-for-all-missing-data]\n\
  DEF:vname=rrdfile:ds-name:CF[:step=step][:start=time][:end=time]\n\
  CDEF:vname=RPN expression\n\
  VDEF=vname:RPN expression\n\n\
Full documentation can be found at:\n\
https://oss.oetiker.ch/rrdtool/doc/rrdgraph.en.html";

592static PyObject *
593_rrdtool_graph(PyObject *Py_UNUSED(self)_unused_self __attribute__((unused)), PyObject *args)
594{
  char **rrdtool_argv = NULL((void*)0);
  int    rrdtool_argc = 0;
  PyObject *ret;
  int xsize, ysize, i, status;
  double ymin, ymax;
  char **calcpr = NULL((void*)0);

  if (convert_args("graph", args, &rrdtool_argv, &rrdtool_argc) == -1)
      return NULL((void*)0);

  Py_BEGIN_ALLOW_THREADS{ PyThreadState *_save; _save = PyEval_SaveThread();
  status = rrd_graph(rrdtool_argc, rrdtool_argv, &calcpr, &xsize, &ysize,
                     NULL((void*)0), &ymin, &ymax);
  Py_END_ALLOW_THREADSPyEval_RestoreThread(_save); }

  if (status == -1) {
      PyErr_SetString(rrdtool_OperationalError, rrd_get_error());
      rrd_clear_error();
      ret = NULL((void*)0);
  } else {
      ret = PyTuple_New(3);

      PyTuple_SET_ITEM(ret, 0, PyRRD_Int_FromLong((long) xsize))PyTuple_SetItem(ret, 0, PyLong_FromLong((long) xsize));
      PyTuple_SET_ITEM(ret, 1, PyRRD_Int_FromLong((long) ysize))PyTuple_SetItem(ret, 1, PyLong_FromLong((long) ysize));

      if (calcpr) {
          PyObject *e, *t;

          e = PyList_New(0);
          PyTuple_SET_ITEM(ret, 2, e)PyTuple_SetItem(ret, 2, e);

          for (i = 0; calcpr[i]; i++) {
              t = PyRRD_String_FromString(calcpr[i])PyUnicode_FromString(calcpr[i]);
              PyList_Append(e, t);
              Py_DECREF(t)_Py_DECREF(((PyObject*)(t)));
              rrd_freemem(calcpr[i]);
          }
      } else {
          Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
          PyTuple_SET_ITEM(ret, 2, Py_None)PyTuple_SetItem(ret, 2, (&_Py_NoneStruct));
      }
  }

  destroy_args(&rrdtool_argv);
  return ret;
640}

642static char _rrdtool_graphv__doc__[] = "Create a graph based on one or more " \
"RRDs and return data in RRDtool info format.\n\n\
This function works the same way as 'graph', but will return a info\n\
dictionary instead of None.\n\n\
Full documentation can be found at (graphv section):\n\
https://oss.oetiker.ch/rrdtool/doc/rrdgraph.en.html";

649static PyObject *
650_rrdtool_graphv(PyObject *Py_UNUSED(self)_unused_self __attribute__((unused)), PyObject *args)
651{
  char **rrdtool_argv = NULL((void*)0);
  int    rrdtool_argc = 0;
  PyObject *ret;
  rrd_info_t *data;

  if (convert_args("graphv", args, &rrdtool_argv, &rrdtool_argc) == -1)
      return NULL((void*)0);

  Py_BEGIN_ALLOW_THREADS{ PyThreadState *_save; _save = PyEval_SaveThread();
  data = rrd_graph_v(rrdtool_argc, rrdtool_argv);
  Py_END_ALLOW_THREADSPyEval_RestoreThread(_save); }

  if (data == NULL((void*)0)) {
      PyErr_SetString(rrdtool_OperationalError, rrd_get_error());
      rrd_clear_error();
      ret = NULL((void*)0);
  } else {
      ret = _rrdtool_util_info2dict(data);
      rrd_info_free(data);
  }

  destroy_args(&rrdtool_argv);
  return ret;
675}

677static char _rrdtool_xport__doc__[] = "Dictionary representation of data " \
"stored in RRDs.\n\n\
Usage: xport(args..)\n\
Arguments:\n\n\
  [-s[--start seconds]\n\
  [-e|--end seconds]\n\
  [-m|--maxrows rows]\n\
  [--step value]\n\
  [--json]\n\
  [--enumds]\n\
  [--daemon address]\n\
  [DEF:vname=rrd:ds-name:CF]\n\
  [CDEF:vname=rpn-expression]\n\
  [XPORT:vname[:legend]]\n\n\
Full documentation can be found at:\n\
https://oss.oetiker.ch/rrdtool/doc/rrdxport.en.html";

694static PyObject *
695_rrdtool_xport(PyObject *Py_UNUSED(self)_unused_self __attribute__((unused)), PyObject *args)
696{
  char **rrdtool_argv = NULL((void*)0);
  int    rrdtool_argc = 0;
  PyObject *ret;
  int xsize, status;
  char **legend_v;
  time_t start, end;
  unsigned long step, col_cnt;
  rrd_value_t *data, *datai;

  if (convert_args("xport", args, &rrdtool_argv, &rrdtool_argc) == -1)
      return NULL((void*)0);

  Py_BEGIN_ALLOW_THREADS{ PyThreadState *_save; _save = PyEval_SaveThread();
  status = rrd_xport(rrdtool_argc, rrdtool_argv, &xsize, &start, &end, &step,
                     &col_cnt, &legend_v, &data);
  Py_END_ALLOW_THREADSPyEval_RestoreThread(_save); }

  if (status == -1) {
      PyErr_SetString(rrdtool_OperationalError, rrd_get_error());
      rrd_clear_error();
      ret = NULL((void*)0);
  } else {
      PyObject *meta_dict, *data_list, *legend_list, *t;
      rrd_value_t dv;
      unsigned long i, j, row_cnt = (end - start) / step;

      ret = PyDict_New();
      meta_dict = PyDict_New();
      legend_list = PyList_New(col_cnt);
      data_list = PyList_New(row_cnt);

      PyDict_SetItem(ret, PyRRD_String_FromString("meta")PyUnicode_FromString("meta"), meta_dict);
      PyDict_SetItem(ret, PyRRD_String_FromString("data")PyUnicode_FromString("data"), data_list);

      datai = data;

      PyDict_SetItem(meta_dict,
          PyRRD_String_FromString("start")PyUnicode_FromString("start"),
          PyRRD_Int_FromLong((long) start)PyLong_FromLong((long) start));
      PyDict_SetItem(meta_dict,
          PyRRD_String_FromString("end")PyUnicode_FromString("end"),
          PyRRD_Int_FromLong((long) end)PyLong_FromLong((long) end));
      PyDict_SetItem(meta_dict,
          PyRRD_String_FromString("step")PyUnicode_FromString("step"),
          PyRRD_Int_FromLong((long) step)PyLong_FromLong((long) step));
      PyDict_SetItem(meta_dict,
          PyRRD_String_FromString("rows")PyUnicode_FromString("rows"),
          PyRRD_Int_FromLong((long) row_cnt)PyLong_FromLong((long) row_cnt));
      PyDict_SetItem(meta_dict,
          PyRRD_String_FromString("columns")PyUnicode_FromString("columns"),
          PyRRD_Int_FromLong((long) col_cnt)PyLong_FromLong((long) col_cnt));
      PyDict_SetItem(meta_dict,
          PyRRD_String_FromString("legend")PyUnicode_FromString("legend"),
          legend_list);

      for (i = 0; i < col_cnt; i++)
          PyList_SET_ITEM(legend_list, i, PyRRD_String_FromString(legend_v[i]))PyList_SetItem(legend_list, i, PyUnicode_FromString(legend_v[
i]));

      for (i = 0; i < row_cnt; i++) {
          t = PyTuple_New(col_cnt);
          PyList_SET_ITEM(data_list, i, t)PyList_SetItem(data_list, i, t);

          for (j = 0; j < col_cnt; j++) {
              dv = *(datai++);

              if (isnan(dv)__builtin_isnan (dv)) {
                  PyTuple_SET_ITEM(t, j, Py_None)PyTuple_SetItem(t, j, (&_Py_NoneStruct));
                  Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
              } else {
                  PyTuple_SET_ITEM(t, j, PyFloat_FromDouble((double) dv))PyTuple_SetItem(t, j, PyFloat_FromDouble((double) dv));
              }
          }
      }

      for (i = 0; i < col_cnt; i++)
          rrd_freemem(legend_v[i]);

      rrd_freemem(legend_v);
      rrd_freemem(data);
  }

  destroy_args(&rrdtool_argv);

  return ret;
781}

783static char _rrdtool_tune__doc__[] = "Modify some basic properties of a " \
"Round Robin Database.\n\n\
Usage: tune(args..)\n\
Arguments:\n\n\
  filename\n\
  [-h|--heartbeat ds-name:heartbeat]\n\
  [-i|--minimum ds-name:min]\n\
  [-a|--maximum ds-name:max]\n\
  [-d|--data-source-type ds-name:DST]\n\
  [-r|--data-source-rename old-name:new-name]\n\n\
Full documentation can be found at:\n\
https://oss.oetiker.ch/rrdtool/doc/rrdtune.en.html";

796static PyObject *
797_rrdtool_tune(PyObject *Py_UNUSED(self)_unused_self __attribute__((unused)), PyObject *args)
798{
  char **rrdtool_argv = NULL((void*)0);
  int    rrdtool_argc = 0;
  PyObject *ret;
  int status;

  if (convert_args("tune", args, &rrdtool_argv, &rrdtool_argc) == -1)
      return NULL((void*)0);

  Py_BEGIN_ALLOW_THREADS{ PyThreadState *_save; _save = PyEval_SaveThread();
  status = rrd_tune(rrdtool_argc, rrdtool_argv);
  Py_END_ALLOW_THREADSPyEval_RestoreThread(_save); }

  if (status == -1) {
      PyErr_SetString(rrdtool_OperationalError, rrd_get_error());
      rrd_clear_error();
      ret = NULL((void*)0);
  } else {
      Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
      ret = Py_None(&_Py_NoneStruct);
  }

  destroy_args(&rrdtool_argv);
  return ret;
822}

824static char _rrdtool_first__doc__[] = "Get the first UNIX timestamp of the "\
"first data sample in an Round Robin Database.\n\n\
Usage: first(args..)\n\
Arguments:\n\n\
  filename\n\
  [--rraindex number]\n\
  [-d|--daemon address]\n\n\
Full documentation can be found at:\n\
https://oss.oetiker.ch/rrdtool/doc/rrdfirst.en.html";

834static PyObject *
835_rrdtool_first(PyObject *Py_UNUSED(self)_unused_self __attribute__((unused)), PyObject *args)
836{
  char **rrdtool_argv = NULL((void*)0);
  int    rrdtool_argc = 0;
  PyObject *ret;
  int ts;

  if (convert_args("first", args, &rrdtool_argv, &rrdtool_argc) == -1)
      return NULL((void*)0);

  Py_BEGIN_ALLOW_THREADS{ PyThreadState *_save; _save = PyEval_SaveThread();
  ts = rrd_first(rrdtool_argc, rrdtool_argv);
  Py_END_ALLOW_THREADSPyEval_RestoreThread(_save); }

  if (ts == -1) {
      PyErr_SetString(rrdtool_OperationalError, rrd_get_error());
      rrd_clear_error();
      ret = NULL((void*)0);
  } else
      ret = PyRRD_Int_FromLong((long) ts)PyLong_FromLong((long) ts);

  destroy_args(&rrdtool_argv);
  return ret;
858}

860static char _rrdtool_last__doc__[] = "Get the UNIX timestamp of the most "\
"recent data sample in an Round Robin Database.\n\n\
Usage: last(args..)\n\
Arguments:\n\n\
  filename\n\
  [-d|--daemon address]\n\n\
Full documentation can be found at:\n\
https://oss.oetiker.ch/rrdtool/doc/rrdlast.en.html";

869static PyObject *
870_rrdtool_last(PyObject *Py_UNUSED(self)_unused_self __attribute__((unused)), PyObject *args)
871{
  char **rrdtool_argv = NULL((void*)0);
  int    rrdtool_argc = 0;
  PyObject *ret;
  int ts;

  if (convert_args("last", args, &rrdtool_argv, &rrdtool_argc) == -1)
      return NULL((void*)0);

  Py_BEGIN_ALLOW_THREADS{ PyThreadState *_save; _save = PyEval_SaveThread();
  ts = rrd_last(rrdtool_argc, rrdtool_argv);
  Py_END_ALLOW_THREADSPyEval_RestoreThread(_save); }

  if (ts == -1) {
      PyErr_SetString(rrdtool_OperationalError, rrd_get_error());
      rrd_clear_error();
      ret = NULL((void*)0);
  } else
      ret = PyRRD_Int_FromLong((long) ts)PyLong_FromLong((long) ts);

  destroy_args(&rrdtool_argv);
  return ret;
893}

895static char _rrdtool_resize__doc__[] = "Modify the number of rows in a "\
"Round Robin Database.\n\n\
Usage: resize(args..)\n\
Arguments:\n\n\
  filename\n\
  rra-num\n\
  GROW|SHRINK\n\
  rows\n\n\
Full documentation can be found at:\n\
https://oss.oetiker.ch/rrdtool/doc/rrdlast.en.html";

906static PyObject *
907_rrdtool_resize(PyObject *Py_UNUSED(self)_unused_self __attribute__((unused)), PyObject *args)
908{
  char **rrdtool_argv = NULL((void*)0);
  int    rrdtool_argc = 0;
  PyObject *ret;
  int status;

  if (convert_args("resize", args, &rrdtool_argv, &rrdtool_argc) == -1)
      return NULL((void*)0);

  Py_BEGIN_ALLOW_THREADS{ PyThreadState *_save; _save = PyEval_SaveThread();
  status = rrd_resize(rrdtool_argc, rrdtool_argv);
  Py_END_ALLOW_THREADSPyEval_RestoreThread(_save); }

  if (status == -1) {
      PyErr_SetString(rrdtool_OperationalError, rrd_get_error());
      rrd_clear_error();
      ret = NULL((void*)0);
  } else {
      Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
      ret = Py_None(&_Py_NoneStruct);
  }

  destroy_args(&rrdtool_argv);
  return ret;
932}

934static char _rrdtool_info__doc__[] = "Extract header information from an "\
"Round Robin Database.\n\n\
Usage: info(filename, ...)\n\
Arguments:\n\n\
  filename\n\
  [-d|--daemon address]\n\
  [-F|--noflush]\n\n\
Full documentation can be found at:\n\
https://oss.oetiker.ch/rrdtool/doc/rrdinfo.en.html";

944static PyObject *
945_rrdtool_info(PyObject *Py_UNUSED(self)_unused_self __attribute__((unused)), PyObject *args)
946{
  char **rrdtool_argv = NULL((void*)0);
  int    rrdtool_argc = 0;
  PyObject *ret;
  rrd_info_t *data;

  if (convert_args("info", args, &rrdtool_argv, &rrdtool_argc) == -1)
      return NULL((void*)0);

  Py_BEGIN_ALLOW_THREADS{ PyThreadState *_save; _save = PyEval_SaveThread();
  data = rrd_info(rrdtool_argc, rrdtool_argv);
  Py_END_ALLOW_THREADSPyEval_RestoreThread(_save); }

  if (data == NULL((void*)0)) {
      PyErr_SetString(rrdtool_OperationalError, rrd_get_error());
      rrd_clear_error();
      ret = NULL((void*)0);
  } else {
      ret = _rrdtool_util_info2dict(data);
      rrd_info_free(data);
  }

  destroy_args(&rrdtool_argv);
  return ret;
970}

972static char _rrdtool_lastupdate__doc__[] = "Returns datetime and value stored "\
"for each datum in the most recent update of an RRD.\n\n\
Usage: lastupdate(filename, ...)\n\
Arguments:\n\n\
  filename\n\
  [-d|--daemon address]\n\n\
Full documentation can be found at:\n\
https://oss.oetiker.ch/rrdtool/doc/rrdlastupdate.en.html";

981static PyObject *
982_rrdtool_lastupdate(PyObject *Py_UNUSED(self)_unused_self __attribute__((unused)), PyObject *args)
983{
  char **rrdtool_argv = NULL((void*)0);
  int    rrdtool_argc = 0;
  PyObject *ret, *ds_dict, *lastupd;
  int status;
  time_t last_update;
  char **ds_names, **last_ds;
  unsigned long ds_cnt, i;

  if (convert_args("lastupdate", args, &rrdtool_argv, &rrdtool_argc) == -1)
      return NULL((void*)0);
  else if (rrdtool_argc < 2) {
      PyErr_SetString(rrdtool_ProgrammingError, "Missing filename argument");
      return NULL((void*)0);
  }

  Py_BEGIN_ALLOW_THREADS{ PyThreadState *_save; _save = PyEval_SaveThread();
  status = rrd_lastupdate_r(rrdtool_argv[1],
                            &last_update,
                            &ds_cnt,
                            &ds_names,
                            &last_ds);
  Py_END_ALLOW_THREADSPyEval_RestoreThread(_save); }

  if (status != 0) {
      PyErr_SetString(rrdtool_OperationalError, rrd_get_error());
      rrd_clear_error();
      ret = NULL((void*)0);
  } else {
      /* convert last_update to Python datetime object */
      ret = PyDict_New();
      ds_dict = PyDict_New();
      lastupd = PyRRD_DateTime_FromTS(last_update);

      PyDict_SetItemString(ret, "date", lastupd);
      PyDict_SetItemString(ret, "ds", ds_dict);

      Py_DECREF(lastupd)_Py_DECREF(((PyObject*)(lastupd)));
      Py_DECREF(ds_dict)_Py_DECREF(((PyObject*)(ds_dict)));

      for (i = 0; i < ds_cnt; i++) {
          PyObject* val = Py_None(&_Py_NoneStruct);

          double num;
          if (sscanf(last_ds[i], "%lf", &num) == 1) {
              val = PyFloat_FromDouble(num);
          }

          if (!val)
              return NULL((void*)0);

          PyDict_SetItemString(ds_dict, ds_names[i], val);

          if (val != Py_None(&_Py_NoneStruct))
              Py_DECREF(val)_Py_DECREF(((PyObject*)(val)));

          free(last_ds[i]);
          free(ds_names[i]);
      }

      free(last_ds);
      free(ds_names);

  }

  destroy_args(&rrdtool_argv);

  return ret;
1051}

1053#ifdef WITH_FETCH_CB1

1055/** A Python object which will hold a callable for fetch callbacks */
1056static PyObject *_rrdtool_fetch_callable = NULL((void*)0);

1058static int
1059_rrdtool_fetch_cb_wrapper(
  const char *filename,
  enum cf_en cf_idx,
  time_t *start,
  time_t *end,
  unsigned long *step,
  unsigned long *ds_cnt,
  char ***ds_namv,
  rrd_value_t **data)
1068{
  PyObject *args;
  PyObject *kwargs;
  PyObject *ret = NULL((void*)0);
  PyObject *tmp;
  PyObject *tmp_min_ts;
  PyGILState_STATE gstate;
  Py_ssize_t rowcount = 0;
  int rc = -1;
  unsigned int i, ii;

  gstate = PyGILState_Ensure();

  if (_rrdtool_fetch_callable == NULL((void*)0)) {
      rrd_set_error("use rrdtool.register_fetch_cb to register a fetch callback");
      goto gil_release_err;
  }

  args = PyTuple_New(0);
  kwargs = PyDict_New();

  /* minimum possible UNIX datetime */
  tmp_min_ts = PyLong_FromLong(0);

  PyObject *po_filename = PyRRD_String_FromString(filename)PyUnicode_FromString(filename);
  PyDict_SetItemString(kwargs, "filename", po_filename);
  Py_DECREF(po_filename)_Py_DECREF(((PyObject*)(po_filename)));

  PyObject *po_cfstr = PyRRD_String_FromString(PyRRD_String_FromCF(cf_idx))PyUnicode_FromString(PyRRD_String_FromCF(cf_idx));
  PyDict_SetItemString(kwargs, "cf", po_cfstr);
  Py_DECREF(po_cfstr)_Py_DECREF(((PyObject*)(po_cfstr)));

  PyObject *po_start = PyLong_FromLong(*start);
  PyDict_SetItemString(kwargs, "start", po_start);
  Py_DECREF(po_start)_Py_DECREF(((PyObject*)(po_start)));

  PyObject *po_end = PyLong_FromLong(*end);
  PyDict_SetItemString(kwargs, "end", po_end);
  Py_DECREF(po_end)_Py_DECREF(((PyObject*)(po_end)));

  PyObject *po_step = PyLong_FromUnsignedLong(*step);
  PyDict_SetItemString(kwargs, "step", po_step);
  Py_DECREF(po_step)_Py_DECREF(((PyObject*)(po_step)));

  /* execute Python callback method */
  ret = PyObject_Call(_rrdtool_fetch_callable, args, kwargs);
  Py_DECREF(args)_Py_DECREF(((PyObject*)(args)));
  Py_DECREF(kwargs)_Py_DECREF(((PyObject*)(kwargs)));

  if (ret == NULL((void*)0)) {
      rrd_set_error("calling python callback failed");
      goto gil_release_err;
  }

  /* handle return value of callback */
  if (!PyDict_Check(ret)((((((PyObject*)(ret))->ob_type))->tp_flags & ((1UL
 << 29))) != 0)) {
      rrd_set_error("expected callback method to be a dict");
      goto gil_release_err;
  }

  tmp = PyDict_GetItemString(ret, "step");
  if (tmp == NULL((void*)0)) {
      rrd_set_error("expected 'step' key in callback return value");
      goto gil_release_err;
  } else if (!PyRRD_Long_Check(tmp)((((((PyObject*)(tmp))->ob_type))->tp_flags & ((1UL
 << 24))) != 0)) {
      rrd_set_error("the 'step' key in callback return value must be int");
      goto gil_release_err;
  } else
      *step = PyLong_AsLong(tmp);

  tmp = PyDict_GetItemString(ret, "start");
  if (tmp == NULL((void*)0)) {
      rrd_set_error("expected 'start' key in callback return value");
      goto gil_release_err;
  } else if (!PyRRD_Long_Check(tmp)((((((PyObject*)(tmp))->ob_type))->tp_flags & ((1UL
 << 24))) != 0)) {
      rrd_set_error("expected 'start' key in callback return value to be "
          "of type int");
      goto gil_release_err;
  } else if (PyObject_RichCompareBool(tmp, tmp_min_ts, Py_EQ2) ||
             PyObject_RichCompareBool(tmp, po_start, Py_LT0)) {
      rrd_set_error("expected 'start' value in callback return dict to be "
          "equal or earlier than passed start timestamp");
      goto gil_release_err;
  } else {
      *start = PyLong_AsLong(po_start);

      if (*start == -1) {
          rrd_set_error("expected 'start' value in callback return value to"
              " not exceed LONG_MAX");
          goto gil_release_err;
      }
  }

  tmp = PyDict_GetItemString(ret, "data");
  if (tmp == NULL((void*)0)) {
      rrd_set_error("expected 'data' key in callback return value");
      goto gil_release_err;
  } else if (!PyDict_Check(tmp)((((((PyObject*)(tmp))->ob_type))->tp_flags & ((1UL
 << 29))) != 0)) {
      rrd_set_error("expected 'data' key in callback return value of type "
          "dict");
      goto gil_release_err;
  } else {
      *ds_cnt = (unsigned long)PyDict_Size(tmp);
      *ds_namv = (char **)calloc(*ds_cnt, sizeof(char *));

      if (*ds_namv == NULL((void*)0)) {
          rrd_set_error("an error occurred while allocating memory for "
              "ds_namv when allocating memory for python callback");
          goto gil_release_err;
      }

      PyObject *key, *value;
      Py_ssize_t pos = 0;  /* don't use pos for indexing */
      unsigned int x = 0;

      while (PyDict_Next(tmp, &pos, &key, &value)) {
          const char *key_str = PyRRD_String_AS_STRING(key)PyUnicode_AsUTF8(key);

          if (key_str == NULL((void*)0)) {
              rrd_set_error("key of 'data' element from callback return "
                  "value is not a string");
              goto gil_release_free_dsnamv_err;
          } else if (strlen(key_str) > DS_NAM_SIZE20) {
              rrd_set_error("key '%s' longer than the allowed maximum of %d "
                  "byte", key_str, DS_NAM_SIZE20 - 1);
              goto gil_release_free_dsnamv_err;
          }

          if ((((*ds_namv)[x]) = (char *)malloc(sizeof(char) * DS_NAM_SIZE20)) == NULL((void*)0)) {
              rrd_set_error("malloc fetch ds_namv entry");
              goto gil_release_free_dsnamv_err;
          }

          strncpy((*ds_namv)[x], key_str, DS_NAM_SIZE20 - 1);
          (*ds_namv)[x][DS_NAM_SIZE20 - 1] = '\0';

          if (!PyList_Check(value)((((((PyObject*)(value))->ob_type))->tp_flags & ((1UL
 << 25))) != 0)) {
              rrd_set_error("expected 'data' dict values in callback return "
                  "value of type list");
              goto gil_release_free_dsnamv_err;
          } else if (PyList_Size(value) > rowcount)
              rowcount = PyList_Size(value);

          ++x;
      }

      *end = *start + *step * rowcount;

      if (((*data) = (rrd_value_t *)malloc(*ds_cnt * rowcount * sizeof(rrd_value_t))) == NULL((void*)0)) {
          rrd_set_error("malloc fetch data area");
          goto gil_release_free_dsnamv_err;
      }

      for (i = 0; i < *ds_cnt; i++) {
          for (ii = 0; ii < (unsigned int)rowcount; ii++) {
              char *ds_namv_i = (*ds_namv)[i];
              double va;
              PyObject *lstv = PyList_GetItem(PyDict_GetItemString(tmp, ds_namv_i), ii);

              /* lstv may be NULL here in case an IndexError has been raised;
                 in such case the rowcount is higher than the number of elements for
                 the list of that ds. use DNAN as value for these then */
              if (lstv == NULL((void*)0) || lstv == Py_None(&_Py_NoneStruct)) {
                  if (lstv == NULL((void*)0))
                      PyErr_Clear();
                  va = DNANrrd_set_to_DNAN();
              }
              else {
                  va = PyFloat_AsDouble(lstv);
                  if (va == -1.0 && PyErr_Occurred()) {
                      PyObject *exc_type, *exc_value, *exc_value_str = NULL((void*)0), *exc_tb;
                      PyErr_Fetch(&exc_type, &exc_value, &exc_tb);

                      if (exc_value != NULL((void*)0)) {
                          exc_value_str = PyObject_Str(exc_value);
                          rrd_set_error((char *)PyRRD_String_AS_STRING(exc_value_str)PyUnicode_AsUTF8(exc_value_str));
                          Py_DECREF(exc_value)_Py_DECREF(((PyObject*)(exc_value)));
                      }

                      Py_DECREF(exc_type)_Py_DECREF(((PyObject*)(exc_type)));
                      Py_DECREF(exc_value_str)_Py_DECREF(((PyObject*)(exc_value_str)));
                      if (exc_tb != NULL((void*)0))
                          Py_DECREF(exc_tb)_Py_DECREF(((PyObject*)(exc_tb)));
                      goto gil_release_free_dsnamv_err;
                  }
              }

              (*data)[i + ii * (*ds_cnt)] = va;
          }
      }
  }

  /* success */
  rc = 1;
  goto gil_release;

1264gil_release_free_dsnamv_err:
  for (i = 0; i < *ds_cnt; i++) {
      if ((*ds_namv)[i]) {
          free((*ds_namv)[i]);
      }
  }

  free(*ds_namv);

1273gil_release_err:
  rc = -1;

1276gil_release:
  if (ret != NULL((void*)0))
      Py_DECREF(ret)_Py_DECREF(((PyObject*)(ret)));
  PyGILState_Release(gstate);
  return rc;
1281}

1283static char _rrdtool_register_fetch_cb__doc__[] = "Register callback for "
  "fetching data";

1286static PyObject *
1287_rrdtool_register_fetch_cb(PyObject *Py_UNUSED(self)_unused_self __attribute__((unused)), PyObject *args)
1288{
  PyObject *callable;

  if (!PyArg_ParseTuple(args, "O", &callable))
      return NULL((void*)0);
  else if (!PyCallable_Check(callable)) {
      PyErr_SetString(rrdtool_ProgrammingError, "first argument must be callable");
      return NULL((void*)0);
  } else {
      _rrdtool_fetch_callable = callable;
      rrd_fetch_cb_register(_rrdtool_fetch_cb_wrapper);
      Py_RETURN_NONEreturn _Py_INCREF(((PyObject*)((&_Py_NoneStruct)))), (&
_Py_NoneStruct);
  }
1301}

1303static char _rrdtool_clear_fetch_cb__doc__[] = "Clear callback for "
  "fetching data";

1306static PyObject *
1307_rrdtool_clear_fetch_cb(PyObject *Py_UNUSED(self)_unused_self __attribute__((unused)), PyObject *Py_UNUSED(args)_unused_args __attribute__((unused)))
1308{
  if (_rrdtool_fetch_callable == NULL((void*)0)) {
      PyErr_SetString(rrdtool_ProgrammingError, "no callback has been set previously");
      return NULL((void*)0);
  }

  _rrdtool_fetch_callable = NULL((void*)0);
  rrd_fetch_cb_register(NULL((void*)0));
  Py_RETURN_NONEreturn _Py_INCREF(((PyObject*)((&_Py_NoneStruct)))), (&
_Py_NoneStruct);
1317}

1319#endif /* WITH_FETCH_CB */

1321static char _rrdtool_lib_version__doc__[] = "Get the version this binding "\
"was compiled against.";

1324/**
* Returns a str object that contains the librrd version.
*
* @return librrd version (Python str object)
*/
1329static PyObject *
1330_rrdtool_lib_version(PyObject *Py_UNUSED(self)_unused_self __attribute__((unused)), PyObject *Py_UNUSED(args)_unused_args __attribute__((unused)))
1331{
  return PyRRD_String_FromString(rrd_strversion())PyUnicode_FromString(rrd_strversion());
1333}

1335/** Method table. */
1336static PyMethodDef rrdtool_methods[] = {
  {"create", (PyCFunction)_rrdtool_create,
   METH_VARARGS0x0001, _rrdtool_create__doc__},
  {"dump", (PyCFunction)_rrdtool_dump,
   METH_VARARGS0x0001, _rrdtool_dump__doc__},
  {"update", (PyCFunction)_rrdtool_update,
   METH_VARARGS0x0001, _rrdtool_update__doc__},
  {"updatev", (PyCFunction)_rrdtool_updatev,
   METH_VARARGS0x0001, _rrdtool_updatev__doc__},
  {"fetch", (PyCFunction)_rrdtool_fetch,
   METH_VARARGS0x0001, _rrdtool_fetch__doc__},
  {"flushcached", (PyCFunction)_rrdtool_flushcached,
   METH_VARARGS0x0001, _rrdtool_flushcached__doc__},
  {"graph", (PyCFunction)_rrdtool_graph,
   METH_VARARGS0x0001, _rrdtool_graph__doc__},
  {"graphv", (PyCFunction)_rrdtool_graphv,
   METH_VARARGS0x0001, _rrdtool_graphv__doc__},
  {"xport", (PyCFunction)_rrdtool_xport,
   METH_VARARGS0x0001, _rrdtool_xport__doc__},
  {"tune", (PyCFunction)_rrdtool_tune,
   METH_VARARGS0x0001, _rrdtool_tune__doc__},
  {"first", (PyCFunction)_rrdtool_first,
   METH_VARARGS0x0001, _rrdtool_first__doc__},
  {"last", (PyCFunction)_rrdtool_last,
   METH_VARARGS0x0001, _rrdtool_last__doc__},
  {"resize", (PyCFunction)_rrdtool_resize,
   METH_VARARGS0x0001, _rrdtool_resize__doc__},
  {"info", (PyCFunction)_rrdtool_info,
   METH_VARARGS0x0001, _rrdtool_info__doc__},
  {"lastupdate", (PyCFunction)_rrdtool_lastupdate,
   METH_VARARGS0x0001, _rrdtool_lastupdate__doc__},
1367#ifdef WITH_FETCH_CB1
  {"register_fetch_cb", (PyCFunction)_rrdtool_register_fetch_cb,
   METH_VARARGS0x0001, _rrdtool_register_fetch_cb__doc__},
  {"clear_fetch_cb", (PyCFunction)_rrdtool_clear_fetch_cb,
   METH_NOARGS0x0004, _rrdtool_clear_fetch_cb__doc__},
1372#endif /* WITH_FETCH_CB */
  {"lib_version", (PyCFunction)_rrdtool_lib_version,
   METH_NOARGS0x0004, _rrdtool_lib_version__doc__},
  {NULL((void*)0), NULL((void*)0), 0, NULL((void*)0)}
1376};

1378/** Library init function. */
1379#ifdef HAVE_PY3K
1380static struct PyModuleDef rrdtoolmodule = {
  .m_base = PyModuleDef_HEAD_INIT{ { 1, ((void*)0) }, ((void*)0), 0, ((void*)0), },
  .m_name = "rrdtool",
  .m_doc = "Python bindings for rrdtool",
  .m_size = -1,
  .m_methods = rrdtool_methods
1386};

1388#endif

1390#ifdef HAVE_PY3K
1391PyMODINIT_FUNCPyObject*
1392PyInit_rrdtool(void)
1393#else
1394void
1395initrrdtool(void)
1396#endif
1397{
  PyObject *m;

  PyDateTime_IMPORTPyDateTimeAPI = (PyDateTime_CAPI *)PyCapsule_Import("datetime.datetime_CAPI"
, 0);  /* initialize PyDateTime_ functions */

  /* make sure that the GIL has been created as we need to aquire it */
  if (!PyEval_ThreadsInitialized())
      PyEval_InitThreads();

1406#ifdef HAVE_PY3K
  m = PyModule_Create(&rrdtoolmodule)PyModule_Create2(&rrdtoolmodule, 1013);
1408#else
  m = Py_InitModule3("rrdtool",
                     rrdtool_methods,
                     "Python bindings for rrdtool");
1412#endif

  if (m == NULL((void*)0))
1415#ifdef HAVE_PY3K
      return NULL((void*)0);
1417#else
      return;
1419#endif

  rrdtool_ProgrammingError = PyErr_NewException("rrdtool.ProgrammingError",
                                                NULL((void*)0), NULL((void*)0));
  Py_INCREF(rrdtool_ProgrammingError)_Py_INCREF(((PyObject*)(rrdtool_ProgrammingError)));
  PyModule_AddObject(m, "ProgrammingError", rrdtool_ProgrammingError);

  rrdtool_OperationalError = PyErr_NewException("rrdtool.OperationalError",
                                                NULL((void*)0), NULL((void*)0));
  Py_INCREF(rrdtool_OperationalError)_Py_INCREF(((PyObject*)(rrdtool_OperationalError)));
  PyModule_AddObject(m, "OperationalError", rrdtool_OperationalError);
  PyModule_AddStringConstant(m, "__version__", _version);

1432#ifdef HAVE_PY3K
  return m;
1434#endif
1435}

←

/opt/pyrefcon/lib/pyrefcon/models/models/PyTuple_New.model

→

1#ifndef PyTuple_New
2struct _object;
3typedef struct _object PyObject;
4PyObject* clang_analyzer_PyObject_New_Reference();
5PyObject* PyTuple_New(Py_ssize_t len) {
6  return clang_analyzer_PyObject_New_Reference();
6
←
Setting reference count to 1→
7}
8#else
9#warning "API PyTuple_New is defined as a macro."
10#endif

←

/opt/pyrefcon/lib/pyrefcon/models/models/PyTuple_SetItem.model

1#ifndef PyTuple_SetItem
2struct _object;
3typedef struct _object PyObject;
4void clang_analyzer_PyObject_Steal_Reference(const void *);
5int clang_analyzer_noimpl_conjure_int();
6int PyTuple_SetItem(PyObject *p, Py_ssize_t pos, PyObject *o) {
7  clang_analyzer_PyObject_Steal_Reference(o);
9
←
Setting reference count to 0→
8  return clang_analyzer_noimpl_conjure_int();
9}
10#else
11#warning "API PyTuple_SetItem is defined as a macro."
12#endif