bindings/tcl/tclrrd.c

   1 /*
   2  * tclrrd.c -- A TCL interpreter extension to access the RRD library.
   3  *
   4  * Copyright (c) 1999,2000 Frank Strauss, Technical University of Braunschweig.
   5  *
   6  * Thread-safe code copyright (c) 2005 Oleg Derevenetz, CenterTelecom Voronezh ISP.
   7  *
   8  * See the file "COPYING" for information on usage and redistribution
   9  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  10  *
  11  * $Id$
  12  */
  13
  14
  15
  16 #include <errno.h>
  17 #include <string.h>
  18 #include <time.h>
  19 #include <unistd.h>
  20 #include <tcl.h>
  21 #include <rrd_tool.h>
  22 #include <rrd_format.h>
  23
  24 /* support pre-8.4 tcl */
  25
  26 #ifndef CONST84
  27 #   define CONST84
  28 #endif
  29
  30 extern int Tclrrd_Init(Tcl_Interp *interp);
  31 extern int Tclrrd_SafeInit(Tcl_Interp *interp);
  32
  33
  34 /*
  35  * some rrd_XXX() and new thread-safe versions of Rrd_XXX()
  36  * functions might modify the argv strings passed to it.
  37  * Hence, we need to do some preparation before
  38  * calling the rrd library functions.
  39  */
  40 static char ** getopt_init(int argc, CONST84 char *argv[])
  41 {
  42     char **argv2;
  43     int i;
  44
  45     argv2 = calloc(argc, sizeof(char *));
  46     for (i = 0; i < argc; i++) {
  47         argv2[i] = strdup(argv[i]);
  48     }
  49     return argv2;
  50 }
  51
  52 static void getopt_cleanup(int argc, char **argv2)
  53 {
  54     int i;
  55
  56     for (i = 0; i < argc; i++) {
  57         if (argv2[i] != NULL) {
  58             free(argv2[i]);
  59         }
  60     }
  61     free(argv2);
  62 }
  63
  64 static void getopt_free_element(argv2, argn)
  65     char *argv2[];
  66     int  argn;
  67 {
  68     if (argv2[argn] != NULL) {
  69         free(argv2[argn]);
  70         argv2[argn] = NULL;
  71     }
  72 }
  73
  74 static void getopt_squieeze(argc, argv2)
  75     int  *argc;
  76     char *argv2[];
  77 {
  78     int i, null_i = 0, argc_tmp = *argc;
  79
  80     for (i = 0; i < argc_tmp; i++) {
  81         if (argv2[i] == NULL) {
  82             (*argc)--;
  83         } else {
  84             argv2[null_i++] = argv2[i];
  85         }
  86     }
  87 }
  88
  89
  90
  91 /* Thread-safe version */
  92 static int
  93 Rrd_Create(ClientData clientData, Tcl_Interp *interp, int argc, CONST84 char *argv[])
  94 {
  95     int                         argv_i;
  96     char                        **argv2;
  97     char                        *parsetime_error = NULL;
  98     time_t                      last_up = time(NULL) - 10;
  99     long int                    long_tmp;
 100     unsigned long int           pdp_step = 300;
 101     struct rrd_time_value       last_up_tv;
 102
 103     argv2 = getopt_init(argc, argv);
 104
 105     for (argv_i = 1; argv_i < argc; argv_i++) {
 106         if (!strcmp(argv2[argv_i], "--start") || !strcmp(argv2[argv_i], "-b")) {
 107             if (argv_i++>=argc) {
 108                 Tcl_AppendResult(interp, "RRD Error: option '",
 109                                  argv2[argv_i - 1], "' needs an argument", (char *) NULL);
 110                 getopt_cleanup(argc, argv2);
 111                 return TCL_ERROR;
 112             }
 113             if ((parsetime_error = parsetime(argv2[argv_i], &last_up_tv))) {
 114                 Tcl_AppendResult(interp, "RRD Error: invalid time format: '",
 115                                  argv2[argv_i], "'", (char *) NULL);
 116                 getopt_cleanup(argc, argv2);
 117                 return TCL_ERROR;
 118             }
 119             if (last_up_tv.type == RELATIVE_TO_END_TIME ||
 120                 last_up_tv.type == RELATIVE_TO_START_TIME) {
 121                 Tcl_AppendResult(interp, "RRD Error: specifying time relative to the 'start' ",
 122                                  "or 'end' makes no sense here", (char *) NULL);
 123                 getopt_cleanup(argc, argv2);
 124                 return TCL_ERROR;
 125             }
 126             last_up = mktime(&last_up_tv.tm) + last_up_tv.offset;
 127             if (last_up < 3600*24*365*10) {
 128                 Tcl_AppendResult(interp, "RRD Error: the first entry to the RRD should be after 1980",
 129                                  (char *) NULL);
 130                 getopt_cleanup(argc, argv2);
 131                 return TCL_ERROR;
 132             }
 133             getopt_free_element(argv2, argv_i - 1);
 134             getopt_free_element(argv2, argv_i);
 135         } else if (!strcmp(argv2[argv_i], "--step") || !strcmp(argv2[argv_i], "-s")) {
 136             if (argv_i++>=argc) {
 137                 Tcl_AppendResult(interp, "RRD Error: option '",
 138                                  argv2[argv_i - 1], "' needs an argument", (char *) NULL);
 139                 getopt_cleanup(argc, argv2);
 140                 return TCL_ERROR;
 141             }
 142             long_tmp = atol(argv2[argv_i]);
 143             if (long_tmp < 1) {
 144                 Tcl_AppendResult(interp, "RRD Error: step size should be no less than one second",
 145                                  (char *) NULL);
 146                 getopt_cleanup(argc, argv2);
 147                 return TCL_ERROR;
 148             }
 149             pdp_step = long_tmp;
 150             getopt_free_element(argv2, argv_i - 1);
 151             getopt_free_element(argv2, argv_i);
 152         } else if (!strcmp(argv2[argv_i], "--")) {
 153             getopt_free_element(argv2, argv_i);
 154             break;
 155         } else if (argv2[argv_i][0]=='-') {
 156             Tcl_AppendResult(interp, "RRD Error: unknown option '",
 157                              argv2[argv_i], "'", (char *) NULL);
 158             getopt_cleanup(argc, argv2);
 159             return TCL_ERROR;
 160         }
 161     }
 162
 163     getopt_squieeze(&argc, argv2);
 164
 165     if (argc < 2) {
 166         Tcl_AppendResult(interp, "RRD Error: needs rrd filename",
 167                          (char *) NULL);
 168         getopt_cleanup(argc, argv2);
 169         return TCL_ERROR;
 170     }
 171
 172     rrd_create_r(argv2[1], pdp_step, last_up, argc - 2, argv2 + 2);
 173
 174     getopt_cleanup(argc, argv2);
 175
 176     if (rrd_test_error()) {
 177         Tcl_AppendResult(interp, "RRD Error: ",
 178                          rrd_get_error(), (char *) NULL);
 179         rrd_clear_error();
 180         return TCL_ERROR;
 181     }
 182
 183     return TCL_OK;
 184 }
 185
 186
 187
 188 /* Thread-safe version */
 189 static int
 190 Rrd_Dump(ClientData clientData, Tcl_Interp *interp, int argc, CONST84 char *argv[])
 191 {
 192     if (argc < 2) {
 193         Tcl_AppendResult(interp, "RRD Error: needs rrd filename",
 194                          (char *) NULL);
 195         return TCL_ERROR;
 196     }
 197
 198     rrd_dump_r(argv[1], NULL);
 199
 200     /* NOTE: rrd_dump() writes to stdout. No interaction with TCL. */
 201
 202     if (rrd_test_error()) {
 203         Tcl_AppendResult(interp, "RRD Error: ",
 204                          rrd_get_error(), (char *) NULL);
 205         rrd_clear_error();
 206         return TCL_ERROR;
 207     }
 208
 209     return TCL_OK;
 210 }
 211
 212
 213
 214 /* Thread-safe version */
 215 static int
 216 Rrd_Last(ClientData clientData, Tcl_Interp *interp, int argc, CONST84 char *argv[])
 217 {
 218     time_t t;
 219
 220     if (argc < 2) {
 221         Tcl_AppendResult(interp, "RRD Error: needs rrd filename",
 222                          (char *) NULL);
 223         return TCL_ERROR;
 224     }
 225
 226     t = rrd_last_r(argv[1]);
 227
 228     if (rrd_test_error()) {
 229         Tcl_AppendResult(interp, "RRD Error: ",
 230                          rrd_get_error(), (char *) NULL);
 231         rrd_clear_error();
 232         return TCL_ERROR;
 233     }
 234
 235     Tcl_SetIntObj(Tcl_GetObjResult(interp), t);
 236
 237     return TCL_OK;
 238 }
 239
 240
 241
 242 /* Thread-safe version */
 243 static int
 244 Rrd_Update(ClientData clientData, Tcl_Interp *interp, int argc, CONST84 char *argv[])
 245 {
 246     int         argv_i;
 247     char        **argv2, *template = NULL;
 248
 249     argv2 = getopt_init(argc, argv);
 250
 251     for (argv_i = 1; argv_i < argc; argv_i++) {
 252         if (!strcmp(argv2[argv_i], "--template") || !strcmp(argv2[argv_i], "-t")) {
 253             if (argv_i++>=argc) {
 254                 Tcl_AppendResult(interp, "RRD Error: option '",
 255                                  argv2[argv_i - 1], "' needs an argument", (char *) NULL);
 256                 if (template != NULL) {
 257                     free(template);
 258                 }
 259                 getopt_cleanup(argc, argv2);
 260                 return TCL_ERROR;
 261             }
 262             if (template != NULL) {
 263                 free(template);
 264             }
 265             template = strdup(argv2[argv_i]);
 266             getopt_free_element(argv2, argv_i - 1);
 267             getopt_free_element(argv2, argv_i);
 268         } else if (!strcmp(argv2[argv_i], "--")) {
 269             getopt_free_element(argv2, argv_i);
 270             break;
 271         } else if (argv2[argv_i][0]=='-') {
 272             Tcl_AppendResult(interp, "RRD Error: unknown option '",
 273                              argv2[argv_i], "'", (char *) NULL);
 274             if (template != NULL) {
 275                 free(template);
 276             }
 277             getopt_cleanup(argc, argv2);
 278             return TCL_ERROR;
 279         }
 280     }
 281
 282     getopt_squieeze(&argc, argv2);
 283
 284     if (argc < 2) {
 285         Tcl_AppendResult(interp, "RRD Error: needs rrd filename",
 286                          (char *) NULL);
 287         if (template != NULL) {
 288             free(template);
 289         }
 290         getopt_cleanup(argc, argv2);
 291         return TCL_ERROR;
 292     }
 293
 294     rrd_update_r(argv2[1], template, argc - 2, argv2 + 2);
 295
 296     if (template != NULL) {
 297         free(template);
 298     }
 299     getopt_cleanup(argc, argv2);
 300
 301     if (rrd_test_error()) {
 302         Tcl_AppendResult(interp, "RRD Error: ",
 303                          rrd_get_error(), (char *) NULL);
 304         rrd_clear_error();
 305         return TCL_ERROR;
 306     }
 307
 308     return TCL_OK;
 309 }
 310
 311 static int
 312 Rrd_Lastupdate(ClientData clientData, Tcl_Interp *interp, int argc, CONST84 char *argv[])
 313   {
 314    time_t last_update;
 315    char **argv2;
 316    char **ds_namv;
 317    char **last_ds;
 318    char s[30];
 319    Tcl_Obj *listPtr;
 320    unsigned long ds_cnt, i;
 321
 322    argv2 = getopt_init(argc, argv);
 323    if (rrd_lastupdate(argc-1, argv2, &last_update,
 324        &ds_cnt, &ds_namv, &last_ds) == 0) {
 325            listPtr = Tcl_GetObjResult(interp);
 326            for (i=0; i<ds_cnt; i++) {
 327                sprintf(s, " %28s", ds_namv[i]);
 328                Tcl_ListObjAppendElement(interp, listPtr,
 329                        Tcl_NewStringObj(s, -1));
 330            sprintf(s, "\n\n%10lu:", last_update);
 331                Tcl_ListObjAppendElement(interp, listPtr,
 332                        Tcl_NewStringObj(s, -1));
 333            for (i=0; i<ds_cnt; i++) {
 334                sprintf(s, " %s", last_ds[i]);
 335                Tcl_ListObjAppendElement(interp, listPtr,
 336                        Tcl_NewStringObj(s, -1));
 337                free(last_ds[i]);
 338                free(ds_namv[i]);
 339            }
 340            sprintf(s, "\n");
 341            Tcl_ListObjAppendElement(interp, listPtr,
 342                     Tcl_NewStringObj(s, -1));
 343            free(last_ds);
 344            free(ds_namv);
 345           }
 346 }
 347
 348 static int
 349 Rrd_Fetch(ClientData clientData, Tcl_Interp *interp, int argc, CONST84 char *argv[])
 350 {
 351     time_t start, end, j;
 352     unsigned long step, ds_cnt, i, ii;
 353     rrd_value_t *data, *datai;
 354     char **ds_namv;
 355     Tcl_Obj *listPtr;
 356     char s[30];
 357     char **argv2;
 358
 359     argv2 = getopt_init(argc, argv);
 360     if (rrd_fetch(argc, argv2, &start, &end, &step,
 361                   &ds_cnt, &ds_namv, &data) != -1) {
 362         datai = data;
 363         listPtr = Tcl_GetObjResult(interp);
 364         for (j = start; j <= end; j += step) {
 365             for (ii = 0; ii < ds_cnt; ii++) {
 366                 sprintf(s, "%.2f", *(datai++));
 367                 Tcl_ListObjAppendElement(interp, listPtr,
 368                                          Tcl_NewStringObj(s, -1));
 369             }
 370         }
 371         for (i=0; i<ds_cnt; i++) free(ds_namv[i]);
 372         free(ds_namv);
 373         free(data);
 374     }
 375     getopt_cleanup(argc, argv2);
 376
 377     if (rrd_test_error()) {
 378         Tcl_AppendResult(interp, "RRD Error: ",
 379                          rrd_get_error(), (char *) NULL);
 380         rrd_clear_error();
 381         return TCL_ERROR;
 382     }
 383
 384     return TCL_OK;
 385 }
 386
 387
 388
 389 static int
 390 Rrd_Graph(ClientData clientData, Tcl_Interp *interp, int argc, CONST84 char *argv[])
 391 {
 392     Tcl_Channel channel;
 393     int mode, fd2;
 394     ClientData fd1;
 395     FILE *stream = NULL;
 396     char **calcpr = NULL;
 397     int rc, xsize, ysize;
 398     double ymin, ymax;
 399     char dimensions[50];
 400     char **argv2;
 401     CONST84 char *save;
 402
 403     /*
 404      * If the "filename" is a Tcl fileID, then arrange for rrd_graph() to write to
 405      * that file descriptor.  Will this work with windoze?  I have no idea.
 406      */
 407     if ((channel = Tcl_GetChannel(interp, argv[1], &mode)) != NULL) {
 408         /*
 409          * It >is< a Tcl fileID
 410          */
 411         if (!(mode & TCL_WRITABLE)) {
 412             Tcl_AppendResult(interp, "channel \"", argv[1],
 413                 "\" wasn't opened for writing", (char *) NULL);
 414             return TCL_ERROR;
 415         }
 416         /*
 417          * Must flush channel to make sure any buffered data is written before
 418          * rrd_graph() writes to the stream
 419          */
 420         if (Tcl_Flush(channel) != TCL_OK) {
 421             Tcl_AppendResult(interp, "flush failed for \"", argv[1], "\": ",
 422                 strerror(Tcl_GetErrno()), (char *) NULL);
 423             return TCL_ERROR;
 424         }
 425         if (Tcl_GetChannelHandle(channel, TCL_WRITABLE, &fd1) != TCL_OK) {
 426             Tcl_AppendResult(interp, "cannot get file descriptor associated with \"",
 427                 argv[1], "\"", (char *) NULL);
 428             return TCL_ERROR;
 429         }
 430         /*
 431          * Must dup() file descriptor so we can fclose(stream), otherwise the fclose()
 432          * would close Tcl's file descriptor
 433          */
 434         if ((fd2 = dup((int)fd1)) == -1) {
 435             Tcl_AppendResult(interp, "dup() failed for file descriptor associated with \"",
 436                 argv[1], "\": ", strerror(errno), (char *) NULL);
 437             return TCL_ERROR;
 438         }
 439         /*
 440          * rrd_graph() wants a FILE*
 441          */
 442         if ((stream = fdopen(fd2, "wb")) == NULL) {
 443             Tcl_AppendResult(interp, "fdopen() failed for file descriptor associated with \"",
 444                 argv[1], "\": ", strerror(errno), (char *) NULL);
 445             close(fd2);         /* plug potential file descriptor leak */
 446             return TCL_ERROR;
 447         }
 448
 449         save = argv[1];
 450         argv[1] = "-";
 451         argv2 = getopt_init(argc, argv);
 452         argv[1] = save;
 453     } else {
 454         Tcl_ResetResult(interp);        /* clear error from Tcl_GetChannel() */
 455         argv2 = getopt_init(argc, argv);
 456     }
 457
 458     rc = rrd_graph(argc, argv2, &calcpr, &xsize, &ysize, stream, &ymin, &ymax);
 459     getopt_cleanup(argc, argv2);
 460
 461     if (stream != NULL)
 462         fclose(stream);         /* plug potential malloc & file descriptor leak */
 463
 464     if (rc != -1) {
 465         sprintf(dimensions, "%d %d", xsize, ysize);
 466         Tcl_AppendResult(interp, dimensions, (char *) NULL);
 467         if (calcpr) {
 468 #if 0
 469             int i;
 470
 471             for(i = 0; calcpr[i]; i++){
 472                 printf("%s\n", calcpr[i]);
 473                 free(calcpr[i]);
 474             }
 475 #endif
 476             free(calcpr);
 477         }
 478     }
 479
 480     if (rrd_test_error()) {
 481         Tcl_AppendResult(interp, "RRD Error: ",
 482                          rrd_get_error(), (char *) NULL);
 483         rrd_clear_error();
 484         return TCL_ERROR;
 485     }
 486
 487     return TCL_OK;
 488 }
 489
 490
 491
 492 static int
 493 Rrd_Tune(ClientData clientData, Tcl_Interp *interp, int argc, CONST84 char *argv[])
 494 {
 495     char **argv2;
 496
 497     argv2 = getopt_init(argc, argv);
 498     rrd_tune(argc, argv2);
 499     getopt_cleanup(argc, argv2);
 500
 501     if (rrd_test_error()) {
 502         Tcl_AppendResult(interp, "RRD Error: ",
 503                          rrd_get_error(), (char *) NULL);
 504         rrd_clear_error();
 505         return TCL_ERROR;
 506     }
 507
 508     return TCL_OK;
 509 }
 510
 511
 512
 513 static int
 514 Rrd_Resize(ClientData clientData, Tcl_Interp *interp, int argc, CONST84 char *argv[])
 515 {
 516     char **argv2;
 517
 518     argv2 = getopt_init(argc, argv);
 519     rrd_resize(argc, argv2);
 520     getopt_cleanup(argc, argv2);
 521
 522     if (rrd_test_error()) {
 523         Tcl_AppendResult(interp, "RRD Error: ",
 524                          rrd_get_error(), (char *) NULL);
 525         rrd_clear_error();
 526         return TCL_ERROR;
 527     }
 528
 529     return TCL_OK;
 530 }
 531
 532
 533
 534 static int
 535 Rrd_Restore(ClientData clientData, Tcl_Interp *interp, int argc, CONST84 char *argv[])
 536 {
 537     char **argv2;
 538
 539     argv2 = getopt_init(argc, argv);
 540     rrd_restore(argc, argv2);
 541     getopt_cleanup(argc, argv2);
 542
 543     if (rrd_test_error()) {
 544         Tcl_AppendResult(interp, "RRD Error: ",
 545                          rrd_get_error(), (char *) NULL);
 546         rrd_clear_error();
 547         return TCL_ERROR;
 548     }
 549
 550     return TCL_OK;
 551 }
 552
 553
 554
 555 /*
 556  * The following structure defines the commands in the Rrd extension.
 557  */
 558
 559 typedef struct {
 560     char *name;                 /* Name of the command. */
 561     Tcl_CmdProc *proc;          /* Procedure for command. */
 562     int hide;                   /* Hide if safe interpreter */
 563 } CmdInfo;
 564
 565 static CmdInfo rrdCmds[] = {
 566     { "Rrd::create",     Rrd_Create,     1 }, /* Thread-safe version */
 567     { "Rrd::dump",       Rrd_Dump,       0 }, /* Thread-safe version */
 568     { "Rrd::last",       Rrd_Last,       0 }, /* Thread-safe version */
 569     { "Rrd::lastupdate", Rrd_Lastupdate, 0 }, /* Thread-safe version */
 570     { "Rrd::update",     Rrd_Update,     1 }, /* Thread-safe version */
 571     { "Rrd::fetch",      Rrd_Fetch,      0 },
 572     { "Rrd::graph",      Rrd_Graph,      1 }, /* Due to RRD's API, a safe
 573                                                 interpreter cannot create
 574                                                 a graph since it writes to
 575                                                 a filename supplied by the
 576                                                 caller */
 577     { "Rrd::tune",       Rrd_Tune,       1 },
 578     { "Rrd::resize",     Rrd_Resize,     1 },
 579     { "Rrd::restore",    Rrd_Restore,    1 },
 580     { (char *) NULL,    (Tcl_CmdProc *)  NULL, 0        }
 581 };
 582
 583
 584
 585 static int
 586 init(Tcl_Interp *interp, int safe)
 587 {
 588     CmdInfo *cmdInfoPtr;
 589     Tcl_CmdInfo info;
 590
 591     if ( Tcl_InitStubs(interp,TCL_VERSION,0) == NULL )
 592         return TCL_ERROR;
 593
 594     if (Tcl_PkgRequire(interp, "Tcl", TCL_VERSION, 1) == NULL) {
 595         return TCL_ERROR;
 596     }
 597
 598     /*
 599      * Why a global array?  In keeping with the Rrd:: namespace, why
 600      * not simply create a normal variable Rrd::version and set it?
 601      */
 602     Tcl_SetVar2(interp, "rrd", "version", VERSION, TCL_GLOBAL_ONLY);
 603
 604     for (cmdInfoPtr = rrdCmds; cmdInfoPtr->name != NULL; cmdInfoPtr++) {
 605         /*
 606          * Check if the command already exists and return an error
 607          * to ensure we detect name clashes while loading the Rrd
 608          * extension.
 609          */
 610         if (Tcl_GetCommandInfo(interp, cmdInfoPtr->name, &info)) {
 611             Tcl_AppendResult(interp, "command \"", cmdInfoPtr->name,
 612                              "\" already exists", (char *) NULL);
 613             return TCL_ERROR;
 614         }
 615         if (safe && cmdInfoPtr->hide) {
 616 #if 0
 617             /*
 618              * Turns out the one cannot hide a command in a namespace
 619              * due to a limitation of Tcl, one can only hide global
 620              * commands.  Thus, if we created the commands without
 621              * the Rrd:: namespace in a safe interpreter, then the
 622              * "unsafe" commands could be hidden -- which would allow
 623              * an owning interpreter either un-hiding them or doing
 624              * an "interp invokehidden".  If the Rrd:: namespace is
 625              * used, then it's still possible for the owning interpreter
 626              * to fake out the missing commands:
 627              *
 628              *   # Make all Rrd::* commands available in master interperter
 629              *   package require Rrd
 630              *   set safe [interp create -safe]
 631              *   # Make safe Rrd::* commands available in safe interperter
 632              *   interp invokehidden $safe -global load ./tclrrd1.2.11.so
 633              *   # Provide the safe interpreter with the missing commands
 634              *   $safe alias Rrd::update do_update $safe
 635              *   proc do_update {which_interp $args} {
 636              *     # Do some checking maybe...
 637              *       :
 638              *     return [eval Rrd::update $args]
 639              *   }
 640              *
 641              * Our solution for now is to just not create the "unsafe"
 642              * commands in a safe interpreter.
 643              */
 644             if (Tcl_HideCommand(interp, cmdInfoPtr->name, cmdInfoPtr->name) != TCL_OK)
 645                 return TCL_ERROR;
 646 #endif
 647         }
 648         else
 649             Tcl_CreateCommand(interp, cmdInfoPtr->name, cmdInfoPtr->proc,
 650                           (ClientData) NULL, (Tcl_CmdDeleteProc *) NULL);
 651     }
 652
 653     if (Tcl_PkgProvide(interp, "Rrd", VERSION) != TCL_OK) {
 654         return TCL_ERROR;
 655     }
 656
 657     return TCL_OK;
 658 }
 659
 660 int
 661 Tclrrd_Init(Tcl_Interp *interp)
 662 {
 663   return init(interp, 0);
 664 }
 665
 666 /*
 667  * See the comments above and note how few commands are considered "safe"...
 668  * Using rrdtool in a safe interpreter has very limited functionality.  It's
 669  * tempting to just return TCL_ERROR and forget about it.
 670  */
 671 int
 672 Tclrrd_SafeInit(Tcl_Interp *interp)
 673 {
 674   return init(interp, 1);
 675 }