commandprocessor.java

你个snmp的源码

                                RequestHandler handler,
                                Request req) {

    if (server == null) {
      req.setErrorStatus(SnmpConstants.SNMP_ERROR_GENERAL_ERROR);
    }
    else {
      handler.processPdu(req, server);
    }
  }

  protected void finalizeRequest(CommandResponderEvent command, Request req,
                                 MOServer server) {
    if (req.isComplete()) {
      requestList.remove(req);
      // send response
      sendResponse(command, (PDU)req.getResponse());
      if (server != null) {
        release(server, req);
      }
    }
  }

  protected void release(MOServer server, Request req) {
    for (Iterator it = req.iterator(); it.hasNext();) {
      SubRequest sreq = (SubRequest)it.next();
      if (sreq.getTargetMO() != null) {
        server.unlock(req, sreq.getTargetMO());
      }
    }
  }

  protected void sendResponse(CommandResponderEvent requestEvent,
                              PDU response) {
    MessageDispatcher disp = requestEvent.getMessageDispatcher();
    try {
      /**@todo BER encoded length checking*/
      StatusInformation status = new StatusInformation();
      requestEvent.getStateReference().
          setTransportMapping(requestEvent.getTransportMapping());
      disp.returnResponsePdu(requestEvent.getMessageProcessingModel(),
                             requestEvent.getSecurityModel(),
                             requestEvent.getSecurityName(),
                             requestEvent.getSecurityLevel(),
                             response,
                             requestEvent.getMaxSizeResponsePDU(),
                             requestEvent.getStateReference(),
                             status);
    }
    catch (MessageException ex) {
      ex.printStackTrace();
      /**@todo implement send error handling */
    }
  }

  protected void setAuthorizationError(Request req, int vacmStatus) {
    req.setErrorStatus(PDU.authorizationError);
  }

  public void addPduHandler(RequestHandler handler) {
    pduHandler.add(handler);
  }

  public void removePduHandler(RequestHandler handler) {
    pduHandler.remove(handler);
  }

  public void addMOServer(MOServer server) {
    moServers.add(server);
  }

  public void removeMOServer(MOServer server) {
    moServers.remove(server);
  }

  public MOServer getServer(OctetString context) {
    for (int i=0; i<moServers.size(); i++) {
      MOServer s = (MOServer)moServers.get(i);
      if (s.isContextSupported(context)) {
        return s;
      }
    }
    return null;
  }

  public TemporaryList getRequestList() {
    return requestList;
  }

  public NotificationOriginator getNotificationOriginator() {
    return notificationOriginator;
  }

  public ProxyMap getProxyForwarder() {
    return proxyForwarder;
  }

  public CoexistenceInfoProvider getCoexistenceProvider() {
    return coexistenceProvider;
  }

  class Command implements Runnable {

    private CommandResponderEvent request;
    private CoexistenceInfo cinfo;

    public Command(CommandResponderEvent event, CoexistenceInfo cinfo) {
      this.request = event;
      this.cinfo = cinfo;
    }

    public void run() {
      dispatchCommand(request, cinfo);
    }
  }

  class ProxyCommand implements Runnable {

    private ProxyForwardRequest request;
    private ProxyForwarder forwarder;

    public ProxyCommand(ProxyForwarder forwarder, ProxyForwardRequest event) {
      this.forwarder = forwarder;
      this.request = event;
    }

    public void run() {
      if (forwarder.forward(request)) {
        PDU response = request.getResponsePDU();
        if (response != null) {
          sendResponse(request.getCommandEvent(), response);
        }
      }
      else if (request.getProxyType() != ProxyForwarder.PROXY_TYPE_NOTIFY) {
        // proxy drop
        CounterEvent cevent = new CounterEvent(this,
                                               SnmpConstants.snmpProxyDrops);
        fireIncrementCounter(cevent);
        if (request.getCommandEvent().getMessageProcessingModel() == MPv3.ID) {
          PDU reportPDU = new PDU();
          reportPDU.add(new VariableBinding(SnmpConstants.snmpProxyDrops,
                                            cevent.getCurrentValue()));
          sendResponse(request.getCommandEvent(), reportPDU);
        }
      }
    }
  }

  protected OctetString getViewName(CommandResponderEvent req,
                                    OctetString context,
                                    int viewType) {
    OctetString viewName =
        vacm.getViewName(context,
                         new OctetString(req.getSecurityName()),
                         req.getSecurityModel(),
                         req.getSecurityLevel(),
                         viewType);
    return viewName;
  }

  protected void processNextSubRequest(Request request, MOServer server,
                                       OctetString context,
                                       SubRequest sreq)
      throws NoSuchElementException
  {
    // We can be sure to have a default context scope here because
    // the inner class SnmpSubRequest creates it!
    DefaultMOContextScope scope = (DefaultMOContextScope) sreq.getScope();
    MOQuery query = sreq.getQuery();
    if (query == null) {
      query = new VACMQuery(context,
                            scope.getLowerBound(),
                            scope.isLowerIncluded(),
                            scope.getUpperBound(),
                            scope.isUpperIncluded(),
                            request.getViewName());
      sreq.setQuery(query);
    }
    while (!sreq.getStatus().isProcessed()) {
      ManagedObject mo = server.lookup(query);
      if (mo == null) {
        if (logger.isDebugEnabled()) {
          logger.debug("EndOfMibView at scope="+scope+" and query "+query);
        }
        sreq.getVariableBinding().setVariable(Null.endOfMibView);
        sreq.getStatus().setPhaseComplete(true);
        continue;
      }
      try {
        if (logger.isDebugEnabled()) {
          logger.debug("Processing NEXT query "+query+" with "+mo+
                       " sub-request with index "+sreq.getIndex());
        }
        if ((!mo.next(sreq) ||
             ((request.getMessageProcessingModel() == MPv1.ID) &&
             (sreq.getVariableBinding().getSyntax() ==
              SMIConstants.SYNTAX_COUNTER64)))) {
          sreq.getVariableBinding().setVariable(Null.instance);
          scope.substractScope(mo.getScope());
          // don't forget to update VACM query:
          query.substractScope(mo.getScope());
        }
      }
      catch (Exception moex) {
        if (logger.isDebugEnabled()) {
          moex.printStackTrace();
        }
        logger.warn(moex);
        if (sreq.getStatus().getErrorStatus() == PDU.noError) {
          sreq.getStatus().setErrorStatus(PDU.genErr);
        }
      }
    }
  }

  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);
      }
    }
  }

  private static void initRequestPhase(Request request) {
    if (request.getPhase() == Request.PHASE_INIT) {
      request.nextPhase();
    }
  }

  class GetNextHandler implements RequestHandler {

    public void processPdu(Request request, MOServer server) {
      initRequestPhase(request);
      OctetString context = request.getContext();
      try {
        SubRequestIterator it = (SubRequestIterator) request.iterator();
        while (it.hasNext()) {
          SubRequest sreq =  it.nextSubRequest();
          processNextSubRequest(request, server, context, sreq);
        }
      }
      catch (NoSuchElementException nsex) {
        if (logger.isDebugEnabled()) {
          nsex.printStackTrace();
        }
        logger.error("SubRequest not found");
        request.setErrorStatus(PDU.genErr);
      }
    }


    public boolean isSupported(int pduType) {
      return (pduType == PDU.GETNEXT);
    }

  }

  class SetHandler implements RequestHandler {

    public void prepare(OctetString context,
                        Request request, MOServer server) {
      try {
        SubRequestIterator it = (SubRequestIterator) request.iterator();
        while ((!request.isPhaseComplete()) && (it.hasNext())) {
          SubRequest sreq =  it.nextSubRequest();
          if (sreq.isComplete()) {
            continue;
          }
          MOScope scope = sreq.getScope();
          MOQuery query = sreq.getQuery();
          if (query == null) {
            query = new VACMQuery(context,
                                  scope.getLowerBound(),
                                  scope.isLowerIncluded(),
                                  scope.getUpperBound(),
                                  scope.isUpperIncluded(),
                                  request.getViewName());
            sreq.setQuery(query);
          }
          if (!query.getScope().isCovered(
              new DefaultMOContextScope(context, scope))) {
            sreq.getStatus().setErrorStatus(PDU.noAccess);
          }
          else {
            ManagedObject mo = server.lookup(query);
            if (mo == null) {
              sreq.getStatus().setErrorStatus(PDU.noSuchName);
              break;
            }
            sreq.setTargetMO(mo);
            server.lock(sreq.getRequest(), mo);
            try {
              mo.prepare(sreq);
            }
            catch (Exception moex) {
              moex.printStackTrace();
              if (sreq.getStatus().getErrorStatus() == PDU.noError) {
                sreq.getStatus().setErrorStatus(PDU.genErr);
              }
              /**@todo implement error handling */
            }
          }
        }
      }
      catch (NoSuchElementException nsex) {
        if (logger.isDebugEnabled()) {
          nsex.printStackTrace();
        }
        logger.error("Cannot find sub-request: ", nsex);
        request.setErrorStatus(PDU.genErr);
      }
    }

    public void processPdu(Request request, MOServer server) {
      OctetString context = request.getContext();
      try {
        while (request.getPhase() < Request.PHASE_2PC_CLEANUP) {
          int phase = request.nextPhase();
          switch (phase) {