chamilo / chamilo-lms

plugin/buycourses/src/Requests/IDNAEncoder.php

Indentation +300 added lines, -300 removed lines

@@ -11,378 +11,378 @@
  * @see https://tools.ietf.org/html/rfc3492 Punycode/Bootstrap specification
  */
 class Requests_IDNAEncoder {
-	/**
-	 * ACE prefix used for IDNA
-	 *
-	 * @see https://tools.ietf.org/html/rfc3490#section-5
-	 * @var string
-	 */
-	const ACE_PREFIX = 'xn--';
+    /**
+     * ACE prefix used for IDNA
+     *
+     * @see https://tools.ietf.org/html/rfc3490#section-5
+     * @var string
+     */
+    const ACE_PREFIX = 'xn--';
 
-	/**#@+
+    /**#@+
 	 * Bootstrap constant for Punycode
 	 *
 	 * @see https://tools.ietf.org/html/rfc3492#section-5
 	 * @var int
 	 */
-	const BOOTSTRAP_BASE         = 36;
-	const BOOTSTRAP_TMIN         = 1;
-	const BOOTSTRAP_TMAX         = 26;
-	const BOOTSTRAP_SKEW         = 38;
-	const BOOTSTRAP_DAMP         = 700;
-	const BOOTSTRAP_INITIAL_BIAS = 72;
-	const BOOTSTRAP_INITIAL_N    = 128;
-	/**#@-*/
+    const BOOTSTRAP_BASE         = 36;
+    const BOOTSTRAP_TMIN         = 1;
+    const BOOTSTRAP_TMAX         = 26;
+    const BOOTSTRAP_SKEW         = 38;
+    const BOOTSTRAP_DAMP         = 700;
+    const BOOTSTRAP_INITIAL_BIAS = 72;
+    const BOOTSTRAP_INITIAL_N    = 128;
+    /**#@-*/
 
-	/**
-	 * Encode a hostname using Punycode
-	 *
-	 * @param string $string Hostname
-	 * @return string Punycode-encoded hostname
-	 */
-	public static function encode($string) {
-		$parts = explode('.', $string);
-		foreach ($parts as &$part) {
-			$part = self::to_ascii($part);
-		}
-		return implode('.', $parts);
-	}
+    /**
+     * Encode a hostname using Punycode
+     *
+     * @param string $string Hostname
+     * @return string Punycode-encoded hostname
+     */
+    public static function encode($string) {
+        $parts = explode('.', $string);
+        foreach ($parts as &$part) {
+            $part = self::to_ascii($part);
+        }
+        return implode('.', $parts);
+    }
 
-	/**
-	 * Convert a UTF-8 string to an ASCII string using Punycode
-	 *
-	 * @throws Requests_Exception Provided string longer than 64 ASCII characters (`idna.provided_too_long`)
-	 * @throws Requests_Exception Prepared string longer than 64 ASCII characters (`idna.prepared_too_long`)
-	 * @throws Requests_Exception Provided string already begins with xn-- (`idna.provided_is_prefixed`)
-	 * @throws Requests_Exception Encoded string longer than 64 ASCII characters (`idna.encoded_too_long`)
-	 *
-	 * @param string $string ASCII or UTF-8 string (max length 64 characters)
-	 * @return string ASCII string
-	 */
-	public static function to_ascii($string) {
-		// Step 1: Check if the string is already ASCII
-		if (self::is_ascii($string)) {
-			// Skip to step 7
-			if (strlen($string) < 64) {
-				return $string;
-			}
+    /**
+     * Convert a UTF-8 string to an ASCII string using Punycode
+     *
+     * @throws Requests_Exception Provided string longer than 64 ASCII characters (`idna.provided_too_long`)
+     * @throws Requests_Exception Prepared string longer than 64 ASCII characters (`idna.prepared_too_long`)
+     * @throws Requests_Exception Provided string already begins with xn-- (`idna.provided_is_prefixed`)
+     * @throws Requests_Exception Encoded string longer than 64 ASCII characters (`idna.encoded_too_long`)
+     *
+     * @param string $string ASCII or UTF-8 string (max length 64 characters)
+     * @return string ASCII string
+     */
+    public static function to_ascii($string) {
+        // Step 1: Check if the string is already ASCII
+        if (self::is_ascii($string)) {
+            // Skip to step 7
+            if (strlen($string) < 64) {
+                return $string;
+            }
 
-			throw new Requests_Exception('Provided string is too long', 'idna.provided_too_long', $string);
-		}
+            throw new Requests_Exception('Provided string is too long', 'idna.provided_too_long', $string);
+        }
 
-		// Step 2: nameprep
-		$string = self::nameprep($string);
+        // Step 2: nameprep
+        $string = self::nameprep($string);
 
-		// Step 3: UseSTD3ASCIIRules is false, continue
-		// Step 4: Check if it's ASCII now
-		if (self::is_ascii($string)) {
-			// Skip to step 7
-			if (strlen($string) < 64) {
-				return $string;
-			}
+        // Step 3: UseSTD3ASCIIRules is false, continue
+        // Step 4: Check if it's ASCII now
+        if (self::is_ascii($string)) {
+            // Skip to step 7
+            if (strlen($string) < 64) {
+                return $string;
+            }
 
-			throw new Requests_Exception('Prepared string is too long', 'idna.prepared_too_long', $string);
-		}
+            throw new Requests_Exception('Prepared string is too long', 'idna.prepared_too_long', $string);
+        }
 
-		// Step 5: Check ACE prefix
-		if (strpos($string, self::ACE_PREFIX) === 0) {
-			throw new Requests_Exception('Provided string begins with ACE prefix', 'idna.provided_is_prefixed', $string);
-		}
+        // Step 5: Check ACE prefix
+        if (strpos($string, self::ACE_PREFIX) === 0) {
+            throw new Requests_Exception('Provided string begins with ACE prefix', 'idna.provided_is_prefixed', $string);
+        }
 
-		// Step 6: Encode with Punycode
-		$string = self::punycode_encode($string);
+        // Step 6: Encode with Punycode
+        $string = self::punycode_encode($string);
 
-		// Step 7: Prepend ACE prefix
-		$string = self::ACE_PREFIX . $string;
+        // Step 7: Prepend ACE prefix
+        $string = self::ACE_PREFIX . $string;
 
-		// Step 8: Check size
-		if (strlen($string) < 64) {
-			return $string;
-		}
+        // Step 8: Check size
+        if (strlen($string) < 64) {
+            return $string;
+        }
 
-		throw new Requests_Exception('Encoded string is too long', 'idna.encoded_too_long', $string);
-	}
+        throw new Requests_Exception('Encoded string is too long', 'idna.encoded_too_long', $string);
+    }
 
-	/**
-	 * Check whether a given string contains only ASCII characters
-	 *
-	 * @internal (Testing found regex was the fastest implementation)
-	 *
-	 * @param string $string
-	 * @return bool Is the string ASCII-only?
-	 */
-	protected static function is_ascii($string) {
-		return (preg_match('/(?:[^\x00-\x7F])/', $string) !== 1);
-	}
+    /**
+     * Check whether a given string contains only ASCII characters
+     *
+     * @internal (Testing found regex was the fastest implementation)
+     *
+     * @param string $string
+     * @return bool Is the string ASCII-only?
+     */
+    protected static function is_ascii($string) {
+        return (preg_match('/(?:[^\x00-\x7F])/', $string) !== 1);
+    }
 
-	/**
-	 * Prepare a string for use as an IDNA name
-	 *
-	 * @todo Implement this based on RFC 3491 and the newer 5891
-	 * @param string $string
-	 * @return string Prepared string
-	 */
-	protected static function nameprep($string) {
-		return $string;
-	}
+    /**
+     * Prepare a string for use as an IDNA name
+     *
+     * @todo Implement this based on RFC 3491 and the newer 5891
+     * @param string $string
+     * @return string Prepared string
+     */
+    protected static function nameprep($string) {
+        return $string;
+    }
 
-	/**
-	 * Convert a UTF-8 string to a UCS-4 codepoint array
-	 *
-	 * Based on Requests_IRI::replace_invalid_with_pct_encoding()
-	 *
-	 * @throws Requests_Exception Invalid UTF-8 codepoint (`idna.invalidcodepoint`)
-	 * @param string $input
-	 * @return array Unicode code points
-	 */
-	protected static function utf8_to_codepoints($input) {
-		$codepoints = array();
+    /**
+     * Convert a UTF-8 string to a UCS-4 codepoint array
+     *
+     * Based on Requests_IRI::replace_invalid_with_pct_encoding()
+     *
+     * @throws Requests_Exception Invalid UTF-8 codepoint (`idna.invalidcodepoint`)
+     * @param string $input
+     * @return array Unicode code points
+     */
+    protected static function utf8_to_codepoints($input) {
+        $codepoints = array();
 
-		// Get number of bytes
-		$strlen = strlen($input);
+        // Get number of bytes
+        $strlen = strlen($input);
 
-		for ($position = 0; $position < $strlen; $position++) {
-			$value = ord($input[$position]);
+        for ($position = 0; $position < $strlen; $position++) {
+            $value = ord($input[$position]);
 
-			// One byte sequence:
-			if ((~$value & 0x80) === 0x80) {
-				$character = $value;
-				$length = 1;
-				$remaining = 0;
-			}
-			// Two byte sequence:
-			elseif (($value & 0xE0) === 0xC0) {
-				$character = ($value & 0x1F) << 6;
-				$length = 2;
-				$remaining = 1;
-			}
-			// Three byte sequence:
-			elseif (($value & 0xF0) === 0xE0) {
-				$character = ($value & 0x0F) << 12;
-				$length = 3;
-				$remaining = 2;
-			}
-			// Four byte sequence:
-			elseif (($value & 0xF8) === 0xF0) {
-				$character = ($value & 0x07) << 18;
-				$length = 4;
-				$remaining = 3;
-			}
-			// Invalid byte:
-			else {
-				throw new Requests_Exception('Invalid Unicode codepoint', 'idna.invalidcodepoint', $value);
-			}
+            // One byte sequence:
+            if ((~$value & 0x80) === 0x80) {
+                $character = $value;
+                $length = 1;
+                $remaining = 0;
+            }
+            // Two byte sequence:
+            elseif (($value & 0xE0) === 0xC0) {
+                $character = ($value & 0x1F) << 6;
+                $length = 2;
+                $remaining = 1;
+            }
+            // Three byte sequence:
+            elseif (($value & 0xF0) === 0xE0) {
+                $character = ($value & 0x0F) << 12;
+                $length = 3;
+                $remaining = 2;
+            }
+            // Four byte sequence:
+            elseif (($value & 0xF8) === 0xF0) {
+                $character = ($value & 0x07) << 18;
+                $length = 4;
+                $remaining = 3;
+            }
+            // Invalid byte:
+            else {
+                throw new Requests_Exception('Invalid Unicode codepoint', 'idna.invalidcodepoint', $value);
+            }
 
-			if ($remaining > 0) {
-				if ($position + $length > $strlen) {
-					throw new Requests_Exception('Invalid Unicode codepoint', 'idna.invalidcodepoint', $character);
-				}
-				for ($position++; $remaining > 0; $position++) {
-					$value = ord($input[$position]);
+            if ($remaining > 0) {
+                if ($position + $length > $strlen) {
+                    throw new Requests_Exception('Invalid Unicode codepoint', 'idna.invalidcodepoint', $character);
+                }
+                for ($position++; $remaining > 0; $position++) {
+                    $value = ord($input[$position]);
 
-					// If it is invalid, count the sequence as invalid and reprocess the current byte:
-					if (($value & 0xC0) !== 0x80) {
-						throw new Requests_Exception('Invalid Unicode codepoint', 'idna.invalidcodepoint', $character);
-					}
+                    // If it is invalid, count the sequence as invalid and reprocess the current byte:
+                    if (($value & 0xC0) !== 0x80) {
+                        throw new Requests_Exception('Invalid Unicode codepoint', 'idna.invalidcodepoint', $character);
+                    }
 
-					$character |= ($value & 0x3F) << (--$remaining * 6);
-				}
-				$position--;
-			}
+                    $character |= ($value & 0x3F) << (--$remaining * 6);
+                }
+                $position--;
+            }
 
-			if (
-				// Non-shortest form sequences are invalid
-				   $length > 1 && $character <= 0x7F
-				|| $length > 2 && $character <= 0x7FF
-				|| $length > 3 && $character <= 0xFFFF
-				// Outside of range of ucschar codepoints
-				// Noncharacters
-				|| ($character & 0xFFFE) === 0xFFFE
-				|| $character >= 0xFDD0 && $character <= 0xFDEF
-				|| (
-					// Everything else not in ucschar
-					   $character > 0xD7FF && $character < 0xF900
-					|| $character < 0x20
-					|| $character > 0x7E && $character < 0xA0
-					|| $character > 0xEFFFD
-				)
-			) {
-				throw new Requests_Exception('Invalid Unicode codepoint', 'idna.invalidcodepoint', $character);
-			}
+            if (
+                // Non-shortest form sequences are invalid
+                    $length > 1 && $character <= 0x7F
+                || $length > 2 && $character <= 0x7FF
+                || $length > 3 && $character <= 0xFFFF
+                // Outside of range of ucschar codepoints
+                // Noncharacters
+                || ($character & 0xFFFE) === 0xFFFE
+                || $character >= 0xFDD0 && $character <= 0xFDEF
+                || (
+                    // Everything else not in ucschar
+                        $character > 0xD7FF && $character < 0xF900
+                    || $character < 0x20
+                    || $character > 0x7E && $character < 0xA0
+                    || $character > 0xEFFFD
+                )
+            ) {
+                throw new Requests_Exception('Invalid Unicode codepoint', 'idna.invalidcodepoint', $character);
+            }
 
-			$codepoints[] = $character;
-		}
+            $codepoints[] = $character;
+        }
 
-		return $codepoints;
-	}
+        return $codepoints;
+    }
 
-	/**
-	 * RFC3492-compliant encoder
-	 *
-	 * @internal Pseudo-code from Section 6.3 is commented with "#" next to relevant code
-	 * @throws Requests_Exception On character outside of the domain (never happens with Punycode) (`idna.character_outside_domain`)
-	 *
-	 * @param string $input UTF-8 encoded string to encode
-	 * @return string Punycode-encoded string
-	 */
-	public static function punycode_encode($input) {
-		$output = '';
+    /**
+     * RFC3492-compliant encoder
+     *
+     * @internal Pseudo-code from Section 6.3 is commented with "#" next to relevant code
+     * @throws Requests_Exception On character outside of the domain (never happens with Punycode) (`idna.character_outside_domain`)
+     *
+     * @param string $input UTF-8 encoded string to encode
+     * @return string Punycode-encoded string
+     */
+    public static function punycode_encode($input) {
+        $output = '';
 #		let n = initial_n
-		$n = self::BOOTSTRAP_INITIAL_N;
+        $n = self::BOOTSTRAP_INITIAL_N;
 #		let delta = 0
-		$delta = 0;
+        $delta = 0;
 #		let bias = initial_bias
-		$bias = self::BOOTSTRAP_INITIAL_BIAS;
+        $bias = self::BOOTSTRAP_INITIAL_BIAS;
 #		let h = b = the number of basic code points in the input
-		$h = $b = 0; // see loop
+        $h = $b = 0; // see loop
 #		copy them to the output in order
-		$codepoints = self::utf8_to_codepoints($input);
-		$extended = array();
+        $codepoints = self::utf8_to_codepoints($input);
+        $extended = array();
 
-		foreach ($codepoints as $char) {
-			if ($char < 128) {
-				// Character is valid ASCII
-				// TODO: this should also check if it's valid for a URL
-				$output .= chr($char);
-				$h++;
-			}
-			// Check if the character is non-ASCII, but below initial n
-			// This never occurs for Punycode, so ignore in coverage
-			// @codeCoverageIgnoreStart
-			elseif ($char < $n) {
-				throw new Requests_Exception('Invalid character', 'idna.character_outside_domain', $char);
-			}
-			// @codeCoverageIgnoreEnd
-			else {
-				$extended[$char] = true;
-			}
-		}
-		$extended = array_keys($extended);
-		sort($extended);
-		$b = $h;
+        foreach ($codepoints as $char) {
+            if ($char < 128) {
+                // Character is valid ASCII
+                // TODO: this should also check if it's valid for a URL
+                $output .= chr($char);
+                $h++;
+            }
+            // Check if the character is non-ASCII, but below initial n
+            // This never occurs for Punycode, so ignore in coverage
+            // @codeCoverageIgnoreStart
+            elseif ($char < $n) {
+                throw new Requests_Exception('Invalid character', 'idna.character_outside_domain', $char);
+            }
+            // @codeCoverageIgnoreEnd
+            else {
+                $extended[$char] = true;
+            }
+        }
+        $extended = array_keys($extended);
+        sort($extended);
+        $b = $h;
 #		[copy them] followed by a delimiter if b > 0
-		if (strlen($output) > 0) {
-			$output .= '-';
-		}
+        if (strlen($output) > 0) {
+            $output .= '-';
+        }
 #		{if the input contains a non-basic code point < n then fail}
 #		while h < length(input) do begin
-		while ($h < count($codepoints)) {
+        while ($h < count($codepoints)) {
 #			let m = the minimum code point >= n in the input
-			$m = array_shift($extended);
-			//printf('next code point to insert is %s' . PHP_EOL, dechex($m));
+            $m = array_shift($extended);
+            //printf('next code point to insert is %s' . PHP_EOL, dechex($m));
 #			let delta = delta + (m - n) * (h + 1), fail on overflow
-			$delta += ($m - $n) * ($h + 1);
+            $delta += ($m - $n) * ($h + 1);
 #			let n = m
-			$n = $m;
+            $n = $m;
 #			for each code point c in the input (in order) do begin
-			for ($num = 0; $num < count($codepoints); $num++) {
-				$c = $codepoints[$num];
+            for ($num = 0; $num < count($codepoints); $num++) {
+                $c = $codepoints[$num];
 #				if c < n then increment delta, fail on overflow
-				if ($c < $n) {
-					$delta++;
-				}
+                if ($c < $n) {
+                    $delta++;
+                }
 #				if c == n then begin
-				elseif ($c === $n) {
+                elseif ($c === $n) {
 #					let q = delta
-					$q = $delta;
+                    $q = $delta;
 #					for k = base to infinity in steps of base do begin
-					for ($k = self::BOOTSTRAP_BASE; ; $k += self::BOOTSTRAP_BASE) {
+                    for ($k = self::BOOTSTRAP_BASE; ; $k += self::BOOTSTRAP_BASE) {
 #						let t = tmin if k <= bias {+ tmin}, or
 #								tmax if k >= bias + tmax, or k - bias otherwise
-						if ($k <= ($bias + self::BOOTSTRAP_TMIN)) {
-							$t = self::BOOTSTRAP_TMIN;
-						}
-						elseif ($k >= ($bias + self::BOOTSTRAP_TMAX)) {
-							$t = self::BOOTSTRAP_TMAX;
-						}
-						else {
-							$t = $k - $bias;
-						}
+                        if ($k <= ($bias + self::BOOTSTRAP_TMIN)) {
+                            $t = self::BOOTSTRAP_TMIN;
+                        }
+                        elseif ($k >= ($bias + self::BOOTSTRAP_TMAX)) {
+                            $t = self::BOOTSTRAP_TMAX;
+                        }
+                        else {
+                            $t = $k - $bias;
+                        }
 #						if q < t then break
-						if ($q < $t) {
-							break;
-						}
+                        if ($q < $t) {
+                            break;
+                        }
 #						output the code point for digit t + ((q - t) mod (base - t))
-						$digit = $t + (($q - $t) % (self::BOOTSTRAP_BASE - $t));
-						$output .= self::digit_to_char($digit);
+                        $digit = $t + (($q - $t) % (self::BOOTSTRAP_BASE - $t));
+                        $output .= self::digit_to_char($digit);
 #						let q = (q - t) div (base - t)
-						$q = floor(($q - $t) / (self::BOOTSTRAP_BASE - $t));
+                        $q = floor(($q - $t) / (self::BOOTSTRAP_BASE - $t));
 #					end
-					}
+                    }
 #					output the code point for digit q
-					$output .= self::digit_to_char($q);
+                    $output .= self::digit_to_char($q);
 #					let bias = adapt(delta, h + 1, test h equals b?)
-					$bias = self::adapt($delta, $h + 1, $h === $b);
+                    $bias = self::adapt($delta, $h + 1, $h === $b);
 #					let delta = 0
-					$delta = 0;
+                    $delta = 0;
 #					increment h
-					$h++;
+                    $h++;
 #				end
-				}
+                }
 #			end
-			}
+            }
 #			increment delta and n
-			$delta++;
-			$n++;
+            $delta++;
+            $n++;
 #		end
-		}
+        }
 
-		return $output;
-	}
+        return $output;
+    }
 
-	/**
-	 * Convert a digit to its respective character
-	 *
-	 * @see https://tools.ietf.org/html/rfc3492#section-5
-	 * @throws Requests_Exception On invalid digit (`idna.invalid_digit`)
-	 *
-	 * @param int $digit Digit in the range 0-35
-	 * @return string Single character corresponding to digit
-	 */
-	protected static function digit_to_char($digit) {
-		// @codeCoverageIgnoreStart
-		// As far as I know, this never happens, but still good to be sure.
-		if ($digit < 0 || $digit > 35) {
-			throw new Requests_Exception(sprintf('Invalid digit %d', $digit), 'idna.invalid_digit', $digit);
-		}
-		// @codeCoverageIgnoreEnd
-		$digits = 'abcdefghijklmnopqrstuvwxyz0123456789';
-		return substr($digits, $digit, 1);
-	}
+    /**
+     * Convert a digit to its respective character
+     *
+     * @see https://tools.ietf.org/html/rfc3492#section-5
+     * @throws Requests_Exception On invalid digit (`idna.invalid_digit`)
+     *
+     * @param int $digit Digit in the range 0-35
+     * @return string Single character corresponding to digit
+     */
+    protected static function digit_to_char($digit) {
+        // @codeCoverageIgnoreStart
+        // As far as I know, this never happens, but still good to be sure.
+        if ($digit < 0 || $digit > 35) {
+            throw new Requests_Exception(sprintf('Invalid digit %d', $digit), 'idna.invalid_digit', $digit);
+        }
+        // @codeCoverageIgnoreEnd
+        $digits = 'abcdefghijklmnopqrstuvwxyz0123456789';
+        return substr($digits, $digit, 1);
+    }
 
-	/**
-	 * Adapt the bias
-	 *
-	 * @see https://tools.ietf.org/html/rfc3492#section-6.1
-	 * @param int $delta
-	 * @param int $numpoints
-	 * @param bool $firsttime
-	 * @return int New bias
-	 */
-	protected static function adapt($delta, $numpoints, $firsttime) {
+    /**
+     * Adapt the bias
+     *
+     * @see https://tools.ietf.org/html/rfc3492#section-6.1
+     * @param int $delta
+     * @param int $numpoints
+     * @param bool $firsttime
+     * @return int New bias
+     */
+    protected static function adapt($delta, $numpoints, $firsttime) {
 #	function adapt(delta,numpoints,firsttime):
 #		if firsttime then let delta = delta div damp
-		if ($firsttime) {
-			$delta = floor($delta / self::BOOTSTRAP_DAMP);
-		}
+        if ($firsttime) {
+            $delta = floor($delta / self::BOOTSTRAP_DAMP);
+        }
 #		else let delta = delta div 2
-		else {
-			$delta = floor($delta / 2);
-		}
+        else {
+            $delta = floor($delta / 2);
+        }
 #		let delta = delta + (delta div numpoints)
-		$delta += floor($delta / $numpoints);
+        $delta += floor($delta / $numpoints);
 #		let k = 0
-		$k = 0;
+        $k = 0;
 #		while delta > ((base - tmin) * tmax) div 2 do begin
-		$max = floor(((self::BOOTSTRAP_BASE - self::BOOTSTRAP_TMIN) * self::BOOTSTRAP_TMAX) / 2);
-		while ($delta > $max) {
+        $max = floor(((self::BOOTSTRAP_BASE - self::BOOTSTRAP_TMIN) * self::BOOTSTRAP_TMAX) / 2);
+        while ($delta > $max) {
 #			let delta = delta div (base - tmin)
-			$delta = floor($delta / (self::BOOTSTRAP_BASE - self::BOOTSTRAP_TMIN));
+            $delta = floor($delta / (self::BOOTSTRAP_BASE - self::BOOTSTRAP_TMIN));
 #			let k = k + base
-			$k += self::BOOTSTRAP_BASE;
+            $k += self::BOOTSTRAP_BASE;
 #		end
-		}
+        }
 #		return k + (((base - tmin + 1) * delta) div (delta + skew))
-		return $k + floor(((self::BOOTSTRAP_BASE - self::BOOTSTRAP_TMIN + 1) * $delta) / ($delta + self::BOOTSTRAP_SKEW));
-	}
+        return $k + floor(((self::BOOTSTRAP_BASE - self::BOOTSTRAP_TMIN + 1) * $delta) / ($delta + self::BOOTSTRAP_SKEW));
+    }
 }
\ No newline at end of file

plugin/buycourses/src/Requests/Auth.php

Indentation +11 added lines, -11 removed lines

@@ -19,15 +19,15 @@
  * @subpackage Authentication
  */
 interface Requests_Auth {
-	/**
-	 * Register hooks as needed
-	 *
-	 * This method is called in {@see Requests::request} when the user has set
-	 * an instance as the 'auth' option. Use this callback to register all the
-	 * hooks you'll need.
-	 *
-	 * @see Requests_Hooks::register
-	 * @param Requests_Hooks $hooks Hook system
-	 */
-	public function register(Requests_Hooks &$hooks);
+    /**
+     * Register hooks as needed
+     *
+     * This method is called in {@see Requests::request} when the user has set
+     * an instance as the 'auth' option. Use this callback to register all the
+     * hooks you'll need.
+     *
+     * @see Requests_Hooks::register
+     * @param Requests_Hooks $hooks Hook system
+     */
+    public function register(Requests_Hooks &$hooks);
 }
\ No newline at end of file

plugin/buycourses/src/Requests/Response.php

Indentation +93 added lines, -93 removed lines

@@ -13,109 +13,109 @@
  * @package Requests
  */
 class Requests_Response {
-	/**
-	 * Constructor
-	 */
-	public function __construct() {
-		$this->headers = new Requests_Response_Headers();
-		$this->cookies = new Requests_Cookie_Jar();
-	}
+    /**
+     * Constructor
+     */
+    public function __construct() {
+        $this->headers = new Requests_Response_Headers();
+        $this->cookies = new Requests_Cookie_Jar();
+    }
 
-	/**
-	 * Response body
-	 *
-	 * @var string
-	 */
-	public $body = '';
+    /**
+     * Response body
+     *
+     * @var string
+     */
+    public $body = '';
 
-	/**
-	 * Raw HTTP data from the transport
-	 *
-	 * @var string
-	 */
-	public $raw = '';
+    /**
+     * Raw HTTP data from the transport
+     *
+     * @var string
+     */
+    public $raw = '';
 
-	/**
-	 * Headers, as an associative array
-	 *
-	 * @var Requests_Response_Headers Array-like object representing headers
-	 */
-	public $headers = array();
+    /**
+     * Headers, as an associative array
+     *
+     * @var Requests_Response_Headers Array-like object representing headers
+     */
+    public $headers = array();
 
-	/**
-	 * Status code, false if non-blocking
-	 *
-	 * @var integer|boolean
-	 */
-	public $status_code = false;
+    /**
+     * Status code, false if non-blocking
+     *
+     * @var integer|boolean
+     */
+    public $status_code = false;
 
-	/**
-	 * Protocol version, false if non-blocking
-	 * @var float|boolean
-	 */
-	public $protocol_version = false;
+    /**
+     * Protocol version, false if non-blocking
+     * @var float|boolean
+     */
+    public $protocol_version = false;
 
-	/**
-	 * Whether the request succeeded or not
-	 *
-	 * @var boolean
-	 */
-	public $success = false;
+    /**
+     * Whether the request succeeded or not
+     *
+     * @var boolean
+     */
+    public $success = false;
 
-	/**
-	 * Number of redirects the request used
-	 *
-	 * @var integer
-	 */
-	public $redirects = 0;
+    /**
+     * Number of redirects the request used
+     *
+     * @var integer
+     */
+    public $redirects = 0;
 
-	/**
-	 * URL requested
-	 *
-	 * @var string
-	 */
-	public $url = '';
+    /**
+     * URL requested
+     *
+     * @var string
+     */
+    public $url = '';
 
-	/**
-	 * Previous requests (from redirects)
-	 *
-	 * @var array Array of Requests_Response objects
-	 */
-	public $history = array();
+    /**
+     * Previous requests (from redirects)
+     *
+     * @var array Array of Requests_Response objects
+     */
+    public $history = array();
 
-	/**
-	 * Cookies from the request
-	 *
-	 * @var Requests_Cookie_Jar Array-like object representing a cookie jar
-	 */
-	public $cookies = array();
+    /**
+     * Cookies from the request
+     *
+     * @var Requests_Cookie_Jar Array-like object representing a cookie jar
+     */
+    public $cookies = array();
 
-	/**
-	 * Is the response a redirect?
-	 *
-	 * @return boolean True if redirect (3xx status), false if not.
-	 */
-	public function is_redirect() {
-		$code = $this->status_code;
-		return in_array($code, array(300, 301, 302, 303, 307)) || $code > 307 && $code < 400;
-	}
+    /**
+     * Is the response a redirect?
+     *
+     * @return boolean True if redirect (3xx status), false if not.
+     */
+    public function is_redirect() {
+        $code = $this->status_code;
+        return in_array($code, array(300, 301, 302, 303, 307)) || $code > 307 && $code < 400;
+    }
 
-	/**
-	 * Throws an exception if the request was not successful
-	 *
-	 * @throws Requests_Exception If `$allow_redirects` is false, and code is 3xx (`response.no_redirects`)
-	 * @throws Requests_Exception_HTTP On non-successful status code. Exception class corresponds to code (e.g. {@see Requests_Exception_HTTP_404})
-	 * @param boolean $allow_redirects Set to false to throw on a 3xx as well
-	 */
-	public function throw_for_status($allow_redirects = true) {
-		if ($this->is_redirect()) {
-			if (!$allow_redirects) {
-				throw new Requests_Exception('Redirection not allowed', 'response.no_redirects', $this);
-			}
-		}
-		elseif (!$this->success) {
-			$exception = Requests_Exception_HTTP::get_class($this->status_code);
-			throw new $exception(null, $this);
-		}
-	}
+    /**
+     * Throws an exception if the request was not successful
+     *
+     * @throws Requests_Exception If `$allow_redirects` is false, and code is 3xx (`response.no_redirects`)
+     * @throws Requests_Exception_HTTP On non-successful status code. Exception class corresponds to code (e.g. {@see Requests_Exception_HTTP_404})
+     * @param boolean $allow_redirects Set to false to throw on a 3xx as well
+     */
+    public function throw_for_status($allow_redirects = true) {
+        if ($this->is_redirect()) {
+            if (!$allow_redirects) {
+                throw new Requests_Exception('Redirection not allowed', 'response.no_redirects', $this);
+            }
+        }
+        elseif (!$this->success) {
+            $exception = Requests_Exception_HTTP::get_class($this->status_code);
+            throw new $exception(null, $this);
+        }
+    }
 }

plugin/buycourses/src/Requests/Auth/Basic.php

Indentation +62 added lines, -62 removed lines

@@ -16,73 +16,73 @@
  * @subpackage Authentication
  */
 class Requests_Auth_Basic implements Requests_Auth {
-	/**
-	 * Username
-	 *
-	 * @var string
-	 */
-	public $user;
+    /**
+     * Username
+     *
+     * @var string
+     */
+    public $user;
 
-	/**
-	 * Password
-	 *
-	 * @var string
-	 */
-	public $pass;
+    /**
+     * Password
+     *
+     * @var string
+     */
+    public $pass;
 
-	/**
-	 * Constructor
-	 *
-	 * @throws Requests_Exception On incorrect number of arguments (`authbasicbadargs`)
-	 * @param array|null $args Array of user and password. Must have exactly two elements
-	 */
-	public function __construct($args = null) {
-		if (is_array($args)) {
-			if (count($args) !== 2) {
-				throw new Requests_Exception('Invalid number of arguments', 'authbasicbadargs');
-			}
+    /**
+     * Constructor
+     *
+     * @throws Requests_Exception On incorrect number of arguments (`authbasicbadargs`)
+     * @param array|null $args Array of user and password. Must have exactly two elements
+     */
+    public function __construct($args = null) {
+        if (is_array($args)) {
+            if (count($args) !== 2) {
+                throw new Requests_Exception('Invalid number of arguments', 'authbasicbadargs');
+            }
 
-			list($this->user, $this->pass) = $args;
-		}
-	}
+            list($this->user, $this->pass) = $args;
+        }
+    }
 
-	/**
-	 * Register the necessary callbacks
-	 *
-	 * @see curl_before_send
-	 * @see fsockopen_header
-	 * @param Requests_Hooks $hooks Hook system
-	 */
-	public function register(Requests_Hooks &$hooks) {
-		$hooks->register('curl.before_send', array(&$this, 'curl_before_send'));
-		$hooks->register('fsockopen.after_headers', array(&$this, 'fsockopen_header'));
-	}
+    /**
+     * Register the necessary callbacks
+     *
+     * @see curl_before_send
+     * @see fsockopen_header
+     * @param Requests_Hooks $hooks Hook system
+     */
+    public function register(Requests_Hooks &$hooks) {
+        $hooks->register('curl.before_send', array(&$this, 'curl_before_send'));
+        $hooks->register('fsockopen.after_headers', array(&$this, 'fsockopen_header'));
+    }
 
-	/**
-	 * Set cURL parameters before the data is sent
-	 *
-	 * @param resource $handle cURL resource
-	 */
-	public function curl_before_send(&$handle) {
-		curl_setopt($handle, CURLOPT_HTTPAUTH, CURLAUTH_BASIC);
-		curl_setopt($handle, CURLOPT_USERPWD, $this->getAuthString());
-	}
+    /**
+     * Set cURL parameters before the data is sent
+     *
+     * @param resource $handle cURL resource
+     */
+    public function curl_before_send(&$handle) {
+        curl_setopt($handle, CURLOPT_HTTPAUTH, CURLAUTH_BASIC);
+        curl_setopt($handle, CURLOPT_USERPWD, $this->getAuthString());
+    }
 
-	/**
-	 * Add extra headers to the request before sending
-	 *
-	 * @param string $out HTTP header string
-	 */
-	public function fsockopen_header(&$out) {
-		$out .= sprintf("Authorization: Basic %s\r\n", base64_encode($this->getAuthString()));
-	}
+    /**
+     * Add extra headers to the request before sending
+     *
+     * @param string $out HTTP header string
+     */
+    public function fsockopen_header(&$out) {
+        $out .= sprintf("Authorization: Basic %s\r\n", base64_encode($this->getAuthString()));
+    }
 
-	/**
-	 * Get the authentication string (user:pass)
-	 *
-	 * @return string
-	 */
-	public function getAuthString() {
-		return $this->user . ':' . $this->pass;
-	}
+    /**
+     * Get the authentication string (user:pass)
+     *
+     * @return string
+     */
+    public function getAuthString() {
+        return $this->user . ':' . $this->pass;
+    }
 }
\ No newline at end of file

plugin/buycourses/src/Requests/Cookie/Jar.php

Indentation +159 added lines, -159 removed lines

@@ -13,163 +13,163 @@
  * @subpackage Cookies
  */
 class Requests_Cookie_Jar implements ArrayAccess, IteratorAggregate {
-	/**
-	 * Actual item data
-	 *
-	 * @var array
-	 */
-	protected $cookies = array();
-
-	/**
-	 * Create a new jar
-	 *
-	 * @param array $cookies Existing cookie values
-	 */
-	public function __construct($cookies = array()) {
-		$this->cookies = $cookies;
-	}
-
-	/**
-	 * Normalise cookie data into a Requests_Cookie
-	 *
-	 * @param string|Requests_Cookie $cookie
-	 * @return Requests_Cookie
-	 */
-	public function normalize_cookie($cookie, $key = null) {
-		if ($cookie instanceof Requests_Cookie) {
-			return $cookie;
-		}
-
-		return Requests_Cookie::parse($cookie, $key);
-	}
-
-	/**
-	 * Normalise cookie data into a Requests_Cookie
-	 *
-	 * @codeCoverageIgnore
-	 * @deprecated Use {@see Requests_Cookie_Jar::normalize_cookie}
-	 * @return Requests_Cookie
-	 */
-	public function normalizeCookie($cookie, $key = null) {
-		return $this->normalize_cookie($cookie, $key);
-	}
-
-	/**
-	 * Check if the given item exists
-	 *
-	 * @param string $key Item key
-	 * @return boolean Does the item exist?
-	 */
-	public function offsetExists($key) {
-		return isset($this->cookies[$key]);
-	}
-
-	/**
-	 * Get the value for the item
-	 *
-	 * @param string $key Item key
-	 * @return string Item value
-	 */
-	public function offsetGet($key) {
-		if (!isset($this->cookies[$key])) {
-			return null;
-		}
-
-		return $this->cookies[$key];
-	}
-
-	/**
-	 * Set the given item
-	 *
-	 * @throws Requests_Exception On attempting to use dictionary as list (`invalidset`)
-	 *
-	 * @param string $key Item name
-	 * @param string $value Item value
-	 */
-	public function offsetSet($key, $value) {
-		if ($key === null) {
-			throw new Requests_Exception('Object is a dictionary, not a list', 'invalidset');
-		}
-
-		$this->cookies[$key] = $value;
-	}
-
-	/**
-	 * Unset the given header
-	 *
-	 * @param string $key
-	 */
-	public function offsetUnset($key) {
-		unset($this->cookies[$key]);
-	}
-
-	/**
-	 * Get an iterator for the data
-	 *
-	 * @return ArrayIterator
-	 */
-	public function getIterator() {
-		return new ArrayIterator($this->cookies);
-	}
-
-	/**
-	 * Register the cookie handler with the request's hooking system
-	 *
-	 * @param Requests_Hooker $hooks Hooking system
-	 */
-	public function register(Requests_Hooker $hooks) {
-		$hooks->register('requests.before_request', array($this, 'before_request'));
-		$hooks->register('requests.before_redirect_check', array($this, 'before_redirect_check'));
-	}
-
-	/**
-	 * Add Cookie header to a request if we have any
-	 *
-	 * As per RFC 6265, cookies are separated by '; '
-	 *
-	 * @param string $url
-	 * @param array $headers
-	 * @param array $data
-	 * @param string $type
-	 * @param array $options
-	 */
-	public function before_request($url, &$headers, &$data, &$type, &$options) {
-		if (!$url instanceof Requests_IRI) {
-			$url = new Requests_IRI($url);
-		}
-
-		if (!empty($this->cookies)) {
-			$cookies = array();
-			foreach ($this->cookies as $key => $cookie) {
-				$cookie = $this->normalize_cookie($cookie, $key);
-
-				// Skip expired cookies
-				if ($cookie->is_expired()) {
-					continue;
-				}
-
-				if ($cookie->domain_matches($url->host)) {
-					$cookies[] = $cookie->format_for_header();
-				}
-			}
-
-			$headers['Cookie'] = implode('; ', $cookies);
-		}
-	}
-
-	/**
-	 * Parse all cookies from a response and attach them to the response
-	 *
-	 * @var Requests_Response $response
-	 */
-	public function before_redirect_check(Requests_Response &$return) {
-		$url = $return->url;
-		if (!$url instanceof Requests_IRI) {
-			$url = new Requests_IRI($url);
-		}
-
-		$cookies = Requests_Cookie::parse_from_headers($return->headers, $url);
-		$this->cookies = array_merge($this->cookies, $cookies);
-		$return->cookies = $this;
-	}
+    /**
+     * Actual item data
+     *
+     * @var array
+     */
+    protected $cookies = array();
+
+    /**
+     * Create a new jar
+     *
+     * @param array $cookies Existing cookie values
+     */
+    public function __construct($cookies = array()) {
+        $this->cookies = $cookies;
+    }
+
+    /**
+     * Normalise cookie data into a Requests_Cookie
+     *
+     * @param string|Requests_Cookie $cookie
+     * @return Requests_Cookie
+     */
+    public function normalize_cookie($cookie, $key = null) {
+        if ($cookie instanceof Requests_Cookie) {
+            return $cookie;
+        }
+
+        return Requests_Cookie::parse($cookie, $key);
+    }
+
+    /**
+     * Normalise cookie data into a Requests_Cookie
+     *
+     * @codeCoverageIgnore
+     * @deprecated Use {@see Requests_Cookie_Jar::normalize_cookie}
+     * @return Requests_Cookie
+     */
+    public function normalizeCookie($cookie, $key = null) {
+        return $this->normalize_cookie($cookie, $key);
+    }
+
+    /**
+     * Check if the given item exists
+     *
+     * @param string $key Item key
+     * @return boolean Does the item exist?
+     */
+    public function offsetExists($key) {
+        return isset($this->cookies[$key]);
+    }
+
+    /**
+     * Get the value for the item
+     *
+     * @param string $key Item key
+     * @return string Item value
+     */
+    public function offsetGet($key) {
+        if (!isset($this->cookies[$key])) {
+            return null;
+        }
+
+        return $this->cookies[$key];
+    }
+
+    /**
+     * Set the given item
+     *
+     * @throws Requests_Exception On attempting to use dictionary as list (`invalidset`)
+     *
+     * @param string $key Item name
+     * @param string $value Item value
+     */
+    public function offsetSet($key, $value) {
+        if ($key === null) {
+            throw new Requests_Exception('Object is a dictionary, not a list', 'invalidset');
+        }
+
+        $this->cookies[$key] = $value;
+    }
+
+    /**
+     * Unset the given header
+     *
+     * @param string $key
+     */
+    public function offsetUnset($key) {
+        unset($this->cookies[$key]);
+    }
+
+    /**
+     * Get an iterator for the data
+     *
+     * @return ArrayIterator
+     */
+    public function getIterator() {
+        return new ArrayIterator($this->cookies);
+    }
+
+    /**
+     * Register the cookie handler with the request's hooking system
+     *
+     * @param Requests_Hooker $hooks Hooking system
+     */
+    public function register(Requests_Hooker $hooks) {
+        $hooks->register('requests.before_request', array($this, 'before_request'));
+        $hooks->register('requests.before_redirect_check', array($this, 'before_redirect_check'));
+    }
+
+    /**
+     * Add Cookie header to a request if we have any
+     *
+     * As per RFC 6265, cookies are separated by '; '
+     *
+     * @param string $url
+     * @param array $headers
+     * @param array $data
+     * @param string $type
+     * @param array $options
+     */
+    public function before_request($url, &$headers, &$data, &$type, &$options) {
+        if (!$url instanceof Requests_IRI) {
+            $url = new Requests_IRI($url);
+        }
+
+        if (!empty($this->cookies)) {
+            $cookies = array();
+            foreach ($this->cookies as $key => $cookie) {
+                $cookie = $this->normalize_cookie($cookie, $key);
+
+                // Skip expired cookies
+                if ($cookie->is_expired()) {
+                    continue;
+                }
+
+                if ($cookie->domain_matches($url->host)) {
+                    $cookies[] = $cookie->format_for_header();
+                }
+            }
+
+            $headers['Cookie'] = implode('; ', $cookies);
+        }
+    }
+
+    /**
+     * Parse all cookies from a response and attach them to the response
+     *
+     * @var Requests_Response $response
+     */
+    public function before_redirect_check(Requests_Response &$return) {
+        $url = $return->url;
+        if (!$url instanceof Requests_IRI) {
+            $url = new Requests_IRI($url);
+        }
+
+        $cookies = Requests_Cookie::parse_from_headers($return->headers, $url);
+        $this->cookies = array_merge($this->cookies, $cookies);
+        $return->cookies = $this;
+    }
 }
\ No newline at end of file

plugin/buycourses/src/Requests/Session.php

Indentation +204 added lines, -204 removed lines

@@ -18,136 +18,136 @@ 
  * @subpackage Session Handler
  */
 class Requests_Session {
-	/**
-	 * Base URL for requests
-	 *
-	 * URLs will be made absolute using this as the base
-	 * @var string|null
-	 */
-	public $url = null;
+    /**
+     * Base URL for requests
+     *
+     * URLs will be made absolute using this as the base
+     * @var string|null
+     */
+    public $url = null;
 
-	/**
-	 * Base headers for requests
-	 * @var array
-	 */
-	public $headers = array();
+    /**
+     * Base headers for requests
+     * @var array
+     */
+    public $headers = array();
 
-	/**
-	 * Base data for requests
-	 *
-	 * If both the base data and the per-request data are arrays, the data will
-	 * be merged before sending the request.
-	 *
-	 * @var array
-	 */
-	public $data = array();
+    /**
+     * Base data for requests
+     *
+     * If both the base data and the per-request data are arrays, the data will
+     * be merged before sending the request.
+     *
+     * @var array
+     */
+    public $data = array();
 
-	/**
-	 * Base options for requests
-	 *
-	 * The base options are merged with the per-request data for each request.
-	 * The only default option is a shared cookie jar between requests.
-	 *
-	 * Values here can also be set directly via properties on the Session
-	 * object, e.g. `$session->useragent = 'X';`
-	 *
-	 * @var array
-	 */
-	public $options = array();
+    /**
+     * Base options for requests
+     *
+     * The base options are merged with the per-request data for each request.
+     * The only default option is a shared cookie jar between requests.
+     *
+     * Values here can also be set directly via properties on the Session
+     * object, e.g. `$session->useragent = 'X';`
+     *
+     * @var array
+     */
+    public $options = array();
 
-	/**
-	 * Create a new session
-	 *
-	 * @param string|null $url Base URL for requests
-	 * @param array $headers Default headers for requests
-	 * @param array $data Default data for requests
-	 * @param array $options Default options for requests
-	 */
-	public function __construct($url = null, $headers = array(), $data = array(), $options = array()) {
-		$this->url = $url;
-		$this->headers = $headers;
-		$this->data = $data;
-		$this->options = $options;
+    /**
+     * Create a new session
+     *
+     * @param string|null $url Base URL for requests
+     * @param array $headers Default headers for requests
+     * @param array $data Default data for requests
+     * @param array $options Default options for requests
+     */
+    public function __construct($url = null, $headers = array(), $data = array(), $options = array()) {
+        $this->url = $url;
+        $this->headers = $headers;
+        $this->data = $data;
+        $this->options = $options;
 
-		if (empty($this->options['cookies'])) {
-			$this->options['cookies'] = new Requests_Cookie_Jar();
-		}
-	}
+        if (empty($this->options['cookies'])) {
+            $this->options['cookies'] = new Requests_Cookie_Jar();
+        }
+    }
 
-	/**
-	 * Get a property's value
-	 *
-	 * @param string $key Property key
-	 * @return mixed|null Property value, null if none found
-	 */
-	public function __get($key) {
-		if (isset($this->options[$key])) {
-			return $this->options[$key];
-		}
+    /**
+     * Get a property's value
+     *
+     * @param string $key Property key
+     * @return mixed|null Property value, null if none found
+     */
+    public function __get($key) {
+        if (isset($this->options[$key])) {
+            return $this->options[$key];
+        }
 
-		return null;
-	}
+        return null;
+    }
 
-	/**
-	 * Set a property's value
-	 *
-	 * @param string $key Property key
-	 * @param mixed $value Property value
-	 */
-	public function __set($key, $value) {
-		$this->options[$key] = $value;
-	}
+    /**
+     * Set a property's value
+     *
+     * @param string $key Property key
+     * @param mixed $value Property value
+     */
+    public function __set($key, $value) {
+        $this->options[$key] = $value;
+    }
 
-	/**
-	 * Remove a property's value
-	 *
-	 * @param string $key Property key
-	 */
-	public function __isset($key) {
-		return isset($this->options[$key]);
-	}
+    /**
+     * Remove a property's value
+     *
+     * @param string $key Property key
+     */
+    public function __isset($key) {
+        return isset($this->options[$key]);
+    }
 
-	/**
-	 * Remove a property's value
-	 *
-	 * @param string $key Property key
-	 */
-	public function __unset($key) {
-		if (isset($this->options[$key])) {
-			unset($this->options[$key]);
-		}
-	}
+    /**
+     * Remove a property's value
+     *
+     * @param string $key Property key
+     */
+    public function __unset($key) {
+        if (isset($this->options[$key])) {
+            unset($this->options[$key]);
+        }
+    }
 
-	/**#@+
+    /**#@+
 	 * @see request()
 	 * @param string $url
 	 * @param array $headers
 	 * @param array $options
 	 * @return Requests_Response
 	 */
-	/**
-	 * Send a GET request
-	 */
-	public function get($url, $headers = array(), $options = array()) {
-		return $this->request($url, $headers, null, Requests::GET, $options);
-	}
+    /**
+     * Send a GET request
+     */
+    public function get($url, $headers = array(), $options = array()) {
+        return $this->request($url, $headers, null, Requests::GET, $options);
+    }
 
-	/**
-	 * Send a HEAD request
-	 */
-	public function head($url, $headers = array(), $options = array()) {
-		return $this->request($url, $headers, null, Requests::HEAD, $options);
-	}
+    /**
+     * Send a HEAD request
+     */
+    public function head($url, $headers = array(), $options = array()) {
+        return $this->request($url, $headers, null, Requests::HEAD, $options);
+    }
 
-	/**
-	 * Send a DELETE request
-	 */
-	public function delete($url, $headers = array(), $options = array()) {
-		return $this->request($url, $headers, null, Requests::DELETE, $options);
-	}
-	/**#@-*/
+    /**
+     * Send a DELETE request
+     */
+    public function delete($url, $headers = array(), $options = array()) {
+        return $this->request($url, $headers, null, Requests::DELETE, $options);
+    }
+    /**#@-*/
 
-	/**#@+
+    /**#@+
 	 * @see request()
 	 * @param string $url
 	 * @param array $headers
@@ -155,112 +155,112 @@ 
 	 * @param array $options
 	 * @return Requests_Response
 	 */
-	/**
-	 * Send a POST request
-	 */
-	public function post($url, $headers = array(), $data = array(), $options = array()) {
-		return $this->request($url, $headers, $data, Requests::POST, $options);
-	}
+    /**
+     * Send a POST request
+     */
+    public function post($url, $headers = array(), $data = array(), $options = array()) {
+        return $this->request($url, $headers, $data, Requests::POST, $options);
+    }
 
-	/**
-	 * Send a PUT request
-	 */
-	public function put($url, $headers = array(), $data = array(), $options = array()) {
-		return $this->request($url, $headers, $data, Requests::PUT, $options);
-	}
+    /**
+     * Send a PUT request
+     */
+    public function put($url, $headers = array(), $data = array(), $options = array()) {
+        return $this->request($url, $headers, $data, Requests::PUT, $options);
+    }
 
-	/**
-	 * Send a PATCH request
-	 *
-	 * Note: Unlike {@see post} and {@see put}, `$headers` is required, as the
-	 * specification recommends that should send an ETag
-	 *
-	 * @link https://tools.ietf.org/html/rfc5789
-	 */
-	public function patch($url, $headers, $data = array(), $options = array()) {
-		return $this->request($url, $headers, $data, Requests::PATCH, $options);
-	}
-	/**#@-*/
+    /**
+     * Send a PATCH request
+     *
+     * Note: Unlike {@see post} and {@see put}, `$headers` is required, as the
+     * specification recommends that should send an ETag
+     *
+     * @link https://tools.ietf.org/html/rfc5789
+     */
+    public function patch($url, $headers, $data = array(), $options = array()) {
+        return $this->request($url, $headers, $data, Requests::PATCH, $options);
+    }
+    /**#@-*/
 
-	/**
-	 * Main interface for HTTP requests
-	 *
-	 * This method initiates a request and sends it via a transport before
-	 * parsing.
-	 *
-	 * @see Requests::request()
-	 *
-	 * @throws Requests_Exception On invalid URLs (`nonhttp`)
-	 *
-	 * @param string $url URL to request
-	 * @param array $headers Extra headers to send with the request
-	 * @param array|null $data Data to send either as a query string for GET/HEAD requests, or in the body for POST requests
-	 * @param string $type HTTP request type (use Requests constants)
-	 * @param array $options Options for the request (see {@see Requests::request})
-	 * @return Requests_Response
-	 */
-	public function request($url, $headers = array(), $data = array(), $type = Requests::GET, $options = array()) {
-		$request = $this->merge_request(compact('url', 'headers', 'data', 'options'));
+    /**
+     * Main interface for HTTP requests
+     *
+     * This method initiates a request and sends it via a transport before
+     * parsing.
+     *
+     * @see Requests::request()
+     *
+     * @throws Requests_Exception On invalid URLs (`nonhttp`)
+     *
+     * @param string $url URL to request
+     * @param array $headers Extra headers to send with the request
+     * @param array|null $data Data to send either as a query string for GET/HEAD requests, or in the body for POST requests
+     * @param string $type HTTP request type (use Requests constants)
+     * @param array $options Options for the request (see {@see Requests::request})
+     * @return Requests_Response
+     */
+    public function request($url, $headers = array(), $data = array(), $type = Requests::GET, $options = array()) {
+        $request = $this->merge_request(compact('url', 'headers', 'data', 'options'));
 
-		return Requests::request($request['url'], $request['headers'], $request['data'], $type, $request['options']);
-	}
+        return Requests::request($request['url'], $request['headers'], $request['data'], $type, $request['options']);
+    }
 
-	/**
-	 * Send multiple HTTP requests simultaneously
-	 *
-	 * @see Requests::request_multiple()
-	 *
-	 * @param array $requests Requests data (see {@see Requests::request_multiple})
-	 * @param array $options Global and default options (see {@see Requests::request})
-	 * @return array Responses (either Requests_Response or a Requests_Exception object)
-	 */
-	public function request_multiple($requests, $options = array()) {
-		foreach ($requests as $key => $request) {
-			$requests[$key] = $this->merge_request($request, false);
-		}
+    /**
+     * Send multiple HTTP requests simultaneously
+     *
+     * @see Requests::request_multiple()
+     *
+     * @param array $requests Requests data (see {@see Requests::request_multiple})
+     * @param array $options Global and default options (see {@see Requests::request})
+     * @return array Responses (either Requests_Response or a Requests_Exception object)
+     */
+    public function request_multiple($requests, $options = array()) {
+        foreach ($requests as $key => $request) {
+            $requests[$key] = $this->merge_request($request, false);
+        }
 
-		$options = array_merge($this->options, $options);
+        $options = array_merge($this->options, $options);
 
-		// Disallow forcing the type, as that's a per request setting
-		unset($options['type']);
+        // Disallow forcing the type, as that's a per request setting
+        unset($options['type']);
 
-		return Requests::request_multiple($requests, $options);
-	}
+        return Requests::request_multiple($requests, $options);
+    }
 
-	/**
-	 * Merge a request's data with the default data
-	 *
-	 * @param array $request Request data (same form as {@see request_multiple})
-	 * @param boolean $merge_options Should we merge options as well?
-	 * @return array Request data
-	 */
-	protected function merge_request($request, $merge_options = true) {
-		if ($this->url !== null) {
-			$request['url'] = Requests_IRI::absolutize($this->url, $request['url']);
-			$request['url'] = $request['url']->uri;
-		}
+    /**
+     * Merge a request's data with the default data
+     *
+     * @param array $request Request data (same form as {@see request_multiple})
+     * @param boolean $merge_options Should we merge options as well?
+     * @return array Request data
+     */
+    protected function merge_request($request, $merge_options = true) {
+        if ($this->url !== null) {
+            $request['url'] = Requests_IRI::absolutize($this->url, $request['url']);
+            $request['url'] = $request['url']->uri;
+        }
 
-		if (empty($request['headers'])) {
-			$request['headers'] = array();
-		}
-		$request['headers'] = array_merge($this->headers, $request['headers']);
+        if (empty($request['headers'])) {
+            $request['headers'] = array();
+        }
+        $request['headers'] = array_merge($this->headers, $request['headers']);
 
-		if (empty($request['data'])) {
-			if (is_array($this->data)) {
-				$request['data'] = $this->data;
-			}
-		}
-		elseif (is_array($request['data']) && is_array($this->data)) {
-			$request['data'] = array_merge($this->data, $request['data']);
-		}
+        if (empty($request['data'])) {
+            if (is_array($this->data)) {
+                $request['data'] = $this->data;
+            }
+        }
+        elseif (is_array($request['data']) && is_array($this->data)) {
+            $request['data'] = array_merge($this->data, $request['data']);
+        }
 
-		if ($merge_options !== false) {
-			$request['options'] = array_merge($this->options, $request['options']);
+        if ($merge_options !== false) {
+            $request['options'] = array_merge($this->options, $request['options']);
 
-			// Disallow forcing the type, as that's a per request setting
-			unset($request['options']['type']);
-		}
+            // Disallow forcing the type, as that's a per request setting
+            unset($request['options']['type']);
+        }
 
-		return $request;
-	}
+        return $request;
+    }
 }

plugin/buycourses/src/Requests/Cookie.php

Indentation +484 added lines, -484 removed lines

@@ -13,488 +13,488 @@
  * @subpackage Cookies
  */
 class Requests_Cookie {
-	/**
-	 * Cookie name.
-	 *
-	 * @var string
-	 */
-	public $name;
-
-	/**
-	 * Cookie value.
-	 *
-	 * @var string
-	 */
-	public $value;
-
-	/**
-	 * Cookie attributes
-	 *
-	 * Valid keys are (currently) path, domain, expires, max-age, secure and
-	 * httponly.
-	 *
-	 * @var Requests_Utility_CaseInsensitiveDictionary|array Array-like object
-	 */
-	public $attributes = array();
-
-	/**
-	 * Cookie flags
-	 *
-	 * Valid keys are (currently) creation, last-access, persistent and
-	 * host-only.
-	 *
-	 * @var array
-	 */
-	public $flags = array();
-
-	/**
-	 * Reference time for relative calculations
-	 *
-	 * This is used in place of `time()` when calculating Max-Age expiration and
-	 * checking time validity.
-	 *
-	 * @var int
-	 */
-	public $reference_time = 0;
-
-	/**
-	 * Create a new cookie object
-	 *
-	 * @param string $name
-	 * @param string $value
-	 * @param array|Requests_Utility_CaseInsensitiveDictionary $attributes Associative array of attribute data
-	 */
-	public function __construct($name, $value, $attributes = array(), $flags = array(), $reference_time = null) {
-		$this->name = $name;
-		$this->value = $value;
-		$this->attributes = $attributes;
-		$default_flags = array(
-			'creation' => time(),
-			'last-access' => time(),
-			'persistent' => false,
-			'host-only' => true,
-		);
-		$this->flags = array_merge($default_flags, $flags);
-
-		$this->reference_time = time();
-		if ($reference_time !== null) {
-			$this->reference_time = $reference_time;
-		}
-
-		$this->normalize();
-	}
-
-	/**
-	 * Check if a cookie is expired.
-	 *
-	 * Checks the age against $this->reference_time to determine if the cookie
-	 * is expired.
-	 *
-	 * @return boolean True if expired, false if time is valid.
-	 */
-	public function is_expired() {
-		// RFC6265, s. 4.1.2.2:
-		// If a cookie has both the Max-Age and the Expires attribute, the Max-
-		// Age attribute has precedence and controls the expiration date of the
-		// cookie.
-		if (isset($this->attributes['max-age'])) {
-			$max_age = $this->attributes['max-age'];
-			return $max_age < $this->reference_time;
-		}
-
-		if (isset($this->attributes['expires'])) {
-			$expires = $this->attributes['expires'];
-			return $expires < $this->reference_time;
-		}
-
-		return false;
-	}
-
-	/**
-	 * Check if a cookie is valid for a given URI
-	 *
-	 * @param Requests_IRI $uri URI to check
-	 * @return boolean Whether the cookie is valid for the given URI
-	 */
-	public function uri_matches(Requests_IRI $uri) {
-		if (!$this->domain_matches($uri->host)) {
-			return false;
-		}
-
-		if (!$this->path_matches($uri->path)) {
-			return false;
-		}
-
-		return empty($this->attributes['secure']) || $uri->scheme === 'https';
-	}
-
-	/**
-	 * Check if a cookie is valid for a given domain
-	 *
-	 * @param string $string Domain to check
-	 * @return boolean Whether the cookie is valid for the given domain
-	 */
-	public function domain_matches($string) {
-		if (!isset($this->attributes['domain'])) {
-			// Cookies created manually; cookies created by Requests will set
-			// the domain to the requested domain
-			return true;
-		}
-
-		$domain_string = $this->attributes['domain'];
-		if ($domain_string === $string) {
-			// The domain string and the string are identical.
-			return true;
-		}
-
-		// If the cookie is marked as host-only and we don't have an exact
-		// match, reject the cookie
-		if ($this->flags['host-only'] === true) {
-			return false;
-		}
-
-		if (strlen($string) <= strlen($domain_string)) {
-			// For obvious reasons, the string cannot be a suffix if the domain
-			// is shorter than the domain string
-			return false;
-		}
-
-		if (substr($string, -1 * strlen($domain_string)) !== $domain_string) {
-			// The domain string should be a suffix of the string.
-			return false;
-		}
-
-		$prefix = substr($string, 0, strlen($string) - strlen($domain_string));
-		if (substr($prefix, -1) !== '.') {
-			// The last character of the string that is not included in the
-			// domain string should be a %x2E (".") character.
-			return false;
-		}
-
-		// The string should be a host name (i.e., not an IP address).
-		return !preg_match('#^(.+\.)\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$#', $string);
-	}
-
-	/**
-	 * Check if a cookie is valid for a given path
-	 *
-	 * From the path-match check in RFC 6265 section 5.1.4
-	 *
-	 * @param string $request_path Path to check
-	 * @return boolean Whether the cookie is valid for the given path
-	 */
-	public function path_matches($request_path) {
-		if (empty($request_path)) {
-			// Normalize empty path to root
-			$request_path = '/';
-		}
-
-		if (!isset($this->attributes['path'])) {
-			// Cookies created manually; cookies created by Requests will set
-			// the path to the requested path
-			return true;
-		}
-
-		$cookie_path = $this->attributes['path'];
-
-		if ($cookie_path === $request_path) {
-			// The cookie-path and the request-path are identical.
-			return true;
-		}
-
-		if (strlen($request_path) > strlen($cookie_path) && substr($request_path, 0, strlen($cookie_path)) === $cookie_path) {
-			if (substr($cookie_path, -1) === '/') {
-				// The cookie-path is a prefix of the request-path, and the last
-				// character of the cookie-path is %x2F ("/").
-				return true;
-			}
-
-			if (substr($request_path, strlen($cookie_path), 1) === '/') {
-				// The cookie-path is a prefix of the request-path, and the
-				// first character of the request-path that is not included in
-				// the cookie-path is a %x2F ("/") character.
-				return true;
-			}
-		}
-
-		return false;
-	}
-
-	/**
-	 * Normalize cookie and attributes
-	 *
-	 * @return boolean Whether the cookie was successfully normalized
-	 */
-	public function normalize() {
-		foreach ($this->attributes as $key => $value) {
-			$orig_value = $value;
-			$value = $this->normalize_attribute($key, $value);
-			if ($value === null) {
-				unset($this->attributes[$key]);
-				continue;
-			}
-
-			if ($value !== $orig_value) {
-				$this->attributes[$key] = $value;
-			}
-		}
-
-		return true;
-	}
-
-	/**
-	 * Parse an individual cookie attribute
-	 *
-	 * Handles parsing individual attributes from the cookie values.
-	 *
-	 * @param string $name Attribute name
-	 * @param string|boolean $value Attribute value (string value, or true if empty/flag)
-	 * @return mixed Value if available, or null if the attribute value is invalid (and should be skipped)
-	 */
-	protected function normalize_attribute($name, $value) {
-		switch (strtolower($name)) {
-			case 'expires':
-				// Expiration parsing, as per RFC 6265 section 5.2.1
-				if (is_int($value)) {
-					return $value;
-				}
-
-				$expiry_time = strtotime($value);
-				if ($expiry_time === false) {
-					return null;
-				}
-
-				return $expiry_time;
-
-			case 'max-age':
-				// Expiration parsing, as per RFC 6265 section 5.2.2
-				if (is_int($value)) {
-					return $value;
-				}
-
-				// Check that we have a valid age
-				if (!preg_match('/^-?\d+$/', $value)) {
-					return null;
-				}
-
-				$delta_seconds = (int) $value;
-				if ($delta_seconds <= 0) {
-					$expiry_time = 0;
-				}
-				else {
-					$expiry_time = $this->reference_time + $delta_seconds;
-				}
-
-				return $expiry_time;
-
-			case 'domain':
-				// Domain normalization, as per RFC 6265 section 5.2.3
-				if ($value[0] === '.') {
-					$value = substr($value, 1);
-				}
-
-				return $value;
-
-			default:
-				return $value;
-		}
-	}
-
-	/**
-	 * Format a cookie for a Cookie header
-	 *
-	 * This is used when sending cookies to a server.
-	 *
-	 * @return string Cookie formatted for Cookie header
-	 */
-	public function format_for_header() {
-		return sprintf('%s=%s', $this->name, $this->value);
-	}
-
-	/**
-	 * Format a cookie for a Cookie header
-	 *
-	 * @codeCoverageIgnore
-	 * @deprecated Use {@see Requests_Cookie::format_for_header}
-	 * @return string
-	 */
-	public function formatForHeader() {
-		return $this->format_for_header();
-	}
-
-	/**
-	 * Format a cookie for a Set-Cookie header
-	 *
-	 * This is used when sending cookies to clients. This isn't really
-	 * applicable to client-side usage, but might be handy for debugging.
-	 *
-	 * @return string Cookie formatted for Set-Cookie header
-	 */
-	public function format_for_set_cookie() {
-		$header_value = $this->format_for_header();
-		if (!empty($this->attributes)) {
-			$parts = array();
-			foreach ($this->attributes as $key => $value) {
-				// Ignore non-associative attributes
-				if (is_numeric($key)) {
-					$parts[] = $value;
-				}
-				else {
-					$parts[] = sprintf('%s=%s', $key, $value);
-				}
-			}
-
-			$header_value .= '; ' . implode('; ', $parts);
-		}
-		return $header_value;
-	}
-
-	/**
-	 * Format a cookie for a Set-Cookie header
-	 *
-	 * @codeCoverageIgnore
-	 * @deprecated Use {@see Requests_Cookie::format_for_set_cookie}
-	 * @return string
-	 */
-	public function formatForSetCookie() {
-		return $this->format_for_set_cookie();
-	}
-
-	/**
-	 * Get the cookie value
-	 *
-	 * Attributes and other data can be accessed via methods.
-	 */
-	public function __toString() {
-		return $this->value;
-	}
-
-	/**
-	 * Parse a cookie string into a cookie object
-	 *
-	 * Based on Mozilla's parsing code in Firefox and related projects, which
-	 * is an intentional deviation from RFC 2109 and RFC 2616. RFC 6265
-	 * specifies some of this handling, but not in a thorough manner.
-	 *
-	 * @param string Cookie header value (from a Set-Cookie header)
-	 * @return Requests_Cookie Parsed cookie object
-	 */
-	public static function parse($string, $name = '', $reference_time = null) {
-		$parts = explode(';', $string);
-		$kvparts = array_shift($parts);
-
-		if (!empty($name)) {
-			$value = $string;
-		}
-		elseif (strpos($kvparts, '=') === false) {
-			// Some sites might only have a value without the equals separator.
-			// Deviate from RFC 6265 and pretend it was actually a blank name
-			// (`=foo`)
-			//
-			// https://bugzilla.mozilla.org/show_bug.cgi?id=169091
-			$name = '';
-			$value = $kvparts;
-		}
-		else {
-			list($name, $value) = explode('=', $kvparts, 2);
-		}
-		$name = trim($name);
-		$value = trim($value);
-
-		// Attribute key are handled case-insensitively
-		$attributes = new Requests_Utility_CaseInsensitiveDictionary();
-
-		if (!empty($parts)) {
-			foreach ($parts as $part) {
-				if (strpos($part, '=') === false) {
-					$part_key = $part;
-					$part_value = true;
-				}
-				else {
-					list($part_key, $part_value) = explode('=', $part, 2);
-					$part_value = trim($part_value);
-				}
-
-				$part_key = trim($part_key);
-				$attributes[$part_key] = $part_value;
-			}
-		}
-
-		return new Requests_Cookie($name, $value, $attributes, array(), $reference_time);
-	}
-
-	/**
-	 * Parse all Set-Cookie headers from request headers
-	 *
-	 * @param Requests_Response_Headers $headers Headers to parse from
-	 * @param Requests_IRI|null $origin URI for comparing cookie origins
-	 * @param int|null $time Reference time for expiration calculation
-	 * @return array
-	 */
-	public static function parse_from_headers(Requests_Response_Headers $headers, Requests_IRI $origin = null, $time = null) {
-		$cookie_headers = $headers->getValues('Set-Cookie');
-		if (empty($cookie_headers)) {
-			return array();
-		}
-
-		$cookies = array();
-		foreach ($cookie_headers as $header) {
-			$parsed = self::parse($header, '', $time);
-
-			// Default domain/path attributes
-			if (empty($parsed->attributes['domain']) && !empty($origin)) {
-				$parsed->attributes['domain'] = $origin->host;
-				$parsed->flags['host-only'] = true;
-			}
-			else {
-				$parsed->flags['host-only'] = false;
-			}
-
-			$path_is_valid = (!empty($parsed->attributes['path']) && $parsed->attributes['path'][0] === '/');
-			if (!$path_is_valid && !empty($origin)) {
-				$path = $origin->path;
-
-				// Default path normalization as per RFC 6265 section 5.1.4
-				if (substr($path, 0, 1) !== '/') {
-					// If the uri-path is empty or if the first character of
-					// the uri-path is not a %x2F ("/") character, output
-					// %x2F ("/") and skip the remaining steps.
-					$path = '/';
-				}
-				elseif (substr_count($path, '/') === 1) {
-					// If the uri-path contains no more than one %x2F ("/")
-					// character, output %x2F ("/") and skip the remaining
-					// step.
-					$path = '/';
-				}
-				else {
-					// Output the characters of the uri-path from the first
-					// character up to, but not including, the right-most
-					// %x2F ("/").
-					$path = substr($path, 0, strrpos($path, '/'));
-				}
-				$parsed->attributes['path'] = $path;
-			}
-
-			// Reject invalid cookie domains
-			if (!empty($origin) && !$parsed->domain_matches($origin->host)) {
-				continue;
-			}
-
-			$cookies[$parsed->name] = $parsed;
-		}
-
-		return $cookies;
-	}
-
-	/**
-	 * Parse all Set-Cookie headers from request headers
-	 *
-	 * @codeCoverageIgnore
-	 * @deprecated Use {@see Requests_Cookie::parse_from_headers}
-	 * @return string
-	 */
-	public static function parseFromHeaders(Requests_Response_Headers $headers) {
-		return self::parse_from_headers($headers);
-	}
+    /**
+     * Cookie name.
+     *
+     * @var string
+     */
+    public $name;
+
+    /**
+     * Cookie value.
+     *
+     * @var string
+     */
+    public $value;
+
+    /**
+     * Cookie attributes
+     *
+     * Valid keys are (currently) path, domain, expires, max-age, secure and
+     * httponly.
+     *
+     * @var Requests_Utility_CaseInsensitiveDictionary|array Array-like object
+     */
+    public $attributes = array();
+
+    /**
+     * Cookie flags
+     *
+     * Valid keys are (currently) creation, last-access, persistent and
+     * host-only.
+     *
+     * @var array
+     */
+    public $flags = array();
+
+    /**
+     * Reference time for relative calculations
+     *
+     * This is used in place of `time()` when calculating Max-Age expiration and
+     * checking time validity.
+     *
+     * @var int
+     */
+    public $reference_time = 0;
+
+    /**
+     * Create a new cookie object
+     *
+     * @param string $name
+     * @param string $value
+     * @param array|Requests_Utility_CaseInsensitiveDictionary $attributes Associative array of attribute data
+     */
+    public function __construct($name, $value, $attributes = array(), $flags = array(), $reference_time = null) {
+        $this->name = $name;
+        $this->value = $value;
+        $this->attributes = $attributes;
+        $default_flags = array(
+            'creation' => time(),
+            'last-access' => time(),
+            'persistent' => false,
+            'host-only' => true,
+        );
+        $this->flags = array_merge($default_flags, $flags);
+
+        $this->reference_time = time();
+        if ($reference_time !== null) {
+            $this->reference_time = $reference_time;
+        }
+
+        $this->normalize();
+    }
+
+    /**
+     * Check if a cookie is expired.
+     *
+     * Checks the age against $this->reference_time to determine if the cookie
+     * is expired.
+     *
+     * @return boolean True if expired, false if time is valid.
+     */
+    public function is_expired() {
+        // RFC6265, s. 4.1.2.2:
+        // If a cookie has both the Max-Age and the Expires attribute, the Max-
+        // Age attribute has precedence and controls the expiration date of the
+        // cookie.
+        if (isset($this->attributes['max-age'])) {
+            $max_age = $this->attributes['max-age'];
+            return $max_age < $this->reference_time;
+        }
+
+        if (isset($this->attributes['expires'])) {
+            $expires = $this->attributes['expires'];
+            return $expires < $this->reference_time;
+        }
+
+        return false;
+    }
+
+    /**
+     * Check if a cookie is valid for a given URI
+     *
+     * @param Requests_IRI $uri URI to check
+     * @return boolean Whether the cookie is valid for the given URI
+     */
+    public function uri_matches(Requests_IRI $uri) {
+        if (!$this->domain_matches($uri->host)) {
+            return false;
+        }
+
+        if (!$this->path_matches($uri->path)) {
+            return false;
+        }
+
+        return empty($this->attributes['secure']) || $uri->scheme === 'https';
+    }
+
+    /**
+     * Check if a cookie is valid for a given domain
+     *
+     * @param string $string Domain to check
+     * @return boolean Whether the cookie is valid for the given domain
+     */
+    public function domain_matches($string) {
+        if (!isset($this->attributes['domain'])) {
+            // Cookies created manually; cookies created by Requests will set
+            // the domain to the requested domain
+            return true;
+        }
+
+        $domain_string = $this->attributes['domain'];
+        if ($domain_string === $string) {
+            // The domain string and the string are identical.
+            return true;
+        }
+
+        // If the cookie is marked as host-only and we don't have an exact
+        // match, reject the cookie
+        if ($this->flags['host-only'] === true) {
+            return false;
+        }
+
+        if (strlen($string) <= strlen($domain_string)) {
+            // For obvious reasons, the string cannot be a suffix if the domain
+            // is shorter than the domain string
+            return false;
+        }
+
+        if (substr($string, -1 * strlen($domain_string)) !== $domain_string) {
+            // The domain string should be a suffix of the string.
+            return false;
+        }
+
+        $prefix = substr($string, 0, strlen($string) - strlen($domain_string));
+        if (substr($prefix, -1) !== '.') {
+            // The last character of the string that is not included in the
+            // domain string should be a %x2E (".") character.
+            return false;
+        }
+
+        // The string should be a host name (i.e., not an IP address).
+        return !preg_match('#^(.+\.)\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$#', $string);
+    }
+
+    /**
+     * Check if a cookie is valid for a given path
+     *
+     * From the path-match check in RFC 6265 section 5.1.4
+     *
+     * @param string $request_path Path to check
+     * @return boolean Whether the cookie is valid for the given path
+     */
+    public function path_matches($request_path) {
+        if (empty($request_path)) {
+            // Normalize empty path to root
+            $request_path = '/';
+        }
+
+        if (!isset($this->attributes['path'])) {
+            // Cookies created manually; cookies created by Requests will set
+            // the path to the requested path
+            return true;
+        }
+
+        $cookie_path = $this->attributes['path'];
+
+        if ($cookie_path === $request_path) {
+            // The cookie-path and the request-path are identical.
+            return true;
+        }
+
+        if (strlen($request_path) > strlen($cookie_path) && substr($request_path, 0, strlen($cookie_path)) === $cookie_path) {
+            if (substr($cookie_path, -1) === '/') {
+                // The cookie-path is a prefix of the request-path, and the last
+                // character of the cookie-path is %x2F ("/").
+                return true;
+            }
+
+            if (substr($request_path, strlen($cookie_path), 1) === '/') {
+                // The cookie-path is a prefix of the request-path, and the
+                // first character of the request-path that is not included in
+                // the cookie-path is a %x2F ("/") character.
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Normalize cookie and attributes
+     *
+     * @return boolean Whether the cookie was successfully normalized
+     */
+    public function normalize() {
+        foreach ($this->attributes as $key => $value) {
+            $orig_value = $value;
+            $value = $this->normalize_attribute($key, $value);
+            if ($value === null) {
+                unset($this->attributes[$key]);
+                continue;
+            }
+
+            if ($value !== $orig_value) {
+                $this->attributes[$key] = $value;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Parse an individual cookie attribute
+     *
+     * Handles parsing individual attributes from the cookie values.
+     *
+     * @param string $name Attribute name
+     * @param string|boolean $value Attribute value (string value, or true if empty/flag)
+     * @return mixed Value if available, or null if the attribute value is invalid (and should be skipped)
+     */
+    protected function normalize_attribute($name, $value) {
+        switch (strtolower($name)) {
+            case 'expires':
+                // Expiration parsing, as per RFC 6265 section 5.2.1
+                if (is_int($value)) {
+                    return $value;
+                }
+
+                $expiry_time = strtotime($value);
+                if ($expiry_time === false) {
+                    return null;
+                }
+
+                return $expiry_time;
+
+            case 'max-age':
+                // Expiration parsing, as per RFC 6265 section 5.2.2
+                if (is_int($value)) {
+                    return $value;
+                }
+
+                // Check that we have a valid age
+                if (!preg_match('/^-?\d+$/', $value)) {
+                    return null;
+                }
+
+                $delta_seconds = (int) $value;
+                if ($delta_seconds <= 0) {
+                    $expiry_time = 0;
+                }
+                else {
+                    $expiry_time = $this->reference_time + $delta_seconds;
+                }
+
+                return $expiry_time;
+
+            case 'domain':
+                // Domain normalization, as per RFC 6265 section 5.2.3
+                if ($value[0] === '.') {
+                    $value = substr($value, 1);
+                }
+
+                return $value;
+
+            default:
+                return $value;
+        }
+    }
+
+    /**
+     * Format a cookie for a Cookie header
+     *
+     * This is used when sending cookies to a server.
+     *
+     * @return string Cookie formatted for Cookie header
+     */
+    public function format_for_header() {
+        return sprintf('%s=%s', $this->name, $this->value);
+    }
+
+    /**
+     * Format a cookie for a Cookie header
+     *
+     * @codeCoverageIgnore
+     * @deprecated Use {@see Requests_Cookie::format_for_header}
+     * @return string
+     */
+    public function formatForHeader() {
+        return $this->format_for_header();
+    }
+
+    /**
+     * Format a cookie for a Set-Cookie header
+     *
+     * This is used when sending cookies to clients. This isn't really
+     * applicable to client-side usage, but might be handy for debugging.
+     *
+     * @return string Cookie formatted for Set-Cookie header
+     */
+    public function format_for_set_cookie() {
+        $header_value = $this->format_for_header();
+        if (!empty($this->attributes)) {
+            $parts = array();
+            foreach ($this->attributes as $key => $value) {
+                // Ignore non-associative attributes
+                if (is_numeric($key)) {
+                    $parts[] = $value;
+                }
+                else {
+                    $parts[] = sprintf('%s=%s', $key, $value);
+                }
+            }
+
+            $header_value .= '; ' . implode('; ', $parts);
+        }
+        return $header_value;
+    }
+
+    /**
+     * Format a cookie for a Set-Cookie header
+     *
+     * @codeCoverageIgnore
+     * @deprecated Use {@see Requests_Cookie::format_for_set_cookie}
+     * @return string
+     */
+    public function formatForSetCookie() {
+        return $this->format_for_set_cookie();
+    }
+
+    /**
+     * Get the cookie value
+     *
+     * Attributes and other data can be accessed via methods.
+     */
+    public function __toString() {
+        return $this->value;
+    }
+
+    /**
+     * Parse a cookie string into a cookie object
+     *
+     * Based on Mozilla's parsing code in Firefox and related projects, which
+     * is an intentional deviation from RFC 2109 and RFC 2616. RFC 6265
+     * specifies some of this handling, but not in a thorough manner.
+     *
+     * @param string Cookie header value (from a Set-Cookie header)
+     * @return Requests_Cookie Parsed cookie object
+     */
+    public static function parse($string, $name = '', $reference_time = null) {
+        $parts = explode(';', $string);
+        $kvparts = array_shift($parts);
+
+        if (!empty($name)) {
+            $value = $string;
+        }
+        elseif (strpos($kvparts, '=') === false) {
+            // Some sites might only have a value without the equals separator.
+            // Deviate from RFC 6265 and pretend it was actually a blank name
+            // (`=foo`)
+            //
+            // https://bugzilla.mozilla.org/show_bug.cgi?id=169091
+            $name = '';
+            $value = $kvparts;
+        }
+        else {
+            list($name, $value) = explode('=', $kvparts, 2);
+        }
+        $name = trim($name);
+        $value = trim($value);
+
+        // Attribute key are handled case-insensitively
+        $attributes = new Requests_Utility_CaseInsensitiveDictionary();
+
+        if (!empty($parts)) {
+            foreach ($parts as $part) {
+                if (strpos($part, '=') === false) {
+                    $part_key = $part;
+                    $part_value = true;
+                }
+                else {
+                    list($part_key, $part_value) = explode('=', $part, 2);
+                    $part_value = trim($part_value);
+                }
+
+                $part_key = trim($part_key);
+                $attributes[$part_key] = $part_value;
+            }
+        }
+
+        return new Requests_Cookie($name, $value, $attributes, array(), $reference_time);
+    }
+
+    /**
+     * Parse all Set-Cookie headers from request headers
+     *
+     * @param Requests_Response_Headers $headers Headers to parse from
+     * @param Requests_IRI|null $origin URI for comparing cookie origins
+     * @param int|null $time Reference time for expiration calculation
+     * @return array
+     */
+    public static function parse_from_headers(Requests_Response_Headers $headers, Requests_IRI $origin = null, $time = null) {
+        $cookie_headers = $headers->getValues('Set-Cookie');
+        if (empty($cookie_headers)) {
+            return array();
+        }
+
+        $cookies = array();
+        foreach ($cookie_headers as $header) {
+            $parsed = self::parse($header, '', $time);
+
+            // Default domain/path attributes
+            if (empty($parsed->attributes['domain']) && !empty($origin)) {
+                $parsed->attributes['domain'] = $origin->host;
+                $parsed->flags['host-only'] = true;
+            }
+            else {
+                $parsed->flags['host-only'] = false;
+            }
+
+            $path_is_valid = (!empty($parsed->attributes['path']) && $parsed->attributes['path'][0] === '/');
+            if (!$path_is_valid && !empty($origin)) {
+                $path = $origin->path;
+
+                // Default path normalization as per RFC 6265 section 5.1.4
+                if (substr($path, 0, 1) !== '/') {
+                    // If the uri-path is empty or if the first character of
+                    // the uri-path is not a %x2F ("/") character, output
+                    // %x2F ("/") and skip the remaining steps.
+                    $path = '/';
+                }
+                elseif (substr_count($path, '/') === 1) {
+                    // If the uri-path contains no more than one %x2F ("/")
+                    // character, output %x2F ("/") and skip the remaining
+                    // step.
+                    $path = '/';
+                }
+                else {
+                    // Output the characters of the uri-path from the first
+                    // character up to, but not including, the right-most
+                    // %x2F ("/").
+                    $path = substr($path, 0, strrpos($path, '/'));
+                }
+                $parsed->attributes['path'] = $path;
+            }
+
+            // Reject invalid cookie domains
+            if (!empty($origin) && !$parsed->domain_matches($origin->host)) {
+                continue;
+            }
+
+            $cookies[$parsed->name] = $parsed;
+        }
+
+        return $cookies;
+    }
+
+    /**
+     * Parse all Set-Cookie headers from request headers
+     *
+     * @codeCoverageIgnore
+     * @deprecated Use {@see Requests_Cookie::parse_from_headers}
+     * @return string
+     */
+    public static function parseFromHeaders(Requests_Response_Headers $headers) {
+        return self::parse_from_headers($headers);
+    }
 }

plugin/buycourses/src/Requests/Transport/cURL.php

Indentation +526 added lines, -526 removed lines

@@ -13,530 +13,530 @@
  * @subpackage Transport
  */
 class Requests_Transport_cURL implements Requests_Transport {
-	const CURL_7_10_5 = 0x070A05;
-	const CURL_7_16_2 = 0x071002;
-
-	/**
-	 * Raw HTTP data
-	 *
-	 * @var string
-	 */
-	public $headers = '';
-
-	/**
-	 * Raw body data
-	 *
-	 * @var string
-	 */
-	public $response_data = '';
-
-	/**
-	 * Information on the current request
-	 *
-	 * @var array cURL information array, see {@see https://secure.php.net/curl_getinfo}
-	 */
-	public $info;
-
-	/**
-	 * Version string
-	 *
-	 * @var long
-	 */
-	public $version;
-
-	/**
-	 * cURL handle
-	 *
-	 * @var resource
-	 */
-	protected $handle;
-
-	/**
-	 * Hook dispatcher instance
-	 *
-	 * @var Requests_Hooks
-	 */
-	protected $hooks;
-
-	/**
-	 * Have we finished the headers yet?
-	 *
-	 * @var boolean
-	 */
-	protected $done_headers = false;
-
-	/**
-	 * If streaming to a file, keep the file pointer
-	 *
-	 * @var resource
-	 */
-	protected $stream_handle;
-
-	/**
-	 * How many bytes are in the response body?
-	 *
-	 * @var int
-	 */
-	protected $response_bytes;
-
-	/**
-	 * What's the maximum number of bytes we should keep?
-	 *
-	 * @var int|bool Byte count, or false if no limit.
-	 */
-	protected $response_byte_limit;
-
-	/**
-	 * Constructor
-	 */
-	public function __construct() {
-		$curl = curl_version();
-		$this->version = $curl['version_number'];
-		$this->handle = curl_init();
-
-		curl_setopt($this->handle, CURLOPT_HEADER, false);
-		curl_setopt($this->handle, CURLOPT_RETURNTRANSFER, 1);
-		if ($this->version >= self::CURL_7_10_5) {
-			curl_setopt($this->handle, CURLOPT_ENCODING, '');
-		}
-		if (defined('CURLOPT_PROTOCOLS')) {
-			curl_setopt($this->handle, CURLOPT_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS);
-		}
-		if (defined('CURLOPT_REDIR_PROTOCOLS')) {
-			curl_setopt($this->handle, CURLOPT_REDIR_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS);
-		}
-	}
-
-	/**
-	 * Destructor
-	 */
-	public function __destruct() {
-		if (is_resource($this->handle)) {
-			curl_close($this->handle);
-		}
-	}
-
-	/**
-	 * Perform a request
-	 *
-	 * @throws Requests_Exception On a cURL error (`curlerror`)
-	 *
-	 * @param string $url URL to request
-	 * @param array $headers Associative array of request headers
-	 * @param string|array $data Data to send either as the POST body, or as parameters in the URL for a GET/HEAD
-	 * @param array $options Request options, see {@see Requests::response()} for documentation
-	 * @return string Raw HTTP result
-	 */
-	public function request($url, $headers = array(), $data = array(), $options = array()) {
-		$this->hooks = $options['hooks'];
-
-		$this->setup_handle($url, $headers, $data, $options);
-
-		$options['hooks']->dispatch('curl.before_send', array(&$this->handle));
-
-		if ($options['filename'] !== false) {
-			$this->stream_handle = fopen($options['filename'], 'wb');
-		}
-
-		$this->response_data = '';
-		$this->response_bytes = 0;
-		$this->response_byte_limit = false;
-		if ($options['max_bytes'] !== false) {
-			$this->response_byte_limit = $options['max_bytes'];
-		}
-
-		if (isset($options['verify'])) {
-			if ($options['verify'] === false) {
-				curl_setopt($this->handle, CURLOPT_SSL_VERIFYHOST, 0);
-				curl_setopt($this->handle, CURLOPT_SSL_VERIFYPEER, 0);
-			}
-			elseif (is_string($options['verify'])) {
-				curl_setopt($this->handle, CURLOPT_CAINFO, $options['verify']);
-			}
-		}
-
-		if (isset($options['verifyname']) && $options['verifyname'] === false) {
-			curl_setopt($this->handle, CURLOPT_SSL_VERIFYHOST, 0);
-		}
-
-		curl_exec($this->handle);
-		$response = $this->response_data;
-
-		$options['hooks']->dispatch('curl.after_send', array());
-
-		if (curl_errno($this->handle) === 23 || curl_errno($this->handle) === 61) {
-			// Reset encoding and try again
-			curl_setopt($this->handle, CURLOPT_ENCODING, 'none');
-
-			$this->response_data = '';
-			$this->response_bytes = 0;
-			curl_exec($this->handle);
-			$response = $this->response_data;
-		}
-
-		$this->process_response($response, $options);
-
-		// Need to remove the $this reference from the curl handle.
-		// Otherwise Requests_Transport_cURL wont be garbage collected and the curl_close() will never be called.
-		curl_setopt($this->handle, CURLOPT_HEADERFUNCTION, null);
-		curl_setopt($this->handle, CURLOPT_WRITEFUNCTION, null);
-
-		return $this->headers;
-	}
-
-	/**
-	 * Send multiple requests simultaneously
-	 *
-	 * @param array $requests Request data
-	 * @param array $options Global options
-	 * @return array Array of Requests_Response objects (may contain Requests_Exception or string responses as well)
-	 */
-	public function request_multiple($requests, $options) {
-		// If you're not requesting, we can't get any responses ¯\_(ツ)_/¯
-		if (empty($requests)) {
-			return array();
-		}
-
-		$multihandle = curl_multi_init();
-		$subrequests = array();
-		$subhandles = array();
-
-		$class = get_class($this);
-		foreach ($requests as $id => $request) {
-			$subrequests[$id] = new $class();
-			$subhandles[$id] = $subrequests[$id]->get_subrequest_handle($request['url'], $request['headers'], $request['data'], $request['options']);
-			$request['options']['hooks']->dispatch('curl.before_multi_add', array(&$subhandles[$id]));
-			curl_multi_add_handle($multihandle, $subhandles[$id]);
-		}
-
-		$completed = 0;
-		$responses = array();
-
-		$request['options']['hooks']->dispatch('curl.before_multi_exec', array(&$multihandle));
-
-		do {
-			$active = false;
-
-			do {
-				$status = curl_multi_exec($multihandle, $active);
-			}
-			while ($status === CURLM_CALL_MULTI_PERFORM);
-
-			$to_process = array();
-
-			// Read the information as needed
-			while ($done = curl_multi_info_read($multihandle)) {
-				$key = array_search($done['handle'], $subhandles, true);
-				if (!isset($to_process[$key])) {
-					$to_process[$key] = $done;
-				}
-			}
-
-			// Parse the finished requests before we start getting the new ones
-			foreach ($to_process as $key => $done) {
-				$options = $requests[$key]['options'];
-				if (CURLE_OK !== $done['result']) {
-					//get error string for handle.
-					$reason = curl_error($done['handle']);
-					$exception = new Requests_Exception_Transport_cURL(
-									$reason,
-									Requests_Exception_Transport_cURL::EASY,
-									$done['handle'],
-									$done['result']
-								);
-					$responses[$key] = $exception;
-					$options['hooks']->dispatch('transport.internal.parse_error', array(&$responses[$key], $requests[$key]));
-				}
-				else {
-					$responses[$key] = $subrequests[$key]->process_response($subrequests[$key]->response_data, $options);
-
-					$options['hooks']->dispatch('transport.internal.parse_response', array(&$responses[$key], $requests[$key]));
-				}
-
-				curl_multi_remove_handle($multihandle, $done['handle']);
-				curl_close($done['handle']);
-
-				if (!is_string($responses[$key])) {
-					$options['hooks']->dispatch('multiple.request.complete', array(&$responses[$key], $key));
-				}
-				$completed++;
-			}
-		}
-		while ($active || $completed < count($subrequests));
-
-		$request['options']['hooks']->dispatch('curl.after_multi_exec', array(&$multihandle));
-
-		curl_multi_close($multihandle);
-
-		return $responses;
-	}
-
-	/**
-	 * Get the cURL handle for use in a multi-request
-	 *
-	 * @param string $url URL to request
-	 * @param array $headers Associative array of request headers
-	 * @param string|array $data Data to send either as the POST body, or as parameters in the URL for a GET/HEAD
-	 * @param array $options Request options, see {@see Requests::response()} for documentation
-	 * @return resource Subrequest's cURL handle
-	 */
-	public function &get_subrequest_handle($url, $headers, $data, $options) {
-		$this->setup_handle($url, $headers, $data, $options);
-
-		if ($options['filename'] !== false) {
-			$this->stream_handle = fopen($options['filename'], 'wb');
-		}
-
-		$this->response_data = '';
-		$this->response_bytes = 0;
-		$this->response_byte_limit = false;
-		if ($options['max_bytes'] !== false) {
-			$this->response_byte_limit = $options['max_bytes'];
-		}
-		$this->hooks = $options['hooks'];
-
-		return $this->handle;
-	}
-
-	/**
-	 * Setup the cURL handle for the given data
-	 *
-	 * @param string $url URL to request
-	 * @param array $headers Associative array of request headers
-	 * @param string|array $data Data to send either as the POST body, or as parameters in the URL for a GET/HEAD
-	 * @param array $options Request options, see {@see Requests::response()} for documentation
-	 */
-	protected function setup_handle($url, $headers, $data, $options) {
-		$options['hooks']->dispatch('curl.before_request', array(&$this->handle));
-
-		// Force closing the connection for old versions of cURL (<7.22).
-		if ( ! isset( $headers['Connection'] ) ) {
-			$headers['Connection'] = 'close';
-		}
-
-		$headers = Requests::flatten($headers);
-
-		if (!empty($data)) {
-			$data_format = $options['data_format'];
-
-			if ($data_format === 'query') {
-				$url = self::format_get($url, $data);
-				$data = '';
-			}
-			elseif (!is_string($data)) {
-				$data = http_build_query($data, null, '&');
-			}
-		}
-
-		switch ($options['type']) {
-			case Requests::POST:
-				curl_setopt($this->handle, CURLOPT_POST, true);
-				curl_setopt($this->handle, CURLOPT_POSTFIELDS, $data);
-				break;
-			case Requests::HEAD:
-				curl_setopt($this->handle, CURLOPT_CUSTOMREQUEST, $options['type']);
-				curl_setopt($this->handle, CURLOPT_NOBODY, true);
-				break;
-			case Requests::TRACE:
-				curl_setopt($this->handle, CURLOPT_CUSTOMREQUEST, $options['type']);
-				break;
-			case Requests::PATCH:
-			case Requests::PUT:
-			case Requests::DELETE:
-			case Requests::OPTIONS:
-			default:
-				curl_setopt($this->handle, CURLOPT_CUSTOMREQUEST, $options['type']);
-				if (!empty($data)) {
-					curl_setopt($this->handle, CURLOPT_POSTFIELDS, $data);
-				}
-		}
-
-		// cURL requires a minimum timeout of 1 second when using the system
-		// DNS resolver, as it uses `alarm()`, which is second resolution only.
-		// There's no way to detect which DNS resolver is being used from our
-		// end, so we need to round up regardless of the supplied timeout.
-		//
-		// https://github.com/curl/curl/blob/4f45240bc84a9aa648c8f7243be7b79e9f9323a5/lib/hostip.c#L606-L609
-		$timeout = max($options['timeout'], 1);
-
-		if (is_int($timeout) || $this->version < self::CURL_7_16_2) {
-			curl_setopt($this->handle, CURLOPT_TIMEOUT, ceil($timeout));
-		}
-		else {
-			curl_setopt($this->handle, CURLOPT_TIMEOUT_MS, round($timeout * 1000));
-		}
-
-		if (is_int($options['connect_timeout']) || $this->version < self::CURL_7_16_2) {
-			curl_setopt($this->handle, CURLOPT_CONNECTTIMEOUT, ceil($options['connect_timeout']));
-		}
-		else {
-			curl_setopt($this->handle, CURLOPT_CONNECTTIMEOUT_MS, round($options['connect_timeout'] * 1000));
-		}
-		curl_setopt($this->handle, CURLOPT_URL, $url);
-		curl_setopt($this->handle, CURLOPT_REFERER, $url);
-		curl_setopt($this->handle, CURLOPT_USERAGENT, $options['useragent']);
-		if (!empty($headers)) {
-			curl_setopt($this->handle, CURLOPT_HTTPHEADER, $headers);
-		}
-		if ($options['protocol_version'] === 1.1) {
-			curl_setopt($this->handle, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1);
-		}
-		else {
-			curl_setopt($this->handle, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_0);
-		}
-
-		if (true === $options['blocking']) {
-			curl_setopt($this->handle, CURLOPT_HEADERFUNCTION, array(&$this, 'stream_headers'));
-			curl_setopt($this->handle, CURLOPT_WRITEFUNCTION, array(&$this, 'stream_body'));
-			curl_setopt($this->handle, CURLOPT_BUFFERSIZE, Requests::BUFFER_SIZE);
-		}
-	}
-
-	/**
-	 * Process a response
-	 *
-	 * @param string $response Response data from the body
-	 * @param array $options Request options
-	 * @return string HTTP response data including headers
-	 */
-	public function process_response($response, $options) {
-		if ($options['blocking'] === false) {
-			$fake_headers = '';
-			$options['hooks']->dispatch('curl.after_request', array(&$fake_headers));
-			return false;
-		}
-		if ($options['filename'] !== false) {
-			fclose($this->stream_handle);
-			$this->headers = trim($this->headers);
-		}
-		else {
-			$this->headers .= $response;
-		}
-
-		if (curl_errno($this->handle)) {
-			$error = sprintf(
-				'cURL error %s: %s',
-				curl_errno($this->handle),
-				curl_error($this->handle)
-			);
-			throw new Requests_Exception($error, 'curlerror', $this->handle);
-		}
-		$this->info = curl_getinfo($this->handle);
-
-		$options['hooks']->dispatch('curl.after_request', array(&$this->headers, &$this->info));
-		return $this->headers;
-	}
-
-	/**
-	 * Collect the headers as they are received
-	 *
-	 * @param resource $handle cURL resource
-	 * @param string $headers Header string
-	 * @return integer Length of provided header
-	 */
-	public function stream_headers($handle, $headers) {
-		// Why do we do this? cURL will send both the final response and any
-		// interim responses, such as a 100 Continue. We don't need that.
-		// (We may want to keep this somewhere just in case)
-		if ($this->done_headers) {
-			$this->headers = '';
-			$this->done_headers = false;
-		}
-		$this->headers .= $headers;
-
-		if ($headers === "\r\n") {
-			$this->done_headers = true;
-		}
-		return strlen($headers);
-	}
-
-	/**
-	 * Collect data as it's received
-	 *
-	 * @since 1.6.1
-	 *
-	 * @param resource $handle cURL resource
-	 * @param string $data Body data
-	 * @return integer Length of provided data
-	 */
-	public function stream_body($handle, $data) {
-		$this->hooks->dispatch('request.progress', array($data, $this->response_bytes, $this->response_byte_limit));
-		$data_length = strlen($data);
-
-		// Are we limiting the response size?
-		if ($this->response_byte_limit) {
-			if ($this->response_bytes === $this->response_byte_limit) {
-				// Already at maximum, move on
-				return $data_length;
-			}
-
-			if (($this->response_bytes + $data_length) > $this->response_byte_limit) {
-				// Limit the length
-				$limited_length = ($this->response_byte_limit - $this->response_bytes);
-				$data = substr($data, 0, $limited_length);
-			}
-		}
-
-		if ($this->stream_handle) {
-			fwrite($this->stream_handle, $data);
-		}
-		else {
-			$this->response_data .= $data;
-		}
-
-		$this->response_bytes += strlen($data);
-		return $data_length;
-	}
-
-	/**
-	 * Format a URL given GET data
-	 *
-	 * @param string $url
-	 * @param array|object $data Data to build query using, see {@see https://secure.php.net/http_build_query}
-	 * @return string URL with data
-	 */
-	protected static function format_get($url, $data) {
-		if (!empty($data)) {
-			$url_parts = parse_url($url);
-			if (empty($url_parts['query'])) {
-				$query = $url_parts['query'] = '';
-			}
-			else {
-				$query = $url_parts['query'];
-			}
-
-			$query .= '&' . http_build_query($data, null, '&');
-			$query = trim($query, '&');
-
-			if (empty($url_parts['query'])) {
-				$url .= '?' . $query;
-			}
-			else {
-				$url = str_replace($url_parts['query'], $query, $url);
-			}
-		}
-		return $url;
-	}
-
-	/**
-	 * Whether this transport is valid
-	 *
-	 * @codeCoverageIgnore
-	 * @return boolean True if the transport is valid, false otherwise.
-	 */
-	public static function test($capabilities = array()) {
-		if (!function_exists('curl_init') || !function_exists('curl_exec')) {
-			return false;
-		}
-
-		// If needed, check that our installed curl version supports SSL
-		if (isset($capabilities['ssl']) && $capabilities['ssl']) {
-			$curl_version = curl_version();
-			if (!(CURL_VERSION_SSL & $curl_version['features'])) {
-				return false;
-			}
-		}
-
-		return true;
-	}
+    const CURL_7_10_5 = 0x070A05;
+    const CURL_7_16_2 = 0x071002;
+
+    /**
+     * Raw HTTP data
+     *
+     * @var string
+     */
+    public $headers = '';
+
+    /**
+     * Raw body data
+     *
+     * @var string
+     */
+    public $response_data = '';
+
+    /**
+     * Information on the current request
+     *
+     * @var array cURL information array, see {@see https://secure.php.net/curl_getinfo}
+     */
+    public $info;
+
+    /**
+     * Version string
+     *
+     * @var long
+     */
+    public $version;
+
+    /**
+     * cURL handle
+     *
+     * @var resource
+     */
+    protected $handle;
+
+    /**
+     * Hook dispatcher instance
+     *
+     * @var Requests_Hooks
+     */
+    protected $hooks;
+
+    /**
+     * Have we finished the headers yet?
+     *
+     * @var boolean
+     */
+    protected $done_headers = false;
+
+    /**
+     * If streaming to a file, keep the file pointer
+     *
+     * @var resource
+     */
+    protected $stream_handle;
+
+    /**
+     * How many bytes are in the response body?
+     *
+     * @var int
+     */
+    protected $response_bytes;
+
+    /**
+     * What's the maximum number of bytes we should keep?
+     *
+     * @var int|bool Byte count, or false if no limit.
+     */
+    protected $response_byte_limit;
+
+    /**
+     * Constructor
+     */
+    public function __construct() {
+        $curl = curl_version();
+        $this->version = $curl['version_number'];
+        $this->handle = curl_init();
+
+        curl_setopt($this->handle, CURLOPT_HEADER, false);
+        curl_setopt($this->handle, CURLOPT_RETURNTRANSFER, 1);
+        if ($this->version >= self::CURL_7_10_5) {
+            curl_setopt($this->handle, CURLOPT_ENCODING, '');
+        }
+        if (defined('CURLOPT_PROTOCOLS')) {
+            curl_setopt($this->handle, CURLOPT_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS);
+        }
+        if (defined('CURLOPT_REDIR_PROTOCOLS')) {
+            curl_setopt($this->handle, CURLOPT_REDIR_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS);
+        }
+    }
+
+    /**
+     * Destructor
+     */
+    public function __destruct() {
+        if (is_resource($this->handle)) {
+            curl_close($this->handle);
+        }
+    }
+
+    /**
+     * Perform a request
+     *
+     * @throws Requests_Exception On a cURL error (`curlerror`)
+     *
+     * @param string $url URL to request
+     * @param array $headers Associative array of request headers
+     * @param string|array $data Data to send either as the POST body, or as parameters in the URL for a GET/HEAD
+     * @param array $options Request options, see {@see Requests::response()} for documentation
+     * @return string Raw HTTP result
+     */
+    public function request($url, $headers = array(), $data = array(), $options = array()) {
+        $this->hooks = $options['hooks'];
+
+        $this->setup_handle($url, $headers, $data, $options);
+
+        $options['hooks']->dispatch('curl.before_send', array(&$this->handle));
+
+        if ($options['filename'] !== false) {
+            $this->stream_handle = fopen($options['filename'], 'wb');
+        }
+
+        $this->response_data = '';
+        $this->response_bytes = 0;
+        $this->response_byte_limit = false;
+        if ($options['max_bytes'] !== false) {
+            $this->response_byte_limit = $options['max_bytes'];
+        }
+
+        if (isset($options['verify'])) {
+            if ($options['verify'] === false) {
+                curl_setopt($this->handle, CURLOPT_SSL_VERIFYHOST, 0);
+                curl_setopt($this->handle, CURLOPT_SSL_VERIFYPEER, 0);
+            }
+            elseif (is_string($options['verify'])) {
+                curl_setopt($this->handle, CURLOPT_CAINFO, $options['verify']);
+            }
+        }
+
+        if (isset($options['verifyname']) && $options['verifyname'] === false) {
+            curl_setopt($this->handle, CURLOPT_SSL_VERIFYHOST, 0);
+        }
+
+        curl_exec($this->handle);
+        $response = $this->response_data;
+
+        $options['hooks']->dispatch('curl.after_send', array());
+
+        if (curl_errno($this->handle) === 23 || curl_errno($this->handle) === 61) {
+            // Reset encoding and try again
+            curl_setopt($this->handle, CURLOPT_ENCODING, 'none');
+
+            $this->response_data = '';
+            $this->response_bytes = 0;
+            curl_exec($this->handle);
+            $response = $this->response_data;
+        }
+
+        $this->process_response($response, $options);
+
+        // Need to remove the $this reference from the curl handle.
+        // Otherwise Requests_Transport_cURL wont be garbage collected and the curl_close() will never be called.
+        curl_setopt($this->handle, CURLOPT_HEADERFUNCTION, null);
+        curl_setopt($this->handle, CURLOPT_WRITEFUNCTION, null);
+
+        return $this->headers;
+    }
+
+    /**
+     * Send multiple requests simultaneously
+     *
+     * @param array $requests Request data
+     * @param array $options Global options
+     * @return array Array of Requests_Response objects (may contain Requests_Exception or string responses as well)
+     */
+    public function request_multiple($requests, $options) {
+        // If you're not requesting, we can't get any responses ¯\_(ツ)_/¯
+        if (empty($requests)) {
+            return array();
+        }
+
+        $multihandle = curl_multi_init();
+        $subrequests = array();
+        $subhandles = array();
+
+        $class = get_class($this);
+        foreach ($requests as $id => $request) {
+            $subrequests[$id] = new $class();
+            $subhandles[$id] = $subrequests[$id]->get_subrequest_handle($request['url'], $request['headers'], $request['data'], $request['options']);
+            $request['options']['hooks']->dispatch('curl.before_multi_add', array(&$subhandles[$id]));
+            curl_multi_add_handle($multihandle, $subhandles[$id]);
+        }
+
+        $completed = 0;
+        $responses = array();
+
+        $request['options']['hooks']->dispatch('curl.before_multi_exec', array(&$multihandle));
+
+        do {
+            $active = false;
+
+            do {
+                $status = curl_multi_exec($multihandle, $active);
+            }
+            while ($status === CURLM_CALL_MULTI_PERFORM);
+
+            $to_process = array();
+
+            // Read the information as needed
+            while ($done = curl_multi_info_read($multihandle)) {
+                $key = array_search($done['handle'], $subhandles, true);
+                if (!isset($to_process[$key])) {
+                    $to_process[$key] = $done;
+                }
+            }
+
+            // Parse the finished requests before we start getting the new ones
+            foreach ($to_process as $key => $done) {
+                $options = $requests[$key]['options'];
+                if (CURLE_OK !== $done['result']) {
+                    //get error string for handle.
+                    $reason = curl_error($done['handle']);
+                    $exception = new Requests_Exception_Transport_cURL(
+                                    $reason,
+                                    Requests_Exception_Transport_cURL::EASY,
+                                    $done['handle'],
+                                    $done['result']
+                                );
+                    $responses[$key] = $exception;
+                    $options['hooks']->dispatch('transport.internal.parse_error', array(&$responses[$key], $requests[$key]));
+                }
+                else {
+                    $responses[$key] = $subrequests[$key]->process_response($subrequests[$key]->response_data, $options);
+
+                    $options['hooks']->dispatch('transport.internal.parse_response', array(&$responses[$key], $requests[$key]));
+                }
+
+                curl_multi_remove_handle($multihandle, $done['handle']);
+                curl_close($done['handle']);
+
+                if (!is_string($responses[$key])) {
+                    $options['hooks']->dispatch('multiple.request.complete', array(&$responses[$key], $key));
+                }
+                $completed++;
+            }
+        }
+        while ($active || $completed < count($subrequests));
+
+        $request['options']['hooks']->dispatch('curl.after_multi_exec', array(&$multihandle));
+
+        curl_multi_close($multihandle);
+
+        return $responses;
+    }
+
+    /**
+     * Get the cURL handle for use in a multi-request
+     *
+     * @param string $url URL to request
+     * @param array $headers Associative array of request headers
+     * @param string|array $data Data to send either as the POST body, or as parameters in the URL for a GET/HEAD
+     * @param array $options Request options, see {@see Requests::response()} for documentation
+     * @return resource Subrequest's cURL handle
+     */
+    public function &get_subrequest_handle($url, $headers, $data, $options) {
+        $this->setup_handle($url, $headers, $data, $options);
+
+        if ($options['filename'] !== false) {
+            $this->stream_handle = fopen($options['filename'], 'wb');
+        }
+
+        $this->response_data = '';
+        $this->response_bytes = 0;
+        $this->response_byte_limit = false;
+        if ($options['max_bytes'] !== false) {
+            $this->response_byte_limit = $options['max_bytes'];
+        }
+        $this->hooks = $options['hooks'];
+
+        return $this->handle;
+    }
+
+    /**
+     * Setup the cURL handle for the given data
+     *
+     * @param string $url URL to request
+     * @param array $headers Associative array of request headers
+     * @param string|array $data Data to send either as the POST body, or as parameters in the URL for a GET/HEAD
+     * @param array $options Request options, see {@see Requests::response()} for documentation
+     */
+    protected function setup_handle($url, $headers, $data, $options) {
+        $options['hooks']->dispatch('curl.before_request', array(&$this->handle));
+
+        // Force closing the connection for old versions of cURL (<7.22).
+        if ( ! isset( $headers['Connection'] ) ) {
+            $headers['Connection'] = 'close';
+        }
+
+        $headers = Requests::flatten($headers);
+
+        if (!empty($data)) {
+            $data_format = $options['data_format'];
+
+            if ($data_format === 'query') {
+                $url = self::format_get($url, $data);
+                $data = '';
+            }
+            elseif (!is_string($data)) {
+                $data = http_build_query($data, null, '&');
+            }
+        }
+
+        switch ($options['type']) {
+            case Requests::POST:
+                curl_setopt($this->handle, CURLOPT_POST, true);
+                curl_setopt($this->handle, CURLOPT_POSTFIELDS, $data);
+                break;
+            case Requests::HEAD:
+                curl_setopt($this->handle, CURLOPT_CUSTOMREQUEST, $options['type']);
+                curl_setopt($this->handle, CURLOPT_NOBODY, true);
+                break;
+            case Requests::TRACE:
+                curl_setopt($this->handle, CURLOPT_CUSTOMREQUEST, $options['type']);
+                break;
+            case Requests::PATCH:
+            case Requests::PUT:
+            case Requests::DELETE:
+            case Requests::OPTIONS:
+            default:
+                curl_setopt($this->handle, CURLOPT_CUSTOMREQUEST, $options['type']);
+                if (!empty($data)) {
+                    curl_setopt($this->handle, CURLOPT_POSTFIELDS, $data);
+                }
+        }
+
+        // cURL requires a minimum timeout of 1 second when using the system
+        // DNS resolver, as it uses `alarm()`, which is second resolution only.
+        // There's no way to detect which DNS resolver is being used from our
+        // end, so we need to round up regardless of the supplied timeout.
+        //
+        // https://github.com/curl/curl/blob/4f45240bc84a9aa648c8f7243be7b79e9f9323a5/lib/hostip.c#L606-L609
+        $timeout = max($options['timeout'], 1);
+
+        if (is_int($timeout) || $this->version < self::CURL_7_16_2) {
+            curl_setopt($this->handle, CURLOPT_TIMEOUT, ceil($timeout));
+        }
+        else {
+            curl_setopt($this->handle, CURLOPT_TIMEOUT_MS, round($timeout * 1000));
+        }
+
+        if (is_int($options['connect_timeout']) || $this->version < self::CURL_7_16_2) {
+            curl_setopt($this->handle, CURLOPT_CONNECTTIMEOUT, ceil($options['connect_timeout']));
+        }
+        else {
+            curl_setopt($this->handle, CURLOPT_CONNECTTIMEOUT_MS, round($options['connect_timeout'] * 1000));
+        }
+        curl_setopt($this->handle, CURLOPT_URL, $url);
+        curl_setopt($this->handle, CURLOPT_REFERER, $url);
+        curl_setopt($this->handle, CURLOPT_USERAGENT, $options['useragent']);
+        if (!empty($headers)) {
+            curl_setopt($this->handle, CURLOPT_HTTPHEADER, $headers);
+        }
+        if ($options['protocol_version'] === 1.1) {
+            curl_setopt($this->handle, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1);
+        }
+        else {
+            curl_setopt($this->handle, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_0);
+        }
+
+        if (true === $options['blocking']) {
+            curl_setopt($this->handle, CURLOPT_HEADERFUNCTION, array(&$this, 'stream_headers'));
+            curl_setopt($this->handle, CURLOPT_WRITEFUNCTION, array(&$this, 'stream_body'));
+            curl_setopt($this->handle, CURLOPT_BUFFERSIZE, Requests::BUFFER_SIZE);
+        }
+    }
+
+    /**
+     * Process a response
+     *
+     * @param string $response Response data from the body
+     * @param array $options Request options
+     * @return string HTTP response data including headers
+     */
+    public function process_response($response, $options) {
+        if ($options['blocking'] === false) {
+            $fake_headers = '';
+            $options['hooks']->dispatch('curl.after_request', array(&$fake_headers));
+            return false;
+        }
+        if ($options['filename'] !== false) {
+            fclose($this->stream_handle);
+            $this->headers = trim($this->headers);
+        }
+        else {
+            $this->headers .= $response;
+        }
+
+        if (curl_errno($this->handle)) {
+            $error = sprintf(
+                'cURL error %s: %s',
+                curl_errno($this->handle),
+                curl_error($this->handle)
+            );
+            throw new Requests_Exception($error, 'curlerror', $this->handle);
+        }
+        $this->info = curl_getinfo($this->handle);
+
+        $options['hooks']->dispatch('curl.after_request', array(&$this->headers, &$this->info));
+        return $this->headers;
+    }
+
+    /**
+     * Collect the headers as they are received
+     *
+     * @param resource $handle cURL resource
+     * @param string $headers Header string
+     * @return integer Length of provided header
+     */
+    public function stream_headers($handle, $headers) {
+        // Why do we do this? cURL will send both the final response and any
+        // interim responses, such as a 100 Continue. We don't need that.
+        // (We may want to keep this somewhere just in case)
+        if ($this->done_headers) {
+            $this->headers = '';
+            $this->done_headers = false;
+        }
+        $this->headers .= $headers;
+
+        if ($headers === "\r\n") {
+            $this->done_headers = true;
+        }
+        return strlen($headers);
+    }
+
+    /**
+     * Collect data as it's received
+     *
+     * @since 1.6.1
+     *
+     * @param resource $handle cURL resource
+     * @param string $data Body data
+     * @return integer Length of provided data
+     */
+    public function stream_body($handle, $data) {
+        $this->hooks->dispatch('request.progress', array($data, $this->response_bytes, $this->response_byte_limit));
+        $data_length = strlen($data);
+
+        // Are we limiting the response size?
+        if ($this->response_byte_limit) {
+            if ($this->response_bytes === $this->response_byte_limit) {
+                // Already at maximum, move on
+                return $data_length;
+            }
+
+            if (($this->response_bytes + $data_length) > $this->response_byte_limit) {
+                // Limit the length
+                $limited_length = ($this->response_byte_limit - $this->response_bytes);
+                $data = substr($data, 0, $limited_length);
+            }
+        }
+
+        if ($this->stream_handle) {
+            fwrite($this->stream_handle, $data);
+        }
+        else {
+            $this->response_data .= $data;
+        }
+
+        $this->response_bytes += strlen($data);
+        return $data_length;
+    }
+
+    /**
+     * Format a URL given GET data
+     *
+     * @param string $url
+     * @param array|object $data Data to build query using, see {@see https://secure.php.net/http_build_query}
+     * @return string URL with data
+     */
+    protected static function format_get($url, $data) {
+        if (!empty($data)) {
+            $url_parts = parse_url($url);
+            if (empty($url_parts['query'])) {
+                $query = $url_parts['query'] = '';
+            }
+            else {
+                $query = $url_parts['query'];
+            }
+
+            $query .= '&' . http_build_query($data, null, '&');
+            $query = trim($query, '&');
+
+            if (empty($url_parts['query'])) {
+                $url .= '?' . $query;
+            }
+            else {
+                $url = str_replace($url_parts['query'], $query, $url);
+            }
+        }
+        return $url;
+    }
+
+    /**
+     * Whether this transport is valid
+     *
+     * @codeCoverageIgnore
+     * @return boolean True if the transport is valid, false otherwise.
+     */
+    public static function test($capabilities = array()) {
+        if (!function_exists('curl_init') || !function_exists('curl_exec')) {
+            return false;
+        }
+
+        // If needed, check that our installed curl version supports SSL
+        if (isset($capabilities['ssl']) && $capabilities['ssl']) {
+            $curl_version = curl_version();
+            if (!(CURL_VERSION_SSL & $curl_version['features'])) {
+                return false;
+            }
+        }
+
+        return true;
+    }
 }

plugin/buycourses/src/Requests/Transport/fsockopen.php

Indentation +428 added lines, -428 removed lines

@@ -13,432 +13,432 @@
  * @subpackage Transport
  */
 class Requests_Transport_fsockopen implements Requests_Transport {
-	/**
-	 * Second to microsecond conversion
-	 *
-	 * @var integer
-	 */
-	const SECOND_IN_MICROSECONDS = 1000000;
-
-	/**
-	 * Raw HTTP data
-	 *
-	 * @var string
-	 */
-	public $headers = '';
-
-	/**
-	 * Stream metadata
-	 *
-	 * @var array Associative array of properties, see {@see https://secure.php.net/stream_get_meta_data}
-	 */
-	public $info;
-
-	/**
-	 * What's the maximum number of bytes we should keep?
-	 *
-	 * @var int|bool Byte count, or false if no limit.
-	 */
-	protected $max_bytes = false;
-
-	protected $connect_error = '';
-
-	/**
-	 * Perform a request
-	 *
-	 * @throws Requests_Exception On failure to connect to socket (`fsockopenerror`)
-	 * @throws Requests_Exception On socket timeout (`timeout`)
-	 *
-	 * @param string $url URL to request
-	 * @param array $headers Associative array of request headers
-	 * @param string|array $data Data to send either as the POST body, or as parameters in the URL for a GET/HEAD
-	 * @param array $options Request options, see {@see Requests::response()} for documentation
-	 * @return string Raw HTTP result
-	 */
-	public function request($url, $headers = array(), $data = array(), $options = array()) {
-		$options['hooks']->dispatch('fsockopen.before_request');
-
-		$url_parts = parse_url($url);
-		if (empty($url_parts)) {
-			throw new Requests_Exception('Invalid URL.', 'invalidurl', $url);
-		}
-		$host = $url_parts['host'];
-		$context = stream_context_create();
-		$verifyname = false;
-		$case_insensitive_headers = new Requests_Utility_CaseInsensitiveDictionary($headers);
-
-		// HTTPS support
-		if (isset($url_parts['scheme']) && strtolower($url_parts['scheme']) === 'https') {
-			$remote_socket = 'ssl://' . $host;
-			if (!isset($url_parts['port'])) {
-				$url_parts['port'] = 443;
-			}
-
-			$context_options = array(
-				'verify_peer' => true,
-				// 'CN_match' => $host,
-				'capture_peer_cert' => true
-			);
-			$verifyname = true;
-
-			// SNI, if enabled (OpenSSL >=0.9.8j)
-			if (defined('OPENSSL_TLSEXT_SERVER_NAME') && OPENSSL_TLSEXT_SERVER_NAME) {
-				$context_options['SNI_enabled'] = true;
-				if (isset($options['verifyname']) && $options['verifyname'] === false) {
-					$context_options['SNI_enabled'] = false;
-				}
-			}
-
-			if (isset($options['verify'])) {
-				if ($options['verify'] === false) {
-					$context_options['verify_peer'] = false;
-				}
-				elseif (is_string($options['verify'])) {
-					$context_options['cafile'] = $options['verify'];
-				}
-			}
-
-			if (isset($options['verifyname']) && $options['verifyname'] === false) {
-				$context_options['verify_peer_name'] = false;
-				$verifyname = false;
-			}
-
-			stream_context_set_option($context, array('ssl' => $context_options));
-		}
-		else {
-			$remote_socket = 'tcp://' . $host;
-		}
-
-		$this->max_bytes = $options['max_bytes'];
-
-		if (!isset($url_parts['port'])) {
-			$url_parts['port'] = 80;
-		}
-		$remote_socket .= ':' . $url_parts['port'];
-
-		set_error_handler(array($this, 'connect_error_handler'), E_WARNING | E_NOTICE);
-
-		$options['hooks']->dispatch('fsockopen.remote_socket', array(&$remote_socket));
-
-		$socket = stream_socket_client($remote_socket, $errno, $errstr, ceil($options['connect_timeout']), STREAM_CLIENT_CONNECT, $context);
-
-		restore_error_handler();
-
-		if ($verifyname && !$this->verify_certificate_from_context($host, $context)) {
-			throw new Requests_Exception('SSL certificate did not match the requested domain name', 'ssl.no_match');
-		}
-
-		if (!$socket) {
-			if ($errno === 0) {
-				// Connection issue
-				throw new Requests_Exception(rtrim($this->connect_error), 'fsockopen.connect_error');
-			}
-
-			throw new Requests_Exception($errstr, 'fsockopenerror', null, $errno);
-		}
-
-		$data_format = $options['data_format'];
-
-		if ($data_format === 'query') {
-			$path = self::format_get($url_parts, $data);
-			$data = '';
-		}
-		else {
-			$path = self::format_get($url_parts, array());
-		}
-
-		$options['hooks']->dispatch('fsockopen.remote_host_path', array(&$path, $url));
-
-		$request_body = '';
-		$out = sprintf("%s %s HTTP/%.1f\r\n", $options['type'], $path, $options['protocol_version']);
-
-		if ($options['type'] !== Requests::TRACE) {
-			if (is_array($data)) {
-				$request_body = http_build_query($data, null, '&');
-			}
-			else {
-				$request_body = $data;
-			}
-
-			if (!empty($data)) {
-				if (!isset($case_insensitive_headers['Content-Length'])) {
-					$headers['Content-Length'] = strlen($request_body);
-				}
-
-				if (!isset($case_insensitive_headers['Content-Type'])) {
-					$headers['Content-Type'] = 'application/x-www-form-urlencoded; charset=UTF-8';
-				}
-			}
-		}
-
-		if (!isset($case_insensitive_headers['Host'])) {
-			$out .= sprintf('Host: %s', $url_parts['host']);
-
-			if (( 'http' === strtolower($url_parts['scheme']) && $url_parts['port'] !== 80 ) || ( 'https' === strtolower($url_parts['scheme']) && $url_parts['port'] !== 443 )) {
-				$out .= ':' . $url_parts['port'];
-			}
-			$out .= "\r\n";
-		}
-
-		if (!isset($case_insensitive_headers['User-Agent'])) {
-			$out .= sprintf("User-Agent: %s\r\n", $options['useragent']);
-		}
-
-		$accept_encoding = $this->accept_encoding();
-		if (!isset($case_insensitive_headers['Accept-Encoding']) && !empty($accept_encoding)) {
-			$out .= sprintf("Accept-Encoding: %s\r\n", $accept_encoding);
-		}
-
-		$headers = Requests::flatten($headers);
-
-		if (!empty($headers)) {
-			$out .= implode($headers, "\r\n") . "\r\n";
-		}
-
-		$options['hooks']->dispatch('fsockopen.after_headers', array(&$out));
-
-		if (substr($out, -2) !== "\r\n") {
-			$out .= "\r\n";
-		}
-
-		if (!isset($case_insensitive_headers['Connection'])) {
-			$out .= "Connection: Close\r\n";
-		}
-
-		$out .= "\r\n" . $request_body;
-
-		$options['hooks']->dispatch('fsockopen.before_send', array(&$out));
-
-		fwrite($socket, $out);
-		$options['hooks']->dispatch('fsockopen.after_send', array($out));
-
-		if (!$options['blocking']) {
-			fclose($socket);
-			$fake_headers = '';
-			$options['hooks']->dispatch('fsockopen.after_request', array(&$fake_headers));
-			return '';
-		}
-
-		$timeout_sec = (int) floor($options['timeout']);
-		if ($timeout_sec == $options['timeout']) {
-			$timeout_msec = 0;
-		}
-		else {
-			$timeout_msec = self::SECOND_IN_MICROSECONDS * $options['timeout'] % self::SECOND_IN_MICROSECONDS;
-		}
-		stream_set_timeout($socket, $timeout_sec, $timeout_msec);
-
-		$response = $body = $headers = '';
-		$this->info = stream_get_meta_data($socket);
-		$size = 0;
-		$doingbody = false;
-		$download = false;
-		if ($options['filename']) {
-			$download = fopen($options['filename'], 'wb');
-		}
-
-		while (!feof($socket)) {
-			$this->info = stream_get_meta_data($socket);
-			if ($this->info['timed_out']) {
-				throw new Requests_Exception('fsocket timed out', 'timeout');
-			}
-
-			$block = fread($socket, Requests::BUFFER_SIZE);
-			if (!$doingbody) {
-				$response .= $block;
-				if (strpos($response, "\r\n\r\n")) {
-					list($headers, $block) = explode("\r\n\r\n", $response, 2);
-					$doingbody = true;
-				}
-			}
-
-			// Are we in body mode now?
-			if ($doingbody) {
-				$options['hooks']->dispatch('request.progress', array($block, $size, $this->max_bytes));
-				$data_length = strlen($block);
-				if ($this->max_bytes) {
-					// Have we already hit a limit?
-					if ($size === $this->max_bytes) {
-						continue;
-					}
-					if (($size + $data_length) > $this->max_bytes) {
-						// Limit the length
-						$limited_length = ($this->max_bytes - $size);
-						$block = substr($block, 0, $limited_length);
-					}
-				}
-
-				$size += strlen($block);
-				if ($download) {
-					fwrite($download, $block);
-				}
-				else {
-					$body .= $block;
-				}
-			}
-		}
-		$this->headers = $headers;
-
-		if ($download) {
-			fclose($download);
-		}
-		else {
-			$this->headers .= "\r\n\r\n" . $body;
-		}
-		fclose($socket);
-
-		$options['hooks']->dispatch('fsockopen.after_request', array(&$this->headers, &$this->info));
-		return $this->headers;
-	}
-
-	/**
-	 * Send multiple requests simultaneously
-	 *
-	 * @param array $requests Request data (array of 'url', 'headers', 'data', 'options') as per {@see Requests_Transport::request}
-	 * @param array $options Global options, see {@see Requests::response()} for documentation
-	 * @return array Array of Requests_Response objects (may contain Requests_Exception or string responses as well)
-	 */
-	public function request_multiple($requests, $options) {
-		$responses = array();
-		$class = get_class($this);
-		foreach ($requests as $id => $request) {
-			try {
-				$handler = new $class();
-				$responses[$id] = $handler->request($request['url'], $request['headers'], $request['data'], $request['options']);
-
-				$request['options']['hooks']->dispatch('transport.internal.parse_response', array(&$responses[$id], $request));
-			}
-			catch (Requests_Exception $e) {
-				$responses[$id] = $e;
-			}
-
-			if (!is_string($responses[$id])) {
-				$request['options']['hooks']->dispatch('multiple.request.complete', array(&$responses[$id], $id));
-			}
-		}
-
-		return $responses;
-	}
-
-	/**
-	 * Retrieve the encodings we can accept
-	 *
-	 * @return string Accept-Encoding header value
-	 */
-	protected static function accept_encoding() {
-		$type = array();
-		if (function_exists('gzinflate')) {
-			$type[] = 'deflate;q=1.0';
-		}
-
-		if (function_exists('gzuncompress')) {
-			$type[] = 'compress;q=0.5';
-		}
-
-		$type[] = 'gzip;q=0.5';
-
-		return implode(', ', $type);
-	}
-
-	/**
-	 * Format a URL given GET data
-	 *
-	 * @param array $url_parts
-	 * @param array|object $data Data to build query using, see {@see https://secure.php.net/http_build_query}
-	 * @return string URL with data
-	 */
-	protected static function format_get($url_parts, $data) {
-		if (!empty($data)) {
-			if (empty($url_parts['query'])) {
-				$url_parts['query'] = '';
-			}
-
-			$url_parts['query'] .= '&' . http_build_query($data, null, '&');
-			$url_parts['query'] = trim($url_parts['query'], '&');
-		}
-		if (isset($url_parts['path'])) {
-			if (isset($url_parts['query'])) {
-				$get = $url_parts['path'] . '?' . $url_parts['query'];
-			}
-			else {
-				$get = $url_parts['path'];
-			}
-		}
-		else {
-			$get = '/';
-		}
-		return $get;
-	}
-
-	/**
-	 * Error handler for stream_socket_client()
-	 *
-	 * @param int $errno Error number (e.g. E_WARNING)
-	 * @param string $errstr Error message
-	 */
-	public function connect_error_handler($errno, $errstr) {
-		// Double-check we can handle it
-		if (($errno & E_WARNING) === 0 && ($errno & E_NOTICE) === 0) {
-			// Return false to indicate the default error handler should engage
-			return false;
-		}
-
-		$this->connect_error .= $errstr . "\n";
-		return true;
-	}
-
-	/**
-	 * Verify the certificate against common name and subject alternative names
-	 *
-	 * Unfortunately, PHP doesn't check the certificate against the alternative
-	 * names, leading things like 'https://www.github.com/' to be invalid.
-	 * Instead
-	 *
-	 * @see https://tools.ietf.org/html/rfc2818#section-3.1 RFC2818, Section 3.1
-	 *
-	 * @throws Requests_Exception On failure to connect via TLS (`fsockopen.ssl.connect_error`)
-	 * @throws Requests_Exception On not obtaining a match for the host (`fsockopen.ssl.no_match`)
-	 * @param string $host Host name to verify against
-	 * @param resource $context Stream context
-	 * @return bool
-	 */
-	public function verify_certificate_from_context($host, $context) {
-		$meta = stream_context_get_options($context);
-
-		// If we don't have SSL options, then we couldn't make the connection at
-		// all
-		if (empty($meta) || empty($meta['ssl']) || empty($meta['ssl']['peer_certificate'])) {
-			throw new Requests_Exception(rtrim($this->connect_error), 'ssl.connect_error');
-		}
-
-		$cert = openssl_x509_parse($meta['ssl']['peer_certificate']);
-
-		return Requests_SSL::verify_certificate($host, $cert);
-	}
-
-	/**
-	 * Whether this transport is valid
-	 *
-	 * @codeCoverageIgnore
-	 * @return boolean True if the transport is valid, false otherwise.
-	 */
-	public static function test($capabilities = array()) {
-		if (!function_exists('fsockopen')) {
-			return false;
-		}
-
-		// If needed, check that streams support SSL
-		if (isset($capabilities['ssl']) && $capabilities['ssl']) {
-			if (!extension_loaded('openssl') || !function_exists('openssl_x509_parse')) {
-				return false;
-			}
-
-			// Currently broken, thanks to https://github.com/facebook/hhvm/issues/2156
-			if (defined('HHVM_VERSION')) {
-				return false;
-			}
-		}
-
-		return true;
-	}
+    /**
+     * Second to microsecond conversion
+     *
+     * @var integer
+     */
+    const SECOND_IN_MICROSECONDS = 1000000;
+
+    /**
+     * Raw HTTP data
+     *
+     * @var string
+     */
+    public $headers = '';
+
+    /**
+     * Stream metadata
+     *
+     * @var array Associative array of properties, see {@see https://secure.php.net/stream_get_meta_data}
+     */
+    public $info;
+
+    /**
+     * What's the maximum number of bytes we should keep?
+     *
+     * @var int|bool Byte count, or false if no limit.
+     */
+    protected $max_bytes = false;
+
+    protected $connect_error = '';
+
+    /**
+     * Perform a request
+     *
+     * @throws Requests_Exception On failure to connect to socket (`fsockopenerror`)
+     * @throws Requests_Exception On socket timeout (`timeout`)
+     *
+     * @param string $url URL to request
+     * @param array $headers Associative array of request headers
+     * @param string|array $data Data to send either as the POST body, or as parameters in the URL for a GET/HEAD
+     * @param array $options Request options, see {@see Requests::response()} for documentation
+     * @return string Raw HTTP result
+     */
+    public function request($url, $headers = array(), $data = array(), $options = array()) {
+        $options['hooks']->dispatch('fsockopen.before_request');
+
+        $url_parts = parse_url($url);
+        if (empty($url_parts)) {
+            throw new Requests_Exception('Invalid URL.', 'invalidurl', $url);
+        }
+        $host = $url_parts['host'];
+        $context = stream_context_create();
+        $verifyname = false;
+        $case_insensitive_headers = new Requests_Utility_CaseInsensitiveDictionary($headers);
+
+        // HTTPS support
+        if (isset($url_parts['scheme']) && strtolower($url_parts['scheme']) === 'https') {
+            $remote_socket = 'ssl://' . $host;
+            if (!isset($url_parts['port'])) {
+                $url_parts['port'] = 443;
+            }
+
+            $context_options = array(
+                'verify_peer' => true,
+                // 'CN_match' => $host,
+                'capture_peer_cert' => true
+            );
+            $verifyname = true;
+
+            // SNI, if enabled (OpenSSL >=0.9.8j)
+            if (defined('OPENSSL_TLSEXT_SERVER_NAME') && OPENSSL_TLSEXT_SERVER_NAME) {
+                $context_options['SNI_enabled'] = true;
+                if (isset($options['verifyname']) && $options['verifyname'] === false) {
+                    $context_options['SNI_enabled'] = false;
+                }
+            }
+
+            if (isset($options['verify'])) {
+                if ($options['verify'] === false) {
+                    $context_options['verify_peer'] = false;
+                }
+                elseif (is_string($options['verify'])) {
+                    $context_options['cafile'] = $options['verify'];
+                }
+            }
+
+            if (isset($options['verifyname']) && $options['verifyname'] === false) {
+                $context_options['verify_peer_name'] = false;
+                $verifyname = false;
+            }
+
+            stream_context_set_option($context, array('ssl' => $context_options));
+        }
+        else {
+            $remote_socket = 'tcp://' . $host;
+        }
+
+        $this->max_bytes = $options['max_bytes'];
+
+        if (!isset($url_parts['port'])) {
+            $url_parts['port'] = 80;
+        }
+        $remote_socket .= ':' . $url_parts['port'];
+
+        set_error_handler(array($this, 'connect_error_handler'), E_WARNING | E_NOTICE);
+
+        $options['hooks']->dispatch('fsockopen.remote_socket', array(&$remote_socket));
+
+        $socket = stream_socket_client($remote_socket, $errno, $errstr, ceil($options['connect_timeout']), STREAM_CLIENT_CONNECT, $context);
+
+        restore_error_handler();
+
+        if ($verifyname && !$this->verify_certificate_from_context($host, $context)) {
+            throw new Requests_Exception('SSL certificate did not match the requested domain name', 'ssl.no_match');
+        }
+
+        if (!$socket) {
+            if ($errno === 0) {
+                // Connection issue
+                throw new Requests_Exception(rtrim($this->connect_error), 'fsockopen.connect_error');
+            }
+
+            throw new Requests_Exception($errstr, 'fsockopenerror', null, $errno);
+        }
+
+        $data_format = $options['data_format'];
+
+        if ($data_format === 'query') {
+            $path = self::format_get($url_parts, $data);
+            $data = '';
+        }
+        else {
+            $path = self::format_get($url_parts, array());
+        }
+
+        $options['hooks']->dispatch('fsockopen.remote_host_path', array(&$path, $url));
+
+        $request_body = '';
+        $out = sprintf("%s %s HTTP/%.1f\r\n", $options['type'], $path, $options['protocol_version']);
+
+        if ($options['type'] !== Requests::TRACE) {
+            if (is_array($data)) {
+                $request_body = http_build_query($data, null, '&');
+            }
+            else {
+                $request_body = $data;
+            }
+
+            if (!empty($data)) {
+                if (!isset($case_insensitive_headers['Content-Length'])) {
+                    $headers['Content-Length'] = strlen($request_body);
+                }
+
+                if (!isset($case_insensitive_headers['Content-Type'])) {
+                    $headers['Content-Type'] = 'application/x-www-form-urlencoded; charset=UTF-8';
+                }
+            }
+        }
+
+        if (!isset($case_insensitive_headers['Host'])) {
+            $out .= sprintf('Host: %s', $url_parts['host']);
+
+            if (( 'http' === strtolower($url_parts['scheme']) && $url_parts['port'] !== 80 ) || ( 'https' === strtolower($url_parts['scheme']) && $url_parts['port'] !== 443 )) {
+                $out .= ':' . $url_parts['port'];
+            }
+            $out .= "\r\n";
+        }
+
+        if (!isset($case_insensitive_headers['User-Agent'])) {
+            $out .= sprintf("User-Agent: %s\r\n", $options['useragent']);
+        }
+
+        $accept_encoding = $this->accept_encoding();
+        if (!isset($case_insensitive_headers['Accept-Encoding']) && !empty($accept_encoding)) {
+            $out .= sprintf("Accept-Encoding: %s\r\n", $accept_encoding);
+        }
+
+        $headers = Requests::flatten($headers);
+
+        if (!empty($headers)) {
+            $out .= implode($headers, "\r\n") . "\r\n";
+        }
+
+        $options['hooks']->dispatch('fsockopen.after_headers', array(&$out));
+
+        if (substr($out, -2) !== "\r\n") {
+            $out .= "\r\n";
+        }
+
+        if (!isset($case_insensitive_headers['Connection'])) {
+            $out .= "Connection: Close\r\n";
+        }
+
+        $out .= "\r\n" . $request_body;
+
+        $options['hooks']->dispatch('fsockopen.before_send', array(&$out));
+
+        fwrite($socket, $out);
+        $options['hooks']->dispatch('fsockopen.after_send', array($out));
+
+        if (!$options['blocking']) {
+            fclose($socket);
+            $fake_headers = '';
+            $options['hooks']->dispatch('fsockopen.after_request', array(&$fake_headers));
+            return '';
+        }
+
+        $timeout_sec = (int) floor($options['timeout']);
+        if ($timeout_sec == $options['timeout']) {
+            $timeout_msec = 0;
+        }
+        else {
+            $timeout_msec = self::SECOND_IN_MICROSECONDS * $options['timeout'] % self::SECOND_IN_MICROSECONDS;
+        }
+        stream_set_timeout($socket, $timeout_sec, $timeout_msec);
+
+        $response = $body = $headers = '';
+        $this->info = stream_get_meta_data($socket);
+        $size = 0;
+        $doingbody = false;
+        $download = false;
+        if ($options['filename']) {
+            $download = fopen($options['filename'], 'wb');
+        }
+
+        while (!feof($socket)) {
+            $this->info = stream_get_meta_data($socket);
+            if ($this->info['timed_out']) {
+                throw new Requests_Exception('fsocket timed out', 'timeout');
+            }
+
+            $block = fread($socket, Requests::BUFFER_SIZE);
+            if (!$doingbody) {
+                $response .= $block;
+                if (strpos($response, "\r\n\r\n")) {
+                    list($headers, $block) = explode("\r\n\r\n", $response, 2);
+                    $doingbody = true;
+                }
+            }
+
+            // Are we in body mode now?
+            if ($doingbody) {
+                $options['hooks']->dispatch('request.progress', array($block, $size, $this->max_bytes));
+                $data_length = strlen($block);
+                if ($this->max_bytes) {
+                    // Have we already hit a limit?
+                    if ($size === $this->max_bytes) {
+                        continue;
+                    }
+                    if (($size + $data_length) > $this->max_bytes) {
+                        // Limit the length
+                        $limited_length = ($this->max_bytes - $size);
+                        $block = substr($block, 0, $limited_length);
+                    }
+                }
+
+                $size += strlen($block);
+                if ($download) {
+                    fwrite($download, $block);
+                }
+                else {
+                    $body .= $block;
+                }
+            }
+        }
+        $this->headers = $headers;
+
+        if ($download) {
+            fclose($download);
+        }
+        else {
+            $this->headers .= "\r\n\r\n" . $body;
+        }
+        fclose($socket);
+
+        $options['hooks']->dispatch('fsockopen.after_request', array(&$this->headers, &$this->info));
+        return $this->headers;
+    }
+
+    /**
+     * Send multiple requests simultaneously
+     *
+     * @param array $requests Request data (array of 'url', 'headers', 'data', 'options') as per {@see Requests_Transport::request}
+     * @param array $options Global options, see {@see Requests::response()} for documentation
+     * @return array Array of Requests_Response objects (may contain Requests_Exception or string responses as well)
+     */
+    public function request_multiple($requests, $options) {
+        $responses = array();
+        $class = get_class($this);
+        foreach ($requests as $id => $request) {
+            try {
+                $handler = new $class();
+                $responses[$id] = $handler->request($request['url'], $request['headers'], $request['data'], $request['options']);
+
+                $request['options']['hooks']->dispatch('transport.internal.parse_response', array(&$responses[$id], $request));
+            }
+            catch (Requests_Exception $e) {
+                $responses[$id] = $e;
+            }
+
+            if (!is_string($responses[$id])) {
+                $request['options']['hooks']->dispatch('multiple.request.complete', array(&$responses[$id], $id));
+            }
+        }
+
+        return $responses;
+    }
+
+    /**
+     * Retrieve the encodings we can accept
+     *
+     * @return string Accept-Encoding header value
+     */
+    protected static function accept_encoding() {
+        $type = array();
+        if (function_exists('gzinflate')) {
+            $type[] = 'deflate;q=1.0';
+        }
+
+        if (function_exists('gzuncompress')) {
+            $type[] = 'compress;q=0.5';
+        }
+
+        $type[] = 'gzip;q=0.5';
+
+        return implode(', ', $type);
+    }
+
+    /**
+     * Format a URL given GET data
+     *
+     * @param array $url_parts
+     * @param array|object $data Data to build query using, see {@see https://secure.php.net/http_build_query}
+     * @return string URL with data
+     */
+    protected static function format_get($url_parts, $data) {
+        if (!empty($data)) {
+            if (empty($url_parts['query'])) {
+                $url_parts['query'] = '';
+            }
+
+            $url_parts['query'] .= '&' . http_build_query($data, null, '&');
+            $url_parts['query'] = trim($url_parts['query'], '&');
+        }
+        if (isset($url_parts['path'])) {
+            if (isset($url_parts['query'])) {
+                $get = $url_parts['path'] . '?' . $url_parts['query'];
+            }
+            else {
+                $get = $url_parts['path'];
+            }
+        }
+        else {
+            $get = '/';
+        }
+        return $get;
+    }
+
+    /**
+     * Error handler for stream_socket_client()
+     *
+     * @param int $errno Error number (e.g. E_WARNING)
+     * @param string $errstr Error message
+     */
+    public function connect_error_handler($errno, $errstr) {
+        // Double-check we can handle it
+        if (($errno & E_WARNING) === 0 && ($errno & E_NOTICE) === 0) {
+            // Return false to indicate the default error handler should engage
+            return false;
+        }
+
+        $this->connect_error .= $errstr . "\n";
+        return true;
+    }
+
+    /**
+     * Verify the certificate against common name and subject alternative names
+     *
+     * Unfortunately, PHP doesn't check the certificate against the alternative
+     * names, leading things like 'https://www.github.com/' to be invalid.
+     * Instead
+     *
+     * @see https://tools.ietf.org/html/rfc2818#section-3.1 RFC2818, Section 3.1
+     *
+     * @throws Requests_Exception On failure to connect via TLS (`fsockopen.ssl.connect_error`)
+     * @throws Requests_Exception On not obtaining a match for the host (`fsockopen.ssl.no_match`)
+     * @param string $host Host name to verify against
+     * @param resource $context Stream context
+     * @return bool
+     */
+    public function verify_certificate_from_context($host, $context) {
+        $meta = stream_context_get_options($context);
+
+        // If we don't have SSL options, then we couldn't make the connection at
+        // all
+        if (empty($meta) || empty($meta['ssl']) || empty($meta['ssl']['peer_certificate'])) {
+            throw new Requests_Exception(rtrim($this->connect_error), 'ssl.connect_error');
+        }
+
+        $cert = openssl_x509_parse($meta['ssl']['peer_certificate']);
+
+        return Requests_SSL::verify_certificate($host, $cert);
+    }
+
+    /**
+     * Whether this transport is valid
+     *
+     * @codeCoverageIgnore
+     * @return boolean True if the transport is valid, false otherwise.
+     */
+    public static function test($capabilities = array()) {
+        if (!function_exists('fsockopen')) {
+            return false;
+        }
+
+        // If needed, check that streams support SSL
+        if (isset($capabilities['ssl']) && $capabilities['ssl']) {
+            if (!extension_loaded('openssl') || !function_exists('openssl_x509_parse')) {
+                return false;
+            }
+
+            // Currently broken, thanks to https://github.com/facebook/hhvm/issues/2156
+            if (defined('HHVM_VERSION')) {
+                return false;
+            }
+        }
+
+        return true;
+    }
 }