nilsteampassnet / TeamPass

includes/libraries/Authentication/agses/axs/AXSILPortal_V1_Auth.php

Indentation +39 added lines, -39 removed lines

@@ -1,58 +1,58 @@
 <?php 
 class AXSILPortal_V1_Auth { 
-	var $server;
+    var $server;
 
-	private $url = "";
-	private $AAId = "";
-	private $apiKey = "";
+    private $url = "";
+    private $AAId = "";
+    private $apiKey = "";
 	
-	private $baseUrl = "";
+    private $baseUrl = "";
 	
-	function setUrl($url) {
-		$this->url = $url;
-	}
+    function setUrl($url) {
+        $this->url = $url;
+    }
 	
-	function setAAId($AAId) {
-		$this->AAId = $AAId;
-	}
+    function setAAId($AAId) {
+        $this->AAId = $AAId;
+    }
 	
-	function setApiKey($apiKey) {
-		$this->apiKey = $apiKey;
-	}
+    function setApiKey($apiKey) {
+        $this->apiKey = $apiKey;
+    }
 	
 	
-	// Verify that you can open the URL from the web server.
-	function create() { 
-		if ($this->url != "" && $this->AAId != "" && $this->apiKey != "") {
-			$this->baseUrl = $this->url."".$this->apiKey."/".$this->AAId;
-		} else {
-			die("Cannot initialize Agses webservice without credentials, please set them in settings");
-		}
-	}
+    // Verify that you can open the URL from the web server.
+    function create() { 
+        if ($this->url != "" && $this->AAId != "" && $this->apiKey != "") {
+            $this->baseUrl = $this->url."".$this->apiKey."/".$this->AAId;
+        } else {
+            die("Cannot initialize Agses webservice without credentials, please set them in settings");
+        }
+    }
 	
-	function createAuthenticationMessage($apn, $createFlickerCode, $returnPath, $authenticationLevel, $hedgeId) {
+    function createAuthenticationMessage($apn, $createFlickerCode, $returnPath, $authenticationLevel, $hedgeId) {
 		
-		$serviceCall = $this->baseUrl."/authmessage/".$apn."/create/".$hedgeId;
+        $serviceCall = $this->baseUrl."/authmessage/".$apn."/create/".$hedgeId;
 		
-		$json = file_get_contents($serviceCall);
-		$response = json_decode($json, true);		
+        $json = file_get_contents($serviceCall);
+        $response = json_decode($json, true);		
 		
-		return $response['flickerCode'];
-	}
-	
-	/**
-	 * @param string $response
-	 * @param string $hedgeId
-	 */
-	function verifyResponse($apn, $response, $hedgeId) {
+        return $response['flickerCode'];
+    }
+	
+    /**
+     * @param string $response
+     * @param string $hedgeId
+     */
+    function verifyResponse($apn, $response, $hedgeId) {
 		
-		$serviceCall = $this->baseUrl."/authmessage/".$apn."/verify/".$hedgeId."/".$response;
+        $serviceCall = $this->baseUrl."/authmessage/".$apn."/verify/".$hedgeId."/".$response;
 		
-		$json = file_get_contents($serviceCall);
-		$response = json_decode($json, true);
+        $json = file_get_contents($serviceCall);
+        $response = json_decode($json, true);
 		
-		return $response['response'];
-	}
+        return $response['response'];
+    }
 
 } 
 ?>
\ No newline at end of file

includes/libraries/Pdf/Tfpdf/font/courieri.php

Indentation +1 added lines, -1 removed lines

@@ -4,5 +4,5 @@
 $up = -100;
 $ut = 50;
 for ($i = 0; $i <= 255; $i++)
-	$cw[chr($i)] = 600;
+    $cw[chr($i)] = 600;
 ?>

includes/libraries/Pdf/Tfpdf/font/courierbi.php

Indentation +1 added lines, -1 removed lines

@@ -4,5 +4,5 @@
 $up = -100;
 $ut = 50;
 for ($i = 0; $i <= 255; $i++)
-	$cw[chr($i)] = 600;
+    $cw[chr($i)] = 600;
 ?>

includes/libraries/Pdf/Tfpdf/font/unifont/ttfonts.php

Indentation +1036 added lines, -1036 removed lines

@@ -69,41 +69,41 @@ 
 var $defaultWidth;
 var $maxStrLenRead;
 
-	function __construct() {
-		$this->maxStrLenRead = 200000;	// Maximum size of glyf table to read in as string (otherwise reads each glyph from file)
-	}
-
-
-	/**
-	 * @param string $file
-	 */
-	function getMetrics($file) {
-		$this->filename = $file;
-		$this->fh = fopen($file,'rb') or die('Can\'t open file ' . $file);
-		$this->_pos = 0;
-		$this->charWidths = '';
-		$this->glyphPos = array();
-		$this->charToGlyph = array();
-		$this->tables = array();
-		$this->otables = array();
-		$this->ascent = 0;
-		$this->descent = 0;
-		$this->TTCFonts = array();
-		$this->version = $version = $this->read_ulong();
-		if ($version == 0x4F54544F) 
-			die("Postscript outlines are not supported");
-		if ($version == 0x74746366) 
-			die("ERROR - TrueType Fonts Collections not supported");
-		if (!in_array($version, array(0x00010000, 0x74727565)))
-			die("Not a TrueType font: version=".$version);
-		$this->readTableDirectory();
-		$this->extractInfo();
-		fclose($this->fh);
-	}
-
-
-	function readTableDirectory() {
-	    $this->numTables = $this->read_ushort();
+    function __construct() {
+        $this->maxStrLenRead = 200000;	// Maximum size of glyf table to read in as string (otherwise reads each glyph from file)
+    }
+
+
+    /**
+     * @param string $file
+     */
+    function getMetrics($file) {
+        $this->filename = $file;
+        $this->fh = fopen($file,'rb') or die('Can\'t open file ' . $file);
+        $this->_pos = 0;
+        $this->charWidths = '';
+        $this->glyphPos = array();
+        $this->charToGlyph = array();
+        $this->tables = array();
+        $this->otables = array();
+        $this->ascent = 0;
+        $this->descent = 0;
+        $this->TTCFonts = array();
+        $this->version = $version = $this->read_ulong();
+        if ($version == 0x4F54544F) 
+            die("Postscript outlines are not supported");
+        if ($version == 0x74746366) 
+            die("ERROR - TrueType Fonts Collections not supported");
+        if (!in_array($version, array(0x00010000, 0x74727565)))
+            die("Not a TrueType font: version=".$version);
+        $this->readTableDirectory();
+        $this->extractInfo();
+        fclose($this->fh);
+    }
+
+
+    function readTableDirectory() {
+        $this->numTables = $this->read_ushort();
             $this->searchRange = $this->read_ushort();
             $this->entrySelector = $this->read_ushort();
             $this->rangeShift = $this->read_ushort();
@@ -115,178 +115,178 @@ 
                 $record['offset'] = $this->read_ulong();
                 $record['length'] = $this->read_ulong();
                 $this->tables[$record['tag']] = $record;
-		}
-	}
-
-
-	/**
-	 * @param integer[] $x
-	 * @param integer[] $y
-	 */
-	function sub32($x, $y) {
-		$xlo = $x[1];
-		$xhi = $x[0];
-		$ylo = $y[1];
-		$yhi = $y[0];
-		if ($ylo > $xlo) { $xlo += 1 << 16; $yhi += 1; }
-		$reslo = $xlo - $ylo;
-		if ($yhi > $xhi) { $xhi += 1 << 16; }
-		$reshi = $xhi - $yhi;
-		$reshi = $reshi & 0xFFFF;
-		return array($reshi, $reslo);
-	}
-
-	function calcChecksum($data) {
-		if (strlen($data) % 4) { $data .= str_repeat("\0", (4 - (strlen($data) % 4))); }
-		$hi = 0x0000;
-		$lo = 0x0000;
-		for ($i = 0; $i < strlen($data); $i += 4) {
-			$hi += (ord($data[$i]) << 8) + ord($data[$i + 1]);
-			$lo += (ord($data[$i + 2]) << 8) + ord($data[$i + 3]);
-			$hi += $lo >> 16;
-			$lo = $lo & 0xFFFF;
-			$hi = $hi & 0xFFFF;
-		}
-		return array($hi, $lo);
-	}
-
-	function get_table_pos($tag) {
-		$offset = $this->tables[$tag]['offset'];
-		$length = $this->tables[$tag]['length'];
-		return array($offset, $length);
-	}
-
-	function seek($pos) {
-		$this->_pos = $pos;
-		fseek($this->fh,$this->_pos);
-	}
-
-	/**
-	 * @param integer $delta
-	 */
-	function skip($delta) {
-		$this->_pos = $this->_pos + $delta;
-		fseek($this->fh,$this->_pos);
-	}
-
-	/**
-	 * @param string $tag
-	 */
-	function seek_table($tag, $offset_in_table = 0) {
-		$tpos = $this->get_table_pos($tag);
-		$this->_pos = $tpos[0] + $offset_in_table;
-		fseek($this->fh, $this->_pos);
-		return $this->_pos;
-	}
-
-	function read_tag() {
-		$this->_pos += 4;
-		return fread($this->fh, 4);
-	}
-
-	function read_short() {
-		$this->_pos += 2;
-		$s = fread($this->fh, 2);
-		$a = (ord($s[0]) << 8) + ord($s[1]);
-		if ($a & (1 << 15)) { $a = ($a - (1 << 16)); }
-		return $a;
-	}
-
-	function unpack_short($s) {
-		$a = (ord($s[0]) << 8) + ord($s[1]);
-		if ($a & (1 << 15)) { 
-			$a = ($a - (1 << 16)); 
-		}
-		return $a;
-	}
-
-	function read_ushort() {
-		$this->_pos += 2;
-		$s = fread($this->fh,2);
-		return (ord($s[0])<<8) + ord($s[1]);
-	}
-
-	function read_ulong() {
-		$this->_pos += 4;
-		$s = fread($this->fh,4);
-		// if large uInt32 as an integer, PHP converts it to -ve
-		return (ord($s[0])*16777216) + (ord($s[1])<<16) + (ord($s[2])<<8) + ord($s[3]); // 	16777216  = 1<<24
-	}
-
-	function get_ushort($pos) {
-		fseek($this->fh,$pos);
-		$s = fread($this->fh,2);
-		return (ord($s[0])<<8) + ord($s[1]);
-	}
-
-	function get_ulong($pos) {
-		fseek($this->fh,$pos);
-		$s = fread($this->fh,4);
-		// iF large uInt32 as an integer, PHP converts it to -ve
-		return (ord($s[0])*16777216) + (ord($s[1])<<16) + (ord($s[2])<<8) + ord($s[3]); // 	16777216  = 1<<24
-	}
-
-	function pack_short($val) {
-		if ($val<0) { 
-			$val = abs($val);
-			$val = ~$val;
-			$val += 1;
-		}
-		return pack("n",$val); 
-	}
-
-	/**
-	 * @param string $value
-	 */
-	function splice($stream, $offset, $value) {
-		return substr($stream,0,$offset) . $value . substr($stream,$offset+strlen($value));
-	}
-
-	/**
-	 * @param string|null $stream
-	 * @param integer $offset
-	 */
-	function _set_ushort($stream, $offset, $value) {
-		$up = pack("n", $value);
-		return $this->splice($stream, $offset, $up);
-	}
-
-	function _set_short($stream, $offset, $val) {
-		if ($val<0) { 
-			$val = abs($val);
-			$val = ~$val;
-			$val += 1;
-		}
-		$up = pack("n",$val); 
-		return $this->splice($stream, $offset, $up);
-	}
-
-	function get_chunk($pos, $length) {
-		fseek($this->fh,$pos);
-		if ($length <1) { return ''; }
-		return (fread($this->fh,$length));
-	}
-
-	/**
-	 * @param string $tag
-	 */
-	function get_table($tag) {
-		list($pos, $length) = $this->get_table_pos($tag);
-		if ($length == 0) { die('Truetype font ('.$this->filename.'): error reading table: '.$tag); }
-		fseek($this->fh,$pos);
-		return (fread($this->fh,$length));
-	}
-
-	/**
-	 * @param string $tag
-	 * @param null|string $data
-	 */
-	function add($tag, $data) {
-		if ($tag == 'head') {
-			$data = $this->splice($data, 8, "\0\0\0\0");
-		}
-		$this->otables[$tag] = $data;
-	}
+        }
+    }
+
+
+    /**
+     * @param integer[] $x
+     * @param integer[] $y
+     */
+    function sub32($x, $y) {
+        $xlo = $x[1];
+        $xhi = $x[0];
+        $ylo = $y[1];
+        $yhi = $y[0];
+        if ($ylo > $xlo) { $xlo += 1 << 16; $yhi += 1; }
+        $reslo = $xlo - $ylo;
+        if ($yhi > $xhi) { $xhi += 1 << 16; }
+        $reshi = $xhi - $yhi;
+        $reshi = $reshi & 0xFFFF;
+        return array($reshi, $reslo);
+    }
+
+    function calcChecksum($data) {
+        if (strlen($data) % 4) { $data .= str_repeat("\0", (4 - (strlen($data) % 4))); }
+        $hi = 0x0000;
+        $lo = 0x0000;
+        for ($i = 0; $i < strlen($data); $i += 4) {
+            $hi += (ord($data[$i]) << 8) + ord($data[$i + 1]);
+            $lo += (ord($data[$i + 2]) << 8) + ord($data[$i + 3]);
+            $hi += $lo >> 16;
+            $lo = $lo & 0xFFFF;
+            $hi = $hi & 0xFFFF;
+        }
+        return array($hi, $lo);
+    }
+
+    function get_table_pos($tag) {
+        $offset = $this->tables[$tag]['offset'];
+        $length = $this->tables[$tag]['length'];
+        return array($offset, $length);
+    }
+
+    function seek($pos) {
+        $this->_pos = $pos;
+        fseek($this->fh,$this->_pos);
+    }
+
+    /**
+     * @param integer $delta
+     */
+    function skip($delta) {
+        $this->_pos = $this->_pos + $delta;
+        fseek($this->fh,$this->_pos);
+    }
+
+    /**
+     * @param string $tag
+     */
+    function seek_table($tag, $offset_in_table = 0) {
+        $tpos = $this->get_table_pos($tag);
+        $this->_pos = $tpos[0] + $offset_in_table;
+        fseek($this->fh, $this->_pos);
+        return $this->_pos;
+    }
+
+    function read_tag() {
+        $this->_pos += 4;
+        return fread($this->fh, 4);
+    }
+
+    function read_short() {
+        $this->_pos += 2;
+        $s = fread($this->fh, 2);
+        $a = (ord($s[0]) << 8) + ord($s[1]);
+        if ($a & (1 << 15)) { $a = ($a - (1 << 16)); }
+        return $a;
+    }
+
+    function unpack_short($s) {
+        $a = (ord($s[0]) << 8) + ord($s[1]);
+        if ($a & (1 << 15)) { 
+            $a = ($a - (1 << 16)); 
+        }
+        return $a;
+    }
+
+    function read_ushort() {
+        $this->_pos += 2;
+        $s = fread($this->fh,2);
+        return (ord($s[0])<<8) + ord($s[1]);
+    }
+
+    function read_ulong() {
+        $this->_pos += 4;
+        $s = fread($this->fh,4);
+        // if large uInt32 as an integer, PHP converts it to -ve
+        return (ord($s[0])*16777216) + (ord($s[1])<<16) + (ord($s[2])<<8) + ord($s[3]); // 	16777216  = 1<<24
+    }
+
+    function get_ushort($pos) {
+        fseek($this->fh,$pos);
+        $s = fread($this->fh,2);
+        return (ord($s[0])<<8) + ord($s[1]);
+    }
+
+    function get_ulong($pos) {
+        fseek($this->fh,$pos);
+        $s = fread($this->fh,4);
+        // iF large uInt32 as an integer, PHP converts it to -ve
+        return (ord($s[0])*16777216) + (ord($s[1])<<16) + (ord($s[2])<<8) + ord($s[3]); // 	16777216  = 1<<24
+    }
+
+    function pack_short($val) {
+        if ($val<0) { 
+            $val = abs($val);
+            $val = ~$val;
+            $val += 1;
+        }
+        return pack("n",$val); 
+    }
+
+    /**
+     * @param string $value
+     */
+    function splice($stream, $offset, $value) {
+        return substr($stream,0,$offset) . $value . substr($stream,$offset+strlen($value));
+    }
+
+    /**
+     * @param string|null $stream
+     * @param integer $offset
+     */
+    function _set_ushort($stream, $offset, $value) {
+        $up = pack("n", $value);
+        return $this->splice($stream, $offset, $up);
+    }
+
+    function _set_short($stream, $offset, $val) {
+        if ($val<0) { 
+            $val = abs($val);
+            $val = ~$val;
+            $val += 1;
+        }
+        $up = pack("n",$val); 
+        return $this->splice($stream, $offset, $up);
+    }
+
+    function get_chunk($pos, $length) {
+        fseek($this->fh,$pos);
+        if ($length <1) { return ''; }
+        return (fread($this->fh,$length));
+    }
+
+    /**
+     * @param string $tag
+     */
+    function get_table($tag) {
+        list($pos, $length) = $this->get_table_pos($tag);
+        if ($length == 0) { die('Truetype font ('.$this->filename.'): error reading table: '.$tag); }
+        fseek($this->fh,$pos);
+        return (fread($this->fh,$length));
+    }
+
+    /**
+     * @param string $tag
+     * @param null|string $data
+     */
+    function add($tag, $data) {
+        if ($tag == 'head') {
+            $data = $this->splice($data, 8, "\0\0\0\0");
+        }
+        $this->otables[$tag] = $data;
+    }
 
 
 
@@ -295,841 +295,841 @@ 
 
 /////////////////////////////////////////////////////////////////////////////////////////
 
-	function extractInfo() {
-		///////////////////////////////////
-		// name - Naming table
-		///////////////////////////////////
-			$this->sFamilyClass = 0;
-			$this->sFamilySubClass = 0;
-
-			$name_offset = $this->seek_table("name");
-			$format = $this->read_ushort();
-			if ($format != 0) {
-							die("Unknown name table format ".$format);
-			}
-			$numRecords = $this->read_ushort();
-			$string_data_offset = $name_offset + $this->read_ushort();
-			$names = array(1=>'', 2=>'', 3=>'', 4=>'', 6=>'');
-			$K = array_keys($names);
-			$nameCount = count($names);
-			for ($i = 0; $i < $numRecords; $i++) {
-				$platformId = $this->read_ushort();
-				$encodingId = $this->read_ushort();
-				$languageId = $this->read_ushort();
-				$nameId = $this->read_ushort();
-				$length = $this->read_ushort();
-				$offset = $this->read_ushort();
-				if (!in_array($nameId, $K)) continue;
-				$N = '';
-				if ($platformId == 3 && $encodingId == 1 && $languageId == 0x409) { // Microsoft, Unicode, US English, PS Name
-					$opos = $this->_pos;
-					$this->seek($string_data_offset + $offset);
-					if ($length % 2 != 0)
-						die("PostScript name is UTF-16BE string of odd length");
-					$length /= 2;
-					$N = '';
-					while ($length > 0) {
-						$char = $this->read_ushort();
-						$N .= (chr($char));
-						$length -= 1;
-					}
-					$this->_pos = $opos;
-					$this->seek($opos);
-				} else if ($platformId == 1 && $encodingId == 0 && $languageId == 0) { // Macintosh, Roman, English, PS Name
-					$opos = $this->_pos;
-					$N = $this->get_chunk($string_data_offset + $offset, $length);
-					$this->_pos = $opos;
-					$this->seek($opos);
-				}
-				if ($N && $names[$nameId] == '') {
-					$names[$nameId] = $N;
-					$nameCount -= 1;
-					if ($nameCount == 0) break;
-				}
-			}
-			if ($names[6])
-				$psName = $names[6];
-			else if ($names[4])
-				$psName = preg_replace('/ /', '-', $names[4]);
-			else if ($names[1])
-				$psName = preg_replace('/ /', '-', $names[1]);
-			else
-				$psName = '';
-			if (!$psName)
-				die("Could not find PostScript font name");
-			$this->name = $psName;
-			if ($names[1]) { $this->familyName = $names[1]; } else { $this->familyName = $psName; }
-			if ($names[2]) { $this->styleName = $names[2]; } else { $this->styleName = 'Regular'; }
-			if ($names[4]) { $this->fullName = $names[4]; } else { $this->fullName = $psName; }
-			if ($names[3]) { $this->uniqueFontID = $names[3]; } else { $this->uniqueFontID = $psName; }
-			if ($names[6]) { $this->fullName = $names[6]; }
-
-		///////////////////////////////////
-		// head - Font header table
-		///////////////////////////////////
-		$this->seek_table("head");
-		$this->skip(18); 
-		$this->unitsPerEm = $unitsPerEm = $this->read_ushort();
-		$scale = 1000 / $unitsPerEm;
-		$this->skip(16);
-		$xMin = $this->read_short();
-		$yMin = $this->read_short();
-		$xMax = $this->read_short();
-		$yMax = $this->read_short();
-		$this->bbox = array(($xMin * $scale), ($yMin * $scale), ($xMax * $scale), ($yMax * $scale));
-		$this->skip(3 * 2);
-		$indexToLocFormat = $this->read_ushort();
-		$glyphDataFormat = $this->read_ushort();
-		if ($glyphDataFormat != 0) {
-					die('Unknown glyph data format '.$glyphDataFormat);
-		}
-
-		///////////////////////////////////
-		// hhea metrics table
-		///////////////////////////////////
-		// ttf2t1 seems to use this value rather than the one in OS/2 - so put in for compatibility
-		if (isset($this->tables["hhea"])) {
-			$this->seek_table("hhea");
-			$this->skip(4);
-			$hheaAscender = $this->read_short();
-			$hheaDescender = $this->read_short();
-			$this->ascent = ($hheaAscender * $scale);
-			$this->descent = ($hheaDescender * $scale);
-		}
-
-		///////////////////////////////////
-		// OS/2 - OS/2 and Windows metrics table
-		///////////////////////////////////
-		if (isset($this->tables["OS/2"])) {
-			$this->seek_table("OS/2");
-			$version = $this->read_ushort();
-			$this->skip(2);
-			$usWeightClass = $this->read_ushort();
-			$this->skip(2);
-			$fsType = $this->read_ushort();
-			if ($fsType == 0x0002 || ($fsType & 0x0300) != 0) {
-				die('ERROR - Font file '.$this->filename.' cannot be embedded due to copyright restrictions.');
-				$this->restrictedUse = true;
-			}
-			$this->skip(20);
-			$sF = $this->read_short();
-			$this->sFamilyClass = ($sF >> 8);
-			$this->sFamilySubClass = ($sF & 0xFF);
-			$this->_pos += 10; //PANOSE = 10 byte length
-			$panose = fread($this->fh, 10);
-			$this->skip(26);
-			$sTypoAscender = $this->read_short();
-			$sTypoDescender = $this->read_short();
-			if (!$this->ascent) $this->ascent = ($sTypoAscender * $scale);
-			if (!$this->descent) $this->descent = ($sTypoDescender * $scale);
-			if ($version > 1) {
-				$this->skip(16);
-				$sCapHeight = $this->read_short();
-				$this->capHeight = ($sCapHeight * $scale);
-			}
-			else {
-				$this->capHeight = $this->ascent;
-			}
-		}
-		else {
-			$usWeightClass = 500;
-			if (!$this->ascent) $this->ascent = ($yMax * $scale);
-			if (!$this->descent) $this->descent = ($yMin * $scale);
-			$this->capHeight = $this->ascent;
-		}
-		$this->stemV = 50 + intval(pow(($usWeightClass / 65.0), 2));
-
-		///////////////////////////////////
-		// post - PostScript table
-		///////////////////////////////////
-		$this->seek_table("post");
-		$this->skip(4); 
-		$this->italicAngle = $this->read_short() + $this->read_ushort() / 65536.0;
-		$this->underlinePosition = $this->read_short() * $scale;
-		$this->underlineThickness = $this->read_short() * $scale;
-		$isFixedPitch = $this->read_ulong();
-
-		$this->flags = 4;
-
-		if ($this->italicAngle != 0) 
-			$this->flags = $this->flags | 64;
-		if ($usWeightClass >= 600)
-			$this->flags = $this->flags | 262144;
-		if ($isFixedPitch)
-			$this->flags = $this->flags | 1;
-
-		///////////////////////////////////
-		// hhea - Horizontal header table
-		///////////////////////////////////
-		$this->seek_table("hhea");
-		$this->skip(32); 
-		$metricDataFormat = $this->read_ushort();
-		if ($metricDataFormat != 0) {
-					die('Unknown horizontal metric data format '.$metricDataFormat);
-		}
-		$numberOfHMetrics = $this->read_ushort();
-		if ($numberOfHMetrics == 0) {
-					die('Number of horizontal metrics is 0');
-		}
-
-		///////////////////////////////////
-		// maxp - Maximum profile table
-		///////////////////////////////////
-		$this->seek_table("maxp");
-		$this->skip(4); 
-		$numGlyphs = $this->read_ushort();
-
-
-		///////////////////////////////////
-		// cmap - Character to glyph index mapping table
-		///////////////////////////////////
-		$cmap_offset = $this->seek_table("cmap");
-		$this->skip(2);
-		$cmapTableCount = $this->read_ushort();
-		$unicode_cmap_offset = 0;
-		for ($i = 0; $i < $cmapTableCount; $i++) {
-			$platformID = $this->read_ushort();
-			$encodingID = $this->read_ushort();
-			$offset = $this->read_ulong();
-			$save_pos = $this->_pos;
-			if (($platformID == 3 && $encodingID == 1) || $platformID == 0) { // Microsoft, Unicode
-				$format = $this->get_ushort($cmap_offset + $offset);
-				if ($format == 4) {
-					if (!$unicode_cmap_offset) $unicode_cmap_offset = $cmap_offset + $offset;
-					break;
-				}
-			}
-			$this->seek($save_pos);
-		}
-		if (!$unicode_cmap_offset)
-			die('Font ('.$this->filename.') does not have cmap for Unicode (platform 3, encoding 1, format 4, or platform 0, any encoding, format 4)');
-
-
-		$glyphToChar = array();
-		$charToGlyph = array();
-		$this->getCMAP4($unicode_cmap_offset, $glyphToChar, $charToGlyph);
-
-		///////////////////////////////////
-		// hmtx - Horizontal metrics table
-		///////////////////////////////////
-		$this->getHMTX($numberOfHMetrics, $numGlyphs, $glyphToChar, $scale);
-
-	}
+    function extractInfo() {
+        ///////////////////////////////////
+        // name - Naming table
+        ///////////////////////////////////
+            $this->sFamilyClass = 0;
+            $this->sFamilySubClass = 0;
+
+            $name_offset = $this->seek_table("name");
+            $format = $this->read_ushort();
+            if ($format != 0) {
+                            die("Unknown name table format ".$format);
+            }
+            $numRecords = $this->read_ushort();
+            $string_data_offset = $name_offset + $this->read_ushort();
+            $names = array(1=>'', 2=>'', 3=>'', 4=>'', 6=>'');
+            $K = array_keys($names);
+            $nameCount = count($names);
+            for ($i = 0; $i < $numRecords; $i++) {
+                $platformId = $this->read_ushort();
+                $encodingId = $this->read_ushort();
+                $languageId = $this->read_ushort();
+                $nameId = $this->read_ushort();
+                $length = $this->read_ushort();
+                $offset = $this->read_ushort();
+                if (!in_array($nameId, $K)) continue;
+                $N = '';
+                if ($platformId == 3 && $encodingId == 1 && $languageId == 0x409) { // Microsoft, Unicode, US English, PS Name
+                    $opos = $this->_pos;
+                    $this->seek($string_data_offset + $offset);
+                    if ($length % 2 != 0)
+                        die("PostScript name is UTF-16BE string of odd length");
+                    $length /= 2;
+                    $N = '';
+                    while ($length > 0) {
+                        $char = $this->read_ushort();
+                        $N .= (chr($char));
+                        $length -= 1;
+                    }
+                    $this->_pos = $opos;
+                    $this->seek($opos);
+                } else if ($platformId == 1 && $encodingId == 0 && $languageId == 0) { // Macintosh, Roman, English, PS Name
+                    $opos = $this->_pos;
+                    $N = $this->get_chunk($string_data_offset + $offset, $length);
+                    $this->_pos = $opos;
+                    $this->seek($opos);
+                }
+                if ($N && $names[$nameId] == '') {
+                    $names[$nameId] = $N;
+                    $nameCount -= 1;
+                    if ($nameCount == 0) break;
+                }
+            }
+            if ($names[6])
+                $psName = $names[6];
+            else if ($names[4])
+                $psName = preg_replace('/ /', '-', $names[4]);
+            else if ($names[1])
+                $psName = preg_replace('/ /', '-', $names[1]);
+            else
+                $psName = '';
+            if (!$psName)
+                die("Could not find PostScript font name");
+            $this->name = $psName;
+            if ($names[1]) { $this->familyName = $names[1]; } else { $this->familyName = $psName; }
+            if ($names[2]) { $this->styleName = $names[2]; } else { $this->styleName = 'Regular'; }
+            if ($names[4]) { $this->fullName = $names[4]; } else { $this->fullName = $psName; }
+            if ($names[3]) { $this->uniqueFontID = $names[3]; } else { $this->uniqueFontID = $psName; }
+            if ($names[6]) { $this->fullName = $names[6]; }
+
+        ///////////////////////////////////
+        // head - Font header table
+        ///////////////////////////////////
+        $this->seek_table("head");
+        $this->skip(18); 
+        $this->unitsPerEm = $unitsPerEm = $this->read_ushort();
+        $scale = 1000 / $unitsPerEm;
+        $this->skip(16);
+        $xMin = $this->read_short();
+        $yMin = $this->read_short();
+        $xMax = $this->read_short();
+        $yMax = $this->read_short();
+        $this->bbox = array(($xMin * $scale), ($yMin * $scale), ($xMax * $scale), ($yMax * $scale));
+        $this->skip(3 * 2);
+        $indexToLocFormat = $this->read_ushort();
+        $glyphDataFormat = $this->read_ushort();
+        if ($glyphDataFormat != 0) {
+                    die('Unknown glyph data format '.$glyphDataFormat);
+        }
+
+        ///////////////////////////////////
+        // hhea metrics table
+        ///////////////////////////////////
+        // ttf2t1 seems to use this value rather than the one in OS/2 - so put in for compatibility
+        if (isset($this->tables["hhea"])) {
+            $this->seek_table("hhea");
+            $this->skip(4);
+            $hheaAscender = $this->read_short();
+            $hheaDescender = $this->read_short();
+            $this->ascent = ($hheaAscender * $scale);
+            $this->descent = ($hheaDescender * $scale);
+        }
+
+        ///////////////////////////////////
+        // OS/2 - OS/2 and Windows metrics table
+        ///////////////////////////////////
+        if (isset($this->tables["OS/2"])) {
+            $this->seek_table("OS/2");
+            $version = $this->read_ushort();
+            $this->skip(2);
+            $usWeightClass = $this->read_ushort();
+            $this->skip(2);
+            $fsType = $this->read_ushort();
+            if ($fsType == 0x0002 || ($fsType & 0x0300) != 0) {
+                die('ERROR - Font file '.$this->filename.' cannot be embedded due to copyright restrictions.');
+                $this->restrictedUse = true;
+            }
+            $this->skip(20);
+            $sF = $this->read_short();
+            $this->sFamilyClass = ($sF >> 8);
+            $this->sFamilySubClass = ($sF & 0xFF);
+            $this->_pos += 10; //PANOSE = 10 byte length
+            $panose = fread($this->fh, 10);
+            $this->skip(26);
+            $sTypoAscender = $this->read_short();
+            $sTypoDescender = $this->read_short();
+            if (!$this->ascent) $this->ascent = ($sTypoAscender * $scale);
+            if (!$this->descent) $this->descent = ($sTypoDescender * $scale);
+            if ($version > 1) {
+                $this->skip(16);
+                $sCapHeight = $this->read_short();
+                $this->capHeight = ($sCapHeight * $scale);
+            }
+            else {
+                $this->capHeight = $this->ascent;
+            }
+        }
+        else {
+            $usWeightClass = 500;
+            if (!$this->ascent) $this->ascent = ($yMax * $scale);
+            if (!$this->descent) $this->descent = ($yMin * $scale);
+            $this->capHeight = $this->ascent;
+        }
+        $this->stemV = 50 + intval(pow(($usWeightClass / 65.0), 2));
+
+        ///////////////////////////////////
+        // post - PostScript table
+        ///////////////////////////////////
+        $this->seek_table("post");
+        $this->skip(4); 
+        $this->italicAngle = $this->read_short() + $this->read_ushort() / 65536.0;
+        $this->underlinePosition = $this->read_short() * $scale;
+        $this->underlineThickness = $this->read_short() * $scale;
+        $isFixedPitch = $this->read_ulong();
+
+        $this->flags = 4;
+
+        if ($this->italicAngle != 0) 
+            $this->flags = $this->flags | 64;
+        if ($usWeightClass >= 600)
+            $this->flags = $this->flags | 262144;
+        if ($isFixedPitch)
+            $this->flags = $this->flags | 1;
+
+        ///////////////////////////////////
+        // hhea - Horizontal header table
+        ///////////////////////////////////
+        $this->seek_table("hhea");
+        $this->skip(32); 
+        $metricDataFormat = $this->read_ushort();
+        if ($metricDataFormat != 0) {
+                    die('Unknown horizontal metric data format '.$metricDataFormat);
+        }
+        $numberOfHMetrics = $this->read_ushort();
+        if ($numberOfHMetrics == 0) {
+                    die('Number of horizontal metrics is 0');
+        }
+
+        ///////////////////////////////////
+        // maxp - Maximum profile table
+        ///////////////////////////////////
+        $this->seek_table("maxp");
+        $this->skip(4); 
+        $numGlyphs = $this->read_ushort();
+
+
+        ///////////////////////////////////
+        // cmap - Character to glyph index mapping table
+        ///////////////////////////////////
+        $cmap_offset = $this->seek_table("cmap");
+        $this->skip(2);
+        $cmapTableCount = $this->read_ushort();
+        $unicode_cmap_offset = 0;
+        for ($i = 0; $i < $cmapTableCount; $i++) {
+            $platformID = $this->read_ushort();
+            $encodingID = $this->read_ushort();
+            $offset = $this->read_ulong();
+            $save_pos = $this->_pos;
+            if (($platformID == 3 && $encodingID == 1) || $platformID == 0) { // Microsoft, Unicode
+                $format = $this->get_ushort($cmap_offset + $offset);
+                if ($format == 4) {
+                    if (!$unicode_cmap_offset) $unicode_cmap_offset = $cmap_offset + $offset;
+                    break;
+                }
+            }
+            $this->seek($save_pos);
+        }
+        if (!$unicode_cmap_offset)
+            die('Font ('.$this->filename.') does not have cmap for Unicode (platform 3, encoding 1, format 4, or platform 0, any encoding, format 4)');
+
+
+        $glyphToChar = array();
+        $charToGlyph = array();
+        $this->getCMAP4($unicode_cmap_offset, $glyphToChar, $charToGlyph);
+
+        ///////////////////////////////////
+        // hmtx - Horizontal metrics table
+        ///////////////////////////////////
+        $this->getHMTX($numberOfHMetrics, $numGlyphs, $glyphToChar, $scale);
+
+    }
 
 
 /////////////////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////////////////
 
 
-	/**
-	 * @return string
-	 */
-	function makeSubset($file, &$subset) {
-		$this->filename = $file;
-		$this->fh = fopen($file, 'rb') or die('Can\'t open file '.$file);
-		$this->_pos = 0;
-		$this->charWidths = '';
-		$this->glyphPos = array();
-		$this->charToGlyph = array();
-		$this->tables = array();
-		$this->otables = array();
-		$this->ascent = 0;
-		$this->descent = 0;
-		$this->skip(4);
-		$this->maxUni = 0;
-		$this->readTableDirectory();
-
-
-		///////////////////////////////////
-		// head - Font header table
-		///////////////////////////////////
-		$this->seek_table("head");
-		$this->skip(50); 
-		$indexToLocFormat = $this->read_ushort();
-		$glyphDataFormat = $this->read_ushort();
-
-		///////////////////////////////////
-		// hhea - Horizontal header table
-		///////////////////////////////////
-		$this->seek_table("hhea");
-		$this->skip(32); 
-		$metricDataFormat = $this->read_ushort();
-		$orignHmetrics = $numberOfHMetrics = $this->read_ushort();
-
-		///////////////////////////////////
-		// maxp - Maximum profile table
-		///////////////////////////////////
-		$this->seek_table("maxp");
-		$this->skip(4);
-		$numGlyphs = $this->read_ushort();
-
-
-		///////////////////////////////////
-		// cmap - Character to glyph index mapping table
-		///////////////////////////////////
-		$cmap_offset = $this->seek_table("cmap");
-		$this->skip(2);
-		$cmapTableCount = $this->read_ushort();
-		$unicode_cmap_offset = 0;
-		for ($i = 0; $i < $cmapTableCount; $i++) {
-			$platformID = $this->read_ushort();
-			$encodingID = $this->read_ushort();
-			$offset = $this->read_ulong();
-			$save_pos = $this->_pos;
-			if (($platformID == 3 && $encodingID == 1) || $platformID == 0) { // Microsoft, Unicode
-				$format = $this->get_ushort($cmap_offset + $offset);
-				if ($format == 4) {
-					$unicode_cmap_offset = $cmap_offset + $offset;
-					break;
-				}
-			}
-			$this->seek($save_pos);
-		}
-
-		if (!$unicode_cmap_offset)
-			die('Font ('.$this->filename.') does not have cmap for Unicode (platform 3, encoding 1, format 4, or platform 0, any encoding, format 4)');
-
-
-		$glyphToChar = array();
-		$charToGlyph = array();
-		$this->getCMAP4($unicode_cmap_offset, $glyphToChar, $charToGlyph);
-
-		$this->charToGlyph = $charToGlyph;
-
-		///////////////////////////////////
-		// hmtx - Horizontal metrics table
-		///////////////////////////////////
-		$scale = 1; // not used
-		$this->getHMTX($numberOfHMetrics, $numGlyphs, $glyphToChar, $scale);
-
-		///////////////////////////////////
-		// loca - Index to location
-		///////////////////////////////////
-		$this->getLOCA($indexToLocFormat, $numGlyphs);
-
-		$subsetglyphs = array(0=>0); 
-		$subsetCharToGlyph = array();
-		foreach ($subset AS $code) {
-			if (isset($this->charToGlyph[$code])) {
-				$subsetglyphs[$this->charToGlyph[$code]] = $code; // Old Glyph ID => Unicode
-				$subsetCharToGlyph[$code] = $this->charToGlyph[$code]; // Unicode to old GlyphID
-
-			}
-			$this->maxUni = max($this->maxUni, $code);
-		}
-
-		list($start, $dummy) = $this->get_table_pos('glyf');
-
-		$glyphSet = array();
-		ksort($subsetglyphs);
-		$n = 0;
-		$fsLastCharIndex = 0; // maximum Unicode index (character code) in this font, according to the cmap subtable for platform ID 3 and platform- specific encoding ID 0 or 1.
-		foreach ($subsetglyphs AS $originalGlyphIdx => $uni) {
-			$fsLastCharIndex = max($fsLastCharIndex, $uni);
-			$glyphSet[$originalGlyphIdx] = $n; // old glyphID to new glyphID
-			$n++;
-		}
-
-		ksort($subsetCharToGlyph);
-		foreach ($subsetCharToGlyph AS $uni => $originalGlyphIdx) {
-			$codeToGlyph[$uni] = $glyphSet[$originalGlyphIdx];
-		}
-		$this->codeToGlyph = $codeToGlyph;
-
-		ksort($subsetglyphs);
-		foreach ($subsetglyphs AS $originalGlyphIdx => $uni) {
-			$this->getGlyphs($originalGlyphIdx, $start, $glyphSet, $subsetglyphs);
-		}
-
-		$numGlyphs = $numberOfHMetrics = count($subsetglyphs);
-
-		//tables copied from the original
-		$tags = array('name');
-		foreach ($tags AS $tag) { $this->add($tag, $this->get_table($tag)); }
-		$tags = array('cvt ', 'fpgm', 'prep', 'gasp');
-		foreach ($tags AS $tag) {
-			if (isset($this->tables[$tag])) { $this->add($tag, $this->get_table($tag)); }
-		}
-
-		// post - PostScript
-		$opost = $this->get_table('post');
-		$post = "\x00\x03\x00\x00".substr($opost, 4, 12)."\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
-		$this->add('post', $post);
-
-		// Sort CID2GID map into segments of contiguous codes
-		ksort($codeToGlyph);
-		unset($codeToGlyph[0]);
-		//unset($codeToGlyph[65535]);
-		$rangeid = 0;
-		$range = array();
-		$prevcid = -2;
-		$prevglidx = -1;
-		// for each character
-		foreach ($codeToGlyph as $cid => $glidx) {
-			if ($cid == ($prevcid + 1) && $glidx == ($prevglidx + 1)) {
-				$range[$rangeid][] = $glidx;
-			} else {
-				// new range
-				$rangeid = $cid;
-				$range[$rangeid] = array();
-				$range[$rangeid][] = $glidx;
-			}
-			$prevcid = $cid;
-			$prevglidx = $glidx;
-		}
-
-		// cmap - Character to glyph mapping - Format 4 (MS / )
-		$segCount = count($range) + 1; // + 1 Last segment has missing character 0xFFFF
-		$searchRange = 1;
-		$entrySelector = 0;
-		while ($searchRange * 2 <= $segCount) {
-			$searchRange = $searchRange * 2;
-			$entrySelector = $entrySelector + 1;
-		}
-		$searchRange = $searchRange * 2;
-		$rangeShift = $segCount * 2 - $searchRange;
-		$length = 16 + (8 * $segCount) + ($numGlyphs + 1);
-		$cmap = array(0, 1, // Index : version, number of encoding subtables
-			3, 1, // Encoding Subtable : platform (MS=3), encoding (Unicode)
-			0, 12, // Encoding Subtable : offset (hi,lo)
-			4, $length, 0, // Format 4 Mapping subtable: format, length, language
-			$segCount * 2,
-			$searchRange,
-			$entrySelector,
-			$rangeShift);
-
-		// endCode(s)
-		foreach ($range AS $start=>$subrange) {
-			$endCode = $start + (count($subrange) - 1);
-			$cmap[] = $endCode; // endCode(s)
-		}
-		$cmap[] = 0xFFFF; // endCode of last Segment
-		$cmap[] = 0; // reservedPad
-
-		// startCode(s)
-		foreach ($range AS $start=>$subrange) {
-			$cmap[] = $start; // startCode(s)
-		}
-		$cmap[] = 0xFFFF; // startCode of last Segment
-		// idDelta(s) 
-		foreach ($range AS $start=>$subrange) {
-			$idDelta = -($start - $subrange[0]);
-			$n += count($subrange);
-			$cmap[] = $idDelta; // idDelta(s)
-		}
-		$cmap[] = 1; // idDelta of last Segment
-		// idRangeOffset(s) 
-		foreach ($range AS $subrange) {
-			$cmap[] = 0; // idRangeOffset[segCount]  	Offset in bytes to glyph indexArray, or 0
-
-		}
-		$cmap[] = 0; // idRangeOffset of last Segment
-		foreach ($range AS $subrange) {
-			foreach ($subrange AS $glidx) {
-				$cmap[] = $glidx;
-			}
-		}
-		$cmap[] = 0; // Mapping for last character
-		$cmapstr = '';
-		foreach ($cmap AS $cm) { $cmapstr .= pack("n", $cm); }
-		$this->add('cmap', $cmapstr);
-
-
-		// glyf - Glyph data
-		list($glyfOffset, $glyfLength) = $this->get_table_pos('glyf');
-		if ($glyfLength < $this->maxStrLenRead) {
-			$glyphData = $this->get_table('glyf');
-		}
-
-		$offsets = array();
-		$glyf = '';
-		$pos = 0;
-
-		$hmtxstr = '';
-		$xMinT = 0;
-		$yMinT = 0;
-		$xMaxT = 0;
-		$yMaxT = 0;
-		$advanceWidthMax = 0;
-		$minLeftSideBearing = 0;
-		$minRightSideBearing = 0;
-		$xMaxExtent = 0;
-		$maxPoints = 0; // points in non-compound glyph
-		$maxContours = 0; // contours in non-compound glyph
-		$maxComponentPoints = 0; // points in compound glyph
-		$maxComponentContours = 0; // contours in compound glyph
-		$maxComponentElements = 0; // number of glyphs referenced at top level
-		$maxComponentDepth = 0; // levels of recursion, set to 0 if font has only simple glyphs
-		$this->glyphdata = array();
-
-		foreach ($subsetglyphs AS $originalGlyphIdx => $uni) {
-			// hmtx - Horizontal Metrics
-			$hm = $this->getHMetric($orignHmetrics, $originalGlyphIdx);	
-			$hmtxstr .= $hm;
-
-			$offsets[] = $pos;
-			$glyphPos = $this->glyphPos[$originalGlyphIdx];
-			$glyphLen = $this->glyphPos[$originalGlyphIdx + 1] - $glyphPos;
-			if ($glyfLength < $this->maxStrLenRead) {
-				$data = substr($glyphData, $glyphPos, $glyphLen);
-			}
-			else {
-				if ($glyphLen > 0) $data = $this->get_chunk($glyfOffset + $glyphPos, $glyphLen);
-				else $data = '';
-			}
-
-			if ($glyphLen > 0) {
-				$up = unpack("n", substr($data, 0, 2));
-			}
-
-			if ($glyphLen > 2 && ($up[1] & (1 << 15))) {	// If number of contours <= -1 i.e. composiste glyph
-				$pos_in_glyph = 10;
-				$flags = GF_MORE;
-				$nComponentElements = 0;
-				while ($flags & GF_MORE) {
-					$nComponentElements += 1; // number of glyphs referenced at top level
-					$up = unpack("n", substr($data, $pos_in_glyph, 2));
-					$flags = $up[1];
-					$up = unpack("n", substr($data, $pos_in_glyph + 2, 2));
-					$glyphIdx = $up[1];
-					$this->glyphdata[$originalGlyphIdx]['compGlyphs'][] = $glyphIdx;
-					$data = $this->_set_ushort($data, $pos_in_glyph + 2, $glyphSet[$glyphIdx]);
-					$pos_in_glyph += 4;
-					if ($flags & GF_WORDS) { $pos_in_glyph += 4; } else { $pos_in_glyph += 2; }
-					if ($flags & GF_SCALE) { $pos_in_glyph += 2; } else if ($flags & GF_XYSCALE) { $pos_in_glyph += 4; } else if ($flags & GF_TWOBYTWO) { $pos_in_glyph += 8; }
-				}
-				$maxComponentElements = max($maxComponentElements, $nComponentElements);
-			}
-
-			$glyf .= $data;
-			$pos += $glyphLen;
-			if ($pos % 4 != 0) {
-				$padding = 4 - ($pos % 4);
-				$glyf .= str_repeat("\0", $padding);
-				$pos += $padding;
-			}
-		}
-
-		$offsets[] = $pos;
-		$this->add('glyf', $glyf);
-
-		// hmtx - Horizontal Metrics
-		$this->add('hmtx', $hmtxstr);
-
-		// loca - Index to location
-		$locastr = '';
-		if ((($pos + 1) >> 1) > 0xFFFF) {
-			$indexToLocFormat = 1; // long format
-			foreach ($offsets AS $offset) { $locastr .= pack("N", $offset); }
-		}
-		else {
-			$indexToLocFormat = 0; // short format
-			foreach ($offsets AS $offset) { $locastr .= pack("n", ($offset / 2)); }
-		}
-		$this->add('loca', $locastr);
-
-		// head - Font header
-		$head = $this->get_table('head');
-		$head = $this->_set_ushort($head, 50, $indexToLocFormat);
-		$this->add('head', $head);
-
-
-		// hhea - Horizontal Header
-		$hhea = $this->get_table('hhea');
-		$hhea = $this->_set_ushort($hhea, 34, $numberOfHMetrics);
-		$this->add('hhea', $hhea);
-
-		// maxp - Maximum Profile
-		$maxp = $this->get_table('maxp');
-		$maxp = $this->_set_ushort($maxp, 4, $numGlyphs);
-		$this->add('maxp', $maxp);
-
-
-		// OS/2 - OS/2
-		$os2 = $this->get_table('OS/2');
-		$this->add('OS/2', $os2);
-
-		fclose($this->fh);
-
-		// Put the TTF file together
-		$stm = '';
-		$this->endTTFile($stm);
-		return $stm;
-	}
-
-	//////////////////////////////////////////////////////////////////////////////////
-	// Recursively get composite glyph data
-	function getGlyphData($originalGlyphIdx, &$maxdepth, &$depth, &$points, &$contours) {
-		$depth++;
-		$maxdepth = max($maxdepth, $depth);
-		if (count($this->glyphdata[$originalGlyphIdx]['compGlyphs'])) {
-			foreach ($this->glyphdata[$originalGlyphIdx]['compGlyphs'] AS $glyphIdx) {
-				$this->getGlyphData($glyphIdx, $maxdepth, $depth, $points, $contours);
-			}
-		} else if (($this->glyphdata[$originalGlyphIdx]['nContours'] > 0) && $depth > 0) {	// simple
-			$contours += $this->glyphdata[$originalGlyphIdx]['nContours'];
-			$points += $this->glyphdata[$originalGlyphIdx]['nPoints'];
-		}
-		$depth--;
-	}
-
-
-	//////////////////////////////////////////////////////////////////////////////////
-	// Recursively get composite glyphs
-	function getGlyphs($originalGlyphIdx, &$start, &$glyphSet, &$subsetglyphs) {
-		$glyphPos = $this->glyphPos[$originalGlyphIdx];
-		$glyphLen = $this->glyphPos[$originalGlyphIdx + 1] - $glyphPos;
-		if (!$glyphLen) { 
-			return;
-		}
-		$this->seek($start + $glyphPos);
-		$numberOfContours = $this->read_short();
-		if ($numberOfContours < 0) {
-			$this->skip(8);
-			$flags = GF_MORE;
-			while ($flags & GF_MORE) {
-				$flags = $this->read_ushort();
-				$glyphIdx = $this->read_ushort();
-				if (!isset($glyphSet[$glyphIdx])) {
-					$glyphSet[$glyphIdx] = count($subsetglyphs); // old glyphID to new glyphID
-					$subsetglyphs[$glyphIdx] = true;
-				}
-				$savepos = ftell($this->fh);
-				$this->getGlyphs($glyphIdx, $start, $glyphSet, $subsetglyphs);
-				$this->seek($savepos);
-				if ($flags & GF_WORDS) {
-									$this->skip(4);
-				} else {
-									$this->skip(2);
-				}
-				if ($flags & GF_SCALE) {
-									$this->skip(2);
-				} else if ($flags & GF_XYSCALE) {
-									$this->skip(4);
-				} else if ($flags & GF_TWOBYTWO) {
-									$this->skip(8);
-				}
-			}
-		}
-	}
-
-	//////////////////////////////////////////////////////////////////////////////////
-
-	/**
-	 * @param integer $numberOfHMetrics
-	 * @param integer $numGlyphs
-	 * @param integer $scale
-	 */
-	function getHMTX($numberOfHMetrics, $numGlyphs, &$glyphToChar, $scale) {
-		$start = $this->seek_table("hmtx");
-		$aw = 0;
-		$this->charWidths = str_pad('', 256 * 256 * 2, "\x00");
-		$nCharWidths = 0;
-		if (($numberOfHMetrics * 4) < $this->maxStrLenRead) {
-			$data = $this->get_chunk($start, ($numberOfHMetrics * 4));
-			$arr = unpack("n*", $data);
-		}
-		else { $this->seek($start); }
-		for ($glyph = 0; $glyph < $numberOfHMetrics; $glyph++) {
-
-			if (($numberOfHMetrics * 4) < $this->maxStrLenRead) {
-				$aw = $arr[($glyph * 2) + 1];
-			}
-			else {
-				$aw = $this->read_ushort();
-				$lsb = $this->read_ushort();
-			}
-			if (isset($glyphToChar[$glyph]) || $glyph == 0) {
-
-				if ($aw >= (1 << 15)) { $aw = 0; }	// 1.03 Some (arabic) fonts have -ve values for width
-					// although should be unsigned value - comes out as e.g. 65108 (intended -50)
-				if ($glyph == 0) {
-					$this->defaultWidth = $scale * $aw;
-					continue;
-				}
-				foreach ($glyphToChar[$glyph] AS $char) {
-					if ($char != 0 && $char != 65535) {
- 						$w = intval(round($scale * $aw));
-						if ($w == 0) { $w = 65535; }
-						if ($char < 196608) {
-							$this->charWidths[$char * 2] = chr($w >> 8);
-							$this->charWidths[$char * 2 + 1] = chr($w & 0xFF);
-							$nCharWidths++;
-						}
-					}
-				}
-			}
-		}
-		$data = $this->get_chunk(($start + $numberOfHMetrics * 4), ($numGlyphs * 2));
-		$arr = unpack("n*", $data);
-		$diff = $numGlyphs - $numberOfHMetrics;
-		for ($pos = 0; $pos < $diff; $pos++) {
-			$glyph = $pos + $numberOfHMetrics;
-			if (isset($glyphToChar[$glyph])) {
-				foreach ($glyphToChar[$glyph] AS $char) {
-					if ($char != 0 && $char != 65535) {
-						$w = intval(round($scale * $aw));
-						if ($w == 0) { $w = 65535; }
-						if ($char < 196608) {
-							$this->charWidths[$char * 2] = chr($w >> 8);
-							$this->charWidths[$char * 2 + 1] = chr($w & 0xFF);
-							$nCharWidths++;
-						}
-					}
-				}
-			}
-		}
-		// NB 65535 is a set width of 0
-		// First bytes define number of chars in font
-		$this->charWidths[0] = chr($nCharWidths >> 8);
-		$this->charWidths[1] = chr($nCharWidths & 0xFF);
-	}
-
-	/**
-	 * @param integer $numberOfHMetrics
-	 */
-	function getHMetric($numberOfHMetrics, $gid) {
-		$start = $this->seek_table("hmtx");
-		if ($gid < $numberOfHMetrics) {
-			$this->seek($start + ($gid * 4));
-			$hm = fread($this->fh, 4);
-		}
-		else {
-			$this->seek($start + (($numberOfHMetrics - 1) * 4));
-			$hm = fread($this->fh, 2);
-			$this->seek($start + ($numberOfHMetrics * 2) + ($gid * 2));
-			$hm .= fread($this->fh, 2);
-		}
-		return $hm;
-	}
-
-	/**
-	 * @param integer $indexToLocFormat
-	 * @param integer $numGlyphs
-	 */
-	function getLOCA($indexToLocFormat, $numGlyphs) {
-		$start = $this->seek_table('loca');
-		$this->glyphPos = array();
-		if ($indexToLocFormat == 0) {
-			$data = $this->get_chunk($start, ($numGlyphs * 2) + 2);
-			$arr = unpack("n*", $data);
-			for ($n = 0; $n <= $numGlyphs; $n++) {
-				$this->glyphPos[] = ($arr[$n + 1] * 2);
-			}
-		}
-		else if ($indexToLocFormat == 1) {
-			$data = $this->get_chunk($start, ($numGlyphs * 4) + 4);
-			$arr = unpack("N*", $data);
-			for ($n = 0; $n <= $numGlyphs; $n++) {
-				$this->glyphPos[] = ($arr[$n + 1]);
-			}
-		}
-		else 
-			die('Unknown location table format '.$indexToLocFormat);
-	}
-
-
-	// CMAP Format 4
-
-	/**
-	 * @param integer $unicode_cmap_offset
-	 */
-	function getCMAP4($unicode_cmap_offset, &$glyphToChar, &$charToGlyph ) {
-		$this->maxUniChar = 0;
-		$this->seek($unicode_cmap_offset + 2);
-		$length = $this->read_ushort();
-		$limit = $unicode_cmap_offset + $length;
-		$this->skip(2);
-
-		$segCount = $this->read_ushort() / 2;
-		$this->skip(6);
-		$endCount = array();
-		for ($i = 0; $i < $segCount; $i++) { $endCount[] = $this->read_ushort(); }
-		$this->skip(2);
-		$startCount = array();
-		for ($i = 0; $i < $segCount; $i++) { $startCount[] = $this->read_ushort(); }
-		$idDelta = array();
-		for ($i = 0; $i < $segCount; $i++) { $idDelta[] = $this->read_short(); }		// ???? was unsigned short
-		$idRangeOffset_start = $this->_pos;
-		$idRangeOffset = array();
-		for ($i = 0; $i < $segCount; $i++) { $idRangeOffset[] = $this->read_ushort(); }
-
-		for ($n = 0; $n < $segCount; $n++) {
-			$endpoint = ($endCount[$n] + 1);
-			for ($unichar = $startCount[$n]; $unichar < $endpoint; $unichar++) {
-				if ($idRangeOffset[$n] == 0)
-					$glyph = ($unichar + $idDelta[$n]) & 0xFFFF;
-				else {
-					$offset = ($unichar - $startCount[$n]) * 2 + $idRangeOffset[$n];
-					$offset = $idRangeOffset_start + 2 * $n + $offset;
-					if ($offset >= $limit)
-						$glyph = 0;
-					else {
-						$glyph = $this->get_ushort($offset);
-						if ($glyph != 0)
-						   $glyph = ($glyph + $idDelta[$n]) & 0xFFFF;
-					}
-				}
-				$charToGlyph[$unichar] = $glyph;
-				if ($unichar < 196608) { $this->maxUniChar = max($unichar, $this->maxUniChar); }
-				$glyphToChar[$glyph][] = $unichar;
-			}
-		}
-	}
-
-
-		// Put the TTF file together
-
-	/**
-	 * @param string $stm
-	 */
-	function endTTFile(&$stm) {
-		$stm = '';
-		$numTables = count($this->otables);
-		$searchRange = 1;
-		$entrySelector = 0;
-		while ($searchRange * 2 <= $numTables) {
-			$searchRange = $searchRange * 2;
-			$entrySelector = $entrySelector + 1;
-		}
-		$searchRange = $searchRange * 16;
-		$rangeShift = $numTables * 16 - $searchRange;
-
-		// Header
-		if (_TTF_MAC_HEADER) {
-			$stm .= (pack("Nnnnn", 0x74727565, $numTables, $searchRange, $entrySelector, $rangeShift)); // Mac
-		}
-		else {
-			$stm .= (pack("Nnnnn", 0x00010000, $numTables, $searchRange, $entrySelector, $rangeShift)); // Windows
-		}
-
-		// Table directory
-		$tables = $this->otables;
-
-		ksort($tables); 
-		$offset = 12 + $numTables * 16;
-		foreach ($tables AS $tag=>$data) {
-			if ($tag == 'head') { $head_start = $offset; }
-			$stm .= $tag;
-			$checksum = $this->calcChecksum($data);
-			$stm .= pack("nn", $checksum[0], $checksum[1]);
-			$stm .= pack("NN", $offset, strlen($data));
-			$paddedLength = (strlen($data) + 3) & ~3;
-			$offset = $offset + $paddedLength;
-		}
-
-		// Table data
-		foreach ($tables AS $tag=>$data) {
-			$data .= "\0\0\0";
-			$stm .= substr($data, 0, (strlen($data) & ~3));
-		}
-
-		$checksum = $this->calcChecksum($stm);
-		$checksum = $this->sub32(array(0xB1B0, 0xAFBA), $checksum);
-		$chk = pack("nn", $checksum[0], $checksum[1]);
-		$stm = $this->splice($stm, ($head_start + 8), $chk);
-		return $stm;
-	}
+    /**
+     * @return string
+     */
+    function makeSubset($file, &$subset) {
+        $this->filename = $file;
+        $this->fh = fopen($file, 'rb') or die('Can\'t open file '.$file);
+        $this->_pos = 0;
+        $this->charWidths = '';
+        $this->glyphPos = array();
+        $this->charToGlyph = array();
+        $this->tables = array();
+        $this->otables = array();
+        $this->ascent = 0;
+        $this->descent = 0;
+        $this->skip(4);
+        $this->maxUni = 0;
+        $this->readTableDirectory();
+
+
+        ///////////////////////////////////
+        // head - Font header table
+        ///////////////////////////////////
+        $this->seek_table("head");
+        $this->skip(50); 
+        $indexToLocFormat = $this->read_ushort();
+        $glyphDataFormat = $this->read_ushort();
+
+        ///////////////////////////////////
+        // hhea - Horizontal header table
+        ///////////////////////////////////
+        $this->seek_table("hhea");
+        $this->skip(32); 
+        $metricDataFormat = $this->read_ushort();
+        $orignHmetrics = $numberOfHMetrics = $this->read_ushort();
+
+        ///////////////////////////////////
+        // maxp - Maximum profile table
+        ///////////////////////////////////
+        $this->seek_table("maxp");
+        $this->skip(4);
+        $numGlyphs = $this->read_ushort();
+
+
+        ///////////////////////////////////
+        // cmap - Character to glyph index mapping table
+        ///////////////////////////////////
+        $cmap_offset = $this->seek_table("cmap");
+        $this->skip(2);
+        $cmapTableCount = $this->read_ushort();
+        $unicode_cmap_offset = 0;
+        for ($i = 0; $i < $cmapTableCount; $i++) {
+            $platformID = $this->read_ushort();
+            $encodingID = $this->read_ushort();
+            $offset = $this->read_ulong();
+            $save_pos = $this->_pos;
+            if (($platformID == 3 && $encodingID == 1) || $platformID == 0) { // Microsoft, Unicode
+                $format = $this->get_ushort($cmap_offset + $offset);
+                if ($format == 4) {
+                    $unicode_cmap_offset = $cmap_offset + $offset;
+                    break;
+                }
+            }
+            $this->seek($save_pos);
+        }
+
+        if (!$unicode_cmap_offset)
+            die('Font ('.$this->filename.') does not have cmap for Unicode (platform 3, encoding 1, format 4, or platform 0, any encoding, format 4)');
+
+
+        $glyphToChar = array();
+        $charToGlyph = array();
+        $this->getCMAP4($unicode_cmap_offset, $glyphToChar, $charToGlyph);
+
+        $this->charToGlyph = $charToGlyph;
+
+        ///////////////////////////////////
+        // hmtx - Horizontal metrics table
+        ///////////////////////////////////
+        $scale = 1; // not used
+        $this->getHMTX($numberOfHMetrics, $numGlyphs, $glyphToChar, $scale);
+
+        ///////////////////////////////////
+        // loca - Index to location
+        ///////////////////////////////////
+        $this->getLOCA($indexToLocFormat, $numGlyphs);
+
+        $subsetglyphs = array(0=>0); 
+        $subsetCharToGlyph = array();
+        foreach ($subset AS $code) {
+            if (isset($this->charToGlyph[$code])) {
+                $subsetglyphs[$this->charToGlyph[$code]] = $code; // Old Glyph ID => Unicode
+                $subsetCharToGlyph[$code] = $this->charToGlyph[$code]; // Unicode to old GlyphID
+
+            }
+            $this->maxUni = max($this->maxUni, $code);
+        }
+
+        list($start, $dummy) = $this->get_table_pos('glyf');
+
+        $glyphSet = array();
+        ksort($subsetglyphs);
+        $n = 0;
+        $fsLastCharIndex = 0; // maximum Unicode index (character code) in this font, according to the cmap subtable for platform ID 3 and platform- specific encoding ID 0 or 1.
+        foreach ($subsetglyphs AS $originalGlyphIdx => $uni) {
+            $fsLastCharIndex = max($fsLastCharIndex, $uni);
+            $glyphSet[$originalGlyphIdx] = $n; // old glyphID to new glyphID
+            $n++;
+        }
+
+        ksort($subsetCharToGlyph);
+        foreach ($subsetCharToGlyph AS $uni => $originalGlyphIdx) {
+            $codeToGlyph[$uni] = $glyphSet[$originalGlyphIdx];
+        }
+        $this->codeToGlyph = $codeToGlyph;
+
+        ksort($subsetglyphs);
+        foreach ($subsetglyphs AS $originalGlyphIdx => $uni) {
+            $this->getGlyphs($originalGlyphIdx, $start, $glyphSet, $subsetglyphs);
+        }
+
+        $numGlyphs = $numberOfHMetrics = count($subsetglyphs);
+
+        //tables copied from the original
+        $tags = array('name');
+        foreach ($tags AS $tag) { $this->add($tag, $this->get_table($tag)); }
+        $tags = array('cvt ', 'fpgm', 'prep', 'gasp');
+        foreach ($tags AS $tag) {
+            if (isset($this->tables[$tag])) { $this->add($tag, $this->get_table($tag)); }
+        }
+
+        // post - PostScript
+        $opost = $this->get_table('post');
+        $post = "\x00\x03\x00\x00".substr($opost, 4, 12)."\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
+        $this->add('post', $post);
+
+        // Sort CID2GID map into segments of contiguous codes
+        ksort($codeToGlyph);
+        unset($codeToGlyph[0]);
+        //unset($codeToGlyph[65535]);
+        $rangeid = 0;
+        $range = array();
+        $prevcid = -2;
+        $prevglidx = -1;
+        // for each character
+        foreach ($codeToGlyph as $cid => $glidx) {
+            if ($cid == ($prevcid + 1) && $glidx == ($prevglidx + 1)) {
+                $range[$rangeid][] = $glidx;
+            } else {
+                // new range
+                $rangeid = $cid;
+                $range[$rangeid] = array();
+                $range[$rangeid][] = $glidx;
+            }
+            $prevcid = $cid;
+            $prevglidx = $glidx;
+        }
+
+        // cmap - Character to glyph mapping - Format 4 (MS / )
+        $segCount = count($range) + 1; // + 1 Last segment has missing character 0xFFFF
+        $searchRange = 1;
+        $entrySelector = 0;
+        while ($searchRange * 2 <= $segCount) {
+            $searchRange = $searchRange * 2;
+            $entrySelector = $entrySelector + 1;
+        }
+        $searchRange = $searchRange * 2;
+        $rangeShift = $segCount * 2 - $searchRange;
+        $length = 16 + (8 * $segCount) + ($numGlyphs + 1);
+        $cmap = array(0, 1, // Index : version, number of encoding subtables
+            3, 1, // Encoding Subtable : platform (MS=3), encoding (Unicode)
+            0, 12, // Encoding Subtable : offset (hi,lo)
+            4, $length, 0, // Format 4 Mapping subtable: format, length, language
+            $segCount * 2,
+            $searchRange,
+            $entrySelector,
+            $rangeShift);
+
+        // endCode(s)
+        foreach ($range AS $start=>$subrange) {
+            $endCode = $start + (count($subrange) - 1);
+            $cmap[] = $endCode; // endCode(s)
+        }
+        $cmap[] = 0xFFFF; // endCode of last Segment
+        $cmap[] = 0; // reservedPad
+
+        // startCode(s)
+        foreach ($range AS $start=>$subrange) {
+            $cmap[] = $start; // startCode(s)
+        }
+        $cmap[] = 0xFFFF; // startCode of last Segment
+        // idDelta(s) 
+        foreach ($range AS $start=>$subrange) {
+            $idDelta = -($start - $subrange[0]);
+            $n += count($subrange);
+            $cmap[] = $idDelta; // idDelta(s)
+        }
+        $cmap[] = 1; // idDelta of last Segment
+        // idRangeOffset(s) 
+        foreach ($range AS $subrange) {
+            $cmap[] = 0; // idRangeOffset[segCount]  	Offset in bytes to glyph indexArray, or 0
+
+        }
+        $cmap[] = 0; // idRangeOffset of last Segment
+        foreach ($range AS $subrange) {
+            foreach ($subrange AS $glidx) {
+                $cmap[] = $glidx;
+            }
+        }
+        $cmap[] = 0; // Mapping for last character
+        $cmapstr = '';
+        foreach ($cmap AS $cm) { $cmapstr .= pack("n", $cm); }
+        $this->add('cmap', $cmapstr);
+
+
+        // glyf - Glyph data
+        list($glyfOffset, $glyfLength) = $this->get_table_pos('glyf');
+        if ($glyfLength < $this->maxStrLenRead) {
+            $glyphData = $this->get_table('glyf');
+        }
+
+        $offsets = array();
+        $glyf = '';
+        $pos = 0;
+
+        $hmtxstr = '';
+        $xMinT = 0;
+        $yMinT = 0;
+        $xMaxT = 0;
+        $yMaxT = 0;
+        $advanceWidthMax = 0;
+        $minLeftSideBearing = 0;
+        $minRightSideBearing = 0;
+        $xMaxExtent = 0;
+        $maxPoints = 0; // points in non-compound glyph
+        $maxContours = 0; // contours in non-compound glyph
+        $maxComponentPoints = 0; // points in compound glyph
+        $maxComponentContours = 0; // contours in compound glyph
+        $maxComponentElements = 0; // number of glyphs referenced at top level
+        $maxComponentDepth = 0; // levels of recursion, set to 0 if font has only simple glyphs
+        $this->glyphdata = array();
+
+        foreach ($subsetglyphs AS $originalGlyphIdx => $uni) {
+            // hmtx - Horizontal Metrics
+            $hm = $this->getHMetric($orignHmetrics, $originalGlyphIdx);	
+            $hmtxstr .= $hm;
+
+            $offsets[] = $pos;
+            $glyphPos = $this->glyphPos[$originalGlyphIdx];
+            $glyphLen = $this->glyphPos[$originalGlyphIdx + 1] - $glyphPos;
+            if ($glyfLength < $this->maxStrLenRead) {
+                $data = substr($glyphData, $glyphPos, $glyphLen);
+            }
+            else {
+                if ($glyphLen > 0) $data = $this->get_chunk($glyfOffset + $glyphPos, $glyphLen);
+                else $data = '';
+            }
+
+            if ($glyphLen > 0) {
+                $up = unpack("n", substr($data, 0, 2));
+            }
+
+            if ($glyphLen > 2 && ($up[1] & (1 << 15))) {	// If number of contours <= -1 i.e. composiste glyph
+                $pos_in_glyph = 10;
+                $flags = GF_MORE;
+                $nComponentElements = 0;
+                while ($flags & GF_MORE) {
+                    $nComponentElements += 1; // number of glyphs referenced at top level
+                    $up = unpack("n", substr($data, $pos_in_glyph, 2));
+                    $flags = $up[1];
+                    $up = unpack("n", substr($data, $pos_in_glyph + 2, 2));
+                    $glyphIdx = $up[1];
+                    $this->glyphdata[$originalGlyphIdx]['compGlyphs'][] = $glyphIdx;
+                    $data = $this->_set_ushort($data, $pos_in_glyph + 2, $glyphSet[$glyphIdx]);
+                    $pos_in_glyph += 4;
+                    if ($flags & GF_WORDS) { $pos_in_glyph += 4; } else { $pos_in_glyph += 2; }
+                    if ($flags & GF_SCALE) { $pos_in_glyph += 2; } else if ($flags & GF_XYSCALE) { $pos_in_glyph += 4; } else if ($flags & GF_TWOBYTWO) { $pos_in_glyph += 8; }
+                }
+                $maxComponentElements = max($maxComponentElements, $nComponentElements);
+            }
+
+            $glyf .= $data;
+            $pos += $glyphLen;
+            if ($pos % 4 != 0) {
+                $padding = 4 - ($pos % 4);
+                $glyf .= str_repeat("\0", $padding);
+                $pos += $padding;
+            }
+        }
+
+        $offsets[] = $pos;
+        $this->add('glyf', $glyf);
+
+        // hmtx - Horizontal Metrics
+        $this->add('hmtx', $hmtxstr);
+
+        // loca - Index to location
+        $locastr = '';
+        if ((($pos + 1) >> 1) > 0xFFFF) {
+            $indexToLocFormat = 1; // long format
+            foreach ($offsets AS $offset) { $locastr .= pack("N", $offset); }
+        }
+        else {
+            $indexToLocFormat = 0; // short format
+            foreach ($offsets AS $offset) { $locastr .= pack("n", ($offset / 2)); }
+        }
+        $this->add('loca', $locastr);
+
+        // head - Font header
+        $head = $this->get_table('head');
+        $head = $this->_set_ushort($head, 50, $indexToLocFormat);
+        $this->add('head', $head);
+
+
+        // hhea - Horizontal Header
+        $hhea = $this->get_table('hhea');
+        $hhea = $this->_set_ushort($hhea, 34, $numberOfHMetrics);
+        $this->add('hhea', $hhea);
+
+        // maxp - Maximum Profile
+        $maxp = $this->get_table('maxp');
+        $maxp = $this->_set_ushort($maxp, 4, $numGlyphs);
+        $this->add('maxp', $maxp);
+
+
+        // OS/2 - OS/2
+        $os2 = $this->get_table('OS/2');
+        $this->add('OS/2', $os2);
+
+        fclose($this->fh);
+
+        // Put the TTF file together
+        $stm = '';
+        $this->endTTFile($stm);
+        return $stm;
+    }
+
+    //////////////////////////////////////////////////////////////////////////////////
+    // Recursively get composite glyph data
+    function getGlyphData($originalGlyphIdx, &$maxdepth, &$depth, &$points, &$contours) {
+        $depth++;
+        $maxdepth = max($maxdepth, $depth);
+        if (count($this->glyphdata[$originalGlyphIdx]['compGlyphs'])) {
+            foreach ($this->glyphdata[$originalGlyphIdx]['compGlyphs'] AS $glyphIdx) {
+                $this->getGlyphData($glyphIdx, $maxdepth, $depth, $points, $contours);
+            }
+        } else if (($this->glyphdata[$originalGlyphIdx]['nContours'] > 0) && $depth > 0) {	// simple
+            $contours += $this->glyphdata[$originalGlyphIdx]['nContours'];
+            $points += $this->glyphdata[$originalGlyphIdx]['nPoints'];
+        }
+        $depth--;
+    }
+
+
+    //////////////////////////////////////////////////////////////////////////////////
+    // Recursively get composite glyphs
+    function getGlyphs($originalGlyphIdx, &$start, &$glyphSet, &$subsetglyphs) {
+        $glyphPos = $this->glyphPos[$originalGlyphIdx];
+        $glyphLen = $this->glyphPos[$originalGlyphIdx + 1] - $glyphPos;
+        if (!$glyphLen) { 
+            return;
+        }
+        $this->seek($start + $glyphPos);
+        $numberOfContours = $this->read_short();
+        if ($numberOfContours < 0) {
+            $this->skip(8);
+            $flags = GF_MORE;
+            while ($flags & GF_MORE) {
+                $flags = $this->read_ushort();
+                $glyphIdx = $this->read_ushort();
+                if (!isset($glyphSet[$glyphIdx])) {
+                    $glyphSet[$glyphIdx] = count($subsetglyphs); // old glyphID to new glyphID
+                    $subsetglyphs[$glyphIdx] = true;
+                }
+                $savepos = ftell($this->fh);
+                $this->getGlyphs($glyphIdx, $start, $glyphSet, $subsetglyphs);
+                $this->seek($savepos);
+                if ($flags & GF_WORDS) {
+                                    $this->skip(4);
+                } else {
+                                    $this->skip(2);
+                }
+                if ($flags & GF_SCALE) {
+                                    $this->skip(2);
+                } else if ($flags & GF_XYSCALE) {
+                                    $this->skip(4);
+                } else if ($flags & GF_TWOBYTWO) {
+                                    $this->skip(8);
+                }
+            }
+        }
+    }
+
+    //////////////////////////////////////////////////////////////////////////////////
+
+    /**
+     * @param integer $numberOfHMetrics
+     * @param integer $numGlyphs
+     * @param integer $scale
+     */
+    function getHMTX($numberOfHMetrics, $numGlyphs, &$glyphToChar, $scale) {
+        $start = $this->seek_table("hmtx");
+        $aw = 0;
+        $this->charWidths = str_pad('', 256 * 256 * 2, "\x00");
+        $nCharWidths = 0;
+        if (($numberOfHMetrics * 4) < $this->maxStrLenRead) {
+            $data = $this->get_chunk($start, ($numberOfHMetrics * 4));
+            $arr = unpack("n*", $data);
+        }
+        else { $this->seek($start); }
+        for ($glyph = 0; $glyph < $numberOfHMetrics; $glyph++) {
+
+            if (($numberOfHMetrics * 4) < $this->maxStrLenRead) {
+                $aw = $arr[($glyph * 2) + 1];
+            }
+            else {
+                $aw = $this->read_ushort();
+                $lsb = $this->read_ushort();
+            }
+            if (isset($glyphToChar[$glyph]) || $glyph == 0) {
+
+                if ($aw >= (1 << 15)) { $aw = 0; }	// 1.03 Some (arabic) fonts have -ve values for width
+                    // although should be unsigned value - comes out as e.g. 65108 (intended -50)
+                if ($glyph == 0) {
+                    $this->defaultWidth = $scale * $aw;
+                    continue;
+                }
+                foreach ($glyphToChar[$glyph] AS $char) {
+                    if ($char != 0 && $char != 65535) {
+                            $w = intval(round($scale * $aw));
+                        if ($w == 0) { $w = 65535; }
+                        if ($char < 196608) {
+                            $this->charWidths[$char * 2] = chr($w >> 8);
+                            $this->charWidths[$char * 2 + 1] = chr($w & 0xFF);
+                            $nCharWidths++;
+                        }
+                    }
+                }
+            }
+        }
+        $data = $this->get_chunk(($start + $numberOfHMetrics * 4), ($numGlyphs * 2));
+        $arr = unpack("n*", $data);
+        $diff = $numGlyphs - $numberOfHMetrics;
+        for ($pos = 0; $pos < $diff; $pos++) {
+            $glyph = $pos + $numberOfHMetrics;
+            if (isset($glyphToChar[$glyph])) {
+                foreach ($glyphToChar[$glyph] AS $char) {
+                    if ($char != 0 && $char != 65535) {
+                        $w = intval(round($scale * $aw));
+                        if ($w == 0) { $w = 65535; }
+                        if ($char < 196608) {
+                            $this->charWidths[$char * 2] = chr($w >> 8);
+                            $this->charWidths[$char * 2 + 1] = chr($w & 0xFF);
+                            $nCharWidths++;
+                        }
+                    }
+                }
+            }
+        }
+        // NB 65535 is a set width of 0
+        // First bytes define number of chars in font
+        $this->charWidths[0] = chr($nCharWidths >> 8);
+        $this->charWidths[1] = chr($nCharWidths & 0xFF);
+    }
+
+    /**
+     * @param integer $numberOfHMetrics
+     */
+    function getHMetric($numberOfHMetrics, $gid) {
+        $start = $this->seek_table("hmtx");
+        if ($gid < $numberOfHMetrics) {
+            $this->seek($start + ($gid * 4));
+            $hm = fread($this->fh, 4);
+        }
+        else {
+            $this->seek($start + (($numberOfHMetrics - 1) * 4));
+            $hm = fread($this->fh, 2);
+            $this->seek($start + ($numberOfHMetrics * 2) + ($gid * 2));
+            $hm .= fread($this->fh, 2);
+        }
+        return $hm;
+    }
+
+    /**
+     * @param integer $indexToLocFormat
+     * @param integer $numGlyphs
+     */
+    function getLOCA($indexToLocFormat, $numGlyphs) {
+        $start = $this->seek_table('loca');
+        $this->glyphPos = array();
+        if ($indexToLocFormat == 0) {
+            $data = $this->get_chunk($start, ($numGlyphs * 2) + 2);
+            $arr = unpack("n*", $data);
+            for ($n = 0; $n <= $numGlyphs; $n++) {
+                $this->glyphPos[] = ($arr[$n + 1] * 2);
+            }
+        }
+        else if ($indexToLocFormat == 1) {
+            $data = $this->get_chunk($start, ($numGlyphs * 4) + 4);
+            $arr = unpack("N*", $data);
+            for ($n = 0; $n <= $numGlyphs; $n++) {
+                $this->glyphPos[] = ($arr[$n + 1]);
+            }
+        }
+        else 
+            die('Unknown location table format '.$indexToLocFormat);
+    }
+
+
+    // CMAP Format 4
+
+    /**
+     * @param integer $unicode_cmap_offset
+     */
+    function getCMAP4($unicode_cmap_offset, &$glyphToChar, &$charToGlyph ) {
+        $this->maxUniChar = 0;
+        $this->seek($unicode_cmap_offset + 2);
+        $length = $this->read_ushort();
+        $limit = $unicode_cmap_offset + $length;
+        $this->skip(2);
+
+        $segCount = $this->read_ushort() / 2;
+        $this->skip(6);
+        $endCount = array();
+        for ($i = 0; $i < $segCount; $i++) { $endCount[] = $this->read_ushort(); }
+        $this->skip(2);
+        $startCount = array();
+        for ($i = 0; $i < $segCount; $i++) { $startCount[] = $this->read_ushort(); }
+        $idDelta = array();
+        for ($i = 0; $i < $segCount; $i++) { $idDelta[] = $this->read_short(); }		// ???? was unsigned short
+        $idRangeOffset_start = $this->_pos;
+        $idRangeOffset = array();
+        for ($i = 0; $i < $segCount; $i++) { $idRangeOffset[] = $this->read_ushort(); }
+
+        for ($n = 0; $n < $segCount; $n++) {
+            $endpoint = ($endCount[$n] + 1);
+            for ($unichar = $startCount[$n]; $unichar < $endpoint; $unichar++) {
+                if ($idRangeOffset[$n] == 0)
+                    $glyph = ($unichar + $idDelta[$n]) & 0xFFFF;
+                else {
+                    $offset = ($unichar - $startCount[$n]) * 2 + $idRangeOffset[$n];
+                    $offset = $idRangeOffset_start + 2 * $n + $offset;
+                    if ($offset >= $limit)
+                        $glyph = 0;
+                    else {
+                        $glyph = $this->get_ushort($offset);
+                        if ($glyph != 0)
+                            $glyph = ($glyph + $idDelta[$n]) & 0xFFFF;
+                    }
+                }
+                $charToGlyph[$unichar] = $glyph;
+                if ($unichar < 196608) { $this->maxUniChar = max($unichar, $this->maxUniChar); }
+                $glyphToChar[$glyph][] = $unichar;
+            }
+        }
+    }
+
+
+        // Put the TTF file together
+
+    /**
+     * @param string $stm
+     */
+    function endTTFile(&$stm) {
+        $stm = '';
+        $numTables = count($this->otables);
+        $searchRange = 1;
+        $entrySelector = 0;
+        while ($searchRange * 2 <= $numTables) {
+            $searchRange = $searchRange * 2;
+            $entrySelector = $entrySelector + 1;
+        }
+        $searchRange = $searchRange * 16;
+        $rangeShift = $numTables * 16 - $searchRange;
+
+        // Header
+        if (_TTF_MAC_HEADER) {
+            $stm .= (pack("Nnnnn", 0x74727565, $numTables, $searchRange, $entrySelector, $rangeShift)); // Mac
+        }
+        else {
+            $stm .= (pack("Nnnnn", 0x00010000, $numTables, $searchRange, $entrySelector, $rangeShift)); // Windows
+        }
+
+        // Table directory
+        $tables = $this->otables;
+
+        ksort($tables); 
+        $offset = 12 + $numTables * 16;
+        foreach ($tables AS $tag=>$data) {
+            if ($tag == 'head') { $head_start = $offset; }
+            $stm .= $tag;
+            $checksum = $this->calcChecksum($data);
+            $stm .= pack("nn", $checksum[0], $checksum[1]);
+            $stm .= pack("NN", $offset, strlen($data));
+            $paddedLength = (strlen($data) + 3) & ~3;
+            $offset = $offset + $paddedLength;
+        }
+
+        // Table data
+        foreach ($tables AS $tag=>$data) {
+            $data .= "\0\0\0";
+            $stm .= substr($data, 0, (strlen($data) & ~3));
+        }
+
+        $checksum = $this->calcChecksum($stm);
+        $checksum = $this->sub32(array(0xB1B0, 0xAFBA), $checksum);
+        $chk = pack("nn", $checksum[0], $checksum[1]);
+        $stm = $this->splice($stm, ($head_start + 8), $chk);
+        return $stm;
+    }
 
 
 

includes/libraries/Pdf/Tfpdf/font/courierb.php

Indentation +1 added lines, -1 removed lines

@@ -4,5 +4,5 @@
 $up = -100;
 $ut = 50;
 for ($i = 0; $i <= 255; $i++)
-	$cw[chr($i)] = 600;
+    $cw[chr($i)] = 600;
 ?>

includes/libraries/Pdf/Tfpdf/fpdf.php

Indentation +15 added lines, -15 removed lines

@@ -122,9 +122,9 @@ 
     }
 
     /**
-    * Compute key depending on object number where the encrypted data is stored
-    * @param integer $n
-    */
+     * Compute key depending on object number where the encrypted data is stored
+     * @param integer $n
+     */
     function _objectkey($n)
     {
         return substr($this->_md5_16($this->encryption_key.pack('VXxx', $n)), 0, 10);
@@ -163,18 +163,18 @@ 
     }
 
     /**
-    * Get MD5 as binary string
-    */
+     * Get MD5 as binary string
+     */
     function _md5_16($string)
     {
         return pack('H*', md5($string));
     }
 
     /**
-    * Compute O value
-    * @param string $user_pass
-    * @param string $owner_pass
-    */
+     * Compute O value
+     * @param string $user_pass
+     * @param string $owner_pass
+     */
     function _Ovalue($user_pass, $owner_pass)
     {
         $tmp = $this->_md5_16($owner_pass);
@@ -183,18 +183,18 @@ 
     }
 
     /**
-    * Compute U value
-    */
+     * Compute U value
+     */
     function _Uvalue()
     {
         return RC4($this->encryption_key, $this->padding);
     }
 
     /**
-    * Compute encryption key
-    * @param string $user_pass
-    * @param integer $protection
-    */
+     * Compute encryption key
+     * @param string $user_pass
+     * @param integer $protection
+     */
     function _generateencryptionkey($user_pass, $owner_pass, $protection)
     {
         // Pad passwords

includes/libraries/Encryption/Crypt/aesctr.php

Indentation +17 added lines, -17 removed lines

@@ -227,16 +227,16 @@ 
 {
 
     /**
-    * Encrypt a text using AES encryption in Counter mode of operation
-    *  - see http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf
-    *
-    * Unicode multi-byte character safe
-    *
-    * @param plaintext string text to be encrypted
-    * @param password  the password to use to generate a key
-    * @param nBits     integer of bits to be used in the key (128, 192, or 256)
-    * @return          string text
-    */
+     * Encrypt a text using AES encryption in Counter mode of operation
+     *  - see http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf
+     *
+     * Unicode multi-byte character safe
+     *
+     * @param plaintext string text to be encrypted
+     * @param password  the password to use to generate a key
+     * @param nBits     integer of bits to be used in the key (128, 192, or 256)
+     * @return          string text
+     */
     public static function encrypt($plaintext, $password, $nBits)
     {
         $blockSize = 16; // block size fixed at 16 bytes / 128 bits (Nb=4) for AES
@@ -311,13 +311,13 @@ 
     }
 
     /**
-    * Decrypt a text encrypted by AES in counter mode of operation
-    *
-    * @param ciphertext source text to be decrypted
-    * @param password   the password to use to generate a key
-    * @param nBits      integer of bits to be used in the key (128, 192, or 256)
-    * @return           string text
-    */
+     * Decrypt a text encrypted by AES in counter mode of operation
+     *
+     * @param ciphertext source text to be decrypted
+     * @param password   the password to use to generate a key
+     * @param nBits      integer of bits to be used in the key (128, 192, or 256)
+     * @return           string text
+     */
     public static function decrypt($ciphertext, $password, $nBits)
     {
         $blockSize = 16; // block size fixed at 16 bytes / 128 bits (Nb=4) for AES

includes/libraries/phpcrypt/Padding.php

Indentation +289 added lines, -289 removed lines

@@ -39,294 +39,294 @@
  */
 class Padding
 {
-	/**
-	 * Constructor
-	 *
-	 * @return void
-	 */
-	public function __construct() { }
-
-
-	/**
-	 * Destructor
-	 *
-	 * @return void
-	 */
-	public function __destruct() { }
-
-
-	/**
-	 * Returns a string padded using the specified padding scheme
-	 *
-	 * @param string $text The string to pad
-	 * @param integer $bytes The number of bytes to pad
-	 * @param integer $type One of the predefined padding types
-	 * @return boolean True on success, false on error
-	 */
-	public static function pad(&$text, $bytes, $type = PHP_Crypt::ZERO)
-	{
-		// if the size of padding is not greater than 1
-		// just return true, no padding will be done
-		if (!($bytes > 0))
-			return true;
-
-		switch ($type)
-		{
-			case PHP_Crypt::PAD_ZERO:
-				return self::zeroPad($text, $bytes);
-				break;
-			case PHP_Crypt::PAD_ANSI_X923:
-				return self::ansiX923Pad($text, $bytes);
-				break;
-			case PHP_Crypt::PAD_ISO_10126:
-				return self::iso10126Pad($text, $bytes);
-				break;
-			case PHP_Crypt::PAD_PKCS7:
-				return self::pkcs7Pad($text, $bytes);
-				break;
-			case PHP_Crypt::PAD_ISO_7816_4:
-				return self::iso7816Pad($text, $bytes);
-				break;
-			default:
-				trigger_error("$type is not a valid padding type.", E_USER_NOTICE);
-				return self::zeroPad($text, $bytes);
-		}
-
-		return true;
-	}
-
-
-	/**
-	 * Strips padding from a string
-	 *
-	 * @param string $text The string strip padding from
-	 * @param integer $type One of the predefined padding types
-	 * @return boolean True on success, false on error
-	 */
-	public static function strip(&$text, $type = PHP_Crypt::ZERO)
-	{
-		switch ($type)
-		{
-			case PHP_Crypt::PAD_ZERO:
-				return self::zeroStrip($text);
-				break;
-			case PHP_Crypt::PAD_ANSI_X923:
-				return self::ansiX923Strip($text);
-				break;
-			case PHP_Crypt::PAD_ISO_10126:
-				return self::iso10126Strip($text);
-				break;
-			case PHP_Crypt::PAD_PKCS7:
-				return self::pkcs7Strip($text);
-				break;
-			case PHP_Crypt::PAD_ISO_7816_4:
-				return self::iso7816Strip($text);
-				break;
-			default:
-				trigger_error("$type is not a valid padding type.", E_USER_NOTICE);
-				return self::zeroStrip($text);
-		}
-
-		return true;
-	}
-
-
-	/**
-	 * Pads a string with null bytes
-	 *
-	 * @param string $text The string to be padded
-	 * @param integer $bytes The number of bytes to pad
-	 * @return boolean Returns true
-	 */
-	private static function zeroPad(&$text, $bytes)
-	{
-		$len = $bytes + strlen($text);
-		$text = str_pad($text, $len, chr(0), STR_PAD_RIGHT);
-		return true;
-	}
-
-
-	/**
-	 * Strips null padding off a string
-	 * NOTE: This is generally a bad idea as there is no way
-	 * to distinguish a null byte that is not padding from
-	 * a null byte that is padding. Stripping null padding should
-	 *  be handled by the developer at the application level.
-	 *
-	 * @param string $text The string with null padding to strip
-	 * @return boolean Returns true
-	 */
-	private static function zeroStrip(&$text)
-	{
-		// with NULL byte padding, we should not strip off the
-		// null bytes, instead leave this to the developer at the
-		// application level
-		//$text = preg_replace('/\0+$/', '', $text);
-		return true;
-	}
-
-
-	/**
-	 * Pads a string using ANSI X.923
-	 * Adds null padding to the string, except for the last byte
-	 * which indicates the number of bytes padded
-	 *
-	 * @param string $text The string to pad
-	 * @param integer The number of bytes to pad
-	 * @param integer $bytes
-	 * @return boolean Returns true
-	 */
-	private static function ansiX923Pad(&$text, $bytes)
-	{
-		$len = $bytes + strlen($text);
-		$text  = str_pad($text, ($len - 1), "\0", STR_PAD_RIGHT);
-		$text .= chr($bytes);
-		return true;
-	}
-
-
-	/**
-	 * Strips ANSI X.923 padding from a string
-	 *
-	 * @param string $text The string to strip padding from
-	 * @return boolean Returns true
-	 */
-	private static function ansiX923Strip(&$text)
-	{
-		$pos = strlen($text) - 1;
-		$c = ord($text[$pos]);
-
-		if ($c == 0)
-			return true;
-		else if ($c == 1)
-			$text = substr($text, 0, -1);
-		else
-		{
-			// the total null bytes are 1 less than the value of the final byte
-			$nc = $c - 1;
-			$text = preg_replace('/\0{'.$nc.'}'.preg_quote(chr($c)).'$/', "", $text);
-		}
-
-		return true;
-	}
-
-
-	/**
-	 * Pads a string using ISO 10126
-	 * Adds random bytes to the end of the string, except for the last
-	 * byte which indicates the number of padded bytes
-	 *
-	 * @param string $text The string to pad
-	 * @param integer The number of bytes to pad
-	 * @param integer $bytes
-	 * @return boolean Returns true
-	 */
-	private static function iso10126Pad(&$text, $bytes)
-	{
-		// create the random pad bytes, we do one less than
-		// needed because the last byte is reserved for the
-		// number of padded bytes
-		for ($i = 0; $i < ($bytes - 1); ++$i)
-			$text .= chr(mt_rand(0, 255));
-
-		// add the byte to indicate the padding length
-		$text .= chr($bytes);
-		return true;
-	}
-
-
-	/**
-	 * Strips ISO 10126 padding from a string
-	 *
-	 * @param string $text The string to strip padding from
-	 * @return boolean Returns true
-	 */
-	private static function iso10126Strip(&$text)
-	{
-		$pos = strlen($text) - 1;
-		$c = ord($text[$pos]) * -1;
-
-		// if we got a null byte at the end of the string,
-		// just return
-		if ($c == 0)
-			return true;
-
-		$text = substr($text, 0, $c);
-		return true;
-	}
-
-
-	/**
-	 * Pads a string using PKCS7
-	 * Adds padding using the bytes with the value of the
-	 * number of bytes need for padding
-	 *
-	 * @param string $text The string to pad
-	 * @param integer The number of bytes to pad
-	 * @param integer $bytes
-	 * @return boolean Returns true
-	 */
-	private static function pkcs7Pad(&$text, $bytes)
-	{
-		$len = $bytes + strlen($text);
-		$text = str_pad($text, $len, chr($bytes), STR_PAD_RIGHT);
-		return true;
-	}
-
-
-	/**
-	 * Strips PKCS7 padding from a string
-	 *
-	 * @param string $text The string to strip padding from
-	 * @return boolean Returns true
-	 */
-	private static function pkcs7Strip(&$text)
-	{
-		$pos = strlen($text) - 1;
-		$c = ord($text[$pos]);
-
-		if ($c == 0)
-			return true;
-
-		$text = preg_replace('/'.preg_quote(chr($c)).'{'.$c.'}$/', "", $text);
-		return true;
-	}
-
-
-	/**
-	 * Pads a string using ISO/IEC 7816-4
-	 * Adds byte 0x80 followed by null bytes to pad a string
-	 *
-	 * @param string $text The string to pad
-	 * @param integer The number of bytes to pad
-	 * @param integer $bytes
-	 * @return boolean Returns true
-	 */
-	private static function iso7816Pad(&$text, $bytes)
-	{
-		$text .= chr(0x80);
-		$len = $bytes + strlen($text);
-
-		// if we are only padding one byte, then 0x80 is all we need
-		// else we follow up with null bytes
-		if ($bytes > 1)
-			$text = str_pad($text, ($len - 1), chr(0), STR_PAD_RIGHT);
-
-		return true;
-	}
-
-
-	/**
-	 * Strips ISO/IEC 7816-4 padding from a string
-	 *
-	 * @param string $text The string to strip padding from
-	 * @return boolean Returns true
-	 */
-	private static function iso7816Strip(&$text)
-	{
-		$c = chr(0x80);
-		$text = preg_replace('/'.preg_quote($c).'\0*$/', '', $text);
-		return true;
-	}
+    /**
+     * Constructor
+     *
+     * @return void
+     */
+    public function __construct() { }
+
+
+    /**
+     * Destructor
+     *
+     * @return void
+     */
+    public function __destruct() { }
+
+
+    /**
+     * Returns a string padded using the specified padding scheme
+     *
+     * @param string $text The string to pad
+     * @param integer $bytes The number of bytes to pad
+     * @param integer $type One of the predefined padding types
+     * @return boolean True on success, false on error
+     */
+    public static function pad(&$text, $bytes, $type = PHP_Crypt::ZERO)
+    {
+        // if the size of padding is not greater than 1
+        // just return true, no padding will be done
+        if (!($bytes > 0))
+            return true;
+
+        switch ($type)
+        {
+            case PHP_Crypt::PAD_ZERO:
+                return self::zeroPad($text, $bytes);
+                break;
+            case PHP_Crypt::PAD_ANSI_X923:
+                return self::ansiX923Pad($text, $bytes);
+                break;
+            case PHP_Crypt::PAD_ISO_10126:
+                return self::iso10126Pad($text, $bytes);
+                break;
+            case PHP_Crypt::PAD_PKCS7:
+                return self::pkcs7Pad($text, $bytes);
+                break;
+            case PHP_Crypt::PAD_ISO_7816_4:
+                return self::iso7816Pad($text, $bytes);
+                break;
+            default:
+                trigger_error("$type is not a valid padding type.", E_USER_NOTICE);
+                return self::zeroPad($text, $bytes);
+        }
+
+        return true;
+    }
+
+
+    /**
+     * Strips padding from a string
+     *
+     * @param string $text The string strip padding from
+     * @param integer $type One of the predefined padding types
+     * @return boolean True on success, false on error
+     */
+    public static function strip(&$text, $type = PHP_Crypt::ZERO)
+    {
+        switch ($type)
+        {
+            case PHP_Crypt::PAD_ZERO:
+                return self::zeroStrip($text);
+                break;
+            case PHP_Crypt::PAD_ANSI_X923:
+                return self::ansiX923Strip($text);
+                break;
+            case PHP_Crypt::PAD_ISO_10126:
+                return self::iso10126Strip($text);
+                break;
+            case PHP_Crypt::PAD_PKCS7:
+                return self::pkcs7Strip($text);
+                break;
+            case PHP_Crypt::PAD_ISO_7816_4:
+                return self::iso7816Strip($text);
+                break;
+            default:
+                trigger_error("$type is not a valid padding type.", E_USER_NOTICE);
+                return self::zeroStrip($text);
+        }
+
+        return true;
+    }
+
+
+    /**
+     * Pads a string with null bytes
+     *
+     * @param string $text The string to be padded
+     * @param integer $bytes The number of bytes to pad
+     * @return boolean Returns true
+     */
+    private static function zeroPad(&$text, $bytes)
+    {
+        $len = $bytes + strlen($text);
+        $text = str_pad($text, $len, chr(0), STR_PAD_RIGHT);
+        return true;
+    }
+
+
+    /**
+     * Strips null padding off a string
+     * NOTE: This is generally a bad idea as there is no way
+     * to distinguish a null byte that is not padding from
+     * a null byte that is padding. Stripping null padding should
+     *  be handled by the developer at the application level.
+     *
+     * @param string $text The string with null padding to strip
+     * @return boolean Returns true
+     */
+    private static function zeroStrip(&$text)
+    {
+        // with NULL byte padding, we should not strip off the
+        // null bytes, instead leave this to the developer at the
+        // application level
+        //$text = preg_replace('/\0+$/', '', $text);
+        return true;
+    }
+
+
+    /**
+     * Pads a string using ANSI X.923
+     * Adds null padding to the string, except for the last byte
+     * which indicates the number of bytes padded
+     *
+     * @param string $text The string to pad
+     * @param integer The number of bytes to pad
+     * @param integer $bytes
+     * @return boolean Returns true
+     */
+    private static function ansiX923Pad(&$text, $bytes)
+    {
+        $len = $bytes + strlen($text);
+        $text  = str_pad($text, ($len - 1), "\0", STR_PAD_RIGHT);
+        $text .= chr($bytes);
+        return true;
+    }
+
+
+    /**
+     * Strips ANSI X.923 padding from a string
+     *
+     * @param string $text The string to strip padding from
+     * @return boolean Returns true
+     */
+    private static function ansiX923Strip(&$text)
+    {
+        $pos = strlen($text) - 1;
+        $c = ord($text[$pos]);
+
+        if ($c == 0)
+            return true;
+        else if ($c == 1)
+            $text = substr($text, 0, -1);
+        else
+        {
+            // the total null bytes are 1 less than the value of the final byte
+            $nc = $c - 1;
+            $text = preg_replace('/\0{'.$nc.'}'.preg_quote(chr($c)).'$/', "", $text);
+        }
+
+        return true;
+    }
+
+
+    /**
+     * Pads a string using ISO 10126
+     * Adds random bytes to the end of the string, except for the last
+     * byte which indicates the number of padded bytes
+     *
+     * @param string $text The string to pad
+     * @param integer The number of bytes to pad
+     * @param integer $bytes
+     * @return boolean Returns true
+     */
+    private static function iso10126Pad(&$text, $bytes)
+    {
+        // create the random pad bytes, we do one less than
+        // needed because the last byte is reserved for the
+        // number of padded bytes
+        for ($i = 0; $i < ($bytes - 1); ++$i)
+            $text .= chr(mt_rand(0, 255));
+
+        // add the byte to indicate the padding length
+        $text .= chr($bytes);
+        return true;
+    }
+
+
+    /**
+     * Strips ISO 10126 padding from a string
+     *
+     * @param string $text The string to strip padding from
+     * @return boolean Returns true
+     */
+    private static function iso10126Strip(&$text)
+    {
+        $pos = strlen($text) - 1;
+        $c = ord($text[$pos]) * -1;
+
+        // if we got a null byte at the end of the string,
+        // just return
+        if ($c == 0)
+            return true;
+
+        $text = substr($text, 0, $c);
+        return true;
+    }
+
+
+    /**
+     * Pads a string using PKCS7
+     * Adds padding using the bytes with the value of the
+     * number of bytes need for padding
+     *
+     * @param string $text The string to pad
+     * @param integer The number of bytes to pad
+     * @param integer $bytes
+     * @return boolean Returns true
+     */
+    private static function pkcs7Pad(&$text, $bytes)
+    {
+        $len = $bytes + strlen($text);
+        $text = str_pad($text, $len, chr($bytes), STR_PAD_RIGHT);
+        return true;
+    }
+
+
+    /**
+     * Strips PKCS7 padding from a string
+     *
+     * @param string $text The string to strip padding from
+     * @return boolean Returns true
+     */
+    private static function pkcs7Strip(&$text)
+    {
+        $pos = strlen($text) - 1;
+        $c = ord($text[$pos]);
+
+        if ($c == 0)
+            return true;
+
+        $text = preg_replace('/'.preg_quote(chr($c)).'{'.$c.'}$/', "", $text);
+        return true;
+    }
+
+
+    /**
+     * Pads a string using ISO/IEC 7816-4
+     * Adds byte 0x80 followed by null bytes to pad a string
+     *
+     * @param string $text The string to pad
+     * @param integer The number of bytes to pad
+     * @param integer $bytes
+     * @return boolean Returns true
+     */
+    private static function iso7816Pad(&$text, $bytes)
+    {
+        $text .= chr(0x80);
+        $len = $bytes + strlen($text);
+
+        // if we are only padding one byte, then 0x80 is all we need
+        // else we follow up with null bytes
+        if ($bytes > 1)
+            $text = str_pad($text, ($len - 1), chr(0), STR_PAD_RIGHT);
+
+        return true;
+    }
+
+
+    /**
+     * Strips ISO/IEC 7816-4 padding from a string
+     *
+     * @param string $text The string to strip padding from
+     * @return boolean Returns true
+     */
+    private static function iso7816Strip(&$text)
+    {
+        $c = chr(0x80);
+        $text = preg_replace('/'.preg_quote($c).'\0*$/', '', $text);
+        return true;
+    }
 }
 ?>

includes/libraries/phpcrypt/phpCrypt.php

Indentation +393 added lines, -393 removed lines

@@ -35,423 +35,423 @@
  */
 class PHP_Crypt
 {
-	// Ciphers
-	const CIPHER_3DES			= "3DES";
-	const CIPHER_3WAY			= "3-Way";
-	const CIPHER_AES_128		= "AES-128";
-	const CIPHER_AES_192		= "AES-192";
-	const CIPHER_AES_256		= "AES-256";
-	const CIPHER_ARC4 = "ARC4"; // Alternative RC4
-	const CIPHER_BLOWFISH		= "Blowfish";
-	const CIPHER_CAST_128		= "CAST-128";
-	const CIPHER_CAST_256		= "CAST-256";
-	const CIPHER_DES			= "DES";
-	const CIPHER_ENIGMA = "Enigma";
-	const CIPHER_GOST = "GOST";
-	const CIPHER_RC2			= "RC2";
-	const CIPHER_RIJNDAEL_128	= "Rijndael-128";
-	const CIPHER_RIJNDAEL_192	= "Rijndael-192";
-	const CIPHER_RIJNDAEL_256	= "Rijndael-256";
-	const CIPHER_SKIPJACK		= "Skipjack";
-	const CIPHER_SIMPLEXOR = "SimpleXOR";
-	const CIPHER_VIGENERE		= "Vigenere"; // historical
-
-	// Modes
-	const MODE_CBC	= "CBC";
-	const MODE_CFB	= "CFB"; // 8 bit cfb mode
-	const MODE_CTR	= "CTR";
-	const MODE_ECB	= "ECB";
-	const MODE_NCFB	= "NCFB"; // blocksize cfb mode
-	const MODE_NOFB	= "NOFB"; // blocksize ofb mode
-	const MODE_OFB	= "OFB"; // 8 bit ofb mode
-	const MODE_PCBC	= "PCBC";
-	const MODE_RAW	= "Raw"; // raw encryption, with no mode
-	const MODE_STREAM = "Stream"; // used only for stream ciphers
-
-	// The source of random data used to create keys and IV's
-	// Used for PHP_Crypt::createKey(), PHP_Crypt::createIV()
-	const RAND = "rand"; // uses mt_rand(), windows & unix
-	const RAND_DEV_RAND	= "/dev/random"; // unix only
-	const RAND_DEV_URAND = "/dev/urandom"; // unix only
-	const RAND_WIN_COM = "wincom"; // windows only, COM extension
-	const RAND_DEFAULT_SZ = 32; // the default number of bytes returned
-
-	// Padding types
-	const PAD_ZERO = 0;
-	const PAD_ANSI_X923		= 1;
-	const PAD_ISO_10126		= 2;
-	const PAD_PKCS7 = 3;
-	const PAD_ISO_7816_4	= 4;
-
-
-	/** @type object $cipher An instance of the cipher object selected */
-	private $cipher = null;
-
-	/** @type object $mode An instance of the mode object selected */
-	private $mode = null;
-
-
-	/**
-	 * Constructor
-	 *
-	 * @param string $key The key to use for the selected Cipher
-	 * @param string $cipher The type of cipher to use
-	 * @param string $mode The encrypt mode to use with the cipher
-	 * @param integer $padding The padding type to use. Defaults to PAD_ZERO
-	 * @return string
-	 */
-	public function __construct($key, $cipher = self::CIPHER_AES_128, $mode = self::MODE_ECB, $padding = self::PAD_ZERO)
-	{
-		/*
+    // Ciphers
+    const CIPHER_3DES			= "3DES";
+    const CIPHER_3WAY			= "3-Way";
+    const CIPHER_AES_128		= "AES-128";
+    const CIPHER_AES_192		= "AES-192";
+    const CIPHER_AES_256		= "AES-256";
+    const CIPHER_ARC4 = "ARC4"; // Alternative RC4
+    const CIPHER_BLOWFISH		= "Blowfish";
+    const CIPHER_CAST_128		= "CAST-128";
+    const CIPHER_CAST_256		= "CAST-256";
+    const CIPHER_DES			= "DES";
+    const CIPHER_ENIGMA = "Enigma";
+    const CIPHER_GOST = "GOST";
+    const CIPHER_RC2			= "RC2";
+    const CIPHER_RIJNDAEL_128	= "Rijndael-128";
+    const CIPHER_RIJNDAEL_192	= "Rijndael-192";
+    const CIPHER_RIJNDAEL_256	= "Rijndael-256";
+    const CIPHER_SKIPJACK		= "Skipjack";
+    const CIPHER_SIMPLEXOR = "SimpleXOR";
+    const CIPHER_VIGENERE		= "Vigenere"; // historical
+
+    // Modes
+    const MODE_CBC	= "CBC";
+    const MODE_CFB	= "CFB"; // 8 bit cfb mode
+    const MODE_CTR	= "CTR";
+    const MODE_ECB	= "ECB";
+    const MODE_NCFB	= "NCFB"; // blocksize cfb mode
+    const MODE_NOFB	= "NOFB"; // blocksize ofb mode
+    const MODE_OFB	= "OFB"; // 8 bit ofb mode
+    const MODE_PCBC	= "PCBC";
+    const MODE_RAW	= "Raw"; // raw encryption, with no mode
+    const MODE_STREAM = "Stream"; // used only for stream ciphers
+
+    // The source of random data used to create keys and IV's
+    // Used for PHP_Crypt::createKey(), PHP_Crypt::createIV()
+    const RAND = "rand"; // uses mt_rand(), windows & unix
+    const RAND_DEV_RAND	= "/dev/random"; // unix only
+    const RAND_DEV_URAND = "/dev/urandom"; // unix only
+    const RAND_WIN_COM = "wincom"; // windows only, COM extension
+    const RAND_DEFAULT_SZ = 32; // the default number of bytes returned
+
+    // Padding types
+    const PAD_ZERO = 0;
+    const PAD_ANSI_X923		= 1;
+    const PAD_ISO_10126		= 2;
+    const PAD_PKCS7 = 3;
+    const PAD_ISO_7816_4	= 4;
+
+
+    /** @type object $cipher An instance of the cipher object selected */
+    private $cipher = null;
+
+    /** @type object $mode An instance of the mode object selected */
+    private $mode = null;
+
+
+    /**
+     * Constructor
+     *
+     * @param string $key The key to use for the selected Cipher
+     * @param string $cipher The type of cipher to use
+     * @param string $mode The encrypt mode to use with the cipher
+     * @param integer $padding The padding type to use. Defaults to PAD_ZERO
+     * @return string
+     */
+    public function __construct($key, $cipher = self::CIPHER_AES_128, $mode = self::MODE_ECB, $padding = self::PAD_ZERO)
+    {
+        /*
 		 * CIPHERS
 		 */
-		switch ($cipher)
-		{
-		    case self::CIPHER_3DES:
-			    $this->cipher = new Cipher_3DES($key);
-			    break;
+        switch ($cipher)
+        {
+            case self::CIPHER_3DES:
+                $this->cipher = new Cipher_3DES($key);
+                break;
 
-		    case self::CIPHER_3WAY:
-			    $this->cipher = new Cipher_3WAY($key);
-			    break;
+            case self::CIPHER_3WAY:
+                $this->cipher = new Cipher_3WAY($key);
+                break;
 
-		    case self::CIPHER_AES_128:
-			    $this->cipher = new Cipher_AES_128($key);
-			    break;
+            case self::CIPHER_AES_128:
+                $this->cipher = new Cipher_AES_128($key);
+                break;
 
-		    case self::CIPHER_AES_192:
-			    $this->cipher = new Cipher_AES_192($key);
-			    break;
+            case self::CIPHER_AES_192:
+                $this->cipher = new Cipher_AES_192($key);
+                break;
 
-		    case self::CIPHER_AES_256:
-			    $this->cipher = new Cipher_AES_256($key);
-			    break;
+            case self::CIPHER_AES_256:
+                $this->cipher = new Cipher_AES_256($key);
+                break;
 
-		    case self::CIPHER_ARC4: // an alternative to RC4
-			    $this->cipher = new Cipher_ARC4($key);
-			    break;
+            case self::CIPHER_ARC4: // an alternative to RC4
+                $this->cipher = new Cipher_ARC4($key);
+                break;
 
-		    case self::CIPHER_BLOWFISH:
-			    $this->cipher = new Cipher_Blowfish($key);
-			    break;
+            case self::CIPHER_BLOWFISH:
+                $this->cipher = new Cipher_Blowfish($key);
+                break;
 
-		    case self::CIPHER_CAST_128:
-			    $this->cipher = new Cipher_CAST_128($key);
-			    break;
+            case self::CIPHER_CAST_128:
+                $this->cipher = new Cipher_CAST_128($key);
+                break;
 
-		    case self::CIPHER_CAST_256:
-			    $this->cipher = new Cipher_CAST_256($key);
-			    break;
+            case self::CIPHER_CAST_256:
+                $this->cipher = new Cipher_CAST_256($key);
+                break;
 
-		    case self::CIPHER_DES:
-			    $this->cipher = new Cipher_DES($key);
-			    break;
+            case self::CIPHER_DES:
+                $this->cipher = new Cipher_DES($key);
+                break;
 
-		    case self::CIPHER_ENIGMA:
-			    $this->cipher = new Cipher_Enigma($key);
-			    break;
+            case self::CIPHER_ENIGMA:
+                $this->cipher = new Cipher_Enigma($key);
+                break;
 
-		    case self::CIPHER_GOST:
-			    $this->cipher = new Cipher_GOST($key);
-			    break;
+            case self::CIPHER_GOST:
+                $this->cipher = new Cipher_GOST($key);
+                break;
 
-		    case self::CIPHER_RC2:
-			    $this->cipher = new Cipher_RC2($key);
-			    break;
+            case self::CIPHER_RC2:
+                $this->cipher = new Cipher_RC2($key);
+                break;
 
-		    case self::CIPHER_RIJNDAEL_128:
-			    $this->cipher = new Cipher_Rijndael_128($key);
-			    break;
+            case self::CIPHER_RIJNDAEL_128:
+                $this->cipher = new Cipher_Rijndael_128($key);
+                break;
 
-		    case self::CIPHER_RIJNDAEL_192:
-			    $this->cipher = new Cipher_Rijndael_192($key);
-			    break;
+            case self::CIPHER_RIJNDAEL_192:
+                $this->cipher = new Cipher_Rijndael_192($key);
+                break;
 
-		    case self::CIPHER_RIJNDAEL_256:
-			    $this->cipher = new Cipher_Rijndael_256($key);
-			    break;
+            case self::CIPHER_RIJNDAEL_256:
+                $this->cipher = new Cipher_Rijndael_256($key);
+                break;
 
-		    case self::CIPHER_SIMPLEXOR:
-			    $this->cipher = new Cipher_Simple_XOR($key);
-			    break;
+            case self::CIPHER_SIMPLEXOR:
+                $this->cipher = new Cipher_Simple_XOR($key);
+                break;
 
-		    case self::CIPHER_SKIPJACK:
-			    $this->cipher = new Cipher_Skipjack($key);
-			    break;
+            case self::CIPHER_SKIPJACK:
+                $this->cipher = new Cipher_Skipjack($key);
+                break;
 
-		    case self::CIPHER_VIGENERE:
-			    $this->cipher = new Cipher_Vigenere($key);
-			    break;
+            case self::CIPHER_VIGENERE:
+                $this->cipher = new Cipher_Vigenere($key);
+                break;
 
-		    default:
-			    trigger_error("$cipher is not a valid cipher", E_USER_WARNING);
-		}
+            default:
+                trigger_error("$cipher is not a valid cipher", E_USER_WARNING);
+        }
 
 
-		/*
+        /*
 		 * MODES
 		 */
-		switch ($mode)
-		{
-		    case self::MODE_CBC:
-			    $this->mode = new Mode_CBC($this->cipher);
-			    break;
-
-		    case self::MODE_CFB:
-			    $this->mode = new Mode_CFB($this->cipher);
-			    break;
-
-		    case self::MODE_CTR:
-			    $this->mode = new Mode_CTR($this->cipher);
-			    break;
-
-		    case self::MODE_ECB:
-			    $this->mode = new Mode_ECB($this->cipher);
-			    break;
-
-		    case self::MODE_NCFB:
-			    $this->mode = new Mode_NCFB($this->cipher);
-			    break;
-
-		    case self::MODE_NOFB:
-			    $this->mode = new Mode_NOFB($this->cipher);
-			    break;
-
-		    case self::MODE_OFB:
-			    $this->mode = new Mode_OFB($this->cipher);
-			    break;
-
-		    case self::MODE_PCBC:
-			    $this->mode = new Mode_PCBC($this->cipher);
-			    break;
-
-		    case self::MODE_RAW:
-			    $this->mode = new Mode_RAW($this->cipher);
-			    break;
-
-		    case self::MODE_STREAM:
-			    $this->mode = new Mode_Stream($this->cipher);
-			    break;
-
-		    default:
-			    trigger_error("$mode is not a valid mode", E_USER_WARNING);
-		}
-
-		// set the default padding
-		$this->padding($padding);
-	}
-
-
-	/**
-	 * Destructor
-	 *
-	 * @return void
-	 */
-	public function __destruct()
-	{
-
-	}
-
-
-	/**
-	 * Encrypt a plain text message using the Mode and Cipher selected.
-	 * Some stream modes require this function to be called in a loop
-	 * which requires the use of $result parameter to retrieve
-	 * the decrypted data.
-	 *
-	 * @param string $text The plain text string
-	 * @return string The encrypted string
-	 */
-	public function encrypt($text)
-	{
-		// check that an iv is set, if required by the mode
-		$this->mode->checkIV();
-
-		// the encryption is done inside the mode
-		$this->mode->encrypt($text);
-		return $text;
-	}
-
-
-	/**
-	 * Decrypt an encrypted message using the Mode and Cipher selected.
-	 * Some stream modes require this function to be called in a loop
-	 * which requires the use of $result parameter to retrieve
-	 * the decrypted data.
-	 *
-	 * @param string $text The encrypted string
-	 * @return string The decrypted string
-	 */
-	public function decrypt($text)
-	{
-		// check that an iv is set, if required by the mode
-		$this->mode->checkIV();
-
-		// the decryption is done inside the mode
-		$this->mode->decrypt($text);
-		return $text;
-	}
-
-
-	/**
-	 * Return the cipher object being used
-	 *
-	 * @return object The Cipher object
-	 */
-	public function cipher()
-	{
-		return $this->cipher;
-	}
-
-
-	/**
-	 * Return the mode object being used
-	 *
-	 * @return object The Mode object
-	 */
-	public function mode()
-	{
-		return $this->mode;
-	}
-
-
-	/**
-	 * Returns the name of the cipher being used
-	 *
-	 * @return string The name of the cipher currently in use,
-	 *	it will be one of the predefined phpCrypt cipher constants
-	 */
-	public function cipherName()
-	{
-		return $this->cipher->name();
-	}
-
-
-	/**
-	 * Return the name of the mode being used
-	 *
-	 * @return string The name of the mode in use, it will
-	 * be one of the predefined phpCrypt mode constants
-	 */
-	public function modeName()
-	{
-		return $this->mode->name();
-	}
-
-
-	/**
-	 * Returns Ciphers required block size in bytes
-	 *
-	 * @return integer The cipher data block size, in bytes
-	 */
-	public function cipherBlockSize()
-	{
-		return $this->cipher->blockSize();
-	}
-
-
-	/**
-	 * Returns the cipher's required key size, in bytes
-	 *
-	 * @return integer The cipher's key size requirement, in bytes
-	 */
-	public function cipherKeySize()
-	{
-		return $this->cipher->keySize();
-	}
-
-
-	/**
-	 * Sets and/or returns the key to be used. Normally you set
-	 * the key in the phpCrypt constructor. This can be usefully
-	 * if you need to change the key on the fly and don't want
-	 * to create a new instance of phpCrypt.
-	 *
-	 * If the $key parameter is not given, this function will simply
-	 * return the key currently in use.
-	 *
-	 * @param string $key Optional, The key to set
-	 * @return string The key being used
-	 */
-	public function cipherKey($key = "")
-	{
-		return $this->cipher->key($key);
-	}
-
-
-	/**
-	 * A helper function which will create a random key. Calls
-	 * Core::randBytes(). By default it will use PHP_Crypt::RAND for
-	 * the random source of bytes, and return a PHP_Crypt::RAND_DEFAULT_SZ
-	 * byte string. There are 4 ways to create a random byte string by
-	 * setting the $src parameter:
-	 * PHP_Crypt::RAND - Default, uses mt_rand()
-	 * PHP_Crypt::RAND_DEV_RAND - Unix only, uses /dev/random
-	 * PHP_Crypt::RAND_DEV_URAND - Unix only, uses /dev/urandom
-	 * PHP_Crypt::RAND_WIN_COM - Windows only, uses Microsoft's CAPICOM SDK
-	 *
-	 * @param string $src Optional, The source to use to create random bytes
-	 * @param integer $len Optional, The number of random bytes to return
-	 * @return string A random string of bytes
-	 */
-	public static function createKey($src = self::RAND, $len = self::RAND_DEFAULT_SZ)
-	{
-		return Core::randBytes($src, $len);
-	}
-
-
-	/**
-	 * Sets the IV to use. Note that you do not need to call
-	 * this function if creating an IV using createIV(). This
-	 * function is used when an IV has already been created
-	 * outside of phpCrypt and needs to be set. Alternatively
-	 * you can just pass the $iv parameter to the encrypt()
-	 * or decrypt() functions
-	 *
-	 * When the $iv parameter is not given, the function will
-	 * return the current IV being used. See createIV() if you
-	 * need to create an IV.
-	 *
-	 * @param string $iv Optional, The IV to use during Encryption/Decryption
-	 * @return void
-	 */
-	public function IV($iv = "")
-	{
-		return $this->mode->IV($iv);
-	}
-
-
-	/**
-	 * Creates an IV for the the Cipher selected, if one is required.
-	 * If you already have an IV to use, this function does not need
-	 * to be called, instead set it with setIV(). If you create an
-	 * IV with createIV(), you do not need to set it with setIV(),
-	 * as it is automatically set in this function
-	 *
-	 * $src values are:
-	 * PHP_Crypt::RAND - Default, uses mt_rand()
-	 * PHP_Crypt::RAND_DEV_RAND - Unix only, uses /dev/random
-	 * PHP_Crypt::RAND_DEV_URAND - Unix only, uses /dev/urandom
-	 * PHP_Crypt::RAND_WIN_COM - Windows only, uses Microsoft's CAPICOM SDK
-	 *
-	 * @param string $src Optional, how the IV is generated
-	 * @return string The IV that was created, and set for the mode
-	 */
-	public function createIV($src = self::RAND)
-	{
-		return $this->mode->createIV($src);
-	}
-
-
-	/**
-	 * Sets the type of padding to be used within the specified Mode
-	 *
-	 * @param string $type One of the predefined padding types
-	 * @return void
-	 */
-	public function padding($type = "")
-	{
-		return $this->mode->padding($type);
-	}
+        switch ($mode)
+        {
+            case self::MODE_CBC:
+                $this->mode = new Mode_CBC($this->cipher);
+                break;
+
+            case self::MODE_CFB:
+                $this->mode = new Mode_CFB($this->cipher);
+                break;
+
+            case self::MODE_CTR:
+                $this->mode = new Mode_CTR($this->cipher);
+                break;
+
+            case self::MODE_ECB:
+                $this->mode = new Mode_ECB($this->cipher);
+                break;
+
+            case self::MODE_NCFB:
+                $this->mode = new Mode_NCFB($this->cipher);
+                break;
+
+            case self::MODE_NOFB:
+                $this->mode = new Mode_NOFB($this->cipher);
+                break;
+
+            case self::MODE_OFB:
+                $this->mode = new Mode_OFB($this->cipher);
+                break;
+
+            case self::MODE_PCBC:
+                $this->mode = new Mode_PCBC($this->cipher);
+                break;
+
+            case self::MODE_RAW:
+                $this->mode = new Mode_RAW($this->cipher);
+                break;
+
+            case self::MODE_STREAM:
+                $this->mode = new Mode_Stream($this->cipher);
+                break;
+
+            default:
+                trigger_error("$mode is not a valid mode", E_USER_WARNING);
+        }
+
+        // set the default padding
+        $this->padding($padding);
+    }
+
+
+    /**
+     * Destructor
+     *
+     * @return void
+     */
+    public function __destruct()
+    {
+
+    }
+
+
+    /**
+     * Encrypt a plain text message using the Mode and Cipher selected.
+     * Some stream modes require this function to be called in a loop
+     * which requires the use of $result parameter to retrieve
+     * the decrypted data.
+     *
+     * @param string $text The plain text string
+     * @return string The encrypted string
+     */
+    public function encrypt($text)
+    {
+        // check that an iv is set, if required by the mode
+        $this->mode->checkIV();
+
+        // the encryption is done inside the mode
+        $this->mode->encrypt($text);
+        return $text;
+    }
+
+
+    /**
+     * Decrypt an encrypted message using the Mode and Cipher selected.
+     * Some stream modes require this function to be called in a loop
+     * which requires the use of $result parameter to retrieve
+     * the decrypted data.
+     *
+     * @param string $text The encrypted string
+     * @return string The decrypted string
+     */
+    public function decrypt($text)
+    {
+        // check that an iv is set, if required by the mode
+        $this->mode->checkIV();
+
+        // the decryption is done inside the mode
+        $this->mode->decrypt($text);
+        return $text;
+    }
+
+
+    /**
+     * Return the cipher object being used
+     *
+     * @return object The Cipher object
+     */
+    public function cipher()
+    {
+        return $this->cipher;
+    }
+
+
+    /**
+     * Return the mode object being used
+     *
+     * @return object The Mode object
+     */
+    public function mode()
+    {
+        return $this->mode;
+    }
+
+
+    /**
+     * Returns the name of the cipher being used
+     *
+     * @return string The name of the cipher currently in use,
+     *	it will be one of the predefined phpCrypt cipher constants
+     */
+    public function cipherName()
+    {
+        return $this->cipher->name();
+    }
+
+
+    /**
+     * Return the name of the mode being used
+     *
+     * @return string The name of the mode in use, it will
+     * be one of the predefined phpCrypt mode constants
+     */
+    public function modeName()
+    {
+        return $this->mode->name();
+    }
+
+
+    /**
+     * Returns Ciphers required block size in bytes
+     *
+     * @return integer The cipher data block size, in bytes
+     */
+    public function cipherBlockSize()
+    {
+        return $this->cipher->blockSize();
+    }
+
+
+    /**
+     * Returns the cipher's required key size, in bytes
+     *
+     * @return integer The cipher's key size requirement, in bytes
+     */
+    public function cipherKeySize()
+    {
+        return $this->cipher->keySize();
+    }
+
+
+    /**
+     * Sets and/or returns the key to be used. Normally you set
+     * the key in the phpCrypt constructor. This can be usefully
+     * if you need to change the key on the fly and don't want
+     * to create a new instance of phpCrypt.
+     *
+     * If the $key parameter is not given, this function will simply
+     * return the key currently in use.
+     *
+     * @param string $key Optional, The key to set
+     * @return string The key being used
+     */
+    public function cipherKey($key = "")
+    {
+        return $this->cipher->key($key);
+    }
+
+
+    /**
+     * A helper function which will create a random key. Calls
+     * Core::randBytes(). By default it will use PHP_Crypt::RAND for
+     * the random source of bytes, and return a PHP_Crypt::RAND_DEFAULT_SZ
+     * byte string. There are 4 ways to create a random byte string by
+     * setting the $src parameter:
+     * PHP_Crypt::RAND - Default, uses mt_rand()
+     * PHP_Crypt::RAND_DEV_RAND - Unix only, uses /dev/random
+     * PHP_Crypt::RAND_DEV_URAND - Unix only, uses /dev/urandom
+     * PHP_Crypt::RAND_WIN_COM - Windows only, uses Microsoft's CAPICOM SDK
+     *
+     * @param string $src Optional, The source to use to create random bytes
+     * @param integer $len Optional, The number of random bytes to return
+     * @return string A random string of bytes
+     */
+    public static function createKey($src = self::RAND, $len = self::RAND_DEFAULT_SZ)
+    {
+        return Core::randBytes($src, $len);
+    }
+
+
+    /**
+     * Sets the IV to use. Note that you do not need to call
+     * this function if creating an IV using createIV(). This
+     * function is used when an IV has already been created
+     * outside of phpCrypt and needs to be set. Alternatively
+     * you can just pass the $iv parameter to the encrypt()
+     * or decrypt() functions
+     *
+     * When the $iv parameter is not given, the function will
+     * return the current IV being used. See createIV() if you
+     * need to create an IV.
+     *
+     * @param string $iv Optional, The IV to use during Encryption/Decryption
+     * @return void
+     */
+    public function IV($iv = "")
+    {
+        return $this->mode->IV($iv);
+    }
+
+
+    /**
+     * Creates an IV for the the Cipher selected, if one is required.
+     * If you already have an IV to use, this function does not need
+     * to be called, instead set it with setIV(). If you create an
+     * IV with createIV(), you do not need to set it with setIV(),
+     * as it is automatically set in this function
+     *
+     * $src values are:
+     * PHP_Crypt::RAND - Default, uses mt_rand()
+     * PHP_Crypt::RAND_DEV_RAND - Unix only, uses /dev/random
+     * PHP_Crypt::RAND_DEV_URAND - Unix only, uses /dev/urandom
+     * PHP_Crypt::RAND_WIN_COM - Windows only, uses Microsoft's CAPICOM SDK
+     *
+     * @param string $src Optional, how the IV is generated
+     * @return string The IV that was created, and set for the mode
+     */
+    public function createIV($src = self::RAND)
+    {
+        return $this->mode->createIV($src);
+    }
+
+
+    /**
+     * Sets the type of padding to be used within the specified Mode
+     *
+     * @param string $type One of the predefined padding types
+     * @return void
+     */
+    public function padding($type = "")
+    {
+        return $this->mode->padding($type);
+    }
 }
 ?>