tools/dump-jax.c

   1 /*
   2  * dump-jax.c --
   3  *
   4  *      Operations to generate JAX AgentX class files.
   5  *
   6  * Copyright (c) 2000 Frank Strauss, Technical University of Braunschweig.
   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: dump-jax.c 1455 2002-10-30 09:17:37Z schoenw $
  12  */
  13
  14 #include <config.h>
  15
  16 #include <stdlib.h>
  17 #include <stdio.h>
  18 #include <string.h>
  19 #include <ctype.h>
  20 #ifdef HAVE_UNISTD_H
  21 #include <unistd.h>
  22 #endif
  23 #ifdef HAVE_WIN_H
  24 #include "win.h"
  25 #endif
  26
  27 #include "smi.h"
  28 #include "smidump.h"
  29
  30
  31
  32 static char *package = NULL;
  33
  34
  35
  36 static struct {
  37     SmiBasetype basetype;
  38     char        *smitype;
  39     char        *javatype;
  40     char        *agentxtype;
  41 } convertType[] = {
  42     { SMI_BASETYPE_OCTETSTRING,      "Opaque",    "byte[]",    "OPAQUE" },
  43     { SMI_BASETYPE_UNSIGNED32,       "TimeTicks", "long",      "TIMETICKS" },
  44     { SMI_BASETYPE_UNSIGNED32,       "Counter",   "long",      "COUNTER32" },
  45     { SMI_BASETYPE_UNSIGNED32,       "Counter32", "long",      "COUNTER32" },
  46     { SMI_BASETYPE_OCTETSTRING,      "IpAddress", "byte[]",    "IPADDRESS" },
  47     { SMI_BASETYPE_INTEGER32,        NULL,        "int",       "INTEGER" },
  48     { SMI_BASETYPE_OCTETSTRING,      NULL,        "byte[]",    "OCTETSTRING" },
  49     { SMI_BASETYPE_OBJECTIDENTIFIER, NULL,        "AgentXOID", "OBJECTIDENTIFIER" },
  50     { SMI_BASETYPE_UNSIGNED32,       NULL,        "long",      "GAUGE32" },
  51     { SMI_BASETYPE_INTEGER64,        NULL,        "long",      "INTEGER" },
  52     { SMI_BASETYPE_UNSIGNED64,       NULL,        "long",      "COUNTER64" },
  53     { SMI_BASETYPE_ENUM,             NULL,        "int",       "INTEGER" },
  54     { SMI_BASETYPE_BITS,             NULL,        "byte[]",    "OCTETSTRING" },
  55     { SMI_BASETYPE_UNKNOWN,          NULL,        NULL,        NULL }
  56 };
  57
  58
  59
  60 static char* translate1Upper(char *m)
  61 {
  62     static char *sarray[5];
  63     static int spos = 0;
  64     char *s;
  65     int i;
  66
  67     s = sarray[spos];
  68     spos++;
  69     if (spos == 5) spos = 0;
  70     if (s) xfree(s);
  71     s = xstrdup(m);
  72     for (i = 0; s[i]; i++) {
  73         if (s[i] == '-') s[i] = '_';
  74     }
  75     if (islower((int) s[0])) {
  76         s[0] = toupper(s[0]);
  77     }
  78
  79     return s;
  80 }
  81
  82
  83
  84 static FILE * createFile(char *name, char *suffix)
  85 {
  86     char *fullname;
  87     FILE *f;
  88
  89     fullname = xmalloc(strlen(name) + (suffix ? strlen(suffix) : 0) + 2);
  90     strcpy(fullname, name);
  91     if (suffix) {
  92         strcat(fullname, suffix);
  93     }
  94     if (!access(fullname, R_OK)) {
  95         fprintf(stderr, "smidump: %s already exists\n", fullname);
  96         xfree(fullname);
  97         return NULL;
  98     }
  99     f = fopen(fullname, "w");
 100     if (!f) {
 101         fprintf(stderr, "smidump: cannot open %s for writing: ", fullname);
 102         perror(NULL);
 103         xfree(fullname);
 104         exit(1);
 105     }
 106     xfree(fullname);
 107     return f;
 108 }
 109
 110
 111
 112 static char *getJavaType(SmiType *smiType)
 113 {
 114     int i;
 115
 116     if (smiType) {
 117         for(i=0; convertType[i].basetype != SMI_BASETYPE_UNKNOWN; i++) {
 118             if (smiType->basetype == convertType[i].basetype)
 119                 return convertType[i].javatype;
 120         }
 121     }
 122
 123     return "<UNKNOWN>";
 124 }
 125
 126
 127
 128 static char *getAgentXType(SmiType *smiType)
 129 {
 130     int i;
 131     SmiType *parentType;
 132     SmiModule *smiModule;
 133
 134     if (smiType) {
 135
 136         parentType = smiGetParentType(smiType);
 137         if (parentType) {
 138             smiModule = smiGetTypeModule(parentType);
 139             if (smiModule && strlen(smiModule->name)) {
 140                 smiType = parentType;
 141             }
 142         }
 143
 144         for(i=0; convertType[i].basetype != SMI_BASETYPE_UNKNOWN; i++) {
 145             if (smiType->basetype == convertType[i].basetype) {
 146                 if (!convertType[i].smitype) {
 147                     return convertType[i].agentxtype;
 148                 }
 149                 if ((smiType->name) &&
 150                     (!strcmp(convertType[i].smitype, smiType->name))) {
 151                     return convertType[i].agentxtype;
 152                 }
 153             }
 154         }
 155     }
 156
 157     return "<UNKNOWN>";
 158 }
 159
 160
 161
 162 static int isGroup(SmiNode *smiNode)
 163 {
 164     SmiNode *childNode;
 165
 166     if (smiNode->nodekind == SMI_NODEKIND_ROW) {
 167         return 1;
 168     }
 169
 170     for(childNode = smiGetFirstChildNode(smiNode);
 171         childNode;
 172         childNode = smiGetNextChildNode(childNode)) {
 173         if (childNode->nodekind == SMI_NODEKIND_SCALAR) {
 174             return 1;
 175         }
 176     }
 177
 178     return 0;
 179 }
 180
 181
 182
 183 static int isAccessible(SmiNode *groupNode)
 184 {
 185     SmiNode *smiNode;
 186     int num = 0;
 187
 188     for (smiNode = smiGetFirstChildNode(groupNode);
 189          smiNode;
 190          smiNode = smiGetNextChildNode(smiNode)) {
 191         if ((smiNode->nodekind == SMI_NODEKIND_SCALAR
 192              || smiNode->nodekind == SMI_NODEKIND_COLUMN)
 193             && (smiNode->access == SMI_ACCESS_READ_ONLY
 194                 || smiNode->access == SMI_ACCESS_READ_WRITE)) {
 195             num++;
 196         }
 197     }
 198
 199     return num;
 200 }
 201
 202
 203
 204 static unsigned int getMaxSize(SmiType *smiType)
 205 {
 206     SmiRange *smiRange;
 207     SmiType  *parentType;
 208     unsigned int max = 0, size;
 209
 210     switch (smiType->basetype) {
 211     case SMI_BASETYPE_OCTETSTRING:
 212         size = 65535;
 213         break;
 214     case SMI_BASETYPE_OBJECTIDENTIFIER:
 215         size = 128;
 216         break;
 217     default:
 218         return 0xffffffff;
 219     }
 220
 221     for(smiRange = smiGetFirstRange(smiType);
 222         smiRange ; smiRange = smiGetNextRange(smiRange)) {
 223         if (smiRange->maxValue.value.unsigned32 > max) {
 224             max = smiRange->maxValue.value.unsigned32;
 225         }
 226     }
 227     if (max > 0 && max < size) {
 228         size = max;
 229     }
 230
 231     parentType = smiGetParentType(smiType);
 232     if (parentType) {
 233         unsigned int psize = getMaxSize(parentType);
 234         if (psize < size) {
 235             size = psize;
 236         }
 237     }
 238
 239     return size;
 240 }
 241
 242
 243
 244 static void dumpTable(SmiNode *smiNode)
 245 {
 246     FILE *f;
 247     SmiNode *parentNode, *columnNode;
 248     unsigned int i;
 249     char *vb_type;
 250
 251     parentNode = smiGetParentNode(smiNode);
 252
 253     f = createFile(translate1Upper(parentNode->name), ".java");
 254     if (! f) {
 255         return;
 256     }
 257
 258     fprintf(f,
 259             "/*\n"
 260             " * This Java file has been generated by smidump "
 261                 SMI_VERSION_STRING "." " Do not edit!\n"
 262             " * It is intended to be used within a Java AgentX sub-agent"
 263                 " environment.\n"
 264             " *\n"
 265             " * $I" "d$\n"
 266             " */\n\n");
 267
 268     fprintf(f,
 269             "/**\n"
 270             "    This class represents a Java AgentX (JAX) implementation of\n"
 271             "    the table %s defined in %s.\n"
 272             "\n"
 273             "    @version 1\n"
 274             "    @author  smidump " SMI_VERSION_STRING "\n"
 275             "    @see     AgentXTable\n"
 276             " */\n\n", parentNode->name, smiGetNodeModule(smiNode)->name);
 277
 278     if (package) {
 279         fprintf(f,
 280                 "package %s;\n\n", package);
 281     }
 282
 283     fprintf(f,
 284             "import java.util.Vector;\n"
 285             "\n"
 286             "import jax.AgentXOID;\n"
 287             "import jax.AgentXVarBind;\n"
 288             "import jax.AgentXResponsePDU;\n"
 289             "import jax.AgentXSetPhase;\n"
 290             "import jax.AgentXTable;\n"
 291             "import jax.AgentXEntry;\n"
 292             "\n");
 293
 294     fprintf(f, "public class %s extends AgentXTable\n{\n\n",
 295             translate1Upper(parentNode->name));
 296
 297     fprintf(f,
 298             "    // entry OID\n"
 299             "    private final static long[] OID = {");
 300     for (i = 0; i < smiNode->oidlen; i++) {
 301         fprintf(f, "%s%d", i ? ", " : "", smiNode->oid[i]);
 302     }
 303     fprintf(f, "};\n\n");
 304
 305     fprintf(f,
 306             "    // constructors\n"
 307             "    public %s()\n", translate1Upper(parentNode->name));
 308     fprintf(f,
 309             "    {\n"
 310             "        oid = new AgentXOID(OID);\n"
 311             "\n"
 312             "        // register implemented columns\n");
 313     for (columnNode = smiGetFirstChildNode(smiNode);
 314          columnNode;
 315          columnNode = smiGetNextChildNode(columnNode)) {
 316         if (columnNode->access >= SMI_ACCESS_READ_ONLY) {
 317             fprintf(f,
 318                     "        columns.addElement(new Long(%d));\n",
 319                     columnNode->oid[columnNode->oidlen-1]);
 320         }
 321     }
 322     fprintf(f,
 323             "    }\n\n");
 324
 325     fprintf(f,
 326             "    public %s(boolean shared)\n",
 327             translate1Upper(parentNode->name));
 328     fprintf(f,
 329             "    {\n"
 330             "        super(shared);\n"
 331             "\n"
 332             "        oid = new AgentXOID(OID);\n"
 333             "\n"
 334             "        // register implemented columns\n");
 335     for (columnNode = smiGetFirstChildNode(smiNode);
 336          columnNode;
 337          columnNode = smiGetNextChildNode(columnNode)) {
 338         if (columnNode->access >= SMI_ACCESS_READ_ONLY) {
 339             fprintf(f,
 340                     "        columns.addElement(new Long(%d));\n",
 341                     columnNode->oid[columnNode->oidlen-1]);
 342         }
 343     }
 344     fprintf(f,
 345             "    }\n\n");
 346
 347     fprintf(f,
 348             "    public AgentXVarBind getVarBind(AgentXEntry entry,"
 349                  " long column)\n");
 350     fprintf(f,
 351             "    {\n"
 352             "        AgentXOID oid = new AgentXOID(getOID(), column, entry.getInstance());\n"
 353             "\n"
 354             "        switch ((int)column) {\n");
 355
 356     for (columnNode = smiGetFirstChildNode(smiNode);
 357          columnNode;
 358          columnNode = smiGetNextChildNode(columnNode)) {
 359         if (columnNode->access >= SMI_ACCESS_NOTIFY) {
 360             fprintf(f,
 361                     "        case %d: // %s\n",
 362                     columnNode->oid[columnNode->oidlen-1],
 363                     columnNode->name);
 364             fprintf(f,
 365                     "        {\n");
 366             fprintf(f,
 367                     "            %s value = ((%s)entry).get_%s();\n",
 368                     getJavaType(smiGetNodeType(columnNode)),
 369                     translate1Upper(smiNode->name),
 370                     columnNode->name);
 371             fprintf(f,
 372                     "            return new AgentXVarBind(oid, "
 373                     "AgentXVarBind.%s, value);\n",
 374                     getAgentXType(smiGetNodeType(columnNode)));
 375
 376             fprintf(f,
 377                     "        }\n");
 378         }
 379     }
 380
 381     fprintf(f,
 382             "        }\n"
 383             "\n"
 384             "        return null;\n"
 385             "    }\n\n");
 386
 387     fprintf(f,
 388             "    public int setEntry(AgentXSetPhase phase,\n"
 389             "                        AgentXEntry entry,\n"
 390             "                        long column,\n"
 391             "                        AgentXVarBind vb)\n");
 392     fprintf(f,
 393             "    {\n"
 394             "\n"
 395             "        switch ((int)column) {\n");
 396
 397     for (columnNode = smiGetFirstChildNode(smiNode);
 398          columnNode;
 399          columnNode = smiGetNextChildNode(columnNode)) {
 400         if (columnNode->access >= SMI_ACCESS_READ_WRITE) {
 401             fprintf(f,
 402                     "        case %d: // %s\n",
 403                     columnNode->oid[columnNode->oidlen-1],
 404                     columnNode->name);
 405             fprintf(f,
 406                     "        {\n");
 407             fprintf(f,
 408                     "            if (vb.getType() != AgentXVarBind.%s)\n"
 409                     "                return AgentXResponsePDU.WRONG_TYPE;\n",
 410                     getAgentXType(smiGetNodeType(columnNode)));
 411             vb_type = getJavaType(smiGetNodeType(columnNode));
 412             vb_type = strcmp("byte[]", vb_type) ? vb_type : "bytes";
 413             fprintf(f,
 414                     "            else\n"
 415                     "                return ((%s)entry).set_%s(phase, vb.%sValue());\n",
 416                     translate1Upper(smiNode->name),
 417                     columnNode->name,
 418                     vb_type);
 419
 420             fprintf(f,
 421                     "        }\n");
 422         }
 423     }
 424
 425     fprintf(f,
 426             "        }\n"
 427             "\n"
 428             "        return AgentXResponsePDU.NOT_WRITABLE;\n"
 429             "    }\n\n");
 430
 431     fprintf(f,
 432             "}\n\n");
 433
 434     if (fflush(f) || ferror(f)) {
 435         perror("smidump: write error");
 436         exit(1);
 437     }
 438
 439     fclose(f);
 440 }
 441
 442
 443
 444 static void dumpEntry(SmiNode *smiNode)
 445 {
 446     FILE *f;
 447     SmiNode *columnNode, *indexNode;
 448     SmiType *smiType;
 449     SmiRange *smiRange;
 450     SmiElement *element;
 451     int cnt;
 452     char *p;
 453     char init[20];
 454
 455     f = createFile(translate1Upper(smiNode->name), ".java");
 456     if (! f) {
 457         return;
 458     }
 459
 460     fprintf(f,
 461             "/*\n"
 462             " * This Java file has been generated by smidump "
 463                 SMI_VERSION_STRING "." " Do not edit!\n"
 464             " * It is intended to be used within a Java AgentX sub-agent"
 465                 " environment.\n"
 466             " *\n"
 467             " * $I" "d$\n"
 468             " */\n\n");
 469
 470     fprintf(f,
 471             "/**\n"
 472             "    This class represents a Java AgentX (JAX) implementation of\n"
 473             "    the table row %s defined in %s.\n"
 474             "\n"
 475             "    @version 1\n"
 476             "    @author  smidump " SMI_VERSION_STRING "\n"
 477             "    @see     AgentXTable, AgentXEntry\n"
 478             " */\n\n", smiNode->name, smiGetNodeModule(smiNode)->name);
 479
 480     if (package) {
 481         fprintf(f,
 482                 "package %s;\n\n", package);
 483     }
 484
 485     fprintf(f,
 486             "import jax.AgentXOID;\n"
 487             "import jax.AgentXSetPhase;\n"
 488             "import jax.AgentXResponsePDU;\n"
 489             "import jax.AgentXEntry;\n"
 490             "\n");
 491
 492     fprintf(f, "public class %s extends AgentXEntry\n{\n\n",
 493             translate1Upper(smiNode->name));
 494
 495     for (columnNode = smiGetFirstChildNode(smiNode);
 496          columnNode;
 497          columnNode = smiGetNextChildNode(columnNode)) {
 498
 499         smiType = smiGetNodeType(columnNode);
 500         if (!smiType) continue;
 501         p = getJavaType(smiType);
 502         if (!strcmp(p, "long")) {
 503             strcpy(init, "0");
 504         } else if (!strcmp(p, "int")) {
 505             strcpy(init, "0");
 506         } else if (!strcmp(p, "byte[]")) {
 507             smiRange = smiGetFirstRange(smiType);
 508             if ((smiRange && (!smiGetNextRange(smiRange)) &&
 509                  (!memcmp(&smiRange->minValue, &smiRange->maxValue,
 510                           sizeof(SmiValue))))) {
 511                 sprintf(init, "new byte[%ld]",
 512                         smiRange->maxValue.value.integer32);
 513             } else {
 514                 sprintf(init, "new byte[0]");
 515             }
 516         } else if (!strcmp(p, "AgentXOID")) {
 517             strcpy(init, "new AgentXOID()");
 518         } else {
 519             strcpy(init, "null");
 520         }
 521         fprintf(f,
 522                 "    protected %s %s = %s;\n",
 523                 getJavaType(smiGetNodeType(columnNode)),
 524                 columnNode->name,
 525                 init);
 526
 527         if (columnNode->access == SMI_ACCESS_READ_WRITE) {
 528             fprintf(f,
 529                     "    protected %s undo_%s = %s;\n",
 530                     getJavaType(smiGetNodeType(columnNode)),
 531                     columnNode->name,
 532                     init);
 533         }
 534     }
 535     for (element = smiGetFirstElement(smiNode), cnt = 0;
 536          element;
 537          element = smiGetNextElement(element)) {
 538         indexNode = smiGetElementNode(element);
 539         for (columnNode = smiGetFirstChildNode(smiNode);
 540              columnNode;
 541              columnNode = smiGetNextChildNode(columnNode)) {
 542             if (!strcmp(columnNode->name, indexNode->name))
 543                 break;
 544         }
 545         if (!columnNode) {
 546             if (!cnt) {
 547                 fprintf(f, "    // foreign indices\n");
 548             }
 549             cnt++;
 550             fprintf(f, "    protected %s %s;\n",
 551                     getJavaType(smiGetNodeType(indexNode)),
 552                     indexNode->name);
 553         }
 554     }
 555     fprintf(f, "\n");
 556
 557     fprintf(f,
 558             "    public %s(", translate1Upper(smiNode->name));
 559     for (element = smiGetFirstElement(smiNode), cnt = 0;
 560          element;
 561          element = smiGetNextElement(element)) {
 562         if (cnt) {
 563             fprintf(f, ",\n%*s", 4 + 7 + 1 + strlen(smiNode->name), " ");
 564         }
 565         cnt++;
 566         indexNode = smiGetElementNode(element);
 567         fprintf(f, "%s %s",
 568                 getJavaType(smiGetNodeType(indexNode)),
 569                 indexNode->name);
 570     }
 571     fprintf(f, ")\n"
 572             "    {\n");
 573     for (element = smiGetFirstElement(smiNode);
 574          element;
 575          element = smiGetNextElement(element)) {
 576         indexNode = smiGetElementNode(element);
 577         fprintf(f, "        this.%s = %s;\n",
 578                 indexNode->name, indexNode->name);
 579     }
 580     fprintf(f, "\n");
 581     for (element = smiGetFirstElement(smiNode);
 582          element;
 583          element = smiGetNextElement(element)) {
 584         indexNode = smiGetElementNode(element);
 585
 586         p = getJavaType(smiGetNodeType(indexNode));
 587         if (!strcmp(p, "long")) {
 588             fprintf(f, "        instance.append(%s);\n",
 589                     indexNode->name);
 590         } else if (!strcmp(p, "int")) {
 591             fprintf(f, "        instance.append(%s);\n",
 592                     indexNode->name);
 593         } else if (!strcmp(p, "byte[]")) {
 594             smiType = smiGetNodeType(indexNode);
 595             smiRange = smiGetFirstRange(smiType);
 596             if ((smiRange && (!smiGetNextRange(smiRange)) &&
 597                  (!memcmp(&smiRange->minValue, &smiRange->maxValue,
 598                           sizeof(SmiValue)))) ||
 599                 (smiNode->implied && (!smiGetNextElement(element)))) {
 600                 fprintf(f, "        instance.appendImplied(%s);\n",
 601                         indexNode->name);
 602             } else {
 603                 fprintf(f, "        instance.append(%s);\n",
 604                         indexNode->name);
 605             }
 606         } else if (!strcmp(p, "AgentXOID")) {
 607             if (smiNode->implied && (!smiGetNextElement(element))) {
 608                 fprintf(f, "        instance.appendImplied(%s);\n",
 609                         indexNode->name);
 610             } else {
 611                 fprintf(f, "        instance.append(%s);\n",
 612                         indexNode->name);
 613             }
 614         } else {
 615             fprintf(f, "        // [smidump: type of %s not supported]\n",
 616                     indexNode->name);
 617         }
 618     }
 619
 620     fprintf(f,
 621             "    }\n"
 622             "\n");
 623
 624     for (element = smiGetFirstElement(smiNode);
 625          element;
 626          element = smiGetNextElement(element)) {
 627         indexNode = smiGetElementNode(element);
 628
 629         fprintf(f,
 630                 "    public %s get_%s()\n"
 631                 "    {\n"
 632                 "        return %s;\n"
 633                 "    }\n"
 634                 "\n",
 635                 getJavaType(smiGetNodeType(indexNode)),
 636                 indexNode->name, indexNode->name);
 637     }
 638
 639     for (columnNode = smiGetFirstChildNode(smiNode);
 640          columnNode;
 641          columnNode = smiGetNextChildNode(columnNode)) {
 642         smiType = smiGetNodeType(columnNode);
 643         if (columnNode->access >= SMI_ACCESS_NOTIFY) {
 644             for (element = smiGetFirstElement(smiNode);
 645                  element;
 646                  element = smiGetNextElement(element)) {
 647                 indexNode = smiGetElementNode(element);
 648                 if (indexNode == columnNode) break;
 649             }
 650             if (!element) {
 651                 fprintf(f,
 652                         "    public %s get_%s()\n"
 653                         "    {\n"
 654                         "        return %s;\n"
 655                         "    }\n"
 656                         "\n",
 657                         getJavaType(smiType),
 658                         columnNode->name, columnNode->name);
 659             }
 660         }
 661         if (columnNode->access == SMI_ACCESS_READ_WRITE) {
 662             fprintf(f,
 663                     "    public int set_%s(AgentXSetPhase phase, %s value)\n"
 664                     "    {\n",
 665                     columnNode->name,
 666                     getJavaType(smiGetNodeType(columnNode)));
 667             fprintf(f,
 668                     "        switch (phase.getPhase()) {\n"
 669                     "        case AgentXSetPhase.TEST_SET:\n"
 670                     "            break;\n"
 671                     "        case AgentXSetPhase.COMMIT:\n"
 672                     "            undo_%s = %s;\n",
 673                     columnNode->name,
 674                     columnNode->name);
 675             if (!strcmp("byte[]", getJavaType(smiGetNodeType(columnNode)))) {
 676                 fprintf(f,
 677                         "            %s = new byte[value.length];\n"
 678                         "            for(int i = 0; i < value.length; i++)\n"
 679                         "                %s[i] = value[i];\n",
 680                         columnNode->name,
 681                         columnNode->name);
 682             } else {
 683                 fprintf(f,
 684                         "            %s = value;\n",
 685                         columnNode->name);
 686             }
 687
 688             fprintf(f,
 689                     "            break;\n"
 690                     "        case AgentXSetPhase.UNDO:\n"
 691                     "            %s = undo_%s;\n"
 692                     "            break;\n",
 693                     columnNode->name,
 694                     columnNode->name);
 695             fprintf(f,
 696                     "        case AgentXSetPhase.CLEANUP:\n");
 697             if (!strcmp("byte[]",getJavaType(smiGetNodeType(columnNode)))) {
 698                 fprintf(f,
 699                         "            undo_%s = null;\n",
 700                         columnNode->name);
 701             }
 702             fprintf(f,
 703                     "            break;\n"
 704                     "        default:\n"
 705                     "            return AgentXResponsePDU.PROCESSING_ERROR;\n"
 706                     "        }\n"
 707                     "        return AgentXResponsePDU.NO_ERROR;\n"
 708                     "    }\n");
 709         }
 710     }
 711
 712     fprintf(f,
 713             "}\n\n");
 714
 715     if (fflush(f) || ferror(f)) {
 716         perror("smidump: write error");
 717         exit(1);
 718     }
 719
 720     fclose(f);
 721 }
 722
 723 static void dumpEntryImpl(SmiNode *smiNode)
 724 {
 725     FILE *f;
 726     SmiNode *columnNode, *indexNode;
 727     SmiType *smiType;
 728     SmiElement *element;
 729     int cnt;
 730
 731     f = createFile(translate1Upper(smiNode->name), "Impl.java");
 732     if (! f) {
 733         return;
 734     }
 735
 736     fprintf(f,
 737             "/*\n"
 738             " * This Java file has been generated by smidump "
 739                 SMI_VERSION_STRING ". It\n"
 740             " * is intended to be edited by the application programmer and\n"
 741             " * to be used within a Java AgentX sub-agent environment.\n"
 742             " *\n"
 743             " * $I" "d$\n"
 744             " */\n\n");
 745     fprintf(f,
 746             "/**\n"
 747             "    This class extends the Java AgentX (JAX) implementation of\n"
 748             "    the table row %s defined in %s.\n"
 749             " */\n\n", smiNode->name, smiGetNodeModule(smiNode)->name);
 750
 751     if (package) {
 752         fprintf(f,
 753                 "package %s;\n\n", package);
 754     }
 755
 756     fprintf(f,
 757             "import jax.AgentXOID;\n"
 758             "import jax.AgentXSetPhase;\n"
 759             "import jax.AgentXResponsePDU;\n"
 760             "import jax.AgentXEntry;\n"
 761             "\n");
 762
 763     fprintf(f, "public class %sImpl extends %s\n{\n\n",
 764             translate1Upper(smiNode->name),
 765             translate1Upper(smiNode->name));
 766
 767     fprintf(f,
 768             "    // constructor\n"
 769             "    public %sImpl(", translate1Upper(smiNode->name));
 770     for (element = smiGetFirstElement(smiNode), cnt = 0;
 771          element;
 772          element = smiGetNextElement(element)) {
 773         if (cnt) {
 774             fprintf(f, ",\n%*s", 4 + 7 + 1 + strlen(smiNode->name), " ");
 775         }
 776         cnt++;
 777         indexNode = smiGetElementNode(element);
 778         fprintf(f, "%s %s",
 779                 getJavaType(smiGetNodeType(indexNode)),
 780                 indexNode->name);
 781     }
 782     fprintf(f, ")\n"
 783             "    {\n"
 784             "        super(");
 785     for (element = smiGetFirstElement(smiNode), cnt = 0;
 786          element;
 787          element = smiGetNextElement(element)) {
 788         if (cnt) {
 789             fprintf(f, ",\n%*s", 2 + strlen(smiNode->name), " ");
 790         }
 791         cnt++;
 792         indexNode = smiGetElementNode(element);
 793         fprintf(f, "%s", indexNode->name);
 794     }
 795     fprintf(f,");\n");
 796
 797     fprintf(f,
 798             "    }\n"
 799             "\n");
 800
 801     for (columnNode = smiGetFirstChildNode(smiNode);
 802          columnNode;
 803          columnNode = smiGetNextChildNode(columnNode)) {
 804         smiType = smiGetNodeType(columnNode);
 805         if (!smiType) continue;
 806         if (columnNode->access >= SMI_ACCESS_NOTIFY) {
 807             fprintf(f,
 808                     "    public %s get_%s()\n"
 809                     "    {\n"
 810                     "        return %s;\n"
 811                     "    }\n"
 812                     "\n",
 813                     getJavaType(smiType),
 814                     columnNode->name, columnNode->name);
 815         }
 816         if (columnNode->access == SMI_ACCESS_READ_WRITE) {
 817             fprintf(f,
 818                     "    public int set_%s(AgentXSetPhase phase, %s value)\n"
 819                     "    {\n",
 820                     columnNode->name,
 821                     getJavaType(smiGetNodeType(columnNode)));
 822             fprintf(f,
 823                     "        switch (phase.getPhase()) {\n"
 824                     "        case AgentXSetPhase.TEST_SET:\n"
 825                     "            break;\n"
 826                     "        case AgentXSetPhase.COMMIT:\n"
 827                     "            undo_%s = %s;\n",
 828                     columnNode->name,
 829                     columnNode->name);
 830             if (!strcmp("byte[]", getJavaType(smiGetNodeType(columnNode)))) {
 831                 fprintf(f,
 832                         "            %s = new byte[value.length];\n"
 833                         "            for(int i = 0; i < value.length; i++)\n"
 834                         "                %s[i] = value[i];\n",
 835                         columnNode->name,
 836                         columnNode->name);
 837             } else {
 838                 fprintf(f,
 839                         "            %s = value;\n",
 840                         columnNode->name);
 841             }
 842
 843             fprintf(f,
 844                     "            break;\n"
 845                     "        case AgentXSetPhase.UNDO:\n"
 846                     "            %s = undo_%s;\n"
 847                     "            break;\n",
 848                     columnNode->name,
 849                     columnNode->name);
 850             fprintf(f,
 851                     "        case AgentXSetPhase.CLEANUP:\n");
 852             if (!strcmp("byte[]",getJavaType(smiGetNodeType(columnNode)))) {
 853                 fprintf(f,
 854                         "            undo_%s = null;\n",
 855                         columnNode->name);
 856             }
 857             fprintf(f,
 858                     "            break;\n"
 859                     "        default:\n"
 860                     "            return AgentXResponsePDU.PROCESSING_ERROR;\n"
 861                     "        }\n"
 862                     "        return AgentXResponsePDU.NO_ERROR;\n"
 863                     "    }\n");
 864         }
 865     }
 866
 867     fprintf(f,
 868             "}\n\n");
 869
 870     if (fflush(f) || ferror(f)) {
 871         perror("smidump: write error");
 872         exit(1);
 873     }
 874
 875     fclose(f);
 876 }
 877
 878
 879
 880 static SmiNode *dumpScalars(SmiNode *smiNode)
 881 {
 882     FILE *f;
 883     char *vb_type;
 884     SmiNode *parentNode, *currNode;
 885     SmiType *smiType;
 886     SmiRange *smiRange;
 887     unsigned int i;
 888     char *p;
 889     char init[20];
 890
 891     parentNode = smiGetParentNode(smiNode);
 892
 893     f = createFile(translate1Upper(parentNode->name), ".java");
 894     if (! f) {
 895         return NULL;
 896     }
 897
 898     fprintf(f,
 899             "/*\n"
 900             " * This Java file has been generated by smidump "
 901                 SMI_VERSION_STRING "." " Do not edit!\n"
 902             " * It is intended to be used within a Java AgentX sub-agent"
 903             " environment.\n"
 904             " *\n"
 905             " * $I" "d$\n"
 906             " */\n\n");
 907     fprintf(f,
 908             "/**\n"
 909             "    This class represents a Java AgentX (JAX) implementation of\n"
 910             "    the scalar group %s defined in %s.\n"
 911             "\n"
 912             "    @version 1\n"
 913             "    @author  smidump " SMI_VERSION_STRING "\n"
 914             "    @see     AgentXGroup, AgentXScalars\n"
 915             " */\n\n", parentNode->name, smiGetNodeModule(smiNode)->name);
 916
 917     if (package) {
 918         fprintf(f,
 919                 "package %s;\n\n", package);
 920     }
 921
 922     fprintf(f,
 923             "import java.util.Vector;\n"
 924             "import java.util.Enumeration;\n"
 925             "import jax.AgentXOID;\n"
 926             "import jax.AgentXVarBind;\n"
 927             "import jax.AgentXSetPhase;\n"
 928             "import jax.AgentXResponsePDU;\n"
 929             "import jax.AgentXScalars;\n"
 930             "\n");
 931
 932     fprintf(f, "public class %s extends AgentXScalars\n{\n\n",
 933             translate1Upper(parentNode->name));
 934
 935     fprintf(f,
 936             "    private final static long[] %sOID = {",
 937             translate1Upper(parentNode->name));
 938     for (i = 0; i < parentNode->oidlen; i++) {
 939         fprintf(f, "%s%d", i ? ", " : "", parentNode->oid[i]);
 940     }
 941     fprintf(f, "};\n\n");
 942
 943     /* -------       variable definitions */
 944
 945     for (currNode = smiNode;
 946          currNode && (currNode->nodekind == SMI_NODEKIND_SCALAR) ;
 947          currNode = smiGetNextNode(currNode,SMI_NODEKIND_ANY)) {
 948         fprintf(f,
 949                 "    protected AgentXOID %sOID;\n"
 950                 "    protected final static long[] %sName = {",
 951                 translate1Upper(currNode->name),
 952                 translate1Upper(currNode->name)
 953                 );
 954         for (i = 0; i < currNode->oidlen; i++) {
 955             fprintf(f, "%s%d", i ? ", " : "", currNode->oid[i]);
 956         }
 957         fprintf(f, ", 0};\n");
 958
 959         smiType = smiGetNodeType(currNode);
 960         p = getJavaType(smiType);
 961         if (!strcmp(p, "long")) {
 962             strcpy(init, "0");
 963         } else if (!strcmp(p, "int")) {
 964             strcpy(init, "0");
 965         } else if (!strcmp(p, "byte[]")) {
 966             smiRange = smiGetFirstRange(smiType);
 967             if ((smiRange && (!smiGetNextRange(smiRange)) &&
 968                  (!memcmp(&smiRange->minValue, &smiRange->maxValue,
 969                           sizeof(SmiValue))))) {
 970                 sprintf(init, "new byte[%ld]",
 971                         smiRange->maxValue.value.integer32);
 972             } else {
 973                 sprintf(init, "new byte[0]");
 974             }
 975         } else if (!strcmp(p, "AgentXOID")) {
 976             strcpy(init, "new AgentXOID()");
 977         } else {
 978             strcpy(init, "null");
 979         }
 980         fprintf(f,
 981                 "    protected %s %s = %s;\n",
 982                 getJavaType(smiGetNodeType(currNode)),
 983                 currNode->name,
 984                 init);
 985
 986         if (currNode->access == SMI_ACCESS_READ_WRITE) {
 987             fprintf(f,
 988                     "    protected %s undo_%s = %s;\n",
 989                     getJavaType(smiGetNodeType(currNode)),
 990                     currNode->name,
 991                     init);
 992         }
 993     }
 994     /* -------       constructor */
 995     fprintf(f,
 996             "    public %s()\n    {\n"
 997             "        oid = new AgentXOID(%sOID);\n"
 998             "        data = new Vector();\n",
 999             translate1Upper(parentNode->name),
1000             translate1Upper(parentNode->name));
1001
1002     for (currNode = smiNode;
1003          currNode && (currNode->nodekind == SMI_NODEKIND_SCALAR) ;
1004          currNode = smiGetNextNode(currNode,SMI_NODEKIND_ANY)) {
1005         fprintf(f,
1006                 "        %sOID = new AgentXOID(%sName);\n"
1007                 "        data.addElement(%sOID);\n",
1008                 translate1Upper(currNode->name),
1009                 translate1Upper(currNode->name),
1010                 translate1Upper(currNode->name));
1011     }
1012     fprintf(f,"    }\n\n");
1013     /* -------         get & set methods */
1014     for (currNode = smiNode;
1015          currNode && (currNode->nodekind == SMI_NODEKIND_SCALAR) ;
1016          currNode = smiGetNextNode(currNode,SMI_NODEKIND_ANY)) {
1017         smiType = smiGetNodeType(currNode);
1018         if (currNode->access >= SMI_ACCESS_NOTIFY) {
1019             fprintf(f,
1020                     "    public %s get_%s()\n"
1021                     "    {\n"
1022                     "        return %s;\n"
1023                     "    }\n"
1024                     "\n",
1025                     getJavaType(smiType),
1026                     currNode->name, currNode->name);
1027         }
1028         if (currNode->access == SMI_ACCESS_READ_WRITE) {
1029             fprintf(f,
1030                     "    public int set_%s(AgentXSetPhase phase, %s value)\n"
1031                     "    {\n",
1032                     currNode->name,
1033                     getJavaType(smiGetNodeType(currNode)));
1034             fprintf(f,
1035                     "        switch (phase.getPhase()) {\n"
1036                     "        case AgentXSetPhase.TEST_SET:\n"
1037                     "            break;\n"
1038                     "        case AgentXSetPhase.COMMIT:\n"
1039                     "            undo_%s = %s;\n",
1040                     currNode->name,
1041                     currNode->name);
1042             if (!strcmp("byte[]", getJavaType(smiGetNodeType(currNode)))) {
1043                 fprintf(f,
1044                         "            %s = new byte[value.length];\n"
1045                         "            for(int i = 0; i < value.length; i++)\n"
1046                         "                %s[i] = value[i];\n",
1047                         currNode->name,
1048                         currNode->name);
1049             } else {
1050                 fprintf(f,
1051                         "            %s = value;\n",
1052                         currNode->name);
1053             }
1054
1055             fprintf(f,
1056                     "            break;\n"
1057                     "        case AgentXSetPhase.UNDO:\n"
1058                     "            %s = undo_%s;\n"
1059                     "            break;\n",
1060                     currNode->name,
1061                     currNode->name);
1062             fprintf(f,
1063                     "        case AgentXSetPhase.CLEANUP:\n");
1064             if (!strcmp("byte[]",getJavaType(smiGetNodeType(currNode)))) {
1065                 fprintf(f,
1066                         "            undo_%s = null;\n",
1067                         currNode->name);
1068             }
1069             fprintf(f,
1070                     "            break;\n"
1071                     "        default:\n"
1072                     "            return AgentXResponsePDU.PROCESSING_ERROR;\n"
1073                     "        }\n"
1074                     "        return AgentXResponsePDU.NO_ERROR;\n"
1075                     "    }\n");
1076         }
1077     }
1078     /* ------    handle get get-next and set requests */
1079     fprintf(f,
1080             "    public AgentXVarBind getScalar(AgentXOID pos,"
1081             " AgentXOID oid)\n"
1082             "    {\n"
1083             "        if ((pos == null) || (pos.compareTo(oid) != 0))\n"
1084             "            return new AgentXVarBind(oid,"
1085             " AgentXVarBind.NOSUCHOBJECT);\n"
1086             "        else {\n"
1087             );
1088     for (currNode = smiNode;
1089          currNode && (currNode->nodekind == SMI_NODEKIND_SCALAR) ;
1090          currNode = smiGetNextNode(currNode,SMI_NODEKIND_ANY)) {
1091         fprintf(f,
1092                 "            if (pos == %sOID)\n"
1093                 "                return new AgentXVarBind(oid,"
1094                 " AgentXVarBind.%s, \n"
1095                 "                                         get_%s());\n",
1096                 translate1Upper(currNode->name),
1097                 getAgentXType(smiGetNodeType(currNode)),
1098                 currNode->name
1099                 );
1100     }
1101     fprintf(f,
1102             "        }\n"
1103             "        return new AgentXVarBind(oid,"
1104             " AgentXVarBind.NOSUCHOBJECT);\n    }\n\n");
1105
1106     fprintf(f,
1107             "    public int setScalar(AgentXSetPhase phase,"
1108             " AgentXOID pos,\n"
1109             "                         AgentXVarBind inVb)\n    {\n"
1110             "        if ((pos == null) || (pos.compareTo(inVb.getOID()) != 0))\n"
1111             "            return AgentXResponsePDU.INCONSISTENT_NAME;\n"
1112             "        else {\n"
1113             );
1114
1115     for (currNode = smiNode;
1116          currNode && (currNode->nodekind == SMI_NODEKIND_SCALAR) ;
1117          currNode = smiGetNextNode(currNode,SMI_NODEKIND_ANY)) {
1118         vb_type = getJavaType(smiGetNodeType(currNode));
1119         vb_type = strcmp("byte[]", vb_type) ? vb_type : "bytes";
1120         if (currNode->access == SMI_ACCESS_READ_WRITE)
1121             fprintf(f,
1122                     "            if (pos == %sOID)\n"
1123                     "                return "
1124                     "set_%s(phase, inVb.%sValue());\n",
1125                     translate1Upper(currNode->name),
1126                     currNode->name,
1127                     vb_type
1128                     );
1129     }
1130     fprintf(f,
1131             "        }\n"
1132             "        return AgentXResponsePDU.NOT_WRITABLE;\n"
1133             "    }\n\n");
1134     fprintf(f,
1135             "    public AgentXVarBind getNextScalar(AgentXOID pos,"
1136             " AgentXOID oid)\n    {\n"
1137             "        if ((pos == null) || (pos.compareTo(oid) <= 0))\n"
1138             "            return new AgentXVarBind(oid,"
1139             " AgentXVarBind.ENDOFMIBVIEW);\n"
1140             "        else {\n"
1141             );
1142     for (currNode = smiNode;
1143          currNode && (currNode->nodekind == SMI_NODEKIND_SCALAR) ;
1144          currNode = smiGetNextNode(currNode,SMI_NODEKIND_ANY)) {
1145         fprintf(f,
1146                 "            if (pos == %sOID)\n"
1147                 "                return new AgentXVarBind(pos,"
1148                 " AgentXVarBind.%s, \n"
1149                 "                                         get_%s());\n",
1150                 translate1Upper(currNode->name),
1151                 getAgentXType(smiGetNodeType(currNode)),
1152                 currNode->name
1153                 );
1154     }
1155     fprintf(f,
1156             "        }\n"
1157             "        return new AgentXVarBind(pos,"
1158             " AgentXVarBind.ENDOFMIBVIEW);\n    }\n\n");
1159     fprintf(f,
1160             "}\n\n");
1161
1162     if (fflush(f) || ferror(f)) {
1163         perror("smidump: write error");
1164         exit(1);
1165     }
1166
1167     fclose(f);
1168     /* skip all already processed nodes */
1169     for(;
1170         smiNode && (smiNode->nodekind == SMI_NODEKIND_SCALAR);
1171         smiNode = smiGetNextNode(smiNode, SMI_NODEKIND_ANY)) {
1172     }
1173     return smiNode;
1174 }
1175
1176 static void dumpNotifications(SmiNode *smiNode)
1177 {
1178     FILE *f;
1179     int cnt;
1180     unsigned int i;
1181     SmiElement *element;
1182     SmiNode *elementNode;
1183
1184     SmiType *snt;
1185     snt = smiGetNodeType(smiNode);
1186
1187     f = createFile(translate1Upper(smiNode->name), ".java");
1188     if (! f) {
1189         return;
1190     }
1191
1192     fprintf(f,
1193             "/*\n"
1194             " * This Java file has been generated by smidump "
1195                 SMI_VERSION_STRING "." " Do not edit!\n"
1196             " * It is intended to be used within a Java AgentX sub-agent"
1197             " environment.\n"
1198             " *\n"
1199             " * $I" "d$\n"
1200             " */\n\n");
1201
1202     if (package) {
1203         fprintf(f,
1204                 "package %s;\n\n", package);
1205     }
1206
1207     fprintf(f,
1208             "import jax.AgentXOID;\n"
1209             "import jax.AgentXVarBind;\n"
1210             "import jax.AgentXNotification;\n"
1211             "import java.util.Vector;\n"
1212             "\n");
1213
1214     fprintf(f, "public class %s extends AgentXNotification\n{\n\n",
1215             translate1Upper(smiNode->name));
1216
1217     fprintf(f,
1218             "    private final static long[] %s_OID = {",
1219             smiNode->name);
1220     for (i = 0; i < smiNode->oidlen; i++) {
1221         fprintf(f, "%s%d", i ? ", " : "", smiNode->oid[i]);
1222     }
1223     fprintf(f, "};\n");
1224     fprintf(f,
1225             "    private static AgentXVarBind snmpTrapOID_VarBind =\n"
1226             "        new AgentXVarBind(snmpTrapOID_OID,\n"
1227             "                          AgentXVarBind.OBJECTIDENTIFIER,\n"
1228             "                          new AgentXOID(%s_OID));\n\n",
1229             smiNode->name);
1230
1231     for (element = smiGetFirstElement(smiNode), cnt = 1;
1232          element;
1233          element = smiGetNextElement(element), cnt++) {
1234         elementNode = smiGetElementNode(element);
1235         fprintf(f, "    private final static long[] OID%d = {", cnt);
1236         for (i = 0; i < elementNode->oidlen; i++) {
1237             fprintf(f, "%s%d", i ? ", " : "", elementNode->oid[i]);
1238         }
1239         fprintf(f,
1240                 "};\n"
1241                 "    private final AgentXOID %s_OID = "
1242                 "new AgentXOID(OID%d",
1243                 elementNode->name, cnt);
1244         fprintf(f,");\n");
1245 #if 0
1246         if (elementNode->nodekind != SMI_NODEKIND_COLUMN ||
1247             (smiGetNodeModule(elementNode) != smiGetNodeModule(smiNode))) {
1248             fprintf(f,
1249                     "    private static AgentXVarBind varBind_%s = new AgentXVarBind(\n"
1250                     "            %sOID, AgentXVarBind.%s\n);\n",
1251                     elementNode->name,
1252                     elementNode->name,
1253                     getAgentXType(smiGetNodeType(elementNode)));
1254         }
1255 #endif
1256     }
1257     fprintf(f,
1258             "\n\n    public %s(",
1259             translate1Upper(smiNode->name));
1260     for (element = smiGetFirstElement(smiNode), cnt = 0;
1261          element;
1262          element = smiGetNextElement(element)) {
1263         elementNode = smiGetElementNode(element);
1264         if (smiGetNodeModule(elementNode) == smiGetNodeModule(smiNode)) {
1265             if (cnt) fprintf(f,", ");
1266             cnt++;
1267             fprintf(f, "%s %s_%d",
1268                     translate1Upper(smiGetParentNode(elementNode)->name),
1269                     smiGetParentNode(elementNode)->name, cnt);
1270         }
1271     }
1272     fprintf(f, ") {\n"
1273             "        AgentXOID oid;\n"
1274             "        AgentXVarBind varBind;\n"
1275             "\n"
1276             "        // add the snmpTrapOID object\n"
1277             "        varBindList.addElement(snmpTrapOID_VarBind);\n");
1278     for (element = smiGetFirstElement(smiNode), cnt = 1;
1279          element;
1280          element = smiGetNextElement(element), cnt++) {
1281         elementNode = smiGetElementNode(element);
1282
1283         if (smiGetNodeModule(elementNode) == smiGetNodeModule(smiNode)) {
1284
1285             fprintf(f,
1286                     "\n        // add the %s %s object of %s_%d\n",
1287                     elementNode->name,
1288                     elementNode->nodekind == SMI_NODEKIND_COLUMN ?
1289                     "columnar" : "scalar",
1290                     smiGetParentNode(elementNode)->name, cnt);
1291
1292             if (elementNode->nodekind == SMI_NODEKIND_COLUMN) {
1293                 fprintf(f,
1294                         "        oid = %s_OID;\n"
1295                         "        oid.appendImplied(%s_%d.getInstance());\n",
1296                         elementNode->name,
1297                         smiGetParentNode(elementNode)->name, cnt);
1298                 fprintf(f,
1299                         "        varBind = new AgentXVarBind(oid,\n"
1300                         "                                    AgentXVarBind.%s,\n"
1301                         "                                    %s_%d.get_%s());\n",
1302                         getAgentXType(smiGetNodeType(elementNode)),
1303                         smiGetParentNode(elementNode)->name, cnt,
1304                         elementNode->name);
1305                 fprintf(f,
1306                         "        varBindList.addElement(varBind);\n");
1307             } else {
1308                 fprintf(f,
1309                         "        oid = %s_OID;\n",
1310                         elementNode->name);
1311                 fprintf(f,
1312                         "        oid.append(0);\n");
1313                 fprintf(f,
1314                         "        varBind = new AgentXVarBind(oid,\n"
1315                         "                                    AgentXVarBind.%s,\n"
1316                         "                                    %s_%d.get_%s());\n",
1317                         getAgentXType(smiGetNodeType(elementNode)),
1318                         smiGetParentNode(elementNode)->name, cnt,
1319                         elementNode->name);
1320                 fprintf(f,
1321                         "        varBindList.addElement(varBind);\n");
1322             }
1323
1324         } else {
1325             fprintf(f,
1326                     "        // the notification's object %s "
1327                     "is not contained in this module.\n",
1328                     elementNode->name);
1329         }
1330     }
1331
1332     fprintf(f,
1333             "    }\n\n");
1334
1335     fprintf(f,
1336             "    public Vector getVarBindList() {\n"
1337             "        return varBindList;\n    }\n\n");
1338
1339     fprintf(f,
1340             "}\n\n");
1341
1342     if (fflush(f) || ferror(f)) {
1343         perror("smidump: write error");
1344         exit(1);
1345     }
1346
1347     fclose(f);
1348 }
1349
1350 static void dumpScalarImpl(SmiNode *smiNode)
1351 {
1352     FILE *f;
1353     SmiNode *parentNode, *currNode;
1354     SmiType *smiType;
1355
1356     parentNode = smiGetParentNode(smiNode);
1357
1358     f = createFile(translate1Upper(parentNode->name), "Impl.java");
1359     if (! f) {
1360         return;
1361     }
1362
1363     fprintf(f,
1364             "/*\n"
1365             " * This Java file has been generated by smidump "
1366                 SMI_VERSION_STRING ". It\n"
1367             " * is intended to be edited by the application programmer and\n"
1368             " * to be used within a Java AgentX sub-agent environment.\n"
1369             " *\n"
1370             " * $I" "d$\n"
1371             " */\n\n");
1372     fprintf(f,
1373             "/**\n"
1374             "    This class extends the Java AgentX (JAX) implementation of\n"
1375             "    the scalar group %s defined in %s.\n"
1376             " */\n\n", parentNode->name, smiGetNodeModule(smiNode)->name);
1377
1378     if (package) {
1379         fprintf(f,
1380                 "package %s;\n\n", package);
1381     }
1382
1383     fprintf(f,
1384             "import java.util.Vector;\n"
1385             "import java.util.Enumeration;\n"
1386             "import jax.AgentXOID;\n"
1387             "import jax.AgentXSetPhase;\n"
1388             "import jax.AgentXResponsePDU;\n"
1389             "\n");
1390
1391     fprintf(f, "public class %sImpl extends %s\n{\n\n",
1392             translate1Upper(parentNode->name),
1393             translate1Upper(parentNode->name));
1394
1395     for (currNode = smiNode;
1396          currNode && (currNode->nodekind == SMI_NODEKIND_SCALAR) ;
1397          currNode = smiGetNextNode(currNode,SMI_NODEKIND_ANY)) {
1398         smiType = smiGetNodeType(currNode);
1399         if (currNode->access >= SMI_ACCESS_NOTIFY) {
1400             fprintf(f,
1401                     "    public %s get_%s()\n"
1402                     "    {\n"
1403                     "        return %s;\n"
1404                     "    }\n"
1405                     "\n",
1406                     getJavaType(smiType),
1407                     currNode->name, currNode->name);
1408         }
1409         if (currNode->access == SMI_ACCESS_READ_WRITE) {
1410             fprintf(f,
1411                     "    public int set_%s(AgentXSetPhase phase, %s value)\n"
1412                     "    {\n",
1413                     currNode->name,
1414                     getJavaType(smiGetNodeType(currNode)));
1415             fprintf(f,
1416                     "        switch (phase.getPhase()) {\n"
1417                     "        case AgentXSetPhase.TEST_SET:\n"
1418                     "            break;\n"
1419                     "        case AgentXSetPhase.COMMIT:\n"
1420                     "            undo_%s = %s;\n",
1421                     currNode->name,
1422                     currNode->name);
1423             if (!strcmp("byte[]", getJavaType(smiGetNodeType(currNode)))) {
1424                 fprintf(f,
1425                         "            %s = new byte[value.length];\n"
1426                         "            for(int i = 0; i < value.length; i++)\n"
1427                         "                %s[i] = value[i];\n",
1428                         currNode->name,
1429                         currNode->name);
1430             } else {
1431                 fprintf(f,
1432                         "            %s = value;\n",
1433                         currNode->name);
1434             }
1435             fprintf(f,
1436                     "            break;\n"
1437                     "        case AgentXSetPhase.UNDO:\n"
1438                     "            %s = undo_%s;\n"
1439                     "            break;\n",
1440                     currNode->name,
1441                     currNode->name);
1442             fprintf(f,
1443                     "        case AgentXSetPhase.CLEANUP:\n");
1444             if (!strcmp("byte[]",getJavaType(smiGetNodeType(currNode)))) {
1445                 fprintf(f,
1446                         "            undo_%s = null;\n",
1447                         currNode->name);
1448             } else {
1449                 fprintf(f,
1450                         "            undo_%s = -1; // TODO: better check!\n",
1451                         currNode->name);
1452             }
1453             fprintf(f,
1454                     "            break;\n"
1455                     "        default:\n"
1456                     "            return AgentXResponsePDU.PROCESSING_ERROR;\n"
1457                     "        }\n"
1458                     "        return AgentXResponsePDU.NO_ERROR;\n"
1459                     "    }\n"
1460                     "\n");
1461         }
1462     }
1463     fprintf(f,
1464             "}\n\n");
1465
1466     if (fflush(f) || ferror(f)) {
1467         perror("smidump: write error");
1468         exit(1);
1469     }
1470
1471     fclose(f);
1472 }
1473
1474
1475 static void dumpJax(int modc, SmiModule **modv, int flags, char *output)
1476 {
1477     SmiNode     *smiNode;
1478     int         i;
1479
1480     for (i = 0; i < modc; i++) {
1481
1482         for(smiNode = smiGetFirstNode(modv[i], SMI_NODEKIND_ROW);
1483             smiNode;
1484             smiNode = smiGetNextNode(smiNode, SMI_NODEKIND_ROW)) {
1485             if (isGroup(smiNode) && isAccessible(smiNode)) {
1486                 dumpTable(smiNode);
1487                 dumpEntry(smiNode);
1488                 dumpEntryImpl(smiNode);
1489             }
1490         }
1491
1492         for(smiNode = smiGetFirstNode(modv[i], SMI_NODEKIND_SCALAR);
1493             smiNode;
1494             smiNode = smiGetNextNode(smiNode, SMI_NODEKIND_SCALAR)) {
1495             dumpScalarImpl(smiNode);
1496             smiNode = dumpScalars(smiNode);
1497         }
1498
1499         for(smiNode = smiGetFirstNode(modv[i], SMI_NODEKIND_NOTIFICATION);
1500             smiNode;
1501             smiNode = smiGetNextNode(smiNode, SMI_NODEKIND_NOTIFICATION)) {
1502             dumpNotifications(smiNode);
1503         }
1504     }
1505 }
1506
1507
1508
1509 void initJax()
1510 {
1511     static SmidumpDriverOption opt[] = {
1512         { "package", OPT_STRING, &package, 0,
1513           "make classes part of a given package"},
1514         { 0, OPT_END, 0, 0 }
1515     };
1516
1517     static SmidumpDriver driver = {
1518         "jax",
1519         dumpJax,
1520         SMI_FLAG_NODESCR,
1521         SMIDUMP_DRIVER_CANT_UNITE | SMIDUMP_DRIVER_CANT_OUTPUT,
1522         "Java AgentX sub-agent classes in separate files",
1523         opt,
1524         NULL
1525     };
1526
1527     smidumpRegisterDriver(&driver);
1528 }