How to Serve Files Through PHP Script and Update Them from Cache Properly

• The article explains how to use the Pragma header to prevent the browser from caching files served through PHP script, which can cause outdated or incorrect content to be displayed.
• The article provides some examples and code snippets for serving files with and without the Pragma header, and shows the difference in the browser’s behavior.

PHP is a powerful and popular scripting language for web development. It allows you to create dynamic and interactive web pages, as well as manipulate files and data on the server side. However, PHP also has some quirks and pitfalls that can cause unexpected behavior and errors. One of them is related to serving files through PHP script and updating them from cache properly.

In this article, we will explain the problem and the solution for this issue, and provide some examples and code snippets to help you implement this solution in your own projects. We will also answer some frequently asked questions related to the topic of this article.

Problem

The problem is that when you serve a file through a PHP script, such as an image or a PDF document, the browser may cache the file and not update it when the file changes on the server. This can lead to outdated or incorrect content being displayed to the user, which can affect the user experience and functionality of your website or application.

For example, suppose you have a PHP script that serves private files from outside of the domain’s folder. The intent behind the script is to use some PHP logic to verify that whoever is requesting the file has proper access to what they are asking for. For the sake of avoiding asking repeatedly for a file the user has already downloaded, you added some headers to establish caching rules for the file.

So far, everything appears to be working correctly for determining if the file served has since changed. However, despite no longer sending a 304 Not Modified status, it’s still sending the old file. For example:

• Request newly added file; serve file with 200 OK code
• Request previously loaded file; serve 304 Not Modified code
• Change image, request newly changed image; serve new file with 200 OK code

The only part that isn’t working is serving the new image, your browser refuses to update it unless you do Ctrl+F5. If you dump just the raw data of the file, you can visually see that it’s updating properly but as soon as you add the Content-type header, it refuses to update.

Here’s a sample of the code you’re using to handle the caching headers (actual values are determined before the script reaches this part, and they aren’t really relevant):

<?php
$filename = 'test.jpg';
$path = '/0001/user/';
$filesize = 300000;
$filetype = 'image/jpeg';
$created = '2023-10-17 12:00:00';
$modified = '2023-10-17 13:00:00';

$etag = md5 ($filename.$modified);

// Set expiration date to 30 days from the current date
$expiration = strtotime ('+30 days');
$expiration = gmdate ('D, d M Y H:i:s \\G\\M\\T', $expiration);

// Set the "Cache-Control" header to specify private caching for 30 days
header ('Cache-Control: private, max-age=2592000');
header ('Expires: '.$expiration);

if (isset ($_SERVER ['HTTP_IF_NONE_MATCH'])) {

    if ($_SERVER ['HTTP_IF_NONE_MATCH'] === $etag) {

        // The client's cached version matches the current version, send a 304 Not Modified response
        $serverLastModified = max (strtotime ($modified), strtotime ($created));
        header ('Last-Modified: '.gmdate ('D, d M Y H:i:s \\G\\M\\T', $serverLastModified));
        header ('ETag: '.$etag);
        header ('HTTP/1.1 304 Not Modified');
        die;
    }
} else if (isset ($_SERVER ['HTTP_IF_MODIFIED_SINCE'])) {

    // If the browser has a cached version, check if it's up to date
    $clientLastModified = strtotime ($_SERVER ['HTTP_IF_MODIFIED_SINCE']);
    $serverLastModified = max (strtotime ($modified), strtotime ($created));

    if ($clientLastModified >= $serverLastModified) {

        // The client's cached version is up to date, send a 304 Not Modified response
        header ('Last-Modified: '.gmdate ('D, d M Y H:i:s \\G\\M\\T', $serverLastModified));
        // Add an ETag header for cache validation
        header ('ETag: '.$etag);
        header ('HTTP/1.1 304 Not Modified');
        die;
    }
}

// Add an ETag header for cache validation
header ('ETag: '.$etag);

// Set the "Last-Modified" header using the most recent date
$lastModifiedDate = max (strtotime ($modified), strtotime ($created));
$lastModifiedDateFormatted = gmdate ('D, d M Y H:i:s \\G\\M\\T', $lastModifiedDate);
header ('Last-Modified: '.$lastModifiedDateFormatted);

// Output file to browser
header ('Content-type: '.$filetype);

// Flush output buffer and send headers
clearstatcache ();
if (ob_get_length ()) {

    ob_clean ();
    ob_end_clean ();
}
flush ();

readfile (__DIR__.'/../../private/'.$path.$filename);

So what’s causing this problem and how can we fix it?

Solution

The solution is to use the Pragma header to prevent the browser from caching the file. The Pragma header is an HTTP/1.0 header that can be used to specify implementation-specific directives that may apply to any recipient along the request/response chain. One of the most common values for the Pragma header is no-cache, which tells the browser not to cache the response.

To use the Pragma header, we need to add it to our PHP script before sending the file to the browser. For example:

<?php
// ...
// Output file to browser
header ('Content-type: '.$filetype);

// Add a Pragma header to prevent caching
header ('Pragma: no-cache');

// Flush output buffer and send headers
clearstatcache ();
if (ob_get_length ()) {

    ob_clean ();
    ob_end_clean ();
}
flush ();

readfile (__DIR__.'/../../private/'.$path.$filename);

By adding this header, we can ensure that the browser will always request the latest version of the file from the server, and not use a cached version. This way, we can avoid serving outdated or incorrect content to the user.

However, using the Pragma header also has some drawbacks. One of them is that it may affect the performance of your website or application, as it will increase the number of requests and data transfer between the server and the client. Another one is that it may not work with some browsers or proxies that do not support or ignore the Pragma header.

Therefore, you may want to consider some alternatives or improvements to this solution, such as:

• Using a different caching strategy, such as adding a query string or a timestamp to the file URL, which will force the browser to request a new version of the file when it changes.
• Using a different file serving method, such as using Apache’s mod_rewrite module or Nginx’s X-Accel-Redirect header, which will allow you to serve files from outside of the document root without using PHP.
• Using a different file storage method, such as storing files in a database or a cloud service, which will allow you to control and update them more easily.

Frequently Asked Questions (FAQs)

Here are some frequently asked questions related to the topic of this article:

Question: What are the benefits of serving files through PHP script?

Answer: Serving files through PHP script can provide some benefits, such as:

• You can serve files from outside of the document root, which can improve security and organization.
• You can use PHP logic to verify access rights and permissions for each file request, which can improve privacy and control.
• You can use PHP functions and headers to manipulate and customize the file content and response, which can improve functionality and user experience.

Question: What are the drawbacks of serving files through PHP script?

Answer: Serving files through PHP script can also have some drawbacks, such as:

• It can affect performance and scalability, as it will consume more server resources and bandwidth than serving files directly from the web server.
• It can cause caching issues, as it may not work well with some browsers or proxies that do not support or ignore some PHP headers.
• It can introduce security risks, as it may expose sensitive information or allow unauthorized access if not implemented properly.

Question: How can I optimize the performance and caching of my website or application?

Answer: You can optimize the performance and caching of your website or application by using some best practices and techniques, such as:

• Using a content delivery network (CDN) to distribute your files across multiple servers and locations, which can reduce latency and bandwidth consumption.
• Using compression and minification to reduce the size of your files, which can improve loading speed and save storage space.
• Using browser caching and cache-control headers to specify how long and under what conditions your files can be cached by the browser, which can improve performance and user experience.
• Using versioning or fingerprinting to append a unique identifier to your file names, which can prevent caching issues when you update your files on the server.

Conclusion

In this article, we have shown you how to serve files through PHP script and update them from cache properly. We have explained the problem and the solution, and provided some examples and code snippets to help you implement this solution in your own projects. We hope you found this article useful and informative.

If you have any questions or feedback, please feel free to leave a comment below. We would love to hear from you and help you with your PHP projects.

Disclaimer: This article is not sponsored or endorsed by PHP. The opinions and views expressed in this article are solely those of the author and do not necessarily reflect the official policy or position of any organization or company. The information and code provided in this article are for educational and informational purposes only and are not guaranteed to be error-free or suitable for any specific purpose. The author is not responsible for any damages or losses caused by the use or misuse of the information and code provided in this article. Use at your own risk.