Beispiel #1
0
  /**
   * Encodes a <code>Variable</code> to an <code>OutputStream</code>.
   *
   * @param outputStream an <code>OutputStream</code>.
   * @throws IOException if an error occurs while writing to the stream.
   */
  @Override
  public void encodeBER(OutputStream outputStream) throws IOException {
    BER.encodeHeader(outputStream, type, getBERPayloadLength());

    if (type == PDU.V1TRAP) {
      enterprise.encodeBER(outputStream);
      agentAddress.encodeBER(outputStream);
      genericTrap.encodeBER(outputStream);
      specificTrap.encodeBER(outputStream);
      timestamp.encodeBER(outputStream);
    } else {
      requestID.encodeBER(outputStream);
      errorStatus.encodeBER(outputStream);
      errorIndex.encodeBER(outputStream);
    }
    int vbLength = 0;
    for (VariableBinding variableBinding : variableBindings) {
      vbLength += variableBinding.getBERLength();
    }
    BER.encodeHeader(outputStream, BER.SEQUENCE, vbLength);
    for (VariableBinding vb : variableBindings) {
      if (!isVariableV1(vb.getVariable())) {
        throw new IOException("Cannot encode Counter64 into a SNMPv1 PDU");
      }
      vb.encodeBER(outputStream);
    }
  }
Beispiel #2
0
  /**
   * Decodes a <code>Variable</code> from an <code>InputStream</code>.
   *
   * @param inputStream an <code>InputStream</code> containing a BER encoded byte stream.
   * @throws IOException
   */
  @Override
  public void decodeBER(BERInputStream inputStream) throws IOException {
    MutableByte pduType = new MutableByte();
    int length = BER.decodeHeader(inputStream, pduType);
    int pduStartPos = (int) inputStream.getPosition();

    switch (pduType.getValue()) {
      case PDU.SET:
      case PDU.GET:
      case PDU.GETNEXT:
      case PDU.V1TRAP:
      case PDU.RESPONSE:
        break;
        // The following PDU types are not supported by the SNMPv1 standard!
      case PDU.NOTIFICATION:
      case PDU.INFORM:
        if (SNMP4JSettings.isAllowSNMPv2InV1()) {
          break;
        }
        // fall through
      default:
        throw new IOException("Unsupported PDU type: " + pduType.getValue());
    }
    this.setType(pduType.getValue());
    if (getType() == PDU.V1TRAP) {
      enterprise.decodeBER(inputStream);
      agentAddress.decodeBER(inputStream);
      genericTrap.decodeBER(inputStream);
      specificTrap.decodeBER(inputStream);
      timestamp.decodeBER(inputStream);
    } else {
      requestID.decodeBER(inputStream);
      errorStatus.decodeBER(inputStream);
      errorIndex.decodeBER(inputStream);
    }
    // reusing pduType here to save memory ;-)
    pduType = new BER.MutableByte();
    int vbLength = BER.decodeHeader(inputStream, pduType);
    if (pduType.getValue() != BER.SEQUENCE) {
      throw new IOException("Encountered invalid tag, SEQUENCE expected: " + pduType.getValue());
    }
    // rest read count
    int startPos = (int) inputStream.getPosition();
    variableBindings = new Vector<>();
    while (inputStream.getPosition() - startPos < vbLength) {
      VariableBinding vb = new VariableBinding();
      vb.decodeBER(inputStream);
      if (!isVariableV1(vb.getVariable())) {
        throw new MessageException("Counter64 encountered in SNMPv1 PDU " + "(RFC 2576 §4.1.2.1)");
      }
      variableBindings.add(vb);
    }
    if (BER.isCheckSequenceLength()) {
      BER.checkSequenceLength(vbLength, (int) inputStream.getPosition() - startPos, this);
      BER.checkSequenceLength(length, (int) inputStream.getPosition() - pduStartPos, this);
    }
  }
  @Override
  public void decodeBER(BERInputStream inputStream) throws java.io.IOException {
    BER.MutableByte type = new BER.MutableByte();
    byte[] value = BER.decodeString(inputStream, type);
    if (type.getValue() != BER.IPADDRESS) {
      throw new IOException("Wrong type encountered when decoding Counter: " + type.getValue());
    }
    if (value.length != 4) {
      if ((value.length == 8)
          && Boolean.getBoolean("org.opennms.snmp.workarounds.allow64BitIpAddress")) {
        byte[] tempValue = {0, 0, 0, 0};
        for (int i = 0; i < 4; i++) {
          tempValue[i] = value[i];
        }
        value = tempValue;
        if (log().isDebugEnabled()) {
          log()
              .debug(
                  "Working around misencoded IpAddress (8 bytes, truncating to 4); likely dealing with a buggy Net-SNMP agent");
        }
      } else {
        throw new IOException("IpAddress encoding error, wrong length: " + value.length);
      }
    }

    this.setInetAddress(InetAddress.getByAddress(value));
  }
 public MessageLength getMessageLength(ByteBuffer buf) throws IOException {
   MutableByte type = new MutableByte();
   BERInputStream is = new BERInputStream(buf);
   int ml = BER.decodeHeader(is, type);
   int hl = (int) is.getPosition();
   MessageLength messageLength = new MessageLength(hl, ml);
   return messageLength;
 }
Beispiel #5
0
 @Override
 protected int getBERPayloadLengthPDU() {
   if (getType() != PDU.V1TRAP) {
     return super.getBERPayloadLengthPDU();
   } else {
     int length = 0;
     // length for all vbs
     for (VariableBinding variableBinding : variableBindings) {
       length += variableBinding.getBERLength();
     }
     length += BER.getBERLengthOfLength(length) + 1;
     length += agentAddress.getBERLength();
     length += enterprise.getBERLength();
     length += genericTrap.getBERLength();
     length += specificTrap.getBERLength();
     length += timestamp.getBERLength();
     return length;
   }
 }
Beispiel #6
0
  private final Object resolvOpaque(Opaque var) {

    // If not resolved, we will return the data as an array of bytes
    Object value = var.getValue();

    try {
      byte[] bytesArray = var.getValue();
      ByteBuffer bais = ByteBuffer.wrap(bytesArray);
      BERInputStream beris = new BERInputStream(bais);
      byte t1 = bais.get();
      byte t2 = bais.get();
      int l = BER.decodeLength(beris);
      if (t1 == TAG1) {
        if (t2 == TAG_FLOAT && l == 4) value = new Float(bais.getFloat());
        else if (t2 == TAG_DOUBLE && l == 8) value = new Double(bais.getDouble());
      }
    } catch (IOException e) {
      logger.error(var.toString());
    }
    return value;
  }