Haneev webdesign

<?PHP
/**
 * Basis curl class met cookie ondersteuning
 * 
 * @author Han */
 
class CurlIt {
	
		/**
	 * Contstante waar een temp bestand naar geschreven moet worden
	 * @var str
	 */
	const TEMP_UPLOAD_DIR = 'tempfiles';	/**
	 * User Agent String, eventueel aangepast
	 * @var str
	 */
	private $user_agent;	
	/**
	 * Disable ssl check, valideer certificaat of niet
	 * @var boolean
	 */	private $disable_ssl;
	
	
	/**
	 * Private storage of cookie	 * @var array|str
	 */
	private $cookie;
	
		/**
	 * Huidige CurlChannel, er kan in PHP maar 1 ding tegelijk dus dan kan dit. In Java kan dit niet
	 * @var resource
	 */
	protected $ch;	
	
	/**
	 * Referer
	 * @var str	 */
	protected $referer;
	
	/**
	 * Initialiseer de Class	 * @param $user_agent   mix 	    NULL geeft huidige user_agent anders je eigen
	 * @param $disable_ssl  boolean 	Disable ssl check
	 * @return void
	 */
	public function __construct($user_agent = null,$disable_ssl = true) {	
	// Browser
	if($user_agent != null) {
		$this->user_agent = $user_agent;
	} else {		$this->user_agent = isset($_SERVER['HTTP_USER_AGENT']) ? $_SERVER['HTTP_USER_AGENT'] : 'WebmailProxy 1.0 (Mozilla Compatible)';
	}
	
	$this->disable_ssl = $disable_ssl;
		// Check voor upload dir
	if(!is_writable(self::TEMP_UPLOAD_DIR)) {
		throw new Exception('Map voor uploaden van bestanden bestaat niet of is niet schrijfbaar');
	}
	}	
	/**
	 * Init A connection
	 * @param $url  URL of page
	 * @return resource	 */
	private function init($url) {
	
	$this->ch = curl_init();
		// Set referer tot de laatste
	if(!empty($this->referer)) {
		curl_setopt($this->ch,CURLOPT_REFERER,$this->referer);
	}
	// Nieuwe ref	$this->referer = $url;
	
	// set URL
	curl_setopt($this->ch,CURLOPT_URL,$url);
	// Disable ssl	if($this->disable_ssl) {
		curl_setopt ($this->ch, CURLOPT_SSL_VERIFYHOST, false);
		curl_setopt ($this->ch, CURLOPT_SSL_VERIFYPEER, false);
	} 
		// Set options
	curl_setopt($this->ch,CURLOPT_USERAGENT,$this->user_agent);
	curl_setopt($this->ch,CURLOPT_RETURNTRANSFER,true);
	curl_setopt($this->ch,CURLOPT_HEADER,true);
	curl_setopt($this->ch,CURLOPT_FOLLOWLOCATION,true);	curl_setopt($this->ch,CURLOPT_AUTOREFERER,true);
		
	return $this->ch;
	}
		/**
	 * 
	 * @param $url  URL to get
	 * @param $cookie       Set stored cookie for this session
	 * @return str  Content of website	 */
	public function get($url,$cookie = false) {
	
	$this->init($url);
		// Als cookie wel moet, store hem dan
	if($cookie) {
		curl_setopt($this->ch,CURLOPT_COOKIE,$this->getStoredCookie());
	}
		// Uitvoeren
	$parse = $this->exec($this->ch);
	
	
		// Cookie store?
	if($cookie === false) {
		$this->parseCookies($parse['header']);
	}
	$this->parseHeader($parse['header']);	
	curl_close($this->ch);
	
	
	return $parse['content'];	}
	
	
	/**
	 * Post A form, with or withoud cookie	 * @param $url
	 * @param $postdata
	 * @param $cookie
	 * @return str
	 */	public function post($url,$postdata,$cookie = false) {
	
	// Preparepost
	foreach($postdata as $key => $v) {
		$nkey = str_replace('_','.',$key);		$postdata[$nkey] = $v;
		
		// Niet een bestaande checken
		if($nkey != $key) {
		unset($postdata[$key]);		}
	}
	
	// Initaliseer
	$this->init($url);	
	// _FILES gebeuren
	$uploaded_files = array();
	if(isset($_FILES)) {
		// Groote en bestanden		foreach($_FILES as $key => $val) {
		$nkey = str_replace('_','.',$key);
		$f = '@'.$this->handleUpload($val);
		$uploaded_files[] = ltrim($f,'@');
		$postdata[$nkey] = $f;		}
	}
	
	
		// Als cookie wel moet, store hem dan
	if($cookie) {
		curl_setopt($this->ch,CURLOPT_COOKIE,$this->getStoredCookie());
	}
		curl_setopt($this->ch,CURLOPT_POST,1);
	curl_setopt($this->ch,CURLOPT_POSTFIELDS,$postdata);
	
	$parse = $this->exec($this->ch);
		
	// Cookie store?
	if($cookie === false) {
		$this->parseCookies($parse['header']);
	}	$this->parseHeader($parse['header']);
	
	curl_close($this->ch);
	
	// Verwijder de bestanden weer	foreach($uploaded_files as $v) {
		unlink($v);
	}
	
		
	return $parse['content'];
	}
	
	/**	 * Uitvoeren van operatie
	 * @return unknown_type
	 */
	public function exec() {
		$out = curl_exec($this->ch);
	
	$error = curl_error($this->ch);
	if(!empty($error)) {
		throw new Exception('cURL ERROR: '.$error.' ('.curl_errno($this->ch).')');	}
	
	$parse = $this->splitContent($out);
	
	// Foute code? Gooi fout!	if(httpCodes::exists($parse['code'])) {
		throw new Exception($parse['code'].' '.httpCodes::getCode($parse['code']),$parse['code']);
	}
	
	return $parse;	}
	
	/**
	 * handleTheUpload
	 * @param $file	 * @return str
	 */
	private function handleUpload($file) {
	if(is_uploaded_file($file['tmp_name'])) {
		$dest = getDir($_SERVER['SCRIPT_FILENAME']).'/'.self::TEMP_UPLOAD_DIR.'/'.$file['name'];		if(move_uploaded_file($file['tmp_name'],$dest)) {
		return $dest;
		} else {
		throw new Exception('Dest niet schrijven, dest: '.$dest);
		}	} 
	}
	
	/**
	 * Get cookie array	 * @return array
	 */
	public function getCookies() {
	return $this->cookie;
	}	
	/**
	 * Voeg cookie toe aan array
	 * @param $key  str
	 * @param $data str	 * @return void
	 */
	public function addCookie($key,$data) {
	$explode = explode(';',$data);
	$this->cookie[$key] = trim($explode[0]);		}
	
	/**
	 * Verwijder cookie
	 * @param $key	 * @return void
	 */
	public function removeCookie($key) {
	unset($this->cookie[$key]);     
	}	
	/**
	 * Reset en Set de class met array data
	 * @param $data array
	 * @return void	 */
	public function setCookies(array $data) {
	$this->cookie = $data;
	}
		/**
	 * Set referer
	 * @param $ref
	 * @return str
	 */	public function setReferer($ref) {
	if($ref != null) {
		$this->referer = $ref;
	}
	}	
	/**
	 * Parse the header string en zet het in de cookie array voor later
	 * @param $header
	 * @return void	 */
	private function parseCookies($header) {
	$patt = '#Set-Cookie: ([a-z0-9]+)=(.*)#i';
	preg_match_all($patt,$header,$return);
		foreach($return[1] as $key => $id) {
		$this->addCookie($id,$return[2][$key]);
	}
	}
		/**
	 * Parse the whole header
	 * @param $header
	 * @return str
	 */	public function parseHeader($h) {
	$ex = explode("\n",$h);
	
	foreach($ex as $v) {    
		if(strstr($v,'Content-') !== false) {		
		if(strstr($v,'Content-Type')) continue; 
		header($v);
		}
	}	}
	
	/**
	 * Get stored cookie in CURL format
	 * @return str	 */
	private function getStoredCookie() {
	
	$ret = '';
	foreach($this->cookie as $key => $val) {		$ret .= $key.'='.$val.';';
	}
	
	return rtrim($ret,';');
	}	
	/**
	 * Split content in header en content deel
	 * @param $content
	 * @return array (header,content)	 */
	private function splitContent($data) {
	
	$patt = "#HTTP/1.1 ([0-9]+) (.*)\n#i";
	$match = preg_split($patt,$data);	
	// Match error code
	preg_match_all($patt,$data,$codes);
	
	// Laatste	$data = end($match);
	$ex = explode("\n",$data);
	
	$header 	= '';
	$content        = '';	$headersplit    = true;
	
	foreach($ex as $v) {
		
		// Lege regel, dus dan is de rest content		$x = trim($v);
		if(empty($x)) {
		$headersplit = false;   
		}
				if($headersplit === true) {
		$header .= $v."\n";
		} else {
		$content .= $v."\n";
		}		
	}
	
	
	$ret = array();	$ret['header']  = $header;
	$ret['content'] 	= $content;
	$ret['code']    = end($codes[1]);
	
	return $ret;	}
	
}
 
 ?>

<?php
/**
 * http status codes
 * 
 * @author Han *
 */
class httpCodes {
	
	/**	 * Array of http status codes
	 * @var Array of codes
	 */
	public static $codes = array(   
	404 => 'File not Found',	403 => 'Forbidden',
	500 => 'Server Error',
	504 => 'Gateway Timeout',
	503 => 'Service niet beschikbaar',
	502 => 'Bad gateway',	415 => 'Unsupported media type',
	414 => 'Request uri too long',
	410 => 'Gone, weggelopen',
	401 => 'Unauthorized',
	400 => 'Bad Request'	);
 
	
	/**
	 * Bestaat code?	 * @param $code
	 * @return bool
	 */
	public static function exists($code) {
	return isset(self::$codes[$code]);	}
	
	/**
	 * Get omschrijving
	 * @param $code	 * @return str
	 */
	public static function getCode($code) {
	if(self::exists($code)) {
		return self::$codes[$code];	}
	throw new Exception('Error code not supported');
	}
}
?>