storage/interface.c

   1 /*  $Id: interface.c 7277 2005-06-07 04:40:16Z eagle $
   2 **
   3 **  Storage Manager interface
   4 */
   5 #include "config.h"
   6 #include "clibrary.h"
   7 #include <ctype.h>
   8 #include <errno.h>
   9 #include <syslog.h>
  10 #include <time.h>
  11
  12 #include "conffile.h"
  13 #include "inn/innconf.h"
  14 #include "inn/wire.h"
  15 #include "interface.h"
  16 #include "libinn.h"
  17 #include "methods.h"
  18 #include "paths.h"
  19
  20 typedef enum {INIT_NO, INIT_DONE, INIT_FAIL} INITTYPE;
  21 typedef struct {
  22     INITTYPE            initialized;
  23     bool                configured;
  24     bool                selfexpire;
  25     bool                expensivestat;
  26 } METHOD_DATA;
  27
  28 METHOD_DATA method_data[NUM_STORAGE_METHODS];
  29
  30 static STORAGE_SUB      *subscriptions = NULL;
  31 static unsigned int     typetoindex[256];
  32 int                     SMerrno;
  33 char                    *SMerrorstr = NULL;
  34 static bool             ErrorAlloc = false;
  35 static bool             Initialized = false;
  36 bool                    SMopenmode = false;
  37 bool                    SMpreopen = false;
  38
  39 /*
  40 ** Checks to see if the token is valid
  41 */
  42 bool IsToken(const char *text) {
  43     const char          *p;
  44
  45     if (!text)
  46         return false;
  47
  48     if (strlen(text) != (sizeof(TOKEN) * 2) + 2)
  49         return false;
  50
  51     if (text[0] != '@')
  52         return false;
  53
  54     if (text[(sizeof(TOKEN) * 2) + 1] != '@')
  55         return false;
  56
  57     for (p = text + 1; *p != '@'; p++)
  58         if (!isxdigit((int)*p))
  59             return false;
  60
  61     return true;
  62 }
  63
  64 /*
  65 ** Converts a token to a textual representation for error messages
  66 ** and the like.
  67 */
  68 char *
  69 TokenToText(const TOKEN token)
  70 {
  71     static const char   hex[] = "0123456789ABCDEF";
  72     static char         result[(sizeof(TOKEN) * 2) + 3];
  73     const char          *p;
  74     char                *q;
  75     size_t              i;
  76
  77
  78     result[0] = '@';
  79     for (q = result + 1, p = (const char *) &token, i = 0; i < sizeof(TOKEN);
  80          i++, p++) {
  81         *q++ = hex[(*p & 0xF0) >> 4];
  82         *q++ = hex[*p & 0x0F];
  83     }
  84     *q++ = '@';
  85     *q++ = '\0';
  86     return result;
  87
  88 }
  89
  90 /*
  91 ** Converts a hex digit and converts it to a int
  92 */
  93 static int hextodec(const int c) {
  94     return isdigit(c) ? (c - '0') : ((c - 'A') + 10);
  95 }
  96
  97 /*
  98 ** Converts a textual representation of a token back to a native
  99 ** representation
 100 */
 101 TOKEN TextToToken(const char *text) {
 102     const char          *p;
 103     char                *q;
 104     int                 i;
 105     TOKEN               token;
 106
 107     if (text[0] == '@')
 108         p = &text[1];
 109     else
 110         p = text;
 111
 112     for (q = (char *)&token, i = 0; i != sizeof(TOKEN); i++) {
 113         q[i] = (hextodec(*p) << 4) + hextodec(*(p + 1));
 114         p += 2;
 115     }
 116     return token;
 117 }
 118
 119 /*
 120 ** Given an article and length in non-wire format, return a malloced region
 121 ** containing the article in wire format.  Set *newlen to the length of the
 122 ** new article.
 123 */
 124 char *
 125 ToWireFmt(const char *article, size_t len, size_t *newlen)
 126 {
 127     size_t bytes;
 128     char *newart;
 129     const char *p;
 130     char  *dest;
 131     bool atstartofline=true;
 132
 133     /* First go thru article and count number of bytes we need. */
 134     for (bytes = 0, p=article ; p < &article[len] ; ++p) {
 135         if (*p == '.' && atstartofline) ++bytes; /* 1 byte for escaping . */
 136         ++bytes;
 137         if (*p == '\n') {
 138             ++bytes; /* need another byte for CR */
 139             atstartofline = true; /* next char starts new line */
 140         } else {
 141             atstartofline = false;
 142         }
 143     }
 144     bytes += 3; /* for .\r\n */
 145     newart = xmalloc(bytes + 1);
 146     *newlen = bytes;
 147
 148     /* now copy the article, making changes */
 149     atstartofline = true;
 150     for (p=article, dest=newart ; p < &article[len] ; ++p) {
 151         if (*p == '\n') {
 152             *dest++ = '\r';
 153             *dest++ = '\n';
 154             atstartofline = true;
 155         } else {
 156             if (atstartofline && *p == '.') *dest++ = '.'; /* add extra . */
 157             *dest++ = *p;
 158             atstartofline = false;
 159         }
 160     }
 161     *dest++ = '.';
 162     *dest++ = '\r';
 163     *dest++ = '\n';
 164     *dest = '\0';
 165     return newart;
 166 }
 167
 168 char *
 169 FromWireFmt(const char *article, size_t len, size_t *newlen)
 170 {
 171     size_t bytes;
 172     char *newart;
 173     const char *p;
 174     char *dest;
 175     bool atstartofline = true;
 176
 177     /* First go thru article and count number of bytes we need */
 178     for (bytes = 0, p=article ; p < &article[len] ; ) {
 179         /* check for terminating .\r\n and if so break */
 180         if (p == &article[len-3] && *p == '.' && p[1] == '\r' && p[2] == '\n')
 181             break;
 182         /* check for .. at start-of-line */
 183         if (atstartofline && p < &article[len-1] && *p == '.' && p[1] == '.') {
 184             bytes++; /* only output 1 byte */
 185             p+=2;
 186             atstartofline = false;
 187         } else if (p < &article[len-1] && *p == '\r' && p[1] == '\n') {
 188             bytes++; /* \r\n counts as only one byte in output */
 189             p += 2;
 190             atstartofline = true;
 191         } else {
 192             bytes++;
 193             p++;
 194             atstartofline = false;
 195         }
 196     }
 197     newart = xmalloc(bytes + 1);
 198     *newlen = bytes;
 199     for (p = article, dest = newart ; p < &article[len]; ) {
 200         /* check for terminating .\r\n and if so break */
 201         if (p == &article[len-3] && *p == '.' && p[1] == '\r' && p[2] == '\n')
 202             break;
 203         if (atstartofline && p < &article[len-1] && *p == '.' && p[1] == '.') {
 204             *dest++ = '.';
 205             p += 2;
 206             atstartofline = false;
 207         } else if (p < &article[len-1] && *p == '\r' && p[1] == '\n') {
 208             *dest++ = '\n';
 209             p += 2;
 210             atstartofline = true;
 211         } else {
 212             *dest++ = *p++;
 213             atstartofline = false;
 214         }
 215     }
 216     *dest = '\0';
 217     return newart;
 218 }
 219
 220 /*
 221 **  get Xref header without pathhost
 222 */
 223 static char *
 224 GetXref(ARTHANDLE *art)
 225 {
 226   const char *p, *p1;
 227   const char *q;
 228   char  *buff;
 229   bool  Nocr = false;
 230
 231   p = wire_findheader(art->data, art->len, "xref");
 232   if (p == NULL)
 233     return NULL;
 234   q = p;
 235   for (p1 = NULL; p < art->data + art->len; p++) {
 236     if (p1 != (char *)NULL && *p1 == '\r' && *p == '\n') {
 237       Nocr = false;
 238       break;
 239     }
 240     if (*p == '\n') {
 241       Nocr = true;
 242       break;
 243     }
 244     p1 = p;
 245   }
 246   if (p >= art->data + art->len)
 247     return NULL;
 248   if (!Nocr)
 249     p = p1;
 250   /* skip pathhost */
 251   for (; (*q == ' ') && (q < p); q++);
 252   if (q == p)
 253     return NULL;
 254   if ((q = memchr(q, ' ', p - q)) == NULL)
 255     return NULL;
 256   for (q++; (*q == ' ') && (q < p); q++);
 257   if (q == p)
 258     return NULL;
 259   buff = xmalloc(p - q + 1);
 260   memcpy(buff, q, p - q);
 261   buff[p - q] = '\0';
 262   return buff;
 263 }
 264
 265 /*
 266 **  Split newsgroup and returns artnum
 267 **  or 0 if there are no newsgroup.
 268 */
 269 static ARTNUM GetGroups(char *Xref) {
 270   char  *p;
 271
 272   if ((p = strchr(Xref, ':')) == NULL)
 273     return 0;
 274   *p++ = '\0';
 275   return ((ARTNUM)atoi(p));
 276 }
 277
 278 STORAGE_SUB *SMGetConfig(STORAGETYPE type, STORAGE_SUB *sub) {
 279     if (sub == (STORAGE_SUB *)NULL)
 280         sub = subscriptions;
 281     else
 282         sub = sub->next;
 283     for (;sub != NULL; sub = sub->next) {
 284         if (sub->type == type) {
 285             return sub;
 286         }
 287     }
 288     return (STORAGE_SUB *)NULL;
 289 }
 290
 291 static time_t ParseTime(char *tmbuf)
 292 {
 293     char *startnum;
 294     time_t ret;
 295     int tmp;
 296
 297     ret = 0;
 298     startnum = tmbuf;
 299     while (*tmbuf) {
 300         if (!isdigit((int)*tmbuf)) {
 301             tmp = atol(startnum);
 302             switch (*tmbuf) {
 303               case 'M':
 304                 ret += tmp*60*60*24*31;
 305                 break;
 306               case 'd':
 307                 ret += tmp*60*60*24;
 308                 break;
 309               case 'h':
 310                 ret += tmp*60*60;
 311                 break;
 312               case 'm':
 313                 ret += tmp*60;
 314                 break;
 315               case 's':
 316                 ret += tmp;
 317                 break;
 318               default:
 319                 return(0);
 320             }
 321             startnum = tmbuf+1;
 322         }
 323         tmbuf++;
 324     }
 325     return(ret);
 326 }
 327
 328 #define SMlbrace  1
 329 #define SMrbrace  2
 330 #define SMmethod  10
 331 #define SMgroups  11
 332 #define SMsize    12
 333 #define SMclass   13
 334 #define SMexpire  14
 335 #define SMoptions 15
 336 #define SMexactmatch 16
 337
 338 static CONFTOKEN smtoks[] = {
 339   { SMlbrace,   "{" },
 340   { SMrbrace,   "}" },
 341   { SMmethod,   "method" },
 342   { SMgroups,   "newsgroups:" },
 343   { SMsize,     "size:" },
 344   { SMclass,    "class:" },
 345   { SMexpire,   "expires:" },
 346   { SMoptions,  "options:" },
 347   { SMexactmatch,       "exactmatch:" },
 348   { 0, 0 }
 349 };
 350
 351 /* Open the config file and parse it, generating the policy data */
 352 static bool
 353 SMreadconfig(void)
 354 {
 355     CONFFILE            *f;
 356     CONFTOKEN           *tok;
 357     int                 type;
 358     int                 i;
 359     char                *p;
 360     char                *q;
 361     char                *path;
 362     char                *method = NULL;
 363     char                *pattern = NULL;
 364     size_t              minsize = 0;
 365     size_t              maxsize = 0;
 366     time_t              minexpire = 0;
 367     time_t              maxexpire = 0;
 368     int                 class = 0;
 369     STORAGE_SUB         *sub = NULL;
 370     STORAGE_SUB         *prev = NULL;
 371     char                *options = 0;
 372     int                 inbrace;
 373     bool                exactmatch = false;
 374
 375     /* if innconf isn't already read in, do so. */
 376     if (innconf == NULL) {
 377         if (!innconf_read(NULL)) {
 378             SMseterror(SMERR_INTERNAL, "ReadInnConf() failed");
 379             return false;
 380         }
 381     }
 382
 383     for (i = 0; i < NUM_STORAGE_METHODS; i++) {
 384         method_data[i].initialized = INIT_NO;
 385         method_data[i].configured = false;
 386     }
 387     path = concatpath(innconf->pathetc, _PATH_STORAGECTL);
 388     f = CONFfopen(path);
 389     if (f == NULL) {
 390         SMseterror(SMERR_UNDEFINED, NULL);
 391         syslog(L_ERROR, "SM Could not open %s: %m", path);
 392         free(path);
 393         return false;
 394     }
 395     free(path);
 396
 397     inbrace = 0;
 398     while ((tok = CONFgettoken(smtoks, f)) != NULL) {
 399         if (!inbrace) {
 400             if (tok->type != SMmethod) {
 401                 SMseterror(SMERR_CONFIG, "Expected 'method' keyword");
 402                 syslog(L_ERROR, "SM expected 'method' keyword, line %d", f->lineno);
 403                 return false;
 404             }
 405             if ((tok = CONFgettoken(0, f)) == NULL) {
 406                 SMseterror(SMERR_CONFIG, "Expected method name");
 407                 syslog(L_ERROR, "SM expected method name, line %d", f->lineno);
 408                 return false;
 409             }
 410             method = xstrdup(tok->name);
 411             if ((tok = CONFgettoken(smtoks, f)) == NULL || tok->type != SMlbrace) {
 412                 SMseterror(SMERR_CONFIG, "Expected '{'");
 413                 syslog(L_ERROR, "SM Expected '{', line %d", f->lineno);
 414                 return false;
 415             }
 416             inbrace = 1;
 417             /* initialize various params to defaults. */
 418             minsize = 0;
 419             maxsize = 0; /* zero means no limit */
 420             class = 0;
 421             pattern = NULL;
 422             options = NULL;
 423             minexpire = 0;
 424             maxexpire = 0;
 425             exactmatch = false;
 426
 427         } else {
 428             type = tok->type;
 429             if (type == SMrbrace)
 430                 inbrace = 0;
 431             else {
 432                 if ((tok = CONFgettoken(0, f)) == NULL) {
 433                     SMseterror(SMERR_CONFIG, "Keyword with no value");
 434                     syslog(L_ERROR, "SM keyword with no value, line %d", f->lineno);
 435                     return false;
 436                 }
 437                 p = tok->name;
 438                 switch(type) {
 439                   case SMgroups:
 440                     if (pattern)
 441                         free(pattern);
 442                     pattern = xstrdup(tok->name);
 443                     break;
 444                   case SMsize:
 445                     minsize = strtoul(p, NULL, 10);
 446                     if ((p = strchr(p, ',')) != NULL) {
 447                         p++;
 448                         maxsize = strtoul(p, NULL, 10);
 449                     }
 450                     break;
 451                   case SMclass:
 452                     class = atoi(p);
 453                     if (class > NUM_STORAGE_CLASSES) {
 454                         SMseterror(SMERR_CONFIG, "Storage class too large");
 455                         warn("SM: storage class larger than %d, line %d",
 456                              NUM_STORAGE_CLASSES, f->lineno);
 457                         return false;
 458                     }
 459                     break;
 460                   case SMexpire:
 461                     q = strchr(p, ',');
 462                     if (q)
 463                         *q++ = 0;
 464                     minexpire = ParseTime(p);
 465                     if (q)
 466                         maxexpire = ParseTime(q);
 467                     break;
 468                   case SMoptions:
 469                     if (options)
 470                         free(options);
 471                     options = xstrdup(p);
 472                     break;
 473                   case SMexactmatch:
 474                     if (strcasecmp(p, "true") == 0
 475                         || strcasecmp(p, "yes") == 0
 476                         || strcasecmp(p, "on") == 0)
 477                         exactmatch = true;
 478                     break;
 479                   default:
 480                     SMseterror(SMERR_CONFIG, "Unknown keyword in method declaration");
 481                     syslog(L_ERROR, "SM Unknown keyword in method declaration, line %d: %s", f->lineno, tok->name);
 482                     free(method);
 483                     return false;
 484                     break;
 485                 }
 486             }
 487         }
 488         if (!inbrace) {
 489             /* just finished a declaration */
 490             sub = xmalloc(sizeof(STORAGE_SUB));
 491             sub->type = TOKEN_EMPTY;
 492             for (i = 0; i < NUM_STORAGE_METHODS; i++) {
 493                 if (!strcasecmp(method, storage_methods[i].name)) {
 494                     sub->type = storage_methods[i].type;
 495                     method_data[i].configured = true;
 496                     break;
 497                 }
 498             }
 499             if (sub->type == TOKEN_EMPTY) {
 500                 SMseterror(SMERR_CONFIG, "Invalid storage method name");
 501                 syslog(L_ERROR, "SM no configured storage methods are named '%s'", method);
 502                 free(options);
 503                 free(sub);
 504                 return false;
 505             }
 506             if (!pattern) {
 507                 SMseterror(SMERR_CONFIG, "pattern not defined");
 508                 syslog(L_ERROR, "SM no pattern defined");
 509                 free(options);
 510                 free(sub);
 511                 return false;
 512             }
 513             sub->pattern = pattern;
 514             sub->minsize = minsize;
 515             sub->maxsize = maxsize;
 516             sub->class = class;
 517             sub->options = options;
 518             sub->minexpire = minexpire;
 519             sub->maxexpire = maxexpire;
 520             sub->exactmatch = exactmatch;
 521
 522             free(method);
 523             method = 0;
 524
 525             if (!prev)
 526                 subscriptions = sub;
 527             if (prev)
 528                 prev->next = sub;
 529             prev = sub;
 530             sub->next = NULL;
 531         }
 532     }
 533
 534     CONFfclose(f);
 535
 536     return true;
 537 }
 538
 539 /*
 540 ** setup storage api environment (open mode etc.)
 541 */
 542 bool SMsetup(SMSETUP type, void *value) {
 543     if (Initialized)
 544         return false;
 545     switch (type) {
 546     case SM_RDWR:
 547         SMopenmode = *(bool *)value;
 548         break;
 549     case SM_PREOPEN:
 550         SMpreopen = *(bool *)value;
 551         break;
 552     default:
 553         return false;
 554     }
 555     return true;
 556 }
 557
 558 /*
 559 ** Calls the setup function for all of the configured methods and returns
 560 ** true if they all initialize ok, false if they don't
 561 */
 562 bool SMinit(void) {
 563     int                 i;
 564     bool                allok = true;
 565     static              bool once = false;
 566     SMATTRIBUTE         smattr;
 567
 568     if (Initialized)
 569         return true;
 570
 571     Initialized = true;
 572
 573     if (!SMreadconfig()) {
 574         SMshutdown();
 575         Initialized = false;
 576         return false;
 577     }
 578
 579     for (i = 0; i < NUM_STORAGE_METHODS; i++) {
 580         if (method_data[i].configured) {
 581             if (method_data[i].configured && storage_methods[i].init(&smattr)) {
 582                 method_data[i].initialized = INIT_DONE;
 583                 method_data[i].selfexpire = smattr.selfexpire;
 584                 method_data[i].expensivestat = smattr.expensivestat;
 585             } else {
 586                 method_data[i].initialized = INIT_FAIL;
 587                 method_data[i].selfexpire = false;
 588                 method_data[i].expensivestat = true;
 589                 syslog(L_ERROR, "SM storage method '%s' failed initialization", storage_methods[i].name);
 590                 allok = false;
 591             }
 592         }
 593         typetoindex[storage_methods[i].type] = i;
 594     }
 595     if (!allok) {
 596         SMshutdown();
 597         Initialized = false;
 598         SMseterror(SMERR_UNDEFINED, "one or more storage methods failed initialization");
 599         syslog(L_ERROR, "SM one or more storage methods failed initialization");
 600         return false;
 601     }
 602     if (!once && atexit(SMshutdown) < 0) {
 603         SMshutdown();
 604         Initialized = false;
 605         SMseterror(SMERR_UNDEFINED, NULL);
 606         return false;
 607     }
 608     once = true;
 609     return true;
 610 }
 611
 612 static bool InitMethod(STORAGETYPE method) {
 613     SMATTRIBUTE         smattr;
 614
 615     if (!Initialized)
 616         if (!SMreadconfig()) {
 617             Initialized = false;
 618             return false;
 619         }
 620     Initialized = true;
 621
 622     if (method_data[method].initialized == INIT_DONE)
 623         return true;
 624
 625     if (method_data[method].initialized == INIT_FAIL)
 626         return false;
 627
 628     if (!method_data[method].configured) {
 629         method_data[method].initialized = INIT_FAIL;
 630         SMseterror(SMERR_UNDEFINED, "storage method is not configured.");
 631         return false;
 632     }
 633     if (!storage_methods[method].init(&smattr)) {
 634         method_data[method].initialized = INIT_FAIL;
 635         method_data[method].selfexpire = false;
 636         method_data[method].expensivestat = true;
 637         SMseterror(SMERR_UNDEFINED, "Could not initialize storage method late.");
 638         return false;
 639     }
 640     method_data[method].initialized = INIT_DONE;
 641     method_data[method].selfexpire = smattr.selfexpire;
 642     method_data[method].expensivestat = smattr.expensivestat;
 643     return true;
 644 }
 645
 646 static bool
 647 MatchGroups(const char *g, int len, const char *pattern, bool exactmatch)
 648 {
 649     char *group, *groups, *q;
 650     int i, lastwhite;
 651     enum uwildmat matched;
 652     bool wanted = false;
 653
 654     q = groups = xmalloc(len + 1);
 655     for (lastwhite = -1,  i = 0 ; i < len ; i++) {
 656         /* trim white chars */
 657         if (g[i] == '\r' || g[i] == '\n' || g[i] == ' ' || g[i] == '\t') {
 658             if (lastwhite + 1 != i)
 659                 *q++ = ' ';
 660             lastwhite = i;
 661         } else
 662             *q++ = g[i];
 663     }
 664     *q = '\0';
 665
 666     group = strtok(groups, " ,");
 667     while (group != NULL) {
 668         q = strchr(group, ':');
 669         if (q != NULL)
 670             *q = '\0';
 671         matched = uwildmat_poison(group, pattern);
 672         if (matched == UWILDMAT_POISON || (exactmatch && !matched)) {
 673             free(groups);
 674             return false;
 675         }
 676         if (matched == UWILDMAT_MATCH)
 677             wanted = true;
 678         group = strtok(NULL, " ,");
 679     }
 680
 681     free(groups);
 682     return wanted;
 683 }
 684
 685 STORAGE_SUB *SMgetsub(const ARTHANDLE article) {
 686     STORAGE_SUB         *sub;
 687
 688     if (article.len == 0) {
 689         SMseterror(SMERR_BADHANDLE, NULL);
 690         return NULL;
 691     }
 692
 693     if (article.groups == NULL)
 694         return NULL;
 695
 696     for (sub = subscriptions; sub != NULL; sub = sub->next) {
 697         if (!(method_data[typetoindex[sub->type]].initialized == INIT_FAIL) &&
 698             (article.len >= sub->minsize) &&
 699             (!sub->maxsize || (article.len <= sub->maxsize)) &&
 700             (!sub->minexpire || article.expires >= sub->minexpire) &&
 701             (!sub->maxexpire || (article.expires <= sub->maxexpire)) &&
 702             MatchGroups(article.groups, article.groupslen, sub->pattern,
 703                         sub->exactmatch)) {
 704             if (InitMethod(typetoindex[sub->type]))
 705                 return sub;
 706         }
 707     }
 708     errno = 0;
 709     SMseterror(SMERR_NOMATCH, "no matching entry in storage.conf");
 710     return NULL;
 711 }
 712
 713 TOKEN SMstore(const ARTHANDLE article) {
 714     STORAGE_SUB         *sub;
 715     TOKEN               result;
 716
 717     if (!SMopenmode) {
 718         result.type = TOKEN_EMPTY;
 719         SMseterror(SMERR_INTERNAL, "read only storage api");
 720         return result;
 721     }
 722     result.type = TOKEN_EMPTY;
 723     if ((sub = SMgetsub(article)) == NULL) {
 724         return result;
 725     }
 726     return storage_methods[typetoindex[sub->type]].store(article, sub->class);
 727 }
 728
 729 ARTHANDLE *SMretrieve(const TOKEN token, const RETRTYPE amount) {
 730     ARTHANDLE           *art;
 731
 732     if (method_data[typetoindex[token.type]].initialized == INIT_FAIL) {
 733         SMseterror(SMERR_UNINIT, NULL);
 734         return NULL;
 735     }
 736     if (method_data[typetoindex[token.type]].initialized == INIT_NO && !InitMethod(typetoindex[token.type])) {
 737         syslog(L_ERROR, "SM could not find token type or method was not initialized (%d)",
 738                token.type);
 739         SMseterror(SMERR_UNINIT, NULL);
 740         return NULL;
 741     }
 742     art = storage_methods[typetoindex[token.type]].retrieve(token, amount);
 743     if (art)
 744         art->nextmethod = 0;
 745     return art;
 746
 747 }
 748
 749 ARTHANDLE *SMnext(const ARTHANDLE *article, const RETRTYPE amount) {
 750     unsigned char       i;
 751     int                 start;
 752     ARTHANDLE           *newart;
 753
 754     if (article == NULL)
 755         start = 0;
 756     else
 757         start= article->nextmethod;
 758
 759     if (method_data[start].initialized == INIT_FAIL) {
 760         SMseterror(SMERR_UNINIT, NULL);
 761         return NULL;
 762     }
 763     if (method_data[start].initialized == INIT_NO && method_data[start].configured
 764       && !InitMethod(start)) {
 765         SMseterror(SMERR_UNINIT, NULL);
 766         return NULL;
 767     }
 768
 769     for (i = start, newart = NULL; i < NUM_STORAGE_METHODS; i++) {
 770         if (method_data[i].configured && (newart = storage_methods[i].next(article, amount)) != (ARTHANDLE *)NULL) {
 771             newart->nextmethod = i;
 772             break;
 773         } else
 774             article = NULL;
 775     }
 776
 777     return newart;
 778 }
 779
 780 void SMfreearticle(ARTHANDLE *article) {
 781     if (method_data[typetoindex[article->type]].initialized == INIT_FAIL) {
 782         return;
 783     }
 784     if (method_data[typetoindex[article->type]].initialized == INIT_NO && !InitMethod(typetoindex[article->type])) {
 785         syslog(L_ERROR, "SM can't free article with uninitialized method");
 786         return;
 787     }
 788     storage_methods[typetoindex[article->type]].freearticle(article);
 789 }
 790
 791 bool SMcancel(TOKEN token) {
 792     if (!SMopenmode) {
 793         SMseterror(SMERR_INTERNAL, "read only storage api");
 794         return false;
 795     }
 796     if (method_data[typetoindex[token.type]].initialized == INIT_FAIL) {
 797         SMseterror(SMERR_UNINIT, NULL);
 798         return false;
 799     }
 800     if (method_data[typetoindex[token.type]].initialized == INIT_NO && !InitMethod(typetoindex[token.type])) {
 801         SMseterror(SMERR_UNINIT, NULL);
 802         syslog(L_ERROR, "SM can't cancel article with uninitialized method");
 803         return false;
 804     }
 805     return storage_methods[typetoindex[token.type]].cancel(token);
 806 }
 807
 808 bool SMprobe(PROBETYPE type, TOKEN *token, void *value) {
 809     struct artngnum     *ann;
 810     ARTHANDLE           *art;
 811
 812     switch (type) {
 813     case SELFEXPIRE:
 814         return (method_data[typetoindex[token->type]].selfexpire);
 815     case SMARTNGNUM:
 816         if (method_data[typetoindex[token->type]].initialized == INIT_FAIL) {
 817             SMseterror(SMERR_UNINIT, NULL);
 818             return false;
 819         }
 820         if (method_data[typetoindex[token->type]].initialized == INIT_NO && !InitMethod(typetoindex[token->type])) {
 821             SMseterror(SMERR_UNINIT, NULL);
 822             syslog(L_ERROR, "SM can't cancel article with uninitialized method");
 823             return false;
 824         }
 825         if ((ann = (struct artngnum *)value) == NULL)
 826             return false;
 827         ann->groupname = NULL;
 828         if (storage_methods[typetoindex[token->type]].ctl(type, token, value)) {
 829             if (ann->artnum != 0) {
 830                 /* set by storage method */
 831                 return true;
 832             } else {
 833                 art = storage_methods[typetoindex[token->type]].retrieve(*token, RETR_HEAD);
 834                 if (art == NULL) {
 835                     if (ann->groupname != NULL)
 836                         free(ann->groupname);
 837                     storage_methods[typetoindex[token->type]].freearticle(art);
 838                     return false;
 839                 }
 840                 if ((ann->groupname = GetXref(art)) == NULL) {
 841                     if (ann->groupname != NULL)
 842                         free(ann->groupname);
 843                     storage_methods[typetoindex[token->type]].freearticle(art);
 844                     return false;
 845                 }
 846                 storage_methods[typetoindex[token->type]].freearticle(art);
 847                 if ((ann->artnum = GetGroups(ann->groupname)) == 0) {
 848                     if (ann->groupname != NULL)
 849                         free(ann->groupname);
 850                     return false;
 851                 }
 852                 return true;
 853             }
 854         } else {
 855             return false;
 856         }
 857     case EXPENSIVESTAT:
 858         return (method_data[typetoindex[token->type]].expensivestat);
 859     default:
 860         return false;
 861     }
 862 }
 863
 864 bool SMflushcacheddata(FLUSHTYPE type) {
 865     int         i;
 866
 867     for (i = 0; i < NUM_STORAGE_METHODS; i++) {
 868         if (method_data[i].initialized == INIT_DONE &&
 869             !storage_methods[i].flushcacheddata(type))
 870             syslog(L_ERROR, "SM can't flush cached data method '%s'", storage_methods[i].name);
 871     }
 872     return true;
 873 }
 874
 875 void SMprintfiles(FILE *file, TOKEN token, char **xref, int ngroups) {
 876     if (method_data[typetoindex[token.type]].initialized == INIT_FAIL)
 877         return;
 878     if (method_data[typetoindex[token.type]].initialized == INIT_NO
 879         && !InitMethod(typetoindex[token.type])) {
 880         SMseterror(SMERR_UNINIT, NULL);
 881         syslog(L_ERROR, "SM can't print files for article with uninitialized method");
 882         return;
 883     }
 884     storage_methods[typetoindex[token.type]].printfiles(file, token, xref, ngroups);
 885 }
 886
 887 void SMshutdown(void) {
 888     int                 i;
 889     STORAGE_SUB         *old;
 890
 891     if (!Initialized)
 892         return;
 893
 894     for (i = 0; i < NUM_STORAGE_METHODS; i++)
 895         if (method_data[i].initialized == INIT_DONE) {
 896             storage_methods[i].shutdown();
 897             method_data[i].initialized = INIT_NO;
 898             method_data[i].configured = false;
 899         }
 900     while (subscriptions) {
 901         old = subscriptions;
 902         subscriptions = subscriptions->next;
 903         free(old->pattern);
 904         free(old->options);
 905         free(old);
 906     }
 907     Initialized = false;
 908 }
 909
 910 void SMseterror(int errornum, char *error) {
 911     if (ErrorAlloc)
 912         free(SMerrorstr);
 913
 914     ErrorAlloc = false;
 915
 916     if ((errornum == SMERR_UNDEFINED) && (errno == ENOENT))
 917         errornum = SMERR_NOENT;
 918
 919     SMerrno = errornum;
 920
 921     if (error == NULL) {
 922         switch (SMerrno) {
 923         case SMERR_UNDEFINED:
 924             SMerrorstr = xstrdup(strerror(errno));
 925             ErrorAlloc = true;
 926             break;
 927         case SMERR_INTERNAL:
 928             SMerrorstr = "Internal error";
 929             break;
 930         case SMERR_NOENT:
 931             SMerrorstr = "Token not found";
 932             break;
 933         case SMERR_TOKENSHORT:
 934             SMerrorstr = "Configured token size too small";
 935             break;
 936         case SMERR_NOBODY:
 937             SMerrorstr = "No article body found";
 938             break;
 939         case SMERR_UNINIT:
 940             SMerrorstr = "Storage manager is not initialized";
 941             break;
 942         case SMERR_CONFIG:
 943             SMerrorstr = "Error reading config file";
 944             break;
 945         case SMERR_BADHANDLE:
 946             SMerrorstr = "Bad article handle";
 947             break;
 948         case SMERR_BADTOKEN:
 949             SMerrorstr = "Bad token";
 950             break;
 951         case SMERR_NOMATCH:
 952             SMerrorstr = "No matching entry in storage.conf";
 953             break;
 954         default:
 955             SMerrorstr = "Undefined error";
 956         }
 957     } else {
 958         SMerrorstr = xstrdup(error);
 959         ErrorAlloc = true;
 960     }
 961 }
 962