Esempio n. 1
0
  private void sendNewSuspectEvent(InetAddress address, Long rtt, String foreignSource) {
    EventBuilder eb =
        new EventBuilder(EventConstants.NEW_SUSPECT_INTERFACE_EVENT_UEI, "OpenNMS.Discovery");
    eb.setInterface(address);
    eb.setHost(InetAddressUtils.getLocalHostName());

    eb.addParam("RTT", rtt);

    if (foreignSource != null) {
      eb.addParam("foreignSource", foreignSource);
    }

    try {
      m_ipc_manager.sendNow(eb.getEvent());
      LOG.debug("Sent event: {}", EventConstants.NEW_SUSPECT_INTERFACE_EVENT_UEI);
    } catch (Throwable t) {
      LOG.warn("run: unexpected throwable exception caught during send to middleware", t);
    }
  }
Esempio n. 2
0
/**
 * This class is designed to be used by the capabilities daemon to test for the existance of an SMTP
 * server on remote interfaces. The class implements the Plugin interface that allows it to be used
 * along with other plugins by the daemon.
 *
 * @author <a href="mailto:[email protected]">Sowmya</a>
 * @author <a href="mailto:[email protected]">Weave</a>
 * @author <a href="http://www.opennms.org">OpenNMS</a>
 */
public final class SmtpPlugin extends AbstractPlugin {

  /**
   * The regular expression test used to determine if the reply is a multi line reply. A multi line
   * reply is one that each line, but the last, is in the form of "ddd-" where 'ddd' is the result
   * code.
   */
  private static final RE MULTILINE_RESULT;

  /** The capability name of the plugin. */
  private static final String PROTOCOL_NAME = "SMTP";

  /** The default port on which the host is checked to see if it supports SMTP. */
  private static final int DEFAULT_PORT = 25;

  /** Default number of retries for SMTP requests. */
  private static final int DEFAULT_RETRY = 0;

  /** Default timeout (in milliseconds) for SMTP requests. */
  private static final int DEFAULT_TIMEOUT = 5000; // in milliseconds

  /** The name of the local host. */
  private static final String LOCALHOST_NAME = InetAddressUtils.getLocalHostName();

  static {
    try {
      MULTILINE_RESULT = new RE("^[1-5][0-9]{2}-");
    } catch (RESyntaxException re) {
      throw new java.lang.reflect.UndeclaredThrowableException(re);
    }
  }

  /**
   * Test to see if the passed host-port pair is the endpoint for an SMTP server. If there is an
   * SMTP server at that destination then a value of true is returned from the method. Otherwise a
   * false value is returned to the caller.
   *
   * @param host The remote host to connect to.
   * @param port The remote port on the host.
   * @return True if server supports SMTP on the specified port, false otherwise
   */
  private boolean isServer(InetAddress host, int port, int retries, int timeout) {
    // get a log to send errors
    //
    ThreadCategory log = ThreadCategory.getInstance(getClass());

    boolean isAServer = false;
    for (int attempts = 0; attempts <= retries && !isAServer; attempts++) {
      Socket socket = null;
      try {
        socket = new Socket();
        socket.connect(new InetSocketAddress(host, port), timeout);
        socket.setSoTimeout(timeout);
        log.debug("SmtpPlugin: connected to host: " + host + " on port: " + port);

        // Allocate a line reader
        //
        BufferedReader lineRdr = new BufferedReader(new InputStreamReader(socket.getInputStream()));

        // Read responses from the server. The initial line should just
        // be a banner, but go ahead and check for multiline response.
        //
        String result = null;
        do {
          result = lineRdr.readLine();

        } while (result != null && result.length() > 0 && MULTILINE_RESULT.match(result));

        if (result == null || result.length() == 0) {
          log.info("Received truncated response from SMTP server " + InetAddressUtils.str(host));
          continue;
        }

        // Tokenize the last line result
        //
        StringTokenizer t = new StringTokenizer(result);
        int rc = Integer.parseInt(t.nextToken());
        if (rc == 220) {
          //
          // Send the HELO command
          //
          String cmd = "HELO " + LOCALHOST_NAME + "\r\n";
          socket.getOutputStream().write(cmd.getBytes());

          // Response from HELO command may be a multi-line response
          // (but
          // most likely will be single-line)..
          // We are expecting to get a response with an integer return
          // code in the first token. We can't ge sure that the first
          // response will give us what we want. Consider the
          // following
          // reponse for example:
          //
          // 250-First line
          // 250-Second line
          // 250 Requested mail action okay, completed
          //
          // In this case the final line of the response contains the
          // return
          // code we are looking for.
          do {
            result = lineRdr.readLine();

          } while (result != null && result.length() > 0 && MULTILINE_RESULT.match(result));

          if (result == null || result.length() == 0) {
            log.info("Received truncated response from SMTP server " + InetAddressUtils.str(host));
            continue;
          }

          t = new StringTokenizer(result);
          rc = Integer.parseInt(t.nextToken());
          if (rc == 250) {
            //
            // Send the QUIT command
            //
            cmd = "QUIT\r\n";
            socket.getOutputStream().write(cmd.getBytes());

            // Response from QUIT command may be a multi-line
            // response.
            // We are expecting to get a response with an integer
            // return
            // code in the first token. We can't ge sure that the
            // first
            // response will give us what we want. Consider the
            // following
            // reponse for example:
            //
            // 221-First line
            // 221-Second line
            // 221 <domain> Service closing transmission channel.
            //
            // In this case the final line of the response contains
            // the return
            // code we are looking for.
            do {
              result = lineRdr.readLine();

            } while (result != null && result.length() > 0 && MULTILINE_RESULT.match(result));

            if (result == null || result.length() == 0) {
              log.info(
                  "Received truncated response from SMTP server " + InetAddressUtils.str(host));
              continue;
            }

            t = new StringTokenizer(result);
            rc = Integer.parseInt(t.nextToken());

            if (rc == 221) isAServer = true;
          }
        }
      } catch (NumberFormatException e) {
        log.info(
            "SmtpPlugin: received invalid result code from server " + InetAddressUtils.str(host),
            e);
        isAServer = false;
      } catch (ConnectException cE) {
        // Connection refused!! Continue to retry.
        //
        log.debug("SmtpPlugin: connection refused to " + InetAddressUtils.str(host) + ":" + port);
        isAServer = false;
      } catch (NoRouteToHostException e) {
        // No route to host!! No need to perform retries.
        e.fillInStackTrace();
        log.info(
            "SmtpPlugin: Unable to test host "
                + InetAddressUtils.str(host)
                + ", no route available",
            e);
        isAServer = false;
        throw new UndeclaredThrowableException(e);
      } catch (InterruptedIOException e) {
        log.debug(
            "SmtpPlugin: did not connect to host within timeout: "
                + timeout
                + " attempt: "
                + attempts);
        isAServer = false;
      } catch (IOException e) {
        log.info("SmtpPlugin: Error communicating with host " + InetAddressUtils.str(host), e);
        isAServer = false;
      } catch (Throwable t) {
        log.warn(
            "SmtpPlugin: Undeclared throwable exception caught contacting host "
                + InetAddressUtils.str(host),
            t);
        isAServer = false;
      } finally {
        try {
          if (socket != null) socket.close();
        } catch (IOException e) {
        }
      }
    }

    //
    // return the success/failure of this
    // attempt to contact an SMTP server.
    //
    return isAServer;
  }

  /**
   * Returns the name of the protocol that this plugin checks on the target system for support.
   *
   * @return The protocol name for this plugin.
   */
  @Override
  public String getProtocolName() {
    return PROTOCOL_NAME;
  }

  /**
   * {@inheritDoc}
   *
   * <p>Returns true if the protocol defined by this plugin is supported. If the protocol is not
   * supported then a false value is returned to the caller.
   */
  @Override
  public boolean isProtocolSupported(InetAddress address) {
    return isServer(address, DEFAULT_PORT, DEFAULT_RETRY, DEFAULT_TIMEOUT);
  }

  /**
   * {@inheritDoc}
   *
   * <p>Returns true if the protocol defined by this plugin is supported. If the protocol is not
   * supported then a false value is returned to the caller. The qualifier map passed to the method
   * is used by the plugin to return additional information by key-name. These key-value pairs can
   * be added to service events if needed.
   */
  @Override
  public boolean isProtocolSupported(InetAddress address, Map<String, Object> qualifiers) {
    int retries = DEFAULT_RETRY;
    int timeout = DEFAULT_TIMEOUT;
    int port = DEFAULT_PORT;

    if (qualifiers != null) {
      retries = ParameterMap.getKeyedInteger(qualifiers, "retry", DEFAULT_RETRY);
      timeout = ParameterMap.getKeyedInteger(qualifiers, "timeout", DEFAULT_TIMEOUT);
      port = ParameterMap.getKeyedInteger(qualifiers, "port", DEFAULT_PORT);
    }

    boolean result = isServer(address, port, retries, timeout);
    if (result && qualifiers != null && !qualifiers.containsKey("port"))
      qualifiers.put("port", port);

    return result;
  }
}