Java RejectException类代码示例

import org.subethamail.smtp.RejectException; //导入依赖的package包/类
/**
 * Gets the current connection to the remote host, or creates one.
 * @throws RejectException if something goes wrong connecting to the backend
 */
SmartClient getFallbackConnection() throws RejectException
{
	if (this.fallbackConnection == null)
	{
		String hostAndPort = SMTPHandler.this.smtpService.getFallbackHost();
		if (hostAndPort != null)
		{
			String[] split = hostAndPort.split(":");
			int port = split.length > 1 ? Integer.parseInt(split[1]) : 25;

			try
			{
				this.fallbackConnection = new SmartClient(split[0], port, this.ctx.getSMTPServer().getHostName());
			}
			catch (IOException e)
			{
				throw new RejectException(554, e.toString());
			}
		}
	}

	return this.fallbackConnection;
}
 

import org.subethamail.smtp.RejectException; //导入依赖的package包/类
@Override
public AuthenticationHandler create()
{
    return new AuthenticationHandler() {
        @Override
        public String auth(String clientInput)
                throws RejectException
        {
            auth.add(clientInput);
            throw new RejectException();
        }

        @Override
        public Object getIdentity()
        {
            throw new AssertionError();
        }
    };
}
 

import org.subethamail.smtp.RejectException; //导入依赖的package包/类
@Override
public FilterReply verifyRecipient(RecipientContext recipientContext)
        throws RejectExceptionExt {
    SPFResult spfResult = spfChecker.getResult();
    String spfResultCode = spfResult.getResult();

    if (spfResultCode.equals(SPFErrorConstants.FAIL_CONV)) {
        String statusText;
        if (spfResult.getExplanation().isEmpty())
            statusText = "Blocked by SPF";
        else
            statusText = "Blocked - see: " + spfResult.getExplanation();
        throw new RejectException(550, statusText);
    } else if (spfResult.equals(SPFErrorConstants.TEMP_ERROR_CONV)) {
        throw new RejectException(451,
                "Temporarily rejected: Problem on SPF lookup");
    } else if (rejectOnPermanentError
            && spfResultCode.equals(SPFErrorConstants.PERM_ERROR_CONV)) {
        throw new RejectException(550, "Blocked - invalid SPF record");
    }

    return chain.verifyRecipient(recipientContext);
}
 

import org.subethamail.smtp.RejectException; //导入依赖的package包/类
public void deliver(InputStream data) throws RejectException, TooMuchDataException, IOException
{
	this.client.dataStart();

	byte[] buffer = new byte[8192];
	int numRead;
	while ((numRead = data.read(buffer)) > 0)
		this.client.dataWrite(buffer, numRead);

	this.client.dataEnd();
}
 

import org.subethamail.smtp.RejectException; //导入依赖的package包/类
protected void startSMTP(String factory) {
  wiser = new Wiser();

  wiser.setPort(1587);
  wiser.getServer().setAuthenticationHandlerFactory(new AuthenticationHandlerFactory() {
    /*
     * AUTH PLAIN handler which returns success on any string
     */
    @Override
    public List<String> getAuthenticationMechanisms() {
      return Arrays.asList("PLAIN");
    }

    @Override
    public AuthenticationHandler create() {
      return new AuthenticationHandler() {

        @Override
        public String auth(final String clientInput) throws RejectException {
          log.info(clientInput);
          return null;
        }

        @Override
        public Object getIdentity() {
          return "username";
        }
      };
    }
  });

  Security.setProperty("ssl.SocketFactory.provider", factory);
  wiser.getServer().setEnableTLS(true);

  wiser.start();
}
 

import org.subethamail.smtp.RejectException; //导入依赖的package包/类
private ReversePath convertToReversePath(String reversePath)
        throws RejectException {
    try {
        return new MailAddressFactory().createReversePath(reversePath);
    } catch (ParseException e) {
        logger.debug("Syntax error in reverse path " + reversePath, e);
        throw new RejectException(553, "Syntax error in reverse path "
                + reversePath);
    }
}
 

import org.subethamail.smtp.RejectException; //导入依赖的package包/类
private Recipient convertToRecipient(String recipient)
        throws RejectException {
    try {
        return new MailAddressFactory().createRecipient(recipient);
    } catch (ParseException e) {
        logger.debug("Syntax error in recipient " + recipient, e);
        throw new RejectException(553, "Syntax error in mailbox name "
                + recipient);
    }
}
 

import org.subethamail.smtp.RejectException; //导入依赖的package包/类
@Override
public void data(Mail mail) throws RejectExceptionExt {
    try {
        transmitter.transmit(mail);
    } catch (LocalMailSystemException e) {
        logger.warn("Cannot accept mail because of a "
                + "transmission failure", e);
        throw new RejectException(e.errorStatus().getSmtpReplyCode(), e
                .errorStatus().getMessagePrefixedWithEnhancedStatusCode());
    }
}
 

import org.subethamail.smtp.RejectException; //导入依赖的package包/类
@Override
public FilterReply verifyRecipient(RecipientContext recipientContext)
        throws RejectException {
    Recipient recipient = recipientContext.recipient;
    if (recipient instanceof GlobalPostmaster)
        return FilterReply.NEUTRAL;
    else if (recipient instanceof RemotePartContainingRecipient)
        return verifyRemotePartContainingRecipient((RemotePartContainingRecipient) recipient);
    else
        throw new IllegalArgumentException();
}
 

import org.subethamail.smtp.RejectException; //导入依赖的package包/类
private FilterReply verifyRemotePartContainingRecipient(
        RemotePartContainingRecipient recipient) throws RejectException {
    RemotePart remotePart = recipient.getMailbox().getRemotePart();
    for (RemotePartSpecification remotePartSpecification : localDomainSpecifications) {
        if (remotePartSpecification.isSatisfiedBy(remotePart))
            return FilterReply.NEUTRAL;
    }
    throw new RejectException(550,
            "Relaying prohibited, user is not local (" + recipient + ")");

}
 

import org.subethamail.smtp.RejectException; //导入依赖的package包/类
@Override
public FilterReply verifyRecipient(RecipientContext recipientContext)
        throws RejectException {
    if (recipientSpecification.isSatisfiedBy(recipientContext.recipient))
        return FilterReply.ACCEPT;
    else
        return FilterReply.NEUTRAL;
}
 

import org.subethamail.smtp.RejectException; //导入依赖的package包/类
@Override
public FilterReply verifyRecipient(RecipientContext recipientContext)
        throws RejectException {
    if (recipientContext.recipient.isPostmaster())
        return FilterReply.ACCEPT;
    else
        return FilterReply.NEUTRAL;
}
 

import org.subethamail.smtp.RejectException; //导入依赖的package包/类
@Override
public FilterReply verifyRecipient(RecipientContext recipientContext)
        throws RejectException {
    if (recipientContext.recipient.isGlobalPostmaster())
        return FilterReply.ACCEPT;
    else
        return FilterReply.NEUTRAL;
}
 

import org.subethamail.smtp.RejectException; //导入依赖的package包/类
@Override
public FilterReply verifyRecipient(RecipientContext recipientContext)
        throws RejectException {
    if (recipientContext.recipient.isDomainPostmaster())
        return FilterReply.ACCEPT;
    return FilterReply.NEUTRAL;
}
 

import org.subethamail.smtp.RejectException; //导入依赖的package包/类
private void sendDataStream(InputStream data) throws IOException,
        RejectException {
    byte[] buffer = new byte[8192];
    int numRead;
    while ((numRead = data.read(buffer)) > 0) {
        try {
            smartClient.dataWrite(buffer, numRead);
        } catch (IOException e) {
            throw new RejectException(451, e.getMessage());
        }
    }
}