Ejemplo n.º 1
0
 /**
  * This method determines whether the inform request is to be retried. This is used if the peer
  * did not respond to a previous request. If the request exceeds the maxTries limit, a timeout is
  * signaled.
  */
 void action() {
   if (inProgress() == false) return;
   while (true) {
     try {
       if (numTries == 0) {
         invokeOnReady();
       } else if (numTries < getMaxTries()) {
         invokeOnRetry();
       } else {
         invokeOnTimeout();
       }
       return;
     } catch (OutOfMemoryError omerr) {
       // Consider it as a try !
       //
       numTries++;
       if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
         SNMP_ADAPTOR_LOGGER.logp(
             Level.FINEST,
             SnmpInformRequest.class.getName(),
             "action",
             "Inform request hit out of memory situation...");
       }
       Thread.currentThread().yield();
     }
   }
 }
Ejemplo n.º 2
0
  /** For SNMP Runtime internal use only. */
  final void processResponse() {

    if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINER)) {
      SNMP_ADAPTOR_LOGGER.logp(
          Level.FINER,
          SnmpInformRequest.class.getName(),
          "processResponse",
          "errstatus = " + errorStatus);
    }

    if (inProgress() == false) { // check if this request is still alive.
      responsePdu = null;
      return; // the request may have  cancelled.
    }

    if (errorStatus >= snmpReqInternalError) {
      handleInternalError("Internal Error...");
      return;
    }

    try {
      parsePduPacket(responsePdu);
      // responsePdu = null;

      // At this point the errorIndex is rationalized to start with 0.
      switch (errorStatus) {
        case snmpRspNoError:
          handleSuccess();
          return;
        case snmpReqTimeout:
          handleTimeout();
          return;
        case snmpReqInternalError:
          handleInternalError("Unknown internal error.  deal with it later!");
          return;
        case snmpReqHandleTooBig:
          setErrorStatusAndIndex(snmpRspTooBig, 0);
          handleError("Cannot handle too-big situation...");
          return;
        case snmpReqRefireAfterVbFix:
          // Refire request after fixing varbindlist.
          initializeAndFire();
          return;
        default:
          handleError("Error status set in packet...!!");
          return;
      }
    } catch (Exception e) {
      if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
        SNMP_ADAPTOR_LOGGER.logp(
            Level.FINEST,
            SnmpInformRequest.class.getName(),
            "processResponse",
            "Got unexpected exception",
            e);
      }
      reason = e.getMessage();
    }
    handleInternalError(reason);
  }
Ejemplo n.º 3
0
  /** For SNMP Runtime internal use only. */
  final void setRequestSentTime(long sendtime) {
    numTries++;
    setPrevPollTime(sendtime);
    waitTimeForResponse = prevPollTime + timeout * numTries;
    setRequestStatus(stWaitingForReply);

    if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINER)) {
      SNMP_ADAPTOR_LOGGER.logp(
          Level.FINER,
          SnmpInformRequest.class.getName(),
          "setRequestSentTime",
          "Inform request Successfully sent");
    }

    informSession.getSnmpQManager().addWaiting(this);
  }
Ejemplo n.º 4
0
  /**
   * Checks if a <CODE>set</CODE> operation can be performed. If the operation can not be performed,
   * the method should emit a <CODE>SnmpStatusException</CODE>.
   *
   * @param inRequest The SnmpMibRequest object holding the list of variables to be set. This list
   *     is composed of <CODE>SnmpVarBind</CODE> objects.
   * @exception SnmpStatusException The <CODE>set</CODE> operation cannot be performed.
   */
  @Override
  public void check(SnmpMibRequest inRequest) throws SnmpStatusException {

    SNMP_ADAPTOR_LOGGER.logp(
        Level.FINEST, SnmpErrorHandlerAgent.class.getName(), "check", "Check in Exception");

    throw new SnmpStatusException(SnmpDefinitions.snmpRspNotWritable);
  }
Ejemplo n.º 5
0
  /**
   * Processes a <CODE>set</CODE> operation. Should never be called (check previously called having
   * failed).
   *
   * @param inRequest The SnmpMibRequest object holding the list of variable to be set.
   * @exception SnmpStatusException An error occurred during the operation.
   */
  @Override
  public void set(SnmpMibRequest inRequest) throws SnmpStatusException {

    SNMP_ADAPTOR_LOGGER.logp(
        Level.FINEST,
        SnmpErrorHandlerAgent.class.getName(),
        "set",
        "Set in Exception, CANNOT be called");

    throw new SnmpStatusException(SnmpDefinitions.snmpRspNotWritable);
  }
Ejemplo n.º 6
0
  /**
   * Parses the inform response packet. If the agent responds with error set, it does not parse any
   * further.
   */
  synchronized void parsePduPacket(SnmpPduRequestType rpdu) {

    if (rpdu == null) return;

    errorStatus = rpdu.getErrorStatus();
    errorIndex = rpdu.getErrorIndex();

    if (errorStatus == snmpRspNoError) {
      updateInternalVarBindWithResult(((SnmpPdu) rpdu).varBindList);
      return;
    }

    if (errorStatus != snmpRspNoError) --errorIndex; // rationalize for index to start with 0.

    if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINER)) {
      SNMP_ADAPTOR_LOGGER.logp(
          Level.FINER,
          SnmpInformRequest.class.getName(),
          "parsePduPacket",
          "received inform response. ErrorStatus/ErrorIndex = " + errorStatus + "/" + errorIndex);
    }
  }
Ejemplo n.º 7
0
  /**
   * Sends the prepared PDU packet to the manager and updates the data structure to expect a
   * response. It acquires a lock on the socket to prevent a case where a response arrives before
   * this thread could insert the request into the wait queue.
   *
   * @exception IOException Signals that an I/O exception of some sort has occurred.
   */
  final void sendPduPacket(byte[] buffer, int length) throws java.io.IOException {

    if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINER)) {
      SNMP_ADAPTOR_LOGGER.logp(
          Level.FINER,
          SnmpInformRequest.class.getName(),
          "sendPduPacket",
          "Send to peer. Peer/Port : "
              + address.getHostName()
              + "/"
              + port
              + ". Length = "
              + length
              + "\nDump : \n"
              + SnmpMessage.dumpHexBuffer(buffer, 0, length));
    }
    SnmpSocket theSocket = informSession.getSocket();
    synchronized (theSocket) {
      theSocket.sendPacket(buffer, length, address, port);
      setRequestSentTime(System.currentTimeMillis());
    }
  }
  /** SNMP V1/V2 . To be called with updateRequest. */
  protected SnmpSubRequestHandler(SnmpMibAgent agent, SnmpPdu req) {
    if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINER)) {
      SNMP_ADAPTOR_LOGGER.logp(
          Level.FINER,
          SnmpSubRequestHandler.class.getName(),
          "constructor",
          "creating instance for request " + String.valueOf(req.requestId));
    }

    version = req.version;
    type = req.type;
    this.agent = agent;

    // We get a ref on the pdu in order to pass it to SnmpMibRequest.
    reqPdu = req;

    // Pre-allocate room for storing varbindlist and translation table.
    //
    int length = req.varBindList.length;
    translation = new int[length];
    varBind = new NonSyncVector<SnmpVarBind>(length);
  }
  /**
   * The method updates a given var bind list with the result of a previsouly invoked operation.
   * Prior to calling the method, one must make sure that the operation was successful. As such the
   * method getErrorIndex or getErrorStatus should be called.
   */
  protected void updateResult(SnmpVarBind[] result) {

    if (result == null) return;
    final int max = varBind.size();
    final int len = result.length;
    for (int i = 0; i < max; i++) {
      // bugId 4641694: must check position in order to avoid
      //       ArrayIndexOutOfBoundException
      final int pos = translation[i];
      if (pos < len) {
        result[pos] = (SnmpVarBind) ((NonSyncVector) varBind).elementAtNonSync(i);
      } else {
        if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
          SNMP_ADAPTOR_LOGGER.logp(
              Level.FINEST,
              SnmpSubRequestHandler.class.getName(),
              "updateResult",
              "Position `" + pos + "' is out of bound...");
        }
      }
    }
  }
Ejemplo n.º 10
0
  /**
   * Processes a <CODE>get</CODE> operation. It will throw an exception for V1 requests or it will
   * set exceptions within the list for V2 requests.
   *
   * @param inRequest The SnmpMibRequest object holding the list of variable to be retrieved.
   * @exception SnmpStatusException An error occurred during the operation.
   */
  @Override
  public void get(SnmpMibRequest inRequest) throws SnmpStatusException {

    SNMP_ADAPTOR_LOGGER.logp(
        Level.FINEST, SnmpErrorHandlerAgent.class.getName(), "get", "Get in Exception");

    if (inRequest.getVersion() == SnmpDefinitions.snmpVersionOne)
      throw new SnmpStatusException(SnmpStatusException.noSuchName);

    Enumeration<SnmpVarBind> l = inRequest.getElements();
    while (l.hasMoreElements()) {
      SnmpVarBind varbind = l.nextElement();
      varbind.setNoSuchObject();
    }
  }
Ejemplo n.º 11
0
  /** Constructs an inform request PDU. */
  synchronized SnmpPdu constructPduPacket() {
    SnmpPduPacket reqpdu = null;
    Exception excep = null;
    try {
      reqpdu = new SnmpPduRequest();
      reqpdu.port = port;
      reqpdu.type = pduInformRequestPdu;
      reqpdu.version = snmpVersionTwo;
      reqpdu.community = communityString.getBytes("8859_1");
      reqpdu.requestId = getRequestId();
      reqpdu.varBindList = internalVarBind;

      if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINER)) {
        SNMP_ADAPTOR_LOGGER.logp(
            Level.FINER, SnmpInformRequest.class.getName(), "constructPduPacket", "Packet built");
      }

    } catch (Exception e) {
      excep = e;
      errorStatus = snmpReqUnknownError;
      reason = e.getMessage();
    }
    if (excep != null) {
      if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
        SNMP_ADAPTOR_LOGGER.logp(
            Level.FINEST,
            SnmpInformRequest.class.getName(),
            "constructPduPacket",
            "Got unexpected exception",
            excep);
      }
      reqpdu = null;
      queueResponse();
    }
    return reqpdu;
  }
Ejemplo n.º 12
0
  /**
   * Processes a <CODE>getBulk</CODE> operation. It will throw an exception if the request is a V1
   * one or it will set exceptions within the list for V2 ones.
   *
   * @param inRequest The SnmpMibRequest object holding the list of variable to be retrieved.
   * @exception SnmpStatusException An error occurred during the operation.
   */
  @Override
  public void getBulk(SnmpMibRequest inRequest, int nonRepeat, int maxRepeat)
      throws SnmpStatusException {

    SNMP_ADAPTOR_LOGGER.logp(
        Level.FINEST, SnmpErrorHandlerAgent.class.getName(), "getBulk", "GetBulk in Exception");

    if (inRequest.getVersion() == SnmpDefinitions.snmpVersionOne)
      throw new SnmpStatusException(SnmpDefinitions.snmpRspGenErr, 0);

    Enumeration<SnmpVarBind> l = inRequest.getElements();
    while (l.hasMoreElements()) {
      SnmpVarBind varbind = l.nextElement();
      varbind.setEndOfMibView();
    }
  }
Ejemplo n.º 13
0
  /** Calls the user implementation of the <CODE>SnmpInformHandler</CODE> interface. */
  private void handleInternalError(String msg) {

    setRequestStatus(stInternalError);
    if (reason == null) reason = msg;

    if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
      SNMP_ADAPTOR_LOGGER.logp(
          Level.FINEST,
          SnmpInformRequest.class.getName(),
          "handleInternalError",
          "Snmp error/index = "
              + snmpErrorToString(errorStatus)
              + "/"
              + errorIndex
              + ". Invoking internal error user defined callback...\n"
              + getVarBindList());
    }

    deleteRequest();
    notifyClient();

    requestPdu = null;
    responsePdu = null;
    internalVarBind = null;

    try {
      if (callback != null) callback.processSnmpInternalError(this, reason);
    } catch (Exception e) { // catch any exception a user might not handle.
      if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
        SNMP_ADAPTOR_LOGGER.logp(
            Level.FINEST,
            SnmpInformRequest.class.getName(),
            "handleInternalError",
            "Exception generated by user callback",
            e);
      }
    } catch (OutOfMemoryError ome) {
      if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
        SNMP_ADAPTOR_LOGGER.logp(
            Level.FINEST,
            SnmpInformRequest.class.getName(),
            "handleInternalError",
            "OutOfMemory Error generated by user callback",
            ome);
      }
      Thread.currentThread().yield();
    }
  }
Ejemplo n.º 14
0
  /** Calls the user implementation of the <CODE>SnmpInformHandler</CODE> interface. */
  private void handleSuccess() {

    setRequestStatus(stResultsAvailable);

    if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINER)) {
      SNMP_ADAPTOR_LOGGER.logp(
          Level.FINER,
          SnmpInformRequest.class.getName(),
          "handleSuccess",
          "Invoking user defined callback...");
    }

    deleteRequest(); // delete only non-poll request.
    notifyClient();

    requestPdu = null;
    // responsePdu = null;
    internalVarBind = null;

    try { // catch all user exception which may happen in callback.
      if (callback != null)
        callback.processSnmpPollData(this, errorStatus, errorIndex, getVarBindList());
    } catch (Exception e) {
      if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
        SNMP_ADAPTOR_LOGGER.logp(
            Level.FINEST,
            SnmpInformRequest.class.getName(),
            "handleSuccess",
            "Exception generated by user callback",
            e);
      }
    } catch (OutOfMemoryError ome) {
      if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
        SNMP_ADAPTOR_LOGGER.logp(
            Level.FINEST,
            SnmpInformRequest.class.getName(),
            "handleSuccess",
            "OutOfMemory Error generated by user callback",
            ome);
      }
      Thread.currentThread().yield();
    }
    return;
  }
Ejemplo n.º 15
0
  boolean sendPdu() {
    try {
      responsePdu = null;

      SnmpPduFactory pduFactory = adaptor.getPduFactory();
      SnmpMessage msg =
          (SnmpMessage)
              pduFactory.encodeSnmpPdu(
                  (SnmpPduPacket) requestPdu, adaptor.getBufferSize().intValue());

      if (msg == null) {
        if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
          SNMP_ADAPTOR_LOGGER.logp(
              Level.FINEST,
              SnmpInformRequest.class.getName(),
              "sendPdu",
              "pdu factory returned a null value");
        }
        throw new SnmpStatusException(snmpReqUnknownError);
        // This exception will caught hereafter and reported as an snmpReqUnknownError
        // FIXME: may be it's not the best behaviour ?
      }

      int maxPktSize = adaptor.getBufferSize().intValue();
      byte[] encoding = new byte[maxPktSize];
      int encodingLength = msg.encodeMessage(encoding);

      if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINER)) {
        SNMP_ADAPTOR_LOGGER.logp(
            Level.FINER,
            SnmpInformRequest.class.getName(),
            "sendPdu",
            "Dump : \n" + msg.printMessage());
      }

      sendPduPacket(encoding, encodingLength);
      return true;
    } catch (SnmpTooBigException ar) {

      if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
        SNMP_ADAPTOR_LOGGER.logp(
            Level.FINEST,
            SnmpInformRequest.class.getName(),
            "sendPdu",
            "Got unexpected exception",
            ar);
      }

      setErrorStatusAndIndex(snmpReqPacketOverflow, ar.getVarBindCount());
      requestPdu = null;
      reason = ar.getMessage();
      if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
        SNMP_ADAPTOR_LOGGER.logp(
            Level.FINEST,
            SnmpInformRequest.class.getName(),
            "sendPdu",
            "Packet Overflow while building inform request");
      }
    } catch (java.io.IOException ioe) {
      setErrorStatusAndIndex(snmpReqSocketIOError, 0);
      reason = ioe.getMessage();
    } catch (Exception e) {
      if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
        SNMP_ADAPTOR_LOGGER.logp(
            Level.FINEST,
            SnmpInformRequest.class.getName(),
            "sendPdu",
            "Got unexpected exception",
            e);
      }
      setErrorStatusAndIndex(snmpReqUnknownError, 0);
      reason = e.getMessage();
    }
    return false;
  }
  public void run() {

    try {
      final ThreadContext oldContext = ThreadContext.push("SnmpUserData", data);
      try {
        switch (type) {
          case pduGetRequestPdu:
            // Invoke a get operation
            //
            if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINER)) {
              SNMP_ADAPTOR_LOGGER.logp(
                  Level.FINER,
                  SnmpSubRequestHandler.class.getName(),
                  "run",
                  "[" + Thread.currentThread() + "]:get operation on " + agent.getMibName());
            }

            agent.get(createMibRequest(varBind, version, data));
            break;

          case pduGetNextRequestPdu:
            if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINER)) {
              SNMP_ADAPTOR_LOGGER.logp(
                  Level.FINER,
                  SnmpSubRequestHandler.class.getName(),
                  "run",
                  "[" + Thread.currentThread() + "]:getNext operation on " + agent.getMibName());
            }
            // #ifdef DEBUG
            agent.getNext(createMibRequest(varBind, version, data));
            break;

          case pduSetRequestPdu:
            if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINER)) {
              SNMP_ADAPTOR_LOGGER.logp(
                  Level.FINER,
                  SnmpSubRequestHandler.class.getName(),
                  "run",
                  "[" + Thread.currentThread() + "]:set operation on " + agent.getMibName());
            }
            agent.set(createMibRequest(varBind, version, data));
            break;

          case pduWalkRequest:
            if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINER)) {
              SNMP_ADAPTOR_LOGGER.logp(
                  Level.FINER,
                  SnmpSubRequestHandler.class.getName(),
                  "run",
                  "[" + Thread.currentThread() + "]:check operation on " + agent.getMibName());
            }
            agent.check(createMibRequest(varBind, version, data));
            break;

          default:
            if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
              SNMP_ADAPTOR_LOGGER.logp(
                  Level.FINEST,
                  SnmpSubRequestHandler.class.getName(),
                  "run",
                  "["
                      + Thread.currentThread()
                      + "]:unknown operation ("
                      + type
                      + ") on "
                      + agent.getMibName());
            }
            errorStatus = snmpRspGenErr;
            errorIndex = 1;
            break;
        } // end of switch

      } finally {
        ThreadContext.restore(oldContext);
      }
    } catch (SnmpStatusException x) {
      errorStatus = x.getStatus();
      errorIndex = x.getErrorIndex();
      if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
        SNMP_ADAPTOR_LOGGER.logp(
            Level.FINEST,
            SnmpSubRequestHandler.class.getName(),
            "run",
            "[" + Thread.currentThread() + "]:an Snmp error occured during the operation",
            x);
      }
    } catch (Exception x) {
      errorStatus = SnmpDefinitions.snmpRspGenErr;
      if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
        SNMP_ADAPTOR_LOGGER.logp(
            Level.FINEST,
            SnmpSubRequestHandler.class.getName(),
            "run",
            "[" + Thread.currentThread() + "]:a generic error occured during the operation",
            x);
      }
    }
    if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINER)) {
      SNMP_ADAPTOR_LOGGER.logp(
          Level.FINER,
          SnmpSubRequestHandler.class.getName(),
          "run",
          "[" + Thread.currentThread() + "]:operation completed");
    }
  }