citadel/serv_sieve.c

   1 /*
   2  * $Id: serv_sieve.c 3850 2005-09-13 14:00:24Z ajc $
   3  *
   4  * This module glues libSieve to the Citadel server in order to implement
   5  * the Sieve mailbox filtering language (RFC 3028).
   6  *
   7  * This code is released under the terms of the GNU General Public License.
   8  */
   9
  10 #include "sysdep.h"
  11 #include <stdlib.h>
  12 #include <unistd.h>
  13 #include <stdio.h>
  14 #include <fcntl.h>
  15 #include <signal.h>
  16 #include <pwd.h>
  17 #include <errno.h>
  18 #include <sys/types.h>
  19
  20 #if TIME_WITH_SYS_TIME
  21 # include <sys/time.h>
  22 # include <time.h>
  23 #else
  24 # if HAVE_SYS_TIME_H
  25 #  include <sys/time.h>
  26 # else
  27 #  include <time.h>
  28 # endif
  29 #endif
  30
  31 #include <sys/wait.h>
  32 #include <string.h>
  33 #include <limits.h>
  34 #include "citadel.h"
  35 #include "server.h"
  36 #include "sysdep_decls.h"
  37 #include "citserver.h"
  38 #include "support.h"
  39 #include "config.h"
  40 #include "serv_extensions.h"
  41 #include "room_ops.h"
  42 #include "policy.h"
  43 #include "database.h"
  44 #include "msgbase.h"
  45 #include "tools.h"
  46
  47 #ifdef HAVE_LIBSIEVE
  48
  49 #include <sieve2.h>
  50 #include <sieve2_error.h>
  51 #include "serv_sieve.h"
  52
  53 struct RoomProcList *sieve_list = NULL;
  54
  55 struct ctdl_sieve {
  56         char *rfc822headers;
  57         int actiontaken;                /* Set to 1 if the message was successfully acted upon */
  58         int keep;                       /* Set to 1 to suppress message deletion from the inbox */
  59         long usernum;                   /* Owner of the mailbox we're processing */
  60         long msgnum;                    /* Message base ID of the message being processed */
  61 };
  62
  63
  64 /*
  65  * Callback function to send libSieve trace messages to Citadel log facility
  66  * Set ctdl_libsieve_debug=1 to see extremely verbose libSieve trace
  67  */
  68 int ctdl_debug(sieve2_context_t *s, void *my)
  69 {
  70         static int ctdl_libsieve_debug = 0;
  71
  72         if (ctdl_libsieve_debug) {
  73                 lprintf(CTDL_DEBUG, "Sieve: level [%d] module [%s] file [%s] function [%s]\n",
  74                         sieve2_getvalue_int(s, "level"),
  75                         sieve2_getvalue_string(s, "module"),
  76                         sieve2_getvalue_string(s, "file"),
  77                         sieve2_getvalue_string(s, "function"));
  78                 lprintf(CTDL_DEBUG, "       message [%s]\n",
  79                         sieve2_getvalue_string(s, "message"));
  80         }
  81         return SIEVE2_OK;
  82 }
  83
  84
  85 /*
  86  * Callback function to log script parsing errors
  87  */
  88 int ctdl_errparse(sieve2_context_t *s, void *my)
  89 {
  90         lprintf(CTDL_WARNING, "Error in script, line %d: %s\n",
  91                 sieve2_getvalue_int(s, "lineno"),
  92                 sieve2_getvalue_string(s, "message")
  93         );
  94         return SIEVE2_OK;
  95 }
  96
  97
  98 /*
  99  * Callback function to log script execution errors
 100  */
 101 int ctdl_errexec(sieve2_context_t *s, void *my)
 102 {
 103         lprintf(CTDL_WARNING, "Error executing script: %s\n",
 104                 sieve2_getvalue_string(s, "message")
 105         );
 106         return SIEVE2_OK;
 107 }
 108
 109
 110 /*
 111  * Callback function to redirect a message to a different folder
 112  */
 113 int ctdl_redirect(sieve2_context_t *s, void *my)
 114 {
 115         struct ctdl_sieve *cs = (struct ctdl_sieve *)my;
 116         struct CtdlMessage *msg = NULL;
 117         struct recptypes *valid = NULL;
 118         char recp[256];
 119
 120         safestrncpy(recp, sieve2_getvalue_string(s, "address"), sizeof recp);
 121
 122         lprintf(CTDL_DEBUG, "Action is REDIRECT, recipient <%s>\n", recp);
 123
 124         valid = validate_recipients(recp);
 125         if (valid == NULL) {
 126                 lprintf(CTDL_WARNING, "REDIRECT failed: bad recipient <%s>\n", recp);
 127                 return SIEVE2_ERROR_BADARGS;
 128         }
 129         if (valid->num_error > 0) {
 130                 lprintf(CTDL_WARNING, "REDIRECT failed: bad recipient <%s>\n", recp);
 131                 free(valid);
 132                 return SIEVE2_ERROR_BADARGS;
 133         }
 134
 135         msg = CtdlFetchMessage(cs->msgnum, 1);
 136         if (msg == NULL) {
 137                 lprintf(CTDL_WARNING, "REDIRECT failed: unable to fetch msg %ld\n", cs->msgnum);
 138                 free(valid);
 139                 return SIEVE2_ERROR_BADARGS;
 140         }
 141
 142         CtdlSubmitMsg(msg, valid, NULL);
 143         cs->actiontaken = 1;
 144         free(valid);
 145         CtdlFreeMessage(msg);
 146         return SIEVE2_OK;
 147 }
 148
 149
 150 /*
 151  * Callback function to indicate that a message *will* be kept in the inbox
 152  */
 153 int ctdl_keep(sieve2_context_t *s, void *my)
 154 {
 155         struct ctdl_sieve *cs = (struct ctdl_sieve *)my;
 156
 157         lprintf(CTDL_DEBUG, "Action is KEEP\n");
 158
 159         cs->keep = 1;
 160         cs->actiontaken = 1;
 161         return SIEVE2_OK;
 162 }
 163
 164
 165 /*
 166  * Callback function to file a message into a different mailbox
 167  */
 168 int ctdl_fileinto(sieve2_context_t *s, void *my)
 169 {
 170         struct ctdl_sieve *cs = (struct ctdl_sieve *)my;
 171         const char *dest_folder = sieve2_getvalue_string(s, "mailbox");
 172         int c;
 173         char foldername[256];
 174         char original_room_name[ROOMNAMELEN];
 175
 176         lprintf(CTDL_DEBUG, "Action is FILEINTO, destination is <%s>\n", dest_folder);
 177
 178         /* FILEINTO 'INBOX' is the same thing as KEEP */
 179         if ( (!strcasecmp(dest_folder, "INBOX")) || (!strcasecmp(dest_folder, MAILROOM)) ) {
 180                 cs->keep = 1;
 181                 cs->actiontaken = 1;
 182                 return SIEVE2_OK;
 183         }
 184
 185         /* Remember what room we came from */
 186         safestrncpy(original_room_name, CC->room.QRname, sizeof original_room_name);
 187
 188         /* First try a mailbox name match (check personal mail folders first) */
 189         snprintf(foldername, sizeof foldername, "%010ld.%s", cs->usernum, dest_folder);
 190         c = getroom(&CC->room, foldername);
 191
 192         /* Then a regular room name match (public and private rooms) */
 193         if (c < 0) {
 194                 safestrncpy(foldername, dest_folder, sizeof foldername);
 195                 c = getroom(&CC->room, foldername);
 196         }
 197
 198         if (c < 0) {
 199                 lprintf(CTDL_WARNING, "FILEINTO failed: target <%s> does not exist\n", dest_folder);
 200                 return SIEVE2_ERROR_BADARGS;
 201         }
 202
 203         /* Yes, we actually have to go there */
 204         usergoto(NULL, 0, 0, NULL, NULL);
 205
 206         c = CtdlSaveMsgPointersInRoom(NULL, &cs->msgnum, 1, 0, NULL);
 207
 208         /* Go back to the room we came from */
 209         if (strcasecmp(original_room_name, CC->room.QRname)) {
 210                 usergoto(original_room_name, 0, 0, NULL, NULL);
 211         }
 212
 213         if (c == 0) {
 214                 cs->actiontaken = 1;
 215                 return SIEVE2_OK;
 216         }
 217         else {
 218                 return SIEVE2_ERROR_BADARGS;
 219         }
 220 }
 221
 222
 223 /*
 224  * Callback function to indicate that a message should be rejected
 225  * FIXME implement this
 226  */
 227 int ctdl_reject(sieve2_context_t *s, void *my)
 228 {
 229         lprintf(CTDL_DEBUG, "Action is REJECT\n");
 230         return SIEVE2_ERROR_UNSUPPORTED;
 231 }
 232
 233
 234 /*
 235  * Callback function to indicate that the user should be notified
 236  * FIXME implement this
 237  */
 238 int ctdl_notify(sieve2_context_t *s, void *my)
 239 {
 240         lprintf(CTDL_DEBUG, "Action is NOTIFY\n");
 241         return SIEVE2_ERROR_UNSUPPORTED;
 242 }
 243
 244
 245 /*
 246  * Callback function to indicate that a vacation message should be generated
 247  * FIXME implement this
 248  */
 249 int ctdl_vacation(sieve2_context_t *s, void *my)
 250 {
 251         lprintf(CTDL_DEBUG, "Action is VACATION\n");
 252         return SIEVE2_ERROR_UNSUPPORTED;
 253 }
 254
 255
 256 /*
 257  * Callback function to parse addresses per local system convention
 258  * FIXME implement this
 259  */
 260 int ctdl_getsubaddress(sieve2_context_t *s, void *my)
 261 {
 262         return SIEVE2_ERROR_UNSUPPORTED;
 263 }
 264
 265
 266 /*
 267  * Callback function to parse message envelope
 268  * FIXME implement this
 269  */
 270 int ctdl_getenvelope(sieve2_context_t *s, void *my)
 271 {
 272         return SIEVE2_ERROR_UNSUPPORTED;
 273 }
 274
 275
 276 /*
 277  * Callback function to fetch message body
 278  * FIXME implement this
 279  */
 280 int ctdl_getbody(sieve2_context_t *s, void *my)
 281 {
 282         return SIEVE2_ERROR_UNSUPPORTED;
 283 }
 284
 285
 286 /*
 287  * Callback function to fetch message size
 288  * FIXME implement this
 289  */
 290 int ctdl_getsize(sieve2_context_t *s, void *my)
 291 {
 292         return SIEVE2_ERROR_UNSUPPORTED;
 293 }
 294
 295
 296 /*
 297  * Callback function to indicate that a message should be discarded.
 298  */
 299 int ctdl_discard(sieve2_context_t *s, void *my)
 300 {
 301         struct ctdl_sieve *cs = (struct ctdl_sieve *)my;
 302
 303         lprintf(CTDL_DEBUG, "Action is DISCARD\n");
 304
 305         /* Yes, this is really all there is to it.  Since we are not setting "keep" to 1,
 306          * the message will be discarded because "some other action" was successfully taken.
 307          */
 308         cs->actiontaken = 1;
 309         return SIEVE2_OK;
 310 }
 311
 312
 313
 314 /*
 315  * Callback function to retrieve the sieve script
 316  */
 317 int ctdl_getscript(sieve2_context_t *s, void *my) {
 318
 319         lprintf(CTDL_DEBUG, "ctdl_getscript() was called\n");
 320
 321         sieve2_setvalue_string(s, "script",
 322
 323                 "require \"fileinto\";                                          \n"
 324                 "    if header :contains [\"Subject\"]  [\"frobnitz\"] {        \n"
 325                 "        redirect \"foo@example.com\";                          \n"
 326                 "    } elsif header :contains \"Subject\" \"XYZZY\" {           \n"
 327                 "        fileinto \"plugh\";                                    \n"
 328                 "    } else {                                                   \n"
 329                 "        keep;                                                  \n"
 330                 "    }                                                          \n"
 331
 332         );
 333
 334         return SIEVE2_OK;
 335 }
 336
 337 /*
 338  * Callback function to retrieve message headers
 339  */
 340 int ctdl_getheaders(sieve2_context_t *s, void *my) {
 341
 342         struct ctdl_sieve *cs = (struct ctdl_sieve *)my;
 343
 344         lprintf(CTDL_DEBUG, "ctdl_getheaders() was called\n");
 345
 346         sieve2_setvalue_string(s, "allheaders", cs->rfc822headers);
 347         return SIEVE2_OK;
 348 }
 349
 350
 351
 352 /*
 353  * Add a room to the list of those rooms which potentially require sieve processing
 354  */
 355 void sieve_queue_room(struct ctdlroom *which_room) {
 356         struct RoomProcList *ptr;
 357
 358         ptr = (struct RoomProcList *) malloc(sizeof (struct RoomProcList));
 359         if (ptr == NULL) return;
 360
 361         safestrncpy(ptr->name, which_room->QRname, sizeof ptr->name);
 362         begin_critical_section(S_SIEVELIST);
 363         ptr->next = sieve_list;
 364         sieve_list = ptr;
 365         end_critical_section(S_SIEVELIST);
 366 }
 367
 368
 369 /*
 370  * We need these structs to pass a bunch of information
 371  * between sieve_do_msg() and sieve_do_room()
 372  */
 373
 374 struct sdm_script {
 375         struct sdm_script *next;
 376         char script_name[256];
 377         int script_active;
 378         char *script_content;
 379 };
 380
 381 struct sdm_userdata {
 382         sieve2_context_t *sieve2_context;       /**< for libsieve's use */
 383         long config_msgnum;                     /**< confirms that a sieve config was located */
 384         char config_roomname[ROOMNAMELEN];
 385         long lastproc;                          /**< last message processed */
 386         struct sdm_script *first_script;
 387 };
 388
 389
 390 /*
 391  * Perform sieve processing for one message (called by sieve_do_room() for each message)
 392  */
 393 void sieve_do_msg(long msgnum, void *userdata) {
 394         struct sdm_userdata *u = (struct sdm_userdata *) userdata;
 395         sieve2_context_t *sieve2_context = u->sieve2_context;
 396         struct ctdl_sieve my;
 397         int res;
 398
 399         lprintf(CTDL_DEBUG, "Performing sieve processing on msg <%ld>\n", msgnum);
 400
 401         CC->redirect_buffer = malloc(SIZ);
 402         CC->redirect_len = 0;
 403         CC->redirect_alloc = SIZ;
 404         CtdlOutputMsg(msgnum, MT_RFC822, HEADERS_ONLY, 0, 1, NULL);
 405         my.rfc822headers = CC->redirect_buffer;
 406         CC->redirect_buffer = NULL;
 407         CC->redirect_len = 0;
 408         CC->redirect_alloc = 0;
 409
 410         my.keep = 0;            /* Don't keep a copy in the inbox unless a callback tells us to do so */
 411         my.actiontaken = 0;     /* Keep track of whether any actions were successfully taken */
 412         my.usernum = atol(CC->room.QRname);     /* Keep track of the owner of the room's namespace */
 413         my.msgnum = msgnum;     /* Keep track of the message number in our local store */
 414
 415         sieve2_setvalue_string(sieve2_context, "allheaders", my.rfc822headers);
 416
 417         lprintf(CTDL_DEBUG, "Calling sieve2_execute()\n");
 418         res = sieve2_execute(sieve2_context, &my);
 419         if (res != SIEVE2_OK) {
 420                 lprintf(CTDL_CRIT, "sieve2_execute() returned %d: %s\n", res, sieve2_errstr(res));
 421         }
 422
 423         free(my.rfc822headers);
 424         my.rfc822headers = NULL;
 425
 426         /*
 427          * Delete the message from the inbox unless either we were told not to, or
 428          * if no other action was successfully taken.
 429          */
 430         if ( (!my.keep) && (my.actiontaken) ) {
 431                 lprintf(CTDL_DEBUG, "keep is 0 -- deleting message from inbox\n");
 432                 CtdlDeleteMessages(CC->room.QRname, &msgnum, 1, "", 0);
 433         }
 434
 435         lprintf(CTDL_DEBUG, "Completed sieve processing on msg <%ld>\n", msgnum);
 436         u->lastproc = msgnum;
 437
 438         return;
 439 }
 440
 441
 442
 443 /*
 444  * Given the on-disk representation of our Sieve config, load
 445  * it into an in-memory data structure.
 446  */
 447 void parse_sieve_config(char *conf, struct sdm_userdata *u) {
 448         char *ptr;
 449         char *c;
 450
 451         c = conf;
 452         while (ptr = bmstrcasestr(conf, CTDLSIEVECONFIGSEPARATOR), ptr != NULL) {
 453                 *ptr = 0;
 454                 ptr += strlen(CTDLSIEVECONFIGSEPARATOR);
 455
 456                 lprintf(CTDL_DEBUG, "CONFIG: <%s>\n", c);
 457
 458                 /* FIXME finish this */
 459
 460         }
 461 }
 462
 463 /*
 464  * We found the Sieve configuration for this user.
 465  * Now do something with it.
 466  */
 467 void get_sieve_config_backend(long msgnum, void *userdata) {
 468         struct sdm_userdata *u = (struct sdm_userdata *) userdata;
 469         struct CtdlMessage *msg;
 470         char *conf;
 471
 472         u->config_msgnum = msgnum;
 473         msg = CtdlFetchMessage(u->config_msgnum, 1);
 474         if (msg == NULL) {
 475                 u->config_msgnum = (-1) ;
 476                 return;
 477         }
 478
 479         conf = msg->cm_fields['M'];
 480         msg->cm_fields['M'] = NULL;
 481         CtdlFreeMessage(msg);
 482
 483         if (conf != NULL) {
 484                 parse_sieve_config(conf, u);
 485                 free(conf);
 486         }
 487 }
 488
 489
 490 /*
 491  * Write our citadel sieve config back to disk
 492  */
 493 void rewrite_ctdl_sieve_config(struct sdm_userdata *u) {
 494         char *text;
 495
 496         text =
 497                 "Content-type: application/x-citadel-sieve-config\n"
 498                 "\n"
 499         ;
 500
 501         /* Save the config */
 502         quickie_message("Citadel", NULL, u->config_roomname,
 503                         text,
 504                         4,
 505                         "Sieve configuration"
 506         );
 507
 508         /* And delete the old one */
 509         CtdlDeleteMessages(u->config_roomname, &u->config_msgnum, 1, "", 0);
 510
 511 }
 512
 513
 514
 515 /*
 516  * Perform sieve processing for a single room
 517  */
 518 void sieve_do_room(char *roomname) {
 519
 520         struct sdm_userdata u;
 521         sieve2_context_t *sieve2_context = NULL;        /* Context for sieve parser */
 522         int res;                                        /* Return code from libsieve calls */
 523         long orig_lastproc = 0;
 524
 525         /*
 526          * This is our callback registration table for libSieve.
 527          */
 528         sieve2_callback_t ctdl_sieve_callbacks[] = {
 529                 { SIEVE2_ACTION_REJECT,         ctdl_reject             },
 530                 { SIEVE2_ACTION_NOTIFY,         ctdl_notify             },
 531                 { SIEVE2_ACTION_VACATION,       ctdl_vacation           },
 532                 { SIEVE2_ERRCALL_PARSE,         ctdl_errparse           },
 533                 { SIEVE2_ERRCALL_RUNTIME,       ctdl_errexec            },
 534                 { SIEVE2_ACTION_FILEINTO,       ctdl_fileinto           },
 535                 { SIEVE2_ACTION_REDIRECT,       ctdl_redirect           },
 536                 { SIEVE2_ACTION_DISCARD,        ctdl_discard            },
 537                 { SIEVE2_ACTION_KEEP,           ctdl_keep               },
 538                 { SIEVE2_SCRIPT_GETSCRIPT,      ctdl_getscript          },
 539                 { SIEVE2_DEBUG_TRACE,           ctdl_debug              },
 540                 { SIEVE2_MESSAGE_GETALLHEADERS, ctdl_getheaders         },
 541                 { SIEVE2_MESSAGE_GETSUBADDRESS, ctdl_getsubaddress      },
 542                 { SIEVE2_MESSAGE_GETENVELOPE,   ctdl_getenvelope        },
 543                 { SIEVE2_MESSAGE_GETBODY,       ctdl_getbody            },
 544                 { SIEVE2_MESSAGE_GETSIZE,       ctdl_getsize            },
 545                 { 0 }
 546         };
 547
 548         /* See if the user who owns this 'mailbox' has any Sieve scripts that
 549          * require execution.
 550          */
 551         snprintf(u.config_roomname, sizeof u.config_roomname, "%010ld.%s", atol(roomname), SIEVERULES);
 552         if (getroom(&CC->room, u.config_roomname) != 0) {
 553                 lprintf(CTDL_DEBUG, "<%s> does not exist.  No processing is required.\n", u.config_roomname);
 554                 return;
 555         }
 556
 557         /*
 558          * Find the sieve scripts and control record and do something
 559          */
 560         u.config_msgnum = (-1);
 561         CtdlForEachMessage(MSGS_LAST, 1, NULL, SIEVECONFIG, NULL,
 562                 get_sieve_config_backend, (void *)&u );
 563
 564         if (u.config_msgnum < 0) {
 565                 lprintf(CTDL_DEBUG, "No Sieve rules exist.  No processing is required.\n");
 566                 return;
 567         }
 568
 569         lprintf(CTDL_DEBUG, "Rules found.  Performing Sieve processing for <%s>\n", roomname);
 570
 571         if (getroom(&CC->room, roomname) != 0) {
 572                 lprintf(CTDL_CRIT, "ERROR: cannot load <%s>\n", roomname);
 573                 return;
 574         }
 575
 576         /* Initialize the Sieve parser */
 577
 578         res = sieve2_alloc(&sieve2_context);
 579         if (res != SIEVE2_OK) {
 580                 lprintf(CTDL_CRIT, "sieve2_alloc() returned %d: %s\n", res, sieve2_errstr(res));
 581                 return;
 582         }
 583
 584         res = sieve2_callbacks(sieve2_context, ctdl_sieve_callbacks);
 585         if (res != SIEVE2_OK) {
 586                 lprintf(CTDL_CRIT, "sieve2_callbacks() returned %d: %s\n", res, sieve2_errstr(res));
 587                 goto BAIL;
 588         }
 589
 590         /* Validate the script */
 591
 592         res = sieve2_validate(sieve2_context, NULL);
 593         if (res != SIEVE2_OK) {
 594                 lprintf(CTDL_CRIT, "sieve2_validate() returned %d: %s\n", res, sieve2_errstr(res));
 595                 goto BAIL;
 596         }
 597
 598         /* Do something useful */
 599         u.sieve2_context = sieve2_context;
 600         orig_lastproc = u.lastproc;
 601         CtdlForEachMessage(MSGS_GT, u.lastproc, NULL, NULL, NULL,
 602                 sieve_do_msg,
 603                 (void *) &u
 604         );
 605
 606 BAIL:
 607         res = sieve2_free(&sieve2_context);
 608         if (res != SIEVE2_OK) {
 609                 lprintf(CTDL_CRIT, "sieve2_free() returned %d: %s\n", res, sieve2_errstr(res));
 610         }
 611
 612         /* Rewrite the config if we have to */
 613         if (u.lastproc > orig_lastproc) {
 614                 rewrite_ctdl_sieve_config(&u);
 615         }
 616 }
 617
 618
 619 /*
 620  * Perform sieve processing for all rooms which require it
 621  */
 622 void perform_sieve_processing(void) {
 623         struct RoomProcList *ptr = NULL;
 624
 625         if (sieve_list != NULL) {
 626                 lprintf(CTDL_DEBUG, "Begin Sieve processing\n");
 627                 while (sieve_list != NULL) {
 628                         char spoolroomname[ROOMNAMELEN];
 629                         safestrncpy(spoolroomname, sieve_list->name, sizeof spoolroomname);
 630                         begin_critical_section(S_SIEVELIST);
 631
 632                         /* pop this record off the list */
 633                         ptr = sieve_list;
 634                         sieve_list = sieve_list->next;
 635                         free(ptr);
 636
 637                         /* invalidate any duplicate entries to prevent double processing */
 638                         for (ptr=sieve_list; ptr!=NULL; ptr=ptr->next) {
 639                                 if (!strcasecmp(ptr->name, spoolroomname)) {
 640                                         ptr->name[0] = 0;
 641                                 }
 642                         }
 643
 644                         end_critical_section(S_SIEVELIST);
 645                         if (spoolroomname[0] != 0) {
 646                                 sieve_do_room(spoolroomname);
 647                         }
 648                 }
 649         }
 650 }
 651
 652
 653
 654 /*
 655  *      We don't really care about dumping the entire credits to the log
 656  *      every time the server is initialized.  The documentation will suffice
 657  *      for that purpose.  We are making a call to sieve2_credits() in order
 658  *      to demonstrate that we have successfully linked in to libsieve.
 659  */
 660 void log_the_sieve2_credits(void) {
 661         char *cred = NULL;
 662
 663         cred = strdup(sieve2_credits());
 664         if (cred == NULL) return;
 665
 666         if (strlen(cred) > 60) {
 667                 strcpy(&cred[55], "...");
 668         }
 669
 670         lprintf(CTDL_INFO, "%s\n",cred);
 671         free(cred);
 672 }
 673
 674
 675 char *serv_sieve_init(void)
 676 {
 677         log_the_sieve2_credits();
 678         return "$Id: serv_sieve.c 3850 2005-09-13 14:00:24Z ajc $";
 679 }
 680
 681 #else   /* HAVE_LIBSIEVE */
 682
 683 char *serv_sieve_init(void)
 684 {
 685         lprintf(CTDL_INFO, "This server is missing libsieve.  Mailbox filtering will be disabled.\n");
 686         return "$Id: serv_sieve.c 3850 2005-09-13 14:00:24Z ajc $";
 687 }
 688
 689 #endif  /* HAVE_LIBSIEVE */