Subversion Repositories Kolibri OS

/*

 * Copyright 2011 John-Mark Bell 

 *

 * 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 .

 */

/** \file

 * MIME type sniffer (implementation)

 *

 * Spec version: 2011-11-27

 */

#include

#include "content/content_factory.h"

#include "content/llcache.h"

#include "content/mimesniff.h"

#include "utils/http.h"

#include "utils/utils.h"

struct map_s {

	const uint8_t *sig;

	size_t len;

	bool safe;

	lwc_string **type;

};

static lwc_string *unknown_unknown;

static lwc_string *application_unknown;

static lwc_string *any;

static lwc_string *text_xml;

static lwc_string *application_xml;

static lwc_string *text_html;

static lwc_string *text_plain;

static lwc_string *application_octet_stream;

static lwc_string *image_gif;

static lwc_string *image_png;

static lwc_string *image_jpeg;

static lwc_string *image_bmp;

static lwc_string *image_vnd_microsoft_icon;

static lwc_string *image_webp;

static lwc_string *application_rss_xml;

static lwc_string *application_atom_xml;

static lwc_string *audio_wave;

static lwc_string *application_ogg;

static lwc_string *video_webm;

static lwc_string *application_x_rar_compressed;

static lwc_string *application_zip;

static lwc_string *application_x_gzip;

static lwc_string *application_postscript;

static lwc_string *application_pdf;

static lwc_string *video_mp4;

static lwc_string *image_svg;

nserror mimesniff_init(void)

{

	lwc_error lerror;

#define SINIT(v, s) \

	lerror = lwc_intern_string(s, SLEN(s), &v); \

	if (lerror != lwc_error_ok) \

		return NSERROR_NOMEM

	SINIT(unknown_unknown,              "unknown/unknown");

	SINIT(application_unknown,          "application/unknown");

	SINIT(any,                          "*/*");

	SINIT(text_xml,                     "text/xml");

	SINIT(application_xml,              "application/xml");

	SINIT(text_html,                    "text/html");

	SINIT(text_plain,                   "text/plain");

	SINIT(application_octet_stream,     "application/octet-stream");

	SINIT(image_gif,                    "image/gif");

	SINIT(image_png,                    "image/png");

	SINIT(image_jpeg,                   "image/jpeg");

	SINIT(image_bmp,                    "image/bmp");

	SINIT(image_vnd_microsoft_icon,     "image/vnd.microsoft.icon");

	SINIT(image_webp,                   "image/webp");

	SINIT(application_rss_xml,          "application/rss+xml");

	SINIT(application_atom_xml,         "application/atom+xml");

	SINIT(audio_wave,                   "audio/wave");

	SINIT(application_ogg,              "application/ogg");

	SINIT(video_webm,                   "video/webm");

	SINIT(application_x_rar_compressed, "application/x-rar-compressed");

	SINIT(application_zip,              "application/zip");

	SINIT(application_x_gzip,           "application/x-gzip");

	SINIT(application_postscript,       "application/postscript");

	SINIT(application_pdf,              "application/pdf");

	SINIT(video_mp4,                    "video/mp4");

	SINIT(image_svg,                    "image/svg+xml");

#undef SINIT

	return NSERROR_OK;

}

void mimesniff_fini(void)

{

	lwc_string_unref(image_svg);

	lwc_string_unref(video_mp4);

	lwc_string_unref(application_pdf);

	lwc_string_unref(application_postscript);

	lwc_string_unref(application_x_gzip);

	lwc_string_unref(application_zip);

	lwc_string_unref(application_x_rar_compressed);

	lwc_string_unref(video_webm);

	lwc_string_unref(application_ogg);

	lwc_string_unref(audio_wave);

	lwc_string_unref(application_atom_xml);

	lwc_string_unref(application_rss_xml);

	lwc_string_unref(image_webp);

	lwc_string_unref(image_vnd_microsoft_icon);

	lwc_string_unref(image_bmp);

	lwc_string_unref(image_jpeg);

	lwc_string_unref(image_png);

	lwc_string_unref(image_gif);

	lwc_string_unref(application_octet_stream);

	lwc_string_unref(text_plain);

	lwc_string_unref(text_html);

	lwc_string_unref(application_xml);

	lwc_string_unref(text_xml);

	lwc_string_unref(any);

	lwc_string_unref(application_unknown);

	lwc_string_unref(unknown_unknown);

}

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 */

		if (c <= 0x1f && c != 0x1b && c != '\r' && c != '\f' &&

				c != '\n' && c != '\t')

			break;

		data++;

	}

	return data != end;

}

static nserror mimesniff__match_mp4(const uint8_t *data, size_t len,

		lwc_string **effective_type)

{

	size_t box_size, i;

	/* 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[];

	 * }

	 *

	 * 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

	 * sniffing input that contains no boxes other than 'ftyp'.

	 *

	 * 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,

	 * which is decidely unlikely.

	 */

	/* 12 reflects the minimum number of octets needed to sniff useful

	 * information out of an 'ftyp' box (i.e. the size, type,

	 * and major_brand words). */

	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 */

	if (data[4] != 'f' || data[5] != 't' ||

			data[6] != 'y' || data[7] != 'p')

		return NSERROR_NOT_FOUND;

	/* Check if major brand begins with 'mp4' */

	if (data[8] == 'm' && data[9] == 'p' && data[10] == '4') {

		*effective_type = lwc_string_ref(video_mp4);

		return NSERROR_OK;

	}

	/* Search each compatible brand in the box for "mp4" */

	for (i = 16; i <= box_size - 4; i += 4) {

		if (data[i] == 'm' && data[i+1] == 'p' && data[i+2] == '4') {

			*effective_type = lwc_string_ref(video_mp4);

			return NSERROR_OK;

		}

	}

	return NSERROR_NOT_FOUND;

}

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[] = {

		SIG(&text_xml, "

		{ NULL, 0, false, NULL }

	};

	static const struct map_s ws_inexact_match_types[] = {

		SIG(&text_html, "

		SIG(&text_html, "

		SIG(&text_html, "

		SIG(&text_html, "

		SIG(&text_html, "

		SIG(&text_html, "

		SIG(&text_html, "

		SIG(&text_html, "

		SIG(&text_html, "

		SIG(&text_html, "

		SIG(&text_html, "

		SIG(&text_html, "

		SIG(&text_html, "

		SIG(&text_html, "

		SIG(&text_html, "

		SIG(&text_html, "

		SIG(&text_html, "