replace memcmp with MagicCmp that supports '.' for single character of anythi...

net/base/mime_sniffer.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Detecting mime types is a tricky business because we need to balance
 // compatibility concerns with security issues.  Here is a survey of how other
 // browsers behave and then a description of how we intend to behave.
 //
 // HTML payload, no Content-Type header:
 // * IE 7: Render as HTML
 // * Firefox 2: Render as HTML
@@ skipping 127 matching lines @@
   MAGIC_NUMBER("text/plain", ">From")
   // Chrome specific
   MAGIC_NUMBER("application/x-gzip", "\x1F\x8B\x08")
   MAGIC_NUMBER("audio/x-pn-realaudio", "\x2E\x52\x4D\x46")
   MAGIC_NUMBER("video/x-ms-asf",
       "\x30\x26\xB2\x75\x8E\x66\xCF\x11\xA6\xD9\x00\xAA\x00\x62\xCE\x6C")
   MAGIC_NUMBER("image/tiff", "I I")
   MAGIC_NUMBER("image/tiff", "II*")
   MAGIC_NUMBER("image/tiff", "MM\x00*")
   MAGIC_NUMBER("audio/mpeg", "ID3")
+  MAGIC_NUMBER("image/webp", "RIFF....WEBPVP8 ")
+  MAGIC_NUMBER("video/webm", "\x1A\x45\xDF\xA3")
   // TODO(abarth): we don't handle partial byte matches yet
   // MAGIC_NUMBER("video/mpeg", "\x00\x00\x01\xB")
   // MAGIC_NUMBER("audio/mpeg", "\xFF\xE")
   // MAGIC_NUMBER("audio/mpeg", "\xFF\xF")
   MAGIC_NUMBER("application/zip", "PK\x03\x04")
   MAGIC_NUMBER("application/x-rar-compressed", "Rar!\x1A\x07\x00")
   MAGIC_NUMBER("application/x-msmetafile", "\xD7\xCD\xC6\x9A")
   MAGIC_NUMBER("application/octet-stream", "MZ")  // EXE
   // Sniffing for Flash:
   //
@@ skipping 49 matching lines @@
 };
 
 static scoped_refptr<base::Histogram> UMASnifferHistogramGet(const char* name,
                                                              int array_size) {
   scoped_refptr<base::Histogram> counter =
       base::LinearHistogram::FactoryGet(name, 1, array_size - 1, array_size,
       base::Histogram::kUmaTargetedHistogramFlag);
   return counter;
 }
 
+// Compare content header to a magic number where magic_entry can contain '.'
+// for single character of anything, allowing some bytes to be skipped.
+static bool MagicCmp(const char* magic_entry, const char* content, size_t len) {
+  bool same = true;
+  while (len && same) {
+    if (!*content && !*magic_entry)

[abarth-chromium, 2011/01/11 19:51:29]

I don't think this is correct.  We want to match null.

[fbarchard1, 2011/01/11 19:57:39]

I think its correct.  If both strings have been the same up to this point, even
if len is >=1, and both terminate with null at the same time, then the compare
returns true... the strings are the same.

[Avi (use Gerrit), 2011/01/11 20:00:02]

Given this argument between you two, I think it's clear that MagicCmp needs a
unit test.

+      break;
+    same = (*magic_entry == *content) || (*magic_entry == '.' && *content);
+    if (!*content || !*magic_entry)
+      break;
+    ++magic_entry;
+    ++content;
+    --len;
+  }
+  return same;
+}
+
 static bool MatchMagicNumber(const char* content, size_t size,
                              const MagicNumber* magic_entry,
                              std::string* result) {
   const size_t len = magic_entry->magic_len;
 
   // Keep kBytesRequiredForMagic honest.
   DCHECK_LE(len, kBytesRequiredForMagic);
 
   // To compare with magic strings, we need to compute strlen(content), but
   // content might not actually have a null terminator.  In that case, we
   // pretend the length is content_size.
   const char* end =
       static_cast<const char*>(memchr(content, '\0', size));
   const size_t content_strlen =
       (end != NULL) ? static_cast<size_t>(end - content) : size;
 
   bool match = false;
   if (magic_entry->is_string) {
     if (content_strlen >= len) {
       // String comparisons are case-insensitive
       match = (base::strncasecmp(magic_entry->magic, content, len) == 0);
     }
   } else {
     if (size >= len)
-      match = (memcmp(magic_entry->magic, content, len) == 0);
+      match = MagicCmp(magic_entry->magic, content, len);
   }
 
   if (match) {
     result->assign(magic_entry->mime_type);
     return true;
   }
   return false;
 }
 
 static bool CheckForMagicNumbers(const char* content, size_t size,
                                  const MagicNumber* magic, size_t magic_len,
-                                 base::Histogram* counter, std::string* result) {
+                                 base::Histogram* counter,
+                                 std::string* result) {
   for (size_t i = 0; i < magic_len; ++i) {
     if (MatchMagicNumber(content, size, &(magic[i]), result)) {
       if (counter) counter->Add(static_cast<int>(i));
       return true;
     }
   }
   return false;
 }
 
 // Truncates |size| to |max_size| and returns true if |size| is at least
@@ skipping 390 matching lines @@
   // Now we look in our large table of magic numbers to see if we can find
   // anything that matches the content.
   if (SniffForMagicNumbers(content, content_size,
                            &have_enough_content, result))
     return true;  // We've matched a magic number.  No more content needed.
 
   return have_enough_content;
 }
 
 }  // namespace net