sign mismatch fixed

[libucw.git] / lib / url.c

diff --git a/lib/url.c b/lib/url.c
index 3920aa59f1efd95263b6fff083573d17e2f27b42..a6dcf7aa06fe4f1335edbe921359136b17bed1dc 100644 (file)
--- a/lib/url.c
+++ b/lib/url.c
@@ -18,7 +18,7 @@
 
 static uns url_ignore_spaces;
 static uns url_ignore_underflow;
-static byte *url_component_separators = "/&?";
+static byte *url_component_separators = "";
 static uns url_min_repeat_count = 0x7fffffff;
 static uns url_max_repeat_length = 0;
 
@@ -500,7 +500,7 @@ url_error(uns err)
   return errmsg[err];
 }
 
-/* A "macro" for canonical split */
+/* Standard cookbook recipes */
 
 int
 url_canon_split(byte *u, byte *buf1, byte *buf2, struct url *url)
@@ -516,6 +516,19 @@ url_canon_split(byte *u, byte *buf1, byte *buf2, struct url *url)
   return url_canonicalize(url);
 }
 
+int
+url_auto_canonicalize(byte *src, byte *dst)
+{
+  byte buf1[MAX_URL_SIZE], buf2[MAX_URL_SIZE], buf3[MAX_URL_SIZE];
+  int err;
+  struct url ur;
+
+  (void)((err = url_canon_split(src, buf1, buf2, &ur)) ||
+   (err = url_pack(&ur, buf3)) ||
+   (err = url_enescape(buf3, dst)));
+  return err;
+}
+
 /* Testing */
 
 #ifdef TEST
@@ -580,8 +593,77 @@ int main(int argc, char **argv)
 
 #endif
 
+struct component {
+       byte *start;
+       int length;
+       u32 hash;
+};
+
+static inline u32
+hashf(byte *start, int length)
+{
+       u32 hf = length;
+       while (length-- > 0)
+               hf = (hf << 8 | hf >> 24) ^ *start++;
+       return hf;
+}
+
+static inline uns
+repeat_count(struct component *comp, uns count, uns len)
+{
+       struct component *orig_comp = comp;
+       uns found = 0;
+       while (1)
+       {
+               uns i;
+               comp += len;
+               count -= len;
+               found++;
+               if (count < len)
+                       return found;
+               for (i=0; i<len; i++)
+                       if (comp[i].hash != orig_comp[i].hash
+                       || comp[i].length != orig_comp[i].length
+                       || memcmp(comp[i].start, orig_comp[i].start, comp[i].length))
+                               return found;
+       }
+}
+
 int
 url_has_repeated_component(byte *url)
 {
+       struct component *comp;
+       uns comps, comp_len, rep_prefix;
+       byte *c;
+       uns i;
+
+       for (comps=0, c=url; c; comps++)
+       {
+               c = strpbrk(c, url_component_separators);
+               if (c)
+                       c++;
+       }
+       if (comps < url_min_repeat_count)
+               return 0;
+       comp = alloca(comps * sizeof(struct component));
+       for (i=0, c=url; c; i++)
+       {
+               comp[i].start = c;
+               c = strpbrk(c, url_component_separators);
+               if (c)
+               {
+                       comp[i].length = c - comp[i].start;
+                       c++;
+               }
+               else
+                       comp[i].length = strlen(comp[i].start);
+       }
+       ASSERT(i == comps);
+       for (i=0; i<comps; i++)
+               comp[i].hash = hashf(comp[i].start, comp[i].length);
+       for (comp_len = 1; comp_len <= url_max_repeat_length && comp_len <= comps; comp_len++)
+               for (rep_prefix = 0; rep_prefix <= comps - comp_len; rep_prefix++)
+                       if (repeat_count(comp + rep_prefix, comps - rep_prefix, comp_len) >= url_min_repeat_count)
+                               return comp_len;
        return 0;
 }