authorizer / vendor / google-api-php-client / src / Google / Http / CacheParser.php

CacheParser.php in Authorizer 2.8.4, at vendor/google-api-php-client/src/Google/Http/CacheParser.php

186 lines 6.0 KB

Raw Download Zip

1	<?php
2	/*
3	* Copyright 2012 Google Inc.
4	*
5	* Licensed under the Apache License, Version 2.0 (the "License");
6	* you may not use this file except in compliance with the License.
7	* You may obtain a copy of the License at
8	*
9	* http://www.apache.org/licenses/LICENSE-2.0
10	*
11	* Unless required by applicable law or agreed to in writing, software
12	* distributed under the License is distributed on an "AS IS" BASIS,
13	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14	* See the License for the specific language governing permissions and
15	* limitations under the License.
16	*/
17
18	if (!class_exists('Google_Client')) {
19	require_once dirname(__FILE__) . '/../autoload.php';
20	}
21
22	/**
23	* Implement the caching directives specified in rfc2616. This
24	* implementation is guided by the guidance offered in rfc2616-sec13.
25	*/
26	class Google_Http_CacheParser
27	{
28	public static $CACHEABLE_HTTP_METHODS = array('GET', 'HEAD');
29	public static $CACHEABLE_STATUS_CODES = array('200', '203', '300', '301');
30
31	/**
32	* Check if an HTTP request can be cached by a private local cache.
33	*
34	* @static
35	* @param Google_Http_Request $resp
36	* @return bool True if the request is cacheable.
37	* False if the request is uncacheable.
38	*/
39	public static function isRequestCacheable(Google_Http_Request $resp)
40	{
41	$method = $resp->getRequestMethod();
42	if (! in_array($method, self::$CACHEABLE_HTTP_METHODS)) {
43	return false;
44	}
45
46	// Don't cache authorized requests/responses.
47	// [rfc2616-14.8] When a shared cache receives a request containing an
48	// Authorization field, it MUST NOT return the corresponding response
49	// as a reply to any other request...
50	if ($resp->getRequestHeader("authorization")) {
51	return false;
52	}
53
54	return true;
55	}
56
57	/**
58	* Check if an HTTP response can be cached by a private local cache.
59	*
60	* @static
61	* @param Google_Http_Request $resp
62	* @return bool True if the response is cacheable.
63	* False if the response is un-cacheable.
64	*/
65	public static function isResponseCacheable(Google_Http_Request $resp)
66	{
67	// First, check if the HTTP request was cacheable before inspecting the
68	// HTTP response.
69	if (false == self::isRequestCacheable($resp)) {
70	return false;
71	}
72
73	$code = $resp->getResponseHttpCode();
74	if (! in_array($code, self::$CACHEABLE_STATUS_CODES)) {
75	return false;
76	}
77
78	// The resource is uncacheable if the resource is already expired and
79	// the resource doesn't have an ETag for revalidation.
80	$etag = $resp->getResponseHeader("etag");
81	if (self::isExpired($resp) && $etag == false) {
82	return false;
83	}
84
85	// [rfc2616-14.9.2] If [no-store is] sent in a response, a cache MUST NOT
86	// store any part of either this response or the request that elicited it.
87	$cacheControl = $resp->getParsedCacheControl();
88	if (isset($cacheControl['no-store'])) {
89	return false;
90	}
91
92	// Pragma: no-cache is an http request directive, but is occasionally
93	// used as a response header incorrectly.
94	$pragma = $resp->getResponseHeader('pragma');
95	if ($pragma == 'no-cache' \|\| strpos($pragma, 'no-cache') !== false) {
96	return false;
97	}
98
99	// [rfc2616-14.44] Vary: * is extremely difficult to cache. "It implies that
100	// a cache cannot determine from the request headers of a subsequent request
101	// whether this response is the appropriate representation."
102	// Given this, we deem responses with the Vary header as uncacheable.
103	$vary = $resp->getResponseHeader('vary');
104	if ($vary) {
105	return false;
106	}
107
108	return true;
109	}
110
111	/**
112	* @static
113	* @param Google_Http_Request $resp
114	* @return bool True if the HTTP response is considered to be expired.
115	* False if it is considered to be fresh.
116	*/
117	public static function isExpired(Google_Http_Request $resp)
118	{
119	// HTTP/1.1 clients and caches MUST treat other invalid date formats,
120	// especially including the value “0”, as in the past.
121	$parsedExpires = false;
122	$responseHeaders = $resp->getResponseHeaders();
123
124	if (isset($responseHeaders['expires'])) {
125	$rawExpires = $responseHeaders['expires'];
126	// Check for a malformed expires header first.
127	if (empty($rawExpires) \|\| (is_numeric($rawExpires) && $rawExpires <= 0)) {
128	return true;
129	}
130
131	// See if we can parse the expires header.
132	$parsedExpires = strtotime($rawExpires);
133	if (false == $parsedExpires \|\| $parsedExpires <= 0) {
134	return true;
135	}
136	}
137
138	// Calculate the freshness of an http response.
139	$freshnessLifetime = false;
140	$cacheControl = $resp->getParsedCacheControl();
141	if (isset($cacheControl['max-age'])) {
142	$freshnessLifetime = $cacheControl['max-age'];
143	}
144
145	$rawDate = $resp->getResponseHeader('date');
146	$parsedDate = strtotime($rawDate);
147
148	if (empty($rawDate) \|\| false == $parsedDate) {
149	// We can't default this to now, as that means future cache reads
150	// will always pass with the logic below, so we will require a
151	// date be injected if not supplied.
152	throw new Google_Exception("All cacheable requests must have creation dates.");
153	}
154
155	if (false == $freshnessLifetime && isset($responseHeaders['expires'])) {
156	$freshnessLifetime = $parsedExpires - $parsedDate;
157	}
158
159	if (false == $freshnessLifetime) {
160	return true;
161	}
162
163	// Calculate the age of an http response.
164	$age = max(0, time() - $parsedDate);
165	if (isset($responseHeaders['age'])) {
166	$age = max($age, strtotime($responseHeaders['age']));
167	}
168
169	return $freshnessLifetime <= $age;
170	}
171
172	/**
173	* Determine if a cache entry should be revalidated with by the origin.
174	*
175	* @param Google_Http_Request $response
176	* @return bool True if the entry is expired, else return false.
177	*/
178	public static function mustRevalidate(Google_Http_Request $response)
179	{
180	// [13.3] When a cache has a stale entry that it would like to use as a
181	// response to a client's request, it first has to check with the origin
182	// server to see if its cached entry is still usable.
183	return self::isExpired($response);
184	}
185	}
186