Back to index

courier  0.68.2
maildirfilter2.c
Go to the documentation of this file.
00001 /*
00002 ** Copyright 2000-2007 Double Precision, Inc.
00003 ** See COPYING for distribution information.
00004 */
00005 
00006 #include      "maildirfilter.h"
00007 #include      "maildirfilterconfig.h"
00008 #include      "maildircreate.h"
00009 #include      <stdlib.h>
00010 #include      <string.h>
00011 #include      <stdio.h>
00012 #include      <ctype.h>
00013 #include      <errno.h>
00014 #if    HAVE_SYS_STAT_H
00015 #include      <sys/stat.h>
00016 #endif
00017 #if    HAVE_UNISTD_H
00018 #include      <unistd.h>
00019 #endif
00020 
00021 
00022 static const char *maildir_filter_config(const char *maildir,
00023        const char *varname)
00024 {
00025 char *p=malloc(strlen(maildir)+sizeof("/maildirfilterconfig"));
00026 FILE   *f;
00027 static char configbuf[256];
00028 
00029        if (!p)       return (0);
00030 
00031        strcat(strcpy(p, maildir), "/maildirfilterconfig");
00032        f=fopen(p, "r");
00033        free(p);
00034 
00035        if (!f)       f=fopen(MAILDIRFILTERCONFIG, "r");
00036        if (!f)       return (0);
00037 
00038        while ((p=fgets(configbuf, sizeof(configbuf), f)) != 0)
00039        {
00040               if ((p=strchr(configbuf, '\n')) != 0)     *p=0;
00041               p=strchr(configbuf, '=');
00042               if (!p)       continue;
00043               *p++=0;
00044               if (strcmp(configbuf, varname) == 0)
00045               {
00046                      fclose(f);
00047                      return (p);
00048               }
00049        }
00050        fclose(f);
00051        return ("");
00052 }
00053 
00054 static char *maildir_filter_config_maildirfilter(const char *maildir)
00055 {
00056 const char *p=maildir_filter_config(maildir, "MAILDIRFILTER");
00057 char *q;
00058 
00059        if (!p)       return (0);
00060        if (*p == 0)
00061        {
00062               errno=ENOENT;
00063               return (0);
00064        }
00065 
00066        q=malloc(strlen(maildir)+strlen(p)+2);
00067        if (!q)
00068               return NULL;
00069 
00070        *q=0;
00071        if (*p != '/')
00072               strcat(strcpy(q, maildir), "/");
00073        strcat(q, p);
00074        return (q);
00075 }
00076 
00077 int maildir_filter_importmaildirfilter(const char *maildir)
00078 {
00079        const char *p=maildir_filter_config(maildir, "MAILDIRFILTER");
00080        char *maildirfilter;
00081        FILE *i, *o;
00082        struct maildir_tmpcreate_info createInfo;
00083 
00084        if (!p)       return (-1);
00085 
00086        if (!*p)
00087        {
00088               errno=ENOENT;
00089               return (-1);
00090        }
00091 
00092        maildirfilter=maildir_filter_config_maildirfilter(maildir);
00093        if (!maildirfilter)  return (-1);
00094 
00095        maildir_tmpcreate_init(&createInfo);
00096 
00097        createInfo.maildir=maildir;
00098        createInfo.uniq="maildirfilter-tmp";
00099        createInfo.doordie=1;
00100 
00101        if ((o=maildir_tmpcreate_fp(&createInfo)) == NULL)
00102        {
00103               free(maildirfilter);
00104               return (-1);
00105        }
00106 
00107        strcat(strcpy(createInfo.newname, maildir),
00108               "/maildirfilter.tmp"); /* We enough we have enough mem: .uniq */
00109 
00110        if ((i=fopen(maildirfilter, "r")) == 0)
00111        {
00112        struct maildirfilter mf;
00113 
00114               if (errno != ENOENT)
00115               {
00116                      fclose(o);
00117                      unlink(createInfo.tmpname);
00118                      maildir_tmpcreate_free(&createInfo);
00119                      free(maildirfilter);
00120                      return (-1);
00121               }
00122 
00123               memset(&mf, 0, sizeof(mf));
00124               fclose(o);
00125               unlink(createInfo.tmpname);
00126               unlink(createInfo.newname);
00127               maildir_filter_savemaildirfilter(&mf, maildir, "");
00128               /* write out a blank one */
00129        }
00130        else
00131        {
00132               char   buf[BUFSIZ];
00133               int    n;
00134 
00135               while ((n=fread(buf, 1, sizeof(buf), i)) > 0)
00136                      if (fwrite(buf, 1, n, o) != n)
00137                      {
00138                             fclose(o);
00139                             fclose(i);
00140                             unlink(createInfo.tmpname);
00141                             maildir_tmpcreate_free(&createInfo);
00142                             free(maildirfilter);
00143                             return (-1);
00144                      }
00145               if (fflush(o))
00146               {
00147                      fclose(o);
00148                      fclose(i);
00149                      unlink(createInfo.tmpname);
00150                      maildir_tmpcreate_free(&createInfo);
00151                      free(maildirfilter);
00152                      return (-1);
00153               }
00154               fclose(o);
00155               fclose(i);
00156               if (chmod(createInfo.tmpname, 0600)
00157                   || rename(createInfo.tmpname, createInfo.newname))
00158               {
00159                      unlink(createInfo.tmpname);
00160                      maildir_tmpcreate_free(&createInfo);
00161                      free(maildirfilter);
00162                      return (-1);
00163               }
00164        }
00165 
00166        maildir_tmpcreate_free(&createInfo);
00167        free(maildirfilter);
00168        return (0);
00169 }
00170 
00171 int maildir_filter_loadmaildirfilter(struct maildirfilter *mf, const char *maildir)
00172 {
00173 char *newname=malloc(strlen(maildir)+sizeof("/maildirfilter.tmp"));
00174 int    rc;
00175 
00176        if (!newname) return (-1);
00177        strcat(strcpy(newname, maildir), "/maildirfilter.tmp");
00178 
00179        rc=maildir_filter_loadrules(mf, newname);
00180        free(newname);
00181        if (rc && rc != MF_LOADNOTFOUND)
00182               rc= -1;
00183        else
00184               rc=0;
00185        return (rc);
00186 }
00187 
00188 
00189 int maildir_filter_savemaildirfilter(struct maildirfilter *mf, const char *maildir,
00190                       const char *from)
00191 {
00192        const char *maildirpath=maildir_filter_config(maildir, "MAILDIR");
00193        struct maildir_tmpcreate_info createInfo;
00194        int fd, rc;
00195 
00196        if (!maildirpath || !*maildirpath)
00197        {
00198               errno=EINVAL;
00199               return (-1);
00200        }
00201 
00202        maildir_tmpcreate_init(&createInfo);
00203        createInfo.maildir=maildir;
00204        createInfo.uniq="maildirfilter-tmp";
00205        createInfo.doordie=1;
00206 
00207        if ((fd=maildir_tmpcreate_fd(&createInfo)) < 0)
00208               return -1;
00209 
00210        close(fd);
00211        unlink(createInfo.tmpname);
00212 
00213        strcat(strcpy(createInfo.newname, maildir), "/maildirfilter.tmp");
00214 
00215        rc=maildir_filter_saverules(mf, createInfo.tmpname,
00216                                 maildir, maildirpath, from);
00217        if (rc == 0 && rename(createInfo.tmpname, createInfo.newname))
00218               rc= -1;
00219        maildir_tmpcreate_free(&createInfo);
00220        return (rc);
00221 }
00222 
00223 int maildir_filter_exportmaildirfilter(const char *maildir)
00224 {
00225 char *maildirfilter=maildir_filter_config_maildirfilter(maildir);
00226 char *newname;
00227 int    rc;
00228 
00229        if (!maildirfilter)  return (-1);
00230 
00231        newname=malloc(strlen(maildir)+sizeof("/maildirfilter.tmp"));
00232        if (!newname)
00233        {
00234               free(maildirfilter);
00235               return (-1);
00236        }
00237 
00238        strcat(strcpy(newname, maildir), "/maildirfilter.tmp");
00239        rc=rename(newname, maildirfilter);
00240        free(maildirfilter);
00241        free(newname);
00242        return (rc);
00243 }
00244 
00245 int maildir_filter_hasmaildirfilter(const char *maildir)
00246 {
00247 const char *p=maildir_filter_config(maildir, "MAILDIR");
00248 
00249        if (!p || !*p)       return (-1);
00250 
00251        p=maildir_filter_config(maildir, "MAILDIRFILTER");
00252        if (!p || !*p)       return (-1);
00253        return (0);
00254 }
00255 
00256 void maildir_filter_endmaildirfilter(const char *maildir)
00257 {
00258 char *maildirfilter=maildir_filter_config_maildirfilter(maildir);
00259 char *newname;
00260 
00261        if (!maildirfilter)  return;
00262 
00263        newname=malloc(strlen(maildir)+sizeof("/maildirfilter.tmp"));
00264        if (!newname)
00265        {
00266               free(maildirfilter);
00267               return;
00268        }
00269 
00270        strcat(strcpy(newname, maildir), "/maildirfilter.tmp");
00271        unlink(newname);
00272        free(maildirfilter);
00273        free(newname);
00274 }