Serving XHTML with the correct mime type using PHP

Posted by Neil Crosby on April 17, 2004 08:27 PM

A lot of websites nowadays make sure that they validate to XHTML 1.0 or 1.1 standards. At least, they think they do. The sad fact is, that unless the correct mime type is being used, no browser will actually process your carefully put together XHTML as XHTML. Instead, it’s treated as tag soup, just as if you’d used any other doc type to identify your page.

Of course, for most websites there’s no real reason to use XHTML in preference to HTML 4.01 - most people (myself included) really just use it to “look cool, and be uber-geeky”. Unless you need the extensible nature of XHTML there’s no real overwhelming reason to use it.

However, if you’re going to say you’re using XHTML, then please make sure you use it properly. This is where most people (and, to be fair, browsers) fall down. Until a couple of months ago, it had never even crossed my mind that I might want to send out a different mime type with my XHTML documents.

The aim of this article is to show you how to use PHP to control the mime type given to your users’ web browsers for your XHTML pages. There are other ways to perform the same task, with httpd.conf or .htaccess files, but this is the way which I control mime types on this website.

What is the correct mime type for XHTML?

According to the W3C’s note on XHTML media types:

• All XHTML variants should be sent out with the “application/xhtml+xml” mime type.
• HTML 4 should be sent with the “text/html” mime type and must not be sent with the “application/xhtml+xml” mime type.
• HTML compatible XHTML 1.0 may be sent with the “text/html” mime type (note that this applies to 1.0 only, not 1.1 or anything which comes after).

HTTP_ACCEPT

So, it would seem that the thing to do would be to simply change the mime type used whenever you write an XHTML page, wouldn’t it? If only life were that simple. Unfortunately, the world’s most dominant browser, Internet Explorer, is incapable of understanding what the “application/xhtml+xml” mime type is talking about, so we’ll need to write a little bit of code to deal with this. Thankfully, there’s a nice easy way to deal with this, since browsers are meant to tell web servers which mime types they know about via the “HTTP_ACCEPT” header which they send with every request. So, if a browser says that it can understand “application/xhtml+xml” as a mime type then we can be sure that it will cope, whereas if it doesn’t say anything about it, then we should make provisions and send as “text/html” instead.

Here’s how we do that bit in PHP:

if(stristr($_SERVER["HTTP_ACCEPT"],"application/xhtml+xml")) { }

Q Values

Now, we need to check the “Q values” which the browser says that it likes. “Q values” are a value between 0 and 1 which the browser can give for each mime type which it says it can deal with - “1” the browser really likes, “0” it hates. So, even if the browser says that it can deal with “application/xhtml+xml”, if it says it prefers “text/html” then that is how we should send the document. This is simply done with a couple of regexes.

$mime = "text/html";
if(preg_match("/application\/xhtml\+xml;q=0(\.[1-9]+)/i",
              $_SERVER["HTTP_ACCEPT"], $matches)) {
   $xhtml_q = $matches[1];
   if(preg_match("/text\/html;q=0(\.[1-9]+)/i",
                 $_SERVER["HTTP_ACCEPT"], $matches)) {

      $html_q = $matches[1];
      if($xhtml_q >= $html_q) {
         $mime = "application/xhtml+xml";
      }
   }
} else {
   $mime = "application/xhtml+xml";
}

We first check if there is a Q value for the “application/xhtml+xml” mime type, and if there is, we compare it to the Q value for the “text/html” mime type. If “application/xhtml+xml” has the greater Q value, or the “application/xhtml+xml” mime type has no Q value given, then the mime type to be used will be “application/xhtml+xml”.

A Special Case for the W3C

What we have so far will deal with all “real” browsers. However, there is one final case which we have to be aware of - the W3C web page validation service. Unfortunately, when their HTML validator requests a webpage, it does not say that it can handle “application/xhtml+xml”. This is a bit of a problem, since if you’re going to the trouble of writing XHTML, you’re definitely going to want to be making sure that it validates! The simple special case which we have to write is as follows:

if (stristr($_SERVER["HTTP_USER_AGENT"],"W3C_Validator")) {
   $mime = "application/xhtml+xml";
}

This ensures that the W3C will always validate the XHTML version of your webpage.

Serving the Headers and writing the Prolog

Now that we know that we’ve chosen a mime type appropriate for the web browser that’s being used, we can serve the headers for the webpage. The headers are what tell the web browser how a file should be interpreted, and can include things such as the mime type, error codes, and server information. We will be changing the “Content-Type” and “Vary” headers. PHP gives us a nice simple method for sending headers - the header function.

header("Content-Type: $mime;charset=$charset");
header("Vary: Accept");

The “Vary” header is used to indicate that the page sent by the webserver will vary, depending on one or more of the request headers originally sent by the web browser. In our case, the page sent back is determined by the contents of the “HTTP_ACCEPT” header.

Once we’ve sent the correct headers, all that remains for us to do with XHTML compatible web browsers is to write the correct doctype and html tags. We decide which we should use with a simple “if” statement.

if($mime == "application/xhtml+xml") {
   $prolog_type = "<?xml version='1.0' encoding='$charset' ?>
      <!DOCTYPE html PUBLIC '-//W3C//DTD XHTML 1.1//EN' 
      'http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd'>
      <html xmlns='http://www.w3.org/1999/xhtml' xml:lang='en'>";
} else {
   $prolog_type = "<!DOCTYPE HTML PUBLIC '-//W3C//DTD HTML 4.01//EN' 
      'http://www.w3.org/TR/html4/strict.dtd'>
      <html lang='en'>";
}
print $prolog_type;

Keeping things nice for the HTML Browsers

However, according to the W3C specifications, things like <br /> are not valid HTML. Now, for the majority of real world browsers, this is not an issue, as they will quite happily parse these closed single tags as if they were just normal HTML. However, there are a few implementations (most notably the standard Java routines) which, if you give them closed single tags, will interpret the first half (<br, say) correctly, and then display the /> as text. So, to ensure that everything works as expected for them, we need to make sure that if we send the web page out with the “text/html” mime type, then we must also change closed single tags into normal single tags.

Again, PHP gives us a nice easy function which does what we want - ob_start. We’ll be using ob_start to pipe output through a function which simply changes any instances of “/>” to “>”.

function fix_code($buffer) {
   return (str_replace(" />", ">", $buffer));
}

This function is called by adding the line ob_start("fix_code"); to the prolog creation code for the “text/html” mime type. This technique could easily be expanded to do more complicated things.

Putting it all Together

Putting everything together, we get the following script. Just copy and paste, and save in an accessible place on your webserver:

<?php
$charset = "iso-8859-1";
$mime = "text/html";

function fix_code($buffer) {
   return (str_replace(" />", ">", $buffer));
}

if(stristr($_SERVER["HTTP_ACCEPT"],"application/xhtml+xml")) {
   # if there's a Q value for "application/xhtml+xml" then also 
   # retrieve the Q value for "text/html"
   if(preg_match("/application\/xhtml\+xml;q=0(\.[1-9]+)/i",
                 $_SERVER["HTTP_ACCEPT"], $matches)) {
      $xhtml_q = $matches[1];
      if(preg_match("/text\/html;q=0(\.[1-9]+)/i",
                    $_SERVER["HTTP_ACCEPT"], $matches)) {
         $html_q = $matches[1];
         # if the Q value for XHTML is greater than or equal to that 
         # for HTML then use the "application/xhtml+xml" mimetype
         if($xhtml_q >= $html_q) {
            $mime = "application/xhtml+xml";
         }
      }
   # if there was no Q value, then just use the 
   # "application/xhtml+xml" mimetype
   } else {
      $mime = "application/xhtml+xml";
   }
}

# special check for the W3C_Validator
if (stristr($_SERVER["HTTP_USER_AGENT"],"W3C_Validator")) {
   $mime = "application/xhtml+xml";
}

# set the prolog_type according to the mime type which was determined
if($mime == "application/xhtml+xml") {
   $prolog_type = "<?xml version='1.0' encoding='$charset' ?>
      <!DOCTYPE html PUBLIC '-//W3C//DTD XHTML 1.1//EN' 
      'http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd'>
      <html xmlns='http://www.w3.org/1999/xhtml' xml:lang='en'>";
} else {
   ob_start("fix_code");
   $prolog_type = "<!DOCTYPE HTML PUBLIC '-//W3C//DTD HTML 4.01//EN' 
      'http://www.w3.org/TR/html4/strict.dtd'>
      <html lang='en'>";
}

# finally, output the mime type and prolog type
header("Content-Type: $mime;charset=$charset");
header("Vary: Accept");
print $prolog_type;
?>

And there you have it. All you need to do to use the correct mime type in your PHP created XHTML pages is replace everything up and including your <html> tag with a simple PHP include. So, your pages will now look like this:

<?php include "/path/to/mimetype.php" ?>
   <head>
      ...
   </head>
   <body>
      ...
   </body>
</html>

And that’s all there is to it.

References

Keystone Websites: Serving up XHTML with the correct mime type - the original script which inspired this article.

Sending XHTML as text/html Considered Harmful - The best text on the subject. It’s been around since 2002, but it’s still being updated regularly.

The Road to XHTML 2.0: MIME Types - Talks about the issues inherent in serving the correct mime type with your documents.

comments (23) | write a comment | permalink | View blog reactions