Better log message for broken headers.
[confparser-old] / mailfilter.py
1 #!/usr/bin/python
2 # -*- coding: iso-8859-1 -*-
3
4 #
5 # MailFilter - Mail filter to replace procmail.
6 # Copyright (C) 2004  Frédéric Jolliton <frederic@jolliton.com>
7 #
8 # This program is free software; you can redistribute it and/or modify
9 # it under the terms of the GNU General Public License as published by
10 # the Free Software Foundation; either version 2 of the License, or
11 # (at your option) any later version.
12 #
13 # This program is distributed in the hope that it will be useful,
14 # but WITHOUT ANY WARRANTY; without even the implied warranty of
15 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 # GNU General Public License for more details.
17 #
18 # You should have received a copy of the GNU General Public License
19 # along with this program; if not, write to the Free Software
20 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
21 #
22
23 #
24 # Policy when error are encountered:
25 #
26 # We backup the mail in a special directory. It will be
27 # at the admin discretion to feed it again to this program
28 # (or may be script that.)
29 #
30
31 #
32 # TODO:
33 #
34 #   [ ] Define precisely what return code use for each possible case.
35 #
36
37 myName = 'mail.filter'
38 myVersion = '0.1.1'
39
40 import sys
41 import os
42 import time
43 import email
44 import email.Header
45 import email.Utils
46 import types
47 import re
48
49 import confparser
50
51 from os import EX_USAGE, EX_OK, EX_NOUSER, EX_TEMPFAIL, EX_DATAERR
52 # EX_OK           0       ok
53 # EX_USAGE        64      command line usage error
54 # EX_DATAERR      65      data format error
55 # EX_NOINPUT      66      cannot open input
56 # EX_NOUSER       67      addressee unknown
57 # EX_NOHOST       68      host name unknown
58 # EX_UNAVAILABLE  69      service unavailable
59 # EX_SOFTWARE     70      internal software error
60 # EX_OSERR        71      system error (e.g., can't fork)
61 # EX_OSFILE       72      critical OS file missing
62 # EX_CANTCREAT    73      can't create (user) output file
63 # EX_IOERR        74      input/output error
64 # EX_TEMPFAIL     75      temp failure; user is invited to retry
65 # EX_PROTOCOL     76      remote error in protocol
66 # EX_NOPERM       77      permission denied
67 # EX_CONFIG       78      configuration error
68
69 #
70 # Path to subprocess module. Ideally not needed if subprocess
71 # (formerly popen5) is installed into /site-packages/ directory.
72 #
73 #sys.path.insert( 0 , '/usr/local/lib/python/' )
74
75 #
76 # subprocess (formerly popen5) - See PEP 324
77 # http://www.lysator.liu.se/~astrand/popen5/
78 #
79 # >>> cat = subprocess.Popen( 'cat' , stdin = subprocess.PIPE , stdout = subprocess.PIPE )
80 # >>> cat.communicate( 'bla' )
81 # ('bla', None)
82 # >>> cat.returncode
83 # 0
84 #
85 try :
86         import subprocess
87 except ImportError :
88         try :
89                 import popen5 as subprocess
90         except ImportError :
91                 print 'Please install subprocess module.'
92                 print 'See http://www.lysator.liu.se/~astrand/popen5/.'
93                 sys.exit( 1 )
94
95 #--[ Configuration variables ]------------------------------------------------
96
97 #
98 # Filename where to put log.
99 #
100 g_pathLog          = '/var/log/mail.filter.log'
101
102 #
103 # For which users receiving a mail should we send a UDP packet.
104 #
105 g_userNotificationFilter = [ 'fred' ]
106
107 #
108 # For which IP address should we send the notification.
109 # (Can include broadcast address.)
110 #
111 g_notificationAddresses = [ '192.168.1.255' ]
112
113 #
114 # On which port should we send the notification.
115 #
116 g_notificationPort = 23978
117
118 #
119 # Max mail size to be processed by this script.
120 #
121 # Larger mail are just not filtered.
122 #
123 g_maxMailSize = 2 * 1024 * 1024
124
125 #
126 # Where to save copy of mail in case of error.
127 #
128 g_directoryBackup  = '/var/mail.filter/recovery/'
129
130 #
131 # If set, then no backup are produced in case of error.
132 #
133 g_backupDisabled = False
134
135 #
136 # Where to find rules about each user.
137
138 # Filename for user 'joe' will be named 'joe.mf' in that
139 # directory. If the file doesn't exist, no filtering is
140 # done (not even spam/virus filtering.)
141 #
142 g_directoryRules   = '/var/mail.filter/rules/'
143
144 #--[ External commands ]------------------------------------------------------
145
146 #
147 # Path to Cyrus's deliver binary.
148 #
149 g_pathCyrusDeliver = '/usr/lib/cyrus/deliver'
150
151 #
152 # Path to spamprobe binary.
153 #
154 g_pathSpamProbe    = '/usr/bin/spamprobe'
155
156 g_pathSpamProbeDb  = '/var/spamprobe/db'
157
158 #
159 # Path to ClamAV binary.
160 #
161 # Could point either to 'clamdscan' or 'clamscan'.
162 #
163 # The first one is *HIGHLY* recommended since
164 # it will use the ClamAV daemon.
165 #
166 g_pathClamdscan    = '/usr/bin/clamdscan'
167
168 #--[ Global variables ]-------------------------------------------------------
169
170 #
171 # Should the log be also printed on stdout ?
172 #
173 g_copyLogToStdout = False
174
175 #
176 # Don't actually feed the mail to Cyrus.
177 #
178 g_testMode = False
179
180 #
181 # The user name of the recipient.
182 #
183 g_user = None
184
185 #
186 # The current mail as string (as read from stdin.)
187 #
188 g_mailText = None
189
190 #
191 # The current mail as email.Message.Message object.
192 #
193 g_mail = None
194
195 #-----------------------------------------------------------------------------
196
197 #
198 # check if predicate is True for all items in list 'lst'.
199 #
200 def all( lst , predicate ) :
201
202         for item in lst :
203                 if not predicate( item ) :
204                         return False
205         return True
206
207 #
208 # check if predicate is True for at least one item in list 'lst'.
209 #
210 def some( lst , predicate ) :
211
212         for item in lst :
213                 if predicate( item ) :
214                         return True
215         return False
216
217 #
218 # Remove leading and trailing blank, and replace any
219 # blank character sequence by one space character.
220 #
221 def normalizeBlank( s ) :
222
223         return ' '.join( s.split() )
224
225 #-----------------------------------------------------------------------------
226
227 #
228 # Utility function to return traceback as string from most recent
229 # exception.
230 #
231 def getTraceBack() : 
232  
233         import traceback, sys 
234         return ''.join( traceback.format_exception( *sys.exc_info() ) )
235
236 #
237 # Return (returnCode, stdout, stderr)
238 #
239 def pipe( cmd , input ) :
240
241         p = subprocess.Popen( cmd ,
242                 stdin = subprocess.PIPE ,
243                 stdout = subprocess.PIPE ,
244                 stderr = subprocess.PIPE )
245         try :
246                 # much faster than passing 'input' to communicate directly..
247                 p.stdin.write( input )
248         except IOError :
249                 pass
250         r = p.communicate()
251         return p.returncode , r[ 0 ] , r[ 1 ]
252
253 #
254 # Return an ISO-8661 date representation for the UTC
255 # timezone.
256 #
257 # timestamp( 0 ) => 1970-01-01T00:00:00Z
258 #
259 def timestamp() :
260
261         t = time.gmtime()
262         return '%04d-%02d-%02dT%02d:%02d:%02dZ' % t[ : 6 ]
263
264 #
265 # Log message 'msg'.
266 #
267 def logMessage( msg ) :
268
269         if not logMessage.logFile and not g_testMode :
270                 #
271                 # If log file is not yet open, try to open it.
272                 #
273                 try :
274                         logMessage.logFile = open( g_pathLog , 'a+' )
275                 except :
276                         if not g_copyLogToStdout :
277                                 return
278
279         msg = msg.splitlines()
280         prefix = timestamp() + ' [%s] ' % os.getpid()
281
282         #
283         # Output to log file.
284         #
285         if logMessage.logFile :
286
287                 for line in msg :
288                         line = prefix + line
289                         try :
290                                 logMessage.logFile.write( line + '\n' )
291                                 logMessage.logFile.flush()
292                         except :
293                                 pass
294
295         #
296         # Output to standard output.
297         #
298         if g_copyLogToStdout :
299
300                 for line in msg :
301                         line = prefix + line
302                         sys.stdout.write( line + '\n' )
303                         sys.stdout.flush()
304
305 logMessage.logFile = None
306
307 #
308 # Make a backup of the mail (in case it's impossible
309 # to store the mail to Cyrus.)
310 #
311 def backup( filenamePrefix = None ) :
312
313         if g_testMode :
314                 logMessage( 'TEST MODE: Backup of the mail requested.' )
315                 return
316
317         if g_backupDisabled :
318                 logMessage( 'Backup requested, but disabled.' )
319                 return
320
321         try :
322                 # Ensure directory exist
323                 import os
324                 os.makedirs( g_directoryBackup )
325         except :
326                 pass
327
328         basename = ''
329         if filenamePrefix :
330                 basename += filenamePrefix + '-'
331         #
332         # Append current unix time as suffix
333         #
334         basename += '%.3f' % time.time()
335
336         fn = g_directoryBackup + '/' + basename
337         try :
338                 f = open( fn , 'a+' )
339                 f.write( g_mailText )
340                 f.close()
341         except :
342                 logMessage( 'PANIC: Unable to write backup to %s.' % fn )
343         else :
344                 logMessage( 'Message appended to backup directory as `%s\'.' % basename )
345
346 #-----------------------------------------------------------------------------
347
348 class Action : pass
349
350 class NullAction( Action ) :
351
352         def __repr__( self ) :
353
354                 return '<NullAction>'
355
356 class FileToFolderAction( Action ) :
357
358         def __init__( self , folder ) :
359
360                 self.folder = folder
361
362         def __repr__( self ) :
363
364                 return '<FileToFolderAction %r>' % ( self.folder , )
365
366 class CustomErrorCodeAction( Action ) :
367
368         def __init__( self , code ) :
369
370                 self.code = code
371
372         def __repr__( self ) :
373
374                 return '<NullAction %r>' % ( self.code , )
375
376 #-----------------------------------------------------------------------------
377
378 #
379 # Experimental !
380 #
381 # Packet payload contains:
382 #
383 # <username> + char( 0 ) + <foldername> + char( 0 )
384 #
385 def notifyDeliver( user , folder ) :
386
387         if user not in g_userNotificationFilter :
388                 return
389         try :
390                 import socket
391                 s = socket.socket( socket.AF_INET , socket.SOCK_DGRAM )
392                 msg = user + chr( 0 ) + folder + chr( 0 )
393                 for address in g_notificationAddresses :
394                         s.sendto( msg , ( address , g_notificationPort ) )
395         except :
396                 pass
397
398 #
399 # Deliver a mail to Cyrus for user 'username' in
400 # folder 'folderName' (or default folder if not
401 # specified.)
402 #
403 def deliverTo( username , folderName = None ) :
404
405         if not folderName :
406                 pseudoFolderName = 'INBOX'
407                 folderName = 'user.' + username
408         else :
409                 pseudoFolderName = 'INBOX.' + folderName
410                 folderName = 'user.' + username + '.' + folderName
411
412         #
413         # Build the command line for running deliver.
414         #
415         cmd = [ g_pathCyrusDeliver ]
416         cmd += [ '-a' , username ]
417         cmd += [ '-m' , folderName ]
418
419         if g_testMode :
420                 logMessage( 'TEST MODE: Delivering mail in `%s\' requested.' % ( folderName , ) )
421                 logMessage( 'TEST MODE: Command: %r.' % cmd )
422                 return EX_OK
423
424         try :
425                 rc , stdout , stderr = pipe( cmd , g_mailText )
426         except OSError , e :
427                 logMessage( 'Error running `%s\': %s.' % ( cmd[ 0 ] , e[ 1 ] ) )
428                 return EX_TEMPFAIL
429
430         if rc == EX_OK :
431                 logMessage( 'Message delivered in folder `%s\'.' % folderName )
432                 notifyDeliver( username , pseudoFolderName )
433         else :
434                 errorMessage = stdout.rstrip()
435                 #
436                 # Extract raw error message
437                 #
438                 # Example of output:
439                 #
440                 #   +user.fred: Message contains invalid header
441                 #
442                 m = errorMessage.split( ': ' , 1 )
443                 if len( m ) == 2 :
444                         m = m[ 1 ]
445                 else :
446                         m = None
447                 rcMsg = '%d' % rc
448                 if m == 'Message contains invalid header' :
449                         rc = EX_DATAERR
450                         rcMsg += '->%d' % rc
451                 elif m == 'Mailbox does not exist' :
452                         rc = EX_NOUSER
453                         rcMsg += '->%d' % rc
454                 else :
455                         # FIXME: DATAERR ok here ?
456                         rc = EX_DATAERR
457                 logMessage( 'Refused by Cyrus: [%s] `%s\'.' % ( rcMsg , errorMessage ) )
458         return rc
459
460 #--[ Antivirus ]--------------------------------------------------------------
461
462 #
463 # Return virus list from the output of ClamAV.
464 #
465 def extractVirusList( clamdOutput ) :
466
467         res = []
468         for line in clamdOutput.splitlines() :
469                 r = extractVirusList.reClamdVirus.search( line.rstrip() )
470                 if r == None : continue
471                 res.append( r.group( 1 ) )
472         return res
473
474 extractVirusList.reClamdVirus = re.compile( r'^[^:]+: (\S+) FOUND$' )
475
476 #
477 # Check for virus.
478 #
479 # Return True if mail is clean.
480 #
481 def antivirusScan() :
482
483         cmd = [ g_pathClamdscan , '-' ]
484
485         if g_testMode :
486                 logMessage( 'TEST MODE: Virus scan requested.' )
487                 logMessage( 'TEST MODE: Command: %r.' % cmd )
488                 return True
489
490         rc , stdout , stderr = pipe( cmd , g_mailText )
491         output = stderr or ''
492         #logMessage( 'clamdscan returned %s' % rc )
493         if rc == 2 :
494                 raise Exception( 'Unable to scan for viruses (%s)' % cmd )
495         ok = not rc
496         if not ok :
497                 msg = 'Virus found.'
498                 viruses = extractVirusList( output )
499                 if viruses :
500                         msg += ' [%s]' % ' '.join( viruses )
501                 logMessage( msg )
502         return ok
503
504 #--[ Antispam ]---------------------------------------------------------------
505
506 #
507 # Check for spam.
508 #
509 # Return True if mail is correct.
510 #
511 def spamScan() :
512
513         if not g_user : return True
514
515         cmd = [ g_pathSpamProbe ]
516         cmd += [ '-d' , g_pathSpamProbeDb + '/' + g_user + '/' ]
517         cmd += [ 'receive' ]
518
519         if g_testMode :
520                 logMessage( 'TEST MODE: Spam scan requested.' )
521                 logMessage( 'TEST MODE: Command: %r.' % cmd )
522                 return True
523
524         rc , stdout , stderr = pipe( cmd , g_mailText )
525         r = ( stdout or '' ).split()
526         return r[ 0 ] != 'SPAM'
527
528 #-----------------------------------------------------------------------------
529
530 def errorNameToErrorCode( code ) :
531
532         code = code.lower()
533         if code == 'nouser' :
534                 return EX_NOUSER
535         elif code == 'tempfail' :
536                 return EX_TEMPFAIL
537         elif code == 'dataerr' :
538                 return EX_DATAERR
539         else :
540                 try :
541                         return int( code )
542                 except :
543                         return 0
544
545 #-----------------------------------------------------------------------------
546
547 #
548 # FIXME: I think it could be better to cache the parsed
549 # configuration, and also to cache the result of the validator
550 # so that we don't run the test each time this script is run !
551 #
552 def readUserRules( user ) :
553
554         filename = g_directoryRules + '/' + user + '.mf'
555
556         #
557         # Read the configuration.
558         #
559         try :
560                 return confparser.readConfiguration( filename )
561         except OSError , e :
562                 pass
563         except Exception , e :
564                 logMessage( str( e ) )
565                 logMessage( 'Error in file %r. See option -c to check this file.' % ( filename , ) )
566
567 #-----------------------------------------------------------------------------
568
569 #
570 # Test a match rule against a particular header.
571 #
572 # header    : string
573 # matchType : string in [ 'match' , 'is' , 'contains' ]
574 # text      : string
575 #
576 def ruleMatch( header , matchType , text ) :
577
578         if matchType == 'match' :
579                 try :
580                         return re.search( text , header , re.I ) != None
581                 except :
582                         logMessage( 'Error with regex `%s\' from %s\'s user configuration.' % ( text , g_user ) )
583                         return False
584         elif matchType == 'is' :
585                 return header.strip().lower() == text.strip().lower()
586         elif matchType == 'contains' :
587                 return header.lower().find( text.strip().lower() ) != -1
588         else :
589                 logMessage( 'Unknown match type `%s\' from %s\'s user configuration.' % ( matchType , g_user ) )
590         return False
591
592 #
593 #    '=?iso-8859-1?q?Fr=E9d=E9ric_Jolliton?= <frederic@jolliton.com>'
594 # => u'Fr\xe9d\xe9ric Jolliton <frederic@jolliton.com>'
595 #
596 def decodeHeader( s ) :
597
598         try :
599                 return ' '.join( [ p[ 0 ].decode( p[ 1 ] or 'ascii' ) for p in email.Header.decode_header( s ) ] )
600         except :
601                 logMessage( 'Error decoding %r' % s )
602                 return s
603
604 def isMailBroken() :
605
606         if g_mail == None :
607                 return True
608         brokenHeaders = []
609         for headerName , headerContents in g_mail.items() :
610                 try :
611                         for text , charset in email.Header.decode_header( headerContents ) :
612                                 text.decode( charset or 'ascii' )
613                 except UnicodeDecodeError , e :
614                         brokenHeaders.append( headerName )
615         if brokenHeaders :
616                 maxHeaderToLog = 8
617                 if len( brokenHeaders ) > maxHeaderToLog :
618                         brokenHeaders = brokenHeaders[ : maxHeaderToLog ] + [ '...' ]
619                 logMessage( 'The following headers are broken: [%s]' % ' '.join( brokenHeaders ) )
620                 return True
621         return False
622
623 #
624 # Test rule 'rule' against the mail.
625 #
626 def testRule( rule ) :
627
628         cmd = rule[ 0 ]
629
630         if cmd == 'and' :
631                 return all( rule[ 2 ] , testRule )
632
633         if cmd == 'or' :
634                 return some( rule[ 2 ] , testRule )
635
636         if cmd == 'not' :
637                 return not some( rule[ 2 ] , testRule )
638
639         #
640         # Matching a header
641         #
642         if cmd == 'header' :
643                 if g_mail == None :
644                         return False
645                 args = rule[ 1 ]
646                 if len( args ) == 2 :
647                         #
648                         # Test 'present'
649                         #
650                         headerName , matchType = args
651                         if matchType not in [ 'present' ] :
652                                 logMessage( 'Unknown match type %r' % matchType )
653                                 return False
654                         return ( g_mail.get( headerName ) != None )
655
656                 headerName , matchType , text = args
657                 text = normalizeBlank( text )
658                 if headerName.find( '.' ) != -1 :
659                         headerName , partName = headerName.split( '.' , 1 )
660                         partName = partName.lower()
661                 else :
662                         partName = 'raw'
663                 headers = g_mail.get_all( headerName ) or []
664                 headers = map( decodeHeader , headers )
665
666                 if partName != 'raw' :
667                         #
668                         # Support for .name, .address and .domain part.
669                         #
670                         # Example:
671                         #
672                         # with 'From: Frederic Jolliton <frederic@jolliton.com>, a@b.c (Foo)'
673                         #
674                         # 'From.name'    -> [ 'Frederic Jolliton' , 'Foo' ]
675                         # 'From.address' -> [ 'frederic@jolliton.com' , 'a@b.c' ]
676                         # 'From.user'    -> [ 'frederic' , 'a' ]
677                         # 'From.domain'  -> [ 'jolliton.com' , 'b.c' ]
678                         #
679                         if partName not in [ 'name' , 'address' , 'user' , 'domain' ] :
680                                 logMessage( 'Unknown header part %r' % partName )
681                                 return False
682                         adrs = email.Utils.getaddresses( headers )
683                         if partName == 'name' :
684                                 headers = [ adr[ 0 ] for adr in adrs ]
685                         elif partName == 'address' :
686                                 headers = [ adr[ 1 ] for adr in adrs ]
687                         elif partName == 'user' :
688                                 headers = [ adr[ 1 ].split( '@' )[ 0 ] for adr in adrs ]
689                         elif partName == 'domain' :
690                                 headers = [ adr[ 1 ].split( '@' )[ -1 ] for adr in adrs ]
691
692                 return some( headers , lambda header : ruleMatch( header , matchType , text ) )
693
694         #
695         # Broken mail
696         #
697         if cmd == 'broken' :
698                 return g_mail == None or isMailBroken()
699
700         #
701         # Infected mail
702         #
703         if cmd == 'infected' :
704                 return g_mail != None and not antivirusScan()
705
706         #
707         # Spam mail
708         #
709         if cmd == 'spam' :
710                 return g_mail != None and not spamScan()
711
712         #
713         # Catchall
714         #
715         if cmd == 'all' :
716                 return True
717
718         #
719         # Unknown rule
720         #
721         logMessage( 'Unknown rule name `%s\'.' % ( cmd , ) )
722         return False
723
724 #-----------------------------------------------------------------------------
725
726 #
727 # Find the destination folder for user 'user' according to rules defined for
728 # him/her against the current mail.
729 #
730 # Return an Action.
731 #
732 def checkUserRules( user ) :
733
734         action = FileToFolderAction( None )
735
736         conf = readUserRules( user )
737
738         #
739         # conf == None  => No rule file.
740         # not conf[ 2 ] => File exist, but contains no rules.
741         #
742         if conf != None and conf[ 2 ] :
743                 for item in conf[ 2 ] :
744                         actionName , args , subs = item[ : 3 ]
745
746                         if some( subs , testRule ) :
747                                 if g_testMode :
748                                         logMessage( 'MATCH: %s %s { ... }' % ( actionName , ' '.join( args ) ) )
749                                         continue
750                                 if actionName == 'folder' :
751                                         action = FileToFolderAction( args[ 0 ] )
752                                 elif actionName == 'reject' :
753                                         action = CustomErrorCodeAction( errorNameToErrorCode( args[ 0 ] ) )
754                                 else :
755                                         logMessage( 'Unknown action `%s\'.' % actionName )
756                                 break
757
758         return action
759
760 #-----------------------------------------------------------------------------
761
762 #
763 # Read mail from standard input.
764 #
765 def readMail() :
766
767         global g_mailText
768
769         #
770         # FIXME: Should we be reading the mail by block, so that
771         # we can at least read and backup a part of the standard input
772         # in case an error occur ? (broken pipe for example)
773         #
774         # If error occur, and since we can't backup the mail,
775         # we ask sendmail to retry later.
776         #
777         try :
778                 g_mailText = sys.stdin.read()
779         except :
780                 logMessage( getTraceBack() )
781                 sys.exit( EX_TEMPFAIL )
782
783 #
784 # Check if the mail is bigger than a predefined amount.
785 #
786 def checkForLargeMail() :
787
788         if len( g_mailText ) > g_maxMailSize :
789                 logMessage( 'Message too big (%s bytes). Not filtering it.' % len( g_mailText ) )
790                 rc = None
791                 if g_user :
792                         rc = deliverTo( g_user )
793                         if rc != EX_OK :
794                                 logMessage( 'Unable to deliver it to user `%s\'.' % g_user )
795                 if rc != EX_OK :
796                         backup( g_user )
797                 sys.exit( EX_OK )
798
799 #
800 # Check if user was specified of command line.
801 #
802 def checkForUser() :
803
804         #
805         # No user specified.
806         #
807         if not g_user :
808                 logMessage( 'No user specified.' )
809                 backup()
810                 sys.exit( EX_OK )
811
812 #
813 # Parse the mail using email python standard module.
814 #
815 def parseMail() :
816
817         global g_mail
818
819         #
820         # Parsing the mail.
821         #
822         try :
823                 g_mail = email.message_from_string( g_mailText , strict = False )
824         except :
825                 logMessage( getTraceBack() )
826
827 #
828 # Dispatch the mail to the correct folder (deduced from rules.)
829 #
830 # Return an error code.
831 #
832 def dispatchMail() :
833
834         action = checkUserRules( g_user )
835         if g_testMode :
836                 return 0
837
838         #
839         # If custom error code is returned, stop processing
840         # here (mail is not saved.)
841         #
842         if isinstance( action , CustomErrorCodeAction ) :
843                 logMessage( 'Custom exit code is %d.' % action.code )
844                 return action.code
845
846         #
847         # File the mail into the specified folder.
848         #
849         if isinstance( action , FileToFolderAction ) :
850                 #
851                 # We got a folder name (or None for default folder.)
852                 #
853                 folder = action.folder
854                 pseudoName = 'INBOX'
855                 if folder : pseudoName += '.' + folder
856
857                 #
858                 # Try to deliver in the named folder
859                 #
860                 rc = deliverTo( g_user , folder )
861                 #
862                 # If we get an error code, then we deliver the mail to default folder,
863                 # except if the error was "data error" or if we already tried to deliver
864                 # it to default folder.
865                 #
866                 if rc not in [ EX_OK , EX_DATAERR ] and folder != None :
867                         logMessage( 'Error delivering to folder %s of user `%s\'.' % ( pseudoName , g_user ) )
868                         logMessage( 'Mail will go into default folder.' )
869                         rc = deliverTo( g_user )
870                 #
871                 # Check again.
872                 #
873                 # Here we also handle the case of EX_DATAERR not handled above.
874                 #
875                 if rc != EX_OK :
876                         logMessage( 'Error delivering to default folder of user `%s\'.' % ( g_user , ) )
877                         #
878                         # Since it's still not ok, backup the mail.
879                         #
880                         backup( g_user )
881                         #
882                         # All errors code different from "data error" are translated to
883                         # "no user" error code.
884                         #
885                         # FIXME: Why?!
886                         #
887                         if rc != EX_DATAERR :
888                                 rc = EX_NOUSER
889
890                 #
891                 # FIXME: !!!!!
892                 #
893                 rc = EX_OK
894
895                 return rc
896         
897         raise Exception( 'Unknown action type' )
898
899 #
900 #
901 #
902 def process() :
903
904         readMail()
905         try :
906                 checkForUser()
907                 checkForLargeMail()
908                 parseMail()
909                 return dispatchMail()
910         except SystemExit :
911                 raise
912         except :
913                 logMessage( getTraceBack() )
914                 return EX_DATAERR
915
916 #-----------------------------------------------------------------------------
917
918 def checkConfiguration( filename ) :
919
920         try :
921                 confparser.readConfiguration( filename )
922         except Exception , e :
923                 print e
924         else :
925                 print filename , 'ok'
926
927 #-----------------------------------------------------------------------------
928
929 def version() :
930
931         print '''%s %s
932
933 Copyright (C) 2004, Frederic Jolliton <frederic@jolliton.com>
934 This is free software; see the source for copying conditions.  There is NO
935 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.''' \
936         % ( myName , myVersion )
937
938 def usage() :
939
940         print '''Usage: mail.filter [OPTIONS] username < EMAIL
941
942  -h, --help                Print this help.
943  -v, --verbose             Verbose mode, output log to stdout.
944  -t, --test                Test mode. Don't feed the mail to Cyrus, don't
945                            do backup, and don't write anything into log file.
946  -l, --log=FILENAME        Set log filename.
947  -r, --rules=DIRECTORY     Directory where are located users rules.
948  -c, --check-config=FILENAME
949                            Check syntax and structure of configuration file
950                            FILENAME.
951      --disable-backup      Disable backup.
952      --version             Output version information and exit.
953 '''
954
955         print 'Current paths are:\n'
956         print '    spamprobe  : %s' % g_pathSpamProbe
957         print '    clamd      : %s' % g_pathClamdscan
958         print '    deliver    : %s' % g_pathCyrusDeliver
959         print '    log        : %s' % g_pathLog
960         print
961         print 'Current directories are:\n'
962         print '    spamprobedb: %s' % g_pathSpamProbeDb
963         print '    rules      : %s' % g_directoryRules
964         print '''
965 Latest version is available from:
966
967     arch://arch.intra.tuxee.net/2004/mail-filter
968
969 Report bugs to <fj@tuxee.net>.'''
970
971 def main() :
972
973         global g_user, g_mail, g_mailText, g_copyLogToStdout, g_pathLog, g_directoryRules , g_testMode, g_backupDisabled
974
975         #--[ Command line ]-------------------------------------------------------
976
977         import getopt
978         try :
979                 _getopt = getopt.gnu_getopt
980         except :
981                 _getopt = getopt.getopt
982
983         try :
984                 options , parameters = \
985                         _getopt( sys.argv[ 1 : ] ,
986                                 'hvtl:r:c:' ,
987                                 ( 'help' , 'verbose' , 'test' , 'log=' , 'rules=' ,
988                                         'check-config=' , 'disable-backup' , 'version' ) )
989         except getopt.GetoptError , e :
990                 myName = sys.argv[ 0 ].split( '/' )[ -1 ]
991                 print '%s: %s' % ( myName , e[ 0 ] )
992                 print 'Try `%s --help\' for more information.' % myName
993                 sys.exit( 1 )
994
995         for option , argument in options :
996                 if option in [ '-h' , '--help' ] :
997                         usage()
998                         sys.exit( 0 )
999                 elif option in [ '-v' , '--verbose' ] :
1000                         g_copyLogToStdout = True
1001                 elif option in [ '-t' , '--test' ] :
1002                         g_testMode = True
1003                 elif option in [ '-l' , '--log' ] :
1004                         g_pathLog = argument
1005                 elif option in [ '-r' , '--rules' ] :
1006                         g_directoryRules = argument
1007                 elif option in [ '-c' , '--check-config' ] :
1008                         checkConfiguration( argument )
1009                         sys.exit( 0 )
1010                 elif option in [ '--disable-backup' ] :
1011                         g_backupDisabled = True
1012                 elif option in [ '--version' ] :
1013                         version()
1014                         sys.exit( 0 )
1015
1016         #
1017         # At most one parameter expected.
1018         #
1019         if len( parameters ) > 1 :
1020                 #
1021                 # We just log a error message. We continue to proceed
1022                 # to not lost the mail !
1023                 #
1024                 logMessage( 'Warning: Expected only one user name.' )
1025
1026         if parameters :
1027                 g_user = parameters[ 0 ]
1028
1029         #--[ Core ]---------------------------------------------------------------
1030
1031         logMessage( 'Running mail.filter for user `%s\'.' % g_user )
1032
1033         return process()
1034
1035 if __name__ == '__main__' :
1036         sys.exit( main() )