def main():
# banner
print('mraptor_milter v%s - http://decalage.info/python/oletools' % __version__)
print('logging to file %s' % LOGFILE_PATH)
print('Press Ctrl+C to stop.')
# make sure the log directory exists:
try:
os.makedirs(LOGFILE_DIR)
except:
pass
# Add the log message handler to the logger
# log to files rotating once a day:
handler = logging.handlers.TimedRotatingFileHandler(LOGFILE_PATH, when='D', encoding='utf8')
# create formatter and add it to the handlers
formatter = logging.Formatter('%(asctime)s - %(levelname)8s: %(message)s')
handler.setFormatter(formatter)
log.addHandler(handler)
# enable logging:
log.setLevel(logging.DEBUG)
log.info('Starting mraptor_milter v%s - listening on %s' % (__version__, SOCKET))
log.debug('Python version: %s' % sys.version)
# Register to have the Milter factory create instances of the class:
Milter.factory = MacroRaptorMilter
flags = Milter.CHGBODY + Milter.CHGHDRS + Milter.ADDHDRS
flags += Milter.ADDRCPT
flags += Milter.DELRCPT
Milter.set_flags(flags) # tell Sendmail which features we use
# set the "last" fall back to ACCEPT if exception occur
Milter.set_exception_policy(Milter.ACCEPT)
# start the milter
Milter.runmilter("mraptor_milter", SOCKET, TIMEOUT)
log.info('Stopping mraptor_milter.')
def main():
# Load the whitelist into memory
WhiteListLoad()
HashTableLoad()
thread_pool = create_and_start_worker_threads()
# Register to have the Milter factory create instances of the class:
Milter.factory = MacroMilter
flags = Milter.CHGBODY + Milter.CHGHDRS + Milter.ADDHDRS
flags += Milter.ADDRCPT
flags += Milter.DELRCPT
Milter.set_flags(flags) # tell Sendmail which features we use
# start milter processing
print "%s Macro milter startup - Version %s" % (time.strftime('%d.%b.%Y %H:%M:%S'), __version__)
sys.stdout.flush()
# set the "last" fall back to ACCEPT if exception occur
Milter.set_exception_policy(Milter.ACCEPT)
# start the milter
Milter.runmilter("MacroMilter", SOCKET, TIMEOUT)
shutdown_worker_threads(thread_pool)
cleanup_queues()
print "%s Macro milter shutdown" % time.strftime('%d.%b.%Y %H:%M:%S')
def main():
# banner
print('mraptor_milter v%s - http://decalage.info/python/oletools' % __version__)
print('logging to file %s' % LOGFILE_PATH)
print('Press Ctrl+C to stop.')
# make sure the log directory exists:
try:
os.makedirs(LOGFILE_DIR)
except:
pass
# Add the log message handler to the logger
# log to files rotating once a day:
handler = logging.handlers.TimedRotatingFileHandler(LOGFILE_PATH, when='D', encoding='utf8')
# create formatter and add it to the handlers
formatter = logging.Formatter('%(asctime)s - %(levelname)8s: %(message)s')
handler.setFormatter(formatter)
log.addHandler(handler)
# enable logging:
log.setLevel(logging.DEBUG)
log.info('Starting mraptor_milter v%s - listening on %s' % (__version__, SOCKET))
log.debug('Python version: %s' % sys.version)
# Register to have the Milter factory create instances of the class:
Milter.factory = MacroRaptorMilter
flags = Milter.CHGBODY + Milter.CHGHDRS + Milter.ADDHDRS
flags += Milter.ADDRCPT
flags += Milter.DELRCPT
Milter.set_flags(flags) # tell Sendmail which features we use
# set the "last" fall back to ACCEPT if exception occur
Milter.set_exception_policy(Milter.ACCEPT)
# start the milter
Milter.runmilter("mraptor_milter", SOCKET, TIMEOUT)
log.info('Stopping mraptor_milter.')
def run(name, config):
"""Start a milter loop.
"""
Milter.factory = PGPMilter
Milter.factory.config = config
Milter.set_flags(Milter.ADDHDRS + Milter.CHGHDRS + Milter.CHGBODY)
Milter.runmilter(name, config.socket, timeout=config.timeout)
def main():
# Run as a specific user
if run_as_user != None:
run_as_uid = getpwnam(run_as_user).pw_uid
run_as_gid = getpwnam(run_as_user).pw_gid
print "%s running as %s (uid=%s,gid=%s)" % (time.strftime('%Y%b%d %H:%M:%S'), run_as_user, run_as_uid, run_as_gid)
# always set gid first, because once we've set uid, we can't set gid anymore
os.setgid(run_as_gid)
os.setuid(run_as_uid)
# Log startup
print "%s milter startup" % time.strftime('%Y%b%d %H:%M:%S')
sys.stdout.flush()
# Handle log printing in the background
bt = Thread(target=background)
bt.start()
# Register to have the Milter factory create instances of your class:
Milter.factory = MilterSysUser
#Milter.set_flags(Milter.ADDHDRS) # we only need to add a header
flags = Milter.CHGBODY + Milter.CHGHDRS + Milter.ADDHDRS
flags += Milter.ADDRCPT
flags += Milter.DELRCPT
Milter.set_flags(flags) # tell Sendmail which features we use
Milter.runmilter("pythonfilter", socketname, timeout)
# Wait for logger to complete
logq.put(None)
bt.join()
print "%s milter shutdown" % time.strftime('%Y%b%d %H:%M:%S')
def main():
"""Start the milter."""
socket = "/tmp/change-rcpt-milter.sock"
timeout = 600
Milter.factory = ChangeRecipientMilter
logger.info("{} {} starting".format(MILTER_NAME, MILTER_VERSION))
Milter.runmilter(MILTER_NAME, socket, timeout)
logger.info("{} {} shutting down".format(MILTER_NAME, MILTER_VERSION))
def main():
# make sure the log directory exists:
try:
os.makedirs(LOGFILE_DIR, 0o0027)
except:
pass
# Load the whitelist into memory
WhiteListLoad()
HashTableLoad()
# Add the log message handler to the logger
# rotation handeld by logrotatd
oldumask = os.umask(0o0026)
handler = logging.handlers.WatchedFileHandler(LOGFILE_PATH,
encoding='utf8')
# create formatter and add it to the handlers
formatter = logging.Formatter('%(asctime)s - %(levelname)8s: %(message)s')
handler.setFormatter(formatter)
log.addHandler(handler)
os.umask(oldumask)
# Loglevels are: 1 = Debug, 2 = Info, 3 = Error
if LOGLEVEL == 2:
log.setLevel(logging.INFO)
elif LOGLEVEL == 3:
log.setLevel(logging.WARNING)
else:
log.setLevel(logging.DEBUG)
# Register to have the Milter factory create instances of the class:
Milter.factory = MacroMilter
flags = Milter.CHGBODY + Milter.CHGHDRS + Milter.ADDHDRS
flags += Milter.ADDRCPT
flags += Milter.DELRCPT
Milter.set_flags(flags) # tell Sendmail which features we use
# start milter processing
print("%s MacroMilter startup - Version %s" %
(time.strftime('%Y-%m-%d %H:%M:%S'), __version__))
print('logging to file %s' % LOGFILE_PATH)
log.info('Starting MarcoMilter v%s - listening on %s' %
(__version__, SOCKET))
log.debug('Python version: %s' % sys.version)
sys.stdout.flush()
# ensure desired permissions on unix socket
os.umask(UMASK)
# set the "last" fall back to ACCEPT if exception occur
Milter.set_exception_policy(Milter.ACCEPT)
# start the milter
Milter.runmilter("MacroMilter", SOCKET, TIMEOUT)
print("%s MacroMilter shutdown" % time.strftime('%Y-%m-%d %H:%M:%S'))
def run(self):
utils.log_to_syslog()
logger.info('DSPAM Milter startup (v{})'.format(VERSION))
self.configure()
utils.daemonize(self.pidfile)
Milter.factory = DspamMilter
Milter.runmilter('DspamMilter', self.socket, self.timeout)
logger.info('DSPAM Milter shutdown (v{})'.format(VERSION))
logging.shutdown()
def main():
bt = Thread()
bt.start()
timeout = 60
# Register with Milter factory
Milter.factory = pgpMilter
# we don't modify mails, so no flags
Milter.set_flags(0)
Milter.runmilter("pgpmilter",socket,timeout)
bt.join()
def main():
socketname = "/var/run/nomixsock"
timeout = 600
# Register to have the Milter factory create instances of your class:
Milter.factory = NoMixMilter
print("%s milter startup" % time.strftime('%Y%b%d %H:%M:%S'))
sys.stdout.flush()
Milter.runmilter("nomixfilter",socketname,timeout)
logq.put(None)
bt.join()
print("%s nomix milter shutdown" % time.strftime('%Y%b%d %H:%M:%S'))
def main():
timeout = 600
Milter.factory = LissMilter
# Tell Sendmail which features we use
flags = Milter.CHGHDRS
Milter.set_flags(flags)
print("%s milter startup" % time.strftime('%Y-%m-%d %H:%M:%S'))
sys.stdout.flush()
Milter.runmilter("lissmilter", connection_string, timeout)
print("%s milter shutdown" % time.strftime('%Y-%m-%d %H:%M:%S'))
def main():
sys.stdout.write("--------------- WUMI START ---------------\n")
sys.stdout.flush()
cfg.vars = cfg.Globals(configfile)
syslog.openlog(cfg.vars["filtername"])
Milter.factory = WUMilter
Milter.set_flags(Milter.ADDHDRS | Milter.CHGHDRS)
Milter.runmilter(cfg.vars["filtername"],
cfg.vars["socketname"],
timeout=1800)
print '%s: runmilter returned - shutdown' % cfg.vars["filtername"]
def main():
bt = Thread(target=background)
bt.start()
socketname = "/var/run/pagure/paguresock"
timeout = 600
# Register to have the Milter factory create instances of your class:
Milter.factory = PagureMilter
print "%s pagure milter startup" % time.strftime('%Y%b%d %H:%M:%S')
sys.stdout.flush()
Milter.runmilter("paguremilter", socketname, timeout)
logq.put(None)
bt.join()
print "%s pagure milter shutdown" % time.strftime('%Y%b%d %H:%M:%S')
def main():
bt = Thread( target = background )
bt.start()
socketname = "/var/spool/EARS/EARSmilter.sock"
timeout = 600
Milter.factory = EARS.milter
flags = Milter.CHGBODY + Milter.CHGHDRS + Milter.ADDHDRS
flags += Milter.ADDRCPT
flags += Milter.DELRCPT
Milter.set_flags( flags ) # tell Sendmail/Postfix which features we use
Milter.runmilter( "EARSmilter", socketname, timeout )
logq.put( None )
bt.join()
def main():
bt = Thread(target=background)
bt.start()
socketname = "/var/run/pagure/paguresock"
timeout = 600
# Register to have the Milter factory create instances of your class:
Milter.factory = PagureMilter
print "%s pagure milter startup" % time.strftime("%Y%b%d %H:%M:%S")
sys.stdout.flush()
Milter.runmilter("paguremilter", socketname, timeout)
logq.put(None)
bt.join()
print "%s pagure milter shutdown" % time.strftime("%Y%b%d %H:%M:%S")
def main():
parser = OptionParser()
parser.add_option('-s', '--socket', dest='socket', help='Socket to listen (e.g. inet:8890@localhost)')
parser.add_option('-t', '--timeout', type='int', dest='timeout', default='10', help='MTA timeout (default is 10 sec)')
(options, args) = parser.parse_args()
if not options.socket:
parser.print_help()
sys.exit(0)
Milter.factory = TuMilter
print "%s TuMilter startup" % time.strftime('%Y %b %d %H:%M:%S')
sys.stdout.flush()
Milter.runmilter("tumilter",options.socket,options.timeout)
def main():
"""Main entry point, run the milter and start the background logging daemon"""
try:
debug = configParser.getboolean('main', 'debug')
# Exit if the main thread have been already created
if os.path.exists(PID_FILE_PATH):
print("pid file {} already exists, exiting".format(PID_FILE_PATH))
os.exit(-1)
lgThread = Thread(target=loggingThread)
lgThread.start()
timeout = 600
# Register to have the Milter factory create new instances
Milter.factory = MarkAddressBookMilter
# For this milter, we only add headers
flags = Milter.ADDHDRS
Milter.set_flags(flags)
# Get the parent process ID and remember it
pid = os.getpid()
with open(PID_FILE_PATH, "w") as pidFile:
pidFile.write(str(pid))
pidFile.close()
print("Started RoundCube address book search and tag milter (pid={}, debug={})".format(pid, debug))
sys.stdout.flush()
# Start the background thread
Milter.runmilter("milter-rc-abook", SOCKET_PATH, timeout)
GlobalLogQueue.put(None)
# Wait until the logging thread terminates
lgThread.join()
# Log the end of process
print("Stopped RoundCube address book search and tag milter (pid={})".format(pid))
except Exception as error:
print("Exception when running the milter: {}".format(error.message))
# Make sure to remove the pid file even if an error occurs
# And close the database connection if opened
finally:
if os.path.exists(PID_FILE_PATH):
os.remove(PID_FILE_PATH)
def main():
os.umask(007)
Milter.set_flags( Milter.QUARANTINE
+ Milter.CHGHDRS
+ Milter.DELRCPT
+ Milter.ADDRCPT
+ Milter.CHGFROM)
config = getConfig()
def instantiate():
return DMARCMilter(config)
Milter.factory = instantiate
Milter.runmilter("dmarc_milter", config.socket, config.timeout)
def main():
bt = Thread(target=background)
bt.start()
socketname = "/home/stuart/pythonsock"
timeout = 600
# Register to have the Milter factory create instances of your class:
Milter.factory = myMilter
flags = Milter.CHGBODY + Milter.CHGHDRS + Milter.ADDHDRS
flags += Milter.ADDRCPT
flags += Milter.DELRCPT
Milter.set_flags(flags) # tell Sendmail which features we use
print("%s milter startup" % time.strftime('%Y%b%d %H:%M:%S'))
sys.stdout.flush()
Milter.runmilter("pythonfilter",socketname,timeout)
logq.put(None)
bt.join()
print("%s bms milter shutdown" % time.strftime('%Y%b%d %H:%M:%S'))
def main():
# Load the whitelist into memory
WhiteListLoad()
HashTableLoad()
# create helper threads
bt = Thread(target=background)
perft = Thread(target=writeperformacedata)
ha = Thread(target=writehashtofile)
ex = Thread(target=writeExData)
# start helper threads
ex.start()
perft.start()
bt.start()
ha.start()
# Register to have the Milter factory create instances of the class:
Milter.factory = MacroMilter
flags = Milter.CHGBODY + Milter.CHGHDRS + Milter.ADDHDRS
flags += Milter.ADDRCPT
flags += Milter.DELRCPT
Milter.set_flags(flags) # tell Sendmail which features we use
# start milter processing
print "%s Macro milter startup - Version %s" % (time.strftime('%d.%b.%Y %H:%M:%S'), __version__)
sys.stdout.flush()
# set the "last" fall back to ACCEPT if exception occur
Milter.set_exception_policy(Milter.ACCEPT)
# start the milter
Milter.runmilter("MacroMilter",SOCKET,TIMEOUT)
# wait for helper threads
bt.join() # stop logging thread
perft.join() # stop performance data thread
ha.join() # stop hash data thread
ex.join() # stop filename thread - obsolete - delete in next version
# cleanup the queues
logq.put(None)
extension_data.put(None)
hash_to_write.put(None)
performace_data.put(None)
print "%s Macro milter shutdown" % time.strftime('%d.%b.%Y %H:%M:%S')
def main():
bt = Thread(target=background)
bt.start()
socketname = "/home/stuart/pythonsock"
timeout = 600
Milter.factory = myMilter
flags = Milter.CHGBODY + Milter.CHGHDRS + Milter.ADDHDRS
flags += Milter.ADDRCPT
flags += Milter.DELRCPT
Milter.set_flags(flags)
print "%s milter startup" % time.strftime('%Y%b%d %H:%M:%S')
sys.stdout.flush()
Milter.runmilter("pythonfilter",socketname,timeout)
logq.put(None)
bt.join()
print "%s bms milter shutdown" % time.strftime('%Y%b%d %H:%M:%S')
def main():
bt = Thread(target=background)
bt.start()
socketname = "/home/stuart/pythonsock"
timeout = 600
# Register to have the Milter factory create instances of your class:
Milter.factory = myMilter
flags = Milter.CHGBODY + Milter.CHGHDRS + Milter.ADDHDRS
flags += Milter.ADDRCPT
flags += Milter.DELRCPT
Milter.set_flags(flags) # tell Sendmail which features we use
print "%s milter startup" % time.strftime('%Y%b%d %H:%M:%S')
sys.stdout.flush()
Milter.runmilter("pythonfilter",socketname,timeout)
logq.put(None)
bt.join()
print "%s bms milter shutdown" % time.strftime('%Y%b%d %H:%M:%S')
def main():
# fully qualified name for the socket, postfix will only see /var/run/zf/sock
socketname = "/var/spool/postfix/var/run/zf/sock"
timeout = 600
# Register to have the Milter factory create instances of your class:
Milter.factory = zfMilter
# these flags allow us to change the body, recipients and headers
flags = Milter.CHGBODY + Milter.CHGHDRS + Milter.ADDHDRS
flags += Milter.ADDRCPT
flags += Milter.DELRCPT
Milter.set_flags(flags) # tell Sendmail which features we use
syslog.syslog(
syslog.LOG_INFO,
json.dumps(
{"msg": "%s milter startup" % time.strftime('%Y%b%d %H:%M:%S')}))
sys.stdout.flush()
Milter.runmilter("zfmilter", socketname, timeout)
print "%s zf milter shutdown" % time.strftime('%Y%b%d %H:%M:%S')
def main():
# TODO: log to file with rotation
logging.basicConfig(format='%(levelname)8s: %(message)s', level=logging.DEBUG)
logging.info('Starting MacroRaptorMilter - listening on %s' % SOCKET)
logging.info('Press Ctrl+C to stop.')
# Register to have the Milter factory create instances of the class:
Milter.factory = MacroRaptorMilter
flags = Milter.CHGBODY + Milter.CHGHDRS + Milter.ADDHDRS
flags += Milter.ADDRCPT
flags += Milter.DELRCPT
Milter.set_flags(flags) # tell Sendmail which features we use
# set the "last" fall back to ACCEPT if exception occur
Milter.set_exception_policy(Milter.ACCEPT)
# start the milter
Milter.runmilter("MacroRaptorMilter", SOCKET, TIMEOUT)
logging.info('Stopping MacroRaptorMilter.')
def main():
# Ugh, but there's no easy way around this.
global milterconfig
global privateRSA
global privateEd25519
global publicSuffixList
privateRSA = False
privateEd25519 = False
configFile = '/usr/local/etc/senderauth-milter.conf'
pslFile = '/usr/local/etc/public_suffix_list.dat'
if len(sys.argv) > 1:
if sys.argv[1] in ('-?', '--help', '-h'):
print('usage: dkimpy-milter [<configfilename>]')
sys.exit(1)
configFile = sys.argv[1]
milterconfig = config._processConfigFile(filename=configFile)
if milterconfig.get('Syslog'):
facility = eval("syslog.LOG_{0}".format(
milterconfig.get('SyslogFacility').upper()))
syslog.openlog(os.path.basename(sys.argv[0]), syslog.LOG_PID, facility)
setExceptHook()
#
pid = write_pid(milterconfig)
if milterconfig.get('KeyFile'):
privateRSA = read_keyfile(milterconfig, 'RSA')
if milterconfig.get('KeyFileEd25519'):
privateEd25519 = read_keyfile(milterconfig, 'Ed25519')
Milter.factory = dkimMilter
Milter.set_flags(Milter.CHGHDRS + Milter.ADDHDRS)
miltername = 'samilter'
socketname = milterconfig.get('Socket')
if milterconfig.get('Syslog'):
syslog.syslog('samilter started:{0} user:{1}'.format(
pid, milterconfig.get('UserID')))
publicSuffixList = dmarc.PublicSuffixList(pslFile)
if not publicSuffixList:
if milterconfig.get('Syslog'):
syslog.syslog('Could not open PSL file:{}'.format(pslFile))
sys.exit(1)
sys.stdout.flush()
Milter.runmilter(miltername, socketname, 240)
own_socketfile(milterconfig)
drop_privileges(milterconfig)
def main():
args = arg_config()
(server_ip, server_port) = args.server.split(":")
socketspec = "inet:" + server_port + ":" + server_ip
syslog.openlog(logoption=syslog.LOG_PID, facility=syslog.LOG_MAIL)
syslog.syslog(syslog.LOG_INFO,
"Start loading rules at {}".format(datetime.datetime.now()))
load_rules(args.config)
syslog.syslog(syslog.LOG_INFO,
"Finish loading rules at {}".format(datetime.datetime.now()))
Milter.factory = MailAcl
Milter.set_flags(Milter.ADDHDRS)
syslog.syslog(syslog.LOG_DEBUG, "running milter")
Milter.runmilter("mail_acl", socketspec, 60)
# Finished
syslog.syslog(syslog.LOG_INFO, "shutdown")
def main():
#TODO parse command line
# read configuration
cfgfile = "/etc/gnupg-milter.conf"
conf = gpgmilter.config.Config(cfgfile)
conf.init_config(cfgfile)
# Register to have the Milter factory create instances of your class:
Milter.factory = gpgmilter.GnupgMilter.gpgm_get_factory(conf=conf)
flags = Milter.CHGBODY + Milter.CHGHDRS + Milter.ADDHDRS
flags += Milter.ADDRCPT
flags += Milter.DELRCPT
Milter.set_flags(flags)
print("%s gnupg-milter startup" % time.strftime('%Y-%m-%d %H:%M:%S'))
sys.stdout.flush()
Milter.runmilter("gnupg-milter", config.socket, config.timeout)
print("%s gnupg-milter shutdown" % time.strftime('%Y-%m-%d %H:%M:%S'))
def main(args=None):
import argparse
parser = argparse.ArgumentParser(
description='Ad-hoc dspam milter that does --deliver=summary'
' and only adds result as header, never rejecting or dropping messages.' )
parser.add_argument('socket',
nargs='?', default='local:/tmp/dspam_milter.sock',
help='libmilter-format socket spec to listen on (default: %(default)s).'
' Examples: local:/tmp/dspam_milter.sock, inet:1234@localhost, inet6:1234@localhost')
parser.add_argument('-u', '--user',
metavar='name', default='dspam',
help='--user parameter to pass argument to dspam client (default: %(default)s).'
' dspam-recognized group names can be passed here as well.'
' Affects spam classification groups and permissions. Empty - dont pass.')
parser.add_argument('-t', '--timeout',
type=float, default=600, metavar='seconds',
help='Number of seconds the MTA should wait'
' for a response before considering this milter dead (default: %(default)s).')
parser.add_argument('--dspam-fail-pass', action='store_true',
help='Accept mails instead of returning TEMPFAIL'
' if dspamc returns any kind of errors instead of filtering results.')
parser.add_argument('--dspam-opts', action='append', metavar='options',
help='Extra options to pass to dspamc command.'
' Will be split on spaces, unless option is used multiple times.')
parser.add_argument('--debug', action='store_true', help='Verbose operation mode.')
opts = parser.parse_args(sys.argv[1:] if args is None else args)
logging.basicConfig(
level=logging.DEBUG if opts.debug else logging.WARNING,
format='%(levelname)s :: %(message)s')
log = logging.getLogger('dspam_milter.main')
# pymilter uses stdout for spam, no logging should go there anyway
sys.stdout = open(os.devnull, 'w')
dspamc_opts = opts.dspam_opts or list()
if len(dspamc_opts) == 1: dspamc_opts = dspamc_opts[0].strip().split()
Milter.factory = ft.partial( MilterDspam, opts.user,
fail_pass=opts.dspam_fail_pass, dspamc_opts=dspamc_opts )
log.debug('Starting libmilter loop...')
Milter.runmilter('DspamMilter', opts.socket, opts.timeout)
log.debug('libmilter loop stopped')
def main():
bt = Thread(target=background)
bt.start()
# This is NOT a good socket location for production, it is for
# playing around. I suggest /var/run/milter/myappnamesock for production.
# socketname = os.path.expanduser('~/pythonsock')
socketname = "inet:8800"
timeout = 600
# Register to have the Milter factory create instances of your class:
Milter.factory = myMilter
flags = Milter.CHGBODY + Milter.CHGHDRS + Milter.ADDHDRS
flags += Milter.ADDRCPT
flags += Milter.DELRCPT
Milter.set_flags(flags) # tell Sendmail which features we use
print("%s milter startup" % time.strftime('%Y%b%d %H:%M:%S'))
sys.stdout.flush()
Milter.runmilter("pythonfilter", socketname, timeout)
logq.put(None)
bt.join()
print("%s bms milter shutdown" % time.strftime('%Y%b%d %H:%M:%S'))
def main():
syslog('Starting daemon')
try:
args = parseArgs()
with PidFile(args.pidfile) as pidfile:
def createMilter():
return EncryptionMilter(args.keyring)
Milter.factory = createMilter
flags = Milter.CHGBODY
Milter.set_flags(flags)
Milter.runmilter('encryption-milter', args.socket, 600)
except Exception as e:
syslog('An error occured')
syslog(str(e))
syslog('Shutting down daemon')
def execute():
log_manager = LogManager(log_queue)
log_manager.start()
postgre_manager = PostgreManager(postgresql_creds, postgre_queue, log_queue)
postgre_manager.start()
Milter.factory = QueuedS3Milter
Milter.set_flags(Milter.MODBODY)
log_queue.put({
'type': 'info',
'message': log_config.log_success(module_name=__name__, function_name='execute',
msg='S3 Milter service launched.')
})
Milter.runmilter('S3Milter', milter_params['socket_name'], milter_params['timeout'])
log_queue.put({
'type': 'info',
'message': log_config.log_success(module_name=__name__, function_name='execute',
msg='S3 Milter service shutdown.')
})
postgre_queue.put(None)
postgre_manager.join()
log_queue.put(None)
log_manager.join()
def main():
if CLIParser() != 0:
sys.stderr.write(
"\nERROR: An error has occurred and the program has been terminated!"
)
sys.exit(0)
__log__.info("%s milter startup" % os.path.basename(sys.argv[0]))
__logOutput__.clipLine()
__logOutput__.itemLine(
"milter version",
str(Milter.getversion()[0]) + "." + str(Milter.getversion()[1]) + "." +
str(Milter.getversion()[2]))
__logOutput__.itemLine("milter listener", __listener__)
__logOutput__.itemLine("milter port", __port__)
__logOutput__.clipLine()
# inet:[email protected]
__socketName__ = "inet:" + str(__port__) + "@" + str(__listener__)
Milter.factory = InfoMilter
# Tell the milter, which feature we want to use.
Milter.set_flags(__flags__)
Milter.runmilter("pythonfilter", __socketName__, __timeout__)
__logOutput__.clipLine()
__log__.info("%s milter shutdown" % sys.argv[0])
if (sys.argv[1] not in ['smtpd', 'nonsmtpd']):
print('%s is not a valid mode' % sys.argv[1])
exit(1)
mode = sys.argv[1]
Milter.factory = SandboxMilter
Milter.set_flags(Milter.ADDRCPT + Milter.DELRCPT)
config = ConfigParser.SafeConfigParser()
config.read('/etc/sandbox_milter/sandbox_milter.cfg')
milter_section = mode + "_milter"
socket = config.get(milter_section, 'socket')
name = config.get(milter_section, 'socket')
# Initialize logging
logger = logging.getLogger('')
if (config.getboolean('sandbox', 'log_debug')):
logger.setLevel(logging.DEBUG)
else:
logger.setLevel(logging.INFO)
handler = logging.handlers.SysLogHandler(
address = '/dev/log',
facility = logging.handlers.SysLogHandler.LOG_MAIL)
formatter = logging.Formatter('sandbox_milter[%(process)d]: %(message)s')
handler.setFormatter(formatter)
logger.addHandler(handler)
Milter.runmilter(name, socket, 0)
return Milter.CONTINUE
def abort(self):
print("abort after %d body chars" % self.bodysize)
return Milter.CONTINUE
#res=do_eml("From hello world\nJozsika\n\njkhdsjkdhas\n")
# TESTING
try:
fp = open("milter.eml", "rb")
#msg = mime.message_from_file(fp)
#print(type(fp))
try:
msg = email.message_from_binary_file(fp)
except:
msg = email.message_from_file(fp)
res = do_eml(msg)
print("X-deepspam: " + res)
except:
print("missing/bad milter.eml -> skipping self-test!")
# MILTER MODE
Milter.factory = deepspamMilter
Milter.set_flags(Milter.ADDHDRS)
Milter.set_exception_policy(Milter.ACCEPT)
sys.stdout.flush()
# Milter.runmilter("deepspam","/var/spool/postfix/var/run/deepspam",240)
Milter.runmilter("deepspam", "inet:1080", 240)
def run():
Milter.factory = BMMilter
socket.setdefaulttimeout(60)
Milter.runmilter("bmmilter", BMConfig().get("bmgateway", "bmgateway", "miltersocket") ,600)
if (sys.argv[1] not in ['smtpd', 'nonsmtpd']):
print('%s is not a valid mode' % sys.argv[1])
exit(1)
mode = sys.argv[1]
Milter.factory = SandboxMilter
Milter.set_flags(Milter.ADDRCPT + Milter.DELRCPT)
config = ConfigParser.SafeConfigParser()
config.read('/etc/sandbox_milter/sandbox_milter.cfg')
milter_section = mode + "_milter"
socket = config.get(milter_section, 'socket')
name = config.get(milter_section, 'socket')
# Initialize logging
logger = logging.getLogger('')
if (config.getboolean('sandbox', 'log_debug')):
logger.setLevel(logging.DEBUG)
else:
logger.setLevel(logging.INFO)
handler = logging.handlers.SysLogHandler(
address='/dev/log', facility=logging.handlers.SysLogHandler.LOG_MAIL)
formatter = logging.Formatter('sandbox_milter[%(process)d]: %(message)s')
handler.setFormatter(formatter)
logger.addHandler(handler)
Milter.runmilter(name, socket, 0)
def main():
"Run PyQuarantine-Milter."
# parse command line
parser = argparse.ArgumentParser(
description="PyQuarantine milter daemon",
formatter_class=lambda prog: argparse.HelpFormatter(
prog, max_help_position=45, width=140))
parser.add_argument("-c",
"--config",
help="List of config files to read.",
nargs="+",
default=pyquarantine.QuarantineMilter.get_cfg_files())
parser.add_argument("-s",
"--socket",
help="Socket used to communicate with the MTA.",
default="inet:[email protected]")
parser.add_argument("-d",
"--debug",
help="Log debugging messages.",
action="store_true")
parser.add_argument("-t",
"--test",
help="Check configuration.",
action="store_true")
parser.add_argument("-v",
"--version",
help="Print version.",
action="version",
version=f"%(prog)s ({version})")
args = parser.parse_args()
# setup logging
loglevel = logging.INFO
logname = "pyquarantine-milter"
syslog_name = logname
if args.debug:
loglevel = logging.DEBUG
logname = f"{logname}[%(name)s]"
syslog_name = f"{syslog_name}: [%(name)s] %(levelname)s"
# set config files for milter class
pyquarantine.QuarantineMilter.set_cfg_files(args.config)
root_logger = logging.getLogger()
root_logger.setLevel(loglevel)
# setup console log
stdouthandler = logging.StreamHandler(sys.stdout)
stdouthandler.setLevel(logging.DEBUG)
formatter = logging.Formatter("%(message)s")
stdouthandler.setFormatter(formatter)
root_logger.addHandler(stdouthandler)
logger = logging.getLogger(__name__)
if args.test:
try:
pyquarantine.setup_milter(test=args.test)
print("Configuration ok")
except RuntimeError as e:
logger.error(e)
sys.exit(255)
else:
sys.exit(0)
formatter = logging.Formatter(
f"%(asctime)s {logname}: [%(levelname)s] %(message)s",
datefmt="%Y-%m-%d %H:%M:%S")
stdouthandler.setFormatter(formatter)
# setup syslog
sysloghandler = logging.handlers.SysLogHandler(
address="/dev/log", facility=logging.handlers.SysLogHandler.LOG_MAIL)
sysloghandler.setLevel(loglevel)
formatter = logging.Formatter(f"{syslog_name}: %(message)s")
sysloghandler.setFormatter(formatter)
root_logger.addHandler(sysloghandler)
logger.info("PyQuarantine-Milter starting")
try:
# generate milter config
pyquarantine.setup_milter()
except RuntimeError as e:
logger.error(e)
sys.exit(255)
# register to have the Milter factory create instances of your class:
Milter.factory = pyquarantine.QuarantineMilter
Milter.set_exception_policy(Milter.TEMPFAIL)
# run milter
rc = 0
try:
Milter.runmilter("pyquarantine-milter",
socketname=args.socket,
timeout=300)
except Milter.milter.error as e:
logger.error(e)
rc = 255
pyquarantine.mailer.queue.put(None)
logger.info("PyQuarantine-Milter terminated")
sys.exit(rc)
recipients = 2 # define maximum number of recipients int To an Cc here
socketname = "/tmp/tumilter"
class TuMilter(Milter.Milter):
"Milter to limit the numer of To and Cc recipients"
def __init__(self):
self.tocc = 0
def header(self,name,val):
sv = self.getsymval('{auth_authen}')
if sv==None or sv=="":
return Milter.CONTINUE
lname = name.lower()
if lname == 'to' or lname=='cc':
mails = string.split(val, ',')
self.tocc=self.tocc+len(mails)
if self.tocc >= recipients:
self.setreply('550',None,'Sorry, your message has too many recipients')
return Milter.REJECT
return Milter.CONTINUE
if __name__ == "__main__":
Milter.factory = TuMilter
Milter.runmilter("tumilter",socketname,240)
def close(self):
sys.stdout.flush() # make log messages visible
if self.tempname:
os.remove(self.tempname) # remove in case session aborted
if self.fp:
self.fp.close()
return Milter.CONTINUE
def abort(self):
self.log("abort after %d body chars" % self.bodysize)
return Milter.CONTINUE
if __name__ == "__main__":
#tempfile.tempdir = "/var/log/milter"
#socketname = "/var/log/milter/pythonsock"
socketname = os.getenv("HOME") + "/pythonsock"
Milter.factory = sampleMilter
Milter.set_flags(Milter.CHGBODY + Milter.CHGHDRS + Milter.ADDHDRS)
print("""To use this with sendmail, add the following to sendmail.cf:
O InputMailFilters=pythonfilter
Xpythonfilter, S=local:%s
See the sendmail README for libmilter.
sample milter startup""" % socketname)
sys.stdout.flush()
Milter.runmilter("pythonfilter", socketname, 240)
print("sample milter shutdown")
def main():
sys.stdout.flush()
# Read the config file
config = configparser.ConfigParser()
config.read("milter-xmpp.ini")
# Parse XMPP options
try:
xmpp_jabberid = config.get("xmpp", "jabberid")
except:
print(
"ERROR: jabberid parameter missing from xmpp section in config file!"
)
sys.exit(1)
try:
xmpp_password = config.get("xmpp", "password")
except:
print(
"ERROR: password parameter missing from xmpp section in config file!"
)
sys.exit(1)
try:
xmpp_room = config.get("xmpp", "room")
except:
print(
"ERROR: room parameter missing from xmpp section in config file!")
sys.exit(1)
try:
xmpp_server = config.get("xmpp", "server")
except:
print(
"ERROR: server parameter missing from xmpp section in config file!"
)
sys.exit(1)
# Parse milter options
try:
milter_valid_from = config.get("milter", "valid_from")
except configparser.NoOptionError:
print(
"ERROR: valid_from parameter missing from milter section in config file!"
)
sys.exit(1)
try:
milter_proto = config.get("milter", "proto")
except configparser.NoOptionError:
milter_proto = "inet"
try:
milter_iface = "@%s" % (config.get("milter", "iface"))
except configparser.NoOptionError:
milter_iface = ""
try:
milter_port = config.get("milter", "port")
except configparser.NoOptionError:
milter_port = 8894
milter_socket = "%s:%s%s" % (milter_proto, milter_port, milter_iface)
# Launch the XMPP agent thread. It will forward emails from pre-defined email
# addresses as XMPP messages.
xmpp_agent = XmppAgent(xmpp_jabberid, xmpp_password, xmpp_room,
xmpp_server)
xmpp_agent.setDaemon(True)
xmpp_agent.establish_session()
xmpp_agent.start()
# Launch the mail filter. Whenever an email is received a new instance
# XmppForwardMilter is launched. Common settings like the XMPP Agent object
# are stored as class variables so that each instance can access them.
milter_timeout = 10
Milter.factory = XmppForwardMilter
XmppForwardMilter.xmpp_agent = xmpp_agent
XmppForwardMilter.valid_from = milter_valid_from
Milter.runmilter("xmppforwardmilter", milter_socket, milter_timeout)
"ENV[MILTER_WHITELISTED_RCPTS]: invalid email address: "
+ whitelisted_rcpt)
sys.exit(1)
else:
logging.info("ENV[MILTER_WHITELISTED_RCPTS]: " +
whitelisted_rcpt)
g_milter_whitelisted_rcpts[whitelisted_rcpt] = {}
set_config_parameter("RESTARTABLE_SLEEPTIME", 2)
set_config_parameter("RESTARTABLE_TRIES", 2)
server = Server(g_ldap_server, get_info=NONE)
g_ldap_conn = Connection(server,
g_ldap_binddn,
g_ldap_bindpw,
auto_bind=True,
raise_exceptions=True,
client_strategy='RESTARTABLE')
logging.info("Connected to LDAP-server: " + g_ldap_server)
timeout = 600
# Register to have the Milter factory create instances of your class:
Milter.factory = LdapAclMilter
# Tell the MTA which features we use
flags = Milter.ADDHDRS
Milter.set_flags(flags)
logging.info("Startup " + g_milter_name + "@socket: " +
g_milter_socket + " in mode: " + g_milter_mode)
Milter.runmilter(g_milter_name, g_milter_socket, timeout, True)
logging.info("Shutdown " + g_milter_name)
except:
logging.error("MAIN-EXCEPTION: " + traceback.format_exc())
sys.exit(1)
logger.writeLog(syslog.LOG_ERR, "Unknown error while loading whitelist: %s"%(milterConfig.heloWhitelist))
logger.writeLog(syslog.LOG_DEBUG, "%s Starting" % (milterConfig.milterInstance))
myID = os.getuid()
grID = os.getgid()
log = str(myID)+" "+str(grID)
logger.writeLog(syslog.LOG_DEBUG, "%s running as uid:%i gid%i" %( milterConfig.milterInstance, myID, grID))
#resource.setrlimit(resource.RLIMIT_NOFILE, limits)
maxNumOpenFiles = resource.getrlimit(resource.RLIMIT_NOFILE)
logger.writeLog(syslog.LOG_DEBUG, "%s File Handle Limits (soft, hard): %s"%(milterConfig.milterInstance, str(maxNumOpenFiles)))
#Configure LaikaMilter factory
Milter.factory = LaikaMilter
Milter.set_flags(Milter.CHGBODY + Milter.CHGHDRS + Milter.ADDHDRS)
sys.stdout.flush()
#Attempt to start Milter factory. If milter cannot start, is is usually because there is another milter running.
try:
Milter.runmilter(milterConfig.milterName,milterConfig.socketname,240)
except Milter.error:
log = "Could not open port "+milterConfig.socketname+". Another milter instance may be running."
logger.writeLog(syslog.LOG_ERR, "%s"%(str(log)))
logger.writeLog(syslog.LOG_DEBUG, "%s Shutting Down" % (milterConfig.milterInstance))
logger.closeLog()
return Milter.TEMPFAIL
def close(self):
sys.stdout.flush() # make log messages visible
if self.tempname:
os.remove(self.tempname) # remove in case session aborted
if self.fp:
self.fp.close()
return Milter.CONTINUE
def abort(self):
self.log("abort after %d body chars" % self.bodysize)
return Milter.CONTINUE
if __name__ == "__main__":
#tempfile.tempdir = "/var/log/milter"
#socketname = "/var/log/milter/pythonsock"
socketname = os.getenv("HOME") + "/pythonsock"
Milter.factory = sampleMilter
Milter.set_flags(Milter.CHGBODY + Milter.CHGHDRS + Milter.ADDHDRS)
print("""To use this with sendmail, add the following to sendmail.cf:
O InputMailFilters=pythonfilter
Xpythonfilter, S=local:%s
See the sendmail README for libmilter.
sample milter startup""" % socketname)
sys.stdout.flush()
Milter.runmilter("pythonfilter",socketname,240)
print("sample milter shutdown")
self.t_cleanup()
return self.exit(t)
self.log(t._Test__policy, verbose=True)
# terminate if all tests are disabled
if not enable:
break
except:
LOG.error('body:\n{}'.format(traceback.format_exc()))
self.log('error-debug', verbose=True)
self.t_cleanup()
return Milter.ACCEPT
if __name__ == '__main__':
LOG.enable_timestamp()
#LOG.enable_debug()
class test(Test):
def main(self, email):
return True
test('0000', 'LOG')
Milter.factory = MInspector
milter = 'MINSPECTOR'
LOG.info('Starting {}[{}]'.format(milter, os.getpid()))
Milter.runmilter(milter, '/run/minspector/sock')
def main():
if LOGHANDLER == 'file':
endstr = '**'
# make sure the log directory exists:
try:
os.makedirs(LOGFILE_DIR, 0o0027)
except:
pass
else:
endstr = ''
# Load the whitelist into memory
global WhiteList, Hash_Whitelist
global r
global rsub
global wfp
global bg_redis_write
global bg_submit_wf
WhiteList, Hash_Whitelist= wildlib.whiteListLoad(CONFIG)
# Register to have the Milter factory create instances of your class:
Milter.factory = WildfireMilter
flags = Milter.ADDHDRS
Milter.set_flags(flags) # tell Sendmail which features we use
print("\n*************************************************************")
print("*********** %s startup - Version %s ***********" % ('Wildfire Milter', __version__))
print('************* logging to %s' % LOGHANDLER, end='')
if LOGSTDOUT:
print(' and to stdout ', end=endstr)
else:
print(' **************', end=endstr)
print("**************\n*************************************************************\n")
log.info('* Starting %s v%s - listening on %s' % ('Wildfire Milter', __version__, SOCKET))
log.debug('* Python version: %s' % str(sys.version).replace('\n', ' - '))
log.debug('* Config file: %s' % CONFIG)
print()
sys.stdout.flush()
# Initialize Wildfire API
wfp = wildlib.wildfireConnect(WILDHOST, WILDKEY)
# Initialize main Redis Cache
r = wildlib.redisConnect(REDISHOST, REDISPORT, REDISDB, REDISAUTH)
# Initialize Redis Cache for Wildfire submit
if 'threading' in sys.modules and submitq is not None:
# This is done in another process/thread
rsub = None
else:
rsub = wildlib.redisConnect(REDISHOST, REDISPORT, DBSUB, REDISAUTH)
# ensure desired permissions on unix socket
os.umask(UMASK)
# set the "last" fall back to ACCEPT if exception occur
Milter.set_exception_policy(Milter.ACCEPT)
if TASK_TYPE != 'single':
bg_redis_write = Thread(target=redis_background_write, args=(redisq,))
bg_submit_wf = Thread(target=submit_wildfire_background, args=(submitq,))
bg_redis_write.start()
bg_submit_wf.start()
# Notify systemd that the milter is ready to serve and to protect
if systemd.daemon.booted():
systemd.daemon.notify('READY=1')
systemd.daemon.notify('STATUS=Initialization of WildFire API and Redis completed. Ready to work.')
# start the milter #################################
Milter.runmilter('WildfireMilter', SOCKET, TIMEOUT)
####################################################
if TASK_TYPE != 'single':
# Terminate the running threads.
redisq.put(None)
submitq.put(None)
bg_redis_write.join()
bg_submit_wf.join()
if systemd.daemon.booted():
systemd.daemon.notify('STOPPING=1')
systemd.daemon.notify('STATUS=Wildfire Milter ready to stop.')
log.info('Wildfire Milter shutdown')
print("\n*********** %s shutdown ***********\n" % 'WildfireMilter')
def lookup_user(self):
user = "******"
for _ in range(2):
try:
self.db["cursor"].execute("SELECT DISTINCT spamuser FROM find_user_address(%s) LIMIT 1", (self.to,))
if self.db["cursor"].rowcount > 0:
user = self.db["cursor"].fetchall()[0][0]
return user
except:
if self.db["connection"].closed > 0:
try:
self.db["connection"] = psycopg2.connect(**self.db["config"])
self.db["connection"].autocommit = True
self.db["cursor"] = self.db["connection"].cursor()
except:
break
return user
if __name__ == "__main__":
os.umask(0007)
socketname = "/var/spool/postfix/run/spammilter.sock"
timeout = 600
SpamdMilter.db["config"] = db_config
SpamdMilter.db["connection"] = psycopg2.connect(**SpamdMilter.db["config"])
SpamdMilter.db["connection"].autocommit = True
SpamdMilter.db["cursor"] = SpamdMilter.db["connection"].cursor()
Milter.factory = SpamdMilter
Milter.set_flags(Milter.ADDHDRS)
Milter.runmilter("SpamdMilter",socketname,timeout)
Milter.factory = spfMilter
Milter.set_flags(Milter.CHGHDRS + Milter.ADDHDRS)
global config
config = read_config(
['spfmilter.cfg','/etc/mail/spfmilter.cfg','/etc/postfix/spfmilter.cfg'])
ue = config.untrapped_exception.upper()
if ue == 'CONTINUE':
Milter.set_exception_policy(Milter.CONTINUE)
elif ue == 'REJECT':
Milter.set_exception_policy(Milter.REJECT)
elif ue == 'TEMPFAIL':
Milter.set_exception_policy(Milter.TEMPFAIL)
else:
print("WARNING: invalid untrapped_exception policy: %s"%ue)
miltername = config.miltername
socketname = config.socketname
# FIXME: set process umask based on config
print("""To use this with sendmail, add the following to sendmail.cf:
O InputMailFilters=%s
X%s, S=local:%s
See the sendmail README for libmilter.
spfmilter startup""" % (miltername,miltername,socketname))
sys.stdout.flush()
config.savumask = os.umask(config.umask)
Milter.runmilter(miltername,socketname,240)
print "spfmilter shutdown"
logger.writeLog(syslog.LOG_ERR, "Unknown error while loading whitelist: %s"%(milterConfig.heloWhitelist))
logger.writeLog(syslog.LOG_DEBUG, "%s Starting" % (milterConfig.milterInstance))
myID = os.getuid()
grID = os.getgid()
log = str(myID)+" "+str(grID)
logger.writeLog(syslog.LOG_DEBUG, "%s running as uid:%i gid%i" %( milterConfig.milterInstance, myID, grID))
#resource.setrlimit(resource.RLIMIT_NOFILE, limits)
maxNumOpenFiles = resource.getrlimit(resource.RLIMIT_NOFILE)
logger.writeLog(syslog.LOG_DEBUG, "%s File Handle Limits (soft, hard): %s"%(milterConfig.milterInstance, str(maxNumOpenFiles)))
#Configure LaikaMilter factory
Milter.factory = LaikaMilter
Milter.set_flags(Milter.CHGBODY + Milter.CHGHDRS + Milter.ADDHDRS)
sys.stdout.flush()
#Attempt to start Milter factory. If milter cannot start, is is usually because there is another milter running.
try:
Milter.runmilter(milterConfig.milterName,milterConfig.socketname,240)
except Milter.error:
log = "Could not open port "+milterConfig.socketname+". Another milter instance may be running."
logger.writeLog(syslog.LOG_ERR, "%s"%(str(log)))
logger.writeLog(syslog.LOG_DEBUG, "%s Shutting Down" % (milterConfig.milterInstance))
logger.closeLog()
try:
self.db["cursor"].execute(
"SELECT DISTINCT spamuser FROM find_user_address(%s) LIMIT 1",
(self.to, ))
if self.db["cursor"].rowcount > 0:
user = self.db["cursor"].fetchall()[0][0]
return user
except:
if self.db["connection"].closed > 0:
try:
self.db["connection"] = psycopg2.connect(
**self.db["config"])
self.db["connection"].autocommit = True
self.db["cursor"] = self.db["connection"].cursor()
except:
break
return user
if __name__ == "__main__":
os.umask(0007)
socketname = "/var/spool/postfix/run/spammilter.sock"
timeout = 600
SpamdMilter.db["config"] = db_config
SpamdMilter.db["connection"] = psycopg2.connect(**SpamdMilter.db["config"])
SpamdMilter.db["connection"].autocommit = True
SpamdMilter.db["cursor"] = SpamdMilter.db["connection"].cursor()
Milter.factory = SpamdMilter
Milter.set_flags(Milter.ADDHDRS)
Milter.runmilter("SpamdMilter", socketname, timeout)
def main():
global spool_dir
global ctx
parser = \
argparse.ArgumentParser(description='OPENPGPKEY milter application'
, epilog='For bugs. see [email protected]')
parser.add_argument('--anchor', '-a', action='store', default='',
help='location of the unbound DNSSEC trust anchor file (default /var/lib/unbound/root.anchor')
parser.add_argument('--port', '-p', action='store', default='8890',
help='port on localhost to use (default 8890)')
parser.add_argument('--pid', '-P', action='store', default='',
help='pidfile to create (default no pid file is created')
parser.add_argument('--rrtype', '-r', action='store',
default='65280',
help='RRtype allocation (default private use 65280)')
parser.add_argument('--spool', '-s', action='store',
default='/var/spool/openpgpkey-milter',
help='spool dir for tmp files (default /var/spool/openpgpkey-milter)')
parser.add_argument('--timeout', '-t', action='store', default=600,
help='timeout (default 600)')
parser.add_argument('--version', action='store_true',
help='show version and exit')
args = parser.parse_args()
if args.version:
print 'openpgpkey-milter version %s by Paul Wouters <*****@*****.**>' % VERSION
print ' options: --rrtype %s --spool %s --port %s --timeout %s --pid <pidfile>' % (args.rrtype, args.spool, args.port, args.timeout)
sys.exit()
if args.anchor:
if not os.path.isfile(args.anchor):
sys.exit("anchor file '%s' does not exist"%args.anchor)
ctx.add_ta_file(args.anchor)
socketname = 'inet:%[email protected]' % args.port
spool_dir = args.spool
bt = Thread(target=background)
bt.start()
# Register to have the Milter factory create instances of your class:
Milter.factory = myMilter
flags = Milter.CHGBODY + Milter.CHGHDRS + Milter.ADDHDRS
flags += Milter.ADDRCPT
flags += Milter.DELRCPT
Milter.set_flags(flags)
mypid = str(os.getpid())
if args.pid:
try:
fp = open(args.pid,"w")
fp.write(mypid)
fp.close()
except:
sys.exit("Failed to write pid, aborted")
syslog('starting daemon [%s] version %s on port %s at %s with timeout %s'
% (mypid, VERSION, args.port, args.spool, args.timeout))
sys.stdout.flush()
Milter.runmilter('pythonfilter', socketname, args.timeout)
logq.put(None)
bt.join()
syslog('shutting down daemon')
if os.path.isfile(args.pid) and not os.path.islink(args.pid):
os.unlink(args.pid)
def main():
python_version = ".".join([str(v) for v in sys.version_info[0:3]])
python_version = f"{python_version}-{sys.version_info[3]}"
"Run PyMod-Milter."
parser = argparse.ArgumentParser(
description="PyMod milter daemon",
formatter_class=lambda prog: argparse.HelpFormatter(
prog, max_help_position=45, width=140))
parser.add_argument(
"-c", "--config", help="Config file to read.",
default="/etc/pymodmilter/pymodmilter.conf")
parser.add_argument(
"-s",
"--socket",
help="Socket used to communicate with the MTA.",
default="")
parser.add_argument(
"-d",
"--debug",
help="Log debugging messages.",
action="store_true")
parser.add_argument(
"-t",
"--test",
help="Check configuration.",
action="store_true")
parser.add_argument(
"-v", "--version",
help="Print version.",
action="version",
version=f"%(prog)s {version} (python {python_version})")
args = parser.parse_args()
root_logger = logging.getLogger()
root_logger.setLevel(logging.DEBUG)
# setup console log
stdouthandler = logging.StreamHandler(sys.stdout)
formatter = logging.Formatter("%(levelname)s: %(message)s")
stdouthandler.setFormatter(formatter)
root_logger.addHandler(stdouthandler)
logger = logging.getLogger(__name__)
if not args.debug:
logger.setLevel(logging.INFO)
try:
logger.debug("read milter configuration")
cfg = get_milter_config(args.config)
logger.setLevel(cfg.get_loglevel(args.debug))
if args.socket:
socket = args.socket
elif "socket" in cfg:
socket = cfg["socket"]
else:
raise RuntimeError(
"listening socket is neither specified on the command line "
"nor in the configuration file")
if not cfg["rules"]:
raise RuntimeError("no rules configured")
for rule in cfg["rules"]:
if not rule["actions"]:
raise RuntimeError(
f"{rule['name']}: no actions configured")
except (RuntimeError, AssertionError) as e:
logger.error(f"config error: {e}")
sys.exit(255)
try:
ModifyMilter.set_config(cfg, args.debug)
except RuntimeError as e:
logger.error(e)
sys.exit(254)
if args.test:
print("Configuration OK")
sys.exit(0)
# setup console log for runtime
formatter = logging.Formatter("%(asctime)s - %(levelname)s: %(message)s")
stdouthandler.setFormatter(formatter)
stdouthandler.setLevel(logging.DEBUG)
# setup syslog
sysloghandler = logging.handlers.SysLogHandler(
address="/dev/log", facility=logging.handlers.SysLogHandler.LOG_MAIL)
sysloghandler.setFormatter(
logging.Formatter("pymodmilter: %(message)s"))
root_logger.addHandler(sysloghandler)
logger.info("pymodmilter starting")
# register milter factory class
Milter.factory = ModifyMilter
Milter.set_exception_policy(Milter.TEMPFAIL)
if args.debug:
Milter.setdbg(1)
rc = 0
try:
Milter.runmilter("pymodmilter", socketname=socket, timeout=600)
except Milter.milter.error as e:
logger.error(e)
rc = 255
mailer.queue.put(None)
logger.info("pymodmilter stopped")
sys.exit(rc)
sys.stdout.flush() # make log messages visible
if self.tempname:
os.remove(self.tempname) # remove in case session aborted
if self.buffer:
self.buffer.close()
return Milter.CONTINUE # pylint:disable=E1101
def abort(self):
"Report if AnalyticsMilter is interrupted"
self.log("abort after %d body chars" % self.bodysize)
return Milter.CONTINUE # pylint:disable=E1101
if __name__ == "__main__":
Milter.factory = AnalyticsMilter
print("""To use this with sendmail, add the following to sendmail.cf:
O InputMailFilters=analyticsmilter
Xanalyticsmilter, S=local:%s
See the sendmail README for libmilter.
To use this with Postfix, add the following to main.cf:
smtpd_milters = local:%s $smtpd_milters
tracking milter startup""" % (SOCKETNAME, SOCKETNAME))
sys.stdout.flush()
Milter.runmilter("analyticsmilter", SOCKETNAME, 240)
print("tracking milter shutdown")
global config
config = read_config([
'spfmilter.cfg', '/etc/mail/spfmilter.cfg',
'/etc/postfix/spfmilter.cfg'
])
ue = config.untrapped_exception.upper()
if ue == 'CONTINUE':
Milter.set_exception_policy(Milter.CONTINUE)
elif ue == 'REJECT':
Milter.set_exception_policy(Milter.REJECT)
elif ue == 'TEMPFAIL':
Milter.set_exception_policy(Milter.TEMPFAIL)
else:
print("WARNING: invalid untrapped_exception policy: %s" % ue)
miltername = config.miltername
socketname = config.socketname
# FIXME: set process umask based on config
print(
"""To use this with sendmail, add the following to sendmail.cf:
O InputMailFilters=%s
X%s, S=local:%s
See the sendmail README for libmilter.
spfmilter startup""" % (miltername, miltername, socketname))
sys.stdout.flush()
config.savumask = os.umask(config.umask)
Milter.runmilter(miltername, socketname, 240)
print "spfmilter shutdown"
