src/store_key_md5.cc

   1
   2 /*
   3  * $Id: store_key_md5.cc,v 1.27 2002/10/13 20:35:05 robertc Exp $
   4  *
   5  * DEBUG: section 20    Storage Manager MD5 Cache Keys
   6  * AUTHOR: Duane Wessels
   7  *
   8  * SQUID Web Proxy Cache          http://www.squid-cache.org/
   9  * ----------------------------------------------------------
  10  *
  11  *  Squid is the result of efforts by numerous individuals from
  12  *  the Internet community; see the CONTRIBUTORS file for full
  13  *  details.   Many organizations have provided support for Squid's
  14  *  development; see the SPONSORS file for full details.  Squid is
  15  *  Copyrighted (C) 2001 by the Regents of the University of
  16  *  California; see the COPYRIGHT file for full details.  Squid
  17  *  incorporates software developed and/or copyrighted by other
  18  *  sources; see the CREDITS file for full details.
  19  *
  20  *  This program is free software; you can redistribute it and/or modify
  21  *  it under the terms of the GNU General Public License as published by
  22  *  the Free Software Foundation; either version 2 of the License, or
  23  *  (at your option) any later version.
  24  *
  25  *  This program is distributed in the hope that it will be useful,
  26  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  27  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  28  *  GNU General Public License for more details.
  29  *
  30  *  You should have received a copy of the GNU General Public License
  31  *  along with this program; if not, write to the Free Software
  32  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
  33  *
  34  */
  35
  36 #include "squid.h"
  37
  38 static cache_key null_key[MD5_DIGEST_CHARS];
  39
  40 const char *
  41 storeKeyText(const unsigned char *key)
  42 {
  43     static MemBuf mb = MemBufNULL;
  44     int i;
  45     memBufReset(&mb);
  46     for (i = 0; i < MD5_DIGEST_CHARS; i++)
  47         memBufPrintf(&mb, "%02X", *(key + i));
  48     return mb.buf;
  49 }
  50
  51 const cache_key *
  52 storeKeyScan(const char *buf)
  53 {
  54     static unsigned char digest[MD5_DIGEST_CHARS];
  55     int i;
  56     int j = 0;
  57     char t[3];
  58     for (i = 0; i < MD5_DIGEST_CHARS; i++) {
  59         t[0] = *(buf + (j++));
  60         t[1] = *(buf + (j++));
  61         t[2] = '\0';
  62         *(digest + i) = (unsigned char) strtol(t, NULL, 16);
  63     }
  64     return digest;
  65 }
  66
  67 int
  68 storeKeyHashCmp(const void *a, const void *b)
  69 {
  70     const unsigned char *A = (const unsigned char *)a;
  71     const unsigned char *B = (const unsigned char *)b;
  72     int i;
  73     for (i = 0; i < MD5_DIGEST_CHARS; i++) {
  74         if (A[i] < B[i])
  75             return -1;
  76         if (A[i] > B[i])
  77             return 1;
  78     }
  79     return 0;
  80 }
  81
  82 unsigned int
  83 storeKeyHashHash(const void *key, unsigned int n)
  84 {
  85     /* note, n must be a power of 2! */
  86     const unsigned char *digest = (const unsigned char *)key;
  87     unsigned int i = digest[0]
  88     | digest[1] << 8
  89     | digest[2] << 16
  90     | digest[3] << 24;
  91     return (i & (--n));
  92 }
  93
  94 const cache_key *
  95 storeKeyPrivate(const char *url, method_t method, int id)
  96 {
  97     static cache_key digest[MD5_DIGEST_CHARS];
  98     MD5_CTX M;
  99     assert(id > 0);
 100     debug(20, 3) ("storeKeyPrivate: %s %s\n",
 101         RequestMethodStr[method], url);
 102     MD5Init(&M);
 103     MD5Update(&M, (unsigned char *) &id, sizeof(id));
 104     MD5Update(&M, (unsigned char *) &method, sizeof(method));
 105     MD5Update(&M, (unsigned char *) url, strlen(url));
 106     MD5Final(digest, &M);
 107     return digest;
 108 }
 109
 110 const cache_key *
 111 storeKeyPublic(const char *url, const method_t method)
 112 {
 113     static cache_key digest[MD5_DIGEST_CHARS];
 114     unsigned char m = (unsigned char) method;
 115     MD5_CTX M;
 116     MD5Init(&M);
 117     MD5Update(&M, &m, sizeof(m));
 118     MD5Update(&M, (unsigned char *) url, strlen(url));
 119     MD5Final(digest, &M);
 120     return digest;
 121 }
 122
 123 const cache_key *
 124 storeKeyPublicByRequest(request_t * request)
 125 {
 126     return storeKeyPublicByRequestMethod(request, request->method);
 127 }
 128
 129 const cache_key *
 130 storeKeyPublicByRequestMethod(request_t * request, const method_t method)
 131 {
 132     static cache_key digest[MD5_DIGEST_CHARS];
 133     unsigned char m = (unsigned char) method;
 134     const char *url = urlCanonical(request);
 135     MD5_CTX M;
 136     MD5Init(&M);
 137     MD5Update(&M, &m, sizeof(m));
 138     MD5Update(&M, (unsigned char *) url, strlen(url));
 139     if (request->vary_headers)
 140         MD5Update(&M, (unsigned char *) request->vary_headers, strlen(request->vary_headers));
 141     MD5Final(digest, &M);
 142     return digest;
 143 }
 144
 145 cache_key *
 146 storeKeyDup(const cache_key * key)
 147 {
 148     cache_key *dup = (cache_key *)memAllocate(MEM_MD5_DIGEST);
 149     xmemcpy(dup, key, MD5_DIGEST_CHARS);
 150     return dup;
 151 }
 152
 153 cache_key *
 154 storeKeyCopy(cache_key * dst, const cache_key * src)
 155 {
 156     xmemcpy(dst, src, MD5_DIGEST_CHARS);
 157     return dst;
 158 }
 159
 160 void
 161 storeKeyFree(const cache_key * key)
 162 {
 163     memFree((void *) key, MEM_MD5_DIGEST);
 164 }
 165
 166 int
 167 storeKeyHashBuckets(int nbuckets)
 168 {
 169     int n = 0x2000;
 170     while (n < nbuckets)
 171         n <<= 1;
 172     return n;
 173 }
 174
 175 int
 176 storeKeyNull(const cache_key * key)
 177 {
 178     if (memcmp(key, null_key, MD5_DIGEST_CHARS) == 0)
 179         return 1;
 180     else
 181         return 0;
 182 }
 183
 184 void
 185 storeKeyInit(void)
 186 {
 187     memset(null_key, '\0', MD5_DIGEST_CHARS);
 188 }