Esempio di Gravatar

http://www.gravatar.com/avatar/36ac00adbe6247f505c702d904f7f44a.jpg?s=100&r=g&d=http%3A%2F%2Fwww.soluzionisis.com%2Finc%2Fimg%2Flogo.jpg

Per avere lo stesso risultato in PHP si può utilizzare questo script:

$email = 'indirizzo@email.it';
$size = 100;
$rating = 'g';
$default = 'http://www.soluzionisis.com/inc/img/logo.jpg';
$url = 'http://www.gravatar.com/avatar/'.md5(strtolower($email)).'.jpg?s='.$size.'&r='.$rating.'&d='.urlencode($default);
echo '<img src="'.$url.'" alt="Avatar" width="'.$size.'" height="'.$size.'" />';

Sicuramente una condizione ottimale per ottenere prestazioni migliori della propria web app o del proprio sito web è impostare il cosidetto Far Future Expire Header degli elementi prensenti nelle pagine e delle pagine stesse.

In questo post cercherò di descrivere alcune tecniche per impostare tale condizione.

Cito dal sito di YSlow:

Web page designs are getting richer and richer, which means more scripts, stylesheets, images, and Flash in the page. A first-time visitor to your page may have to make several HTTP requests, but by using the Expires header you make those components cacheable. This avoids unnecessary HTTP requests on subsequent page views. Expires headers are most often used with images, but they should be used on all components including scripts, stylesheets, and Flash components.

Quindi in pratica che fa?:-)

L’Expire Header definisce la scadenza dell’oggetto che il browser preleva dal server e deposita nella cache del client. Impostando la “data di scadenza” ad un periodo molto lontano (Far Future per l’appunto) diciamo al browser di non richiamare più tale componente durante le succesive visite alla pagina che lo conteneva, rendendo di fatto la navigazione più veloce. Inoltre, applicando questa tecnica ad elementi comuni a tutte le pagine (es: background o file javascript o file css) l’utente usufruirà dei benefici di questa tecnica fin dalla seconda pagina che andrà a visualizzare sul nostro sito.

Vediamo come fare.

Tramite l’uso di .htaccess (Apache)

<FilesMatch "\.(ico|pdf|flv|jpg|jpeg|png|gif|js|css|swf|php|html|htm|php4|php5)$">
Header set Expires "Thu, 2 Feb 2010 20:00:00 GMT"
</FilesMatch>

con l’istruzione FileMatch indichiamo a quale tipo di file applicare le regole all’interno del blocco di codice e con “Header set Expires” andremo a dire ad Apache di servire il contenuto indicato con una data di scadenza molto lontana. Nell’esempio ho usato il 2 Febbraio 2010, alle 8 di sera.

Tramite le impostazioni di IIS 6.0

1. Aprite il pannello di controllo di Internet Information Services (IIS).
2. Espandete “LocalMachine” sul pannelo di sinistra e succesivamente cliccate su Web Sites
3. Click con il tasto destro sul sito interessato e selezionate Properties.
4. Nel tab HTTP Headers, attivate la checkbox “Enable Content Expiration” e succesivamente selezionate l’opzione “Expire On”. e impostare il 2 Febbraio 2010 alle 8 di sera
5. Riavviate tutti i servizi IIS.

Con PHP
File far_future_loader.php

<?php
header("Content-type: text/javascript; charset: UTF-8");
header("Cache-Control: must-revalidate");
header("Expires: " . gmdate("D, d M Y H:i:s",time() + (60 * 60 * 24 * 3)) . " GMT");
include(dirname(__FILE__).'/scripts.js');
?>

con il codice sopra potete, ad esempio, raggruppare tutti i vostri file javascript in un unico grande file .php, modificare l’header Content-type in modo che venga interpretato correttamente dal browser come text/javascript e poi modificarne a piaciemento la deata di scandenza.
Successivamente nell’header delle vostre pagine, anzichè includere i singoli file javascript con l’istruzione:

<script type="text/javascript" src="js/scripts.js"></script>

userete

<script type="text/javascript" src="js/far_future_loader.php"></script>

Potete usare il file far_future_loader.php per ogni tipo di file, semplicemente cambiano il Content-type dei file che andrete ad includere, ad esempio, se volete averne uno anche per i file .css dovrete scrivere:

<?php
header("Content-type: text/css; charset: UTF-8");
header("Cache-Control: must-revalidate");
header("Expires: " . gmdate("D, d M Y H:i:s",time() + (60 * 60 * 24 * 3)) . " GMT");
include(dirname(__FILE__).'/style.css');
?>

e successivamente nell’header delle vostre pagine, esattamente come avete fatto per il file javascript, sostituirete l’istruzione:

<link rel="stylesheet" href="css/style.css" type="text/css" />

con

<link rel="stylesheet" href="css/far_future_loader.php" type="text/css" />

Con ASP
la procedura è identica a quella per PHP con la sola differenza che in ASP gli header si setttano con i seguenti comandi:

<% Response.CacheControl = "must-revalidate" %>
<% Response.Expires = -1 %>

Con JSP (Tomcat)
Grazie a Byron Tymvios su jGuru
E’ possibile ottenere l’identico risultato avuto con PHP o ASP tramite i filtri. Ad esempio:

package com.xyz
 
import java.io.IOException;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletResponse;
 
public class CacheFilter implements javax.servlet.Filter {
  FilterConfig filterConfig = null;
 
  public void init(FilterConfig filterConfig){
    this.filterConfig = filterConfig;
  }
 
  public void doFilter(ServletRequest req,
     ServletResponse res,
     FilterChain chain)
     throws IOException, ServletException {
    String sCache = filterConfig.getInitParameter("cache");
 
    if(sCache != null){       ((HttpServletResponse)res).setHeader("Cache-Control", sCache);
 
    }
 
    chain.doFilter(req, res);
  }
 
  public void destroy(){
    this.filterConfig = null;
  }
}

e poi impostare nel file web.xml il filtro per ogni contenuto desiderato. Ecco l’esempio per i file .jpg:

<filter>
  <filter-name>Cache</filter-name>
  <filter-class>com.xyz.CacheFilter</filter-class>
  <init-param>
    <param-name>cache</param-name>
    <param-value>public, max-age=2592000</param-value>
  </init-param>
</filter>
<filter-mapping>
  <filter-name>Cache</filter-name>
  <url-pattern>*.jpg</url-pattern>
</filter-mapping>

è tutto
nella prossimo post parleremo degli ETag.
Giovanni

abstract class ActiveRecordBase {
  # qui ci va la dichiarazione degli attributi della classe che tralasciamo
  # .....
  #
  public function __construct($data=array()){
     $this->__db = &MDB2::connect(DB_DSN);  // DB_DSN è una stringa che contiene di dati accesso al DB
     $this->__table = strtolower(get_class($this));
     if (!is_array($data) && is_numeric($data)){
         $sql = "SELECT * FROM ".$this->__db->quoteIdentifier($this->__table).
                  " WHERE ".$this->__db->quoteIdentifier($this->__primary_key)." = ".$this->__db->quote($data);
         $data = $this->__db->queryRow($sql);
     }
     if (!empty($data)) foreach ($data as $key => $value){ $this->$key = $value; $this->fields[] = $key;}
  }
# Qui prosegue il resto del codice della classe
# ....
}

Con questa modifica la nostra classe continua a funzionare accettando 0 o 1 parametro di tipo numerico o array/hash.
Vediamo ora l’implementazione di un metodo find() che permetta di passare come parametro l’ID del record che vogliamo ottenere. Per semplicità d’ora in avanti verranno omesse le dichiarazioni di classe quando non strettamente necessarie.

    public function find($id){
         if (!is_numeric($id)) return false;
         $sql = "SELECT * FROM ".$this->__db->quoteIdentifier($this->__table)." WHERE ".
                  $this->__db->quoteIdentifier($this->__primary_key)." = ".$this->__db->quote($id);
         $data = $this->__db->queryRow($data);
         if (!empty($data)){
             foreach ($data as $key => $value){ $this->$key = $value; $this->fields[] = $key;}
             return true;
         }
         return false;
    }

Come potete vedere, l’implementazione di find() è molto simile a quella del costruttore. Ricordiamoci il principio DRY (= Don’t Repeat Yourself). Modifichiamo il costruttore e aggiungiamo un metodo privato che assegni a partire da un array i valori corrispondenti agli attributi della classe.
__assignData sarà un metodo privato che assegna i valori agli attributi:

    private function __assignData($data=array()){
        if (!empty($data)){
             foreach ($data as $key => $value){ $this->$key = $value; $this->fields[] = $key;}
             return true;
         }
         return false;
    }

Possiamo semplificare il metodo find():

    public function find($id){
         if (!is_numeric($id)) return false;
         $sql = "SELECT * FROM ".$this->__db->quoteIdentifier($this->__table)." WHERE ".
                  $this->__db->quoteIdentifier($this->__primary_key)." = ".$this->__db->quote($id);
         $data = $this->__db->queryRow($data);
         return $this->__assignData($data);
    }

E ora rivediamo il costruttore:

  public function __construct($data=array()){
     $this->__db = &MDB2::connect(DB_DSN);  // DB_DSN è una stringa che contiene di dati accesso al DB
     $this->__table = strtolower(get_class($this));
     if (!is_array($data) && is_numeric($data)){
         $this->find($data);
     }
     $this->__assignData($data);
  }

L’implementazione di ActiveRecord in Rails è molto complessa, permette di effettuare validazioni e avere riferimenti a chiavi esterne. Vediamo un’implementazione più semplice in PHP, ma comunque efficace.
Cercheremo di arrivare ad un’implementazione molto potente in qualche puntata.

Il concetto che sta alla base di active record è di trasformare l’accesso al database in accesso a una classe.
Cominciamo a definire una classe base che abbia l’accesso al database. Per semplificare utilizzeremo la classe PEAR::MDB2.

require 'MDB2.php';
abstract class ActiveRecordBase {
  protected $__db; // Dichiariamo un oggetto "protected" per l'accesso al DB
  protected $__primary_key = "id"; // Definiamo una chiave primaria per la tabella. Può essere poi
                                           // modificata per ogni singola classe che estende questa.
  protected $__fields; // In questo attributo di tipo array andremo a salvare i campi della nostra tabella (escluso il campo primary key)
  protected $__table; // In questo attributo salviamo il nome della tabella
  /**
   * Il costruttore istanzia una connessione con il db e se sono presenti dei dati
   * li salva nell'oggetto (non nel database!)
   */
  public function __construct($data=array()){
     $this->db = &MDB2::connect(DB_DSN);  // DB_DSN è una stringa che contiene di dati accesso al DB
     $this->__table = strtolower(get_class($this));
     if (!empty($data)) foreach ($data as $key => $value){ $this->$key = $value; $this->fields[] = $key;}
  }
 
  /**
   * Definiamo un metodo per create un nuovo Record.
   * Esso è privato perché verrà utilizzato dal metodo save()
   */
  private function create(){
     // Creaimo l'istruzione SQL a partire dai campi disponibili
     $sql = "INSERT INTO ".$this->__db->quoteIdentifier($this->table)." (";
     $first = true;
     $data = array();
     foreach ($this->__fields as $field){
       if (!$first) $sql.=",";
       $sql.= $this->__db->quoteIdentifier($field);
       $data[] = $this->$field;
       $first = false;
     }
     $sql.= ") VALUES (";
     for ($i = 0; $i < count($fields); $i++) if ($i=0) $sql.="?" else $sql.=",?";
     $sql:=");";
     $prep = $this->__db->prepare($sql);
     $res =  $prep->execute($data);
     $pkey_field = $this->__primary_key;
     if ($res) $this->$pkey_field = $this->__db->lastInsertID($this->__table);
     return $res;
  }
 
  private function update(){
    $sql = "UPDATE ".$this->__db->quoteIdentifier($this->__table)." SET ";
    $first = true;
    $data = array();
    foreach ($this->__fields as $field){
      if (!$first) $sql.=",";
      $sql = "$field = ?";
      $data[] = $this->$field;
      $first = false;
    }
    $pkey_field = $this->__primary_key;
    $sql = "WHERE ".$this->db->quoteIdentifier($pkey_field)." = ".$this->db->quote($this->$pkey_field);
    $prep = $this->__db->prepare($sql);
    return $prep->execute($data);
  }
 
  private function delete(){
    $pkey_field = $this->__primary_key;
    $sql = "DELETE FROM ".$this->__db->quoteIdentifier($this->__table).
             " WHERE ".$this->db->quoteIdentifier($pkey_field)." = ".$this->db->quote($this->$pkey_field);
    return $this->__db->query($sql);
  }
 
  public function save(){
     $pkey_field = $this->__primary_key;
     if (!isset($this->$pkey_field)) return $this->create();
     else return $this->update();
  }
 
  public function destroy(){
     $pkey_field = $this->__primary_key;
     if (isset($this->$pkey_field)) return $this->delete();
     else return false;
  }
 
}

In questa implementazione, ancora in stato “embrionale”, è possibile creare un nuovo record.
Un uso molto semplice potrebbe essere creare una classe che estenda la base e istanziarne un oggetto:

require 'ActiveRecordBase.class.php'
class Dog extends ActiveRecordBase {}
$dog = new Dog(array('name' => 'Pluto', 'age' => '7'));
$dog->save();

Il precedente script inserisce un nuovo record in una tabella ‘dog’ (stessa nome della classe che estende ActiveRecordBase) assegnando gli attributi ‘name’ e ‘age’.
La primary key viene implicitamente impostata come “id” (ovviamente se il campo ha l’attributo auto_increment) e il valore inserito automaticamente.
Il tutto in 3 righe di codice, molto molto semplici…non è una bella comodità?
Più avanti vedremo come effettuare ricerche, e quindi come implementare il metodo “find” e migliorare ulteriormente la classe base in modo da gestire meglio errori, validazioni e chiavi esterne.

Questa funzione restituisce TRUE o FALSE in base al successo o meno dell’ordinamento e mantiene le chiavi se non sono numeriche. Accetta un numero flessibile di parametri. Il primo parametro deve essere un array e quelli seguenti possono essere array o metodi di ordinamento (SORT_ASC per ordinare in ordine crescente, SORT_DESC per l’ordine decrescente e i metodi che abbiamo già visto SORT_REGULAR, SORT_NUMERIC e SORT_STRING).

Nel primo esempio vediamo come ordinare più array contemporaneamente:

$arr1 = array(3,2,2,4,5);
$arr2 = array('a','b','c','d','e');
array_multisort($arr1,$arr2);

Il primo array quindi sarà ordinato in questo modo 2, 2, 3, 4 e 5 e il secondo in questo modo ‘b’, ‘c’, ‘a’, ‘d’ e ‘e’. Praticamente viene effettuato l’ordinamento del primo array e quando ci sono degli elementi uguali (nell’esempio il 2) si effettua l’ordinamento in base all’elemento con lo stesso indice del secondo array.

Per ordinare un array multidimensionale il ragionamento è il medesimo. Ecco un esempio:

$arr = array(
		array(3,2,2,4,5),
		array('a','b','c','d','e')
	);
array_multisort($arr[0],$arr[1]);

Il risultato sarà come quello dell’esempio precedente, cioè il primo sotto-array sarà uguale al primo array dell’esempio precedente e il secondo sotto-array sarà uguale al secondo dell’esempio precedente.

Quindi si può dedurre che la funzione array_multisort è molto simile all’ORDER BY di SQL.
Ecco una query di esempio:

SELECT nome,cognome FROM utenti ORDER BY cognome DESC,nome ASC

È uguale a questo script in PHP:

$utenti = array(
		array('nome'=>'Pippo','cognome'=>'Baudo'),
		array('nome'=>'Mickey','cognome'=>'Mouse'),
		array('nome'=>'Paolino','cognome'=>'Paperino')
	);
$cognomi = array();
$nomi = array();
foreach($utenti as $k=>$v){
	$cognomi[$k] = $v['cognome'];
	$nomi[$k] = $v['nome'];
}
array_multisort($cognomi,SORT_DESC,SORT_STRING, $nomi,SORT_DESC,SORT_STRING, $utenti);

L’array $utenti sarà ordinato prima in modo decrescente in base ai cognomi e poi, per i cognomi uguali, in modo crescente in base ai nomi.

Ecco un esempio:

$arr = array('pippo','pluto','paperino');
sort($arr);

Dopo l’utilizzo di questa funzione potrebbe essere necessario azzerare il contatore utilizzando la funzione reset.
Le seguenti funzioni si utilizzano alla stesso modo di sort ma servono per ordinare gli array in modo diverso:

• rsort ordina un array in ordine decrescente;
• asort ordina un array in ordine crescente ma mantiene le chiavi;
• arsort ordina un array in ordine decrescente ma mantiene le chiavi;
• ksort ordina un array in base alle chiavi e non ai valori;
• krsort ordina un array in base alle chiavi in ordine decrescente.

Per ordinare un array in modo naturale si possono usare le funzioni natsort e natcasesort. Entrambe ordinano in ordine crescente e mantengono le chiavi con l’unica differenza che natcasesort non fa differenza tra lettere maiuscole e minuscole. Queste funzioni non restituiscono nulla e hanno solo un parametro, l’array che si vuole ordinare.
Ecco un esempio:

$arr = array('pippo12.php','pippo2.php','pippo1.php');
$arr2 = $arr;
sort($arr);
natsort($arr2);

Il risultato di sort sarà un array con gli elementi in questo ordine: “pippo1.php”, “pippo12.php” e “pippo2.php”; invece il risultato di natsort sarà questo: “pippo1.php”, “pippo2.php” e “pippo12.php”.

È possibile poi ordinare un array in base a una funzione definita dal programmatore. Per far ciò si può utilizzare la funzione usort che restituisce TRUE o FALSE in base al successo o meno dell’ordinamento e accetta due parametri. Il primo parametro è l’array da ordinare e il secondo è il nome della funzione definita dal programmatore.
La funzione definita dal programmatore deve accettare due parametri che saranno i due valori da confrontare e deve restituire un numero intero minore di zero se il primo parametro è minore del secondo, zero se i due parametri sono uguale e un numero intero maggiore di zero se il secondo parametro è maggiore del secondo.
Ecco un esempio che simula la funzione sort:

function sortAccordingMe($a,$b){
	if($a==$b)
		return 0;
	else if($a<$b)
		return -1;
	else
		return 1;
}
$arr = array('pippo','pluto','paperino');
usort($arr,'sortAccordingMe');

Altre due funzioni simili nel funzionamento a usort sono uasort che mantiene le chiavi e uksort che ordina in base alle chiavi e non ai valori.

La prossima volta spiegherò come ordinare un array multidimensionale e più array contemporaneamente.

Una classe astratta è una classe che non può essere istanziata, ma che può essere estesa da altre classi. Prendiamo per esempio questa classe astratta:

abstract class Personaggio {
    private $nome;
    public function __construct($nome){ $this->nome = $nome;}
    public function saluta(){ return "Ciao! Io sono ".$this->nome;}
}

Se tentassimo di istanziare questa classe con

$pippo = new Personaggio("Pippo");

l’interprete PHP ci risponderebbe con: “Fatal error: Cannot instantiate abstract class Personaggio”.

Possiamo però creare una nuova classe che estenda Personaggio:

class Pippo extends Personaggio {
    public function __construct(){
        parent::__construct("Pippo");
    }
}

La classe Pippo eredita i metodi e gli attributi di Personaggio e ha una redifinizione del costruttore, dove si va esplicitamente a richiamare il costruttore della classe astratta, specificando però un parametro costante per questa classe (la stringa “Pippo”). Possiamo quindi istanziare Pippo ed utilizzare i metodi della classe personaggio:

$pippo = new Pippo();
echo $pippo->saluta();

L’output di questo banale programma è la stringa “Ciao! Io sono Pippo”. Le classi astratte quindi servono quando si devono implementare della classi ha hanno alcune operazioni in comune. Le classi che estendono una classe astratta possono poi avere dei metodi propri o ridefinire i metodi già definiti nella classe astratta.

Le interfacce invece definiscono un “prototipo” di una classe. Tutte le classi che implementano un’interfaccia devono definirne tutti i metodi. Vediamo un esempio di utilizzo:

interface Personaggio {
    public function saluta();
}
class Pippo implements Personaggio {
    private $nome;
    public function __construct(){ $this->nome = "Pippo";}
    public function saluta(){ return "Ciao! Io sono ".$this->nome;}
}
 
$pippo = new Pippo();
echo $pippo->saluta();

Apparentemente l’uso di una classe astratta o di una interfaccia sembra pressoché indifferente, soprattutto perché PHP non è un linguaggio fortemente tipizzato, ma il concetto che sta alla base di uno o dell’altro cambia: una classe Pippo che estende una classe astratta Personaggio è una classe di tipo “Pippo” che eredita i metodi e gli attributi della classe “Personaggio”. Una classe Pippo che implementa un’interfaccia “Personaggio” è sia una classe di tipo “Pippo” che di tipo “Personaggio”.
Questa differenza si noterebbe di più se si potesse dichiarare il tipo degli argomenti di una funzione (come ad esempio avviene in Java).
Ammettiamo che lo si possa fare anche in PHP e che abbiamo la seguente funzione:

function incontra(Personaggio $p){
    $p->saluta();
}

Se usiamo le interfacce non abbiamo nessun problema a far passare come argomento un’istanza di Pippo, mentre se Pippo è una classe che ne estende una astratta Personaggio, per poter far passare come argomento della funzione una istanza di Pippo dovremmo farne il downcast a Personaggio.

Riepilogando: l’uso delle classi astratte che vengono estese è utile quando si devono implementare più classi che hanno metodi e attributi in comune, ma dove il “caso base” (la classe astratta) non è ammissibile.
L’uso delle interfacce invece è utile quando le classi devono essere dello stesso tipo, ma ogni volta devono implementare i metodi dell’interfaccia in modo differente. Vediamo ora un esempio più concreto:

// Definiamo un'interfaccia Forma con un metodo getArea()
interface Forma {
    public function getArea();
}
// Definiamo ora le implementazioni di Forma, per semplicità sono stati omessi i costruttori. Ammettiamo che comunque abbiano dei
// parametri per impostare gli attributi delle varie classi
class Quadrato implements Forma {
   public function getArea() { return $this->lato*$this->lato;}
}
class Cerchio implements Forma {
   public function getArea(){ return $this->raggio*$this->raggio*3.14;}
}
class Triangolo implements Forma {
   public function getArea(){ return $this->base*$this->altezza/2;}
}
// Definiamo ora una funzione in "stile Java" che stampi a video l'area di una forma
function stampaArea(Forma $f){
    echo $f->getArea();
}
// Proviamo ad utilizzare le implementazione dell'interfaccia Forma con questa funzione
$t = new Triangolo($base,$altezza);
$q = new Quadrato($lato);
stampaArea($t);
stampaArea($q);

In particolare Internet Explorer 6 mi ha dato una bella gatta da pelare con i file da scaricare.
In un’applicazione web che ho scritto è possibile scaricare alcuni file, solo da parte di utenti registrati. Quindi i file stanno fuori dalla visibilità del browser e vengono serviti da un file (download.php, nel mio caso) che, dopo aver fatto i relativi controlli a login e permessi vari, cambia gli header in modo da far scaricare il file scelto. Semplificando molto è una cosa simile:

1
2
3
4
5
6
7
8
9
10
11

<?php
session_start();
$db = new db();
checkPermission($_GET['id'],$_SESSION['userid']) || die();
$file = $db->query("SELECT * FROM attachments WHERE id = ".$db->quote($_GET['id']);
header ("Content-type: ".$file['mime']);
header ("Content-disposition: attachment; filename=".$file['name']);
header ("Content-Transfer-Enconding: binary");
@readfile($file['full_path']);
exit();
?>

Risultato? Con Firefox nessun problema, con IE 7 nessun problema (eh meno male!!) ma con IE6… disastro!! I file venivano scaricato, ma IE6 ignorava bellamente l’header content-type e l’header content-disposition, nominando il file “download.php”.

Le ho provate davvero tutte per ovviare a questo problema, cambiare header rigurdanti la cache,ecc. ecc., ma l’unico effetto che sono riuscito ad ottenere è stato che il file non si chiamava più download.php, ma download.pdf piuttosto che download.zip…ma io voglio il nome corretto!!!

Google alla mano, ho fatto mille ricerche che non hanno portato a nulla finchè non sono arrivato a questa pagina: http://www.sitefoundry.com/broken_msie.html
e qui ho appreso che per un baco, IE6 in questi casi tenta sempre due richieste andando in errore e che a differenza di Firefox utilizza il protocollo HTTP 1.1 anziché 1.0. Allora mi sono detto: “non è che è tutto un problema di protocollo?!?”.
Prima di:

1

header ("Content-type ...");

ho inserito la seguente riga:

1

header ("HTTP/1.0 200 OK");

forzando così che la mia risposta sia in HTTP/1.0…e ha funzionato!!!
La mia spiegazione è questa: IE cerca (per motivi di sicurezza, dicono) di indentificare autonomamente il tipo di file, ignorando i Content-type e content-disposition vari che si mettono. Forzando il protocollo HTTP a 1.0 probabilmente IE si va a trovare in una modalità compatibile col vecchio protocollo, disabilitando le feature che normalmente utilizza col protocollo HTTP/1.1.

Bisogna stare attenti però all’output compression: il vostro server (Apache) potrebbe avere attivo mod_gzip, il che porterebbe a “g-zippare” tutto il suo output per risparmiare banda di rete. Purtroppo il “caro vecchio” IE6 ha un po’ di problemi a trattare gli header con output gzipped.
La soluzione è in questo caso aggiungere una riga

1

apache_setenv("no-gzip","1");

al vostro script, prima di mandare in output il file da servire. Eventualmente verificate anche che sia disattivata la compressione gzip da PHP.
Per disattivarla occorre aggiungere

1

ini_set("zlib.output_compression","Off");

Io ci sono impazzito 2 giorni su sta cosa…spero che possa essere d’aiuto a molti!