Parsing file di log di Apache – Apache log parsing:
(\d+\.\d+\.\d+\.\d+) (-|\w*) (-|\w*) \[(\d+\/\w+\/\d+):(\d+:\d+:\d+) -(\d\d\d\d)\] "([^"]*)" (\d+) (-|\d+) "([^"]*)" "(.*)"\s*\Z

se utilizzate python è estremamente utile compilare l’espressione regolare che ho appena scritto in questo modo:
myregex = re.compile('(?P\d+\.\d+\.\d+\.\d+) (?P-|\w*) (?P-|\w*) \[(?P\d+\/\w+\/\d+):(?P\d+:\d+:\d+) -(?P\d\d\d\d)\] "(?P[^"]*)" (?P\d+) (?P-|\d+) "(?P[^"]*)" "(?P.*)"\s*\Z')

in questo modo utilizzando questo codice:

log = self.regex.match(row)
log_line = log.groupdict()

nella variabile log_line otterrete un dizionario contenente come chiavi i valori che avete inserito nella fase di compilazione come ?P e come valore la relativa sottostringa, ad esempio log_line['ip'] = valore ip .

Those kind of images are particular appreciated in “web2.0 style” and many website are moving their graphics towards this style, so why don’t you keep updated?

Ajax o Asyncronous JavaScript and XML non è facilmente descrivibile, è un nuovo sistema di pensare il web, di offrire interfacce utente più usabili grazie all’ausilio delle tecnologie ormai d’uso comune, fondanti AJAX ossia Javascript, CSS e XML.
Con Ajax è possibile aggiornare singole porzioni di pagine web senza doverle ricaricare, è possibile offrire form in grado di validare i dati inseriti e di auto-completare quanto digitato dall’utente, tutto questo vi sembra fantascienza? Dovreste vedere cos’altro si può fare.

Molti portali e grandi aziende hanno puntato negli ultimi anni su questa innovazione tecnologica, il più visibile tra questi attori è Google, che ha fatto di Ajax il suo cavallo di battaglia, ad esempio, l’intera interfaccia di GMail è gestita in AJAX e attraverso un complicato sistema di frame e javascript.

Inoltre sempre Google offre ai suoi utenti la possibilità di effettuare delle ricerche con dei suggerimenti, il servizio si chiama Google Suggest, in poche parole mentre voi digitate la parola da ricercare, l’interfaccia di Google vi offre dei suggerimenti che riguardano i possibili risultati ottenuti e la rilevanza, rispetto alla chiave di ricerca, di ciascuno di questi.

Google non è davvero l’unico, ci sono molti altri esempi, ma non mi dilungherò oltre nei case studies.

Cos’è una richiesta Asincrona:

Quando carichiamo una pagina web tutti i suoi elementi vengono caricati in modo sequenziale uno dopo l’altro, se uno di questi elementi esegue un’operazione lunga allora il caricamento della pagina viene sospeso fintanto che il lavoro non è terminato e in seguito viene completato.
Quello appena descritto è il comportamento standard delle pagine web che è definito sincrono, quindi quello che è successo fin’ora � che se volevamo validare i campi di un form dovevamo inviare il form e in seguito restituire gli eventuali errori, ma…

Come abbiamo detto AJAX consente un comportamento asincrono, con questo si intende la capacità di un elemento della pagina che deve eseguire un lavoro (anche lungo) di non interrompere il normale caricamento o flusso di lavoro, in questo modo è possibile fornire all’utente la pagina completamente caricata con i suoi elementi fondamentali, e man mano che l’utente si sofferma nella pagina caricare altri elementi o effettuare operazioni di qualunque altro tipo.
Tornando quindi al nostro esempio della validazione del form, ci sarà possibile una volta che l’utente ha completato un campo da validare, inviare al server (in modo del tutto trasparente, ossia senza che l’utente se ne accorga) il valore di quel campo e restituire praticamente in tempo reale gli eventuali errori, senza dover ricaricare la pagina.

Cos’è XMLHttpRequest:

Come funziona tutto questo? Alla base di tutto quello che abbiamo fin qui detto risiede XMLHttpRequest, un’oggetto JavaScript in grado di effettuare le richieste sincrone o asincrone verso il server.

Non è mia intenzione addentrarmi nelle caratteristiche e nella sintassi di quest’oggetto, per questi aspetti vi rimando alle documentazioni tecniche che trovate in internet, un buon punto di partenza è
http://xulplanet.com/references/objref/XMLHttpRequest.html oppure potreste aspettare i prossimi post sull’argomento

Vorrei invece mettere in risalto il fatto che attualmente non esiste ancora uno standard per scrivere applicazioni AJAX, esistono infatti diverse implementazioni a seconda del browser e della piattaforma, quindi al momento lo sforzo maggiore che viene compiuto nel cimentarsi con AJAX è proprio quello di cercare di rendere gli script cross browser.

La sicurezza in AJAX:

Un ultimo aspetto che vorrei descrivere di AJAX riguarda la sicurezza, difatti se tra voi lettori, ci fosse qualche maniaco di sicurezza, con crisi di persecuzione come me, potrebbe subito chiedersi quali sono le possibili falle di sicurezza che un sistema come questo, nel quale il codice viene eseguito all’insaputa dell’utente, è in grado di aprire.

Ebbene anche a questo si è pensato, ed è stato adottato concettualmente lo stesso schema di sicurezza delle applet java, la cui esecuzione è limitata all’area di memoria nella quale vengono eseguite, così per ajax è stato imposto il limite del dominio, ossia le richieste sincrone o asincrone che siano, debbono essere limitate al dominio nel quale viene caricata la pagina, in questo modo non è possibile fare richieste ad un server remoto che potrebbe scaricare sul nostro computer codice malevolo.

Se da una parte questa limitazione ci garantisce da brutte sorprese, dall’altra però limita fortemente le possibilità di questo sistema, impedendoci ad esempio di usufruire dei molti web services messi a disposizione dai siti esterni al nostro, per questa ragione sono state introdotte diverse tecniche che fanno uso di proxy in grado di incaricarsi delle richieste verso siti remoti e che consentono di superare il problema.

Pro e Contro AJAX:

Per quanto riguarda gli aspetti positivi sono sicuramente da menzionare:

• Il traffico minimo: solo le parti coinvolte in un cambiamento vengono aggiornate
• Accessibilità
• Limitare le distrazioni con continui caricamenti
• Interazione migliorata
• In una parola sola Usabilità

Ci sono però alcuni aspetti anche negativi come:

• Maggiore complessità nello sviluppo delle applicazioni
• Inesistenza di uno standard per l’uso di queste tecnologie
• Difficoltà di garantire agli utenti non in grado di sfruttare javascript perché utilizzano browser incompatibili un’esperienza comunque di qualità sul sito
• Impossibilità di gestire la cronologia delle azioni eseguite
• Impossibilità per i motori di ricerca di ricerca di indicizzare i dati gestiti tramite javascript

Spero vivamente che l’introduzione ad AJAX risulti chiara, esistono ancora molti aspetti che però debbono essere trattati, e chissà magari li tratterò più in la, di sicuro a breve comincerò a pubblicare esempi ajax che sicuramente aiuteranno a capire come muoversi in quello che è il futuro del web, non mi rimane che dirvi stay tuned e vi lascio indicandovi la pagina di Wikipedia che parla di AJAX:
http://it.wikipedia.org/wiki/AJAX

In questo modo praticamente ad ogni richiesta della loro pagina web viene consumata la nostra banda per scaricare le immagini rubate, si potrebbe considerare l’hotlinking come un vero e proprio furto, poiché la banda consumata dal ragazzaccio a noi proprietari di siti costa denaro (e molto!).

Per risolvere il problema esiste però una possibilità che ci è offerta dal mod_rewrite di Apache, in pratica questa tecnica consente di bloccare le richieste esterne al nostro sito delle immagini, o di cambiare le richieste con altre richieste scelte da noi (quest’ultima frase è volutamente criptica perché non vi voglio rovinare la sorpresa).

Passiamo alla fase pratica e nella directory che contiene le immagini del nostro spazio web creiamo un file .htaccess (il punto che precede il nome serve per nascondere il file dopo la sua creazione), e al suo interno inseriamo le righe:

RewriteEngine on
RewriteCond %{HTTP_REFERER} !^$
RewriteCond %{HTTP_REFERER} !^http://yourdomain.com/.*$ [NC]
RewriteCond %{HTTP_REFERER} !^http://www.yourdomain.com/.*$ [NC]
RewriteRule .*.(gif|GIF|jpg|JPG|bmp|BMP)$ - [F]

Con queste poche linee di codice stiamo dicendo che:

• riga 1: attiva il RewriteEngine che ci consente di riscrivere le url su Apache (utile anche per l’url rewrite)
• righe 2,3,4: controllano se l’url da cui è partita la richiesta fa parte di una delle tre ammesse come ad esempio yourdomain.com o www.yourdomain.com o ancora un path relativo o assoluto locale, altrimenti non prosegue a servire la richiesta, e chi ha linkato l’immagine senza il nostro permesso non riuscirà a caricarla.
• riga 5: sono le estensioni dei file di cui si vuole bloccare l’hotlinking.

Per quanto riguarda quei codici a fine linea sono delle opzioni che vengono accettate dal RewriteEngine, in particolare [NC] sta per No Case ossia il controllo tra l ‘url del richiedente e l’url ammessa viene fatto senza preoccuparsi di lettere maiuscole o minuscole.

Ma con questo sistema si può fare molto di più, perché limitarci a non far visualizzare, a chi ci sta rubando le immagini, quello che ha linkato, quando potremmo cambiare la sua richiesta e mostrargli una immagine scelta da noi, magari con un testo che gli ricorda proprio che sta rubando le immagini dal nostro sito?

Ecco quindi il codice che consente di realizzare tutto ciò, come prima va inserito in un file .htaccess nella cartella delle immagini:

RewriteEngine On
RewriteCond %{HTTP_REFERER} !^$
RewriteCond %{HTTP_REFERER} !^http://yourdomain.com/ [NC]
RewriteCond %{HTTP_REFERER} !^http://www.yourdomain.com/ [NC]
RewriteCond %{REQUEST_URI} !^/antiHotLink.jpg [NC]
RewriteRule .(gif|GIF|jpg|JPG|bmp|BMP)$ http://yourdomain.com/antiHotLink.jpg [R]

Questo codice è praticamente identico al precedente ad eccezione della riga 6 nella quale diciamo che tutte le richieste ai file che non vogliamo siano linkati, fatte da siti esterni al nostro debbono essere redirette verso antiHotLink.jpg in questo modo se il “ladro” linka l’immagine con Topolino troverà al suo posto l’immagine scelta da noi con un bel testo nel quale potrete inserire il vostro indirizzo in modo che suo malgrado vi farà pubblicità .

Fate attenzione però che se l’immagine antiHotLink.jpg è sul vostro dominio, questa consumerà ancora la vostra banda, quindi per ottenere risultati migliori conviene che l’immagine sia su un secondo server e che in ogni caso sia di dimensioni (intendo il peso) ridottissime.

Lo script è particolarmente utile quando si debbono utilizzare le librerie grafiche di PHP come ad esempio la famosa GD Library, che in molte delle sue funzioni, richiede l’uso di colori nel formato RGB.

Questo è il codice della funzione:

/*----------------------------------------------*
* Funzione ColorConvert                        *
* Realizzato da: Antonello Cicchese            *
* http://www.antonellocicchese.com             *
* If you use this script                       *
* please keep this notice                      *
*----------------------------------------------*/

/*
Funzione per convertire un colore HEX in RGB
*/
function ColorConvert($color)
{
$red   = 100;
$green = 100;
$blue  = 100;
$col=array();
if( eregi( "[#]?([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})", $color, $ret ) )
{
$red = hexdec( $ret[1] );
$green = hexdec( $ret[2] );
$blue = hexdec( $ret[3] );
}
$col[1]=$red;
$col[2]=$green;
$col[3]=$blue;
return($col);
}
?>

e questo è il link per scaricare lo script: hex2rgb.php download

Quello che fa lo script è produrre un’immagine PNG al volo contenente l’indirizzo email da voi passato, inoltre per evitare che gli spider dediti alla raccolta di email riconoscano nel vostro codice html l’indirizzo, questo può essere invalidato con due tecniche (che in realtà possono essere anche abinate insieme):

1. con l’inserimento di un numero arbitrario di spazi bianchi all’interno dell’email
2. con la sostituzione del carattere @ con la stringa [___AT___] (N.B. sono tre gli underscore prima e dopo AT).

Lo script prevede anche la possibilità di rendere lo sfondo dell’immagine trasparente in modo da adattarla allo sfondo della pagina sulla quale deve visualizzare l’immagine, per questa funzionalità basterà decommentare la linea 15 del file emailToImage.php

Per quanto riguarda l’utilizzo del file vi propongo qui di seguito un breve codice HTML (perdonatemi se non è un codice perfetto ma non è questo l’intento dell’articolo):

Error: Could not open Test_emailToImage.html

mentre per quanto riguarda il codice dello script PHP è questo

/*---------------------------------------------     *
* EmailToImage.php                                  *
* Realizzato da: Antonello Cicchese                 *
* http://www.antonellocicchese.com                  *
* If you use this script                            *
* please keep this notice                           *
*-----------------------------------------------    */

function emailToImage ( $email )
{
if($email){
/* Ripulisco l'email dagli spazi se è stata scritta come nome    @    dominio.xx */
$email = ereg_replace(" ","",$email);
/* Produco un'email valida se è stata scritta come nome[___AT___]dominio.xx */
$email = ereg_replace("\[___AT___\]","@",$email);

$length = strlen($email);
$imgOutput = ImageCreateTrueColor($length*8,20);
$black = ImageColorAllocate($imgOutput, 0, 0, 0); /* Alloco il colore nero per il testo*/
$white = ImageColorAllocate($imgOutput, 255, 255, 255); /* Alloco il colore bianco per lo sfondo */
ImageFill($imgOutput,0,0,$white); /* Riempio lo sfondo con il bianco */
//ImageColorTransparent($imgOutput,$white); /* Se attivato rende lo sfondo trasparente */
ImageString($imgOutput, 3, $length/2, 3, $email, $black); /* Scrivo l'email centrata */
/* Produco l'immagine di output */
header("Content-type: image/png");
header("Content-Disposition:inline;filename=".$email.".png");
ImagePng($imgOutput);
ImageDestroy($imgOutput);
}
return;
}

if(isset($_GET['email'])) emailToImage($_GET['email']);

Come è facile vedere nel file html il trucco c’è e si vede, basta inserire nella pagina uno o più tag img il cui attributo src punti verso il file php che produce l’immagine seguito dalla variabile “email”, preceduta da un ? e dal carattere &, che contiene il valore dell’email da convertire in immagine, scritta in uno dei due formati consentiti, e verrà visualizzata l’immagine risultante.Questo è il link per scaricare il file html Test_emailToImage.html
e questo è il link per scaricare lo script php emailToImage.phpmentre questo è il risultato del suo utilizzo:

Hello, today I wanna tell you about my last python script (really nuts and bolts), called sitemaps.
With it you can build your website sitemaps, it works as a simple spider, it doesn’t produce a xml file but later maybe i can implement this function, for now it only produces a txt file.

This little spider, starts its crawling from a user specified starting page, and it moves all around the internal links it founds. At the end it produces a txt file with all the links, one per line, found during its crawl, this file could be submitted to Google SiteMaps and its syntax is legal.

The importans of using this kind of tool is that Google could index all your internal pages in less time, giving you the chance to increase your popularity.

As I said before this is really “nuts and bolts” but it’s a good starting point to write more sofisticated spider or web analysis tools.

The script core is a BFS (Breadth first search) visit of the graph composed from target web site internal links.

As usually if you have any comments, please don’t esitate, write them!

Here is the source code

Error: Could not open sitemap.py

and here sitemap.py you can download the script.

Ciao a tutti, quello che vi presento oggi è un semplicissimo script python, che consente a partire da un indirizzo internet specificato all’avvio, di costruire un file indice contenente tutti i link interni del sito analizzato.

Con questo strumento è possibile creare dei file utilizzabili con Google SiteMaps che vi aiuteranno a far indicizzare l’intero contenuto del vostro sito.

Lo script essendo stato scritto in meno di mezz’ora è veramente spartano, non prevede alcuna personalizzazione né produce in output un file xml compatibile con lo standard definito da google per le sitemaps, ma un semplice file di testo con l’elenco dei link.

È comunque un buon inizio sia per poter sviluppare tool più sofisticati per la produzione di sitemap sia per gettare le basi per un piccolo web crawler in python, perché quello che fa questo script è effettuare una visita BFS cioè in ampiezza, del grafo dei link interni di un sito.

Come al solito se avete commenti non esitate, anzi più ce ne sono migliore sarà il prodotto finale.

Clicca qui per il codice

Error: Could not open sitemap.py

e clicca sitemap.py per scaricare il file.

Questa è una versione modificata rispetto alla guida ufficiale che potrete trovare sul wiki di dreamhost, difatti punta a farvi utilizzare non la versione preinstallata che trovate sul vostro server di python ma una vostra installazione personalizzata, con tutte le librerie di cui potreste aver bisogno, il documento originale in inglese da cui sono partito per scrivere questo tutorial si trova all’indirizzo:
http://forums.site5.com/showthread.php?t=10236
ora non mi rimane che augurarvi una buona lettura.

Per iniziare dopo aver completato le fasi di registrazione su dreamhost e una volta che avrete ottenuto un account ssh questi sono i passi da seguire per installare Django su Dreamhost, facendo uso però di una versione personalizzata di python:

1. collegatevi in ssh sul vostro server
2. una volta entrati nella vostra home digitate:

   wget http://peak.telecommunity.com/dist/virtual-python.py
   python virtual-python.py

   Questo creerà nella vostra home diverse cartelle (bin, lib, …) che vi consentiranno di avere una installazione personalizzata di python.
   Il vantaggio di questo approccio è che vi consentirà di avere a vostra disposizione le librerie più indicate per il vostro progetto proprio come se aveste un vostro server personale.

3. Adesso è necessario scaricare ez_setup:

   wget http://peak.telecommunity.com/dist/ez-setup.py
   ~/bin/python ez_setup.py

   Adesso avete un’installazione completamente funzionante di python al vostro servizio, passiamo ora all’installazione delle librerire necessarie.

Librerie di python:

1. La prima libreria necessaria per il funzionamento di Django su Dreamhost è quella per interfacciare Python al dbms MySQL, consiglio vivamente di scaricarsi ogni volta l’ultima versione della libreria che trova a questo indirizzo http://sourceforge.net/projects/mysql-python e al limite caricarla in ftp direttamente nella vostra home e seguire le indicazioni che vi sto per dare, per la sua installazione, ad eccezione della prima linea.

   wget http://path.to.sourceforge.mirror/sourceforge/mysql-python/MySQL-python-1.2.1_p2.tar.gz
   tar zxvf MySQL-python-1.2.1_p2.tar.gz
   cd MySQL-python-1.2.1_p2
   ~/bin/python setup.py install

2. Installiamo una libreria che è utile (e necessaria) soprattutto se usate le immagini nel vostro progetto e gli ImageField, si tratta della libreria PIL (Python Imaging Library):

   wget http://effbot.org/downloads/Imaging-1.1.5.tar.gz
   tar zxvf Imaging-1.1.5.tar.gz
   cd Imaging-1.1.5
   ~/bin/python setup.py install

3. Installiamo infine la libreria flup:

   svn co http://svn.saddi.com/flup/trunk flup
   cd flup
   ~/bin/python setup.py install

   a questo punto siete pronti per l’installazione vera e propria di Django.

Installazione di Django:

1. scarichiamo per prima cosa nella nostra home l’ultima versione di django, utilizzando svn:

   svn co http://code.djangoproject.com/svn/django/trunk/ django-src

2. adesso rendiamo disponibile il path di django nella nostra installazione di python facendo un soft link:

   ln -s ~/django_src/django ~/lib/python2.4/site-packages/django

3. creiamo una directory nella vostra home che conterrà il progetto che andrete ad utilizzare:

   mkdir ~/django_project

   All’interno di questa directory dovrete caricare il vostro progetto django con tutte le cartelle ad eccezione della cartella media.

Rendiamoci visibili:

Nella vostra home oltre a tutte le cartelle che avete creato fin qui, ci dovrebbe essere una cartella con il nome uguale a quello del dominio che avete acquistato, in caso contrario vi consiglio di visitare il wiki di dreamhost per maggiori informazioni.

1. Supponendo quindi che voi abbiate una cartella miodominio.com la prima cosa da fare è aggiungere le ultime due cartelle create nel PATH di sistema:

   vim ~/.bashrc
   export PYTHONPATH=$PYTHONPATH:$HOME/django_src:$HOME/django_projects
   :wq
   source ~/.bashrc

2. bisogna creare un file di configurazione che vi permetta di interfacciare il vostro progetto Django con il modulo fcgi:

   vim ~/miodominio.com/django.fcgi
   #!/home/username/bin/python
   import sys
   sys.path += ['/home/username/django_src']
   sys.path += ['/home/username/django_projects']
   from flup.server.fcgi import WSGIServer
   from django.core.handlers.wsgi import WSGIHandler
   import os os.environ['DJANGO_SETTINGS_MODULE'] = 'Progetto.settings'
   WSGIServer(WSGIHandler()).run()
   
   :wq

   ovviamente le parti con username e Progetto vanno sostituite con i vostri dati.
   (N.B.) Fate molta attenzione ad utilizzare nano o vim come editor se hanno il wordwrap, perch� in questo caso le linee troppo lunghe verranno spezzate ed il file sar� inservibile.

3. ora va creato sempre nella directory miodominio.com il file che vi consentirà di utilizzare il mod_rewrite di Apache, quindi questo è quello che dovrete scrivere:

   vim ~/miodominio.com/.htaccess
   RewriteEngine On
   RewriteBase /
   
   RewriteCond %{REQUEST_URI} ^/stats/(.*)$ [OR]
   RewriteRule ^.*$ - [L]
   RewriteRule ^(media/.*)$ - [L]
   RewriteRule ^(admin_media/.*)$ - [L]
   RewriteCond %{REQUEST_URI} !(django.fcgi)
   RewriteRule ^(.*)$ django.fcgi/$1 [L]  
   
   :wq

   la riga

   RewriteCond %{REQUEST_URI} ^/stats/(.*)$ [OR]

   sta ad indicare la parte di file nella quale dovrete inserire tutte le url che non debbono essere gestite da django, quindi ad esempio l’url per accedere alle statistiche del sito www.miodominio.com/stats

4. gli ultimi ritocchi da fare sono:

   ln -s ~/django_src/django/contrib/admin/media ~/miodomionio.com/admin_media

   per rendere disponibile la grafica dell’amministrazione e caricare tramite ftp la cartella media del proprio progetto sempre dentro ~/miodominio.com

5. Ormai giunti alla fine di questo lungo lavoro, dovrete modificare il file di configurazione di django, settings.py in modo tale che rispetti il nuovo ordinamento delle directory, in particolare vanno modificate tutte le linee che si riferiscono alla cartella media indicando dove queste vanno ricercate, cioè ~/miodominio.com:

   MEDIA_ROOT = '/home/username/miodominio.com/media/'
   
   MEDIA_URL = 'http://www.miodominio.com/media/'
   
   ADMIN_MEDIA_PREFIX = '/admin_media/'
   
   TEMPLATE_DIRS = ( '/home/username/miodominio.com/media/template/',  )

6. Per concludere dovrete “uccidere” tutti i processi attivi con python e django, ricordate questo passaggio è necessario ripeterlo tutte le volte che modificherete un file vitale di django come settings.py o urls.py, digitate quindi:

   killall -9 /home/username/bin/python
   killall -9 django.fcgi

Questo è veramente tutto, vi consiglio di leggere il tutorial su come utilizzare vim presente in questo blog all’indirizzo: http://www.antonellocicchese.com/2005/12/12/tutorial-vim/

ATTENZIONE: questa configurazione dopo i recenti aggiornamenti su dreamhost non è più consigliata, spesso causa crash nel sito che risulta irraggiungibile ritornando Errore 500, appena possibile pubblicherò una guida aggiornata…

Dal punto di vista di quei simpatici ragnetti dei motori di ricerca questi url sono la cosa pi� pericolosa che esista, difatti nulla assicura allo spider che seguendo questi indirizzi riuscirebbe ad indicizzare correttamente il sito ad esempio supponiamo che voi abbiate un sito con due sole pagine index.php e spidertrap.php, e che per qualche motivo index contenga un link a spidertrap utlizzando un indirizzo nel formato sito/spidertrap.php?SID=84duryreyey e spidertrap contenga un link a index sempre nel formato di prima, dove SID � la variabile che contiene l’id di sessione del vostro visitatore, quello che potrebbe succedere, ad ogni nuova visita degli spider, è che seguendo i link tra le due pagine, lo spider cadrebbe in un loop nel quale ad ogni nuovo accesso SID avrebbe un valore diverso da quello precedente, inducendo così lo spider a pensare di trovarsi difronte ad una pagina mai indicizzata, ottenendo così un’indicizzazione infinita.

La norma per gli spider è quindi quella di non considerare i parametri negli url, (o almeno tralasciarne buona parte) riducendo così la profondità di indicizzazione nei vostri siti.

Proprio in ragione di questo interviene l’url rewriting che consente di riscrivere gli indirizzi che contengono parametri in indirizzi nel formato: sito/param1/param2/param3/pippo.php o in quasi qualunque altra forma vi venga in mente, consentendo così agli spider di attraversare tutto il vostro sito, oltre che ai vostri utenti di rintracciare una pagina interna senza diventare matti.

Il post potrei dichiararlo concluso qui, non mi metterò a spiegare come vanno scritte le regole per l’url rewrite, ma se qualcuno fosse particolarmente interessato potrei pensare di scrivere un nuovo post.

Consiglio a tutti gli interessati di leggersi questo articolo se potete usare .htaccess sul vostro server:

http://pro.html.it/articoli/id_219/idcat_28/pag_3/pag.html

mentre quest’altro se non vi viene concesso:

http://freephp.html.it/articoli/view_articolo.asp?id=61

Originariamente questa testo è stato pubblicato da me sul forum del sito AlVerde.net, a questo indirizzo potrete leggere la versione originale:
http://www.alverde.net/forum/topic.asp?TOPIC_ID=6866&whichpage=1