src/python/pmapi.c

   1 /*
   2  * Copyright (C) 2012-2017 Red Hat.
   3  * Copyright (C) 2009-2012 Michael T. Werner
   4  *
   5  * This file is part of the "pcp" module, the python interfaces for the
   6  * Performance Co-Pilot toolkit.
   7  *
   8  * This program is free software; you can redistribute it and/or modify it
   9  * under the terms of the GNU General Public License as published by the
  10  * Free Software Foundation; either version 2 of the License, or (at your
  11  * option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  15  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16  * for more details.
  17  */
  18
  19 /**************************************************************************\
  20 **                                                                        **
  21 ** This C extension module mainly serves the purpose of loading constants **
  22 ** from PCP headers into the module dictionary.  The PMAPI functions and  **
  23 ** data structures are wrapped in pmapi.py and friends, using ctypes.     **
  24 **                                                                        **
  25 \**************************************************************************/
  26
  27 #include <Python.h>
  28 #include <pcp/pmapi.h>
  29 #include <pcp/impl.h>
  30
  31 #if PY_MAJOR_VERSION >= 3
  32 #define MOD_ERROR_VAL NULL
  33 #define MOD_SUCCESS_VAL(val) val
  34 #define MOD_INIT(name) PyMODINIT_FUNC PyInit_##name(void)
  35 #define MOD_DEF(ob, name, doc, methods) \
  36         static struct PyModuleDef moduledef = { \
  37           PyModuleDef_HEAD_INIT, name, doc, -1, methods, }; \
  38         ob = PyModule_Create(&moduledef);
  39 #else
  40 #define MOD_ERROR_VAL
  41 #define MOD_SUCCESS_VAL(val)
  42 #define MOD_INIT(name) void init##name(void)
  43 #define MOD_DEF(ob, name, doc, methods) \
  44         ob = Py_InitModule3(name, methods, doc);
  45 #endif
  46
  47 static pmOptions options;
  48 static int longOptionsCount;
  49 static PyObject *optionCallback;
  50 static PyObject *overridesCallback;
  51
  52 static void
  53 dict_add_unsigned(PyObject *dict, char *symbol, unsigned long value)
  54 {
  55     PyObject *pyvalue = PyLong_FromUnsignedLong(value);
  56     PyDict_SetItemString(dict, symbol, pyvalue);
  57     Py_XDECREF(pyvalue);
  58 }
  59
  60 static void
  61 dict_add(PyObject *dict, char *symbol, long value)
  62 {
  63 #if PY_MAJOR_VERSION >= 3
  64     PyObject *pyvalue = PyLong_FromLong(value);
  65 #else
  66     PyObject *pyvalue = PyInt_FromLong(value);
  67 #endif
  68     PyDict_SetItemString(dict, symbol, pyvalue);
  69     Py_XDECREF(pyvalue);
  70 }
  71
  72 static void
  73 edict_add(PyObject *dict, PyObject *edict, char *symbol, long value)
  74 {
  75 #if PY_MAJOR_VERSION >= 3
  76     PyObject *pyvalue = PyLong_FromLong(value);
  77     PyObject *pysymbol = PyUnicode_FromString(symbol);
  78 #else
  79     PyObject *pyvalue = PyInt_FromLong(value);
  80     PyObject *pysymbol = PyString_FromString(symbol);
  81 #endif
  82
  83     PyDict_SetItemString(dict, symbol, pyvalue);
  84     PyDict_SetItem(edict, pyvalue, pysymbol);
  85     Py_XDECREF(pysymbol);
  86     Py_XDECREF(pyvalue);
  87 }
  88
  89 static PyObject *
  90 setExtendedTimeBase(PyObject *self, PyObject *args, PyObject *keywords)
  91 {
  92     int type;
  93     char *keyword_list[] = {"type", NULL};
  94
  95     if (!PyArg_ParseTupleAndKeywords(args, keywords,
  96                         "i:PM_XTB_SET", keyword_list, &type))
  97         return NULL;
  98     return Py_BuildValue("i", PM_XTB_SET(type));
  99 }
 100
 101 static PyObject *
 102 getExtendedTimeBase(PyObject *self, PyObject *args, PyObject *keywords)
 103 {
 104     int mode;
 105     char *keyword_list[] = {"mode", NULL};
 106
 107     if (!PyArg_ParseTupleAndKeywords(args, keywords,
 108                         "i:PM_XTB_GET", keyword_list, &mode))
 109         return NULL;
 110     return Py_BuildValue("i", PM_XTB_GET(mode));
 111 }
 112
 113 static PyObject *
 114 timevalSleep(PyObject *self, PyObject *args, PyObject *keywords)
 115 {
 116     struct timeval ctv;
 117     long seconds, useconds;
 118     char *keyword_list[] = {"seconds", "useconds", NULL};
 119     extern void __pmtimevalSleep(struct timeval);
 120
 121     if (!PyArg_ParseTupleAndKeywords(args, keywords,
 122                         "ll:pmtimevalSleep", keyword_list, &seconds, &useconds))
 123         return NULL;
 124     ctv.tv_sec = seconds;
 125     ctv.tv_usec = useconds;
 126     __pmtimevalSleep(ctv);
 127     Py_INCREF(Py_None);
 128     return Py_None;
 129 }
 130
 131 static PyObject *
 132 timevalToReal(PyObject *self, PyObject *args, PyObject *keywords)
 133 {
 134     struct timeval ctv;
 135     long seconds, useconds;
 136     char *keyword_list[] = {"seconds", "useconds", NULL};
 137     extern double __pmtimevalToReal(const struct timeval *);
 138
 139     if (!PyArg_ParseTupleAndKeywords(args, keywords,
 140                         "ll:pmtimevalToReal", keyword_list, &seconds, &useconds))
 141         return NULL;
 142     ctv.tv_sec = seconds;
 143     ctv.tv_usec = useconds;
 144     return Py_BuildValue("d", __pmtimevalToReal(&ctv));
 145 }
 146
 147 static PyObject *
 148 setIdentity(PyObject *self, PyObject *args, PyObject *keywords)
 149 {
 150     char *name;
 151     char *keyword_list[] = {"name", NULL};
 152     extern int __pmSetProcessIdentity(const char *);
 153
 154     if (!PyArg_ParseTupleAndKeywords(args, keywords,
 155                         "s:pmSetProcessIdentity", keyword_list, &name))
 156         return NULL;
 157     return Py_BuildValue("i", __pmSetProcessIdentity(name));
 158 }
 159
 160 static PyObject *
 161 makeTime(PyObject *self, PyObject *args, PyObject *keywords)
 162 {
 163     struct tm tm;
 164     int gmtoff = 0;
 165     char *zone = NULL;
 166     char *keyword_list[] = {"tm_sec", "tm_min", "tm_hour",
 167                             "tm_mday", "tm_mon", "tm_year",
 168                             "tm_wday", "tm_yday", "tm_isdst",
 169                             "tm_gmtoff", "tm_zone", NULL};
 170
 171     if (!PyArg_ParseTupleAndKeywords(args, keywords,
 172                         "iiiiiiiiils:pmMktime", keyword_list,
 173                         &tm.tm_sec, &tm.tm_min, &tm.tm_hour,
 174                         &tm.tm_mday, &tm.tm_mon, &tm.tm_year,
 175                         &tm.tm_wday, &tm.tm_yday, &tm.tm_isdst,
 176                         &gmtoff, &zone))
 177         return NULL;
 178 #ifdef IS_LINUX
 179     tm.tm_gmtoff = gmtoff;
 180     tm.tm_zone = zone;
 181 #endif
 182     return Py_BuildValue("l", __pmMktime(&tm));
 183 }
 184
 185 /*
 186  * Common command line option handling code - wrapping pmOptions
 187  */
 188
 189 static int
 190 addLongOption(pmLongOptions *opt, int duplicate)
 191 {
 192     size_t bytes;
 193     pmLongOptions *lp;
 194     int index = longOptionsCount;
 195
 196     if (!opt->long_opt)
 197         return -EINVAL;
 198
 199     bytes = (index + 2) * sizeof(pmLongOptions); /* +2 for PMAPI_OPTIONS_END */
 200     if ((lp = realloc(options.long_options, bytes)) == NULL)
 201         return -ENOMEM;
 202     options.long_options = lp;
 203
 204     if (!duplicate)
 205         goto update;
 206
 207     if ((opt->long_opt = strdup(opt->long_opt)) == NULL)
 208         return -ENOMEM;
 209     if (opt->argname &&
 210         (opt->argname = strdup(opt->argname)) == NULL) {
 211         free((char *)opt->long_opt);
 212         return -ENOMEM;
 213     }
 214     if (opt->message &&
 215         (opt->message = strdup(opt->message)) == NULL) {
 216         free((char *)opt->long_opt);
 217         free((char *)opt->argname);
 218         return -ENOMEM;
 219     }
 220
 221 update:
 222     lp[index].long_opt = opt->long_opt;
 223     lp[index].has_arg = opt->has_arg;
 224     lp[index].short_opt = opt->short_opt;
 225     lp[index].argname = opt->argname;
 226     lp[index].message = opt->message;
 227     memset(&lp[index+1], 0, sizeof(pmLongOptions));     /* PMAPI_OPTIONS_END */
 228     longOptionsCount++;
 229     return 0;
 230 }
 231
 232 static PyObject *
 233 setLongOptionHeader(PyObject *self, PyObject *args, PyObject *keywords)
 234 {
 235     pmLongOptions header = PMAPI_OPTIONS_HEADER("");
 236     char *keyword_list[] = {"heading", NULL};
 237
 238     if (!PyArg_ParseTupleAndKeywords(args, keywords,
 239                         "s:pmSetLongOptionHeader", keyword_list,
 240                         &header.message))
 241         return NULL;
 242     if ((header.message = strdup(header.message)) == NULL)
 243         return PyErr_NoMemory();
 244
 245     if (addLongOption(&header, 0) < 0) {
 246         free((char *)header.message);
 247         return PyErr_NoMemory();
 248     }
 249     Py_INCREF(Py_None);
 250     return Py_None;
 251 }
 252
 253 static PyObject *
 254 setLongOptionText(PyObject *self, PyObject *args, PyObject *keywords)
 255 {
 256     pmLongOptions text = PMAPI_OPTIONS_TEXT("");
 257     char *keyword_list[] = {"text", NULL};
 258
 259     if (!PyArg_ParseTupleAndKeywords(args, keywords,
 260                         "s:pmSetLongOptionText", keyword_list,
 261                         &text.message))
 262         return NULL;
 263     if ((text.message = strdup(text.message)) == NULL)
 264         return PyErr_NoMemory();
 265
 266     if (addLongOption(&text, 0) < 0) {
 267         free((char *)text.message);
 268         return PyErr_NoMemory();
 269     }
 270     Py_INCREF(Py_None);
 271     return Py_None;
 272 }
 273
 274 static PyObject *
 275 addLongOptionObject(pmLongOptions *option)
 276 {
 277     if (addLongOption(option, 1) < 0)
 278         return PyErr_NoMemory();
 279     Py_INCREF(Py_None);
 280     return Py_None;
 281 }
 282
 283 static PyObject *
 284 setLongOption(PyObject *self, PyObject *args, PyObject *keywords)
 285 {
 286     char *short_opt = NULL;
 287     pmLongOptions option = { 0 };
 288     char *keyword_list[] = {"long_opt", "has_arg", "short_opt",
 289                             "argname", "message", NULL};
 290
 291     if (!PyArg_ParseTupleAndKeywords(args, keywords,
 292                         "sisss:pmSetLongOption", keyword_list,
 293                         &option.long_opt, &option.has_arg, &short_opt,
 294                         &option.argname, &option.message))
 295         return NULL;
 296     if (short_opt)
 297         option.short_opt = (int)short_opt[0];
 298     return addLongOptionObject(&option);
 299 }
 300
 301 static PyObject *
 302 setLongOptionAlign(PyObject *self, PyObject *args)
 303 {
 304     pmLongOptions option = PMOPT_ALIGN;
 305     return addLongOptionObject(&option);
 306 }
 307
 308 static PyObject *
 309 setLongOptionArchive(PyObject *self, PyObject *args)
 310 {
 311     pmLongOptions option = PMOPT_ARCHIVE;
 312     return addLongOptionObject(&option);
 313 }
 314
 315 static PyObject *
 316 setLongOptionHostList(PyObject *self, PyObject *args)
 317 {
 318     pmLongOptions option = PMOPT_HOST_LIST;
 319     return addLongOptionObject(&option);
 320 }
 321
 322 static PyObject *
 323 setLongOptionArchiveList(PyObject *self, PyObject *args)
 324 {
 325     pmLongOptions option = PMOPT_ARCHIVE_LIST;
 326     return addLongOptionObject(&option);
 327 }
 328
 329 static PyObject *
 330 setLongOptionArchiveFolio(PyObject *self, PyObject *args)
 331 {
 332     pmLongOptions option = PMOPT_ARCHIVE_FOLIO;
 333     return addLongOptionObject(&option);
 334 }
 335
 336 static PyObject *
 337 setLongOptionContainer(PyObject *self, PyObject *args)
 338 {
 339     pmLongOptions option = PMOPT_CONTAINER;
 340     return addLongOptionObject(&option);
 341 }
 342
 343 static PyObject *
 344 setLongOptionDebug(PyObject *self, PyObject *args)
 345 {
 346     pmLongOptions option = PMOPT_DEBUG;
 347     return addLongOptionObject(&option);
 348 }
 349
 350 static PyObject *
 351 setLongOptionHost(PyObject *self, PyObject *args)
 352 {
 353     pmLongOptions option = PMOPT_HOST;
 354     return addLongOptionObject(&option);
 355 }
 356
 357 static PyObject *
 358 setLongOptionHostsFile(PyObject *self, PyObject *args)
 359 {
 360     pmLongOptions option = PMOPT_HOSTSFILE;
 361     return addLongOptionObject(&option);
 362 }
 363
 364 static PyObject *
 365 setLongOptionSpecLocal(PyObject *self, PyObject *args)
 366 {
 367     pmLongOptions option = PMOPT_SPECLOCAL;
 368     return addLongOptionObject(&option);
 369 }
 370
 371 static PyObject *
 372 setLongOptionLocalPMDA(PyObject *self, PyObject *args)
 373 {
 374     pmLongOptions option = PMOPT_LOCALPMDA;
 375     return addLongOptionObject(&option);
 376 }
 377
 378 static PyObject *
 379 setLongOptionOrigin(PyObject *self, PyObject *args)
 380 {
 381     pmLongOptions option = PMOPT_ORIGIN;
 382     return addLongOptionObject(&option);
 383 }
 384
 385 static PyObject *
 386 setLongOptionStart(PyObject *self, PyObject *args)
 387 {
 388     pmLongOptions option = PMOPT_START;
 389     return addLongOptionObject(&option);
 390 }
 391
 392 static PyObject *
 393 setLongOptionSamples(PyObject *self, PyObject *args)
 394 {
 395     pmLongOptions option = PMOPT_SAMPLES;
 396     return addLongOptionObject(&option);
 397 }
 398
 399 static PyObject *
 400 setLongOptionFinish(PyObject *self, PyObject *args)
 401 {
 402     pmLongOptions option = PMOPT_FINISH;
 403     return addLongOptionObject(&option);
 404 }
 405
 406 static PyObject *
 407 setLongOptionInterval(PyObject *self, PyObject *args)
 408 {
 409     pmLongOptions option = PMOPT_INTERVAL;
 410     return addLongOptionObject(&option);
 411 }
 412
 413 static PyObject *
 414 setLongOptionVersion(PyObject *self, PyObject *args)
 415 {
 416     pmLongOptions option = PMOPT_VERSION;
 417     return addLongOptionObject(&option);
 418 }
 419
 420 static PyObject *
 421 setLongOptionTimeZone(PyObject *self, PyObject *args)
 422 {
 423     pmLongOptions option = PMOPT_TIMEZONE;
 424     return addLongOptionObject(&option);
 425 }
 426
 427 static PyObject *
 428 setLongOptionHostZone(PyObject *self, PyObject *args)
 429 {
 430     pmLongOptions option = PMOPT_HOSTZONE;
 431     return addLongOptionObject(&option);
 432 }
 433
 434 static PyObject *
 435 setLongOptionHelp(PyObject *self, PyObject *args)
 436 {
 437     pmLongOptions option = PMOPT_HELP;
 438     return addLongOptionObject(&option);
 439 }
 440
 441 static PyObject *
 442 resetAllOptions(PyObject *self, PyObject *args)
 443 {
 444     pmFreeOptions(&options);
 445     memset(&options, 0, sizeof(options));
 446     Py_INCREF(Py_None);
 447     return Py_None;
 448 }
 449
 450 static PyObject *
 451 setShortOptions(PyObject *self, PyObject *args, PyObject *keywords)
 452 {
 453     char *short_opts;
 454     char *keyword_list[] = {"short_options", NULL};
 455
 456     if (!PyArg_ParseTupleAndKeywords(args, keywords,
 457                         "s:pmSetShortOptions", keyword_list, &short_opts))
 458         return NULL;
 459
 460     if ((short_opts = strdup(short_opts ? short_opts : "")) == NULL)
 461         return PyErr_NoMemory();
 462     if (options.short_options)
 463         free((void *)options.short_options);
 464     options.short_options = short_opts;
 465     Py_INCREF(Py_None);
 466     return Py_None;
 467 }
 468
 469 static PyObject *
 470 setShortUsage(PyObject *self, PyObject *args, PyObject *keywords)
 471 {
 472     char *short_usage;
 473     char *keyword_list[] = {"short_usage", NULL};
 474
 475     if (!PyArg_ParseTupleAndKeywords(args, keywords,
 476                         "s:pmSetShortUsage", keyword_list, &short_usage))
 477         return NULL;
 478
 479     if ((short_usage = strdup(short_usage ? short_usage : "")) == NULL)
 480         return PyErr_NoMemory();
 481     if (options.short_usage)
 482         free((void *)options.short_usage);
 483     options.short_usage = short_usage;
 484     Py_INCREF(Py_None);
 485     return Py_None;
 486 }
 487
 488 static PyObject *
 489 setOptionContext(PyObject *self, PyObject *args, PyObject *keywords)
 490 {
 491     int context;
 492     char *keyword_list[] = {"context", NULL};
 493
 494     if (!PyArg_ParseTupleAndKeywords(args, keywords,
 495                         "i:pmSetOptionContext", keyword_list, &context))
 496         return NULL;
 497
 498     options.context = context;
 499     Py_INCREF(Py_None);
 500     return Py_None;
 501 }
 502
 503 static PyObject *
 504 setOptionFlags(PyObject *self, PyObject *args, PyObject *keywords)
 505 {
 506     int flags;
 507     char *keyword_list[] = {"flags", NULL};
 508
 509     if (!PyArg_ParseTupleAndKeywords(args, keywords,
 510                         "i:pmSetOptionFlags", keyword_list, &flags))
 511         return NULL;
 512
 513     options.flags |= flags;
 514     Py_INCREF(Py_None);
 515     return Py_None;
 516 }
 517
 518 static PyObject *
 519 setOptionArchiveFolio(PyObject *self, PyObject *args, PyObject *keywords)
 520 {
 521     char *folio;
 522     char *keyword_list[] = {PMLONGOPT_ARCHIVE_FOLIO, NULL};
 523
 524     if (!PyArg_ParseTupleAndKeywords(args, keywords,
 525                         "s:pmSetOptionArchiveFolio", keyword_list, &folio))
 526         return NULL;
 527
 528     __pmAddOptArchiveFolio(&options, folio);
 529     Py_INCREF(Py_None);
 530     return Py_None;
 531 }
 532
 533 static PyObject *
 534 setOptionArchiveList(PyObject *self, PyObject *args, PyObject *keywords)
 535 {
 536     char *archives;
 537     char *keyword_list[] = {PMLONGOPT_ARCHIVE_LIST, NULL};
 538
 539     if (!PyArg_ParseTupleAndKeywords(args, keywords,
 540                         "s:pmSetOptionArchiveList", keyword_list, &archives))
 541         return NULL;
 542
 543     __pmAddOptArchiveList(&options, archives);
 544     Py_INCREF(Py_None);
 545     return Py_None;
 546 }
 547
 548 static PyObject *
 549 setOptionArchive(PyObject *self, PyObject *args, PyObject *keywords)
 550 {
 551     char *archive;
 552     char *keyword_list[] = {"archive", NULL};
 553
 554     if (!PyArg_ParseTupleAndKeywords(args, keywords,
 555                         "s:pmSetOptionArchive", keyword_list, &archive))
 556         return NULL;
 557
 558     if ((archive = strdup(archive ? archive : "")) == NULL)
 559         return PyErr_NoMemory();
 560     __pmAddOptArchive(&options, archive);
 561     Py_INCREF(Py_None);
 562     return Py_None;
 563 }
 564
 565 static PyObject *
 566 setOptionContainer(PyObject *self, PyObject *args, PyObject *keywords)
 567 {
 568     char *container;
 569     char *keyword_list[] = {PMLONGOPT_CONTAINER, NULL};
 570
 571     if (!PyArg_ParseTupleAndKeywords(args, keywords,
 572                         "s:pmSetOptionContainer", keyword_list, &container))
 573         return NULL;
 574
 575     if ((container = strdup(container ? container : "")) == NULL)
 576         return PyErr_NoMemory();
 577     __pmAddOptContainer(&options, container);
 578     Py_INCREF(Py_None);
 579     return Py_None;
 580 }
 581
 582 static PyObject *
 583 setOptionHost(PyObject *self, PyObject *args, PyObject *keywords)
 584 {
 585     char *host;
 586     char *keyword_list[] = {"host", NULL};
 587
 588     if (!PyArg_ParseTupleAndKeywords(args, keywords,
 589                         "s:pmSetOptionHost", keyword_list, &host))
 590         return NULL;
 591
 592     if ((host = strdup(host ? host : "")) == NULL)
 593         return PyErr_NoMemory();
 594     __pmAddOptHost(&options, host);
 595     Py_INCREF(Py_None);
 596     return Py_None;
 597 }
 598
 599 static PyObject *
 600 setOptionHostList(PyObject *self, PyObject *args, PyObject *keywords)
 601 {
 602     char *hosts;
 603     char *keyword_list[] = {PMLONGOPT_HOST_LIST, NULL};
 604
 605     if (!PyArg_ParseTupleAndKeywords(args, keywords,
 606                         "s:pmSetOptionHostList", keyword_list, &hosts))
 607         return NULL;
 608
 609     __pmAddOptHostList(&options, hosts);
 610     Py_INCREF(Py_None);
 611     return Py_None;
 612 }
 613
 614 static PyObject *
 615 setOptionSpecLocal(PyObject *self, PyObject *args, PyObject *keywords)
 616 {
 617     char *spec;
 618     char *keyword_list[] = {"spec", NULL};
 619
 620     if (!PyArg_ParseTupleAndKeywords(args, keywords,
 621                         "s:pmSetOptionSpecLocal", keyword_list, &spec))
 622         return NULL;
 623
 624     if ((spec = strdup(spec ? spec : "")) == NULL)
 625         return PyErr_NoMemory();
 626     __pmSetLocalContextTable(&options, spec);
 627     Py_INCREF(Py_None);
 628     return Py_None;
 629 }
 630
 631 static PyObject *
 632 setOptionLocalPMDA(PyObject *self, PyObject *args, PyObject *keywords)
 633 {
 634     __pmSetLocalContextFlag(&options);
 635     Py_INCREF(Py_None);
 636     return Py_None;
 637 }
 638
 639 static PyObject *
 640 setOptionSamples(PyObject *self, PyObject *args, PyObject *keywords)
 641 {
 642     char *count, *endnum;
 643     char *keyword_list[] = {"count", NULL};
 644
 645     if (!PyArg_ParseTupleAndKeywords(args, keywords,
 646                         "s:pmSetOptionSamples", keyword_list, &count))
 647         return NULL;
 648
 649     if (options.finish_optarg) {
 650         pmprintf("%s: at most one of finish time and sample count allowed\n",
 651                 pmProgname);
 652         options.errors++;
 653     } else {
 654         options.samples = (int)strtol(count, &endnum, 10);
 655         if (*endnum != '\0' || options.samples < 0) {
 656             pmprintf("%s: sample count must be a positive numeric argument\n",
 657                 pmProgname);
 658             options.errors++;
 659         }
 660     }
 661     Py_INCREF(Py_None);
 662     return Py_None;
 663 }
 664
 665 static PyObject *
 666 setOptionInterval(PyObject *self, PyObject *args, PyObject *keywords)
 667 {
 668     char *delta, *errmsg;
 669     char *keyword_list[] = {"delta", NULL};
 670
 671     if (!PyArg_ParseTupleAndKeywords(args, keywords,
 672                         "s:pmSetOptionInterval", keyword_list, &delta))
 673         return NULL;
 674
 675     if (pmParseInterval(delta, &options.interval, &errmsg) < 0) {
 676         pmprintf("%s: interval argument not in pmParseInterval(3) format:\n",
 677                 pmProgname);
 678         pmprintf("%s\n", errmsg);
 679         options.errors++;
 680         free(errmsg);
 681     }
 682     Py_INCREF(Py_None);
 683     return Py_None;
 684 }
 685
 686 static PyObject *
 687 setOptionErrors(PyObject *self, PyObject *args, PyObject *keywords)
 688 {
 689     int errors;
 690     char *keyword_list[] = {"errors", NULL};
 691
 692     if (!PyArg_ParseTupleAndKeywords(args, keywords,
 693                         "i:pmSetOptionErrors", keyword_list, &errors))
 694         return NULL;
 695
 696     options.errors = errors;
 697     Py_INCREF(Py_None);
 698     return Py_None;
 699 }
 700
 701 static int
 702 override_callback(int opt, pmOptions *opts)
 703 {
 704     PyObject *arglist, *result;
 705     char argstring[2] = { (char)opt, '\0' };
 706     int sts;
 707
 708     arglist = Py_BuildValue("(s)", argstring);
 709     if (!arglist) {
 710         PyErr_Print();
 711         return -ENOMEM;
 712     }
 713     result = PyEval_CallObject(overridesCallback, arglist);
 714     Py_DECREF(arglist);
 715     if (!result) {
 716         PyErr_Print();
 717         return -EAGAIN; /* exception thrown */
 718     }
 719     sts = PyLong_AsLong(result);
 720     Py_DECREF(result);
 721     return sts;
 722 }
 723
 724 static void
 725 options_callback(int opt, pmOptions *opts)
 726 {
 727     PyObject *arglist, *result;
 728     char argstring[2] = { (char)opt, '\0' };
 729
 730     arglist = Py_BuildValue("(ssi)", argstring, options.optarg, options.index);
 731     if (!arglist) {
 732         PyErr_Print();
 733     } else {
 734         result = PyEval_CallObject(optionCallback, arglist);
 735         Py_DECREF(arglist);
 736         if (!result) {
 737             PyErr_Print();
 738             return;
 739         }
 740         Py_DECREF(result);
 741     }
 742 }
 743
 744 static PyObject *
 745 getNonOptionsFromList(PyObject *self, PyObject *args, PyObject *keywords)
 746 {
 747     int argc, length, i;
 748     PyObject *result;
 749     PyObject *pyargv = NULL;
 750     char *keyword_list[] = {"argv", NULL};
 751
 752     /* Caller must perform pmGetOptions before running this, check */
 753     if (!(options.flags & PM_OPTFLAG_DONE)) {
 754         PyErr_SetString(PyExc_RuntimeError, "pmGetOptions must be called first");
 755         return NULL;
 756     }
 757
 758     if (!PyArg_ParseTupleAndKeywords(args, keywords,
 759                         "O:pmGetNonOptionsFromList", keyword_list, &pyargv))
 760     if (pyargv == NULL)
 761         return NULL;
 762
 763     if (!PyList_Check(pyargv)) {
 764         PyErr_SetString(PyExc_TypeError, "pmGetNonOptionsFromList uses a list");
 765         return NULL;
 766     }
 767
 768     length = 0;
 769     if ((argc = PyList_GET_SIZE(pyargv)) > 0)
 770         length = argc - options.optind;
 771
 772     if (length <= 0) {
 773         Py_INCREF(Py_None);
 774         return Py_None;
 775     }
 776
 777     if ((result = PyList_New(length)) == NULL)
 778         return PyErr_NoMemory();
 779
 780     for (i = 0; i < length; i++) {
 781         PyObject *pyarg = PyList_GET_ITEM(pyargv, options.optind + i);
 782         Py_INCREF(pyarg);
 783         PyList_SET_ITEM(result, i, pyarg);
 784     }
 785     Py_INCREF(result);
 786     return result;
 787 }
 788
 789 static PyObject *
 790 getOptionsFromList(PyObject *self, PyObject *args, PyObject *keywords)
 791 {
 792     int i, argc;
 793     char **argv;
 794     PyObject *pyargv = NULL;
 795     char *keyword_list[] = {"argv", NULL};
 796
 797     // Note that PyArg_ParseTupleAndKeywords() returns a "borrowed"
 798     // reference, so there is no need to decrement a reference to
 799     // pyargv.
 800     if (!PyArg_ParseTupleAndKeywords(args, keywords,
 801                         "O:pmGetOptionsFromList", keyword_list, &pyargv))
 802         return NULL;
 803
 804     if (pyargv == NULL)
 805         return Py_BuildValue("i", 0);
 806
 807     if (!PyList_Check(pyargv)) {
 808         PyErr_SetString(PyExc_TypeError, "pmGetOptionsFromList uses a list");
 809         return NULL;
 810     }
 811
 812     if ((argc = PyList_GET_SIZE(pyargv)) <= 0) {
 813         return Py_BuildValue("i", 0);
 814     }
 815
 816     if ((argv = malloc(argc * sizeof(char *))) == NULL) {
 817         return PyErr_NoMemory();
 818     }
 819
 820     for (i = 0; i < argc; i++) {
 821         PyObject *pyarg = PyList_GET_ITEM(pyargv, i);
 822 #if PY_MAJOR_VERSION >= 3
 823         char *string = PyUnicode_AsUTF8(pyarg);
 824 #else
 825         char *string = PyString_AsString(pyarg);
 826 #endif
 827
 828         /* argv[0] parameter will be used for pmProgname, so need to
 829          * ensure the memory that backs it will be with us forever.
 830          */
 831         if (i == 0 && (string = strdup(string)) == NULL) {
 832             free(argv);
 833             return PyErr_NoMemory();
 834         }
 835         argv[i] = string;
 836     }
 837
 838     if (overridesCallback)
 839         options.override = override_callback;
 840     while ((i = pmGetOptions(argc, argv, &options)) != -1)
 841         options_callback(i, &options);
 842     free(argv);
 843
 844     if (options.flags & PM_OPTFLAG_EXIT)
 845         return Py_BuildValue("i", PM_ERR_APPVERSION);
 846
 847     return Py_BuildValue("i", options.errors);
 848 }
 849
 850 static PyObject *
 851 endOptions(PyObject *self, PyObject *args, PyObject *keywords)
 852 {
 853     __pmEndOptions(&options);
 854     Py_INCREF(Py_None);
 855     return Py_None;
 856 }
 857
 858 static PyObject *
 859 setContextOptions(PyObject *self, PyObject *args, PyObject *keywords)
 860 {
 861     int sts, ctx, step, mode, delta;
 862     char *keyword_list[] = {"context", "mode", "delta", NULL};
 863
 864     if (!PyArg_ParseTupleAndKeywords(args, keywords,
 865                 "iii:pmSetContextOptions", keyword_list, &ctx, &mode, &delta))
 866         return NULL;
 867
 868     /* complete time window and timezone setup */
 869     if ((sts = pmGetContextOptions(ctx, &options)) < 0)
 870         return Py_BuildValue("i", sts);
 871
 872     /* initial archive mode, position and delta */
 873     if (options.context == PM_CONTEXT_ARCHIVE &&
 874         (options.flags & PM_OPTFLAG_BOUNDARIES)) {
 875         const int SECONDS_IN_24_DAYS = 2073600;
 876         struct timeval interval = options.interval;
 877         struct timeval position = options.origin;
 878
 879         if (interval.tv_sec > SECONDS_IN_24_DAYS) {
 880             step = interval.tv_sec;
 881             mode |= PM_XTB_SET(PM_TIME_SEC);
 882         } else {
 883             if (interval.tv_sec == 0 && interval.tv_usec == 0)
 884                 interval.tv_sec = delta;
 885             step = interval.tv_sec * 1e3 + interval.tv_usec / 1e3;
 886             mode |= PM_XTB_SET(PM_TIME_MSEC);
 887         }
 888         if ((sts = pmSetMode(mode, &position, step)) < 0) {
 889             pmprintf("%s: pmSetMode: %s\n", pmProgname, pmErrStr(sts));
 890             options.flags |= PM_OPTFLAG_RUNTIME_ERR;
 891             options.errors++;
 892         }
 893     }
 894     return Py_BuildValue("i", sts);
 895 }
 896
 897 static void
 898 pmnsDecodeCallback(const char *name, void *closure)
 899 {
 900     PyObject *arglist, *result;
 901
 902     arglist = Py_BuildValue("(s)", name);
 903     if (arglist == NULL)
 904         return;
 905     result = PyEval_CallObject(closure, arglist);
 906     Py_DECREF(arglist);
 907     if (!result)
 908         PyErr_Print();
 909     else
 910         Py_DECREF(result);
 911 }
 912
 913 /*
 914  * This pmTraversePMNS_r wrapper is specifically so that python3
 915  * installs can pass out correctly decoded python strings rather
 916  * than byte arrays.
 917  */
 918 static PyObject *
 919 pmnsTraverse(PyObject *self, PyObject *args, PyObject *keywords)
 920 {
 921     PyObject *func;
 922     char *keyword_list[] = {"name", "callback", NULL};
 923     char *name;
 924     int sts;
 925
 926     if (!PyArg_ParseTupleAndKeywords(args, keywords,
 927                 "sO:pmnsTraverse", keyword_list, &name, &func))
 928         return NULL;
 929     if (!PyCallable_Check(func)) {
 930         PyErr_SetString(PyExc_TypeError, "pmnsTraverse needs a callable");
 931         return NULL;
 932     }
 933     sts = pmTraversePMNS_r(name, pmnsDecodeCallback, func);
 934     return Py_BuildValue("i", sts);
 935 }
 936
 937 static PyObject *
 938 usageMessage(PyObject *self, PyObject *args)
 939 {
 940     pmUsageMessage(&options);
 941     Py_INCREF(Py_None);
 942     return Py_None;
 943 }
 944
 945 static PyObject *
 946 setOverrideCallback(PyObject *self, PyObject *args)
 947 {
 948     PyObject *func;
 949
 950     if (!PyArg_ParseTuple(args, "O:pmSetOverrideCallback", &func))
 951         return NULL;
 952     if (!PyCallable_Check(func)) {
 953         PyErr_SetString(PyExc_TypeError,
 954                         "pmSetOverrideCallback parameter not callable");
 955         return NULL;
 956     }
 957     Py_XINCREF(func);
 958     Py_XDECREF(overridesCallback);
 959     overridesCallback = func;
 960     Py_INCREF(Py_None);
 961     return Py_None;
 962 }
 963
 964 static PyObject *
 965 setOptionCallback(PyObject *self, PyObject *args)
 966 {
 967     PyObject *func;
 968
 969     if (!PyArg_ParseTuple(args, "O:pmSetOptionCallback", &func))
 970         return NULL;
 971     if (!PyCallable_Check(func)) {
 972         PyErr_SetString(PyExc_TypeError,
 973                         "pmSetOptionCallback parameter not callable");
 974         return NULL;
 975     }
 976     Py_XINCREF(func);
 977     Py_XDECREF(optionCallback);
 978     optionCallback = func;
 979     Py_INCREF(Py_None);
 980     return Py_None;
 981 }
 982
 983 static PyObject *
 984 getOptionErrors(PyObject *self, PyObject *args)
 985 {
 986     return Py_BuildValue("i", options.errors);
 987 }
 988
 989 static PyObject *
 990 getOptionFlags(PyObject *self, PyObject *args)
 991 {
 992     return Py_BuildValue("i", options.flags);
 993 }
 994
 995 static PyObject *
 996 getOptionContext(PyObject *self, PyObject *args)
 997 {
 998     if (options.context > 0)
 999         return Py_BuildValue("i", options.context);
1000     Py_INCREF(Py_None);
1001     return Py_None;
1002 }
1003
1004 static PyObject *
1005 getOptionHosts(PyObject *self, PyObject *args)
1006 {
1007     PyObject    *result;
1008     int         i;
1009
1010     if (options.nhosts > 0) {
1011         if ((result = PyList_New(options.nhosts)) == NULL)
1012             return PyErr_NoMemory();
1013         for (i = 0; i < options.nhosts; i++) {
1014 #if PY_MAJOR_VERSION >= 3
1015             PyObject *pyent = PyUnicode_FromString(options.hosts[i]);
1016 #else
1017             PyObject *pyent = PyString_FromString(options.hosts[i]);
1018 #endif
1019             PyList_SET_ITEM(result, i, pyent);
1020         }
1021         Py_INCREF(result);
1022         return result;
1023     }
1024     Py_INCREF(Py_None);
1025     return Py_None;
1026 }
1027
1028 static PyObject *
1029 getOptionArchives(PyObject *self, PyObject *args)
1030 {
1031     PyObject    *result;
1032     int         i;
1033
1034     if (options.narchives > 0) {
1035         if ((result = PyList_New(options.narchives)) == NULL)
1036             return PyErr_NoMemory();
1037         for (i = 0; i < options.narchives; i++) {
1038 #if PY_MAJOR_VERSION >= 3
1039             PyObject *pyent = PyUnicode_FromString(options.archives[i]);
1040 #else
1041             PyObject *pyent = PyString_FromString(options.archives[i]);
1042 #endif
1043             PyList_SET_ITEM(result, i, pyent);
1044         }
1045         Py_INCREF(result);
1046         return result;
1047     }
1048     Py_INCREF(Py_None);
1049     return Py_None;
1050 }
1051
1052 static PyObject *
1053 getOptionStart_sec(PyObject *self, PyObject *args)
1054 {
1055     if (options.start.tv_sec || options.start.tv_usec)
1056         return Py_BuildValue("l", options.start.tv_sec);
1057     Py_INCREF(Py_None);
1058     return Py_None;
1059 }
1060
1061 static PyObject *
1062 getOptionStart_usec(PyObject *self, PyObject *args)
1063 {
1064     if (options.start.tv_sec || options.start.tv_usec)
1065         return Py_BuildValue("l", options.start.tv_usec);
1066     Py_INCREF(Py_None);
1067     return Py_None;
1068 }
1069
1070 static PyObject *
1071 getOptionAlign_optarg(PyObject *self, PyObject *args)
1072 {
1073     if (options.align_optarg)
1074         return Py_BuildValue("s", options.align_optarg);
1075     Py_INCREF(Py_None);
1076     return Py_None;
1077 }
1078
1079 static PyObject *
1080 getOptionFinish_optarg(PyObject *self, PyObject *args)
1081 {
1082     if (options.finish_optarg)
1083         return Py_BuildValue("s", options.finish_optarg);
1084     Py_INCREF(Py_None);
1085     return Py_None;
1086 }
1087
1088 static PyObject *
1089 getOptionFinish_sec(PyObject *self, PyObject *args)
1090 {
1091     if (options.finish.tv_sec || options.finish.tv_usec)
1092         return Py_BuildValue("l", options.finish.tv_sec);
1093     Py_INCREF(Py_None);
1094     return Py_None;
1095 }
1096
1097 static PyObject *
1098 getOptionFinish_usec(PyObject *self, PyObject *args)
1099 {
1100     if (options.finish.tv_sec || options.finish.tv_usec)
1101         return Py_BuildValue("l", options.finish.tv_usec);
1102     Py_INCREF(Py_None);
1103     return Py_None;
1104 }
1105
1106 static PyObject *
1107 getOptionOrigin_sec(PyObject *self, PyObject *args)
1108 {
1109     if (options.origin.tv_sec || options.origin.tv_usec)
1110         return Py_BuildValue("l", options.origin.tv_sec);
1111     Py_INCREF(Py_None);
1112     return Py_None;
1113 }
1114
1115 static PyObject *
1116 getOptionOrigin_usec(PyObject *self, PyObject *args)
1117 {
1118     if (options.origin.tv_sec || options.origin.tv_usec)
1119         return Py_BuildValue("l", options.origin.tv_usec);
1120     Py_INCREF(Py_None);
1121     return Py_None;
1122 }
1123
1124 static PyObject *
1125 getOptionInterval_sec(PyObject *self, PyObject *args)
1126 {
1127     if (options.interval.tv_sec || options.interval.tv_usec)
1128         return Py_BuildValue("l", options.interval.tv_sec);
1129     Py_INCREF(Py_None);
1130     return Py_None;
1131 }
1132
1133 static PyObject *
1134 getOptionInterval_usec(PyObject *self, PyObject *args)
1135 {
1136     if (options.interval.tv_sec || options.interval.tv_usec)
1137         return Py_BuildValue("l", options.interval.tv_usec);
1138     Py_INCREF(Py_None);
1139     return Py_None;
1140 }
1141
1142 static PyObject *
1143 getOptionSamples(PyObject *self, PyObject *args)
1144 {
1145     if (options.samples)
1146         return Py_BuildValue("i", options.samples);
1147     Py_INCREF(Py_None);
1148     return Py_None;
1149 }
1150
1151 static PyObject *
1152 getOptionTimezone(PyObject *self, PyObject *args)
1153 {
1154     if (options.timezone)
1155         return Py_BuildValue("s", options.timezone);
1156     Py_INCREF(Py_None);
1157     return Py_None;
1158 }
1159
1160 static PyObject *
1161 getOptionHostZone(PyObject *self, PyObject *args)
1162 {
1163     return Py_BuildValue("i", options.tzflag);
1164 }
1165
1166 static PyObject *
1167 getOptionContainer(PyObject *self, PyObject *args)
1168 {
1169     char *container;
1170
1171     if ((container = getenv("PCP_CONTAINER")) != NULL)
1172         return Py_BuildValue("s", strdup(container));
1173     Py_INCREF(Py_None);
1174     return Py_None;
1175 }
1176
1177 static PyObject *
1178 getOptionLocalPMDA(PyObject *self, PyObject *args)
1179 {
1180     return Py_BuildValue("i", options.Lflag);
1181 }
1182
1183 static PyMethodDef methods[] = {
1184     { .ml_name = "PM_XTB_SET",
1185         .ml_meth = (PyCFunction) setExtendedTimeBase,
1186         .ml_flags = METH_VARARGS | METH_KEYWORDS },
1187     { .ml_name = "PM_XTB_GET",
1188         .ml_meth = (PyCFunction) getExtendedTimeBase,
1189         .ml_flags = METH_VARARGS | METH_KEYWORDS },
1190     { .ml_name = "pmtimevalSleep",
1191         .ml_meth = (PyCFunction) timevalSleep,
1192         .ml_flags = METH_VARARGS | METH_KEYWORDS },
1193     { .ml_name = "pmtimevalToReal",
1194         .ml_meth = (PyCFunction) timevalToReal,
1195         .ml_flags = METH_VARARGS | METH_KEYWORDS },
1196     { .ml_name = "pmSetProcessIdentity",
1197         .ml_meth = (PyCFunction) setIdentity,
1198         .ml_flags = METH_VARARGS | METH_KEYWORDS },
1199     { .ml_name = "pmMktime",
1200         .ml_meth = (PyCFunction) makeTime,
1201         .ml_flags = METH_VARARGS | METH_KEYWORDS },
1202     { .ml_name = "pmResetAllOptions",
1203         .ml_meth = (PyCFunction) resetAllOptions,
1204         .ml_flags = METH_NOARGS },
1205     { .ml_name = "pmSetLongOptionHeader",
1206         .ml_meth = (PyCFunction) setLongOptionHeader,
1207         .ml_flags = METH_VARARGS | METH_KEYWORDS },
1208     { .ml_name = "pmSetLongOptionText",
1209         .ml_meth = (PyCFunction) setLongOptionText,
1210         .ml_flags = METH_VARARGS | METH_KEYWORDS },
1211     { .ml_name = "pmSetLongOption",
1212         .ml_meth = (PyCFunction) setLongOption,
1213         .ml_flags = METH_VARARGS | METH_KEYWORDS },
1214     { .ml_name = "pmSetLongOptionAlign",
1215         .ml_meth = (PyCFunction) setLongOptionAlign,
1216         .ml_flags = METH_NOARGS },
1217     { .ml_name = "pmSetLongOptionArchive",
1218         .ml_meth = (PyCFunction) setLongOptionArchive,
1219         .ml_flags = METH_NOARGS },
1220     { .ml_name = "pmSetLongOptionArchiveList",
1221         .ml_meth = (PyCFunction) setLongOptionArchiveList,
1222         .ml_flags = METH_NOARGS },
1223     { .ml_name = "pmSetLongOptionArchiveFolio",
1224         .ml_meth = (PyCFunction) setLongOptionArchiveFolio,
1225         .ml_flags = METH_NOARGS },
1226     { .ml_name = "pmSetLongOptionContainer",
1227         .ml_meth = (PyCFunction) setLongOptionContainer,
1228         .ml_flags = METH_NOARGS },
1229     { .ml_name = "pmSetLongOptionDebug",
1230         .ml_meth = (PyCFunction) setLongOptionDebug,
1231         .ml_flags = METH_NOARGS },
1232     { .ml_name = "pmSetLongOptionHost",
1233         .ml_meth = (PyCFunction) setLongOptionHost,
1234         .ml_flags = METH_NOARGS },
1235     { .ml_name = "pmSetLongOptionHostList",
1236         .ml_meth = (PyCFunction) setLongOptionHostList,
1237         .ml_flags = METH_NOARGS },
1238     { .ml_name = "pmSetLongOptionHostsFile",
1239         .ml_meth = (PyCFunction) setLongOptionHostsFile,
1240         .ml_flags = METH_NOARGS },
1241     { .ml_name = "pmSetLongOptionSpecLocal",
1242         .ml_meth = (PyCFunction) setLongOptionSpecLocal,
1243         .ml_flags = METH_NOARGS },
1244     { .ml_name = "pmSetLongOptionLocalPMDA",
1245         .ml_meth = (PyCFunction) setLongOptionLocalPMDA,
1246         .ml_flags = METH_NOARGS },
1247     { .ml_name = "pmSetLongOptionOrigin",
1248         .ml_meth = (PyCFunction) setLongOptionOrigin,
1249         .ml_flags = METH_NOARGS },
1250     { .ml_name = "pmSetLongOptionStart",
1251         .ml_meth = (PyCFunction) setLongOptionStart,
1252         .ml_flags = METH_NOARGS },
1253     { .ml_name = "pmSetLongOptionSamples",
1254         .ml_meth = (PyCFunction) setLongOptionSamples,
1255         .ml_flags = METH_NOARGS },
1256     { .ml_name = "pmSetLongOptionFinish",
1257         .ml_meth = (PyCFunction) setLongOptionFinish,
1258         .ml_flags = METH_NOARGS },
1259     { .ml_name = "pmSetLongOptionInterval",
1260         .ml_meth = (PyCFunction) setLongOptionInterval,
1261         .ml_flags = METH_NOARGS },
1262     { .ml_name = "pmSetLongOptionVersion",
1263         .ml_meth = (PyCFunction) setLongOptionVersion,
1264         .ml_flags = METH_NOARGS },
1265     { .ml_name = "pmSetLongOptionTimeZone",
1266         .ml_meth = (PyCFunction) setLongOptionTimeZone,
1267         .ml_flags = METH_NOARGS },
1268     { .ml_name = "pmSetLongOptionHostZone",
1269         .ml_meth = (PyCFunction) setLongOptionHostZone,
1270         .ml_flags = METH_NOARGS },
1271     { .ml_name = "pmSetLongOptionHelp",
1272         .ml_meth = (PyCFunction) setLongOptionHelp,
1273         .ml_flags = METH_NOARGS },
1274     { .ml_name = "pmSetShortOptions",
1275         .ml_meth = (PyCFunction) setShortOptions,
1276         .ml_flags = METH_VARARGS | METH_KEYWORDS },
1277     { .ml_name = "pmSetShortUsage",
1278         .ml_meth = (PyCFunction) setShortUsage,
1279         .ml_flags = METH_VARARGS | METH_KEYWORDS },
1280     { .ml_name = "pmSetOptionContext",
1281         .ml_meth = (PyCFunction) setOptionContext,
1282         .ml_flags = METH_VARARGS | METH_KEYWORDS },
1283     { .ml_name = "pmSetOptionFlags",
1284         .ml_meth = (PyCFunction) setOptionFlags,
1285         .ml_flags = METH_VARARGS | METH_KEYWORDS },
1286     { .ml_name = "pmSetOptionErrors",
1287         .ml_meth = (PyCFunction) setOptionErrors,
1288         .ml_flags = METH_VARARGS | METH_KEYWORDS },
1289     { .ml_name = "pmGetOptionErrors",
1290         .ml_meth = (PyCFunction) getOptionErrors,
1291         .ml_flags = METH_NOARGS },
1292     { .ml_name = "pmGetOptionFlags",
1293         .ml_meth = (PyCFunction) getOptionFlags,
1294         .ml_flags = METH_NOARGS },
1295     { .ml_name = "pmGetOptionsFromList",
1296         .ml_meth = (PyCFunction) getOptionsFromList,
1297         .ml_flags = METH_VARARGS | METH_KEYWORDS },
1298     { .ml_name = "pmGetNonOptionsFromList",
1299         .ml_meth = (PyCFunction) getNonOptionsFromList,
1300         .ml_flags = METH_VARARGS | METH_KEYWORDS },
1301     { .ml_name = "pmEndOptions",
1302         .ml_meth = (PyCFunction) endOptions,
1303         .ml_flags = METH_NOARGS },
1304     { .ml_name = "pmSetContextOptions",
1305         .ml_meth = (PyCFunction) setContextOptions,
1306         .ml_flags = METH_VARARGS | METH_KEYWORDS},
1307     { .ml_name = "pmUsageMessage",
1308         .ml_meth = (PyCFunction) usageMessage,
1309         .ml_flags = METH_NOARGS },
1310     { .ml_name = "pmSetOptionCallback",
1311         .ml_meth = (PyCFunction) setOptionCallback,
1312         .ml_flags = METH_VARARGS | METH_KEYWORDS },
1313     { .ml_name = "pmSetOverrideCallback",
1314         .ml_meth = (PyCFunction) setOverrideCallback,
1315         .ml_flags = METH_VARARGS | METH_KEYWORDS },
1316     { .ml_name = "pmGetOptionContext",
1317         .ml_meth = (PyCFunction) getOptionContext,
1318         .ml_flags = METH_NOARGS },
1319     { .ml_name = "pmGetOptionHosts",
1320         .ml_meth = (PyCFunction) getOptionHosts,
1321         .ml_flags = METH_NOARGS },
1322     { .ml_name = "pmGetOptionArchives",
1323         .ml_meth = (PyCFunction) getOptionArchives,
1324         .ml_flags = METH_NOARGS },
1325     { .ml_name = "pmGetOptionStart_sec",
1326         .ml_meth = (PyCFunction) getOptionStart_sec,
1327         .ml_flags = METH_NOARGS },
1328     { .ml_name = "pmGetOptionStart_usec",
1329         .ml_meth = (PyCFunction) getOptionStart_usec,
1330         .ml_flags = METH_NOARGS },
1331     { .ml_name = "pmGetOptionAlign_optarg",
1332         .ml_meth = (PyCFunction) getOptionAlign_optarg,
1333         .ml_flags = METH_NOARGS },
1334     { .ml_name = "pmGetOptionFinish_optarg",
1335         .ml_meth = (PyCFunction) getOptionFinish_optarg,
1336         .ml_flags = METH_NOARGS },
1337     { .ml_name = "pmGetOptionFinish_sec",
1338         .ml_meth = (PyCFunction) getOptionFinish_sec,
1339         .ml_flags = METH_NOARGS },
1340     { .ml_name = "pmGetOptionFinish_usec",
1341         .ml_meth = (PyCFunction) getOptionFinish_usec,
1342         .ml_flags = METH_NOARGS },
1343     { .ml_name = "pmGetOptionOrigin_sec",
1344         .ml_meth = (PyCFunction) getOptionOrigin_sec,
1345         .ml_flags = METH_NOARGS },
1346     { .ml_name = "pmGetOptionOrigin_usec",
1347         .ml_meth = (PyCFunction) getOptionOrigin_usec,
1348         .ml_flags = METH_NOARGS },
1349     { .ml_name = "pmGetOptionInterval_sec",
1350         .ml_meth = (PyCFunction) getOptionInterval_sec,
1351         .ml_flags = METH_NOARGS },
1352     { .ml_name = "pmGetOptionInterval_usec",
1353         .ml_meth = (PyCFunction) getOptionInterval_usec,
1354         .ml_flags = METH_NOARGS },
1355     { .ml_name = "pmSetOptionInterval",
1356         .ml_meth = (PyCFunction) setOptionInterval,
1357         .ml_flags = METH_VARARGS | METH_KEYWORDS },
1358     { .ml_name = "pmGetOptionSamples",
1359         .ml_meth = (PyCFunction) getOptionSamples,
1360         .ml_flags = METH_NOARGS },
1361     { .ml_name = "pmSetOptionSamples",
1362         .ml_meth = (PyCFunction) setOptionSamples,
1363         .ml_flags = METH_VARARGS | METH_KEYWORDS },
1364     { .ml_name = "pmGetOptionTimezone",
1365         .ml_meth = (PyCFunction) getOptionTimezone,
1366         .ml_flags = METH_NOARGS },
1367     { .ml_name = "pmGetOptionHostZone",
1368         .ml_meth = (PyCFunction) getOptionHostZone,
1369         .ml_flags = METH_NOARGS },
1370     { .ml_name = "pmGetOptionContainer",
1371         .ml_meth = (PyCFunction) getOptionContainer,
1372         .ml_flags = METH_NOARGS },
1373     { .ml_name = "pmGetOptionLocalPMDA",
1374         .ml_meth = (PyCFunction) getOptionLocalPMDA,
1375         .ml_flags = METH_NOARGS },
1376     { .ml_name = "pmSetOptionArchive",
1377         .ml_meth = (PyCFunction) setOptionArchive,
1378         .ml_flags = METH_VARARGS | METH_KEYWORDS },
1379     { .ml_name = "pmSetOptionArchiveList",
1380         .ml_meth = (PyCFunction) setOptionArchiveList,
1381         .ml_flags = METH_VARARGS | METH_KEYWORDS },
1382     { .ml_name = "pmSetOptionArchiveFolio",
1383         .ml_meth = (PyCFunction) setOptionArchiveFolio,
1384         .ml_flags = METH_VARARGS | METH_KEYWORDS },
1385     { .ml_name = "pmSetOptionContainer",
1386         .ml_meth = (PyCFunction) setOptionContainer,
1387         .ml_flags = METH_VARARGS | METH_KEYWORDS },
1388     { .ml_name = "pmSetOptionHost",
1389         .ml_meth = (PyCFunction) setOptionHost,
1390         .ml_flags = METH_VARARGS | METH_KEYWORDS },
1391     { .ml_name = "pmSetOptionHostList",
1392         .ml_meth = (PyCFunction) setOptionHostList,
1393         .ml_flags = METH_VARARGS | METH_KEYWORDS },
1394     { .ml_name = "pmSetOptionSpecLocal",
1395         .ml_meth = (PyCFunction) setOptionSpecLocal,
1396         .ml_flags = METH_VARARGS | METH_KEYWORDS },
1397     { .ml_name = "pmSetOptionLocalPMDA",
1398         .ml_meth = (PyCFunction) setOptionLocalPMDA,
1399         .ml_flags = METH_VARARGS | METH_KEYWORDS },
1400     { .ml_name = "pmnsTraverse",
1401         .ml_meth = (PyCFunction) pmnsTraverse,
1402         .ml_flags = METH_VARARGS | METH_KEYWORDS },
1403     { NULL }
1404 };
1405
1406 /* called when the module is initialized. */
1407 MOD_INIT(cpmapi)
1408 {
1409     PyObject *module, *dict, *edict;
1410
1411     MOD_DEF(module, "cpmapi", NULL, methods);
1412     if (module == NULL)
1413         return MOD_ERROR_VAL;
1414
1415     dict = PyModule_GetDict(module);
1416     edict = PyDict_New();
1417     Py_INCREF(edict);
1418     PyModule_AddObject(module, "pmErrSymDict", edict);
1419
1420     dict_add(dict, "PMAPI_VERSION_2", PMAPI_VERSION_2);
1421     dict_add(dict, "PMAPI_VERSION", PMAPI_VERSION);
1422
1423     dict_add_unsigned(dict, "PM_ID_NULL", PM_ID_NULL);
1424     dict_add_unsigned(dict, "PM_INDOM_NULL", PM_INDOM_NULL);
1425     dict_add_unsigned(dict, "PM_IN_NULL", PM_IN_NULL);
1426
1427     dict_add_unsigned(dict, "PM_NS_DEFAULT", 0);
1428
1429 #ifdef HAVE_BITFIELDS_LTOR
1430     dict_add(dict, "HAVE_BITFIELDS_LTOR", 1);
1431     dict_add(dict, "HAVE_BITFIELDS_RTOL", 0);
1432 #else
1433     dict_add(dict, "HAVE_BITFIELDS_LTOR", 0);
1434     dict_add(dict, "HAVE_BITFIELDS_RTOL", 1);
1435 #endif
1436     dict_add(dict, "SIZEOF_SUSECONDS_T", SIZEOF_SUSECONDS_T);
1437     dict_add(dict, "SIZEOF_TIME_T", SIZEOF_TIME_T);
1438
1439     dict_add(dict, "PM_SPACE_BYTE", PM_SPACE_BYTE);
1440     dict_add(dict, "PM_SPACE_KBYTE", PM_SPACE_KBYTE);
1441     dict_add(dict, "PM_SPACE_MBYTE", PM_SPACE_MBYTE);
1442     dict_add(dict, "PM_SPACE_GBYTE", PM_SPACE_GBYTE);
1443     dict_add(dict, "PM_SPACE_TBYTE", PM_SPACE_TBYTE);
1444     dict_add(dict, "PM_SPACE_PBYTE", PM_SPACE_PBYTE);
1445     dict_add(dict, "PM_SPACE_EBYTE", PM_SPACE_EBYTE);
1446
1447     dict_add(dict, "PM_TIME_NSEC", PM_TIME_NSEC);
1448     dict_add(dict, "PM_TIME_USEC", PM_TIME_USEC);
1449     dict_add(dict, "PM_TIME_MSEC", PM_TIME_MSEC);
1450     dict_add(dict, "PM_TIME_SEC", PM_TIME_SEC);
1451     dict_add(dict, "PM_TIME_MIN", PM_TIME_MIN);
1452     dict_add(dict, "PM_TIME_HOUR", PM_TIME_HOUR);
1453     dict_add(dict, "PM_COUNT_ONE", PM_COUNT_ONE);
1454
1455     dict_add(dict, "PM_TYPE_NOSUPPORT", PM_TYPE_NOSUPPORT);
1456     dict_add(dict, "PM_TYPE_32", PM_TYPE_32);
1457     dict_add(dict, "PM_TYPE_U32", PM_TYPE_U32);
1458     dict_add(dict, "PM_TYPE_64", PM_TYPE_64);
1459     dict_add(dict, "PM_TYPE_U64", PM_TYPE_U64);
1460     dict_add(dict, "PM_TYPE_FLOAT", PM_TYPE_FLOAT);
1461     dict_add(dict, "PM_TYPE_DOUBLE", PM_TYPE_DOUBLE);
1462     dict_add(dict, "PM_TYPE_STRING", PM_TYPE_STRING);
1463     dict_add(dict, "PM_TYPE_AGGREGATE", PM_TYPE_AGGREGATE);
1464     dict_add(dict, "PM_TYPE_AGGREGATE_STATIC", PM_TYPE_AGGREGATE_STATIC);
1465     dict_add(dict, "PM_TYPE_EVENT", PM_TYPE_EVENT);
1466     dict_add(dict, "PM_TYPE_HIGHRES_EVENT", PM_TYPE_HIGHRES_EVENT);
1467     dict_add(dict, "PM_TYPE_UNKNOWN", PM_TYPE_UNKNOWN);
1468
1469     dict_add(dict, "PM_SEM_COUNTER", PM_SEM_COUNTER);
1470     dict_add(dict, "PM_SEM_INSTANT", PM_SEM_INSTANT);
1471     dict_add(dict, "PM_SEM_DISCRETE", PM_SEM_DISCRETE);
1472
1473     dict_add(dict, "PMNS_LOCAL", PMNS_LOCAL);
1474     dict_add(dict, "PMNS_REMOTE", PMNS_REMOTE);
1475     dict_add(dict, "PMNS_ARCHIVE", PMNS_ARCHIVE);
1476     dict_add(dict, "PMNS_LEAF_STATUS", PMNS_LEAF_STATUS);
1477     dict_add(dict, "PMNS_NONLEAF_STATUS", PMNS_NONLEAF_STATUS);
1478
1479     dict_add(dict, "PM_CONTEXT_UNDEF", PM_CONTEXT_UNDEF);
1480     dict_add(dict, "PM_CONTEXT_HOST", PM_CONTEXT_HOST);
1481     dict_add(dict, "PM_CONTEXT_ARCHIVE", PM_CONTEXT_ARCHIVE);
1482     dict_add(dict, "PM_CONTEXT_LOCAL", PM_CONTEXT_LOCAL);
1483     dict_add(dict, "PM_CONTEXT_TYPEMASK", PM_CONTEXT_TYPEMASK);
1484     dict_add(dict, "PM_CTXFLAG_EXCLUSIVE", PM_CTXFLAG_EXCLUSIVE);
1485     dict_add(dict, "PM_CTXFLAG_SECURE", PM_CTXFLAG_SECURE);
1486     dict_add(dict, "PM_CTXFLAG_COMPRESS", PM_CTXFLAG_COMPRESS);
1487     dict_add(dict, "PM_CTXFLAG_RELAXED", PM_CTXFLAG_RELAXED);
1488
1489     dict_add(dict, "PM_VAL_HDR_SIZE", PM_VAL_HDR_SIZE);
1490     dict_add(dict, "PM_VAL_VLEN_MAX", PM_VAL_VLEN_MAX);
1491     dict_add(dict, "PM_VAL_INSITU", PM_VAL_INSITU);
1492     dict_add(dict, "PM_VAL_DPTR",   PM_VAL_DPTR);
1493     dict_add(dict, "PM_VAL_SPTR",   PM_VAL_SPTR);
1494
1495     dict_add(dict, "PMCD_NO_CHANGE", PMCD_NO_CHANGE);
1496     dict_add(dict, "PMCD_ADD_AGENT", PMCD_ADD_AGENT);
1497     dict_add(dict, "PMCD_RESTART_AGENT", PMCD_RESTART_AGENT);
1498     dict_add(dict, "PMCD_DROP_AGENT", PMCD_DROP_AGENT);
1499
1500     dict_add(dict, "PM_MAXERRMSGLEN", PM_MAXERRMSGLEN);
1501     dict_add(dict, "PM_TZ_MAXLEN",    PM_TZ_MAXLEN);
1502
1503     dict_add(dict, "PM_LOG_MAXHOSTLEN", PM_LOG_MAXHOSTLEN);
1504     dict_add(dict, "PM_LOG_MAGIC",    PM_LOG_MAGIC);
1505     dict_add(dict, "PM_LOG_VERS02",   PM_LOG_VERS02);
1506     dict_add(dict, "PM_LOG_VOL_TI",   PM_LOG_VOL_TI);
1507     dict_add(dict, "PM_LOG_VOL_META", PM_LOG_VOL_META);
1508
1509     dict_add(dict, "PM_MODE_LIVE",   PM_MODE_LIVE);
1510     dict_add(dict, "PM_MODE_INTERP", PM_MODE_INTERP);
1511     dict_add(dict, "PM_MODE_FORW",   PM_MODE_FORW);
1512     dict_add(dict, "PM_MODE_BACK",   PM_MODE_BACK);
1513
1514     dict_add(dict, "PM_TEXT_ONELINE", PM_TEXT_ONELINE);
1515     dict_add(dict, "PM_TEXT_HELP",    PM_TEXT_HELP);
1516
1517     dict_add(dict, "PM_XTB_FLAG", PM_XTB_FLAG);
1518
1519     dict_add(dict, "PM_OPTFLAG_INIT", PM_OPTFLAG_INIT);
1520     dict_add(dict, "PM_OPTFLAG_DONE", PM_OPTFLAG_DONE);
1521     dict_add(dict, "PM_OPTFLAG_MULTI", PM_OPTFLAG_MULTI);
1522     dict_add(dict, "PM_OPTFLAG_USAGE_ERR", PM_OPTFLAG_USAGE_ERR);
1523     dict_add(dict, "PM_OPTFLAG_RUNTIME_ERR", PM_OPTFLAG_RUNTIME_ERR);
1524     dict_add(dict, "PM_OPTFLAG_EXIT", PM_OPTFLAG_EXIT);
1525     dict_add(dict, "PM_OPTFLAG_POSIX", PM_OPTFLAG_POSIX);
1526     dict_add(dict, "PM_OPTFLAG_MIXED", PM_OPTFLAG_MIXED);
1527     dict_add(dict, "PM_OPTFLAG_ENV_ONLY", PM_OPTFLAG_ENV_ONLY);
1528     dict_add(dict, "PM_OPTFLAG_LONG_ONLY", PM_OPTFLAG_LONG_ONLY);
1529     dict_add(dict, "PM_OPTFLAG_BOUNDARIES", PM_OPTFLAG_BOUNDARIES);
1530     dict_add(dict, "PM_OPTFLAG_STDOUT_TZ", PM_OPTFLAG_STDOUT_TZ);
1531     dict_add(dict, "PM_OPTFLAG_NOFLUSH", PM_OPTFLAG_NOFLUSH);
1532     dict_add(dict, "PM_OPTFLAG_QUIET", PM_OPTFLAG_QUIET);
1533
1534     dict_add(dict, "PM_EVENT_FLAG_POINT",  PM_EVENT_FLAG_POINT);
1535     dict_add(dict, "PM_EVENT_FLAG_START",  PM_EVENT_FLAG_START);
1536     dict_add(dict, "PM_EVENT_FLAG_END",    PM_EVENT_FLAG_END);
1537     dict_add(dict, "PM_EVENT_FLAG_ID",     PM_EVENT_FLAG_ID);
1538     dict_add(dict, "PM_EVENT_FLAG_PARENT", PM_EVENT_FLAG_PARENT);
1539     dict_add(dict, "PM_EVENT_FLAG_MISSED", PM_EVENT_FLAG_MISSED);
1540
1541     /*
1542      * subset of the debug flags - all of 'em seems like overkill
1543      * order here the same as the output from pmdbg -l
1544      */
1545     dict_add(dict, "PM_DEBUG_APPL0", DBG_TRACE_APPL0);
1546     dict_add(dict, "PM_DEBUG_APPL1", DBG_TRACE_APPL1);
1547     dict_add(dict, "PM_DEBUG_APPL2", DBG_TRACE_APPL2);
1548
1549     /*
1550      * for ease of maintenance make the order of the error codes
1551      * here the same as the output from pmerr -l
1552      */
1553     edict_add(dict, edict, "PM_ERR_GENERIC", PM_ERR_GENERIC);
1554     edict_add(dict, edict, "PM_ERR_PMNS", PM_ERR_PMNS);
1555     edict_add(dict, edict, "PM_ERR_NOPMNS", PM_ERR_NOPMNS);
1556     edict_add(dict, edict, "PM_ERR_DUPPMNS", PM_ERR_DUPPMNS);
1557     edict_add(dict, edict, "PM_ERR_TEXT", PM_ERR_TEXT);
1558     edict_add(dict, edict, "PM_ERR_APPVERSION", PM_ERR_APPVERSION);
1559     edict_add(dict, edict, "PM_ERR_VALUE", PM_ERR_VALUE);
1560     edict_add(dict, edict, "PM_ERR_TIMEOUT", PM_ERR_TIMEOUT);
1561     edict_add(dict, edict, "PM_ERR_NODATA", PM_ERR_NODATA);
1562     edict_add(dict, edict, "PM_ERR_RESET", PM_ERR_RESET);
1563     edict_add(dict, edict, "PM_ERR_NAME", PM_ERR_NAME);
1564     edict_add(dict, edict, "PM_ERR_PMID", PM_ERR_PMID);
1565     edict_add(dict, edict, "PM_ERR_INDOM", PM_ERR_INDOM);
1566     edict_add(dict, edict, "PM_ERR_INST", PM_ERR_INST);
1567     edict_add(dict, edict, "PM_ERR_TYPE", PM_ERR_TYPE);
1568     edict_add(dict, edict, "PM_ERR_UNIT", PM_ERR_UNIT);
1569     edict_add(dict, edict, "PM_ERR_CONV", PM_ERR_CONV);
1570     edict_add(dict, edict, "PM_ERR_TRUNC", PM_ERR_TRUNC);
1571     edict_add(dict, edict, "PM_ERR_SIGN", PM_ERR_SIGN);
1572     edict_add(dict, edict, "PM_ERR_PROFILE", PM_ERR_PROFILE);
1573     edict_add(dict, edict, "PM_ERR_IPC", PM_ERR_IPC);
1574     edict_add(dict, edict, "PM_ERR_EOF", PM_ERR_EOF);
1575     edict_add(dict, edict, "PM_ERR_NOTHOST", PM_ERR_NOTHOST);
1576     edict_add(dict, edict, "PM_ERR_EOL", PM_ERR_EOL);
1577     edict_add(dict, edict, "PM_ERR_MODE", PM_ERR_MODE);
1578     edict_add(dict, edict, "PM_ERR_LABEL", PM_ERR_LABEL);
1579     edict_add(dict, edict, "PM_ERR_LOGREC", PM_ERR_LOGREC);
1580     edict_add(dict, edict, "PM_ERR_LOGFILE", PM_ERR_LOGFILE);
1581     edict_add(dict, edict, "PM_ERR_NOTARCHIVE", PM_ERR_NOTARCHIVE);
1582     edict_add(dict, edict, "PM_ERR_NOCONTEXT", PM_ERR_NOCONTEXT);
1583     edict_add(dict, edict, "PM_ERR_PROFILESPEC", PM_ERR_PROFILESPEC);
1584     edict_add(dict, edict, "PM_ERR_PMID_LOG", PM_ERR_PMID_LOG);
1585     edict_add(dict, edict, "PM_ERR_INDOM_LOG", PM_ERR_INDOM_LOG);
1586     edict_add(dict, edict, "PM_ERR_INST_LOG", PM_ERR_INST_LOG);
1587     edict_add(dict, edict, "PM_ERR_NOPROFILE", PM_ERR_NOPROFILE);
1588     edict_add(dict, edict, "PM_ERR_NOAGENT", PM_ERR_NOAGENT);
1589     edict_add(dict, edict, "PM_ERR_PERMISSION", PM_ERR_PERMISSION);
1590     edict_add(dict, edict, "PM_ERR_CONNLIMIT", PM_ERR_CONNLIMIT);
1591     edict_add(dict, edict, "PM_ERR_AGAIN", PM_ERR_AGAIN);
1592     edict_add(dict, edict, "PM_ERR_ISCONN", PM_ERR_ISCONN);
1593     edict_add(dict, edict, "PM_ERR_NOTCONN", PM_ERR_NOTCONN);
1594     edict_add(dict, edict, "PM_ERR_NEEDPORT", PM_ERR_NEEDPORT);
1595     edict_add(dict, edict, "PM_ERR_NONLEAF", PM_ERR_NONLEAF);
1596     edict_add(dict, edict, "PM_ERR_PMDAREADY", PM_ERR_PMDAREADY);
1597     edict_add(dict, edict, "PM_ERR_PMDANOTREADY", PM_ERR_PMDANOTREADY);
1598     edict_add(dict, edict, "PM_ERR_TOOSMALL", PM_ERR_TOOSMALL);
1599     edict_add(dict, edict, "PM_ERR_TOOBIG", PM_ERR_TOOBIG);
1600     edict_add(dict, edict, "PM_ERR_FAULT", PM_ERR_FAULT);
1601     edict_add(dict, edict, "PM_ERR_THREAD", PM_ERR_THREAD);
1602     edict_add(dict, edict, "PM_ERR_NOCONTAINER", PM_ERR_NOCONTAINER);
1603     edict_add(dict, edict, "PM_ERR_BADSTORE", PM_ERR_BADSTORE);
1604     edict_add(dict, edict, "PM_ERR_LOGOVERLAP", PM_ERR_LOGOVERLAP);
1605     edict_add(dict, edict, "PM_ERR_LOGHOST", PM_ERR_LOGHOST);
1606     edict_add(dict, edict, "PM_ERR_LOGCHANGETYPE", PM_ERR_LOGCHANGETYPE);
1607     edict_add(dict, edict, "PM_ERR_LOGCHANGESEM", PM_ERR_LOGCHANGESEM);
1608     edict_add(dict, edict, "PM_ERR_LOGCHANGEINDOM", PM_ERR_LOGCHANGEINDOM);
1609     edict_add(dict, edict, "PM_ERR_LOGCHANGEUNITS", PM_ERR_LOGCHANGEUNITS);
1610     edict_add(dict, edict, "PM_ERR_NEEDCLIENTCERT", PM_ERR_NEEDCLIENTCERT);
1611     edict_add(dict, edict, "PM_ERR_NYI", PM_ERR_NYI);
1612
1613     return MOD_SUCCESS_VAL(module);
1614 }