Comunidad PHPeros
Lenguajes => PHP => (POO) Programación Orientada a Objetos => Mensaje iniciado por: Focux en 10 de Julio de 2010, 04:31:08 am
-
Bueno está clase la hizo un amigo para su framework, le hize registrar en este foro su usuario es hans.php, bueno aqui les dejo la clase.
<?php
/****************************************
**** Autores: Hans Von *******
**** Versión: 2.1 *******
****************************************/
class H_HTTP{
public $automatic=false; #lee y guarda las cookies y usa un user agent automatico y asigna automaticamente el referer
public $cookie_ligera=false; # si esta en true solo guarda sus valores y no sus datos adicionales como expires, domain etc..
public $header; # Almacena todos los header que se le van a enviar a la pagina remota
public $headers; # Agrega todos los headers adicionales a los normales
public $referer=''; # Almacena el referer de la ultima pagina
public $url=''; # Almacena el url actual
public $cont;
public $head;
public $cookies;
private $so; // Variable donde se almacena la conexión
public $script_path; // ej.: /var/www/
public $cook_dir='cookies/'; // directorio donde se guardan las cookies, este directorio debe de existir
public $ua; // Aquí alamcenamos el User Agent si es que queremos usar
/* Variables de la url - no modificar!!! */
private $scheme; // ej.: http
private $host; // ej.: localhost
private $path = '/'; // ej.: /fichero/paginas/index.html
private $dir_path; // ej.: /
private $port = 80; // ej.: 8080
/* Constructor y Destructor del objeto */
function __construct($url=''){
#ponemos en memoria el path sin nombre del archivo
$this->script_path = dirname($_SERVER['SCRIPT_FILENAME'])."/";
#Verificamos si el path es escribible
is_writable($this->script_path) || die("No se puede editar en el directorio");
#re declaramos la carpeta de las cookies para que este full su path
$this->cook_dir=$this->script_path.$this->cook_dir;
#cargamos el url
if(!empty($url)) $this->URL($url);
}
function __destruct(){
# Al destruir el objeto cerramos la conexión
$this->soff();
}
function soff(){
#Comprueba si el socket ya fue cerrado, si no, lo cierra
if($this->so){fclose($this->so);$this->so = false;}
}
function __set($var,$val){
die($var); # debugger
}
function extraer($str,$izq,$der){
/* Extrae fracmentos espesificos no de una cadena */
# Extrae el extremo izquierdo
$ex = explode($izq,$this->$str,2);
# Extrae el extremo derecho
$xe = explode($der,$ex[1],2);
# Regesa lo que sobra de la cadena y sin los delimitadores
$this->$str=$ex[0].$xe[1];
return $xe[0];
}
function URL($url=''){
# No ejecuta si no hay URL
if(empty($url)) die('No URL');
#Pasa los valor a propiedades scheme,host etc..
foreach(parse_url($url) as $id => $val) $this->$id = $val;
$this->dir_path=str_replace(basename($this->path),'',$this->path);
# Verificamos que sea solo el protocolo permitido
if($this->scheme!=('http' || 'https')) die("Solo protocolos HTTP y HTTPS");
if($this->scheme=='https') $this->port=443;
$this->url=$url;
!$this->automatic || $this->UA();
}
function aheader($key,$val){
$this->headers.="$key: $val\r\n"; # agrega un header adicional
}
/**/
function cookie($ax='',$archivo="cookie_automatica"){
#identidica si pasan parametros
if(empty($ax)) die("la cookie no pasa parametros");
/* Dos opciones de acción, leer cookie de la pagina y guardar cookie en una sesión txt */
# lee la cookie de la pagina
if($ax=='leer'){
# comprueba si existe la sesion, si no mejor ni se mete en broncas
if(file_exists($this->cook_dir.$archivo)){
# Obtiene el contenido de la sesión, lo unserializa y pasa a la variable $this->cookies
$this->cookies=unserialize(file_get_contents($this->cook_dir.$archivo));
# comprueba si ya se habian guardado cookies
if(!empty($this->cookies)){
# comprueba si existe una cookie en el path actual, si no usa el path principal /
if(!empty($this->cookies[$this->dir_path])){
# si hay cookies segun el path, las implota en un cadena para ser inyectadas
foreach($this->cookies[$this->dir_path] as $k => $v) $cookie.="$k=$v[valor]; ";
}else{
# si no encuentra el path usa las cookies pincipales y las implota
foreach($this->cookies['/'] as $k => $v) $cookie.="$k=$v[valor];";
}
#agrega al header la o las cookies
$this->headers.="Cookie: ".$cookie."\r\n";
}
}else{
// echo("no existe la sesión");
}
# En caso de que se requiera guardar la sesion
}else if ($ax=='guardar'){
# Verifica si es escribible el directorio de coookies
if(is_writable($this->cook_dir)){
# Extrae las cookies de los header devueltos una por una para ser almacenadas en una matriz multi.dimensional
while($cook=$this->extraer('head',"Set-Cookie: ","\r\n")){
# $acook va a ser la matriz provisional de las cookies nuevas <br />
# Esta matriz como otros elementos se redeclaran a cada ciclo del while
$acook=array();
# parte la cookie a cada ";" ej.: PREF=ID; NID=36
$cook=explode("; ",$cook);
# Quita el primer elemento.
# siempre las cookies tienen como primer elemento su clave y valor despues dominio path etc..
$p = array_shift($cook);
# Divide entre clave y valor ej.: nombre_de_la_cookie = "valor"
$vcook=explode("=",$p,2);
# se le asigna el valor a la clave valor de la matriz en curso
$acook['valor']=$vcook[1];
# checa que $cook no este vacia por si se llegase a tener un solo elemento $cook ya que anteriormente le quitamos
if(!empty($cook) && $this->cookie_ligera==false){# hasta aqui cook puede quedarse vacio y es perfectamente normal
#el resto de los elementos los explora
foreach($cook as $v){
#Divide entre clave y valor
$ecook=explode("=",$v,2);
# si tiene path
if($ecook[0]=='path') {
# Verifica que termine en /
if($ecook[1][strlen($ecook[1])-1]!='/') $ecook[1].='/';
}
# Guarda en la matriz actual la clave y el valor
$acook[strtolower($ecook[0])]=$ecook[1];
}
}
# si la cookie tiene seteado el path se le coloca en ese división de la matriz ej.:
if(!empty($acook['path'])){
$this->cookies[$acook['path']][$vcook[0]]=$acook;
}else{# si la cookie no cuenta con path se le asigna el path desde donde se ejecuto la pagina remota
if(basename($this->path)) { # si el path de la pagina tiene nombre se le quita
$this->cookies[str_replace(basename($this->path),'',$this->path)][$vcook[0]]=$acook;
}else{# ya en ultimo caso se le asigna en el path directamente a la matriz
$this->cookies[$this->path][$vcook[0]]=$acook;
}
}
}
// print_r($this->cookies);
# se guarda la sesion fisicamente
file_put_contents($this->cook_dir.$archivo,serialize($this->cookies));
}else{
die("no se puede crear la sesión");
}
}
}
#defalut : Windows XP españa safari
function UA($so='',$len='',$nav=''){
switch ($so){
case windows_7:$ua.="Windows NT 6.1;";break; # Windows 7
case windows_vista:$ua.="Windows NT 6.0;";break; # Windows Vista
default:$ua.="Windows NT 5.1;"; # Windows XP
}
switch($len){
case mex:$ua.="es-MX;";break; # México
case arg:$ua.="es-AR;";break; # Argentina
case dom:$ua.="es-DO;";break; # Rep. Dominicana
case pue:$ua.="es-PR;";break; # Puerto Rico
case usa:$ua.="en-US;";break; # Estados Unidos
case rei:$ua.="en-GB;";break; # Reino Unido
case ita:$ua.="it-IT;";break; # Italia
default:$ua.="es-ES;";break; # España
}
switch($nav){
case firefox:
$ua='Mozilla/5.0 (Windows; U;'.$ua.
') Gecko/20100625 Firefox/'.rand(2,3).'.'.rand(0,6).'.'.rand(0,8); # Firefox
break;
case iexplorer:
$ua='Mozilla/4.0 (compatible; MSIE 6.0;'.$ua.
'.NET CLR 2.0.50727)'; # Iexplorer
break;
default:
$ua='Mozilla/5.0 (Windows; U;'.$ua.') Version/3.2 Safari/525.26.12'; # Safari
}
$this->ua="User-Agent: $ua\r\n";
}
function IR($method=''){
# declara por segunta vvez los headers
!$this->automatic || $this->cookie('leer');
$this->header=" ".$this->path.
((isset($this->query))?'?'.$this->query:'').
" HTTP/1.1\r\n".
"Host: $this->host\r\n".
$this->ua.
$this->referer.
$this->headers.
"Accept: */*\r\n".
"Accept-Language: es-es,es;q=0.8,en-us;q=0.5,en;q=0.3\r\n".
"Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7\r\n".
"Pragma: no-cache\r\n".
"Cache-Control: no-cache\r\n".
"Connection: Close\r\n\r\n";
# Ya no son necesario así que se mueren los headers $this->headers
unset($this->headers,$this->head,$this->cont);
# Abre un socket con la conexion al servidor remoto sea https o http
$this->so = @fsockopen((($this->scheme=='https')?'ssl://':'').$this->host, $this->port, $errno, $errstr, 30);
# Comprueba que no haya error
if(!$this->so) die("$errstr ($errno)");
# Agrega el metodo a los headers ej.: GET o POST
$this->header=strtoupper($method).$this->header;
# envia la petición
fwrite($this->so, $this->header);
/* Extrae las cabeceras */
do{
#obtiene las cabeceras
$this->head .= fgets($this->so, 228);
# Para el bucle hasta que encuentre los cuatro bytes de la muerte
if(stripos($this->head,"\r\n\r\n")) break;
} while (!feof($this->so));
#obtiene el contenido desde el puntero
while (!feof($this->so)) $this->cont .= fgets($this->so, 228);
# mata el socket, si este metodo no se ejecuta lo ara el destructor
$this->soff();
if($this->automatic==true){
$this->cookie('guardar');
$this->referer = "Referer: $this->url\r\n";
}
#$cook=$this->extraer('head',"Set-Cookie: ","\r\n");
# returna positivo si responde con 200 OK la pagina
if(stripos($this->head,"200 OK")) return true;
}
}
$ini = new H_HTTP();
$ini->URL("http://www.google.com");
$ini->UA('windows_xp','usa','firefox');
$ini->cookie('leer','google');
$ini->IR('GET');
$ini->cookie('guardar','google');
print_r($ini->header);
print_r($ini->head);
print_r(htmlentities($ini->cont));
-
Excelente aporte man.
justo andaba buscando algo así, pero no como curl si no mas maleable.
-
Esta clase además de todo guarda las cookies & almacena header & todo como si fuera un navegado normal.
-
Es mejorable en algunos sentidos pero tiene pinta de funcionar y es un buen ejemplo :D
-
Es como un navegador común & corriente, guarda los header, guarda las cookies, claro que con seguridad.
-
¿Podrías agregar alguna descripción al menos de lo que hace?
O sea, para qué sirve la clase? Gracias de antemano. Es que si me pones solo HTTP no lo capto xD
-
Es como un navegador en PHP, guarda las cookies, los header & todo, es totalmente seguro.
-
Man luego te paso la nueva versión con soporte de progressbar para descarga y subida a de mas de interpretación de "Chunked transfer encoding"