src/StoreMeta.cc

   1
   2 /*
   3  * DEBUG: section 20    Storage Manager Swapfile Metadata
   4  * AUTHOR: Kostas Anagnostakis
   5  *
   6  * SQUID Web Proxy Cache          http://www.squid-cache.org/
   7  * ----------------------------------------------------------
   8  *
   9  *  Squid is the result of efforts by numerous individuals from
  10  *  the Internet community; see the CONTRIBUTORS file for full
  11  *  details.   Many organizations have provided support for Squid's
  12  *  development; see the SPONSORS file for full details.  Squid is
  13  *  Copyrighted (C) 2001 by the Regents of the University of
  14  *  California; see the COPYRIGHT file for full details.  Squid
  15  *  incorporates software developed and/or copyrighted by other
  16  *  sources; see the CREDITS file for full details.
  17  *
  18  *  This program is free software; you can redistribute it and/or modify
  19  *  it under the terms of the GNU General Public License as published by
  20  *  the Free Software Foundation; either version 2 of the License, or
  21  *  (at your option) any later version.
  22  *
  23  *  This program is distributed in the hope that it will be useful,
  24  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  25  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  26  *  GNU General Public License for more details.
  27  *
  28  *  You should have received a copy of the GNU General Public License
  29  *  along with this program; if not, write to the Free Software
  30  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
  31  *
  32  */
  33
  34 #include "squid.h"
  35 #include "MemObject.h"
  36 #include "Store.h"
  37 #include "StoreMeta.h"
  38 #include "StoreMetaMD5.h"
  39 #include "StoreMetaObjSize.h"
  40 #include "StoreMetaSTD.h"
  41 #include "StoreMetaSTDLFS.h"
  42 #include "StoreMetaURL.h"
  43 #include "StoreMetaVary.h"
  44
  45 bool
  46 StoreMeta::validType(char type)
  47 {
  48     /* VOID is reserved, and new types have to be added as classes */
  49     if (type <= STORE_META_VOID || type >= STORE_META_END + 10) {
  50         debugs(20, DBG_CRITICAL, "storeSwapMetaUnpack: bad type (" << type << ")!");
  51         return false;
  52     }
  53
  54     /* Not yet implemented */
  55     if (type >= STORE_META_END ||
  56             type == STORE_META_STOREURL ||
  57             type == STORE_META_VARY_ID) {
  58         debugs(20, 3, "storeSwapMetaUnpack: Not yet implemented (" << type << ") in disk metadata");
  59         return false;
  60     }
  61
  62     /* Unused in any current squid code */
  63     if (type == STORE_META_KEY_URL ||
  64             type == STORE_META_KEY_SHA ||
  65             type == STORE_META_HITMETERING ||
  66             type == STORE_META_VALID) {
  67         debugs(20, DBG_CRITICAL, "Obsolete and unused type (" << type << ") in disk metadata");
  68         return false;
  69     }
  70
  71     return true;
  72 }
  73
  74 class IntRange
  75 {
  76
  77 public:
  78     IntRange (int minimum, int maximum) : _min (minimum), _max (maximum) {
  79         if (_min > _max) {
  80             int temp = _min;
  81             _min = _max;
  82             _max = temp;
  83         }
  84     }
  85
  86     bool includes (int anInt) const {
  87         if (anInt < _min || anInt > _max)
  88             return false;
  89
  90         return true;
  91     }
  92
  93 private:
  94     int _min;
  95     int _max;
  96 };
  97
  98 const int StoreMeta::MinimumTLVLength = 0;
  99 const int StoreMeta::MaximumTLVLength = 1 << 16;
 100
 101 bool
 102 StoreMeta::validLength(int aLength) const
 103 {
 104     if (!IntRange (MinimumTLVLength, MaximumTLVLength).includes(aLength)) {
 105         debugs(20, DBG_CRITICAL, "storeSwapMetaUnpack: insane length (" << aLength << ")!");
 106         return false;
 107     }
 108
 109     return true;
 110 }
 111
 112 StoreMeta *
 113 StoreMeta::Factory (char type, size_t len, void const *value)
 114 {
 115     if (!validType(type))
 116         return NULL;
 117
 118     StoreMeta *result;
 119
 120     switch (type) {
 121
 122     case STORE_META_KEY:
 123         result = new StoreMetaMD5;
 124         break;
 125
 126     case STORE_META_URL:
 127         result = new StoreMetaURL;
 128         break;
 129
 130     case STORE_META_STD:
 131         result = new StoreMetaSTD;
 132         break;
 133
 134     case STORE_META_STD_LFS:
 135         result = new StoreMetaSTDLFS;
 136         break;
 137
 138     case STORE_META_OBJSIZE:
 139         result = new StoreMetaObjSize;
 140         break;
 141
 142     case STORE_META_VARY_HEADERS:
 143         result = new StoreMetaVary;
 144         break;
 145
 146     default:
 147         debugs(20, DBG_CRITICAL, "Attempt to create unknown concrete StoreMeta");
 148         return NULL;
 149     }
 150
 151     if (!result->validLength(len)) {
 152         delete result;
 153         return NULL;
 154     }
 155
 156     result->length = len;
 157     result->value = xmalloc(len);
 158     memcpy(result->value, value, len);
 159     return result;
 160 }
 161
 162 void
 163 StoreMeta::FreeList(StoreMeta **head)
 164 {
 165     StoreMeta *node;
 166
 167     while ((node = *head) != NULL) {
 168         *head = node->next;
 169         xfree(node->value);
 170         delete node;
 171     }
 172 }
 173
 174 StoreMeta **
 175 StoreMeta::Add(StoreMeta **tail, StoreMeta *aNode)
 176 {
 177     assert (*tail == NULL);
 178     *tail = aNode;
 179     return &aNode->next;                /* return new tail pointer */
 180 }
 181
 182 bool
 183 StoreMeta::checkConsistency(StoreEntry *e) const
 184 {
 185     switch (getType()) {
 186
 187     case STORE_META_KEY:
 188
 189     case STORE_META_URL:
 190
 191     case STORE_META_VARY_HEADERS:
 192         assert(0);
 193         break;
 194
 195     case STORE_META_STD:
 196         break;
 197
 198     case STORE_META_STD_LFS:
 199         break;
 200
 201     case STORE_META_OBJSIZE:
 202         break;
 203
 204     default:
 205         debugs(20, DBG_IMPORTANT, "WARNING: got unused STORE_META type " << getType());
 206         break;
 207     }
 208
 209     return true;
 210 }