897 lines
23 KiB
C
897 lines
23 KiB
C
/*
|
|
* Copyright 2016 Vincent Sanders <vince@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/>.
|
|
*/
|
|
|
|
/**
|
|
* \file
|
|
* Test mime sniffing
|
|
*/
|
|
|
|
#include <assert.h>
|
|
#include <stdbool.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <check.h>
|
|
|
|
#include "utils/utils.h"
|
|
#include "utils/corestrings.h"
|
|
#include "content/content_factory.h"
|
|
#include "content/mimesniff.h"
|
|
|
|
#define NELEMS(x) (sizeof(x) / sizeof((x)[0]))
|
|
|
|
struct test_mimetype {
|
|
const uint8_t* data;
|
|
const size_t len;
|
|
lwc_string **mime_type;
|
|
bool safe;
|
|
};
|
|
|
|
/* helpers */
|
|
|
|
/**
|
|
* test implentation of mime type to content type conversion
|
|
*
|
|
* in the full implementation this converts a mime type to content
|
|
* type for content types with handler in the browser. This
|
|
* implementation provides a minimal version to pretends to support a
|
|
* couple of image types
|
|
*/
|
|
content_type content_factory_type_from_mime_type(lwc_string *mime_type)
|
|
{
|
|
content_type type = CONTENT_NONE;
|
|
bool match;
|
|
|
|
if (lwc_string_caseless_isequal(mime_type,
|
|
corestring_lwc_image_gif,
|
|
&match) == lwc_error_ok && match) {
|
|
type = CONTENT_IMAGE;
|
|
}
|
|
if (lwc_string_caseless_isequal(mime_type,
|
|
corestring_lwc_image_jpeg,
|
|
&match) == lwc_error_ok && match) {
|
|
type = CONTENT_IMAGE;
|
|
}
|
|
return type;
|
|
}
|
|
|
|
/* Fixtures */
|
|
|
|
static void corestring_create(void)
|
|
{
|
|
ck_assert(corestrings_init() == NSERROR_OK);
|
|
}
|
|
|
|
/**
|
|
* iterator for any remaining strings in teardown fixture
|
|
*/
|
|
static void netsurf_lwc_iterator(lwc_string *str, void *pw)
|
|
{
|
|
fprintf(stderr,
|
|
"[%3u] %.*s",
|
|
str->refcnt,
|
|
(int)lwc_string_length(str),
|
|
lwc_string_data(str));
|
|
}
|
|
|
|
static void corestring_teardown(void)
|
|
{
|
|
corestrings_fini();
|
|
|
|
lwc_iterate_strings(netsurf_lwc_iterator, NULL);
|
|
}
|
|
|
|
/* tests */
|
|
|
|
START_TEST(mimesniff_api_test)
|
|
{
|
|
nserror err;
|
|
lwc_string *effective_type;
|
|
|
|
/* no header type, no data and sniffing not allowed */
|
|
err = mimesniff_compute_effective_type(NULL,
|
|
NULL,
|
|
0,
|
|
false,
|
|
false,
|
|
&effective_type);
|
|
ck_assert(err == NSERROR_NOT_FOUND);
|
|
|
|
/* no header type, no data and sniffing allowed */
|
|
err = mimesniff_compute_effective_type(NULL,
|
|
NULL,
|
|
0,
|
|
true,
|
|
false,
|
|
&effective_type);
|
|
ck_assert(err == NSERROR_NEED_DATA);
|
|
|
|
}
|
|
END_TEST
|
|
|
|
|
|
static TCase *mimesniff_api_case_create(void)
|
|
{
|
|
TCase *tc;
|
|
tc = tcase_create("mimesniff API");
|
|
|
|
|
|
tcase_add_test(tc, mimesniff_api_test);
|
|
|
|
return tc;
|
|
}
|
|
|
|
|
|
/* unknown header exact binary type checks in safe context */
|
|
#define SIG(s,m,a) { (const uint8_t *)s, SLEN(s), &corestring_lwc_##m, a }
|
|
static struct test_mimetype match_unknown_exact_tests[] = {
|
|
SIG("GIF87a", image_gif, true),
|
|
SIG("GIF89a", image_gif, true),
|
|
SIG("\x89PNG\r\n\x1a\n", image_png, true),
|
|
SIG("\xff\xd8\xff", image_jpeg, true),
|
|
SIG("BM", image_bmp, true),
|
|
SIG("\x00\x00\x01\x00", image_vnd_microsoft_icon, true),
|
|
SIG("OggS\x00", application_ogg, true),
|
|
SIG("\x1a\x45\xdf\xa3", video_webm, true),
|
|
SIG("Rar \x1a\x07\x00", application_x_rar_compressed, true),
|
|
SIG("PK\x03\x04", application_zip, true),
|
|
SIG("\x1f\x8b\x08", application_x_gzip, true),
|
|
SIG("%!PS-Adobe-", application_postscript, true),
|
|
SIG("%PDF-", application_pdf, false),
|
|
};
|
|
|
|
static struct test_mimetype match_unknown_riff_tests[] = {
|
|
SIG("RIFF WEBPVP", image_webp, true),
|
|
SIG("RIFF WAVE", audio_wave, true),
|
|
};
|
|
|
|
static struct test_mimetype match_unknown_bom_tests[] = {
|
|
SIG("\xfe\xff",text_plain, false),
|
|
SIG("\xff\xfe", text_plain, false),
|
|
SIG("\xef\xbb\xbf", text_plain, false),
|
|
};
|
|
|
|
static struct test_mimetype match_unknown_ws_tests[] = {
|
|
SIG("<?xml", text_xml, false),
|
|
SIG("<!DOCTYPE HTML>", text_html, false),
|
|
SIG("<HTML ", text_html, false),
|
|
SIG("<HEAD ", text_html, false),
|
|
SIG("<SCRIPT ", text_html, false),
|
|
SIG("<IFRAME ", text_html, false),
|
|
SIG("<H1 ", text_html, false),
|
|
SIG("<DIV ", text_html, false),
|
|
SIG("<FONT ", text_html, false),
|
|
SIG("<TABLE ", text_html, false),
|
|
SIG("<A ", text_html, false),
|
|
SIG("<STYLE ", text_html, false),
|
|
SIG("<TITLE ", text_html, false),
|
|
SIG("<B ", text_html, false),
|
|
SIG("<BODY ", text_html, false),
|
|
SIG("<BR ", text_html, false),
|
|
SIG("<P ", text_html, false),
|
|
SIG("<!-- ", text_html, false),
|
|
};
|
|
|
|
static struct test_mimetype match_unknown_mp4_tests[] = {
|
|
SIG("\x00\x00\x00\040ftypisom\x00\x00\x02\x00isomiso2avc1mp41", video_mp4, true),
|
|
SIG("\x00\x00\x00\040ftypmp41\x00\x00\x02\x00isomiso2avc1mp41", video_mp4, true),
|
|
};
|
|
|
|
static struct test_mimetype match_unknown_bad_mp4_tests[] = {
|
|
SIG("\x00\x00\x00\044ftypisom\x00\x00\x02\x00isomiso2avc1mp41", application_octet_stream, true),
|
|
SIG("\x00\x00\x00\037ftypmp41\x00\x00\x02\x00isomiso2avc1mp41", application_octet_stream, true),
|
|
SIG("\x00\x00\x00\040atypmp41\x00\x00\x02\x00isomiso2avc1mp41", application_octet_stream, true),
|
|
SIG("\x00\x00\x00\040faypmp41\x00\x00\x02\x00isomiso2avc1mp41", application_octet_stream, true),
|
|
SIG("\x00\x00\x00\040ftapmp41\x00\x00\x02\x00isomiso2avc1mp41", application_octet_stream, true),
|
|
SIG("\x00\x00\x00\040ftyamp41\x00\x00\x02\x00isomiso2avc1mp41", application_octet_stream, true),
|
|
SIG("\x00\x00\x00\040ftypmp31\x00\x00\x02\x00isomiso2avc1mp31", application_octet_stream, true),
|
|
SIG("\x00\x00\x00\040ftypma41\x00\x00\x02\x00isomiso2avc1ma41", application_octet_stream, true),
|
|
};
|
|
|
|
static struct test_mimetype match_unknown_txtbin_tests[] = {
|
|
SIG("a\nb\tc ", text_plain, true),
|
|
SIG("\x1b\r\f ", text_plain, true),
|
|
SIG("a\nb\tc \x01", application_octet_stream, true),
|
|
};
|
|
|
|
#undef SIG
|
|
|
|
/**
|
|
* exact unknown tests
|
|
*
|
|
* allows return of unsafe type matches
|
|
*/
|
|
START_TEST(mimesniff_match_unknown_exact_test)
|
|
{
|
|
nserror err;
|
|
const struct test_mimetype *tst = &match_unknown_exact_tests[_i];
|
|
lwc_string *effective_type;
|
|
bool match;
|
|
|
|
err = mimesniff_compute_effective_type(NULL,
|
|
tst->data,
|
|
tst->len,
|
|
true,
|
|
false,
|
|
&effective_type);
|
|
ck_assert(err == NSERROR_OK);
|
|
|
|
ck_assert(lwc_string_caseless_isequal(effective_type,
|
|
*(tst->mime_type),
|
|
&match) == lwc_error_ok && match);
|
|
lwc_string_unref(effective_type);
|
|
}
|
|
END_TEST
|
|
|
|
/**
|
|
* riff test
|
|
*/
|
|
START_TEST(mimesniff_match_unknown_riff_test)
|
|
{
|
|
nserror err;
|
|
const struct test_mimetype *tst = &match_unknown_riff_tests[_i];
|
|
lwc_string *effective_type;
|
|
bool match;
|
|
|
|
err = mimesniff_compute_effective_type(NULL,
|
|
tst->data,
|
|
tst->len,
|
|
true,
|
|
false,
|
|
&effective_type);
|
|
ck_assert(err == NSERROR_OK);
|
|
|
|
ck_assert(lwc_string_caseless_isequal(effective_type,
|
|
*(tst->mime_type),
|
|
&match) == lwc_error_ok && match);
|
|
lwc_string_unref(effective_type);
|
|
}
|
|
END_TEST
|
|
|
|
/**
|
|
* BOM test
|
|
*/
|
|
START_TEST(mimesniff_match_unknown_bom_test)
|
|
{
|
|
nserror err;
|
|
const struct test_mimetype *tst = &match_unknown_bom_tests[_i];
|
|
lwc_string *effective_type;
|
|
bool match;
|
|
|
|
err = mimesniff_compute_effective_type(NULL,
|
|
tst->data,
|
|
tst->len,
|
|
true,
|
|
false,
|
|
&effective_type);
|
|
ck_assert(err == NSERROR_OK);
|
|
|
|
ck_assert(lwc_string_caseless_isequal(effective_type,
|
|
*(tst->mime_type),
|
|
&match) == lwc_error_ok && match);
|
|
lwc_string_unref(effective_type);
|
|
}
|
|
END_TEST
|
|
|
|
/**
|
|
* ws test
|
|
*/
|
|
START_TEST(mimesniff_match_unknown_ws_test)
|
|
{
|
|
nserror err;
|
|
const struct test_mimetype *tst = &match_unknown_ws_tests[_i];
|
|
lwc_string *effective_type;
|
|
bool match;
|
|
|
|
err = mimesniff_compute_effective_type(NULL,
|
|
tst->data,
|
|
tst->len,
|
|
true,
|
|
false,
|
|
&effective_type);
|
|
ck_assert(err == NSERROR_OK);
|
|
|
|
ck_assert(lwc_string_caseless_isequal(effective_type,
|
|
*(tst->mime_type),
|
|
&match) == lwc_error_ok && match);
|
|
lwc_string_unref(effective_type);
|
|
}
|
|
END_TEST
|
|
|
|
/**
|
|
* mp4 test
|
|
*/
|
|
START_TEST(mimesniff_match_unknown_mp4_test)
|
|
{
|
|
nserror err;
|
|
const struct test_mimetype *tst = &match_unknown_mp4_tests[_i];
|
|
lwc_string *effective_type;
|
|
bool match;
|
|
|
|
err = mimesniff_compute_effective_type(NULL,
|
|
tst->data,
|
|
tst->len,
|
|
true,
|
|
false,
|
|
&effective_type);
|
|
ck_assert(err == NSERROR_OK);
|
|
|
|
ck_assert(lwc_string_caseless_isequal(effective_type,
|
|
*(tst->mime_type),
|
|
&match) == lwc_error_ok && match);
|
|
lwc_string_unref(effective_type);
|
|
}
|
|
END_TEST
|
|
|
|
/**
|
|
* mp4 test
|
|
*/
|
|
START_TEST(mimesniff_match_unknown_bad_mp4_test)
|
|
{
|
|
nserror err;
|
|
const struct test_mimetype *tst = &match_unknown_bad_mp4_tests[_i];
|
|
lwc_string *effective_type;
|
|
bool match;
|
|
|
|
err = mimesniff_compute_effective_type(NULL,
|
|
tst->data,
|
|
tst->len,
|
|
true,
|
|
false,
|
|
&effective_type);
|
|
ck_assert(err == NSERROR_OK);
|
|
|
|
ck_assert(lwc_string_caseless_isequal(effective_type,
|
|
*(tst->mime_type),
|
|
&match) == lwc_error_ok && match);
|
|
lwc_string_unref(effective_type);
|
|
}
|
|
END_TEST
|
|
|
|
/**
|
|
* unknown header text/binary test
|
|
*/
|
|
START_TEST(mimesniff_match_unknown_txtbin_test)
|
|
{
|
|
nserror err;
|
|
const struct test_mimetype *tst = &match_unknown_txtbin_tests[_i];
|
|
lwc_string *effective_type;
|
|
bool match;
|
|
|
|
err = mimesniff_compute_effective_type(NULL,
|
|
tst->data,
|
|
tst->len,
|
|
true,
|
|
false,
|
|
&effective_type);
|
|
ck_assert(err == NSERROR_OK);
|
|
|
|
ck_assert(lwc_string_caseless_isequal(effective_type,
|
|
*(tst->mime_type),
|
|
&match) == lwc_error_ok && match);
|
|
lwc_string_unref(effective_type);
|
|
}
|
|
END_TEST
|
|
|
|
|
|
static TCase *mimesniff_match_unknown_case_create(void)
|
|
{
|
|
TCase *tc;
|
|
tc = tcase_create("mimesniff");
|
|
|
|
tcase_add_unchecked_fixture(tc,
|
|
corestring_create,
|
|
corestring_teardown);
|
|
|
|
tcase_add_loop_test(tc,
|
|
mimesniff_match_unknown_exact_test,
|
|
0, NELEMS(match_unknown_exact_tests));
|
|
|
|
tcase_add_loop_test(tc,
|
|
mimesniff_match_unknown_riff_test,
|
|
0, NELEMS(match_unknown_riff_tests));
|
|
|
|
tcase_add_loop_test(tc,
|
|
mimesniff_match_unknown_bom_test,
|
|
0, NELEMS(match_unknown_bom_tests));
|
|
|
|
tcase_add_loop_test(tc,
|
|
mimesniff_match_unknown_ws_test,
|
|
0, NELEMS(match_unknown_ws_tests));
|
|
|
|
tcase_add_loop_test(tc,
|
|
mimesniff_match_unknown_mp4_test,
|
|
0, NELEMS(match_unknown_mp4_tests));
|
|
|
|
tcase_add_loop_test(tc,
|
|
mimesniff_match_unknown_bad_mp4_test,
|
|
0, NELEMS(match_unknown_bad_mp4_tests));
|
|
|
|
tcase_add_loop_test(tc,
|
|
mimesniff_match_unknown_txtbin_test,
|
|
0, NELEMS(match_unknown_txtbin_tests));
|
|
|
|
return tc;
|
|
}
|
|
|
|
|
|
START_TEST(mimesniff_unparsable_header_test)
|
|
{
|
|
nserror err;
|
|
lwc_string *effective_type;
|
|
|
|
/* unparsable header type, no data and sniffing not allowed */
|
|
err = mimesniff_compute_effective_type("badheader",
|
|
NULL,
|
|
0,
|
|
false,
|
|
false,
|
|
&effective_type);
|
|
ck_assert_int_eq(err, NSERROR_NOT_FOUND);
|
|
|
|
/* unparsable header type, no data and sniffing allowed */
|
|
err = mimesniff_compute_effective_type("badheader",
|
|
NULL,
|
|
0,
|
|
true,
|
|
false,
|
|
&effective_type);
|
|
ck_assert_int_eq(err, NSERROR_NEED_DATA);
|
|
|
|
}
|
|
END_TEST
|
|
|
|
|
|
START_TEST(mimesniff_parsable_header_nosniff_test)
|
|
{
|
|
nserror err;
|
|
lwc_string *effective_type;
|
|
bool match;
|
|
|
|
/* unparsable header type, no data and sniffing not allowed */
|
|
err = mimesniff_compute_effective_type("text/plain",
|
|
NULL,
|
|
0,
|
|
false,
|
|
false,
|
|
&effective_type);
|
|
ck_assert(err == NSERROR_OK);
|
|
|
|
ck_assert(lwc_string_caseless_isequal(effective_type,
|
|
corestring_lwc_text_plain,
|
|
&match) == lwc_error_ok && match);
|
|
lwc_string_unref(effective_type);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(mimesniff_svg_header_sniff_imageonly_test)
|
|
{
|
|
nserror err;
|
|
lwc_string *effective_type;
|
|
bool match;
|
|
|
|
/* svg header type, no data and sniffing allowed images only*/
|
|
err = mimesniff_compute_effective_type("image/svg+xml",
|
|
NULL,
|
|
0,
|
|
true,
|
|
true,
|
|
&effective_type);
|
|
ck_assert_int_eq(err, NSERROR_OK);
|
|
|
|
ck_assert(lwc_string_caseless_isequal(effective_type,
|
|
corestring_lwc_image_svg,
|
|
&match) == lwc_error_ok && match);
|
|
lwc_string_unref(effective_type);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(mimesniff_image_header_sniff_imageonly_test)
|
|
{
|
|
nserror err;
|
|
lwc_string *effective_type;
|
|
bool match;
|
|
|
|
/* jpeg header type, no data and sniffing allowed images only */
|
|
err = mimesniff_compute_effective_type("image/jpeg",
|
|
NULL,
|
|
0,
|
|
true,
|
|
true,
|
|
&effective_type);
|
|
ck_assert_int_eq(err, NSERROR_NEED_DATA);
|
|
|
|
/* svg header type, unsniffable data and sniffing allowed images only */
|
|
err = mimesniff_compute_effective_type("image/jpeg",
|
|
(const uint8_t*)"notsniffablejpeg",
|
|
12,
|
|
true,
|
|
true,
|
|
&effective_type);
|
|
ck_assert_int_eq(err, NSERROR_OK);
|
|
|
|
ck_assert(lwc_string_caseless_isequal(effective_type,
|
|
corestring_lwc_image_jpeg,
|
|
&match) == lwc_error_ok && match);
|
|
lwc_string_unref(effective_type);
|
|
|
|
/* svg header type, gif data and sniffing allowed images only */
|
|
err = mimesniff_compute_effective_type("image/jpeg",
|
|
(const uint8_t*)"GIF87a",
|
|
6,
|
|
true,
|
|
true,
|
|
&effective_type);
|
|
ck_assert_int_eq(err, NSERROR_OK);
|
|
|
|
ck_assert(lwc_string_caseless_isequal(effective_type,
|
|
corestring_lwc_image_gif,
|
|
&match) == lwc_error_ok && match);
|
|
lwc_string_unref(effective_type);
|
|
|
|
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(mimesniff_text_header_nodata_sniff_test)
|
|
{
|
|
nserror err;
|
|
lwc_string *effective_type;
|
|
bool match;
|
|
|
|
/* text header type, no data and sniffing allowed */
|
|
err = mimesniff_compute_effective_type("text/plain",
|
|
NULL,
|
|
0,
|
|
true,
|
|
false,
|
|
&effective_type);
|
|
ck_assert_int_eq(err, NSERROR_NEED_DATA);
|
|
|
|
/* svg header type, unsniffable data and sniffing allowed images only */
|
|
err = mimesniff_compute_effective_type("text/plain",
|
|
(const uint8_t*)"a\nb\tc \x01",
|
|
7,
|
|
true,
|
|
false,
|
|
&effective_type);
|
|
ck_assert_int_eq(err, NSERROR_OK);
|
|
|
|
ck_assert(lwc_string_caseless_isequal(effective_type,
|
|
corestring_lwc_application_octet_stream,
|
|
&match) == lwc_error_ok && match);
|
|
lwc_string_unref(effective_type);
|
|
|
|
}
|
|
END_TEST
|
|
|
|
#define SIG(s,m,a) { (const uint8_t *)s, SLEN(s), &corestring_lwc_##m, a }
|
|
static struct test_mimetype text_header_tests[] = {
|
|
SIG("text/plain", text_plain, true),
|
|
SIG("text/plain; charset=ISO-8859-1", text_plain, true),
|
|
SIG("text/plain; charset=iso-8859-1", text_plain, true),
|
|
SIG("text/plain; charset=UTF-8", text_plain, true),
|
|
};
|
|
#undef SIG
|
|
|
|
START_TEST(mimesniff_text_header_sniff_test)
|
|
{
|
|
nserror err;
|
|
const struct test_mimetype *tst = &text_header_tests[_i];
|
|
lwc_string *effective_type;
|
|
bool match;
|
|
|
|
|
|
err = mimesniff_compute_effective_type((const char*)tst->data,
|
|
(const uint8_t*)"text",
|
|
4,
|
|
true,
|
|
false,
|
|
&effective_type);
|
|
ck_assert_int_eq(err, NSERROR_OK);
|
|
|
|
ck_assert(lwc_string_caseless_isequal(effective_type,
|
|
corestring_lwc_text_plain,
|
|
&match) == lwc_error_ok && match);
|
|
lwc_string_unref(effective_type);
|
|
}
|
|
END_TEST
|
|
|
|
|
|
START_TEST(mimesniff_unknown_header_sniff_test)
|
|
{
|
|
nserror err;
|
|
lwc_string *effective_type;
|
|
bool match;
|
|
|
|
/* unknown header type, sniffable data and sniffing allowed */
|
|
err = mimesniff_compute_effective_type("unknown/unknown",
|
|
match_unknown_riff_tests[0].data,
|
|
match_unknown_riff_tests[0].len,
|
|
true,
|
|
false,
|
|
&effective_type);
|
|
ck_assert_int_eq(err, NSERROR_OK);
|
|
|
|
ck_assert(lwc_string_caseless_isequal(effective_type,
|
|
*match_unknown_riff_tests[0].mime_type,
|
|
&match) == lwc_error_ok && match);
|
|
lwc_string_unref(effective_type);
|
|
|
|
/* unknown header type, sniffable data and sniffing allowed */
|
|
err = mimesniff_compute_effective_type("application/unknown",
|
|
match_unknown_riff_tests[1].data,
|
|
match_unknown_riff_tests[1].len,
|
|
true,
|
|
false,
|
|
&effective_type);
|
|
ck_assert_int_eq(err, NSERROR_OK);
|
|
|
|
ck_assert(lwc_string_caseless_isequal(effective_type,
|
|
*match_unknown_riff_tests[1].mime_type,
|
|
&match) == lwc_error_ok && match);
|
|
lwc_string_unref(effective_type);
|
|
|
|
/* unknown header type, sniffable data and sniffing allowed */
|
|
err = mimesniff_compute_effective_type("*/*",
|
|
match_unknown_riff_tests[0].data,
|
|
match_unknown_riff_tests[0].len,
|
|
true,
|
|
false,
|
|
&effective_type);
|
|
ck_assert_int_eq(err, NSERROR_OK);
|
|
|
|
ck_assert(lwc_string_caseless_isequal(effective_type,
|
|
*match_unknown_riff_tests[0].mime_type,
|
|
&match) == lwc_error_ok && match);
|
|
lwc_string_unref(effective_type);
|
|
|
|
}
|
|
END_TEST
|
|
|
|
|
|
START_TEST(mimesniff_plusxml_header_sniff_test)
|
|
{
|
|
nserror err;
|
|
lwc_string *effective_type;
|
|
bool match;
|
|
|
|
/* unknown header type, sniffable data and sniffing allowed */
|
|
err = mimesniff_compute_effective_type("image/svg+xml",
|
|
NULL,
|
|
0,
|
|
true,
|
|
false,
|
|
&effective_type);
|
|
ck_assert_int_eq(err, NSERROR_OK);
|
|
|
|
ck_assert(lwc_string_caseless_isequal(effective_type,
|
|
corestring_lwc_image_svg,
|
|
&match) == lwc_error_ok && match);
|
|
lwc_string_unref(effective_type);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(mimesniff_xml_header_sniff_test)
|
|
{
|
|
nserror err;
|
|
lwc_string *effective_type;
|
|
bool match;
|
|
|
|
err = mimesniff_compute_effective_type("text/xml",
|
|
NULL,
|
|
0,
|
|
true,
|
|
false,
|
|
&effective_type);
|
|
ck_assert_int_eq(err, NSERROR_OK);
|
|
|
|
ck_assert(lwc_string_caseless_isequal(effective_type,
|
|
corestring_lwc_text_xml,
|
|
&match) == lwc_error_ok && match);
|
|
lwc_string_unref(effective_type);
|
|
|
|
err = mimesniff_compute_effective_type("application/xml",
|
|
NULL,
|
|
0,
|
|
true,
|
|
false,
|
|
&effective_type);
|
|
ck_assert_int_eq(err, NSERROR_OK);
|
|
|
|
ck_assert(lwc_string_caseless_isequal(effective_type,
|
|
corestring_lwc_application_xml,
|
|
&match) == lwc_error_ok && match);
|
|
lwc_string_unref(effective_type);
|
|
|
|
}
|
|
END_TEST
|
|
|
|
|
|
START_TEST(mimesniff_supported_image_header_sniff_test)
|
|
{
|
|
nserror err;
|
|
lwc_string *effective_type;
|
|
bool match;
|
|
|
|
err = mimesniff_compute_effective_type("image/gif",
|
|
NULL,
|
|
0,
|
|
true,
|
|
false,
|
|
&effective_type);
|
|
ck_assert_int_eq(err, NSERROR_NEED_DATA);
|
|
|
|
err = mimesniff_compute_effective_type("image/gif",
|
|
match_unknown_exact_tests[0].data,
|
|
match_unknown_exact_tests[0].len,
|
|
true,
|
|
false,
|
|
&effective_type);
|
|
ck_assert_int_eq(err, NSERROR_OK);
|
|
|
|
ck_assert(lwc_string_caseless_isequal(effective_type,
|
|
corestring_lwc_image_gif,
|
|
&match) == lwc_error_ok && match);
|
|
lwc_string_unref(effective_type);
|
|
}
|
|
END_TEST
|
|
|
|
|
|
START_TEST(mimesniff_html_header_sniff_test)
|
|
{
|
|
nserror err;
|
|
lwc_string *effective_type;
|
|
|
|
err = mimesniff_compute_effective_type("text/html",
|
|
NULL,
|
|
0,
|
|
true,
|
|
false,
|
|
&effective_type);
|
|
ck_assert_int_eq(err, NSERROR_NEED_DATA);
|
|
}
|
|
END_TEST
|
|
|
|
|
|
#define SIG(s,m,a) { (const uint8_t *)s, SLEN(s), &corestring_lwc_##m, a }
|
|
static struct test_mimetype text_html_header_tests[] = {
|
|
SIG("text", text_html, true),
|
|
SIG("\xef\xbb\xbf\t\n\r <!-- a comment --><!DOCTYPE HTML><?pi?><head>", text_html, true),
|
|
SIG("\xef\xbb\xbf\t\n\r <!DOCTYPE HTML><?pi?><rss version=\"2.0\">", application_rss_xml, true),
|
|
SIG("\t\n\r <? pi ?><feed>", application_atom_xml, true),
|
|
SIG("<rdf:RDF xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\" xmlns=\"http://purl.org/rss/1.0\">", application_rss_xml, true),
|
|
SIG("<rdf:RDF xmlns=\"http://purl.org/rss/1.0\">", text_html, true),
|
|
SIG("<rdf:RDF xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\">", text_html, true),
|
|
};
|
|
#undef SIG
|
|
|
|
|
|
START_TEST(mimesniff_text_html_header_sniff_test)
|
|
{
|
|
nserror err;
|
|
const struct test_mimetype *tst = &text_html_header_tests[_i];
|
|
lwc_string *effective_type;
|
|
bool match;
|
|
|
|
err = mimesniff_compute_effective_type("text/html",
|
|
tst->data,
|
|
tst->len,
|
|
true,
|
|
false,
|
|
&effective_type);
|
|
ck_assert_int_eq(err, NSERROR_OK);
|
|
|
|
ck_assert(lwc_string_caseless_isequal(effective_type,
|
|
*(tst->mime_type),
|
|
&match) == lwc_error_ok && match);
|
|
lwc_string_unref(effective_type);
|
|
|
|
}
|
|
END_TEST
|
|
|
|
|
|
START_TEST(mimesniff_text_fancy_header_sniff_test)
|
|
{
|
|
nserror err;
|
|
lwc_string *effective_type;
|
|
lwc_string *text_fancy;
|
|
bool match;
|
|
|
|
ck_assert(lwc_intern_string("text/fancy", SLEN("text/fancy"), &text_fancy) == lwc_error_ok);
|
|
|
|
err = mimesniff_compute_effective_type("text/fancy",
|
|
NULL,
|
|
0,
|
|
true,
|
|
false,
|
|
&effective_type);
|
|
ck_assert_int_eq(err, NSERROR_OK);
|
|
|
|
ck_assert(lwc_string_caseless_isequal(effective_type,
|
|
text_fancy,
|
|
&match) == lwc_error_ok && match);
|
|
|
|
lwc_string_unref(effective_type);
|
|
lwc_string_unref(text_fancy);
|
|
}
|
|
END_TEST
|
|
|
|
|
|
/* test cases with header mime type */
|
|
static TCase *mimesniff_header_case_create(void)
|
|
{
|
|
TCase *tc;
|
|
tc = tcase_create("mimesniff header");
|
|
|
|
tcase_add_unchecked_fixture(tc,
|
|
corestring_create,
|
|
corestring_teardown);
|
|
|
|
tcase_add_test(tc, mimesniff_unparsable_header_test);
|
|
tcase_add_test(tc, mimesniff_parsable_header_nosniff_test);
|
|
tcase_add_test(tc, mimesniff_svg_header_sniff_imageonly_test);
|
|
tcase_add_test(tc, mimesniff_image_header_sniff_imageonly_test);
|
|
tcase_add_test(tc, mimesniff_text_header_nodata_sniff_test);
|
|
tcase_add_loop_test(tc,
|
|
mimesniff_text_header_sniff_test,
|
|
0, NELEMS(text_header_tests));
|
|
tcase_add_test(tc, mimesniff_unknown_header_sniff_test);
|
|
tcase_add_test(tc, mimesniff_plusxml_header_sniff_test);
|
|
tcase_add_test(tc, mimesniff_xml_header_sniff_test);
|
|
tcase_add_test(tc, mimesniff_supported_image_header_sniff_test);
|
|
|
|
tcase_add_test(tc, mimesniff_html_header_sniff_test);
|
|
tcase_add_loop_test(tc,
|
|
mimesniff_text_html_header_sniff_test,
|
|
0, NELEMS(text_html_header_tests));
|
|
|
|
tcase_add_test(tc, mimesniff_text_fancy_header_sniff_test);
|
|
|
|
return tc;
|
|
}
|
|
|
|
|
|
static Suite *mimesniff_suite_create(void)
|
|
{
|
|
Suite *s;
|
|
s = suite_create("mime sniffing");
|
|
|
|
suite_add_tcase(s, mimesniff_api_case_create());
|
|
suite_add_tcase(s, mimesniff_match_unknown_case_create());
|
|
suite_add_tcase(s, mimesniff_header_case_create());
|
|
|
|
return s;
|
|
}
|
|
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
int number_failed;
|
|
SRunner *sr;
|
|
|
|
sr = srunner_create(mimesniff_suite_create());
|
|
|
|
srunner_run_all(sr, CK_ENV);
|
|
|
|
number_failed = srunner_ntests_failed(sr);
|
|
srunner_free(sr);
|
|
|
|
return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
|
|
}
|