}
      target.setSecurityName(securityName);
      return target;
    }
    else {
      CommunityTarget target = new CommunityTarget();
      target.setCommunity(community);
      return target;
    }
  }

  public PDU send() throws IOException {
    Snmp snmp = createSnmpSession();
    this.target = createTarget();
    target.setVersion(version);
    target.setAddress(address);
    target.setRetries(retries);
    target.setTimeout(timeout);
    target.setMaxSizeRequestPDU(maxSizeResponsePDU);
    snmp.listen();

    PDU request = createPDU(target);
    if (request.getType() == PDU.GETBULK) {
      request.setMaxRepetitions(maxRepetitions);
      request.setNonRepeaters(nonRepeaters);
    }
    for (int i=0; i<vbs.size(); i++) {
      request.add((VariableBinding)vbs.get(i));
    }

    PDU response = null;
    if ((operation == WALK) || (operation == SNAPSHOT_CREATION)) {
      ArrayList snapshot = null;
      if (operation == SNAPSHOT_CREATION) {
        snapshot = new ArrayList();
      }
      walk(snmp, request, target, snapshot);
      if (snapshot != null) {
        createSnapshot(snapshot);
      }
      return null;
    }
    else {
      ResponseEvent responseEvent;
      long startTime = System.currentTimeMillis();
      responseEvent = snmp.send(request, target);
      if (responseEvent != null) {
        response = responseEvent.getResponse();
        System.out.println("Received response after "+
                           (System.currentTimeMillis()-startTime)+" millis");
      }
    }
    snmp.close();
    return response;
  }

  private PDU walk(Snmp snmp, PDU request, Target target, final List snapshot)
      throws IOException
  {
    request.setNonRepeaters(0);
    OID rootOID = request.get(0).getOid();
    PDU response = null;
    final WalkCounts counts = new WalkCounts();
    final long startTime = System.currentTimeMillis();
    TreeUtils treeUtils = new TreeUtils(snmp, new DefaultPDUFactory());
    TreeListener treeListener = new TreeListener() {
      public boolean next(TreeEvent e) {
        counts.requests++;
        if (e.getVariableBindings() != null) {
          VariableBinding[] vbs = e.getVariableBindings();
          counts.objects += vbs.length;
          for (int i=0; i<vbs.length; i++) {
            if (snapshot != null) {
              snapshot.add(vbs[i]);
            }
            System.out.println(vbs[i].toString());
          }
        }
        return true;
      }

      public void finished(TreeEvent e) {
        if ((e.getVariableBindings() != null) &&
            (e.getVariableBindings().length > 0)) {
          next(e);
        }
        System.out.println();
        System.out.println("Total requests sent:    "+counts.requests);
        System.out.println("Total objects received: "+counts.objects);
        System.out.println("Total walk time:        "+
                           (System.currentTimeMillis()-startTime)+" milliseconds");
        if (e.isError()) {
          System.err.println("The following error occurred during walk:");
          System.err.println(e.getErrorMessage());
        }
        synchronized(this) {
          this.notify();
        }
      }
    };
    synchronized (treeListener) {
      treeUtils.getSubtree(target, rootOID, null, treeListener);
      try {
        treeListener.wait();
      }
      catch (InterruptedException ex) {
        System.err.println("Tree retrieval interrupted: " + ex.getMessage());
        Thread.currentThread().interrupt();
      }
    }
    return response;
  }


  private static Vector getVariableBindings(String[] args, int position) {
    Vector v = new Vector(args.length-position+1);
    for (int i=position; i<args.length; i++) {
      String oid = args[i];
      char type = 'i';
      String value = null;
      int equal = oid.indexOf("={");
      if (equal > 0) {
        oid = args[i].substring(0, equal);
        type = args[i].charAt(equal+2);
        value = args[i].substring(args[i].indexOf('}')+1);
      }
      else if (oid.indexOf('-') > 0) {
        StringTokenizer st = new StringTokenizer(oid, "-");
        if (st.countTokens() != 2) {
          throw new IllegalArgumentException("Illegal OID range specified: '"+
                                             oid);
        }
        oid = st.nextToken();
        VariableBinding vbLower = new VariableBinding(new OID(oid));
        v.add(vbLower);
        long last = Long.parseLong(st.nextToken());
        long first = vbLower.getOid().lastUnsigned();
        for (long k=first+1; k<=last; k++) {
          OID nextOID = new OID(vbLower.getOid().getValue(), 0,
                                vbLower.getOid().size()-1);
          nextOID.appendUnsigned(k);
          VariableBinding next = new VariableBinding(nextOID);
          v.add(next);
        }
        continue;
      }
      VariableBinding vb = new VariableBinding(new OID(oid));
      if (value != null) {
        Variable variable;
        switch (type) {
          case 'i':
            variable = new Integer32(Integer.parseInt(value));
            break;
          case 'u':
            variable = new UnsignedInteger32(Long.parseLong(value));
            break;
          case 's':
            variable = new OctetString(value);
            break;
          case 'x':
            variable = OctetString.fromString(value, ':', 16);
            break;
          case 'd':
            variable = OctetString.fromString(value, '.', 10);
            break;
          case 'b':
            variable = OctetString.fromString(value, ' ', 2);
            break;
          case 'n':
            variable = new Null();
            break;
          case 'o':
            variable = new OID(value);
            break;
          case 't':
            variable = new TimeTicks(Long.parseLong(value));
            break;
          case 'a':
            variable = new IpAddress(value);
            break;
          default:
            throw new IllegalArgumentException("Variable type "+type+
                                               " not supported");
         }
         vb.setVariable(variable);
       }
       v.add(vb);
    }
    return v;
  }

  private static Address getAddress(String transportAddress) {
    String transport = "udp";
    int colon = transportAddress.indexOf(':');
    if (colon > 0) {
      transport = transportAddress.substring(0, colon);
      transportAddress = transportAddress.substring(colon+1);
    }
    // set default port
    if (transportAddress.indexOf('/') < 0) {
      transportAddress += "/161";
    }
    if (transport.equalsIgnoreCase("udp")) {
      return new UdpAddress(transportAddress);
    }
    else if (transport.equalsIgnoreCase("tcp")) {
      return new TcpAddress(transportAddress);
    }
    throw new IllegalArgumentException("Unknown transport "+transport);
  }

  private static String nextOption(String[] args, int position) {
    if (position+1 >= args.length) {
      throw new IllegalArgumentException("Missing option value for " +
                                         args[position]);
    }
    return args[position+1];
  }

  private static OctetString createOctetString(String s) {
    OctetString octetString;
    if (s.startsWith("0x")) {
      octetString = OctetString.fromHexString(s.substring(2), ':');
    }
    else {
      octetString = new OctetString(s);
    }
    return octetString;
  }

  private int parseArgs(String[] args) {
    for (int i=0; i<args.length; i++) {
      if (args[i].equals("-a")) {
        String s = nextOption(args, i++);
        if (s.equals("MD5")) {
          authProtocol = AuthMD5.ID;
        }
        else if (s.equals("SHA")) {
          authProtocol = AuthSHA.ID;
        }
        else {
          throw new IllegalArgumentException("Authentication protocol unsupported: "+s);
        }
      }
      else if (args[i].equals("-A")) {
       authPassphrase = createOctetString(nextOption(args, i++));
      }
      else if (args[i].equals("-X") || args[i].equals("-P")) {
       privPassphrase = createOctetString(nextOption(args, i++));
      }
      else if (args[i].equals("-c")) {
        community = createOctetString(nextOption(args, i++));
      }
      else if (args[i].equals("-b")) {
        engineBootCount = Math.max(Integer.parseInt(nextOption(args, i++)), 0);
      }
      else if (args[i].equals("-d")) {
        String debugOption = nextOption(args, i++);
        LogFactory.getLogFactory().getRootLogger().setLogLevel(
            LogLevel.toLevel(debugOption));
      }
      else if (args[i].equals("-l")) {
        localEngineID = createOctetString(nextOption(args, i++));
      }
      else if (args[i].equals("-e")) {
        authoritativeEngineID = createOctetString(nextOption(args, i++));
      }
      else if (args[i].equals("-E")) {
        contextEngineID = createOctetString(nextOption(args, i++));
      }
      else if (args[i].equals("-h")) {
        printUsage();
        System.exit(0);
      }
      else if (args[i].equals("-n")) {
        contextName = createOctetString(nextOption(args, i++));
      }
      else if (args[i].equals("-m")) {
        maxSizeResponsePDU = Integer.parseInt(nextOption(args, i++));
      }
      else if (args[i].equals("-r")) {
        retries = Integer.parseInt(nextOption(args, i++));
      }
      else if (args[i].equals("-t")) {
        timeout = Integer.parseInt(nextOption(args, i++));
      }
      else if (args[i].equals("-u")) {
        securityName = createOctetString(nextOption(args, i++));
      }
      else if (args[i].equals("-V")) {
        printVersion();
        System.exit(0);
      }
      else if (args[i].equals("-Cr")) {
        maxRepetitions = Integer.parseInt(nextOption(args, i++));
      }
      else if (args[i].equals("-Cn")) {
        nonRepeaters = Integer.parseInt(nextOption(args, i++));
      }
      else if (args[i].equals("-Ce")) {
        v1TrapPDU.setEnterprise(new OID(nextOption(args, i++)));
      }
      else if (args[i].equals("-Ct")) {
        trapOID = new OID(nextOption(args, i++));
      }
      else if (args[i].equals("-Cg")) {
        v1TrapPDU.setGenericTrap(Integer.parseInt(nextOption(args, i++)));
      }
      else if (args[i].equals("-Cs")) {
        v1TrapPDU.setSpecificTrap(Integer.parseInt(nextOption(args, i++)));
      }
      else if (args[i].equals("-Ca")) {
        v1TrapPDU.setAgentAddress(new IpAddress(nextOption(args, i++)));
      }
      else if (args[i].equals("-Cu")) {
        String upTime = nextOption(args, i++);
        v1TrapPDU.setTimestamp(Long.parseLong(upTime));
        sysUpTime.setValue(Long.parseLong(upTime));
      }
      else if (args[i].equals("-Ow")) {
        operation = WALK;
      }
      else if (args[i].equals("-Ocs")) {
        operation = SNAPSHOT_CREATION;
        snapshotFile = new File(nextOption(args, i++));
        if (!snapshotFile.canWrite() && snapshotFile.exists()) {
          throw new IllegalArgumentException("Snapshot file '"+snapshotFile+
                                             "' cannot be written");
        }
      }
      else if (args[i].equals("-Ods")) {
        operation = SNAPSHOT_DUMP;
        snapshotFile = new File(nextOption(args, i++));
        if (!snapshotFile.canRead()) {
          throw new IllegalArgumentException("Snapshot file '"+snapshotFile+
                                             "' cannot be read");
        }
      }
      else if (args[i].equals("-Ol")) {
        operation = LISTEN;
      }
      else if (args[i].equals("-OtCSV")) {
        operation = CVS_TABLE;
      }
      else if (args[i].equals("-OttCSV")) {
        operation = TIME_BASED_CVS_TABLE;
      }
      else if (args[i].equals("-Ot")) {
        operation = TABLE;
      }
      else if (args[i].equals("-Otd")) {
        operation = TABLE;
        useDenseTableOperation = true;