proxyforwarderimpl.java

你个snmp的源码

    }
    PDU resp = response.getResponse();
    if ((resp.getErrorStatus() == PDU.tooBig) &&
        (reqPDU.getType() != PDU.GETBULK)) {
      response.getResponse().clear();
      response.getResponse().setErrorStatus(PDU.noError);
      response.getResponse().setErrorIndex(0);
      return false;
    }
    if ((resp.getErrorStatus() == PDU.tooBig) &&
        (reqPDU.getType() == PDU.GETBULK) && (pdu.getType() == PDU.GETBULK)) {
      /**implemented as defined in RFC 3584 4.3.1(3)*/
      if (pdu.size() == 1) {
        response.getResponse().clear();
        response.getResponse().setErrorStatus(PDU.noError);
        response.getResponse().setErrorIndex(0);
        return false;
      }
      else {
        while (pdu.size() > 1) {
          pdu.trim();
        }
        pdu.setType(PDU.GETNEXT);
        return true;
      }
    }
    if ((reqPDU instanceof PDUv1) &&
        (!(response.getResponse() instanceof PDUv1))) {
      boolean resendNeeded = false;
      for (int i=0; i<resp.size(); i++) {
        VariableBinding vb = resp.get(i);
        if (vb.getVariable() instanceof Counter64) {
          OID nextOID = new OID(vb.getOid());
          if (nextOID.last() < 65535) {
            nextOID.set(nextOID.size()-1, 65535);
          }
          else {
            nextOID.set(nextOID.size()-1, OID.MAX_SUBID_VALUE);
          }
          pdu.get(i).setOid(vb.getOid());
          resendNeeded = true;
        }
      }
      if (resendNeeded && (reqPDU.getType() != PDU.GETNEXT)) {
        throw new IllegalArgumentException(
            "GET response with Counter64 cannot be proxied");
      }
      else {
        return true;
      }
    }
    return false;
  }

  /**
   * Translates a source PDU into the supplied target PDU. The mapping between
   * the source PDU and the target PDU is done as defined by RFC 3584.
   * @param request
   *    the proxy forwarding request.
   * @param source
   *    the source PDU instance.
   * @param target
   *    the target PDU instance. The variable bindings of the source will
   *    replace any VBs of the target instance. If the source PDU cannot
   *    be converted to the target PDU <code>target</code> is not changed.
   *    Instead an intermediate PDU is returned.
   */
  protected void proxyForwardTranslation(ProxyForwardRequest request,
                                         PDU source, PDU target)
      throws IllegalArgumentException
  {
    target.clear();
    target.setType(source.getType());
    if (!(target instanceof PDUv1) && !(source instanceof PDUv1)) {
      target.setMaxRepetitions(source.getMaxRepetitions());
      target.setNonRepeaters(source.getNonRepeaters());
    }
    if ((source.getType() == PDU.V1TRAP) &&
        (source instanceof PDUv1) &&
        (!(target instanceof PDUv1))) {
      PDUv1 sourceV1 = (PDUv1)source;
      target.setType(PDU.NOTIFICATION);
      target.add(new VariableBinding(SnmpConstants.sysUpTime,
                                     new TimeTicks(sourceV1.getTimestamp())));
      target.add(new VariableBinding(SnmpConstants.snmpTrapOID,
                                     SnmpConstants.getTrapOID(
                                         sourceV1.getEnterprise(),
                                         sourceV1.getGenericTrap(),
                                         sourceV1.getSpecificTrap())));
      target.addAll(source.toArray());
      target.add(new VariableBinding(SnmpConstants.snmpTrapAddress,
                                     sourceV1.getAgentAddress()));
      target.add(new VariableBinding(SnmpConstants.snmpTrapEnterprise,
                                     sourceV1.getEnterprise()));
      OctetString community =
          new OctetString(request.getCommandEvent().getSecurityName());
      target.add(new VariableBinding(SnmpConstants.snmpTrapCommunity,
                                     community));
    }
    else if (((source.getType() == PDU.NOTIFICATION) ||
              (source.getType() == PDU.INFORM)) &&
             (target instanceof PDUv1)) {
      PDUv1 targetV1 = (PDUv1)target;
      target.setType(PDU.V1TRAP);
      if ((source.size() < 2) ||
          (!(source.get(0).getVariable() instanceof TimeTicks)) ||
          (!(source.get(1).getVariable() instanceof OID))) {
        throw new IllegalArgumentException("Proxy source invalid notification PDU: "+
                                           source);
      }
      TimeTicks sysUpTime = (TimeTicks) source.get(0).getVariable();
      OID trapOID = (OID)source.get(1).getVariable();
      int genericID = SnmpConstants.getGenericTrapID(trapOID);
      // RFC 3584 Translating
      // SNMPv2 notification to SNMPv1 notification parameters
      if (genericID < 0) {
        targetV1.setGenericTrap(6);
        if ((trapOID.size() > 2) && (trapOID.get(trapOID.size() - 2) == 0)) {
          targetV1.setSpecificTrap(trapOID.get(trapOID.size() - 1));
          OID enterprise = new OID(trapOID);
          enterprise.trim(2);
          targetV1.setEnterprise(enterprise);
        }
        else if (trapOID.size() > 1) {
          targetV1.setSpecificTrap(trapOID.get(trapOID.size() - 1));
          OID enterprise = new OID(trapOID);
          enterprise.trim(1);
          targetV1.setEnterprise(enterprise);
        }
      }
      else {
        targetV1.setGenericTrap(genericID);
        targetV1.setSpecificTrap(0);
      }
      target.addAll(source.toArray());
      if (request.getCommandEvent().getPeerAddress() instanceof IpAddress) {
        targetV1.setAgentAddress((IpAddress)
                                 request.getCommandEvent().getPeerAddress());
      }
      else {
        targetV1.setAgentAddress(new IpAddress("0.0.0.0"));
      }
      targetV1.setTimestamp(sysUpTime.getValue());
    }
    else {
      target.addAll(source.toArray());
    }
  }

  protected boolean multipleForward(ProxyForwardRequest request) {
    List matches = getMatches(request);
    boolean allOK = true;
    for (Iterator it = matches.iterator(); it.hasNext(); ) {
      SnmpProxyRow item = (SnmpProxyRow) it.next();
      OctetString outParam = item.getSnmpProxyMultipleTargetOut();
      Set tags = SnmpTagList.getTags(outParam);
      if (logger.isDebugEnabled()) {
        logger.debug("Proxy multiple targets out with tags "+tags);
      }
      for (Iterator tagit = tags.iterator (); tagit.hasNext(); ) {
        OctetString tag = (OctetString) tagit.next();
        Collection targets = this.targetMIB.getTargetAddrRowsForTag(tag);
        for (Iterator tit = targets.iterator(); tit.hasNext(); ) {
          SnmpTargetAddrEntryRow targetRow =
              (SnmpTargetAddrEntryRow) tit.next();
          Target target = targetRow.getTarget(request.getContextEngineID(),
                                              request.getContext());
          if (target != null) {
            try {
              PDU reqPDU = request.getCommandEvent().getPDU();
              PDU pdu = DefaultPDUFactory.createPDU(target, reqPDU.getType());
              proxyForwardTranslation(request, reqPDU, pdu);
              ResponseEvent resp = session.send(pdu, target);
              if (logger.isInfoEnabled()) {
                logger.info("Forwarded " + request.getCommandEvent() +
                            " to target " + target + " with response " + resp);
              }
              if (request.getCommandEvent().getPDU().getType() == PDU.INFORM) {
                if ((resp.getResponse() == null) ||
                    (resp.getResponse().getType() == PDU.REPORT) ||
                    (resp.getResponse().getErrorStatus() != PDU.noError)) {
                  allOK = false;
                }
              }
            }
            catch (IOException ex) {
              if (logger.isDebugEnabled()) {
                ex.printStackTrace();
              }
              logger.error("Failed to forward request " + request +
                           " to target " + target);
              allOK = false;
            }
          }
          else {
            if (logger.isDebugEnabled()) {
              logger.debug("Parameters for target " + targetRow + " not found");
            }
          }
        }
      }
    }
    return allOK;
  }

  public synchronized void addCounterListener(CounterListener l) {
    if (counterListeners == null) {
      counterListeners = new Vector(2);
    }
    counterListeners.add(l);
  }

  public synchronized void removeCounterListener(CounterListener l) {
    if (counterListeners != null) {
      counterListeners.remove(l);
    }
  }

  protected void fireIncrementCounter(CounterEvent event) {
    if (counterListeners != null) {
      Vector listeners = counterListeners;
      int count = listeners.size();
      for (int i = 0; i < count; i++) {
        ((CounterListener) listeners.elementAt(i)).incrementCounter(event);
      }
    }
  }

}