kamailio.cfg: removed sample db_mode parameter for domain module
[sip-router] / hashes.h
index b4b258d..9932905 100644 (file)
--- a/hashes.h
+++ b/hashes.h
                        (v)=(*(p)<<24)+((p)[1]<<16)+((p)[2]<<8)+(p)[3]; \
                        (h)+=(v)^((v)>>3); \
                } \
-               (v)=0; \
-               for (;(p)<(end); (p)++){ (v)<<=8; (v)+=*(p);} \
+               switch((end)-(p)){\
+                       case 3: \
+                               (v)=(*(p)<<16)+((p)[1]<<8)+(p)[2]; break; \
+                       case 2: \
+                               (v)=(*(p)<<8)+p[1]; break; \
+                       case 1: \
+                               (v)=*p; break; \
+                       default: \
+                               (v)=0; break; \
+               } \
                (h)+=(v)^((v)>>3); \
        }while(0)
 
@@ -75,7 +83,7 @@
 /* "raw" 2 strings hash
  * returns an unsigned int (which you can use modulo table_size as hash value)
  */
-inline static unsigned int get_hash2_raw(str* key1, str* key2)
+inline static unsigned int get_hash2_raw(const str* key1, const str* key2)
 {
        char* p;
        register unsigned v;
@@ -93,9 +101,9 @@ inline static unsigned int get_hash2_raw(str* key1, str* key2)
 /* "raw" 1 string hash
  * returns an unsigned int (which you can use modulo table_size as hash value)
  */
-inline static unsigned int get_hash1_raw(char* s, int len)
+inline static unsigned int get_hash1_raw(const char* s, int len)
 {
-       char* p;
+       const char* p;
        register unsigned v;
        register unsigned h;
        
@@ -140,9 +148,9 @@ inline static unsigned int get_hash1_raw(char* s, int len)
 
 /* a little slower than get_hash1_raw() , but better distribution for 
  * numbers and about the same for strings */
-inline static unsigned int get_hash1_raw2(char* s, int len)
+inline static unsigned int get_hash1_raw2(const char* s, int len)
 {
-       char* p;
+       const char* p;
        register unsigned v;
        register unsigned h;
        
@@ -157,7 +165,7 @@ inline static unsigned int get_hash1_raw2(char* s, int len)
 /* "raw" 2 strings hash optimized for numeric strings (see above)
  * returns an unsigned int (which you can use modulo table_size as hash value)
  */
-inline static unsigned int get_hash2_raw2(str* key1, str* key2)
+inline static unsigned int get_hash2_raw2(const str* key1, const str* key2)
 {
        char* p;
        register unsigned v;
@@ -176,7 +184,7 @@ inline static unsigned int get_hash2_raw2(str* key1, str* key2)
  * insensitive)
  * returns an unsigned int (which you can use modulo table_size as hash value)
  */
-inline static unsigned int get_hash2_case_raw(str* key1, str* key2)
+inline static unsigned int get_hash2_case_raw(const str* key1, const str* key2)
 {
        char* p;
        register unsigned v;
@@ -194,9 +202,9 @@ inline static unsigned int get_hash2_case_raw(str* key1, str* key2)
 /* "raw" 1 string case insensitive hash
  * returns an unsigned int (which you can use modulo table_size as hash value)
  */
-inline static unsigned int get_hash1_case_raw(char* s, int len)
+inline static unsigned int get_hash1_case_raw(const char* s, int len)
 {
-       char* p;
+       const char* p;
        register unsigned v;
        register unsigned h;
        
@@ -210,9 +218,9 @@ inline static unsigned int get_hash1_case_raw(char* s, int len)
 /* same as get_hash1_raw2, but case insensitive and slower
  * returns an unsigned int (which you can use modulo table_size as hash value)
  */
-inline static unsigned int get_hash1_case_raw2(char* s, int len)
+inline static unsigned int get_hash1_case_raw2(const char* s, int len)
 {
-       char* p;
+       const char* p;
        register unsigned v;
        register unsigned h;
        
@@ -228,7 +236,8 @@ inline static unsigned int get_hash1_case_raw2(char* s, int len)
  * same as get_hash2_raw2 but case insensitive and slower
  * returns an unsigned int (which you can use modulo table_size as hash value)
  */
-inline static unsigned int get_hash2_case_raw2(str* key1, str* key2)
+inline static unsigned int get_hash2_case_raw2(const str* key1,
+                                                                                          const str* key2)
 {
        char* p;
        register unsigned v;
@@ -242,5 +251,94 @@ inline static unsigned int get_hash2_case_raw2(str* key1, str* key2)
 }
 
 
+/*
+ * generic hashing - from the intial origins of ser
+ */
+#define ch_h_inc h+=v^(v>>3)
+#define ch_icase(_c) (((_c)>='A'&&(_c)<='Z')?((_c)|0x20):(_c))
+
+/*
+ * case sensitive hashing
+ * - s1 - str to hash
+ * - s2 - optional - continue hashing over s2
+ * - size - optional - size of hash table (must be power of 1); if set (!=0),
+ *   instead of hash id, returned value is slot index
+ * return computed hash id or hash table slot index
+ */
+static inline unsigned int core_hash(const str *s1, const str *s2,
+               const unsigned int size)
+{
+       char *p, *end;
+       register unsigned v;
+       register unsigned h;
+
+       h=0;
+
+       end=s1->s+s1->len;
+       for ( p=s1->s ; p<=(end-4) ; p+=4 ){
+               v=(*p<<24)+(p[1]<<16)+(p[2]<<8)+p[3];
+               ch_h_inc;
+       }
+       v=0;
+       for (; p<end ; p++){ v<<=8; v+=*p;}
+       ch_h_inc;
+
+       if (s2) {
+               end=s2->s+s2->len;
+               for (p=s2->s; p<=(end-4); p+=4){
+                       v=(*p<<24)+(p[1]<<16)+(p[2]<<8)+p[3];
+                       ch_h_inc;
+               }
+               v=0;
+               for (; p<end ; p++){ v<<=8; v+=*p;}
+               ch_h_inc;
+       }
+       h=((h)+(h>>11))+((h>>13)+(h>>23));
+       return size?((h)&(size-1)):h;
+}
+
+
+/*
+ * case insensitive hashing
+ * - s1 - str to hash
+ * - s2 - optional - continue hashing over s2
+ * - size - optional - size of hash table (must be power of 1); if set (!=0),
+ *   instead of hash id, returned value is slot index
+ * return computed hash id or hash table slot index
+ */
+static inline unsigned int core_case_hash( str *s1, str *s2,
+               unsigned int size)
+{
+       char *p, *end;
+       register unsigned v;
+       register unsigned h;
+
+       h=0;
+
+       end=s1->s+s1->len;
+       for ( p=s1->s ; p<=(end-4) ; p+=4 ){
+               v=(ch_icase(*p)<<24)+(ch_icase(p[1])<<16)+(ch_icase(p[2])<<8)
+                       + ch_icase(p[3]);
+               ch_h_inc;
+       }
+       v=0;
+       for (; p<end ; p++){ v<<=8; v+=ch_icase(*p);}
+       ch_h_inc;
+
+       if (s2) {
+               end=s2->s+s2->len;
+               for (p=s2->s; p<=(end-4); p+=4){
+                       v=(ch_icase(*p)<<24)+(ch_icase(p[1])<<16)+(ch_icase(p[2])<<8)
+                               + ch_icase(p[3]);
+                       ch_h_inc;
+               }
+               v=0;
+               for (; p<end ; p++){ v<<=8; v+=ch_icase(*p);}
+               ch_h_inc;
+       }
+       h=((h)+(h>>11))+((h>>13)+(h>>23));
+       return size?((h)&(size-1)):h;
+}
+
 
 #endif