2011-09-04 10:28:09 +04:00
|
|
|
/*
|
|
|
|
|
* Copyright 2011 John-Mark Bell <jmb@netsurf-browser.org>
|
|
|
|
|
*
|
|
|
|
|
* This file is part of NetSurf, http://www.netsurf-browser.org/
|
|
|
|
|
*
|
|
|
|
|
* NetSurf is free software; you can redistribute it and/or modify
|
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
|
* the Free Software Foundation; version 2 of the License.
|
|
|
|
|
*
|
|
|
|
|
* NetSurf is distributed in the hope that it will be useful,
|
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
|
*
|
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
|
*/
|
|
|
|
|
|
2017-03-19 18:00:21 +03:00
|
|
|
/**
|
|
|
|
|
* \file
|
|
|
|
|
* MIME type sniffer implementation
|
2011-09-27 04:33:37 +04:00
|
|
|
*
|
2011-12-23 04:21:47 +04:00
|
|
|
* Spec version: 2011-11-27
|
2011-09-04 10:28:09 +04:00
|
|
|
*/
|
|
|
|
|
|
2014-12-28 01:48:37 +03:00
|
|
|
#include <string.h>
|
|
|
|
|
#include <strings.h>
|
2011-09-04 10:28:09 +04:00
|
|
|
|
2017-03-19 18:00:21 +03:00
|
|
|
#include "utils/http.h"
|
|
|
|
|
#include "utils/utils.h"
|
|
|
|
|
#include "utils/corestrings.h"
|
|
|
|
|
|
2011-09-04 10:28:09 +04:00
|
|
|
#include "content/content_factory.h"
|
|
|
|
|
#include "content/mimesniff.h"
|
|
|
|
|
|
2011-09-27 04:33:37 +04:00
|
|
|
struct map_s {
|
|
|
|
|
const uint8_t *sig;
|
|
|
|
|
size_t len;
|
|
|
|
|
bool safe;
|
|
|
|
|
lwc_string **type;
|
|
|
|
|
};
|
|
|
|
|
|
2011-09-04 10:28:09 +04:00
|
|
|
static bool mimesniff__has_binary_octets(const uint8_t *data, size_t len)
|
|
|
|
|
{
|
|
|
|
|
const uint8_t *end = data + len;
|
|
|
|
|
|
|
|
|
|
while (data != end) {
|
|
|
|
|
const uint8_t c = *data;
|
|
|
|
|
|
|
|
|
|
/* Binary iff in C0 and not ESC, CR, FF, LF, HT */
|
2017-03-19 18:00:21 +03:00
|
|
|
if (c <= 0x1f && c != 0x1b && c != '\r' && c != '\f' &&
|
2011-09-04 10:28:09 +04:00
|
|
|
c != '\n' && c != '\t')
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
data++;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return data != end;
|
|
|
|
|
}
|
|
|
|
|
|
2011-09-27 04:33:37 +04:00
|
|
|
static nserror mimesniff__match_mp4(const uint8_t *data, size_t len,
|
|
|
|
|
lwc_string **effective_type)
|
|
|
|
|
{
|
2014-02-04 17:24:25 +04:00
|
|
|
uint32_t box_size, i;
|
2011-09-27 04:33:37 +04:00
|
|
|
|
|
|
|
|
/* ISO/IEC 14496-12:2008 $4.3 says (effectively):
|
|
|
|
|
*
|
|
|
|
|
* struct ftyp_box {
|
|
|
|
|
* uint32_t size; (in octets, including size+type words)
|
|
|
|
|
* uint32_t type; (== 'ftyp')
|
|
|
|
|
* uint32_t major_brand;
|
|
|
|
|
* uint32_t minor_version;
|
|
|
|
|
* uint32_t compatible_brands[];
|
|
|
|
|
* }
|
|
|
|
|
*
|
2017-03-19 18:00:21 +03:00
|
|
|
* Note 1: A size of 0 implies that the length of the box is designated
|
|
|
|
|
* by the remaining input data (and thus may only occur in the last
|
|
|
|
|
* box in the input). We'll reject this below, as it's pointless
|
2011-09-27 04:33:37 +04:00
|
|
|
* sniffing input that contains no boxes other than 'ftyp'.
|
|
|
|
|
*
|
2017-03-19 18:00:21 +03:00
|
|
|
* Note 2: A size of 1 implies an additional uint64_t field after
|
|
|
|
|
* the type which contains the extended box size. We'll reject this,
|
|
|
|
|
* too, as it implies a minimum of (2^32 - 24) / 4 compatible brands,
|
2011-09-27 04:33:37 +04:00
|
|
|
* which is decidely unlikely.
|
|
|
|
|
*/
|
|
|
|
|
|
2017-03-19 18:00:21 +03:00
|
|
|
/* 12 reflects the minimum number of octets needed to sniff useful
|
|
|
|
|
* information out of an 'ftyp' box (i.e. the size, type,
|
2011-12-23 04:21:47 +04:00
|
|
|
* and major_brand words). */
|
2011-09-27 04:33:37 +04:00
|
|
|
if (len < 12)
|
|
|
|
|
return NSERROR_NOT_FOUND;
|
|
|
|
|
|
|
|
|
|
/* Box size is big-endian */
|
|
|
|
|
box_size = (data[0] << 24) | (data[1] << 16) | (data[2] << 8) | data[3];
|
|
|
|
|
|
|
|
|
|
/* Require that we can read the entire box, and reject bad box sizes */
|
|
|
|
|
if (len < box_size || box_size % 4 != 0)
|
|
|
|
|
return NSERROR_NOT_FOUND;
|
|
|
|
|
|
|
|
|
|
/* Ensure this is an 'ftyp' box */
|
2017-03-19 18:00:21 +03:00
|
|
|
if (data[4] != 'f' || data[5] != 't' ||
|
2011-12-23 04:21:47 +04:00
|
|
|
data[6] != 'y' || data[7] != 'p')
|
2011-09-27 04:33:37 +04:00
|
|
|
return NSERROR_NOT_FOUND;
|
|
|
|
|
|
|
|
|
|
/* Check if major brand begins with 'mp4' */
|
2011-12-23 04:21:47 +04:00
|
|
|
if (data[8] == 'm' && data[9] == 'p' && data[10] == '4') {
|
2017-03-19 18:00:21 +03:00
|
|
|
*effective_type = lwc_string_ref(corestring_lwc_video_mp4);
|
2011-09-27 04:33:37 +04:00
|
|
|
return NSERROR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Search each compatible brand in the box for "mp4" */
|
|
|
|
|
for (i = 16; i <= box_size - 4; i += 4) {
|
2017-03-19 18:00:21 +03:00
|
|
|
if (data[i] == 'm' &&
|
|
|
|
|
data[i+1] == 'p' &&
|
2014-02-04 17:24:25 +04:00
|
|
|
data[i+2] == '4') {
|
2017-03-19 18:00:21 +03:00
|
|
|
*effective_type = lwc_string_ref(corestring_lwc_video_mp4);
|
2011-09-27 04:33:37 +04:00
|
|
|
return NSERROR_OK;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return NSERROR_NOT_FOUND;
|
|
|
|
|
}
|
2011-09-04 10:28:09 +04:00
|
|
|
|
|
|
|
|
static nserror mimesniff__match_unknown_ws(const uint8_t *data, size_t len,
|
|
|
|
|
lwc_string **effective_type)
|
|
|
|
|
{
|
|
|
|
|
#define SIG(t, s, x) { (const uint8_t *) s, SLEN(s), x, t }
|
|
|
|
|
static const struct map_s ws_exact_match_types[] = {
|
2017-03-19 18:00:21 +03:00
|
|
|
SIG(&corestring_lwc_text_xml, "<?xml", false),
|
2011-09-04 10:28:09 +04:00
|
|
|
{ NULL, 0, false, NULL }
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static const struct map_s ws_inexact_match_types[] = {
|
2017-03-19 18:00:21 +03:00
|
|
|
SIG(&corestring_lwc_text_html, "<!DOCTYPE HTML", false),
|
|
|
|
|
SIG(&corestring_lwc_text_html, "<HTML", false),
|
|
|
|
|
SIG(&corestring_lwc_text_html, "<HEAD", false),
|
|
|
|
|
SIG(&corestring_lwc_text_html, "<SCRIPT", false),
|
|
|
|
|
SIG(&corestring_lwc_text_html, "<IFRAME", false),
|
|
|
|
|
SIG(&corestring_lwc_text_html, "<H1", false),
|
|
|
|
|
SIG(&corestring_lwc_text_html, "<DIV", false),
|
|
|
|
|
SIG(&corestring_lwc_text_html, "<FONT", false),
|
|
|
|
|
SIG(&corestring_lwc_text_html, "<TABLE", false),
|
|
|
|
|
SIG(&corestring_lwc_text_html, "<A", false),
|
|
|
|
|
SIG(&corestring_lwc_text_html, "<STYLE", false),
|
|
|
|
|
SIG(&corestring_lwc_text_html, "<TITLE", false),
|
|
|
|
|
SIG(&corestring_lwc_text_html, "<B", false),
|
|
|
|
|
SIG(&corestring_lwc_text_html, "<BODY", false),
|
|
|
|
|
SIG(&corestring_lwc_text_html, "<BR", false),
|
|
|
|
|
SIG(&corestring_lwc_text_html, "<P", false),
|
|
|
|
|
SIG(&corestring_lwc_text_html, "<!--", false),
|
2011-09-04 10:28:09 +04:00
|
|
|
{ NULL, 0, false, NULL }
|
|
|
|
|
};
|
|
|
|
|
#undef SIG
|
|
|
|
|
const uint8_t *end = data + len;
|
|
|
|
|
const struct map_s *it;
|
|
|
|
|
|
|
|
|
|
/* Skip leading whitespace */
|
|
|
|
|
while (data != end) {
|
|
|
|
|
const uint8_t c = *data;
|
|
|
|
|
|
2017-03-19 18:00:21 +03:00
|
|
|
if (c != '\t' && c != '\n' && c != '\f' &&
|
2011-09-04 10:28:09 +04:00
|
|
|
c != '\r' && c != ' ')
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
data++;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (data == end)
|
|
|
|
|
return NSERROR_NOT_FOUND;
|
|
|
|
|
|
2011-09-09 01:32:07 +04:00
|
|
|
len = end - data;
|
|
|
|
|
|
2011-09-04 10:28:09 +04:00
|
|
|
for (it = ws_exact_match_types; it->sig != NULL; it++) {
|
|
|
|
|
if (it->len <= len && memcmp(data, it->sig, it->len) == 0) {
|
|
|
|
|
*effective_type = lwc_string_ref(*it->type);
|
|
|
|
|
return NSERROR_OK;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (it = ws_inexact_match_types; it->sig != NULL; it++) {
|
|
|
|
|
/* +1 for trailing space or > */
|
|
|
|
|
if (len < it->len + 1)
|
|
|
|
|
continue;
|
|
|
|
|
|
2017-03-19 18:00:21 +03:00
|
|
|
if (strncasecmp((const char *) data,
|
|
|
|
|
(const char *) it->sig, it->len) == 0 &&
|
|
|
|
|
(data[it->len] == ' ' ||
|
2011-09-04 10:28:09 +04:00
|
|
|
data[it->len] == '>')) {
|
|
|
|
|
*effective_type = lwc_string_ref(*it->type);
|
|
|
|
|
return NSERROR_OK;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return NSERROR_NOT_FOUND;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static nserror mimesniff__match_unknown_bom(const uint8_t *data, size_t len,
|
|
|
|
|
lwc_string **effective_type)
|
|
|
|
|
{
|
|
|
|
|
#define SIG(t, s, x) { (const uint8_t *) s, SLEN(s), x, t }
|
|
|
|
|
static const struct map_s bom_match_types[] = {
|
2017-03-19 18:00:21 +03:00
|
|
|
SIG(&corestring_lwc_text_plain, "\xfe\xff", false),
|
|
|
|
|
SIG(&corestring_lwc_text_plain, "\xff\xfe", false),
|
|
|
|
|
SIG(&corestring_lwc_text_plain, "\xef\xbb\xbf", false),
|
2011-09-04 10:28:09 +04:00
|
|
|
{ NULL, 0, false, NULL }
|
|
|
|
|
};
|
|
|
|
|
#undef SIG
|
|
|
|
|
const struct map_s *it;
|
|
|
|
|
|
|
|
|
|
for (it = bom_match_types; it->sig != NULL; it++) {
|
|
|
|
|
if (it->len <= len && memcmp(data, it->sig, it->len) == 0) {
|
|
|
|
|
*effective_type = lwc_string_ref(*it->type);
|
|
|
|
|
return NSERROR_OK;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return NSERROR_NOT_FOUND;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static nserror mimesniff__match_unknown_riff(const uint8_t *data, size_t len,
|
|
|
|
|
lwc_string **effective_type)
|
|
|
|
|
{
|
|
|
|
|
#define SIG(t, s, x) { (const uint8_t *) s, SLEN(s), x, t }
|
|
|
|
|
static const struct map_s riff_match_types[] = {
|
2017-03-19 18:00:21 +03:00
|
|
|
SIG(&corestring_lwc_image_webp, "WEBPVP", true),
|
|
|
|
|
SIG(&corestring_lwc_audio_wave, "WAVE", true),
|
2011-09-04 10:28:09 +04:00
|
|
|
{ NULL, 0, false, NULL }
|
|
|
|
|
};
|
|
|
|
|
#undef SIG
|
|
|
|
|
const struct map_s *it;
|
|
|
|
|
|
|
|
|
|
for (it = riff_match_types; it->sig != NULL; it++) {
|
2017-03-19 18:00:21 +03:00
|
|
|
if (it->len + SLEN("RIFF????") <= len &&
|
2011-09-04 10:28:09 +04:00
|
|
|
memcmp(data, "RIFF", SLEN("RIFF")) == 0 &&
|
2017-03-19 18:00:21 +03:00
|
|
|
memcmp(data + SLEN("RIFF????"),
|
2011-09-04 10:28:09 +04:00
|
|
|
it->sig, it->len) == 0) {
|
|
|
|
|
*effective_type = lwc_string_ref(*it->type);
|
|
|
|
|
return NSERROR_OK;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return NSERROR_NOT_FOUND;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static nserror mimesniff__match_unknown_exact(const uint8_t *data, size_t len,
|
|
|
|
|
bool allow_unsafe, lwc_string **effective_type)
|
|
|
|
|
{
|
|
|
|
|
#define SIG(t, s, x) { (const uint8_t *) s, SLEN(s), x, t }
|
|
|
|
|
static const struct map_s exact_match_types[] = {
|
2017-03-19 18:00:21 +03:00
|
|
|
SIG(&corestring_lwc_image_gif, "GIF87a", true),
|
|
|
|
|
SIG(&corestring_lwc_image_gif, "GIF89a", true),
|
|
|
|
|
SIG(&corestring_lwc_image_png, "\x89PNG\r\n\x1a\n", true),
|
|
|
|
|
SIG(&corestring_lwc_image_jpeg, "\xff\xd8\xff", true),
|
|
|
|
|
SIG(&corestring_lwc_image_bmp, "BM", true),
|
|
|
|
|
SIG(&corestring_lwc_image_vnd_microsoft_icon, "\x00\x00\x01\x00", true),
|
|
|
|
|
SIG(&corestring_lwc_application_ogg, "OggS\x00", true),
|
|
|
|
|
SIG(&corestring_lwc_video_webm, "\x1a\x45\xdf\xa3", true),
|
|
|
|
|
SIG(&corestring_lwc_application_x_rar_compressed, "Rar \x1a\x07\x00", true),
|
|
|
|
|
SIG(&corestring_lwc_application_zip, "PK\x03\x04", true),
|
|
|
|
|
SIG(&corestring_lwc_application_x_gzip, "\x1f\x8b\x08", true),
|
|
|
|
|
SIG(&corestring_lwc_application_postscript, "%!PS-Adobe-",true),
|
|
|
|
|
SIG(&corestring_lwc_application_pdf, "%PDF-", false),
|
2023-11-26 18:51:40 +03:00
|
|
|
SIG(&corestring_lwc_image_jxl, "\xFF\x0A", true), /* containerless jpeg xl*/
|
|
|
|
|
{
|
|
|
|
|
(const uint8_t *)"\x00\x00\x00\x0CJXL \x0D\x0A\x87\x0A",
|
|
|
|
|
12,
|
|
|
|
|
true,
|
|
|
|
|
&corestring_lwc_image_jxl
|
|
|
|
|
}, /* containered jpeg xl*/
|
2011-09-04 10:28:09 +04:00
|
|
|
{ NULL, 0, false, NULL }
|
|
|
|
|
};
|
|
|
|
|
#undef SIG
|
|
|
|
|
const struct map_s *it;
|
|
|
|
|
|
|
|
|
|
for (it = exact_match_types; it->sig != NULL; it++) {
|
|
|
|
|
if (it->len <= len && memcmp(data, it->sig, it->len) == 0 &&
|
|
|
|
|
(allow_unsafe || it->safe)) {
|
|
|
|
|
*effective_type = lwc_string_ref(*it->type);
|
|
|
|
|
return NSERROR_OK;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return NSERROR_NOT_FOUND;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static nserror mimesniff__match_unknown(const uint8_t *data, size_t len,
|
|
|
|
|
bool allow_unsafe, lwc_string **effective_type)
|
|
|
|
|
{
|
2017-03-19 18:00:21 +03:00
|
|
|
if (mimesniff__match_unknown_exact(data, len, allow_unsafe,
|
2011-09-04 10:28:09 +04:00
|
|
|
effective_type) == NSERROR_OK)
|
|
|
|
|
return NSERROR_OK;
|
|
|
|
|
|
2017-03-19 18:00:21 +03:00
|
|
|
if (mimesniff__match_unknown_riff(data, len,
|
2011-09-04 10:28:09 +04:00
|
|
|
effective_type) == NSERROR_OK)
|
|
|
|
|
return NSERROR_OK;
|
|
|
|
|
|
|
|
|
|
if (allow_unsafe == false)
|
|
|
|
|
return NSERROR_NOT_FOUND;
|
|
|
|
|
|
|
|
|
|
if (mimesniff__match_unknown_bom(data, len,
|
|
|
|
|
effective_type) == NSERROR_OK)
|
|
|
|
|
return NSERROR_OK;
|
|
|
|
|
|
|
|
|
|
if (mimesniff__match_unknown_ws(data, len,
|
|
|
|
|
effective_type) == NSERROR_OK)
|
|
|
|
|
return NSERROR_OK;
|
|
|
|
|
|
2011-09-27 04:33:37 +04:00
|
|
|
if (mimesniff__match_mp4(data, len, effective_type) == NSERROR_OK)
|
|
|
|
|
return NSERROR_OK;
|
|
|
|
|
|
2011-09-04 10:28:09 +04:00
|
|
|
return NSERROR_NOT_FOUND;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static nserror mimesniff__compute_unknown(const uint8_t *data, size_t len,
|
|
|
|
|
lwc_string **effective_type)
|
|
|
|
|
{
|
|
|
|
|
if (data == NULL)
|
|
|
|
|
return NSERROR_NEED_DATA;
|
|
|
|
|
|
|
|
|
|
len = min(len, 512);
|
|
|
|
|
|
2017-03-19 18:00:21 +03:00
|
|
|
if (mimesniff__match_unknown(data, len, true,
|
|
|
|
|
effective_type) == NSERROR_OK) {
|
2011-09-04 10:28:09 +04:00
|
|
|
return NSERROR_OK;
|
2017-03-19 18:00:21 +03:00
|
|
|
}
|
2011-09-04 10:28:09 +04:00
|
|
|
|
|
|
|
|
if (mimesniff__has_binary_octets(data, len) == false) {
|
|
|
|
|
/* No binary octets => text/plain */
|
2017-03-19 18:00:21 +03:00
|
|
|
*effective_type = lwc_string_ref(corestring_lwc_text_plain);
|
2011-09-04 10:28:09 +04:00
|
|
|
return NSERROR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
2017-03-19 18:00:21 +03:00
|
|
|
*effective_type = lwc_string_ref(corestring_lwc_application_octet_stream);
|
2011-09-04 10:28:09 +04:00
|
|
|
|
|
|
|
|
return NSERROR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
2017-03-19 18:00:21 +03:00
|
|
|
static nserror mimesniff__compute_text_or_binary(const uint8_t *data,
|
2011-09-04 10:28:09 +04:00
|
|
|
size_t len, lwc_string **effective_type)
|
|
|
|
|
{
|
2017-03-19 18:00:21 +03:00
|
|
|
if (data == NULL) {
|
2011-09-04 10:28:09 +04:00
|
|
|
return NSERROR_NEED_DATA;
|
2017-03-19 18:00:21 +03:00
|
|
|
}
|
2011-09-04 10:28:09 +04:00
|
|
|
|
|
|
|
|
len = min(len, 512);
|
|
|
|
|
|
|
|
|
|
if (len >= 3 && ((data[0] == 0xfe && data[1] == 0xff) ||
|
|
|
|
|
(data[0] == 0xff && data[1] == 0xfe) ||
|
2017-03-19 18:00:21 +03:00
|
|
|
(data[0] == 0xef && data[1] == 0xbb &&
|
2011-09-04 10:28:09 +04:00
|
|
|
data[2] == 0xbf))) {
|
|
|
|
|
/* Found a BOM => text/plain */
|
2017-03-19 18:00:21 +03:00
|
|
|
*effective_type = lwc_string_ref(corestring_lwc_text_plain);
|
2011-09-04 10:28:09 +04:00
|
|
|
return NSERROR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (mimesniff__has_binary_octets(data, len) == false) {
|
|
|
|
|
/* No binary octets => text/plain */
|
2017-03-19 18:00:21 +03:00
|
|
|
*effective_type = lwc_string_ref(corestring_lwc_text_plain);
|
2011-09-04 10:28:09 +04:00
|
|
|
return NSERROR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
2017-03-19 18:00:21 +03:00
|
|
|
if (mimesniff__match_unknown(data, len, false,
|
2011-09-04 10:28:09 +04:00
|
|
|
effective_type) == NSERROR_OK)
|
|
|
|
|
return NSERROR_OK;
|
|
|
|
|
|
2017-03-19 18:00:21 +03:00
|
|
|
*effective_type = lwc_string_ref(corestring_lwc_application_octet_stream);
|
2011-09-04 10:28:09 +04:00
|
|
|
|
|
|
|
|
return NSERROR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static nserror mimesniff__compute_image(lwc_string *official_type,
|
|
|
|
|
const uint8_t *data, size_t len, lwc_string **effective_type)
|
|
|
|
|
{
|
|
|
|
|
#define SIG(t, s) { (const uint8_t *) s, SLEN(s), t }
|
|
|
|
|
static const struct it_s {
|
|
|
|
|
const uint8_t *sig;
|
|
|
|
|
size_t len;
|
|
|
|
|
lwc_string **type;
|
|
|
|
|
} image_types[] = {
|
2017-03-19 18:00:21 +03:00
|
|
|
SIG(&corestring_lwc_image_gif, "GIF87a"),
|
|
|
|
|
SIG(&corestring_lwc_image_gif, "GIF89a"),
|
|
|
|
|
SIG(&corestring_lwc_image_png, "\x89PNG\r\n\x1a\n"),
|
|
|
|
|
SIG(&corestring_lwc_image_jpeg, "\xff\xd8\xff"),
|
|
|
|
|
SIG(&corestring_lwc_image_bmp, "BM"),
|
|
|
|
|
SIG(&corestring_lwc_image_vnd_microsoft_icon, "\x00\x00\x01\x00"),
|
2023-11-26 18:51:40 +03:00
|
|
|
SIG(&corestring_lwc_image_jxl, "\xFF\x0A"), /* containerless jpeg xl*/
|
|
|
|
|
{
|
|
|
|
|
(const uint8_t *)"\x00\x00\x00\x0CJXL \x0D\x0A\x87\x0A",
|
|
|
|
|
12,
|
|
|
|
|
&corestring_lwc_image_jxl
|
|
|
|
|
}, /* containered jpeg xl*/
|
2011-09-04 10:28:09 +04:00
|
|
|
{ NULL, 0, NULL }
|
|
|
|
|
};
|
|
|
|
|
#undef SIG
|
|
|
|
|
|
|
|
|
|
const struct it_s *it;
|
|
|
|
|
|
2011-09-04 15:14:19 +04:00
|
|
|
if (data == NULL) {
|
|
|
|
|
lwc_string_unref(official_type);
|
2011-09-04 10:28:09 +04:00
|
|
|
return NSERROR_NEED_DATA;
|
2011-09-04 15:14:19 +04:00
|
|
|
}
|
2011-09-04 10:28:09 +04:00
|
|
|
|
|
|
|
|
for (it = image_types; it->sig != NULL; it++) {
|
|
|
|
|
if (it->len <= len && memcmp(data, it->sig, it->len) == 0) {
|
|
|
|
|
lwc_string_unref(official_type);
|
|
|
|
|
*effective_type = lwc_string_ref(*it->type);
|
|
|
|
|
return NSERROR_OK;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* WebP has a signature that doesn't fit into the above table */
|
2017-03-19 18:00:21 +03:00
|
|
|
if (SLEN("RIFF????WEBPVP") <= len &&
|
|
|
|
|
memcmp(data, "RIFF", SLEN("RIFF")) == 0 &&
|
|
|
|
|
memcmp(data + SLEN("RIFF????"),
|
2011-09-04 10:28:09 +04:00
|
|
|
"WEBPVP", SLEN("WEBPVP")) == 0 ) {
|
|
|
|
|
lwc_string_unref(official_type);
|
2017-03-19 18:00:21 +03:00
|
|
|
*effective_type = lwc_string_ref(corestring_lwc_image_webp);
|
2011-09-04 10:28:09 +04:00
|
|
|
return NSERROR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
*effective_type = official_type;
|
|
|
|
|
|
|
|
|
|
return NSERROR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static nserror mimesniff__compute_feed_or_html(const uint8_t *data,
|
|
|
|
|
size_t len, lwc_string **effective_type)
|
|
|
|
|
{
|
|
|
|
|
#define RDF_NS "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
|
|
|
|
|
#define RSS_NS "http://purl.org/rss/1.0"
|
|
|
|
|
|
|
|
|
|
enum state_e {
|
|
|
|
|
BEFORE_BOM,
|
|
|
|
|
BEFORE_MARKUP,
|
|
|
|
|
MARKUP_START,
|
|
|
|
|
COMMENT_OR_DOCTYPE,
|
|
|
|
|
IN_COMMENT,
|
|
|
|
|
IN_DOCTYPE,
|
|
|
|
|
IN_PI,
|
|
|
|
|
IN_TAG,
|
|
|
|
|
IN_RDF
|
|
|
|
|
} state = BEFORE_BOM;
|
|
|
|
|
|
|
|
|
|
bool rdf = false, rss = false;
|
|
|
|
|
const uint8_t *end;
|
|
|
|
|
|
|
|
|
|
if (data == NULL)
|
|
|
|
|
return NSERROR_NEED_DATA;
|
|
|
|
|
|
|
|
|
|
end = data + min(len, 512);
|
|
|
|
|
|
|
|
|
|
while (data < end) {
|
|
|
|
|
const uint8_t c = *data;
|
|
|
|
|
|
|
|
|
|
#define MATCH(s) SLEN(s) <= (size_t) (end - data) && \
|
|
|
|
|
memcmp(data, s, SLEN(s)) == 0
|
|
|
|
|
|
|
|
|
|
switch (state) {
|
|
|
|
|
case BEFORE_BOM:
|
2017-03-19 18:00:21 +03:00
|
|
|
if (3 <= end - data && c == 0xef && data[1] == 0xbb &&
|
2011-09-04 10:28:09 +04:00
|
|
|
data[2] == 0xbf) {
|
|
|
|
|
data += 3;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
state = BEFORE_MARKUP;
|
|
|
|
|
break;
|
|
|
|
|
case BEFORE_MARKUP:
|
|
|
|
|
if (c == '\t' || c == '\n' || c == '\r' || c == ' ')
|
|
|
|
|
data++;
|
|
|
|
|
else if (c != '<')
|
|
|
|
|
data = end;
|
|
|
|
|
else {
|
|
|
|
|
state = MARKUP_START;
|
|
|
|
|
data++;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case MARKUP_START:
|
|
|
|
|
if (c == '!') {
|
|
|
|
|
state = COMMENT_OR_DOCTYPE;
|
|
|
|
|
data++;
|
|
|
|
|
} else if (c == '?') {
|
|
|
|
|
state = IN_PI;
|
|
|
|
|
data++;
|
|
|
|
|
} else {
|
|
|
|
|
/* Reconsume input */
|
|
|
|
|
state = IN_TAG;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case COMMENT_OR_DOCTYPE:
|
|
|
|
|
if (2 <= end - data && c == '-' && data[1] == '-') {
|
|
|
|
|
state = IN_COMMENT;
|
|
|
|
|
data += 2;
|
|
|
|
|
} else {
|
|
|
|
|
/* Reconsume input */
|
|
|
|
|
state = IN_DOCTYPE;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case IN_COMMENT:
|
|
|
|
|
if (3 <= end - data && c == '-' && data[1] == '-' &&
|
|
|
|
|
data[2] == '>') {
|
|
|
|
|
state = BEFORE_MARKUP;
|
|
|
|
|
data += 3;
|
|
|
|
|
} else
|
|
|
|
|
data++;
|
|
|
|
|
break;
|
|
|
|
|
case IN_DOCTYPE:
|
|
|
|
|
if (c == '>')
|
|
|
|
|
state = BEFORE_MARKUP;
|
|
|
|
|
data++;
|
|
|
|
|
break;
|
|
|
|
|
case IN_PI:
|
|
|
|
|
if (2 <= end - data && c == '?' && data[1] == '>') {
|
|
|
|
|
state = BEFORE_MARKUP;
|
|
|
|
|
data += 2;
|
|
|
|
|
} else
|
|
|
|
|
data++;
|
|
|
|
|
break;
|
|
|
|
|
case IN_TAG:
|
|
|
|
|
if (MATCH("rss")) {
|
2017-03-19 18:00:21 +03:00
|
|
|
*effective_type =
|
|
|
|
|
lwc_string_ref(corestring_lwc_application_rss_xml);
|
2011-09-04 10:28:09 +04:00
|
|
|
return NSERROR_OK;
|
|
|
|
|
} else if (MATCH("feed")) {
|
2017-03-19 18:00:21 +03:00
|
|
|
*effective_type =
|
|
|
|
|
lwc_string_ref(corestring_lwc_application_atom_xml);
|
2011-09-04 10:28:09 +04:00
|
|
|
return NSERROR_OK;
|
|
|
|
|
} else if (MATCH("rdf:RDF")) {
|
|
|
|
|
state = IN_RDF;
|
|
|
|
|
data += SLEN("rdf:RDF");
|
|
|
|
|
} else
|
|
|
|
|
data = end;
|
|
|
|
|
break;
|
|
|
|
|
case IN_RDF:
|
|
|
|
|
if (MATCH(RSS_NS)) {
|
|
|
|
|
rss = true;
|
|
|
|
|
data += SLEN(RSS_NS);
|
|
|
|
|
} else if (MATCH(RDF_NS)) {
|
|
|
|
|
rdf = true;
|
|
|
|
|
data += SLEN(RDF_NS);
|
|
|
|
|
} else
|
|
|
|
|
data++;
|
|
|
|
|
|
|
|
|
|
if (rdf && rss) {
|
2017-03-19 18:00:21 +03:00
|
|
|
*effective_type = lwc_string_ref(corestring_lwc_application_rss_xml);
|
2011-09-04 10:28:09 +04:00
|
|
|
return NSERROR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
#undef MATCH
|
|
|
|
|
}
|
|
|
|
|
|
2017-03-19 18:00:21 +03:00
|
|
|
*effective_type = lwc_string_ref(corestring_lwc_text_html);
|
2011-09-04 10:28:09 +04:00
|
|
|
|
|
|
|
|
return NSERROR_OK;
|
|
|
|
|
|
|
|
|
|
#undef RSS_NS
|
|
|
|
|
#undef RDF_NS
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* See mimesniff.h for documentation */
|
2017-03-20 03:48:11 +03:00
|
|
|
nserror
|
|
|
|
|
mimesniff_compute_effective_type(const char *content_type_header,
|
|
|
|
|
const uint8_t *data,
|
|
|
|
|
size_t len,
|
|
|
|
|
bool sniff_allowed,
|
|
|
|
|
bool image_only,
|
|
|
|
|
lwc_string **effective_type)
|
2011-09-04 10:28:09 +04:00
|
|
|
{
|
|
|
|
|
#define S(s) { s, SLEN(s) }
|
|
|
|
|
static const struct tt_s {
|
|
|
|
|
const char *data;
|
|
|
|
|
size_t len;
|
|
|
|
|
} text_types[] = {
|
|
|
|
|
S("text/plain"),
|
|
|
|
|
S("text/plain; charset=ISO-8859-1"),
|
|
|
|
|
S("text/plain; charset=iso-8859-1"),
|
|
|
|
|
S("text/plain; charset=UTF-8"),
|
|
|
|
|
{ NULL, 0 }
|
|
|
|
|
};
|
|
|
|
|
#undef S
|
|
|
|
|
|
|
|
|
|
size_t content_type_header_len;
|
|
|
|
|
http_content_type *ct;
|
|
|
|
|
const struct tt_s *tt;
|
|
|
|
|
bool match;
|
|
|
|
|
nserror error;
|
|
|
|
|
|
|
|
|
|
if (content_type_header == NULL) {
|
2017-03-20 01:29:23 +03:00
|
|
|
if (sniff_allowed == false) {
|
2011-09-04 10:28:09 +04:00
|
|
|
return NSERROR_NOT_FOUND;
|
2017-03-20 01:29:23 +03:00
|
|
|
}
|
2011-09-04 10:28:09 +04:00
|
|
|
|
|
|
|
|
/* No official type => unknown */
|
|
|
|
|
return mimesniff__compute_unknown(data, len, effective_type);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
error = http_parse_content_type(content_type_header, &ct);
|
|
|
|
|
if (error != NSERROR_OK) {
|
|
|
|
|
if (sniff_allowed == false)
|
|
|
|
|
return NSERROR_NOT_FOUND;
|
|
|
|
|
|
|
|
|
|
/* Unparseable => unknown */
|
|
|
|
|
return mimesniff__compute_unknown(data, len, effective_type);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (sniff_allowed == false) {
|
|
|
|
|
*effective_type = lwc_string_ref(ct->media_type);
|
|
|
|
|
http_content_type_destroy(ct);
|
|
|
|
|
return NSERROR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
2012-02-08 04:52:16 +04:00
|
|
|
if (image_only) {
|
|
|
|
|
lwc_string *official_type;
|
|
|
|
|
|
2017-03-19 18:00:21 +03:00
|
|
|
if (lwc_string_caseless_isequal(ct->media_type,
|
|
|
|
|
corestring_lwc_image_svg,
|
|
|
|
|
&match) == lwc_error_ok && match) {
|
|
|
|
|
*effective_type = lwc_string_ref(corestring_lwc_image_svg);
|
2012-02-08 04:52:16 +04:00
|
|
|
http_content_type_destroy(ct);
|
|
|
|
|
return NSERROR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
official_type = lwc_string_ref(ct->media_type);
|
|
|
|
|
http_content_type_destroy(ct);
|
|
|
|
|
return mimesniff__compute_image(official_type,
|
|
|
|
|
data, len, effective_type);
|
|
|
|
|
}
|
|
|
|
|
|
2011-09-04 10:28:09 +04:00
|
|
|
content_type_header_len = strlen(content_type_header);
|
|
|
|
|
|
|
|
|
|
/* Look for text types */
|
|
|
|
|
for (tt = text_types; tt->data != NULL; tt++) {
|
|
|
|
|
if (tt->len == content_type_header_len &&
|
2017-03-19 18:00:21 +03:00
|
|
|
memcmp(tt->data,
|
|
|
|
|
content_type_header,
|
|
|
|
|
content_type_header_len) == 0) {
|
2011-09-04 10:28:09 +04:00
|
|
|
http_content_type_destroy(ct);
|
|
|
|
|
return mimesniff__compute_text_or_binary(data, len,
|
|
|
|
|
effective_type);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* unknown/unknown, application/unknown, * / * */
|
2017-03-19 18:00:21 +03:00
|
|
|
if ((lwc_string_caseless_isequal(ct->media_type,
|
|
|
|
|
corestring_lwc_unknown_unknown,
|
|
|
|
|
&match) == lwc_error_ok && match) ||
|
|
|
|
|
(lwc_string_caseless_isequal(ct->media_type,
|
|
|
|
|
corestring_lwc_application_unknown,
|
|
|
|
|
&match) == lwc_error_ok && match) ||
|
|
|
|
|
(lwc_string_caseless_isequal(ct->media_type,
|
|
|
|
|
corestring_lwc_any,
|
|
|
|
|
&match) == lwc_error_ok && match)) {
|
2011-09-04 10:28:09 +04:00
|
|
|
http_content_type_destroy(ct);
|
|
|
|
|
return mimesniff__compute_unknown(data, len, effective_type);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* +xml */
|
|
|
|
|
if (lwc_string_length(ct->media_type) > SLEN("+xml") &&
|
2017-03-19 18:00:21 +03:00
|
|
|
strncasecmp(lwc_string_data(ct->media_type) +
|
|
|
|
|
lwc_string_length(ct->media_type) -
|
|
|
|
|
SLEN("+xml"),
|
2011-09-04 10:28:09 +04:00
|
|
|
"+xml", SLEN("+xml")) == 0) {
|
|
|
|
|
/* Use official type */
|
|
|
|
|
*effective_type = lwc_string_ref(ct->media_type);
|
|
|
|
|
http_content_type_destroy(ct);
|
|
|
|
|
return NSERROR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* text/xml, application/xml */
|
2017-03-19 18:00:21 +03:00
|
|
|
if ((lwc_string_caseless_isequal(ct->media_type,
|
|
|
|
|
corestring_lwc_text_xml,
|
|
|
|
|
&match) == lwc_error_ok && match) ||
|
|
|
|
|
(lwc_string_caseless_isequal(ct->media_type,
|
|
|
|
|
corestring_lwc_application_xml,
|
|
|
|
|
&match) == lwc_error_ok && match)) {
|
2011-09-04 10:28:09 +04:00
|
|
|
/* Use official type */
|
|
|
|
|
*effective_type = lwc_string_ref(ct->media_type);
|
|
|
|
|
http_content_type_destroy(ct);
|
|
|
|
|
return NSERROR_OK;
|
|
|
|
|
}
|
2017-03-19 18:00:21 +03:00
|
|
|
|
2011-09-04 10:28:09 +04:00
|
|
|
/* Image types */
|
2017-03-19 18:00:21 +03:00
|
|
|
if (content_factory_type_from_mime_type(ct->media_type) ==
|
2011-09-04 10:28:09 +04:00
|
|
|
CONTENT_IMAGE) {
|
|
|
|
|
lwc_string *official_type = lwc_string_ref(ct->media_type);
|
|
|
|
|
http_content_type_destroy(ct);
|
|
|
|
|
return mimesniff__compute_image(official_type,
|
|
|
|
|
data, len, effective_type);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* text/html */
|
2017-03-19 18:00:21 +03:00
|
|
|
if ((lwc_string_caseless_isequal(ct->media_type,
|
|
|
|
|
corestring_lwc_text_html,
|
|
|
|
|
&match) == lwc_error_ok && match)) {
|
2011-09-04 10:28:09 +04:00
|
|
|
http_content_type_destroy(ct);
|
|
|
|
|
return mimesniff__compute_feed_or_html(data, len,
|
2017-03-19 18:00:21 +03:00
|
|
|
effective_type);
|
2011-09-04 10:28:09 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Use official type */
|
|
|
|
|
*effective_type = lwc_string_ref(ct->media_type);
|
|
|
|
|
|
|
|
|
|
http_content_type_destroy(ct);
|
|
|
|
|
|
|
|
|
|
return NSERROR_OK;
|
|
|
|
|
}
|
