ConditionalHeaderUtil.php

Go to the documentation of this file.

<?php
 
namespace MediaWiki\Rest;
 
use MediaWiki\Rest\HeaderParser\HttpDate;
use MediaWiki\Rest\HeaderParser\IfNoneMatch;
use RuntimeException;
use Wikimedia\Timestamp\ConvertibleTimestamp;
use Wikimedia\Timestamp\TimestampFormat as TS;
 
class ConditionalHeaderUtil {
    private bool $varnishETagHack = true;
    private $eTag;
    private $lastModified;
    private $hasRepresentation;
 
    private IfNoneMatch $eTagParser;
 
    private ?array $eTagParts = null;
 
    public function __construct() {
        $this->eTagParser = new IfNoneMatch;
    }
 
    public function setValidators(
        $eTag,
        $lastModified,
        $hasRepresentation = null
    ) {
        $this->eTag = $eTag;
        $this->lastModified = $lastModified;
        $this->hasRepresentation = $hasRepresentation;
    }
 
    public function setVarnishETagHack( bool $hack ) {
        $this->varnishETagHack = $hack;
    }
 
    private function getETag(): ?string {
        if ( is_callable( $this->eTag ) ) {
            // resolve callback
            $this->eTag = ( $this->eTag )();
        }
 
        return $this->eTag;
    }
 
    private function getETagParts(): ?array {
        if ( $this->eTagParts !== null ) {
            return $this->eTagParts;
        }
 
        $eTag = $this->getETag();
 
        if ( $eTag === null ) {
            return null;
        }
 
        $this->eTagParts = $this->eTagParser->parseETag( $eTag );
        if ( !$this->eTagParts ) {
            throw new RuntimeException( 'Invalid ETag returned by handler: `' .
                $this->eTagParser->getLastError() . '`' );
        }
 
        return $this->eTagParts;
    }
 
    private function getLastModified(): ?int {
        if ( is_callable( $this->lastModified ) ) {
            // resolve callback
            $this->lastModified = ( $this->lastModified )();
        }
 
        if ( is_string( $this->lastModified ) ) {
            // normalize to int
            $this->lastModified = (int)ConvertibleTimestamp::convert(
                TS::UNIX,
                $this->lastModified
            );
        }
 
        // should be int or null now.
        return $this->lastModified;
    }
 
    private function hasRepresentation(): bool {
        if ( is_callable( $this->hasRepresentation ) ) {
            // resolve callback
            $this->hasRepresentation = ( $this->hasRepresentation )();
        }
 
        if ( $this->hasRepresentation === null ) {
            // apply fallback
            $this->hasRepresentation = $this->getETag() !== null
                || $this->getLastModified() !== null;
        }
 
        return $this->hasRepresentation;
    }
 
    public function checkPreconditions( RequestInterface $request ) {
        $getOrHead = in_array( $request->getMethod(), [ 'GET', 'HEAD' ] );
        if ( $request->hasHeader( 'If-Match' ) ) {
            $im = $request->getHeader( 'If-Match' );
            $match = false;
            foreach ( $this->eTagParser->parseHeaderList( $im ) as $tag ) {
                if ( ( $tag['whole'] === '*' && $this->hasRepresentation() ) ||
                    $this->strongCompare( $this->getETagParts(), $tag )
                ) {
                    $match = true;
                    break;
                }
            }
            if ( !$match ) {
                return 412;
            }
        } elseif ( $request->hasHeader( 'If-Unmodified-Since' ) ) {
            $requestDate = HttpDate::parse( $request->getHeader( 'If-Unmodified-Since' )[0] );
            $lastModified = $this->getLastModified();
            if ( $requestDate !== null
                && ( $lastModified === null || $lastModified > $requestDate )
            ) {
                return 412;
            }
        }
        if ( $request->hasHeader( 'If-None-Match' ) ) {
            $inm = $request->getHeader( 'If-None-Match' );
            foreach ( $this->eTagParser->parseHeaderList( $inm ) as $tag ) {
                if ( ( $tag['whole'] === '*' && $this->hasRepresentation() ) ||
                    $this->weakCompare( $this->getETagParts(), $tag )
                ) {
                    return $getOrHead ? 304 : 412;
                }
            }
        } elseif ( $getOrHead && $request->hasHeader( 'If-Modified-Since' ) ) {
            $requestDate = HttpDate::parse( $request->getHeader( 'If-Modified-Since' )[0] );
            $lastModified = $this->getLastModified();
            if ( $requestDate !== null && $lastModified !== null
                && $lastModified <= $requestDate
            ) {
                return 304;
            }
        }
        // RFC 7232 states that If-Range should be evaluated here. However, the
        // purpose of If-Range is to cause the Range request header to be
        // conditionally ignored, not to immediately send a response, so it
        // doesn't fit here. RFC 7232 only requires that If-Range be checked
        // after the other conditional header fields, a requirement that is
        // satisfied if it is processed in Handler::execute().
        return null;
    }
 
    public function applyResponseHeaders( ResponseInterface $response ) {
        if ( $response->getStatusCode() >= 400
            || $response->getStatusCode() === 301
            || $response->getStatusCode() === 307
        ) {
            // Don't add Last-Modified and ETag for errors, including 412.
            // Note that 304 responses are required to have these headers set.
            // See IETF RFC 7232 section 4.
            return;
        }
 
        $lastModified = $this->getLastModified();
        if ( $lastModified !== null && !$response->hasHeader( 'Last-Modified' ) ) {
            $response->setHeader( 'Last-Modified', HttpDate::format( $lastModified ) );
        }
 
        $eTag = $this->getETag();
        if ( $eTag !== null && !$response->hasHeader( 'ETag' ) ) {
            $response->setHeader( 'ETag', $eTag );
        }
    }
 
    private function weakCompare( $resourceETag, $headerETag ) {
        if ( $resourceETag === null || $headerETag === null ) {
            return false;
        }
        return $resourceETag['contents'] === $headerETag['contents'];
    }
 
    private function strongCompare( $resourceETag, $headerETag ) {
        if ( $resourceETag === null || $headerETag === null ) {
            return false;
        }
 
        return !$resourceETag['weak']
            && ( $this->varnishETagHack || !$headerETag['weak'] )
            && $resourceETag['contents'] === $headerETag['contents'];
    }
 
}