Smtp.idl

Go to the documentation of this file.

/**
 * @file   Smtp.idl
 * @brief  Set SMTP Server.
 *
 * @author Dusan Juhas
 *
 * @copyright Copyright © 2017 Kerio Technologies s.r.o.
 */

#import <kerio/web/idl/SharedStructures.idl>
#import <Users.idl> //ItemCountLimit
#import <FiltersCommon.idl>


module kerio {
module jsonapi {
module admin {

enum SmtpAuthentication {
   Auth,       ///< AUTH SMTP command
   Pop3Based      ///< POP3 authentication before SMTP
};

/**
 * SMTP Relay options
 */
struct Relay {
   boolean        isRestricted;           ///< is relay restricted? false == open relay enabled
   string         ipAddressGroupName;        ///< output only: name of IP group from which open relay is enabled
   kerio::web::KId   ipAddressGroupId;       ///< ID of IP group from which open relay is enabled
   boolean        authenticateOutgoing;      ///< client must authenticate before sending a message
   ItemCountLimit forwardPop3authentication; ///< client can be authenticated by POP3 before SMTP relay for certain number of minutes
   boolean        hideLocalIpInRcv;        ///< hide local IP address in receive headers
};

struct RelayAuthentication {
   boolean           isRequired;       ///< is authentication required?
   string            userName;         ///< a user name for relay server authentication
   string            password;         ///< a password for relay server authentication, it's allowed to send ID of a rule to copy a password
   SmtpAuthentication   authType;         ///< type of authentication
};

struct IpLimit {
   ItemCountLimit maximumFromIp;       ///< maximum number of messages per hour from 1 IP address
   ItemCountLimit maximumConnections;     ///< maximum number of concurrent SMTP connections from 1 IP address
   ItemCountLimit maximumUnknowns;     ///< maximum number of unknown recipients
   string         ipAddressGroupName;     ///< output only: name of IP group on which limits are NOT applied
   kerio::web::KId   ipAddressGroupId;    ///< ID of IP group on which limits are NOT applied
};

struct SmtpServerSettings {
   Relay             relayControl;        ///< relay control options
   IpLimit              ipBasedLimit;        ///< limits based on IP address
   boolean              blockUnknownDns;     ///< block is sender's mail domain was not found in DNS
   boolean              verifyClientRDnsEntry;  ///< block if client's IP address has no reverse DNS entry (PTR)
   boolean              requireLocalDomainSenderAuth; ///< require SMTP authentication if the sender's address is from a local domain
   ItemCountLimit       maximumRecipients;      ///< maximum number of recipients in 1 message
   ItemCountLimit       maximumSmtpFailures; ///< maximum number of failed commands in 1 SMTP session
   kerio::web::SizeLimit   messageSize;         ///< limit for incomming SMTP message size
   long              readerHops;          ///< maximum number of accepted received headers (hops)
   boolean              useSSL;              ///< use SSL if supported by remote SMTP server
   long              maximumThreads;         ///< maximum number of delivery threads
   TimeLimit            retryInterval;       ///< delivery retry interval
   TimeLimit            bounceInterval;         ///< bounce the message to the sender if not delivered in defined time
   TimeLimit            warningInterval;     ///< warn sender if a message is not delivered within define time
   string               reportLanguage;         ///< 2 char abbreviation; we don't support reports added by user
};


enum RelayRuleCondType {
   RelayCondNone,         ///< there is none condition; it's always true  
   RelayCondRecipient,    ///< recipient from envelope
   RelayCondSender        ///< sender from envelope
};

enum RelayRuleComparatorType {
   RelayCompEqual,
   RelayCompNotEqual
};

struct RelayRuleCondition {
   RelayRuleCondType test;
   RelayRuleComparatorType comparator;
   string pattern; ///< patern shoud be type match E.g. *@example.com 
};

struct RelayDeliveryRule {
   kerio::web::KId     id;             ///< [READ-ONLY] global identification
   boolean             isEnabled;
   string              description;    ///< contains rule description
   string            hostName;       ///< relay server hostname
   long           port;           ///< relay server port
   RelayAuthentication  authentication; ///< relay server authentication parameters
   RelayRuleCondition  condition;
};
typedef sequence<RelayDeliveryRule> RelayDeliveryRuleList;

struct FilterRule {
   boolean isIncomplete;                  ///< if rule is not completed (it does not contain any definition of conditions and actions)

   kerio::jsonapi::filters::EvaluationModeType evaluationMode;     ///< determines evaluation mod of initial conditions
   kerio::jsonapi::filters::FilterConditionList conditions;        ///< list of rule's initial conditions
   kerio::jsonapi::filters::FilterActionList actions;              ///< list of rule's actions (performed if initial conditions are meet)
};

struct DeliveryRule {
   kerio::web::KId id;                    ///< [READ-ONLY] global identification
   boolean isEnabled;                     ///< says whether rule is enabled
   string description;                    ///< contains rules description
   FilterRule rule;  
};
typedef sequence<DeliveryRule> DeliveryRuleList;

interface Smtp {

   /**
    * Obtain SMTP server settings.
    *
    * @param server - SMTP settings
    */
   void get(out SmtpServerSettings server);

   /**
    * Change SMTP server settings.
    *
    * @param server - SMTP settings
    */
   void set(in SmtpServerSettings server); 

   void getRelayDeliveryRuleList(out RelayDeliveryRuleList list);
   void setRelayDeliveryRuleList(in RelayDeliveryRuleList list);

   void getIncomingRuleList(out DeliveryRuleList list);
   void setIncomingRuleList(in DeliveryRuleList list);

   void getOutgoingRuleList(out DeliveryRuleList list);
   void setOutgoingRuleList(in DeliveryRuleList list);
};

}; }; };//end of namespace