php写的http协议

这个协议纯自已手工打造，超级灵活，如，我可以用它来分析wireshark的截包

用法请看 test函数.  用到请保留作者信息。 

<?php
/**
 * 
 * @author aerror
 *
 */
class HttpHeader
{
	public $method;
	public $status_code;
	public $chunked;
	public $status_line;
	public $headers;
	public $content_len;
	public $header_len;
	public $contentEncoding;
	public function HttpHeader()
	{
		self::reset();
	}
	public function reset()
	{
		$this->headers = array();
		$this->status_code=0;
		$this->chunked=0;
		$this->status_line="";
		$this->content_len=0;
		$this->header_len=0;
		$this->contentEncoding = "";
	}
};

class XAutoBuffer
{
	private $m_innerbuf="";
	private $length=0;
	private $each_inc_size=1024;
	public function XAutoBuffer($initSize)
	{
		$this->m_innerbuf="";
		$this->length = 0;
	}

	public function Append($buf, $offset, $len)
	{
		$this->m_innerbuf .= substr($buf, $offset,$len);

		$this->length +=$len;
	}

	public function SetLength($val)
	{
	
		$this->m_innerbuf = substr($this->m_innerbuf,0,$val);
		$this->length = $val;
	}

	public function GetLength()
	{
		return $this->length;
	}

	public function GetBuffer()
	{
		return $this->m_innerbuf;
	}

	public function Clear()
	{
	    $this->m_innerbuf="";
		$this->length =0;
	}

}


class HttpContext
{

	public $m_header;
	public $m_state;
	public $m_bHeaderReceived;
	public $m_cur_chunk_len;
	public $m_cur_chunk_read;
	public $m_chunk_hdr_offset;
	public $header_origin;
	public function HttpContext()
	{
		self::reset();
	}

	public function  reset()
	{
		$this->m_header = new HttpHeader();
		$this->m_state = 0;
		$this->m_bHeaderReceived=0;
		$this->m_cur_chunk_len=0;
		$this->m_cur_chunk_read=0;
		$this->m_chunk_hdr_offset=0;
		$this->header_origin=0;
	}

	public function  getHeaderValueByName($name)
	{
		foreach($this->m_header->headers as $p)
		{

			if($p['name'] == $name)
			{
				return $p['value'];
			}
		}
		return null;
	}
};


class HttpProtocolClient
{

	const		NEW_PACKET=0;
	const		RECEIVING_HEADER=1;
	const		RECEIVING_CONTENT=2;
	const		RECEIVING_CHUNKED_LEN=3;
	const		RECEIVING_CHUNKED_BODY=4;
	const		PACKET_COMPLETE=5;
	const		PACKET_PARSE_FAILED=6;
	const MAX_HEADER_LEN				 =2048;
	const HTTP_HEADER_END_STRING	=	 "\r\n\r\n";
	const HTTP_HEADER_END_STRING_SIZE =4;
	const HTTP_1_1_MAGIC			=	 "HTTP/1.";
	const HTTP_1_1_MAGIC_LEN			 =7;
	const HTTP_HEAD_CONNECTION   =     	"Connection";
	const HTTP_TRANSFER_ENCODING	=	"Transfer-Encoding";
	const HTTP_CONTENT_ENCODING	=	"Content-Encoding";
	const HTTP_CONTENT_LENGTH	=	"Content-length";
	const HTTP_CHUNKED			 = "chunked";
	const HTTP_TEXT_HTML		=	 "text/html";
	const HTTP_CHUNKED_END		= "0\r\n\r\n";
	const HTTP_CRLF			= "\r\n";
	const HTTP_CRLF_SIZE			= 2;
	const XPROTO_FAILED					=-1;
	const XPROTO_REMAIN_LENGTH_ERROR		=-2;
	const XPROTO_XCMD_OUT_OF_RANGE		=-3;
	const XPROTO_PACKET_LENGTH_OVERFLOW	=-4;
	const XPROTO_PACKET_NOT_COMPLETED	=-5;
	const XPROTO_PACKET_LESS_THAN_HDRLEN	=-6;
	const XPROTO_DISPATCH_EXCEPTION		=-7;
	const XPROTO_OUT_OF_MEMORY			=-8;
	const XPROTO_GET_SEND_BUFF_FAILED	=-9;
	const XPROTO_FROM_BUFF_FAILED		=-10;
	const XPROTO_TO_BUFF_FAILED			=-11;
	const XPROTO_XML_NODE_NOT_FOUND		=-12;
	const XPROTO_TOO_LESS_HEADER_LINE	=-13;
	const XPROTO_MAGIC_NOT_MATCH			=-14;
	const XPROTO_TOO_LESS_HEADER_VALUE	=-15;
	const XPROTO_PROTOCOL_STATE_WRONG	=-16;
	const XPROTO_PARSE_HEADER_FAILED		=-17;
	const XPROTO_MAX_HEADER_LEN			=-18;
	const XPROTO_UNKOWN_CONTENT_TYPE		=-19;
	const XPROTO_UNSUPPORT_TRANS_TYPE	=-20;


	public static function strsnstr(
			$dest1,$dst1Off, $dstlen1,
			$dest2,$dst2Off, $dstlen2,
			$src,$srclen)
	{
		$dlen = $dstlen1+ $dstlen2;
		$p1  = 0;
		$p2 = 0;
		for($j=0;$j<=$dlen-$srclen;$j++)
		{

				
			$p1 =$dst1Off+$j;
				

			$match=1;
			for($i=0;$i<$srclen;$i++)
			{

				if(($j+$i) < $dstlen1)
				{
					$p2 = $dest1[$dst1Off+$j+$i];
				}
				else
				{
					$p2 = $dest2[$dst2Off+$j+$i-$dstlen1];
				}

				if($p2!=$src[$i])
				{
					$match=0;
					break;
				}
			}

			if($match!=0)
			{
				return $p1;
			}
		}
		return -1;
	}


	public static function HexStringnToIntegerA($lpHexString, $offset, $len)
	{
		$x=substr($lpHexString, $offset, $len);
		return hexdec($x);
	}




	public static function parseHttp($ctx,  $inputBuf,$len, $buf )
	{
		$byteAvailable = $len;
		$curOffset=0;

		$res =0;
		$phdr = null;

		//uses state machine.
		//
		while($byteAvailable>0)
		{

			switch($ctx->m_state)
			{
				case HttpProtocolClient::NEW_PACKET:
					{
						//new packet
						//
						$ctx->m_state =HttpProtocolClient::RECEIVING_HEADER;
						continue;
					}

				case HttpProtocolClient::RECEIVING_HEADER:
					{
						$ptemp = 0;
						if($buf->GetLength()>=HttpProtocolClient::HTTP_HEADER_END_STRING_SIZE)
						{
							$ptemp =self::strsnstr(
									$buf->GetBuffer(),  //d1
									$buf->GetLength()-HttpProtocolClient::HTTP_HEADER_END_STRING_SIZE,//do1
									HttpProtocolClient::HTTP_HEADER_END_STRING_SIZE,//dl2
									$inputBuf,
									$curOffset,
									$byteAvailable,
									HttpProtocolClient::HTTP_HEADER_END_STRING,
									HttpProtocolClient::HTTP_HEADER_END_STRING_SIZE);
						}
						else
						{
							$ptemp =self::strsnstr(
									$buf->GetBuffer(),
									0,
									$buf->GetLength(),
									$inputBuf,
									$curOffset,
									$byteAvailable,
									HttpProtocolClient::HTTP_HEADER_END_STRING,
									HttpProtocolClient::HTTP_HEADER_END_STRING_SIZE);
						}
							
							
						if($ptemp<0)
						{
							if($byteAvailable+$buf->GetLength() >HttpProtocolClient::MAX_HEADER_LEN )
							{
								$ctx->m_state =(HttpProtocolClient::PACKET_PARSE_FAILED);
								return HttpProtocolClient::XPROTO_MAX_HEADER_LEN;
							}

							//header not completed.
							//

							$buf->Append($inputBuf,$curOffset,$byteAvailable);

							//update pointers.
							//

							$curOffset+=$byteAvailable;
							$byteAvailable = 0;

							$ctx->m_state =(HttpProtocolClient::RECEIVING_HEADER);
							return $len;
						}

						//head completed.
						//
						$hdrRemain = 0;
						if($ptemp < $buf->GetLength())
						{
							$hdrRemain = (int)(HttpProtocolClient::HTTP_HEADER_END_STRING_SIZE-
									($buf->GetLength() -$ptemp));
						}
						else
						{
							$hdrRemain = (int)(($ptemp-$buf->GetLength()) + HttpProtocolClient::HTTP_HEADER_END_STRING_SIZE);
						}
							
						if($hdrRemain+$buf->GetLength() > HttpProtocolClient::MAX_HEADER_LEN )
						{
							$ctx->m_state =(HttpProtocolClient::PACKET_PARSE_FAILED);
							return HttpProtocolClient::XPROTO_MAX_HEADER_LEN;
						}
							
							
						$buf->Append($inputBuf,$curOffset,$hdrRemain);

						//var_dump($buf);
						//update pointers.
						//
						$curOffset+=$hdrRemain;
						$byteAvailable-= $hdrRemain;

						$ctx->m_bHeaderReceived = 1;
						if(($res=HttpProtocolClient::ParseHeader($ctx,$buf->GetBuffer(),$buf->GetLength()))!=0)
						{
							$ctx->m_state =(HttpProtocolClient::PACKET_PARSE_FAILED);
							return $res;
						}

						if($ctx->m_header->chunked!=0)
						{

							//very import to update the content pointer.
							//
							$ctx->m_chunk_hdr_offset = $buf->GetLength();
							$ctx->m_state =(HttpProtocolClient::RECEIVING_CHUNKED_LEN);
								
						}
						else
						{
							//$ctx->m_header->all = pCurrentBuf-hdr_len;
							$ctx->m_state =(HttpProtocolClient::RECEIVING_CONTENT);
							if($ctx->m_header->content_len ==0) //sometime head with content-length:0, suck!
							{
								$ctx->m_state =(HttpProtocolClient::PACKET_COMPLETE);
								return $len-$byteAvailable;
							}
						}
						continue;
					}

				case HttpProtocolClient::RECEIVING_CONTENT:
					{
						$phdr =$ctx->m_header;
						if($phdr->content_len >0)
						{

							$remainLen = $phdr->content_len + $phdr->header_len - $buf->GetLength();
							if($byteAvailable < $remainLen)
							{
								//not completed
								//copy and return
								//
									
								$buf->Append($inputBuf,$curOffset,$byteAvailable);

								//should use this.buf
								//
									

									
								$byteAvailable =0;
								$ctx->m_state =(HttpProtocolClient::RECEIVING_CONTENT);
								return $len;
							}

							$buf->Append($inputBuf,$curOffset,$remainLen);

							$curOffset		+= $remainLen;
							$byteAvailable	-= $remainLen;

						}



						$ctx->m_state =(HttpProtocolClient::PACKET_COMPLETE);
						return $len-$byteAvailable;
					}
					//break;//case RECEIVING_CONTENT

				case HttpProtocolClient::RECEIVING_CHUNKED_LEN:
					{
						/*0x48,0x54,0x54,0x50,0x2F,0x31,0x2E,0x31,0x20,0x32,0x30,0x30,0x20,0x4F,0x4B,0x0D,0x0A,0x53,0x65,0x72,0x76,0x65,0x72,0x3A,0x20,0x6E,0x67,0x69,0x6E,0x78,0x2F,0x30,
						 0x2E,0x37,0x2E,0x36,0x32,0x0D,0x0A,0x44,0x61,0x74,0x65,0x3A,0x20,0x53,0x61,0x74,0x2C,0x20,0x32,0x35,0x20,0x4A,0x75,0x6E,0x20,0x32,0x30,0x31,0x31,0x20,0x31,0x33,
						0x3A,0x30,0x36,0x3A,0x35,0x35,0x20,0x47,0x4D,0x54,0x0D,0x0A,0x43,0x6F,0x6E,0x74,0x65,0x6E,0x74,0x2D,0x54,0x79,0x70,0x65,0x3A,0x20,0x69,0x6D,0x61,0x67,0x65,0x2F,
						0x67,0x69,0x66,0x0D,0x0A,0x54,0x72,0x61,0x6E,0x73,0x66,0x65,0x72,0x2D,0x45,0x6E,0x63,0x6F,0x64,0x69,0x6E,0x67,0x3A,0x20,0x63,0x68,0x75,0x6E,0x6B,0x65,0x64,0x0D,
						0x0A,0x43,0x6F,0x6E,0x6E,0x65,0x63,0x74,0x69,0x6F,0x6E,0x3A,0x20,0x63,0x6C,0x6F,0x73,0x65,0x0D,0x0A,0x0D,0x0A,0x32,0x62,0x0D,0x0A,0x47,0x49,0x46,0x38,0x39,0x61,
						0x01,0x00,0x01,0x00,0x80,0x00,0x00,0xFF,0xFF,0xFF,0x00,0x00,0x00,0x21,0xF9,0x04,0x01,0x00,0x00,0x00,0x00,0x2C,0x00,0x00,0x00,0x00,0x01,0x00,0x01,0x00,0x00,0x02,
						0x02,0x44,0x01,0x00,0x3B,0x0D,0x0A,0x31,0x0D,0x0A,0x31,0x0D,0x0A,0x30,0x0D,0x0A,0x0D,0x0A*/

						$ptemp = 0;
							
						$cur_chunk_hdr_len = (int)($buf->GetLength() - $ctx->m_chunk_hdr_offset);
						$chunkHdr = $ctx->m_chunk_hdr_offset;
							
						if($cur_chunk_hdr_len >=HttpProtocolClient::HTTP_CRLF_SIZE)
						{
							$ptemp =self::strsnstr(
									$buf->GetBuffer(),
									$buf->GetLength()-HttpProtocolClient::HTTP_CRLF_SIZE,
									HttpProtocolClient::HTTP_CRLF_SIZE,
									$inputBuf,
									$curOffset,
									$byteAvailable,
									HttpProtocolClient::HTTP_CRLF,
									HttpProtocolClient::HTTP_CRLF_SIZE);
						}
						else
						{
							$ptemp =self::strsnstr(
									$buf->GetBuffer(),
									$chunkHdr,
									$cur_chunk_hdr_len,
									$inputBuf,
									$curOffset,
									$byteAvailable,
									HttpProtocolClient::HTTP_CRLF,
									HttpProtocolClient::HTTP_CRLF_SIZE);
						}

							
						if($ptemp<0)
						{
							//chunked len not completed.
							//
							$buf->Append($inputBuf,$curOffset,$byteAvailable);

							//update pointers.
							//

							$curOffset+=$byteAvailable;
							$byteAvailable = 0;

							$ctx->m_state =(HttpProtocolClient::RECEIVING_CHUNKED_LEN);
							return $len;
						}

						//head completed.
						//
						$hdrRemain = 0;
						if($ptemp < $buf->GetLength())
						{
							//partial header received.
							//
							$hdrRemain = (int)(HttpProtocolClient::HTTP_CRLF_SIZE-($buf->GetLength() -$ptemp));
						}
						else
						{
							$hdrRemain = (int)(($ptemp-$buf->GetLength())+HttpProtocolClient::HTTP_CRLF_SIZE);
						}
							
						if($hdrRemain+$cur_chunk_hdr_len >12 )
						{
							$ctx->m_state =(HttpProtocolClient::PACKET_PARSE_FAILED);
							return HttpProtocolClient::XPROTO_MAX_HEADER_LEN;
						}

						$cur_chunk_hdr_len +=$hdrRemain;
							
						$buf->Append($inputBuf,$curOffset,$hdrRemain);
						//calc again , because bufs will realloc.
						//
						$chunkHdr = $ctx->m_chunk_hdr_offset;

						//update pointers.
						//
							
						$curOffset+=$hdrRemain;
						$byteAvailable-= $hdrRemain;

							
						$ctx->m_cur_chunk_len  = (int)HttpProtocolClient::HexStringnToIntegerA($buf->GetBuffer(),$chunkHdr,$cur_chunk_hdr_len);
						$ctx->m_cur_chunk_read = 0;
							
						//skip the header before copy chunk body
						//
						$buf->SetLength($buf->GetLength()-$cur_chunk_hdr_len);

						$ctx->m_state =(HttpProtocolClient::RECEIVING_CHUNKED_BODY);
							
							
					}//case RECEIVING_CHUNKED_LEN
					break;

				case HttpProtocolClient::RECEIVING_CHUNKED_BODY:
					{
						$remainLen = ($ctx->m_cur_chunk_len + HttpProtocolClient::HTTP_CRLF_SIZE)-$ctx->m_cur_chunk_read;
							
						if($byteAvailable < $remainLen)
						{
							//not completed
							//copy and return
							//
							$buf->Append($inputBuf,$curOffset,$byteAvailable);
							$ctx->m_cur_chunk_read+=$byteAvailable;

							$byteAvailable =0;
							$ctx->m_state =(HttpProtocolClient::RECEIVING_CHUNKED_BODY);
							return $len;
						}

						//here should be a completed chunk body.
						//
						$buf->Append($inputBuf,$curOffset,$remainLen);
						$ctx->m_cur_chunk_read+=$remainLen;
						$buf->SetLength($buf->GetLength()-HttpProtocolClient::HTTP_CRLF_SIZE);//SKIP BODY CRLF
						$curOffset += $remainLen;
						$byteAvailable -= $remainLen;
							
						if($ctx->m_cur_chunk_len==0)
						{

							//chunk over.
							//
							$ctx->m_state =(HttpProtocolClient::PACKET_COMPLETE);

							//must set content_len  before dispatch
							//
							$ctx->m_header->content_len = $buf->GetLength() - $ctx->m_header->header_len;

							return $len-$byteAvailable;
						}
						else
							//next chunk
						{
							$ctx->m_chunk_hdr_offset = $buf->GetLength();
							$ctx->m_state =(HttpProtocolClient::RECEIVING_CHUNKED_LEN);
						}
					}//case RECEIVING_CHUNKED_BODY
					break;
				case HttpProtocolClient::PACKET_PARSE_FAILED:
					{
						return -1;
					}
				default:
					return -2;
			}
				
		}//while
		return $len;
	}
	public static function ParseHeader( $ctx, $buf, $len)
	{
		$s = substr($buf,0,$len);
		$lines = explode("\r\n",$s);
		if(count($lines) <= 0)
		{
			return -1;
		}
		$ctx->m_header->header_len = $len;
		$ctx->m_header->status_line  = $lines[0];
		$statu_values = explode(" ",$ctx->m_header->status_line);
		
		if(count($statu_values) >2)
		{
			$ctx->m_header->status_code =$statu_values[1];
			$ctx->m_header->method   = $statu_values[0];
		}	
		for($i=1;$i<count($lines);$i++)
		{
			$idx = strpos($lines[$i],":");
			if($idx > 0)
			{
				$name = trim(substr($lines[$i], 0,$idx));
				$value = trim(substr($lines[$i],$idx+1)); 

				if(strcasecmp(HttpProtocolClient::HTTP_CONTENT_LENGTH,$name)==0)
				{
					$ctx->m_header->content_len = intval($value);
				}
				else if(strcasecmp(HttpProtocolClient::HTTP_TRANSFER_ENCODING, $name)==0 && strcasecmp(HttpProtocolClient::HTTP_CHUNKED,$value)==0)
				{
					$ctx->m_header->chunked = 1;
				}
				else if(strcasecmp(HttpProtocolClient::HTTP_CONTENT_ENCODING, $name)==0 )
				{
					$ctx->m_header->contentEncoding = $value;
				}
				array_push($ctx->m_header->headers, array('name'=>$name,'value'=>$value));
			}
		}

		return 0;
	}

	/**
	 * return the uncomp$ressed content.
	 *
	 * */
	public function uncompressContent( $ctx, $input) 
	{

// 		$content_len = input.GetLength()-$ctx->m_header->header_len;
// 		if(content_len<=0)
// 		{
// 			return null;
// 		}
// 		long t1  = System.currentTimeMillis();
// 		byte []tmp = new byte[4096];
// 		InputStream body=null;
// 		$guess_ratio = 1;
// 		if($ctx->m_header->contentEncoding.equals("gzip"))
// 		{
				
// 			ByteArrayInputStream ins = new ByteArrayInputStream(input.GetBuffer(),
// 					$ctx->m_header->header_len,
// 					content_len);
// 			body = new GZIPInputStream(ins);
// 			guess_ratio = 5;
				
// 		}
// 		else if($ctx->m_header->contentEncoding.equals("deflate"))
// 		{
// 			ByteArrayInputStream ins = new ByteArrayInputStream(input.GetBuffer(),
// 					$ctx->m_header->header_len,
// 					content_len);
// 			body = new InflaterInputStream(ins);
// 			guess_ratio = 5;
// 		}
// 		else if($ctx->m_header->contentEncoding.equals(""))
// 		{
// 			body = new ByteArrayInputStream(input.GetBuffer(),
// 					$ctx->m_header->header_len,
// 					content_len);
// 			guess_ratio = 1;
// 		}

// 		if(body!=null)
// 		{
// 			XAutoBuffer ret = new XAutoBuffer(content_len*guess_ratio);
// 			while(true)
// 			{
// 				$rn = body.read(tmp,0,tmp.length);
// 				if(rn<=0)
// 				{
// 					break;
// 				}
// 				ret.Append(tmp, 0, rn);
// 			}
// 			//			print("SEND_POST_MANUALLY_PROFILE","UNCOMP$resS_CONTENT("+$ctx->m_header->contentEncoding+"): "+ (System.currentTimeMillis()-t1)
// 			//					+" zip size:"+content_len + " unzip size: " + ret.GetLength());
// 			return ret;
// 		}

		return null;
	}

	public static function getContentLen($ctx, $input)
	{
		return input.GetLength() - $ctx->m_header->header_len;
	}

	public static function getContent($ctx, $input)
	{

// 		try {
// 			return uncomp$ressContent(ctx,input);
// 		} catch (IOException e) {
// 			print("HTTP getContent", e.getMessage());
// 		}

		return $input;
	}

	public static function test()
	{

		$szChunked ="\x48\x54\x54\x50\x2F\x31\x2E\x31\x20\x32\x30\x30\x20\x4F\x4B\x0D\x0A\x53\x65\x72\x76\x65\x72\x3A\x20\x6E\x67\x69\x6E\x78\x2F\x30\x2E\x37\x2E\x36\x32\x0D\x0A\x44\x61\x74\x65\x3A\x20\x53\x61\x74\x2C\x20\x32\x35\x20\x4A\x75\x6E\x20\x32\x30\x31\x31\x20\x31\x33\x3A\x30\x36\x3A\x35\x35\x20\x47\x4D\x54\x0D\x0A\x43\x6F\x6E\x74\x65\x6E\x74\x2D\x54\x79\x70\x65\x3A\x20\x69\x6D\x61\x67\x65\x2F\x67\x69\x66\x0D\x0A\x54\x72\x61\x6E\x73\x66\x65\x72\x2D\x45\x6E\x63\x6F\x64\x69\x6E\x67\x3A\x20\x63\x68\x75\x6E\x6B\x65\x64\x0D\x0A\x43\x6F\x6E\x6E\x65\x63\x74\x69\x6F\x6E\x3A\x20\x63\x6C\x6F\x73\x65\x0D\x0A\x0D\x0A\x32\x62\x0D\x0A\x47\x49\x46\x38\x39\x61\x01\x00\x01\x00\x80\x00\x00\xFF\xFF\xFF\x00\x00\x00\x21\xF9\x04\x01\x00\x00\x00\x00\x2C\x00\x00\x00\x00\x01\x00\x01\x00\x00\x02\x02\x44\x01\x00\x3B\x0D\x0A\x31\x0D\x0A\x31\x0D\x0A\x30\x0D\x0A\x0D\x0A";

		$szContentLenght="\x48\x54\x54\x50\x2F\x31\x2E\x31\x20\x32\x30\x30\x20\x4F\x4B\x0D\x0A\x53\x65\x72\x76\x65\x72\x3A\x20\x4D\x65\x64\x69\x61\x56\x2F\x30\x2E\x31\x2E\x35\x34\x0D\x0A\x44\x61\x74\x65\x3A\x20\x53\x61\x74\x2C\x20\x32\x35\x20\x4A\x75\x6E\x20\x32\x30\x31\x31\x20\x31\x34\x3A\x34\x34\x3A\x30\x38\x20\x47\x4D\x54\x0D\x0A\x43\x6F\x6E\x74\x65\x6E\x74\x2D\x54\x79\x70\x65\x3A\x20\x69\x6D\x61\x67\x65\x2F\x67\x69\x66\x0D\x0A\x43\x6F\x6E\x74\x65\x6E\x74\x2D\x4C\x65\x6E\x67\x74\x68\x3A\x20\x34\x33\x0D\x0A\x43\x6F\x6E\x6E\x65\x63\x74\x69\x6F\x6E\x3A\x20\x6B\x65\x65\x70\x2D\x61\x6C\x69\x76\x65\x0D\x0A\x53\x65\x74\x2D\x43\x6F\x6F\x6B\x69\x65\x3A\x20\x20\x76\x3D\x67\x24\x3C\x66\x46\x3C\x41\x41\x29\x63\x43\x40\x2A\x21\x2D\x29\x37\x40\x77\x67\x3B\x20\x65\x78\x70\x69\x72\x65\x73\x3D\x57\x65\x64\x6E\x65\x73\x64\x61\x79\x2C\x20\x30\x32\x2D\x4E\x6F\x76\x2D\x32\x30\x39\x39\x20\x32\x32\x3A\x34\x34\x3A\x30\x38\x20\x47\x4D\x54\x3B\x20\x70\x61\x74\x68\x3D\x2F\x3B\x20\x64\x6F\x6D\x61\x69\x6E\x3D\x2E\x6D\x65\x64\x69\x61\x76\x2E\x63\x6F\x6D\x0D\x0A\x43\x6F\x6E\x6E\x65\x63\x74\x69\x6F\x6E\x3A\x20\x43\x6C\x6F\x73\x65\x0D\x0A\x50\x72\x61\x67\x6D\x61\x3A\x20\x6E\x6F\x2D\x63\x61\x63\x68\x65\x0D\x0A\x50\x33\x50\x3A\x20\x43\x50\x3D\x22\x43\x55\x52\x61\x20\x41\x44\x4D\x61\x20\x44\x45\x56\x61\x20\x50\x53\x41\x6F\x20\x50\x53\x44\x6F\x20\x4F\x55\x52\x20\x42\x55\x53\x20\x55\x4E\x49\x20\x50\x55\x52\x20\x49\x4E\x54\x20\x44\x45\x4D\x20\x53\x54\x41\x20\x50\x52\x45\x20\x43\x4F\x4D\x20\x4E\x41\x56\x20\x4F\x54\x43\x20\x4E\x4F\x49\x20\x44\x53\x50\x20\x43\x4F\x52\x22\x0D\x0A\x43\x61\x63\x68\x65\x2D\x43\x6F\x6E\x74\x72\x6F\x6C\x3A\x20\x6E\x6F\x2D\x63\x61\x63\x68\x65\x2C\x20\x6D\x75\x73\x74\x2D\x72\x65\x76\x61\x6C\x69\x64\x61\x74\x65\x0D\x0A\x0D\x0A\x47\x49\x46\x38\x39\x61\x01\x00\x01\x00\x80\x01\x00\x00\x00\x00\xFF\xFF\xFF\x21\xF9\x04\x01\x00\x00\x01\x00\x2C\x00\x00\x00\x00\x01\x00\x01\x00\x00\x02\x02\x4C\x01\x00\x3B";
		$ctx= new HttpContext();
		$bufs  = new XAutoBuffer(4096);

		$consumeLen = HttpProtocolClient::parseHttp($ctx,$szChunked,strlen($szChunked),$bufs);
		if($consumeLen==strlen($szChunked) && $ctx->m_state==HttpProtocolClient::PACKET_COMPLETE)
		{
			print("TEST HTTP PROTOCOL STAGE 1 OK\n");
		}
		else
		{
			print("TEST HTTP PROTOCOL STAGE 1 FAILED\n");
		}
		$ctx->reset();
		$bufs->Clear();
		$consumeLen = 0;
	
		for($i=0;$i<strlen($szChunked);$i++)
		{
			$tmb = pack( "c", ord($szChunked[$i]) );
			$consumeLen += HttpProtocolClient::parseHttp($ctx,$tmb,1,$bufs);
		}

		if($consumeLen==strlen($szChunked) && $ctx->m_state==HttpProtocolClient::PACKET_COMPLETE)
		{
			print("TEST HTTP PROTOCOL STAGE 2 OK\n");
		}
		else
		{
			print("TEST HTTP PROTOCOL STAGE 2 FAILED\n");
		}


		$ctx->reset();
		$bufs->Clear();
		$consumeLen = 0;

		$consumeLen = HttpProtocolClient::parseHttp($ctx,$szContentLenght,strlen($szContentLenght),$bufs);
		if($consumeLen==strlen($szContentLenght) && $ctx->m_state==HttpProtocolClient::PACKET_COMPLETE)
		{
			print("TEST HTTP PROTOCOL STAGE 3 OK\n");
		}
		else
		{
			print("TEST HTTP PROTOCOL STAGE 3 FAILED\n");
		}

		$ctx->reset();
		$bufs->Clear();
		$consumeLen = 0;
		for($i=0;$i<strlen($szContentLenght);$i++)
		{
			$tmb = pack ( "c", ord($szContentLenght[$i]) );
			$consumeLen += HttpProtocolClient::parseHttp($ctx,$tmb,1,$bufs);
		}
		if($consumeLen==strlen($szContentLenght) && $ctx->m_state==HttpProtocolClient::PACKET_COMPLETE)
		{
			print("TEST HTTP PROTOCOL STAGE 4 OK\n");
		}
		else
		{
			print("TEST HTTP PROTOCOL STAGE 4 FAILED\n");
		}
	}
	
	public static function test2()
	{
		$input = fopen("/tmp/httpdata.dump",'rb');
		$filesize = fstat($input);
		var_dump($filesize);
		$filesize = $filesize["size"];
		$data = fread($input,$filesize);
		fclose($input);
		
		$ctx= new HttpContext();
		$bufs  = new XAutoBuffer(4096);
		
		while($filesize>0)
		{
			$consumeLen = HttpProtocolClient::parseHttp($ctx,$data,$filesize,$bufs);
			$data = substr($data, $consumeLen);
			$filesize -=$consumeLen;
			
			if($consumeLen>=0 && $ctx->m_state==HttpProtocolClient::PACKET_COMPLETE)
			{
				
				echo " ok $consumeLen \n";
				$ctx->reset();
				$bufs->Clear();
			}
			else
			{
				echo "not ok  $consumeLen \n";
				var_dump($ctx);
				break;
				
			}
		}
	}

};


//HttpProtocolClient::test2();