fork download 
  1. <?php
  2. class MimeTypeDefinition {
  3. 	var $start;
  4. 	var $type;
  5. 	var $pattern;
  6. 	var $mime;
  7.  
  8. 	function  __construct($start, $type, $pattern, $mime)
  9. 	{
  10. 		$this->start = $start;
  11. 		$this->type = $type;
  12. 		$this->pattern = $pattern;
  13. 		$this->mime = $mime;
  14. 	}
  15. }
  16. class MimeChecker {
  17. 	var $data = null;
  18. 	var $types = array();
  19.  
  20. 	function  __construct()
  21. 	{
  22. 	}
  23.  
  24. 	function parse($filepath)
  25. 	{
  26. 		if((!file_exists($filepath)) || (is_dir($filepath)))
  27. 		{
  28. 			return "mimeタイプの定義ファイルが見つかりません。";
  29. 		}
  30.  
  31. 		$this->data = file($filepath);
  32.  
  33. 		$types = array(
  34. 			'byte','short','long','string','date',
  35. 			'beshort','belong','bedate',
  36. 			'leshort','lelong','ledate'
  37. 		);
  38.  
  39. 		$ptn_types = implode('|', $types);
  40.  
  41. 		foreach($this->data as $line)
  42. 		{
  43. 			if(preg_match('/^#/', $line))
  44. 			{	
  45. 				continue;
  46. 			}
  47.  
  48. 			if(preg_match(
  49. 				'/^(>?\d+)\s+(' . $ptn_types . ')\s+((\x5c |[^\s])*)\s+([^\s]+)?/',
  50. 				 $line, $match) == 0)
  51. 			{
  52. 				continue;
  53. 			}
  54. 			else
  55. 			{
  56. 				if(empty($match[5]))
  57. 				{
  58. 					$match[5] = null;
  59. 				}
  60.  
  61. 				$this->types[] = new MimeTypeDefinition($match[1], $match[2], $match[3], $match[5]);
  62. 			}
  63. 		}
  64.  
  65. 		return false;
  66. 	}
  67.  
  68. 	function getMime($path)
  69. 	{
  70. 		if(empty($this->data))
  71. 		{
  72. 			return false;
  73. 		}
  74.  
  75. 		if((!file_exists($path)) || (is_dir($path)))
  76. 		{
  77. 			return false;
  78. 		}
  79.  
  80. 		$mime = null;
  81. 		$fp = fopen($path, "rb");
  82.  
  83. 		$count = count($this->types);
  84.  
  85. 		for($i = 0; $i < $count;)
  86. 		{
  87. 			$start = $this->types[$i]->start;
  88.  
  89. 			if(preg_match('/^\d+$/', $start) > 0)
  90. 			{
  91. 				$mime = $this->checkMime($fp, $i);
  92. 				$i++;
  93.  
  94. 				if($mime)
  95. 				{
  96. 					return trim($mime);
  97. 				}
  98. 			}
  99. 			else
  100. 			{
  101. 				$i++;
  102. 			}
  103. 		}
  104.  
  105. 		if(!$mime)
  106. 		{
  107. 			return 'application/octet-stream';
  108. 		}
  109. 	}
  110.  
  111. 	function checkMime($fp, $i)
  112. 	{
  113. 		$ismatch = false;
  114.  
  115. 		switch($this->types[$i]->type)
  116. 		{
  117. 			case "byte" : 
  118. 				$ismatch = $this->checkByte($fp, $this->types[$i]);
  119. 			break;
  120. 			case "short" : 
  121. 				$ismatch = $this->checkShort($fp, $this->types[$i]);
  122. 			break;
  123. 			case "long" : 
  124. 				$ismatch = $this->checkLong($fp, $this->types[$i]);
  125. 			break;
  126. 			case "string" : 
  127. 				$ismatch = $this->checkStr($fp, $this->types[$i]);
  128. 			break;
  129. 			case "date" : 
  130. 				$ismatch = $this->checkTime($fp, $this->types[$i]);
  131. 			break;
  132. 			case "beshort" : 
  133. 				$ismatch = $this->checkBeShort($fp, $this->types[$i]);
  134. 			break;
  135. 			case "belong" : 
  136. 				$ismatch = $this->checkBeLong($fp, $this->types[$i]);
  137. 			break;
  138. 			case "bedate" : 
  139. 				$ismatch = $this->checkBeTime($fp, $this->types[$i]);
  140. 			break;
  141. 			case "leshort" : 
  142. 				$ismatch = $this->checkLeShort($fp, $this->types[$i]);
  143. 			break;
  144. 			case "lelong" : 
  145. 				$ismatch = $this->checkLeLong($fp, $this->types[$i]);
  146. 			break;
  147. 			case "ledate" : 
  148. 				$ismatch = $this->checkLeTime($fp, $this->types[$i]);
  149. 			break;
  150. 		}
  151.  
  152. 		if((!$ismatch) && (preg_match('/^\d+$/', $this->types[$i]->start) > 0))
  153. 		{
  154. 			return null;
  155. 		}
  156.  
  157. 		if(isset($this->types[$i]->mime))
  158. 		{
  159. 			return $this->types[$i]->mime;
  160. 		}
  161.  
  162. 		$count = count($this->types);
  163.  
  164. 		for($i++; $i < $count; $i++)
  165. 		{
  166. 			if(preg_match('/^\d+$/', $this->types[$i]->start) > 0)
  167. 			{
  168. 				return null;
  169. 			}
  170. 			else
  171. 			{
  172. 				$mime = $this->checkMime($fp, $i);
  173.  
  174. 				if($mime)
  175. 				{
  176. 					return $mime;
  177. 				}
  178. 			}
  179. 		}
  180. 	}
  181.  
  182. 	function checkByte($fp, $type)
  183. 	{
  184. 		$start = $type->start;
  185.  
  186. 		if($type->pattern == "x")
  187. 		{
  188. 			return true;
  189. 		}
  190. 		else if(preg_match('/^(=|<|>|&|^|~)?(0?x?[\da-f]+)$/i', $type->pattern, $match) == 0)
  191. 		{
  192. 			return false;
  193. 		}
  194.  
  195. 		if(empty($match[1]))
  196. 		{
  197. 			$match[1] = null;
  198. 		}
  199.  
  200. 		fseek($fp, $start);
  201. 		$data = fread($fp, 1);
  202.  
  203. 		return $this->checkInt($match[1], $match[2], $data);
  204.  
  205. 	}
  206.  
  207. 	function checkShort($fp, $type)
  208. 	{
  209. 		$start = $type->start;
  210.  
  211. 		if($type->pattern == "x")
  212. 		{
  213. 			return true;
  214. 		}
  215. 		else if(preg_match('/^(=|<|>|&|^|~)?(0?x?[\da-f]+)$/i', $type->pattern, $match) == 0)
  216. 		{
  217. 			return false;
  218. 		}
  219.  
  220. 		if(empty($match[1]))
  221. 		{
  222. 			$match[1] = null;
  223. 		}
  224.  
  225. 		fseek($fp, $start);
  226. 		$data = fread($fp, 2);
  227.  
  228. 		return $this->checkInt($match[1], $match[2], $data);
  229.  
  230. 	}
  231.  
  232. 	function checkLong($fp, $type)
  233. 	{
  234. 		$start = $type->start;
  235.  
  236. 		if($type->pattern == "x")
  237. 		{
  238. 			return true;
  239. 		}
  240. 		else if(preg_match('/^(=|<|>|&|^|~)?(0?x?[\da-f]+)$/i', $type->pattern, $match) == 0)
  241. 		{
  242. 			return false;
  243. 		}
  244.  
  245. 		if(empty($match[1]))
  246. 		{
  247. 			$match[1] = null;
  248. 		}
  249.  
  250. 		fseek($fp, $start);
  251. 		$data = fread($fp, 4);
  252.  
  253. 		return $this->checkInt($match[1], $match[2], $data);
  254.  
  255. 	}
  256.  
  257. 	function checkInt($mode, $num, $data, $packfmt = null)
  258. 	{
  259. 		if(preg_match('/^0x([\da-f]+)$/i', $num, $match) > 0)
  260. 		{
  261. 			$num = intval($match[1], 16);
  262. 		}
  263. 		else if(preg_match('/^0(\d+)$/', $num, $match) > 0)
  264. 		{
  265. 			$num = intval($match[1], 8);
  266. 		}
  267. 		else if(preg_match('/^(\d+)$/', $num, $match) > 0)
  268. 		{
  269. 			$num = intval($num, 10);
  270. 		}
  271. 		else
  272. 		{
  273. 			return false;
  274. 		}
  275.  
  276. 		if($packfmt)
  277. 		{
  278. 			switch($packfmt)
  279. 			{
  280. 				case "n" :
  281. 				break;
  282.  
  283. 				case "N" :
  284. 				break;
  285.  
  286. 				case "v" :
  287. 				break;
  288.  
  289. 				case "V" :
  290. 				break;
  291.  
  292. 				default:
  293. 				 return false;
  294. 			}
  295.  
  296. 			$num = pack($packfmt, $num);
  297. 		}
  298.  
  299. 		if(empty($mode) || ($mode == "="))
  300. 		{
  301. 			if($data == $num)
  302. 			{
  303. 				return true;
  304. 			}
  305. 		}
  306. 		else if($mode == "<")
  307. 		{
  308. 			if($data < $num)
  309. 			{
  310. 				return true;
  311. 			}
  312. 		}
  313. 		else if($mode == ">")
  314. 		{
  315. 			if($data > $num)
  316. 			{
  317. 				return true;
  318. 			}
  319. 		}
  320. 		else if($mode == "&")
  321. 		{
  322. 			if(($data & $num) == $num)
  323. 			{
  324. 				return true;
  325. 			}
  326. 		}
  327. 		else if($mode == "^")
  328. 		{
  329. 			if(($data & $num) != $num)
  330. 			{
  331. 				return true;
  332. 			}
  333. 		}
  334. 		else if($mode == "~")
  335. 		{
  336. 			if($data == ~$num)
  337. 			{
  338. 				return true;
  339. 			}
  340. 		}
  341.  
  342. 		return false;
  343. 	}
  344.  
  345. 	function checkStr($fp, $type)
  346. 	{
  347. 		$start = $type->start;
  348.  
  349. 		if(preg_match('/^(=|<|>)?((\x5c |[^\s])*)$/i', $type->pattern, $match) == 0)
  350. 		{
  351. 			return false;
  352. 		}
  353.  
  354. 		if(empty($match[1]))
  355. 		{
  356. 			$match[1] = null;
  357. 		}
  358.  
  359. 		$match[2] = preg_replace('/\x5c /', ' ', $match[2]);
  360. 		$match[2] = preg_replace('/\x5c</', '<', $match[2]);
  361. 		$match[2] = preg_replace('/\x5c>/', '>', $match[2]);
  362. 		$match[2] = preg_replace('/\x5c=/', '=', $match[2]);
  363.  
  364. 		$ptn = $this->unescape($match[2]);
  365. 		$len = strlen($ptn);
  366.  
  367. 		fseek($fp, $start);
  368. 		$data = fread($fp, $len);
  369.  
  370. 		if(empty($match[1]) || ($match[1] == "="))
  371. 		{
  372. 			if(($match[0] == '=\0') && ($data == ""))
  373. 			{
  374. 				return true;
  375. 			}
  376. 			else if($data == $ptn)
  377. 			{
  378. 				return true;
  379. 			}
  380. 			else
  381. 			{
  382. 				return false;
  383. 			}
  384.  
  385. 		}
  386. 		else if($match[1] == "<")
  387. 		{
  388. 			if(strcmp($data, $ptn) < 0)
  389. 			{
  390. 				return true;
  391. 			}
  392. 			else
  393. 			{
  394. 				return false;
  395. 			}
  396. 		}
  397. 		else if($match[1] == ">")
  398. 		{
  399. 			if(($match[0] == '>\0') && ($data != ""))
  400. 			{
  401. 				return true;
  402. 			}
  403. 			else if(strcmp($data, $ptn) > 0)
  404. 			{
  405. 				return true;
  406. 			}
  407. 			else
  408. 			{
  409. 				return false;
  410. 			}
  411. 		}
  412. 	}
  413.  
  414. 	function checkTime($fp, $type)
  415. 	{
  416. 		$start = $type->start;
  417.  
  418. 		fseek($fp, $start);
  419. 		$data = fread($fp, 4);
  420.  
  421. 		if(intval($data) == intval($this->pattern))
  422. 		{
  423. 			return true;
  424. 		}
  425. 		else
  426. 		{
  427. 			return false;
  428. 		}
  429. 	}
  430.  
  431. 	function checkBeShort($fp, $type)
  432. 	{
  433. 		$start = $type->start;
  434.  
  435. 		if($type->pattern == "x")
  436. 		{
  437. 			return true;
  438. 		}
  439. 		else if(preg_match('/^(=|<|>|&|^|~)?(0?x?[\da-f]+)$/i', $type->pattern, $match) == 0)
  440. 		{
  441. 			return false;
  442. 		}
  443.  
  444. 		if(empty($match[1]))
  445. 		{
  446. 			$match[1] = null;
  447. 		}
  448.  
  449. 		fseek($fp, $start);
  450. 		$data = fread($fp, 2);
  451.  
  452. 		return $this->checkInt($match[1], $match[2], $data, "n");
  453.  
  454. 	}
  455.  
  456. 	function checkBeLong($fp, $type)
  457. 	{
  458. 		$start = $type->start;
  459.  
  460. 		if($type->pattern == "x")
  461. 		{
  462. 			return true;
  463. 		}
  464. 		else if(preg_match('/^(=|<|>|&|^|~)?(0?x?[\da-f]+)$/i', $type->pattern, $match) == 0)
  465. 		{
  466. 			return false;
  467. 		}
  468.  
  469. 		if(empty($match[1]))
  470. 		{
  471. 			$match[1] = null;
  472. 		}
  473.  
  474. 		fseek($fp, $start);
  475. 		$data = fread($fp, 4);
  476.  
  477. 		return $this->checkInt($match[1], $match[2], $data, "N");
  478.  
  479. 	}
  480.  
  481. 	function checkBeTime($fp, $type)
  482. 	{
  483. 		$start = $type->start;
  484.  
  485. 		fseek($fp, $start);
  486. 		$data = fread($fp, 4);
  487.  
  488. 		if(pack("N", intval($data)) == intval($this->pattern))
  489. 		{
  490. 			return true;
  491. 		}
  492. 		else
  493. 		{
  494. 			return false;
  495. 		}
  496. 	}
  497.  
  498. 	function checkLeShort($fp, $type)
  499. 	{
  500. 		$start = $type->start;
  501.  
  502. 		if($type->pattern == "x")
  503. 		{
  504. 			return true;
  505. 		}
  506. 		else if(preg_match('/^(=|<|>|&|^|~)?(0?x?[\da-f]+)$/i', $type->pattern, $match) == 0)
  507. 		{
  508. 			return false;
  509. 		}
  510.  
  511. 		if(empty($match[1]))
  512. 		{
  513. 			$match[1] = null;
  514. 		}
  515.  
  516. 		fseek($fp, $start);
  517. 		$data = fread($fp, 2);
  518.  
  519. 		return $this->checkInt($match[1], $match[2], $data, "v");
  520.  
  521. 	}
  522.  
  523. 	function checkLeLong($fp, $type)
  524. 	{
  525. 		$start = $type->start;
  526.  
  527. 		if($type->pattern == "x")
  528. 		{
  529. 			return true;
  530. 		}
  531. 		else if(preg_match('/^(=|<|>|&|^|~)?(0?x?[\da-f]+)$/i', $type->pattern, $match) == 0)
  532. 		{
  533. 			return false;
  534. 		}
  535.  
  536. 		if(empty($match[1]))
  537. 		{
  538. 			$match[1] = null;
  539. 		}
  540.  
  541. 		fseek($fp, $start);
  542. 		$data = fread($fp, 4);
  543.  
  544. 		return $this->checkInt($match[1], $match[2], $data, "V");
  545.  
  546. 	}
  547.  
  548. 	function checkLeTime($fp, $type)
  549. 	{
  550. 		$start = $type->start;
  551.  
  552. 		fseek($fp, $start);
  553. 		$data = fread($fp, 4);
  554.  
  555. 		if(pack("V", intval($data)) == intval($this->pattern))
  556. 		{
  557. 			return true;
  558. 		}
  559. 		else
  560. 		{
  561. 			return false;
  562. 		}
  563. 	}
  564.  
  565. 	function unescape($str)
  566. 	{
  567. 		$ptn = array(
  568. 			'\d{3}', 'x[\da-f]{2}', '0', '01', '02', '03', '04', '05', '06',
  569. 			'a', 'b', 't', 'n', 'v', 'f','r', '\x5c', '\x3f', '"', '\x27', 
  570. 		);
  571. 		$ptn = implode('|', $ptn);
  572.  
  573. 		return preg_replace_callback('/\x5c(' . $ptn . ')/i', //'\\'と記述しても正常に動作しないため、\x5cと記述
  574. 			create_function('$match', 'return MimeChecker::unescapesub($match[1]);'),
  575. 			$str);
  576. 	}
  577.  
  578. 	static function unescapesub($match)
  579. 	{
  580. 		switch($match)
  581. 		{
  582. 			case "0" :
  583. 				return "\0";
  584. 			break;
  585. 			case "01" :
  586. 				return "\01";
  587. 			break;
  588. 			case "02" :
  589. 				return "\02";
  590. 			break;
  591. 			case "03" :
  592. 				return "\03";
  593. 			break;
  594. 			case "04" :
  595. 				return "\04";
  596. 			break;
  597. 			case "05" :
  598. 				return "\05";
  599. 			break;
  600. 			case "06" :
  601. 				return "\06";
  602. 			break;
  603. 			case "a" :
  604. 				return "\a";
  605. 			break;
  606. 			case "b" :
  607. 				return "\b";
  608. 			break;
  609. 			case "t" :
  610. 				return "\t";
  611. 			break;
  612. 			case "n" :
  613. 				return "\n";
  614. 			break;
  615. 			case "v" :
  616. 				return "\v";
  617. 			break;
  618. 			case "f" :
  619. 				return "\f";
  620. 			break;
  621. 			case "r" :
  622. 				return "\r";
  623. 			break;
  624. 			case "\x5c" :
  625. 				return "\x5c";
  626. 			break;
  627. 			case "?" :
  628. 				return "?";
  629. 			break;
  630. 			case "'" :
  631. 				return "'";
  632. 			break;
  633. 			case '"' :
  634. 				return '"';
  635. 			break;
  636. 		}
  637.  
  638. 		if(preg_match('/^(\d{3})$/', $match, $submatch) > 0)
  639. 		{
  640. 			return pack("C", intval($submatch[1], 8));
  641. 		}
  642. 		else if(preg_match('/^x([\da-f]{2})$/i', $match, $submatch) > 0)
  643. 		{
  644. 			return pack("C", intval($submatch[1], 16));
  645. 		}
  646. 	}
  647. }
  648. ?>
Success #stdin #stdout 0.02s 13112KB
comments (?)
stdin 
Standard input is empty
stdout 
Standard output is empty
https://ideone.com/IVppt
language:
PHP (php 7.3.5)
created:
13 years ago
visibility:
secret

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!