codysnider / tt-rss

plugins/af_comics/filters/af_comics_dilbert.php

Indentation +51 added lines, -51 removed lines

@@ -2,73 +2,73 @@
 
 class Af_Comics_Dilbert extends Af_ComicFilter {
 
-	public function supported() {
-		return array("Dilbert");
-	}
+    public function supported() {
+        return array("Dilbert");
+    }
 
-	public function process(&$article) {
-		if (strpos($article["link"], "dilbert.com") !== false ||
-			strpos($article["link"], "/DilbertDailyStrip") !== false) {
+    public function process(&$article) {
+        if (strpos($article["link"], "dilbert.com") !== false ||
+            strpos($article["link"], "/DilbertDailyStrip") !== false) {
 
-				$res = fetch_file_contents($article["link"], false, false, false,
-					 false, false, 0,
-					 "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:50.0) Gecko/20100101 Firefox/50.0");
+                $res = fetch_file_contents($article["link"], false, false, false,
+                        false, false, 0,
+                        "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:50.0) Gecko/20100101 Firefox/50.0");
 
-				global $fetch_last_error_content;
+                global $fetch_last_error_content;
 
-				if (!$res && $fetch_last_error_content) {
-									$res = $fetch_last_error_content;
-				}
+                if (!$res && $fetch_last_error_content) {
+                                    $res = $fetch_last_error_content;
+                }
 
-				$doc = new DOMDocument();
+                $doc = new DOMDocument();
 
-				if (@$doc->loadHTML($res)) {
-					$xpath = new DOMXPath($doc);
+                if (@$doc->loadHTML($res)) {
+                    $xpath = new DOMXPath($doc);
 
-					// Get the image container
-					$basenode = $xpath->query('(//div[@class="img-comic-container"]/a[@class="img-comic-link"])')->item(0);
+                    // Get the image container
+                    $basenode = $xpath->query('(//div[@class="img-comic-container"]/a[@class="img-comic-link"])')->item(0);
 
-					// Get the comic title
-					$comic_title = $xpath->query('(//span[@class="comic-title-name"])')->item(0)->textContent;
+                    // Get the comic title
+                    $comic_title = $xpath->query('(//span[@class="comic-title-name"])')->item(0)->textContent;
 
-					// Get tags from the article
-					$matches = $xpath->query('(//p[contains(@class, "comic-tags")][1]//a)');
-					$tags = array();
+                    // Get tags from the article
+                    $matches = $xpath->query('(//p[contains(@class, "comic-tags")][1]//a)');
+                    $tags = array();
 
-					foreach ($matches as $tag) {
-						// Only strings starting with a number sign are considered tags
-						if (substr($tag->textContent, 0, 1) == '#') {
-							$tags[] = mb_strtolower(substr($tag->textContent, 1), 'utf-8');
-						}
-					}
+                    foreach ($matches as $tag) {
+                        // Only strings starting with a number sign are considered tags
+                        if (substr($tag->textContent, 0, 1) == '#') {
+                            $tags[] = mb_strtolower(substr($tag->textContent, 1), 'utf-8');
+                        }
+                    }
 
-					// Get the current comics transcript and set it
-					// as the title so it will be visible on mousover
-					$transcript = $xpath->query('(//div[starts-with(@id, "js-toggle-transcript-")]//p)')->item(0);
-					if ($transcript) {
-						$basenode->setAttribute("title", $transcript->textContent);
-					}
+                    // Get the current comics transcript and set it
+                    // as the title so it will be visible on mousover
+                    $transcript = $xpath->query('(//div[starts-with(@id, "js-toggle-transcript-")]//p)')->item(0);
+                    if ($transcript) {
+                        $basenode->setAttribute("title", $transcript->textContent);
+                    }
 
-					if ($basenode) {
-						$article["content"] = $doc->saveHTML($basenode);
-					}
+                    if ($basenode) {
+                        $article["content"] = $doc->saveHTML($basenode);
+                    }
 
-					// Add comic title to article type if not empty (mostly Sunday strips)
-					if ($comic_title) {
-						$article["title"] = $article["title"]." - ".$comic_title;
-					}
+                    // Add comic title to article type if not empty (mostly Sunday strips)
+                    if ($comic_title) {
+                        $article["title"] = $article["title"]." - ".$comic_title;
+                    }
 
-					if (!empty($tags)) {
-						// Ignore existing tags and just replace them all
-						$article["tags"] = array_unique($tags);
-					}
+                    if (!empty($tags)) {
+                        // Ignore existing tags and just replace them all
+                        $article["tags"] = array_unique($tags);
+                    }
 
-				}
+                }
 
-			return true;
-		}
+            return true;
+        }
 
-		return false;
-	}
+        return false;
+    }
 }
 ?>

plugins/af_comics/filters/af_comics_tfd.php

Indentation +24 added lines, -24 removed lines

@@ -1,34 +1,34 @@
 <?php
 class Af_Comics_Tfd extends Af_ComicFilter {
 
-	public function supported() {
-		return array("Toothpaste For Dinner", "Married to the Sea");
-	}
+    public function supported() {
+        return array("Toothpaste For Dinner", "Married to the Sea");
+    }
 
-	public function process(&$article) {
-		if (strpos($article["link"], "toothpastefordinner.com") !== false ||
-		    strpos($article["link"], "marriedtothesea.com") !== false) {
-			$res = fetch_file_contents($article["link"], false, false, false,
-				false, false, 0,
-				"Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.1; WOW64; Trident/6.0)");
+    public function process(&$article) {
+        if (strpos($article["link"], "toothpastefordinner.com") !== false ||
+            strpos($article["link"], "marriedtothesea.com") !== false) {
+            $res = fetch_file_contents($article["link"], false, false, false,
+                false, false, 0,
+                "Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.1; WOW64; Trident/6.0)");
 
-			if (!$res) {
-			    return $article;
-			}
+            if (!$res) {
+                return $article;
+            }
 
-			$doc = new DOMDocument();
+            $doc = new DOMDocument();
 
-			if (@$doc->loadHTML(fetch_file_contents($article["link"]))) {
-				$xpath = new DOMXPath($doc);
-				$basenode = $xpath->query('//img[contains(@src, ".gif")]')->item(0);
+            if (@$doc->loadHTML(fetch_file_contents($article["link"]))) {
+                $xpath = new DOMXPath($doc);
+                $basenode = $xpath->query('//img[contains(@src, ".gif")]')->item(0);
 
-				if ($basenode) {
-					$article["content"] = $doc->saveHTML($basenode);
-					return true;
-				}
-			}
-		}
+                if ($basenode) {
+                    $article["content"] = $doc->saveHTML($basenode);
+                    return true;
+                }
+            }
+        }
 
-		return false;
-	}
+        return false;
+    }
 }

plugins/auto_assign_labels/init.php

Indentation +38 added lines, -38 removed lines

@@ -1,57 +1,57 @@
 <?php
 class Auto_Assign_Labels extends Plugin {
 
-	/* @var PluginHost $host */
-	private $host;
+    /* @var PluginHost $host */
+    private $host;
 
-	public function about() {
-		return array(1.0,
-			"Assign labels automatically based on article title, content, and tags",
-			"fox");
-	}
+    public function about() {
+        return array(1.0,
+            "Assign labels automatically based on article title, content, and tags",
+            "fox");
+    }
 
-	public function init($host) {
-		$this->host = $host;
+    public function init($host) {
+        $this->host = $host;
 
-		$host->add_hook($host::HOOK_ARTICLE_FILTER, $this);
-	}
+        $host->add_hook($host::HOOK_ARTICLE_FILTER, $this);
+    }
 
-	public function get_all_labels_filter_format($owner_uid) {
-		$rv = array();
+    public function get_all_labels_filter_format($owner_uid) {
+        $rv = array();
 
-		$sth = $this->pdo->prepare("SELECT id, fg_color, bg_color, caption FROM ttrss_labels2 WHERE owner_uid = ?");
-		$sth->execute([$owner_uid]);
+        $sth = $this->pdo->prepare("SELECT id, fg_color, bg_color, caption FROM ttrss_labels2 WHERE owner_uid = ?");
+        $sth->execute([$owner_uid]);
 
-		while ($line = $sth->fetch()) {
-			array_push($rv, array(Labels::label_to_feed_id($line["id"]),
-				$line["caption"], $line["fg_color"], $line["bg_color"]));
-		}
+        while ($line = $sth->fetch()) {
+            array_push($rv, array(Labels::label_to_feed_id($line["id"]),
+                $line["caption"], $line["fg_color"], $line["bg_color"]));
+        }
 
-		return $rv;
-	}
+        return $rv;
+    }
 
 
-	public function hook_article_filter($article) {
+    public function hook_article_filter($article) {
 
-		$owner_uid = $article["owner_uid"];
-		$labels = $this->get_all_labels_filter_format($owner_uid);
-		$tags_str = join(",", $article["tags"]);
+        $owner_uid = $article["owner_uid"];
+        $labels = $this->get_all_labels_filter_format($owner_uid);
+        $tags_str = join(",", $article["tags"]);
 
-		foreach ($labels as $label) {
-			$caption = preg_quote($label[1], "/");
+        foreach ($labels as $label) {
+            $caption = preg_quote($label[1], "/");
 
-			if ($caption && preg_match("/\b$caption\b/i", "$tags_str ".strip_tags($article["content"])." ".$article["title"])) {
+            if ($caption && preg_match("/\b$caption\b/i", "$tags_str ".strip_tags($article["content"])." ".$article["title"])) {
 
-				if (!RSSUtils::labels_contains_caption($article["labels"], $caption)) {
-					array_push($article["labels"], $label);
-				}
-			}
-		}
+                if (!RSSUtils::labels_contains_caption($article["labels"], $caption)) {
+                    array_push($article["labels"], $label);
+                }
+            }
+        }
 
-		return $article;
-	}
+        return $article;
+    }
 
-	public function api_version() {
-		return 2;
-	}
+    public function api_version() {
+        return 2;
+    }
 }

plugins/toggle_sidebar/init.php

Indentation +19 added lines, -19 removed lines

@@ -1,26 +1,26 @@ 
 <?php
 class Toggle_Sidebar extends Plugin {
 
-	private $host;
+    private $host;
 
-	public function about() {
-		return array(1.0,
-			"Adds a main toolbar button to toggle sidebar",
-			"fox");
-	}
+    public function about() {
+        return array(1.0,
+            "Adds a main toolbar button to toggle sidebar",
+            "fox");
+    }
 
-	public function init($host) {
-		$this->host = $host;
+    public function init($host) {
+        $this->host = $host;
 
-		$host->add_hook($host::HOOK_MAIN_TOOLBAR_BUTTON, $this);
-	}
+        $host->add_hook($host::HOOK_MAIN_TOOLBAR_BUTTON, $this);
+    }
 
-	public function get_js() {
-		return file_get_contents(__DIR__."/init.js");
-	}
+    public function get_js() {
+        return file_get_contents(__DIR__."/init.js");
+    }
 
-	public function hook_main_toolbar_button() {
-		?>
+    public function hook_main_toolbar_button() {
+        ?>
 
 		<button dojoType="dijit.form.Button" onclick="Plugins.Toggle_Sidebar.toggle(this)">
 			<i class="material-icons toggle-sidebar-label"
@@ -28,11 +28,11 @@ 
 		</button>
 
 		<?php
-	}
+    }
 
-	public function api_version() {
-		return 2;
-	}
+    public function api_version() {
+        return 2;
+    }
 
 }
 ?>

plugins/search_sphinx/init.php

Indentation +47 added lines, -47 removed lines

@@ -1,66 +1,66 @@
 <?php
 
 class Search_Sphinx extends Plugin {
-	public function about() {
-		return array(1.0,
-			"Delegate searching for articles to Sphinx (don't forget to set options in config.php)",
-			"hoelzro",
-			true,
-			"https://git.tt-rss.org/fox/tt-rss/wiki/SphinxSearch");
-	}
+    public function about() {
+        return array(1.0,
+            "Delegate searching for articles to Sphinx (don't forget to set options in config.php)",
+            "hoelzro",
+            true,
+            "https://git.tt-rss.org/fox/tt-rss/wiki/SphinxSearch");
+    }
 
-	public function init($host) {
-		$host->add_hook($host::HOOK_SEARCH, $this);
+    public function init($host) {
+        $host->add_hook($host::HOOK_SEARCH, $this);
 
-		// idk if that would work but checking for the class being loaded is somehow not enough
-		if (class_exists("SphinxClient") && !defined('SEARCHD_COMMAND_SEARCH')) {
-			user_error("Your PHP has a separate systemwide Sphinx client installed which conflicts with the client library used by tt-rss. Either remove the system library or disable Sphinx support.");
-		}
+        // idk if that would work but checking for the class being loaded is somehow not enough
+        if (class_exists("SphinxClient") && !defined('SEARCHD_COMMAND_SEARCH')) {
+            user_error("Your PHP has a separate systemwide Sphinx client installed which conflicts with the client library used by tt-rss. Either remove the system library or disable Sphinx support.");
+        }
 
-		require_once __DIR__."/sphinxapi.php";
-	}
+        require_once __DIR__."/sphinxapi.php";
+    }
 
-	public function hook_search($search) {
-		$offset = 0;
-		$limit  = 500;
+    public function hook_search($search) {
+        $offset = 0;
+        $limit  = 500;
 
-		$sphinxClient = new SphinxClient();
+        $sphinxClient = new SphinxClient();
 
-		$sphinxpair = explode(":", SPHINX_SERVER, 2);
+        $sphinxpair = explode(":", SPHINX_SERVER, 2);
 
-		$sphinxClient->SetServer($sphinxpair[0], (int) $sphinxpair[1]);
-		$sphinxClient->SetConnectTimeout(1);
+        $sphinxClient->SetServer($sphinxpair[0], (int) $sphinxpair[1]);
+        $sphinxClient->SetConnectTimeout(1);
 
-		$sphinxClient->SetFieldWeights(array('title' => 70, 'content' => 30,
-			'feed_title' => 20));
+        $sphinxClient->SetFieldWeights(array('title' => 70, 'content' => 30,
+            'feed_title' => 20));
 
-		$sphinxClient->SetMatchMode(SPH_MATCH_EXTENDED2);
-		$sphinxClient->SetRankingMode(SPH_RANK_PROXIMITY_BM25);
-		$sphinxClient->SetLimits($offset, $limit, 1000);
-		$sphinxClient->SetArrayResult(false);
-		$sphinxClient->SetFilter('owner_uid', array($_SESSION['uid']));
+        $sphinxClient->SetMatchMode(SPH_MATCH_EXTENDED2);
+        $sphinxClient->SetRankingMode(SPH_RANK_PROXIMITY_BM25);
+        $sphinxClient->SetLimits($offset, $limit, 1000);
+        $sphinxClient->SetArrayResult(false);
+        $sphinxClient->SetFilter('owner_uid', array($_SESSION['uid']));
 
-		$result = $sphinxClient->Query($search, SPHINX_INDEX);
+        $result = $sphinxClient->Query($search, SPHINX_INDEX);
 
-		$ids = array();
+        $ids = array();
 
-		if (is_array($result['matches'])) {
-			foreach (array_keys($result['matches']) as $int_id) {
-				$ref_id = $result['matches'][$int_id]['attrs']['ref_id'];
-				array_push($ids, $ref_id);
-			}
-		}
+        if (is_array($result['matches'])) {
+            foreach (array_keys($result['matches']) as $int_id) {
+                $ref_id = $result['matches'][$int_id]['attrs']['ref_id'];
+                array_push($ids, $ref_id);
+            }
+        }
 
-		$ids = join(",", $ids);
+        $ids = join(",", $ids);
 
-		if ($ids) {
-					return array("ref_id IN ($ids)", array());
-		} else {
-					return array("ref_id = -1", array());
-		}
-	}
+        if ($ids) {
+                    return array("ref_id IN ($ids)", array());
+        } else {
+                    return array("ref_id = -1", array());
+        }
+    }
 
-	public function api_version() {
-		return 2;
-	}
+    public function api_version() {
+        return 2;
+    }
 }

plugins/search_sphinx/sphinxapi.php

Indentation +1534 added lines, -1534 removed lines

@@ -123,1571 +123,1571 @@
 /// pack 64-bit signed
 function sphPackI64($v)
 {
-	assert(is_numeric($v));
-
-	// x64
-	if (PHP_INT_SIZE >= 8)
-	{
-		$v = (int) $v;
-		return pack("NN", $v >> 32, $v & 0xFFFFFFFF);
-	}
-
-	// x32, int
-	if (is_int($v))
-		return pack("NN", $v < 0 ? -1 : 0, $v);
-
-	// x32, bcmath
-	if (function_exists("bcmul"))
-	{
-		if (bccomp($v, 0) == -1)
-			$v = bcadd("18446744073709551616", $v);
-		$h = bcdiv($v, "4294967296", 0);
-		$l = bcmod($v, "4294967296");
-		return pack("NN", (float) $h, (float) $l); // conversion to float is intentional; int would lose 31st bit
-	}
-
-	// x32, no-bcmath
-	$p = max(0, strlen($v) - 13);
-	$lo = abs((float) substr($v, $p));
-	$hi = abs((float) substr($v, 0, $p));
-
-	$m = $lo + $hi * 1316134912.0; // (10 ^ 13) % (1 << 32) = 1316134912
-	$q = floor($m / 4294967296.0);
-	$l = $m - ($q * 4294967296.0);
-	$h = $hi * 2328.0 + $q; // (10 ^ 13) / (1 << 32) = 2328
-
-	if ($v < 0)
-	{
-		if ($l == 0)
-			$h = 4294967296.0 - $h;
-		else
-		{
-			$h = 4294967295.0 - $h;
-			$l = 4294967296.0 - $l;
-		}
-	}
-	return pack("NN", $h, $l);
+    assert(is_numeric($v));
+
+    // x64
+    if (PHP_INT_SIZE >= 8)
+    {
+        $v = (int) $v;
+        return pack("NN", $v >> 32, $v & 0xFFFFFFFF);
+    }
+
+    // x32, int
+    if (is_int($v))
+        return pack("NN", $v < 0 ? -1 : 0, $v);
+
+    // x32, bcmath
+    if (function_exists("bcmul"))
+    {
+        if (bccomp($v, 0) == -1)
+            $v = bcadd("18446744073709551616", $v);
+        $h = bcdiv($v, "4294967296", 0);
+        $l = bcmod($v, "4294967296");
+        return pack("NN", (float) $h, (float) $l); // conversion to float is intentional; int would lose 31st bit
+    }
+
+    // x32, no-bcmath
+    $p = max(0, strlen($v) - 13);
+    $lo = abs((float) substr($v, $p));
+    $hi = abs((float) substr($v, 0, $p));
+
+    $m = $lo + $hi * 1316134912.0; // (10 ^ 13) % (1 << 32) = 1316134912
+    $q = floor($m / 4294967296.0);
+    $l = $m - ($q * 4294967296.0);
+    $h = $hi * 2328.0 + $q; // (10 ^ 13) / (1 << 32) = 2328
+
+    if ($v < 0)
+    {
+        if ($l == 0)
+            $h = 4294967296.0 - $h;
+        else
+        {
+            $h = 4294967295.0 - $h;
+            $l = 4294967296.0 - $l;
+        }
+    }
+    return pack("NN", $h, $l);
 }
 
 /// pack 64-bit unsigned
 function sphPackU64($v)
 {
-	assert(is_numeric($v));
-
-	// x64
-	if (PHP_INT_SIZE >= 8)
-	{
-		assert($v >= 0);
-
-		// x64, int
-		if (is_int($v))
-			return pack("NN", $v >> 32, $v & 0xFFFFFFFF);
-
-		// x64, bcmath
-		if (function_exists("bcmul"))
-		{
-			$h = bcdiv($v, 4294967296, 0);
-			$l = bcmod($v, 4294967296);
-			return pack("NN", $h, $l);
-		}
-
-		// x64, no-bcmath
-		$p = max(0, strlen($v) - 13);
-		$lo = (int) substr($v, $p);
-		$hi = (int) substr($v, 0, $p);
-
-		$m = $lo + $hi * 1316134912;
-		$l = $m % 4294967296;
-		$h = $hi * 2328 + (int) ($m / 4294967296);
-
-		return pack("NN", $h, $l);
-	}
-
-	// x32, int
-	if (is_int($v))
-		return pack("NN", 0, $v);
-
-	// x32, bcmath
-	if (function_exists("bcmul"))
-	{
-		$h = bcdiv($v, "4294967296", 0);
-		$l = bcmod($v, "4294967296");
-		return pack("NN", (float) $h, (float) $l); // conversion to float is intentional; int would lose 31st bit
-	}
-
-	// x32, no-bcmath
-	$p = max(0, strlen($v) - 13);
-	$lo = (float) substr($v, $p);
-	$hi = (float) substr($v, 0, $p);
-
-	$m = $lo + $hi * 1316134912.0;
-	$q = floor($m / 4294967296.0);
-	$l = $m - ($q * 4294967296.0);
-	$h = $hi * 2328.0 + $q;
-
-	return pack("NN", $h, $l);
+    assert(is_numeric($v));
+
+    // x64
+    if (PHP_INT_SIZE >= 8)
+    {
+        assert($v >= 0);
+
+        // x64, int
+        if (is_int($v))
+            return pack("NN", $v >> 32, $v & 0xFFFFFFFF);
+
+        // x64, bcmath
+        if (function_exists("bcmul"))
+        {
+            $h = bcdiv($v, 4294967296, 0);
+            $l = bcmod($v, 4294967296);
+            return pack("NN", $h, $l);
+        }
+
+        // x64, no-bcmath
+        $p = max(0, strlen($v) - 13);
+        $lo = (int) substr($v, $p);
+        $hi = (int) substr($v, 0, $p);
+
+        $m = $lo + $hi * 1316134912;
+        $l = $m % 4294967296;
+        $h = $hi * 2328 + (int) ($m / 4294967296);
+
+        return pack("NN", $h, $l);
+    }
+
+    // x32, int
+    if (is_int($v))
+        return pack("NN", 0, $v);
+
+    // x32, bcmath
+    if (function_exists("bcmul"))
+    {
+        $h = bcdiv($v, "4294967296", 0);
+        $l = bcmod($v, "4294967296");
+        return pack("NN", (float) $h, (float) $l); // conversion to float is intentional; int would lose 31st bit
+    }
+
+    // x32, no-bcmath
+    $p = max(0, strlen($v) - 13);
+    $lo = (float) substr($v, $p);
+    $hi = (float) substr($v, 0, $p);
+
+    $m = $lo + $hi * 1316134912.0;
+    $q = floor($m / 4294967296.0);
+    $l = $m - ($q * 4294967296.0);
+    $h = $hi * 2328.0 + $q;
+
+    return pack("NN", $h, $l);
 }
 
 // unpack 64-bit unsigned
 function sphUnpackU64($v)
 {
-	list ($hi, $lo) = array_values(unpack("N*N*", $v));
-
-	if (PHP_INT_SIZE >= 8)
-	{
-		if ($hi < 0) $hi += (1 << 32); // because php 5.2.2 to 5.2.5 is totally fucked up again
-		if ($lo < 0) $lo += (1 << 32);
-
-		// x64, int
-		if ($hi <= 2147483647)
-			return ($hi << 32) + $lo;
-
-		// x64, bcmath
-		if (function_exists("bcmul"))
-			return bcadd($lo, bcmul($hi, "4294967296"));
-
-		// x64, no-bcmath
-		$C = 100000;
-		$h = ((int) ($hi / $C) << 32) + (int) ($lo / $C);
-		$l = (($hi % $C) << 32) + ($lo % $C);
-		if ($l > $C)
-		{
-			$h += (int) ($l / $C);
-			$l  = $l % $C;
-		}
-
-		if ($h == 0)
-			return $l;
-		return sprintf("%d%05d", $h, $l);
-	}
-
-	// x32, int
-	if ($hi == 0)
-	{
-		if ($lo > 0)
-			return $lo;
-		return sprintf("%u", $lo);
-	}
-
-	$hi = sprintf("%u", $hi);
-	$lo = sprintf("%u", $lo);
-
-	// x32, bcmath
-	if (function_exists("bcmul"))
-		return bcadd($lo, bcmul($hi, "4294967296"));
-
-	// x32, no-bcmath
-	$hi = (float) $hi;
-	$lo = (float) $lo;
-
-	$q = floor($hi / 10000000.0);
-	$r = $hi - $q * 10000000.0;
-	$m = $lo + $r * 4967296.0;
-	$mq = floor($m / 10000000.0);
-	$l = $m - $mq * 10000000.0;
-	$h = $q * 4294967296.0 + $r * 429.0 + $mq;
-
-	$h = sprintf("%.0f", $h);
-	$l = sprintf("%07.0f", $l);
-	if ($h == "0")
-		return sprintf("%.0f", (float) $l);
-	return $h.$l;
+    list ($hi, $lo) = array_values(unpack("N*N*", $v));
+
+    if (PHP_INT_SIZE >= 8)
+    {
+        if ($hi < 0) $hi += (1 << 32); // because php 5.2.2 to 5.2.5 is totally fucked up again
+        if ($lo < 0) $lo += (1 << 32);
+
+        // x64, int
+        if ($hi <= 2147483647)
+            return ($hi << 32) + $lo;
+
+        // x64, bcmath
+        if (function_exists("bcmul"))
+            return bcadd($lo, bcmul($hi, "4294967296"));
+
+        // x64, no-bcmath
+        $C = 100000;
+        $h = ((int) ($hi / $C) << 32) + (int) ($lo / $C);
+        $l = (($hi % $C) << 32) + ($lo % $C);
+        if ($l > $C)
+        {
+            $h += (int) ($l / $C);
+            $l  = $l % $C;
+        }
+
+        if ($h == 0)
+            return $l;
+        return sprintf("%d%05d", $h, $l);
+    }
+
+    // x32, int
+    if ($hi == 0)
+    {
+        if ($lo > 0)
+            return $lo;
+        return sprintf("%u", $lo);
+    }
+
+    $hi = sprintf("%u", $hi);
+    $lo = sprintf("%u", $lo);
+
+    // x32, bcmath
+    if (function_exists("bcmul"))
+        return bcadd($lo, bcmul($hi, "4294967296"));
+
+    // x32, no-bcmath
+    $hi = (float) $hi;
+    $lo = (float) $lo;
+
+    $q = floor($hi / 10000000.0);
+    $r = $hi - $q * 10000000.0;
+    $m = $lo + $r * 4967296.0;
+    $mq = floor($m / 10000000.0);
+    $l = $m - $mq * 10000000.0;
+    $h = $q * 4294967296.0 + $r * 429.0 + $mq;
+
+    $h = sprintf("%.0f", $h);
+    $l = sprintf("%07.0f", $l);
+    if ($h == "0")
+        return sprintf("%.0f", (float) $l);
+    return $h.$l;
 }
 
 // unpack 64-bit signed
 function sphUnpackI64($v)
 {
-	list ($hi, $lo) = array_values(unpack("N*N*", $v));
-
-	// x64
-	if (PHP_INT_SIZE >= 8)
-	{
-		if ($hi < 0) $hi += (1 << 32); // because php 5.2.2 to 5.2.5 is totally fucked up again
-		if ($lo < 0) $lo += (1 << 32);
-
-		return ($hi << 32) + $lo;
-	}
-
-	// x32, int
-	if ($hi == 0)
-	{
-		if ($lo > 0)
-			return $lo;
-		return sprintf("%u", $lo);
-	}
-	// x32, int
-	elseif ($hi == -1)
-	{
-		if ($lo < 0)
-			return $lo;
-		return sprintf("%.0f", $lo - 4294967296.0);
-	}
-
-	$neg = "";
-	$c = 0;
-	if ($hi < 0)
-	{
-		$hi = ~$hi;
-		$lo = ~$lo;
-		$c = 1;
-		$neg = "-";
-	}
-
-	$hi = sprintf("%u", $hi);
-	$lo = sprintf("%u", $lo);
-
-	// x32, bcmath
-	if (function_exists("bcmul"))
-		return $neg.bcadd(bcadd($lo, bcmul($hi, "4294967296")), $c);
-
-	// x32, no-bcmath
-	$hi = (float) $hi;
-	$lo = (float) $lo;
-
-	$q = floor($hi / 10000000.0);
-	$r = $hi - $q * 10000000.0;
-	$m = $lo + $r * 4967296.0;
-	$mq = floor($m / 10000000.0);
-	$l = $m - $mq * 10000000.0 + $c;
-	$h = $q * 4294967296.0 + $r * 429.0 + $mq;
-	if ($l == 10000000)
-	{
-		$l = 0;
-		$h += 1;
-	}
-
-	$h = sprintf("%.0f", $h);
-	$l = sprintf("%07.0f", $l);
-	if ($h == "0")
-		return $neg.sprintf("%.0f", (float) $l);
-	return $neg.$h.$l;
+    list ($hi, $lo) = array_values(unpack("N*N*", $v));
+
+    // x64
+    if (PHP_INT_SIZE >= 8)
+    {
+        if ($hi < 0) $hi += (1 << 32); // because php 5.2.2 to 5.2.5 is totally fucked up again
+        if ($lo < 0) $lo += (1 << 32);
+
+        return ($hi << 32) + $lo;
+    }
+
+    // x32, int
+    if ($hi == 0)
+    {
+        if ($lo > 0)
+            return $lo;
+        return sprintf("%u", $lo);
+    }
+    // x32, int
+    elseif ($hi == -1)
+    {
+        if ($lo < 0)
+            return $lo;
+        return sprintf("%.0f", $lo - 4294967296.0);
+    }
+
+    $neg = "";
+    $c = 0;
+    if ($hi < 0)
+    {
+        $hi = ~$hi;
+        $lo = ~$lo;
+        $c = 1;
+        $neg = "-";
+    }
+
+    $hi = sprintf("%u", $hi);
+    $lo = sprintf("%u", $lo);
+
+    // x32, bcmath
+    if (function_exists("bcmul"))
+        return $neg.bcadd(bcadd($lo, bcmul($hi, "4294967296")), $c);
+
+    // x32, no-bcmath
+    $hi = (float) $hi;
+    $lo = (float) $lo;
+
+    $q = floor($hi / 10000000.0);
+    $r = $hi - $q * 10000000.0;
+    $m = $lo + $r * 4967296.0;
+    $mq = floor($m / 10000000.0);
+    $l = $m - $mq * 10000000.0 + $c;
+    $h = $q * 4294967296.0 + $r * 429.0 + $mq;
+    if ($l == 10000000)
+    {
+        $l = 0;
+        $h += 1;
+    }
+
+    $h = sprintf("%.0f", $h);
+    $l = sprintf("%07.0f", $l);
+    if ($h == "0")
+        return $neg.sprintf("%.0f", (float) $l);
+    return $neg.$h.$l;
 }
 
 
 function sphFixUint($value)
 {
-	if (PHP_INT_SIZE >= 8)
-	{
-		// x64 route, workaround broken unpack() in 5.2.2+
-		if ($value < 0) $value += (1 << 32);
-		return $value;
-	}
-	else
-	{
-		// x32 route, workaround php signed/unsigned braindamage
-		return sprintf("%u", $value);
-	}
+    if (PHP_INT_SIZE >= 8)
+    {
+        // x64 route, workaround broken unpack() in 5.2.2+
+        if ($value < 0) $value += (1 << 32);
+        return $value;
+    }
+    else
+    {
+        // x32 route, workaround php signed/unsigned braindamage
+        return sprintf("%u", $value);
+    }
 }
 
 
 /// sphinx searchd client class
 class SphinxClient
 {
-	var $_host; ///< searchd host (default is "localhost")
-	var $_port; ///< searchd port (default is 9312)
-	var $_offset; ///< how many records to seek from result-set start (default is 0)
-	var $_limit; ///< how many records to return from result-set starting at offset (default is 20)
-	var $_mode; ///< query matching mode (default is SPH_MATCH_ALL)
-	var $_weights; ///< per-field weights (default is 1 for all fields)
-	var $_sort; ///< match sorting mode (default is SPH_SORT_RELEVANCE)
-	var $_sortby; ///< attribute to sort by (defualt is "")
-	var $_min_id; ///< min ID to match (default is 0, which means no limit)
-	var $_max_id; ///< max ID to match (default is 0, which means no limit)
-	var $_filters; ///< search filters
-	var $_groupby; ///< group-by attribute name
-	var $_groupfunc; ///< group-by function (to pre-process group-by attribute value with)
-	var $_groupsort; ///< group-by sorting clause (to sort groups in result set with)
-	var $_groupdistinct; ///< group-by count-distinct attribute
-	var $_maxmatches; ///< max matches to retrieve
-	var $_cutoff; ///< cutoff to stop searching at (default is 0)
-	var $_retrycount; ///< distributed retries count
-	var $_retrydelay; ///< distributed retries delay
-	var $_anchor; ///< geographical anchor point
-	var $_indexweights; ///< per-index weights
-	var $_ranker; ///< ranking mode (default is SPH_RANK_PROXIMITY_BM25)
-	var $_maxquerytime; ///< max query time, milliseconds (default is 0, do not limit)
-	var $_fieldweights; ///< per-field-name weights
-	var $_overrides; ///< per-query attribute values overrides
-	var $_select; ///< select-list (attributes or expressions, with optional aliases)
-
-	var $_error; ///< last error message
-	var $_warning; ///< last warning message
-	var $_connerror; ///< connection error vs remote error flag
-
-	var $_reqs; ///< requests array for multi-query
-	var $_mbenc; ///< stored mbstring encoding
-	var $_arrayresult; ///< whether $result["matches"] should be a hash or an array
-	var $_timeout; ///< connect timeout
-
-	/////////////////////////////////////////////////////////////////////////////
-	// common stuff
-	/////////////////////////////////////////////////////////////////////////////
-
-	/// create a new client object and fill defaults
-	public function __construct()
-	{
-		// per-client-object settings
-		$this->_host		= "localhost";
-		$this->_port		= 9312;
-		$this->_path		= false;
-		$this->_socket		= false;
-
-		// per-query settings
-		$this->_offset		= 0;
-		$this->_limit = 20;
-		$this->_mode		= SPH_MATCH_ALL;
-		$this->_weights = array();
-		$this->_sort		= SPH_SORT_RELEVANCE;
-		$this->_sortby		= "";
-		$this->_min_id		= 0;
-		$this->_max_id		= 0;
-		$this->_filters		= array();
-		$this->_groupby		= "";
-		$this->_groupfunc	= SPH_GROUPBY_DAY;
-		$this->_groupsort	= "@group desc";
-		$this->_groupdistinct = "";
-		$this->_maxmatches	= 1000;
-		$this->_cutoff		= 0;
-		$this->_retrycount	= 0;
-		$this->_retrydelay	= 0;
-		$this->_anchor		= array();
-		$this->_indexweights = array();
-		$this->_ranker		= SPH_RANK_PROXIMITY_BM25;
-		$this->_maxquerytime = 0;
-		$this->_fieldweights = array();
-		$this->_overrides = array();
-		$this->_select = "*";
-
-		$this->_error = ""; // per-reply fields (for single-query case)
-		$this->_warning = "";
-		$this->_connerror = false;
-
-		$this->_reqs = array(); // requests storage (for multi-query case)
-		$this->_mbenc = "";
-		$this->_arrayresult = false;
-		$this->_timeout = 0;
-	}
-
-	public function __destruct()
-	{
-		if ($this->_socket !== false)
-			fclose($this->_socket);
-	}
-
-	/// get last error message (string)
-	public function GetLastError()
-	{
-		return $this->_error;
-	}
-
-	/// get last warning message (string)
-	public function GetLastWarning()
-	{
-		return $this->_warning;
-	}
-
-	/// get last error flag (to tell network connection errors from searchd errors or broken responses)
-	public function IsConnectError()
-	{
-		return $this->_connerror;
-	}
-
-	/// set searchd host name (string) and port (integer)
-	public function SetServer($host, $port = 0)
-	{
-		assert(is_string($host));
-		if ($host[0] == '/')
-		{
-			$this->_path = 'unix://'.$host;
-			return;
-		}
-		if (substr($host, 0, 7) == "unix://")
-		{
-			$this->_path = $host;
-			return;
-		}
-
-		assert(is_int($port));
-		$this->_host = $host;
-		$this->_port = $port;
-		$this->_path = '';
-
-	}
-
-	/// set server connection timeout (0 to remove)
-	public function SetConnectTimeout($timeout)
-	{
-		assert(is_numeric($timeout));
-		$this->_timeout = $timeout;
-	}
-
-
-	public function _Send($handle, $data, $length)
-	{
-		if (feof($handle) || fwrite($handle, $data, $length) !== $length)
-		{
-			$this->_error = 'connection unexpectedly closed (timed out?)';
-			$this->_connerror = true;
-			return false;
-		}
-		return true;
-	}
-
-	/////////////////////////////////////////////////////////////////////////////
-
-	/// enter mbstring workaround mode
-	public function _MBPush()
-	{
-		$this->_mbenc = "";
-		if (ini_get("mbstring.func_overload") & 2)
-		{
-			$this->_mbenc = mb_internal_encoding();
-			mb_internal_encoding("latin1");
-		}
+    var $_host; ///< searchd host (default is "localhost")
+    var $_port; ///< searchd port (default is 9312)
+    var $_offset; ///< how many records to seek from result-set start (default is 0)
+    var $_limit; ///< how many records to return from result-set starting at offset (default is 20)
+    var $_mode; ///< query matching mode (default is SPH_MATCH_ALL)
+    var $_weights; ///< per-field weights (default is 1 for all fields)
+    var $_sort; ///< match sorting mode (default is SPH_SORT_RELEVANCE)
+    var $_sortby; ///< attribute to sort by (defualt is "")
+    var $_min_id; ///< min ID to match (default is 0, which means no limit)
+    var $_max_id; ///< max ID to match (default is 0, which means no limit)
+    var $_filters; ///< search filters
+    var $_groupby; ///< group-by attribute name
+    var $_groupfunc; ///< group-by function (to pre-process group-by attribute value with)
+    var $_groupsort; ///< group-by sorting clause (to sort groups in result set with)
+    var $_groupdistinct; ///< group-by count-distinct attribute
+    var $_maxmatches; ///< max matches to retrieve
+    var $_cutoff; ///< cutoff to stop searching at (default is 0)
+    var $_retrycount; ///< distributed retries count
+    var $_retrydelay; ///< distributed retries delay
+    var $_anchor; ///< geographical anchor point
+    var $_indexweights; ///< per-index weights
+    var $_ranker; ///< ranking mode (default is SPH_RANK_PROXIMITY_BM25)
+    var $_maxquerytime; ///< max query time, milliseconds (default is 0, do not limit)
+    var $_fieldweights; ///< per-field-name weights
+    var $_overrides; ///< per-query attribute values overrides
+    var $_select; ///< select-list (attributes or expressions, with optional aliases)
+
+    var $_error; ///< last error message
+    var $_warning; ///< last warning message
+    var $_connerror; ///< connection error vs remote error flag
+
+    var $_reqs; ///< requests array for multi-query
+    var $_mbenc; ///< stored mbstring encoding
+    var $_arrayresult; ///< whether $result["matches"] should be a hash or an array
+    var $_timeout; ///< connect timeout
+
+    /////////////////////////////////////////////////////////////////////////////
+    // common stuff
+    /////////////////////////////////////////////////////////////////////////////
+
+    /// create a new client object and fill defaults
+    public function __construct()
+    {
+        // per-client-object settings
+        $this->_host		= "localhost";
+        $this->_port		= 9312;
+        $this->_path		= false;
+        $this->_socket		= false;
+
+        // per-query settings
+        $this->_offset		= 0;
+        $this->_limit = 20;
+        $this->_mode		= SPH_MATCH_ALL;
+        $this->_weights = array();
+        $this->_sort		= SPH_SORT_RELEVANCE;
+        $this->_sortby		= "";
+        $this->_min_id		= 0;
+        $this->_max_id		= 0;
+        $this->_filters		= array();
+        $this->_groupby		= "";
+        $this->_groupfunc	= SPH_GROUPBY_DAY;
+        $this->_groupsort	= "@group desc";
+        $this->_groupdistinct = "";
+        $this->_maxmatches	= 1000;
+        $this->_cutoff		= 0;
+        $this->_retrycount	= 0;
+        $this->_retrydelay	= 0;
+        $this->_anchor		= array();
+        $this->_indexweights = array();
+        $this->_ranker		= SPH_RANK_PROXIMITY_BM25;
+        $this->_maxquerytime = 0;
+        $this->_fieldweights = array();
+        $this->_overrides = array();
+        $this->_select = "*";
+
+        $this->_error = ""; // per-reply fields (for single-query case)
+        $this->_warning = "";
+        $this->_connerror = false;
+
+        $this->_reqs = array(); // requests storage (for multi-query case)
+        $this->_mbenc = "";
+        $this->_arrayresult = false;
+        $this->_timeout = 0;
+    }
+
+    public function __destruct()
+    {
+        if ($this->_socket !== false)
+            fclose($this->_socket);
+    }
+
+    /// get last error message (string)
+    public function GetLastError()
+    {
+        return $this->_error;
+    }
+
+    /// get last warning message (string)
+    public function GetLastWarning()
+    {
+        return $this->_warning;
+    }
+
+    /// get last error flag (to tell network connection errors from searchd errors or broken responses)
+    public function IsConnectError()
+    {
+        return $this->_connerror;
+    }
+
+    /// set searchd host name (string) and port (integer)
+    public function SetServer($host, $port = 0)
+    {
+        assert(is_string($host));
+        if ($host[0] == '/')
+        {
+            $this->_path = 'unix://'.$host;
+            return;
+        }
+        if (substr($host, 0, 7) == "unix://")
+        {
+            $this->_path = $host;
+            return;
+        }
+
+        assert(is_int($port));
+        $this->_host = $host;
+        $this->_port = $port;
+        $this->_path = '';
+
+    }
+
+    /// set server connection timeout (0 to remove)
+    public function SetConnectTimeout($timeout)
+    {
+        assert(is_numeric($timeout));
+        $this->_timeout = $timeout;
+    }
+
+
+    public function _Send($handle, $data, $length)
+    {
+        if (feof($handle) || fwrite($handle, $data, $length) !== $length)
+        {
+            $this->_error = 'connection unexpectedly closed (timed out?)';
+            $this->_connerror = true;
+            return false;
+        }
+        return true;
+    }
+
+    /////////////////////////////////////////////////////////////////////////////
+
+    /// enter mbstring workaround mode
+    public function _MBPush()
+    {
+        $this->_mbenc = "";
+        if (ini_get("mbstring.func_overload") & 2)
+        {
+            $this->_mbenc = mb_internal_encoding();
+            mb_internal_encoding("latin1");
+        }
+    }
+
+    /// leave mbstring workaround mode
+    public function _MBPop()
+    {
+        if ($this->_mbenc)
+            mb_internal_encoding($this->_mbenc);
+    }
+
+    /// connect to searchd server
+    public function _Connect()
+    {
+        if ($this->_socket !== false)
+        {
+            // we are in persistent connection mode, so we have a socket
+            // however, need to check whether it's still alive
+            if (!@feof($this->_socket))
+                return $this->_socket;
+
+            // force reopen
+            $this->_socket = false;
+        }
+
+        $errno = 0;
+        $errstr = "";
+        $this->_connerror = false;
+
+        if ($this->_path)
+        {
+            $host = $this->_path;
+            $port = 0;
+        }
+        else
+        {
+            $host = $this->_host;
+            $port = $this->_port;
+        }
+
+        if ($this->_timeout <= 0)
+            $fp = @fsockopen($host, $port, $errno, $errstr);
+        else
+            $fp = @fsockopen($host, $port, $errno, $errstr, $this->_timeout);
+
+        if (!$fp)
+        {
+            if ($this->_path)
+                $location = $this->_path;
+            else
+                $location = "{$this->_host}:{$this->_port}";
+
+            $errstr = trim($errstr);
+            $this->_error = "connection to $location failed (errno=$errno, msg=$errstr)";
+            $this->_connerror = true;
+            return false;
+        }
+
+        // send my version
+        // this is a subtle part. we must do it before (!) reading back from searchd.
+        // because otherwise under some conditions (reported on FreeBSD for instance)
+        // TCP stack could throttle write-write-read pattern because of Nagle.
+        if (!$this->_Send($fp, pack("N", 1), 4))
+        {
+            fclose($fp);
+            $this->_error = "failed to send client protocol version";
+            return false;
+        }
+
+        // check version
+        list(,$v) = unpack("N*", fread($fp, 4));
+        $v = (int) $v;
+        if ($v < 1)
+        {
+            fclose($fp);
+            $this->_error = "expected searchd protocol version 1+, got version '$v'";
+            return false;
+        }
+
+        return $fp;
+    }
+
+    /// get and check response packet from searchd server
+    public function _GetResponse($fp, $client_ver)
+    {
+        $response = "";
+        $len = 0;
+
+        $header = fread($fp, 8);
+        if (strlen($header) == 8)
+        {
+            list ($status, $ver, $len) = array_values(unpack("n2a/Nb", $header));
+            $left = $len;
+            while ($left > 0 && !feof($fp))
+            {
+                $chunk = fread($fp, min(8192, $left));
+                if ($chunk)
+                {
+                    $response .= $chunk;
+                    $left -= strlen($chunk);
+                }
+            }
+        }
+        if ($this->_socket === false)
+            fclose($fp);
+
+        // check response
+        $read = strlen($response);
+        if (!$response || $read != $len)
+        {
+            $this->_error = $len
+                ? "failed to read searchd response (status=$status, ver=$ver, len=$len, read=$read)"
+                : "received zero-sized searchd response";
+            return false;
+        }
+
+        // check status
+        if ($status == SEARCHD_WARNING)
+        {
+            list(,$wlen) = unpack("N*", substr($response, 0, 4));
+            $this->_warning = substr($response, 4, $wlen);
+            return substr($response, 4 + $wlen);
+        }
+        if ($status == SEARCHD_ERROR)
+        {
+            $this->_error = "searchd error: ".substr($response, 4);
+            return false;
+        }
+        if ($status == SEARCHD_RETRY)
+        {
+            $this->_error = "temporary searchd error: ".substr($response, 4);
+            return false;
+        }
+        if ($status != SEARCHD_OK)
+        {
+            $this->_error = "unknown status code '$status'";
+            return false;
+        }
+
+        // check version
+        if ($ver < $client_ver)
+        {
+            $this->_warning = sprintf("searchd command v.%d.%d older than client's v.%d.%d, some options might not work",
+                $ver >> 8, $ver & 0xff, $client_ver >> 8, $client_ver & 0xff);
+        }
+
+        return $response;
+    }
+
+    /////////////////////////////////////////////////////////////////////////////
+    // searching
+    /////////////////////////////////////////////////////////////////////////////
+
+    /// set offset and count into result set,
+    /// and optionally set max-matches and cutoff limits
+    public function SetLimits($offset, $limit, $max = 0, $cutoff = 0)
+    {
+        assert(is_int($offset));
+        assert(is_int($limit));
+        assert($offset >= 0);
+        assert($limit > 0);
+        assert($max >= 0);
+        $this->_offset = $offset;
+        $this->_limit = $limit;
+        if ($max > 0)
+            $this->_maxmatches = $max;
+        if ($cutoff > 0)
+            $this->_cutoff = $cutoff;
+    }
+
+    /// set maximum query time, in milliseconds, per-index
+    /// integer, 0 means "do not limit"
+    public function SetMaxQueryTime($max)
+    {
+        assert(is_int($max));
+        assert($max >= 0);
+        $this->_maxquerytime = $max;
+    }
+
+    /// set matching mode
+    public function SetMatchMode($mode)
+    {
+        assert($mode == SPH_MATCH_ALL
+            || $mode == SPH_MATCH_ANY
+            || $mode == SPH_MATCH_PHRASE
+            || $mode == SPH_MATCH_BOOLEAN
+            || $mode == SPH_MATCH_EXTENDED
+            || $mode == SPH_MATCH_FULLSCAN
+            || $mode == SPH_MATCH_EXTENDED2);
+        $this->_mode = $mode;
+    }
+
+    /// set ranking mode
+    public function SetRankingMode($ranker)
+    {
+        assert($ranker >= 0 && $ranker < SPH_RANK_TOTAL);
+        $this->_ranker = $ranker;
+    }
+
+    /// set matches sorting mode
+    public function SetSortMode($mode, $sortby = "")
+    {
+        assert(
+            $mode == SPH_SORT_RELEVANCE ||
+            $mode == SPH_SORT_ATTR_DESC ||
+            $mode == SPH_SORT_ATTR_ASC ||
+            $mode == SPH_SORT_TIME_SEGMENTS ||
+            $mode == SPH_SORT_EXTENDED ||
+            $mode == SPH_SORT_EXPR );
+        assert(is_string($sortby));
+        assert($mode == SPH_SORT_RELEVANCE || strlen($sortby) > 0);
+
+        $this->_sort = $mode;
+        $this->_sortby = $sortby;
+    }
+
+    /// bind per-field weights by order
+    /// DEPRECATED; use SetFieldWeights() instead
+    public function SetWeights($weights)
+    {
+        assert(is_array($weights));
+        foreach ($weights as $weight)
+            assert(is_int($weight));
+
+        $this->_weights = $weights;
+    }
+
+    /// bind per-field weights by name
+    public function SetFieldWeights($weights)
+    {
+        assert(is_array($weights));
+        foreach ($weights as $name=>$weight)
+        {
+            assert(is_string($name));
+            assert(is_int($weight));
+        }
+        $this->_fieldweights = $weights;
+    }
+
+    /// bind per-index weights by name
+    public function SetIndexWeights($weights)
+    {
+        assert(is_array($weights));
+        foreach ($weights as $index=>$weight)
+        {
+            assert(is_string($index));
+            assert(is_int($weight));
+        }
+        $this->_indexweights = $weights;
+    }
+
+    /// set IDs range to match
+    /// only match records if document ID is beetwen $min and $max (inclusive)
+    public function SetIDRange($min, $max)
+    {
+        assert(is_numeric($min));
+        assert(is_numeric($max));
+        assert($min <= $max);
+        $this->_min_id = $min;
+        $this->_max_id = $max;
+    }
+
+    /// set values set filter
+    /// only match records where $attribute value is in given set
+    public function SetFilter($attribute, $values, $exclude = false)
+    {
+        assert(is_string($attribute));
+        assert(is_array($values));
+        assert(count($values));
+
+        if (is_array($values) && count($values))
+        {
+            foreach ($values as $value)
+                assert(is_numeric($value));
+
+            $this->_filters[] = array("type"=>SPH_FILTER_VALUES, "attr"=>$attribute, "exclude"=>$exclude, "values"=>$values);
+        }
+    }
+
+    /// set range filter
+    /// only match records if $attribute value is beetwen $min and $max (inclusive)
+    public function SetFilterRange($attribute, $min, $max, $exclude = false)
+    {
+        assert(is_string($attribute));
+        assert(is_numeric($min));
+        assert(is_numeric($max));
+        assert($min <= $max);
+
+        $this->_filters[] = array("type"=>SPH_FILTER_RANGE, "attr"=>$attribute, "exclude"=>$exclude, "min"=>$min, "max"=>$max);
+    }
+
+    /// set float range filter
+    /// only match records if $attribute value is beetwen $min and $max (inclusive)
+    public function SetFilterFloatRange($attribute, $min, $max, $exclude = false)
+    {
+        assert(is_string($attribute));
+        assert(is_float($min));
+        assert(is_float($max));
+        assert($min <= $max);
+
+        $this->_filters[] = array("type"=>SPH_FILTER_FLOATRANGE, "attr"=>$attribute, "exclude"=>$exclude, "min"=>$min, "max"=>$max);
+    }
+
+    /// setup anchor point for geosphere distance calculations
+    /// required to use @geodist in filters and sorting
+    /// latitude and longitude must be in radians
+    public function SetGeoAnchor($attrlat, $attrlong, $lat, $long)
+    {
+        assert(is_string($attrlat));
+        assert(is_string($attrlong));
+        assert(is_float($lat));
+        assert(is_float($long));
+
+        $this->_anchor = array("attrlat"=>$attrlat, "attrlong"=>$attrlong, "lat"=>$lat, "long"=>$long);
+    }
+
+    /// set grouping attribute and function
+    public function SetGroupBy($attribute, $func, $groupsort = "@group desc")
+    {
+        assert(is_string($attribute));
+        assert(is_string($groupsort));
+        assert($func == SPH_GROUPBY_DAY
+            || $func == SPH_GROUPBY_WEEK
+            || $func == SPH_GROUPBY_MONTH
+            || $func == SPH_GROUPBY_YEAR
+            || $func == SPH_GROUPBY_ATTR
+            || $func == SPH_GROUPBY_ATTRPAIR);
+
+        $this->_groupby = $attribute;
+        $this->_groupfunc = $func;
+        $this->_groupsort = $groupsort;
+    }
+
+    /// set count-distinct attribute for group-by queries
+    public function SetGroupDistinct($attribute)
+    {
+        assert(is_string($attribute));
+        $this->_groupdistinct = $attribute;
+    }
+
+    /// set distributed retries count and delay
+    public function SetRetries($count, $delay = 0)
+    {
+        assert(is_int($count) && $count >= 0);
+        assert(is_int($delay) && $delay >= 0);
+        $this->_retrycount = $count;
+        $this->_retrydelay = $delay;
+    }
+
+    /// set result set format (hash or array; hash by default)
+    /// PHP specific; needed for group-by-MVA result sets that may contain duplicate IDs
+    public function SetArrayResult($arrayresult)
+    {
+        assert(is_bool($arrayresult));
+        $this->_arrayresult = $arrayresult;
+    }
+
+    /// set attribute values override
+    /// there can be only one override per attribute
+    /// $values must be a hash that maps document IDs to attribute values
+    public function SetOverride($attrname, $attrtype, $values)
+    {
+        assert(is_string($attrname));
+        assert(in_array($attrtype, array(SPH_ATTR_INTEGER, SPH_ATTR_TIMESTAMP, SPH_ATTR_BOOL, SPH_ATTR_FLOAT, SPH_ATTR_BIGINT)));
+        assert(is_array($values));
+
+        $this->_overrides[$attrname] = array("attr"=>$attrname, "type"=>$attrtype, "values"=>$values);
+    }
+
+    /// set select-list (attributes or expressions), SQL-like syntax
+    public function SetSelect($select)
+    {
+        assert(is_string($select));
+        $this->_select = $select;
+    }
+
+    //////////////////////////////////////////////////////////////////////////////
+
+    /// clear all filters (for multi-queries)
+    public function ResetFilters()
+    {
+        $this->_filters = array();
+        $this->_anchor = array();
+    }
+
+    /// clear groupby settings (for multi-queries)
+    public function ResetGroupBy()
+    {
+        $this->_groupby = "";
+        $this->_groupfunc	= SPH_GROUPBY_DAY;
+        $this->_groupsort	= "@group desc";
+        $this->_groupdistinct = "";
     }
 
-	/// leave mbstring workaround mode
-	public function _MBPop()
-	{
-		if ($this->_mbenc)
-			mb_internal_encoding($this->_mbenc);
-	}
-
-	/// connect to searchd server
-	public function _Connect()
-	{
-		if ($this->_socket !== false)
-		{
-			// we are in persistent connection mode, so we have a socket
-			// however, need to check whether it's still alive
-			if (!@feof($this->_socket))
-				return $this->_socket;
-
-			// force reopen
-			$this->_socket = false;
-		}
-
-		$errno = 0;
-		$errstr = "";
-		$this->_connerror = false;
-
-		if ($this->_path)
-		{
-			$host = $this->_path;
-			$port = 0;
-		}
-		else
-		{
-			$host = $this->_host;
-			$port = $this->_port;
-		}
-
-		if ($this->_timeout <= 0)
-			$fp = @fsockopen($host, $port, $errno, $errstr);
-		else
-			$fp = @fsockopen($host, $port, $errno, $errstr, $this->_timeout);
-
-		if (!$fp)
-		{
-			if ($this->_path)
-				$location = $this->_path;
-			else
-				$location = "{$this->_host}:{$this->_port}";
-
-			$errstr = trim($errstr);
-			$this->_error = "connection to $location failed (errno=$errno, msg=$errstr)";
-			$this->_connerror = true;
-			return false;
-		}
-
-		// send my version
-		// this is a subtle part. we must do it before (!) reading back from searchd.
-		// because otherwise under some conditions (reported on FreeBSD for instance)
-		// TCP stack could throttle write-write-read pattern because of Nagle.
-		if (!$this->_Send($fp, pack("N", 1), 4))
-		{
-			fclose($fp);
-			$this->_error = "failed to send client protocol version";
-			return false;
-		}
-
-		// check version
-		list(,$v) = unpack("N*", fread($fp, 4));
-		$v = (int) $v;
-		if ($v < 1)
-		{
-			fclose($fp);
-			$this->_error = "expected searchd protocol version 1+, got version '$v'";
-			return false;
-		}
-
-		return $fp;
-	}
-
-	/// get and check response packet from searchd server
-	public function _GetResponse($fp, $client_ver)
-	{
-		$response = "";
-		$len = 0;
-
-		$header = fread($fp, 8);
-		if (strlen($header) == 8)
-		{
-			list ($status, $ver, $len) = array_values(unpack("n2a/Nb", $header));
-			$left = $len;
-			while ($left > 0 && !feof($fp))
-			{
-				$chunk = fread($fp, min(8192, $left));
-				if ($chunk)
-				{
-					$response .= $chunk;
-					$left -= strlen($chunk);
-				}
-			}
-		}
-		if ($this->_socket === false)
-			fclose($fp);
-
-		// check response
-		$read = strlen($response);
-		if (!$response || $read != $len)
-		{
-			$this->_error = $len
-				? "failed to read searchd response (status=$status, ver=$ver, len=$len, read=$read)"
-				: "received zero-sized searchd response";
-			return false;
-		}
-
-		// check status
-		if ($status == SEARCHD_WARNING)
-		{
-			list(,$wlen) = unpack("N*", substr($response, 0, 4));
-			$this->_warning = substr($response, 4, $wlen);
-			return substr($response, 4 + $wlen);
-		}
-		if ($status == SEARCHD_ERROR)
-		{
-			$this->_error = "searchd error: ".substr($response, 4);
-			return false;
-		}
-		if ($status == SEARCHD_RETRY)
-		{
-			$this->_error = "temporary searchd error: ".substr($response, 4);
-			return false;
-		}
-		if ($status != SEARCHD_OK)
-		{
-			$this->_error = "unknown status code '$status'";
-			return false;
-		}
-
-		// check version
-		if ($ver < $client_ver)
-		{
-			$this->_warning = sprintf("searchd command v.%d.%d older than client's v.%d.%d, some options might not work",
-				$ver >> 8, $ver & 0xff, $client_ver >> 8, $client_ver & 0xff);
-		}
-
-		return $response;
-	}
-
-	/////////////////////////////////////////////////////////////////////////////
-	// searching
-	/////////////////////////////////////////////////////////////////////////////
-
-	/// set offset and count into result set,
-	/// and optionally set max-matches and cutoff limits
-	public function SetLimits($offset, $limit, $max = 0, $cutoff = 0)
-	{
-		assert(is_int($offset));
-		assert(is_int($limit));
-		assert($offset >= 0);
-		assert($limit > 0);
-		assert($max >= 0);
-		$this->_offset = $offset;
-		$this->_limit = $limit;
-		if ($max > 0)
-			$this->_maxmatches = $max;
-		if ($cutoff > 0)
-			$this->_cutoff = $cutoff;
-	}
-
-	/// set maximum query time, in milliseconds, per-index
-	/// integer, 0 means "do not limit"
-	public function SetMaxQueryTime($max)
-	{
-		assert(is_int($max));
-		assert($max >= 0);
-		$this->_maxquerytime = $max;
-	}
-
-	/// set matching mode
-	public function SetMatchMode($mode)
-	{
-		assert($mode == SPH_MATCH_ALL
-			|| $mode == SPH_MATCH_ANY
-			|| $mode == SPH_MATCH_PHRASE
-			|| $mode == SPH_MATCH_BOOLEAN
-			|| $mode == SPH_MATCH_EXTENDED
-			|| $mode == SPH_MATCH_FULLSCAN
-			|| $mode == SPH_MATCH_EXTENDED2);
-		$this->_mode = $mode;
-	}
-
-	/// set ranking mode
-	public function SetRankingMode($ranker)
-	{
-		assert($ranker >= 0 && $ranker < SPH_RANK_TOTAL);
-		$this->_ranker = $ranker;
-	}
-
-	/// set matches sorting mode
-	public function SetSortMode($mode, $sortby = "")
-	{
-		assert(
-			$mode == SPH_SORT_RELEVANCE ||
-			$mode == SPH_SORT_ATTR_DESC ||
-			$mode == SPH_SORT_ATTR_ASC ||
-			$mode == SPH_SORT_TIME_SEGMENTS ||
-			$mode == SPH_SORT_EXTENDED ||
-			$mode == SPH_SORT_EXPR );
-		assert(is_string($sortby));
-		assert($mode == SPH_SORT_RELEVANCE || strlen($sortby) > 0);
-
-		$this->_sort = $mode;
-		$this->_sortby = $sortby;
-	}
-
-	/// bind per-field weights by order
-	/// DEPRECATED; use SetFieldWeights() instead
-	public function SetWeights($weights)
-	{
-		assert(is_array($weights));
-		foreach ($weights as $weight)
-			assert(is_int($weight));
-
-		$this->_weights = $weights;
-	}
-
-	/// bind per-field weights by name
-	public function SetFieldWeights($weights)
-	{
-		assert(is_array($weights));
-		foreach ($weights as $name=>$weight)
-		{
-			assert(is_string($name));
-			assert(is_int($weight));
-		}
-		$this->_fieldweights = $weights;
-	}
-
-	/// bind per-index weights by name
-	public function SetIndexWeights($weights)
-	{
-		assert(is_array($weights));
-		foreach ($weights as $index=>$weight)
-		{
-			assert(is_string($index));
-			assert(is_int($weight));
-		}
-		$this->_indexweights = $weights;
-	}
-
-	/// set IDs range to match
-	/// only match records if document ID is beetwen $min and $max (inclusive)
-	public function SetIDRange($min, $max)
-	{
-		assert(is_numeric($min));
-		assert(is_numeric($max));
-		assert($min <= $max);
-		$this->_min_id = $min;
-		$this->_max_id = $max;
-	}
-
-	/// set values set filter
-	/// only match records where $attribute value is in given set
-	public function SetFilter($attribute, $values, $exclude = false)
-	{
-		assert(is_string($attribute));
-		assert(is_array($values));
-		assert(count($values));
-
-		if (is_array($values) && count($values))
-		{
-			foreach ($values as $value)
-				assert(is_numeric($value));
-
-			$this->_filters[] = array("type"=>SPH_FILTER_VALUES, "attr"=>$attribute, "exclude"=>$exclude, "values"=>$values);
-		}
-	}
-
-	/// set range filter
-	/// only match records if $attribute value is beetwen $min and $max (inclusive)
-	public function SetFilterRange($attribute, $min, $max, $exclude = false)
-	{
-		assert(is_string($attribute));
-		assert(is_numeric($min));
-		assert(is_numeric($max));
-		assert($min <= $max);
-
-		$this->_filters[] = array("type"=>SPH_FILTER_RANGE, "attr"=>$attribute, "exclude"=>$exclude, "min"=>$min, "max"=>$max);
-	}
-
-	/// set float range filter
-	/// only match records if $attribute value is beetwen $min and $max (inclusive)
-	public function SetFilterFloatRange($attribute, $min, $max, $exclude = false)
-	{
-		assert(is_string($attribute));
-		assert(is_float($min));
-		assert(is_float($max));
-		assert($min <= $max);
-
-		$this->_filters[] = array("type"=>SPH_FILTER_FLOATRANGE, "attr"=>$attribute, "exclude"=>$exclude, "min"=>$min, "max"=>$max);
-	}
-
-	/// setup anchor point for geosphere distance calculations
-	/// required to use @geodist in filters and sorting
-	/// latitude and longitude must be in radians
-	public function SetGeoAnchor($attrlat, $attrlong, $lat, $long)
-	{
-		assert(is_string($attrlat));
-		assert(is_string($attrlong));
-		assert(is_float($lat));
-		assert(is_float($long));
-
-		$this->_anchor = array("attrlat"=>$attrlat, "attrlong"=>$attrlong, "lat"=>$lat, "long"=>$long);
-	}
-
-	/// set grouping attribute and function
-	public function SetGroupBy($attribute, $func, $groupsort = "@group desc")
-	{
-		assert(is_string($attribute));
-		assert(is_string($groupsort));
-		assert($func == SPH_GROUPBY_DAY
-			|| $func == SPH_GROUPBY_WEEK
-			|| $func == SPH_GROUPBY_MONTH
-			|| $func == SPH_GROUPBY_YEAR
-			|| $func == SPH_GROUPBY_ATTR
-			|| $func == SPH_GROUPBY_ATTRPAIR);
-
-		$this->_groupby = $attribute;
-		$this->_groupfunc = $func;
-		$this->_groupsort = $groupsort;
-	}
-
-	/// set count-distinct attribute for group-by queries
-	public function SetGroupDistinct($attribute)
-	{
-		assert(is_string($attribute));
-		$this->_groupdistinct = $attribute;
-	}
-
-	/// set distributed retries count and delay
-	public function SetRetries($count, $delay = 0)
-	{
-		assert(is_int($count) && $count >= 0);
-		assert(is_int($delay) && $delay >= 0);
-		$this->_retrycount = $count;
-		$this->_retrydelay = $delay;
-	}
-
-	/// set result set format (hash or array; hash by default)
-	/// PHP specific; needed for group-by-MVA result sets that may contain duplicate IDs
-	public function SetArrayResult($arrayresult)
-	{
-		assert(is_bool($arrayresult));
-		$this->_arrayresult = $arrayresult;
-	}
-
-	/// set attribute values override
-	/// there can be only one override per attribute
-	/// $values must be a hash that maps document IDs to attribute values
-	public function SetOverride($attrname, $attrtype, $values)
-	{
-		assert(is_string($attrname));
-		assert(in_array($attrtype, array(SPH_ATTR_INTEGER, SPH_ATTR_TIMESTAMP, SPH_ATTR_BOOL, SPH_ATTR_FLOAT, SPH_ATTR_BIGINT)));
-		assert(is_array($values));
-
-		$this->_overrides[$attrname] = array("attr"=>$attrname, "type"=>$attrtype, "values"=>$values);
-	}
-
-	/// set select-list (attributes or expressions), SQL-like syntax
-	public function SetSelect($select)
-	{
-		assert(is_string($select));
-		$this->_select = $select;
-	}
-
-	//////////////////////////////////////////////////////////////////////////////
-
-	/// clear all filters (for multi-queries)
-	public function ResetFilters()
-	{
-		$this->_filters = array();
-		$this->_anchor = array();
-	}
-
-	/// clear groupby settings (for multi-queries)
-	public function ResetGroupBy()
-	{
-		$this->_groupby = "";
-		$this->_groupfunc	= SPH_GROUPBY_DAY;
-		$this->_groupsort	= "@group desc";
-		$this->_groupdistinct = "";
-	}
-
-	/// clear all attribute value overrides (for multi-queries)
-	public function ResetOverrides()
+    /// clear all attribute value overrides (for multi-queries)
+    public function ResetOverrides()
     {
-    	$this->_overrides = array();
+        $this->_overrides = array();
     }
 
-	//////////////////////////////////////////////////////////////////////////////
-
-	/// connect to searchd server, run given search query through given indexes,
-	/// and return the search results
-	public function Query($query, $index = "*", $comment = "")
-	{
-		assert(empty($this->_reqs));
-
-		$this->AddQuery($query, $index, $comment);
-		$results = $this->RunQueries();
-		$this->_reqs = array(); // just in case it failed too early
-
-		if (!is_array($results))
-			return false; // probably network error; error message should be already filled
-
-		$this->_error = $results[0]["error"];
-		$this->_warning = $results[0]["warning"];
-		if ($results[0]["status"] == SEARCHD_ERROR)
-			return false;
-		else
-			return $results[0];
-	}
-
-	/// helper to pack floats in network byte order
-	public function _PackFloat($f)
-	{
-		$t1 = pack("f", $f); // machine order
-		list(,$t2) = unpack("L*", $t1); // int in machine order
-		return pack("N", $t2);
-	}
-
-	/**
-	 * @SuppressWarnings(unused)
-	 */
-
-	/// add query to multi-query batch
-	/// returns index into results array from RunQueries() call
-	public function AddQuery($query, $index = "*", $comment = "")
-	{
-		// mbstring workaround
-		$this->_MBPush();
-
-		// build request
-		$req = pack("NNNNN", $this->_offset, $this->_limit, $this->_mode, $this->_ranker, $this->_sort); // mode and limits
-		$req .= pack("N", strlen($this->_sortby)).$this->_sortby;
-		$req .= pack("N", strlen($query)).$query; // query itself
-		$req .= pack("N", count($this->_weights)); // weights
-		foreach ($this->_weights as $weight)
-			$req .= pack("N", (int) $weight);
-		$req .= pack("N", strlen($index)).$index; // indexes
-		$req .= pack("N", 1); // id64 range marker
-		$req .= sphPackU64($this->_min_id).sphPackU64($this->_max_id); // id64 range
-
-		// filters
-		$req .= pack("N", count($this->_filters));
-		foreach ($this->_filters as $filter)
-		{
-			$req .= pack("N", strlen($filter["attr"])).$filter["attr"];
-			$req .= pack("N", $filter["type"]);
-			switch ($filter["type"])
-			{
-				case SPH_FILTER_VALUES:
-					$req .= pack("N", count($filter["values"]));
-					foreach ($filter["values"] as $value)
-						$req .= sphPackI64($value);
-					break;
-
-				case SPH_FILTER_RANGE:
-					$req .= sphPackI64($filter["min"]).sphPackI64($filter["max"]);
-					break;
-
-				case SPH_FILTER_FLOATRANGE:
-					$req .= $this->_PackFloat($filter["min"]).$this->_PackFloat($filter["max"]);
-					break;
-
-				default:
-					assert(0 && "internal error: unhandled filter type");
-			}
-			$req .= pack("N", $filter["exclude"]);
-		}
-
-		// group-by clause, max-matches count, group-sort clause, cutoff count
-		$req .= pack("NN", $this->_groupfunc, strlen($this->_groupby)).$this->_groupby;
-		$req .= pack("N", $this->_maxmatches);
-		$req .= pack("N", strlen($this->_groupsort)).$this->_groupsort;
-		$req .= pack("NNN", $this->_cutoff, $this->_retrycount, $this->_retrydelay);
-		$req .= pack("N", strlen($this->_groupdistinct)).$this->_groupdistinct;
-
-		// anchor point
-		if (empty($this->_anchor))
-		{
-			$req .= pack("N", 0);
-		} else
-		{
-			$a = & $this->_anchor;
-			$req .= pack("N", 1);
-			$req .= pack("N", strlen($a["attrlat"])).$a["attrlat"];
-			$req .= pack("N", strlen($a["attrlong"])).$a["attrlong"];
-			$req .= $this->_PackFloat($a["lat"]).$this->_PackFloat($a["long"]);
-		}
-
-		// per-index weights
-		$req .= pack("N", count($this->_indexweights));
-		foreach ($this->_indexweights as $idx=>$weight)
-			$req .= pack("N", strlen($idx)).$idx.pack("N", $weight);
-
-		// max query time
-		$req .= pack("N", $this->_maxquerytime);
-
-		// per-field weights
-		$req .= pack("N", count($this->_fieldweights));
-		foreach ($this->_fieldweights as $field=>$weight)
-			$req .= pack("N", strlen($field)).$field.pack("N", $weight);
-
-		// comment
-		$req .= pack("N", strlen($comment)).$comment;
-
-		// attribute overrides
-		$req .= pack("N", count($this->_overrides));
-		foreach ($this->_overrides as $key => $entry)
-		{
-			$req .= pack("N", strlen($entry["attr"])).$entry["attr"];
-			$req .= pack("NN", $entry["type"], count($entry["values"]));
-			foreach ($entry["values"] as $id=>$val)
-			{
-				assert(is_numeric($id));
-				assert(is_numeric($val));
-
-				$req .= sphPackU64($id);
-				switch ($entry["type"])
-				{
-					case SPH_ATTR_FLOAT:	$req .= $this->_PackFloat($val); break;
-					case SPH_ATTR_BIGINT:	$req .= sphPackI64($val); break;
-					default:				$req .= pack("N", $val); break;
-				}
-			}
-		}
-
-		// select-list
-		$req .= pack("N", strlen($this->_select)).$this->_select;
-
-		// mbstring workaround
-		$this->_MBPop();
-
-		// store request to requests array
-		$this->_reqs[] = $req;
-		return count($this->_reqs) - 1;
-	}
-
-	/// connect to searchd, run queries batch, and return an array of result sets
-	public function RunQueries()
-	{
-		if (empty($this->_reqs))
-		{
-			$this->_error = "no queries defined, issue AddQuery() first";
-			return false;
-		}
-
-		// mbstring workaround
-		$this->_MBPush();
-
-		if (!($fp = $this->_Connect()))
-		{
-			$this->_MBPop();
-			return false;
-		}
-
-		// send query, get response
-		$nreqs = count($this->_reqs);
-		$req = join("", $this->_reqs);
-		$len = 8 + strlen($req);
-		$req = pack("nnNNN", SEARCHD_COMMAND_SEARCH, VER_COMMAND_SEARCH, $len, 0, $nreqs).$req; // add header
-
-		if (!($this->_Send($fp, $req, $len + 8)) ||
-			 !($response = $this->_GetResponse($fp, VER_COMMAND_SEARCH)))
-		{
-			$this->_MBPop();
-			return false;
-		}
-
-		// query sent ok; we can reset reqs now
-		$this->_reqs = array();
-
-		// parse and return response
-		return $this->_ParseSearchResponse($response, $nreqs);
-	}
-
-	/// parse and return search query (or queries) response
-	public function _ParseSearchResponse($response, $nreqs)
-	{
-		$p = 0; // current position
-		$max = strlen($response); // max position for checks, to protect against broken responses
-
-		$results = array();
-		for ($ires = 0; $ires < $nreqs && $p < $max; $ires++)
-		{
-			$results[] = array();
-			$result = & $results[$ires];
-
-			$result["error"] = "";
-			$result["warning"] = "";
-
-			// extract status
-			list(,$status) = unpack("N*", substr($response, $p, 4)); $p += 4;
-			$result["status"] = $status;
-			if ($status != SEARCHD_OK)
-			{
-				list(,$len) = unpack("N*", substr($response, $p, 4)); $p += 4;
-				$message = substr($response, $p, $len); $p += $len;
-
-				if ($status == SEARCHD_WARNING)
-				{
-					$result["warning"] = $message;
-				} else
-				{
-					$result["error"] = $message;
-					continue;
-				}
-			}
-
-			// read schema
-			$fields = array();
-			$attrs = array();
-
-			list(,$nfields) = unpack("N*", substr($response, $p, 4)); $p += 4;
-			while ($nfields-- > 0 && $p < $max)
-			{
-				list(,$len) = unpack("N*", substr($response, $p, 4)); $p += 4;
-				$fields[] = substr($response, $p, $len); $p += $len;
-			}
-			$result["fields"] = $fields;
-
-			list(,$nattrs) = unpack("N*", substr($response, $p, 4)); $p += 4;
-			while ($nattrs-- > 0 && $p < $max)
-			{
-				list(,$len) = unpack("N*", substr($response, $p, 4)); $p += 4;
-				$attr = substr($response, $p, $len); $p += $len;
-				list(,$type) = unpack("N*", substr($response, $p, 4)); $p += 4;
-				$attrs[$attr] = $type;
-			}
-			$result["attrs"] = $attrs;
-
-			// read match count
-			list(,$count) = unpack("N*", substr($response, $p, 4)); $p += 4;
-			list(,$id64) = unpack("N*", substr($response, $p, 4)); $p += 4;
-
-			// read matches
-			$idx = -1;
-			while ($count-- > 0 && $p < $max)
-			{
-				// index into result array
-				$idx++;
-
-				// parse document id and weight
-				if ($id64)
-				{
-					$doc = sphUnpackU64(substr($response, $p, 8)); $p += 8;
-					list(,$weight) = unpack("N*", substr($response, $p, 4)); $p += 4;
-				}
-				else
-				{
-					list ($doc, $weight) = array_values(unpack("N*N*",
-						substr($response, $p, 8)));
-					$p += 8;
-					$doc = sphFixUint($doc);
-				}
-				$weight = sprintf("%u", $weight);
-
-				// create match entry
-				if ($this->_arrayresult)
-					$result["matches"][$idx] = array("id"=>$doc, "weight"=>$weight);
-				else
-					$result["matches"][$doc]["weight"] = $weight;
-
-				// parse and create attributes
-				$attrvals = array();
-				foreach ($attrs as $attr=>$type)
-				{
-					// handle 64bit ints
-					if ($type == SPH_ATTR_BIGINT)
-					{
-						$attrvals[$attr] = sphUnpackI64(substr($response, $p, 8)); $p += 8;
-						continue;
-					}
-
-					// handle floats
-					if ($type == SPH_ATTR_FLOAT)
-					{
-						list(,$uval) = unpack("N*", substr($response, $p, 4)); $p += 4;
-						list(,$fval) = unpack("f*", pack("L", $uval));
-						$attrvals[$attr] = $fval;
-						continue;
-					}
-
-					// handle everything else as unsigned ints
-					list(,$val) = unpack("N*", substr($response, $p, 4)); $p += 4;
-					if ($type & SPH_ATTR_MULTI)
-					{
-						$attrvals[$attr] = array();
-						$nvalues = $val;
-						while ($nvalues-- > 0 && $p < $max)
-						{
-							list(,$val) = unpack("N*", substr($response, $p, 4)); $p += 4;
-							$attrvals[$attr][] = sphFixUint($val);
-						}
-					} else if ($type == SPH_ATTR_STRING)
-					{
-						$attrvals[$attr] = substr($response, $p, $val);
-						$p += $val;
-					} else
-					{
-						$attrvals[$attr] = sphFixUint($val);
-					}
-				}
-
-				if ($this->_arrayresult)
-					$result["matches"][$idx]["attrs"] = $attrvals;
-				else
-					$result["matches"][$doc]["attrs"] = $attrvals;
-			}
-
-			list ($total, $total_found, $msecs, $words) =
-				array_values(unpack("N*N*N*N*", substr($response, $p, 16)));
-			$result["total"] = sprintf("%u", $total);
-			$result["total_found"] = sprintf("%u", $total_found);
-			$result["time"] = sprintf("%.3f", $msecs / 1000);
-			$p += 16;
-
-			while ($words-- > 0 && $p < $max)
-			{
-				list(,$len) = unpack("N*", substr($response, $p, 4)); $p += 4;
-				$word = substr($response, $p, $len); $p += $len;
-				list ($docs, $hits) = array_values(unpack("N*N*", substr($response, $p, 8))); $p += 8;
-				$result["words"][$word] = array(
-					"docs"=>sprintf("%u", $docs),
-					"hits"=>sprintf("%u", $hits) );
-			}
-		}
-
-		$this->_MBPop();
-		return $results;
-	}
-
-	/////////////////////////////////////////////////////////////////////////////
-	// excerpts generation
-	/////////////////////////////////////////////////////////////////////////////
-
-	/// connect to searchd server, and generate exceprts (snippets)
-	/// of given documents for given query. returns false on failure,
-	/// an array of snippets on success
-	public function BuildExcerpts($docs, $index, $words, $opts = array())
-	{
-		assert(is_array($docs));
-		assert(is_string($index));
-		assert(is_string($words));
-		assert(is_array($opts));
-
-		$this->_MBPush();
-
-		if (!($fp = $this->_Connect()))
-		{
-			$this->_MBPop();
-			return false;
-		}
-
-		/////////////////
-		// fixup options
-		/////////////////
-
-		if (!isset($opts["before_match"]))		$opts["before_match"] = "<b>";
-		if (!isset($opts["after_match"]))			$opts["after_match"] = "</b>";
-		if (!isset($opts["chunk_separator"]))		$opts["chunk_separator"] = " ... ";
-		if (!isset($opts["limit"]))				$opts["limit"] = 256;
-		if (!isset($opts["limit_passages"]))		$opts["limit_passages"] = 0;
-		if (!isset($opts["limit_words"]))			$opts["limit_words"] = 0;
-		if (!isset($opts["around"]))				$opts["around"] = 5;
-		if (!isset($opts["exact_phrase"]))		$opts["exact_phrase"] = false;
-		if (!isset($opts["single_passage"]))		$opts["single_passage"] = false;
-		if (!isset($opts["use_boundaries"]))		$opts["use_boundaries"] = false;
-		if (!isset($opts["weight_order"]))		$opts["weight_order"] = false;
-		if (!isset($opts["query_mode"]))			$opts["query_mode"] = false;
-		if (!isset($opts["force_all_words"]))		$opts["force_all_words"] = false;
-		if (!isset($opts["start_passage_id"]))	$opts["start_passage_id"] = 1;
-		if (!isset($opts["load_files"]))			$opts["load_files"] = false;
-		if (!isset($opts["html_strip_mode"]))		$opts["html_strip_mode"] = "index";
-		if (!isset($opts["allow_empty"]))			$opts["allow_empty"] = false;
-		if (!isset($opts["passage_boundary"]))	$opts["passage_boundary"] = "none";
-		if (!isset($opts["emit_zones"]))			$opts["emit_zones"] = false;
-
-		/////////////////
-		// build request
-		/////////////////
-
-		// v.1.2 req
-		$flags = 1; // remove spaces
-		if ($opts["exact_phrase"])	$flags |= 2;
-		if ($opts["single_passage"])	$flags |= 4;
-		if ($opts["use_boundaries"])	$flags |= 8;
-		if ($opts["weight_order"])	$flags |= 16;
-		if ($opts["query_mode"])		$flags |= 32;
-		if ($opts["force_all_words"])	$flags |= 64;
-		if ($opts["load_files"])		$flags |= 128;
-		if ($opts["allow_empty"])		$flags |= 256;
-		if ($opts["emit_zones"])		$flags |= 512;
-		$req = pack("NN", 0, $flags); // mode=0, flags=$flags
-		$req .= pack("N", strlen($index)).$index; // req index
-		$req .= pack("N", strlen($words)).$words; // req words
-
-		// options
-		$req .= pack("N", strlen($opts["before_match"])).$opts["before_match"];
-		$req .= pack("N", strlen($opts["after_match"])).$opts["after_match"];
-		$req .= pack("N", strlen($opts["chunk_separator"])).$opts["chunk_separator"];
-		$req .= pack("NN", (int) $opts["limit"], (int) $opts["around"]);
-		$req .= pack("NNN", (int) $opts["limit_passages"], (int) $opts["limit_words"], (int) $opts["start_passage_id"]); // v.1.2
-		$req .= pack("N", strlen($opts["html_strip_mode"])).$opts["html_strip_mode"];
-		$req .= pack("N", strlen($opts["passage_boundary"])).$opts["passage_boundary"];
-
-		// documents
-		$req .= pack("N", count($docs));
-		foreach ($docs as $doc)
-		{
-			assert(is_string($doc));
-			$req .= pack("N", strlen($doc)).$doc;
-		}
-
-		////////////////////////////
-		// send query, get response
-		////////////////////////////
-
-		$len = strlen($req);
-		$req = pack("nnN", SEARCHD_COMMAND_EXCERPT, VER_COMMAND_EXCERPT, $len).$req; // add header
-		if (!($this->_Send($fp, $req, $len + 8)) ||
-			 !($response = $this->_GetResponse($fp, VER_COMMAND_EXCERPT)))
-		{
-			$this->_MBPop();
-			return false;
-		}
-
-		//////////////////
-		// parse response
-		//////////////////
-
-		$pos = 0;
-		$res = array();
-		$rlen = strlen($response);
-		for ($i = 0; $i < count($docs); $i++)
-		{
-			list(,$len) = unpack("N*", substr($response, $pos, 4));
-			$pos += 4;
-
-			if ($pos + $len > $rlen)
-			{
-				$this->_error = "incomplete reply";
-				$this->_MBPop();
-				return false;
-			}
-			$res[] = $len ? substr ($response, $pos, $len) : "";
-			$pos += $len;
-		}
-
-		$this->_MBPop();
-		return $res;
-	}
-
-
-	/////////////////////////////////////////////////////////////////////////////
-	// keyword generation
-	/////////////////////////////////////////////////////////////////////////////
-
-	/// connect to searchd server, and generate keyword list for a given query
-	/// returns false on failure,
-	/// an array of words on success
-	public function BuildKeywords($query, $index, $hits)
-	{
-		assert(is_string($query));
-		assert(is_string($index));
-		assert(is_bool($hits));
-
-		$this->_MBPush();
-
-		if (!($fp = $this->_Connect()))
-		{
-			$this->_MBPop();
-			return false;
-		}
-
-		/////////////////
-		// build request
-		/////////////////
-
-		// v.1.0 req
-		$req  = pack("N", strlen($query)).$query; // req query
-		$req .= pack("N", strlen($index)).$index; // req index
-		$req .= pack("N", (int) $hits);
-
-		////////////////////////////
-		// send query, get response
-		////////////////////////////
-
-		$len = strlen($req);
-		$req = pack("nnN", SEARCHD_COMMAND_KEYWORDS, VER_COMMAND_KEYWORDS, $len).$req; // add header
-		if (!($this->_Send($fp, $req, $len + 8)) ||
-			 !($response = $this->_GetResponse($fp, VER_COMMAND_KEYWORDS)))
-		{
-			$this->_MBPop();
-			return false;
-		}
-
-		//////////////////
-		// parse response
-		//////////////////
-
-		$pos = 0;
-		$res = array();
-		$rlen = strlen($response);
-		list(,$nwords) = unpack("N*", substr($response, $pos, 4));
-		$pos += 4;
-		for ($i = 0; $i < $nwords; $i++)
-		{
-			list(,$len) = unpack("N*", substr($response, $pos, 4)); $pos += 4;
-			$tokenized = $len ? substr ($response, $pos, $len) : "";
-			$pos += $len;
-
-			list(,$len) = unpack("N*", substr($response, $pos, 4)); $pos += 4;
-			$normalized = $len ? substr ($response, $pos, $len) : "";
-			$pos += $len;
-
-			$res[] = array("tokenized"=>$tokenized, "normalized"=>$normalized);
-
-			if ($hits)
-			{
-				list($ndocs, $nhits) = array_values(unpack("N*N*", substr($response, $pos, 8)));
-				$pos += 8;
-				$res [$i]["docs"] = $ndocs;
-				$res [$i]["hits"] = $nhits;
-			}
-
-			if ($pos > $rlen)
-			{
-				$this->_error = "incomplete reply";
-				$this->_MBPop();
-				return false;
-			}
-		}
-
-		$this->_MBPop();
-		return $res;
-	}
-
-	public function EscapeString($string)
-	{
-		$from = array('\\', '(', ')', '|', '-', '!', '@', '~', '"', '&', '/', '^', '$', '=');
-		$to   = array('\\\\', '\(', '\)', '\|', '\-', '\!', '\@', '\~', '\"', '\&', '\/', '\^', '\$', '\=');
-
-		return str_replace($from, $to, $string);
-	}
-
-	/////////////////////////////////////////////////////////////////////////////
-	// attribute updates
-	/////////////////////////////////////////////////////////////////////////////
-
-	/// batch update given attributes in given rows in given indexes
-	/// returns amount of updated documents (0 or more) on success, or -1 on failure
-	public function UpdateAttributes($index, $attrs, $values, $mva = false)
-	{
-		// verify everything
-		assert(is_string($index));
-		assert(is_bool($mva));
-
-		assert(is_array($attrs));
-		foreach ($attrs as $attr)
-			assert(is_string($attr));
-
-		assert(is_array($values));
-		foreach ($values as $id=>$entry)
-		{
-			assert(is_numeric($id));
-			assert(is_array($entry));
-			assert(count($entry) == count($attrs));
-			foreach ($entry as $v)
-			{
-				if ($mva)
-				{
-					assert(is_array($v));
-					foreach ($v as $vv)
-						assert(is_int($vv));
-				} else
-					assert(is_int($v));
-			}
-		}
-
-		// build request
-		$this->_MBPush();
-		$req = pack("N", strlen($index)).$index;
-
-		$req .= pack("N", count($attrs));
-		foreach ($attrs as $attr)
-		{
-			$req .= pack("N", strlen($attr)).$attr;
-			$req .= pack("N", $mva ? 1 : 0);
-		}
-
-		$req .= pack("N", count($values));
-		foreach ($values as $id=>$entry)
-		{
-			$req .= sphPackU64($id);
-			foreach ($entry as $v)
-			{
-				$req .= pack("N", $mva ? count($v) : $v);
-				if ($mva)
-					foreach ($v as $vv)
-						$req .= pack("N", $vv);
-			}
-		}
-
-		// connect, send query, get response
-		if (!($fp = $this->_Connect()))
-		{
-			$this->_MBPop();
-			return -1;
-		}
-
-		$len = strlen($req);
-		$req = pack("nnN", SEARCHD_COMMAND_UPDATE, VER_COMMAND_UPDATE, $len).$req; // add header
-		if (!$this->_Send($fp, $req, $len + 8))
-		{
-			$this->_MBPop();
-			return -1;
-		}
-
-		if (!($response = $this->_GetResponse($fp, VER_COMMAND_UPDATE)))
-		{
-			$this->_MBPop();
-			return -1;
-		}
-
-		// parse response
-		list(,$updated) = unpack("N*", substr($response, 0, 4));
-		$this->_MBPop();
-		return $updated;
-	}
-
-	/////////////////////////////////////////////////////////////////////////////
-	// persistent connections
-	/////////////////////////////////////////////////////////////////////////////
-
-	public function Open()
-	{
-		if ($this->_socket !== false)
-		{
-			$this->_error = 'already connected';
-			return false;
-		}
-		if (!$fp = $this->_Connect())
-			return false;
-
-		// command, command version = 0, body length = 4, body = 1
-		$req = pack("nnNN", SEARCHD_COMMAND_PERSIST, 0, 4, 1);
-		if (!$this->_Send($fp, $req, 12))
-			return false;
-
-		$this->_socket = $fp;
-		return true;
-	}
-
-	public function Close()
-	{
-		if ($this->_socket === false)
-		{
-			$this->_error = 'not connected';
-			return false;
-		}
-
-		fclose($this->_socket);
-		$this->_socket = false;
-
-		return true;
-	}
-
-	//////////////////////////////////////////////////////////////////////////
-	// status
-	//////////////////////////////////////////////////////////////////////////
-
-	public function Status()
-	{
-		$this->_MBPush();
-		if (!($fp = $this->_Connect()))
-		{
-			$this->_MBPop();
-			return false;
-		}
-
-		$req = pack("nnNN", SEARCHD_COMMAND_STATUS, VER_COMMAND_STATUS, 4, 1); // len=4, body=1
-		if (!($this->_Send($fp, $req, 12)) ||
-			 !($response = $this->_GetResponse($fp, VER_COMMAND_STATUS)))
-		{
-			$this->_MBPop();
-			return false;
-		}
-
-		$res = substr($response, 4); // just ignore length, error handling, etc
-		$p = 0;
-		list ($rows, $cols) = array_values(unpack("N*N*", substr($response, $p, 8))); $p += 8;
-
-		$res = array();
-		for ($i = 0; $i < $rows; $i++)
-			for ($j = 0; $j < $cols; $j++)
-		{
-			list(,$len) = unpack("N*", substr($response, $p, 4)); $p += 4;
-			$res[$i][] = substr($response, $p, $len); $p += $len;
-		}
-
-		$this->_MBPop();
-		return $res;
-	}
-
-	//////////////////////////////////////////////////////////////////////////
-	// flush
-	//////////////////////////////////////////////////////////////////////////
-
-	public function FlushAttributes()
-	{
-		$this->_MBPush();
-		if (!($fp = $this->_Connect()))
-		{
-			$this->_MBPop();
-			return -1;
-		}
-
-		$req = pack("nnN", SEARCHD_COMMAND_FLUSHATTRS, VER_COMMAND_FLUSHATTRS, 0); // len=0
-		if (!($this->_Send($fp, $req, 8)) ||
-			 !($response = $this->_GetResponse($fp, VER_COMMAND_FLUSHATTRS)))
-		{
-			$this->_MBPop();
-			return -1;
-		}
-
-		$tag = -1;
-		if (strlen($response) == 4)
-			list(,$tag) = unpack("N*", $response);
-		else
-			$this->_error = "unexpected response length";
-
-		$this->_MBPop();
-		return $tag;
-	}
+    //////////////////////////////////////////////////////////////////////////////
+
+    /// connect to searchd server, run given search query through given indexes,
+    /// and return the search results
+    public function Query($query, $index = "*", $comment = "")
+    {
+        assert(empty($this->_reqs));
+
+        $this->AddQuery($query, $index, $comment);
+        $results = $this->RunQueries();
+        $this->_reqs = array(); // just in case it failed too early
+
+        if (!is_array($results))
+            return false; // probably network error; error message should be already filled
+
+        $this->_error = $results[0]["error"];
+        $this->_warning = $results[0]["warning"];
+        if ($results[0]["status"] == SEARCHD_ERROR)
+            return false;
+        else
+            return $results[0];
+    }
+
+    /// helper to pack floats in network byte order
+    public function _PackFloat($f)
+    {
+        $t1 = pack("f", $f); // machine order
+        list(,$t2) = unpack("L*", $t1); // int in machine order
+        return pack("N", $t2);
+    }
+
+    /**
+     * @SuppressWarnings(unused)
+     */
+
+    /// add query to multi-query batch
+    /// returns index into results array from RunQueries() call
+    public function AddQuery($query, $index = "*", $comment = "")
+    {
+        // mbstring workaround
+        $this->_MBPush();
+
+        // build request
+        $req = pack("NNNNN", $this->_offset, $this->_limit, $this->_mode, $this->_ranker, $this->_sort); // mode and limits
+        $req .= pack("N", strlen($this->_sortby)).$this->_sortby;
+        $req .= pack("N", strlen($query)).$query; // query itself
+        $req .= pack("N", count($this->_weights)); // weights
+        foreach ($this->_weights as $weight)
+            $req .= pack("N", (int) $weight);
+        $req .= pack("N", strlen($index)).$index; // indexes
+        $req .= pack("N", 1); // id64 range marker
+        $req .= sphPackU64($this->_min_id).sphPackU64($this->_max_id); // id64 range
+
+        // filters
+        $req .= pack("N", count($this->_filters));
+        foreach ($this->_filters as $filter)
+        {
+            $req .= pack("N", strlen($filter["attr"])).$filter["attr"];
+            $req .= pack("N", $filter["type"]);
+            switch ($filter["type"])
+            {
+                case SPH_FILTER_VALUES:
+                    $req .= pack("N", count($filter["values"]));
+                    foreach ($filter["values"] as $value)
+                        $req .= sphPackI64($value);
+                    break;
+
+                case SPH_FILTER_RANGE:
+                    $req .= sphPackI64($filter["min"]).sphPackI64($filter["max"]);
+                    break;
+
+                case SPH_FILTER_FLOATRANGE:
+                    $req .= $this->_PackFloat($filter["min"]).$this->_PackFloat($filter["max"]);
+                    break;
+
+                default:
+                    assert(0 && "internal error: unhandled filter type");
+            }
+            $req .= pack("N", $filter["exclude"]);
+        }
+
+        // group-by clause, max-matches count, group-sort clause, cutoff count
+        $req .= pack("NN", $this->_groupfunc, strlen($this->_groupby)).$this->_groupby;
+        $req .= pack("N", $this->_maxmatches);
+        $req .= pack("N", strlen($this->_groupsort)).$this->_groupsort;
+        $req .= pack("NNN", $this->_cutoff, $this->_retrycount, $this->_retrydelay);
+        $req .= pack("N", strlen($this->_groupdistinct)).$this->_groupdistinct;
+
+        // anchor point
+        if (empty($this->_anchor))
+        {
+            $req .= pack("N", 0);
+        } else
+        {
+            $a = & $this->_anchor;
+            $req .= pack("N", 1);
+            $req .= pack("N", strlen($a["attrlat"])).$a["attrlat"];
+            $req .= pack("N", strlen($a["attrlong"])).$a["attrlong"];
+            $req .= $this->_PackFloat($a["lat"]).$this->_PackFloat($a["long"]);
+        }
+
+        // per-index weights
+        $req .= pack("N", count($this->_indexweights));
+        foreach ($this->_indexweights as $idx=>$weight)
+            $req .= pack("N", strlen($idx)).$idx.pack("N", $weight);
+
+        // max query time
+        $req .= pack("N", $this->_maxquerytime);
+
+        // per-field weights
+        $req .= pack("N", count($this->_fieldweights));
+        foreach ($this->_fieldweights as $field=>$weight)
+            $req .= pack("N", strlen($field)).$field.pack("N", $weight);
+
+        // comment
+        $req .= pack("N", strlen($comment)).$comment;
+
+        // attribute overrides
+        $req .= pack("N", count($this->_overrides));
+        foreach ($this->_overrides as $key => $entry)
+        {
+            $req .= pack("N", strlen($entry["attr"])).$entry["attr"];
+            $req .= pack("NN", $entry["type"], count($entry["values"]));
+            foreach ($entry["values"] as $id=>$val)
+            {
+                assert(is_numeric($id));
+                assert(is_numeric($val));
+
+                $req .= sphPackU64($id);
+                switch ($entry["type"])
+                {
+                    case SPH_ATTR_FLOAT:	$req .= $this->_PackFloat($val); break;
+                    case SPH_ATTR_BIGINT:	$req .= sphPackI64($val); break;
+                    default:				$req .= pack("N", $val); break;
+                }
+            }
+        }
+
+        // select-list
+        $req .= pack("N", strlen($this->_select)).$this->_select;
+
+        // mbstring workaround
+        $this->_MBPop();
+
+        // store request to requests array
+        $this->_reqs[] = $req;
+        return count($this->_reqs) - 1;
+    }
+
+    /// connect to searchd, run queries batch, and return an array of result sets
+    public function RunQueries()
+    {
+        if (empty($this->_reqs))
+        {
+            $this->_error = "no queries defined, issue AddQuery() first";
+            return false;
+        }
+
+        // mbstring workaround
+        $this->_MBPush();
+
+        if (!($fp = $this->_Connect()))
+        {
+            $this->_MBPop();
+            return false;
+        }
+
+        // send query, get response
+        $nreqs = count($this->_reqs);
+        $req = join("", $this->_reqs);
+        $len = 8 + strlen($req);
+        $req = pack("nnNNN", SEARCHD_COMMAND_SEARCH, VER_COMMAND_SEARCH, $len, 0, $nreqs).$req; // add header
+
+        if (!($this->_Send($fp, $req, $len + 8)) ||
+             !($response = $this->_GetResponse($fp, VER_COMMAND_SEARCH)))
+        {
+            $this->_MBPop();
+            return false;
+        }
+
+        // query sent ok; we can reset reqs now
+        $this->_reqs = array();
+
+        // parse and return response
+        return $this->_ParseSearchResponse($response, $nreqs);
+    }
+
+    /// parse and return search query (or queries) response
+    public function _ParseSearchResponse($response, $nreqs)
+    {
+        $p = 0; // current position
+        $max = strlen($response); // max position for checks, to protect against broken responses
+
+        $results = array();
+        for ($ires = 0; $ires < $nreqs && $p < $max; $ires++)
+        {
+            $results[] = array();
+            $result = & $results[$ires];
+
+            $result["error"] = "";
+            $result["warning"] = "";
+
+            // extract status
+            list(,$status) = unpack("N*", substr($response, $p, 4)); $p += 4;
+            $result["status"] = $status;
+            if ($status != SEARCHD_OK)
+            {
+                list(,$len) = unpack("N*", substr($response, $p, 4)); $p += 4;
+                $message = substr($response, $p, $len); $p += $len;
+
+                if ($status == SEARCHD_WARNING)
+                {
+                    $result["warning"] = $message;
+                } else
+                {
+                    $result["error"] = $message;
+                    continue;
+                }
+            }
+
+            // read schema
+            $fields = array();
+            $attrs = array();
+
+            list(,$nfields) = unpack("N*", substr($response, $p, 4)); $p += 4;
+            while ($nfields-- > 0 && $p < $max)
+            {
+                list(,$len) = unpack("N*", substr($response, $p, 4)); $p += 4;
+                $fields[] = substr($response, $p, $len); $p += $len;
+            }
+            $result["fields"] = $fields;
+
+            list(,$nattrs) = unpack("N*", substr($response, $p, 4)); $p += 4;
+            while ($nattrs-- > 0 && $p < $max)
+            {
+                list(,$len) = unpack("N*", substr($response, $p, 4)); $p += 4;
+                $attr = substr($response, $p, $len); $p += $len;
+                list(,$type) = unpack("N*", substr($response, $p, 4)); $p += 4;
+                $attrs[$attr] = $type;
+            }
+            $result["attrs"] = $attrs;
+
+            // read match count
+            list(,$count) = unpack("N*", substr($response, $p, 4)); $p += 4;
+            list(,$id64) = unpack("N*", substr($response, $p, 4)); $p += 4;
+
+            // read matches
+            $idx = -1;
+            while ($count-- > 0 && $p < $max)
+            {
+                // index into result array
+                $idx++;
+
+                // parse document id and weight
+                if ($id64)
+                {
+                    $doc = sphUnpackU64(substr($response, $p, 8)); $p += 8;
+                    list(,$weight) = unpack("N*", substr($response, $p, 4)); $p += 4;
+                }
+                else
+                {
+                    list ($doc, $weight) = array_values(unpack("N*N*",
+                        substr($response, $p, 8)));
+                    $p += 8;
+                    $doc = sphFixUint($doc);
+                }
+                $weight = sprintf("%u", $weight);
+
+                // create match entry
+                if ($this->_arrayresult)
+                    $result["matches"][$idx] = array("id"=>$doc, "weight"=>$weight);
+                else
+                    $result["matches"][$doc]["weight"] = $weight;
+
+                // parse and create attributes
+                $attrvals = array();
+                foreach ($attrs as $attr=>$type)
+                {
+                    // handle 64bit ints
+                    if ($type == SPH_ATTR_BIGINT)
+                    {
+                        $attrvals[$attr] = sphUnpackI64(substr($response, $p, 8)); $p += 8;
+                        continue;
+                    }
+
+                    // handle floats
+                    if ($type == SPH_ATTR_FLOAT)
+                    {
+                        list(,$uval) = unpack("N*", substr($response, $p, 4)); $p += 4;
+                        list(,$fval) = unpack("f*", pack("L", $uval));
+                        $attrvals[$attr] = $fval;
+                        continue;
+                    }
+
+                    // handle everything else as unsigned ints
+                    list(,$val) = unpack("N*", substr($response, $p, 4)); $p += 4;
+                    if ($type & SPH_ATTR_MULTI)
+                    {
+                        $attrvals[$attr] = array();
+                        $nvalues = $val;
+                        while ($nvalues-- > 0 && $p < $max)
+                        {
+                            list(,$val) = unpack("N*", substr($response, $p, 4)); $p += 4;
+                            $attrvals[$attr][] = sphFixUint($val);
+                        }
+                    } else if ($type == SPH_ATTR_STRING)
+                    {
+                        $attrvals[$attr] = substr($response, $p, $val);
+                        $p += $val;
+                    } else
+                    {
+                        $attrvals[$attr] = sphFixUint($val);
+                    }
+                }
+
+                if ($this->_arrayresult)
+                    $result["matches"][$idx]["attrs"] = $attrvals;
+                else
+                    $result["matches"][$doc]["attrs"] = $attrvals;
+            }
+
+            list ($total, $total_found, $msecs, $words) =
+                array_values(unpack("N*N*N*N*", substr($response, $p, 16)));
+            $result["total"] = sprintf("%u", $total);
+            $result["total_found"] = sprintf("%u", $total_found);
+            $result["time"] = sprintf("%.3f", $msecs / 1000);
+            $p += 16;
+
+            while ($words-- > 0 && $p < $max)
+            {
+                list(,$len) = unpack("N*", substr($response, $p, 4)); $p += 4;
+                $word = substr($response, $p, $len); $p += $len;
+                list ($docs, $hits) = array_values(unpack("N*N*", substr($response, $p, 8))); $p += 8;
+                $result["words"][$word] = array(
+                    "docs"=>sprintf("%u", $docs),
+                    "hits"=>sprintf("%u", $hits) );
+            }
+        }
+
+        $this->_MBPop();
+        return $results;
+    }
+
+    /////////////////////////////////////////////////////////////////////////////
+    // excerpts generation
+    /////////////////////////////////////////////////////////////////////////////
+
+    /// connect to searchd server, and generate exceprts (snippets)
+    /// of given documents for given query. returns false on failure,
+    /// an array of snippets on success
+    public function BuildExcerpts($docs, $index, $words, $opts = array())
+    {
+        assert(is_array($docs));
+        assert(is_string($index));
+        assert(is_string($words));
+        assert(is_array($opts));
+
+        $this->_MBPush();
+
+        if (!($fp = $this->_Connect()))
+        {
+            $this->_MBPop();
+            return false;
+        }
+
+        /////////////////
+        // fixup options
+        /////////////////
+
+        if (!isset($opts["before_match"]))		$opts["before_match"] = "<b>";
+        if (!isset($opts["after_match"]))			$opts["after_match"] = "</b>";
+        if (!isset($opts["chunk_separator"]))		$opts["chunk_separator"] = " ... ";
+        if (!isset($opts["limit"]))				$opts["limit"] = 256;
+        if (!isset($opts["limit_passages"]))		$opts["limit_passages"] = 0;
+        if (!isset($opts["limit_words"]))			$opts["limit_words"] = 0;
+        if (!isset($opts["around"]))				$opts["around"] = 5;
+        if (!isset($opts["exact_phrase"]))		$opts["exact_phrase"] = false;
+        if (!isset($opts["single_passage"]))		$opts["single_passage"] = false;
+        if (!isset($opts["use_boundaries"]))		$opts["use_boundaries"] = false;
+        if (!isset($opts["weight_order"]))		$opts["weight_order"] = false;
+        if (!isset($opts["query_mode"]))			$opts["query_mode"] = false;
+        if (!isset($opts["force_all_words"]))		$opts["force_all_words"] = false;
+        if (!isset($opts["start_passage_id"]))	$opts["start_passage_id"] = 1;
+        if (!isset($opts["load_files"]))			$opts["load_files"] = false;
+        if (!isset($opts["html_strip_mode"]))		$opts["html_strip_mode"] = "index";
+        if (!isset($opts["allow_empty"]))			$opts["allow_empty"] = false;
+        if (!isset($opts["passage_boundary"]))	$opts["passage_boundary"] = "none";
+        if (!isset($opts["emit_zones"]))			$opts["emit_zones"] = false;
+
+        /////////////////
+        // build request
+        /////////////////
+
+        // v.1.2 req
+        $flags = 1; // remove spaces
+        if ($opts["exact_phrase"])	$flags |= 2;
+        if ($opts["single_passage"])	$flags |= 4;
+        if ($opts["use_boundaries"])	$flags |= 8;
+        if ($opts["weight_order"])	$flags |= 16;
+        if ($opts["query_mode"])		$flags |= 32;
+        if ($opts["force_all_words"])	$flags |= 64;
+        if ($opts["load_files"])		$flags |= 128;
+        if ($opts["allow_empty"])		$flags |= 256;
+        if ($opts["emit_zones"])		$flags |= 512;
+        $req = pack("NN", 0, $flags); // mode=0, flags=$flags
+        $req .= pack("N", strlen($index)).$index; // req index
+        $req .= pack("N", strlen($words)).$words; // req words
+
+        // options
+        $req .= pack("N", strlen($opts["before_match"])).$opts["before_match"];
+        $req .= pack("N", strlen($opts["after_match"])).$opts["after_match"];
+        $req .= pack("N", strlen($opts["chunk_separator"])).$opts["chunk_separator"];
+        $req .= pack("NN", (int) $opts["limit"], (int) $opts["around"]);
+        $req .= pack("NNN", (int) $opts["limit_passages"], (int) $opts["limit_words"], (int) $opts["start_passage_id"]); // v.1.2
+        $req .= pack("N", strlen($opts["html_strip_mode"])).$opts["html_strip_mode"];
+        $req .= pack("N", strlen($opts["passage_boundary"])).$opts["passage_boundary"];
+
+        // documents
+        $req .= pack("N", count($docs));
+        foreach ($docs as $doc)
+        {
+            assert(is_string($doc));
+            $req .= pack("N", strlen($doc)).$doc;
+        }
+
+        ////////////////////////////
+        // send query, get response
+        ////////////////////////////
+
+        $len = strlen($req);
+        $req = pack("nnN", SEARCHD_COMMAND_EXCERPT, VER_COMMAND_EXCERPT, $len).$req; // add header
+        if (!($this->_Send($fp, $req, $len + 8)) ||
+             !($response = $this->_GetResponse($fp, VER_COMMAND_EXCERPT)))
+        {
+            $this->_MBPop();
+            return false;
+        }
+
+        //////////////////
+        // parse response
+        //////////////////
+
+        $pos = 0;
+        $res = array();
+        $rlen = strlen($response);
+        for ($i = 0; $i < count($docs); $i++)
+        {
+            list(,$len) = unpack("N*", substr($response, $pos, 4));
+            $pos += 4;
+
+            if ($pos + $len > $rlen)
+            {
+                $this->_error = "incomplete reply";
+                $this->_MBPop();
+                return false;
+            }
+            $res[] = $len ? substr ($response, $pos, $len) : "";
+            $pos += $len;
+        }
+
+        $this->_MBPop();
+        return $res;
+    }
+
+
+    /////////////////////////////////////////////////////////////////////////////
+    // keyword generation
+    /////////////////////////////////////////////////////////////////////////////
+
+    /// connect to searchd server, and generate keyword list for a given query
+    /// returns false on failure,
+    /// an array of words on success
+    public function BuildKeywords($query, $index, $hits)
+    {
+        assert(is_string($query));
+        assert(is_string($index));
+        assert(is_bool($hits));
+
+        $this->_MBPush();
+
+        if (!($fp = $this->_Connect()))
+        {
+            $this->_MBPop();
+            return false;
+        }
+
+        /////////////////
+        // build request
+        /////////////////
+
+        // v.1.0 req
+        $req  = pack("N", strlen($query)).$query; // req query
+        $req .= pack("N", strlen($index)).$index; // req index
+        $req .= pack("N", (int) $hits);
+
+        ////////////////////////////
+        // send query, get response
+        ////////////////////////////
+
+        $len = strlen($req);
+        $req = pack("nnN", SEARCHD_COMMAND_KEYWORDS, VER_COMMAND_KEYWORDS, $len).$req; // add header
+        if (!($this->_Send($fp, $req, $len + 8)) ||
+             !($response = $this->_GetResponse($fp, VER_COMMAND_KEYWORDS)))
+        {
+            $this->_MBPop();
+            return false;
+        }
+
+        //////////////////
+        // parse response
+        //////////////////
+
+        $pos = 0;
+        $res = array();
+        $rlen = strlen($response);
+        list(,$nwords) = unpack("N*", substr($response, $pos, 4));
+        $pos += 4;
+        for ($i = 0; $i < $nwords; $i++)
+        {
+            list(,$len) = unpack("N*", substr($response, $pos, 4)); $pos += 4;
+            $tokenized = $len ? substr ($response, $pos, $len) : "";
+            $pos += $len;
+
+            list(,$len) = unpack("N*", substr($response, $pos, 4)); $pos += 4;
+            $normalized = $len ? substr ($response, $pos, $len) : "";
+            $pos += $len;
+
+            $res[] = array("tokenized"=>$tokenized, "normalized"=>$normalized);
+
+            if ($hits)
+            {
+                list($ndocs, $nhits) = array_values(unpack("N*N*", substr($response, $pos, 8)));
+                $pos += 8;
+                $res [$i]["docs"] = $ndocs;
+                $res [$i]["hits"] = $nhits;
+            }
+
+            if ($pos > $rlen)
+            {
+                $this->_error = "incomplete reply";
+                $this->_MBPop();
+                return false;
+            }
+        }
+
+        $this->_MBPop();
+        return $res;
+    }
+
+    public function EscapeString($string)
+    {
+        $from = array('\\', '(', ')', '|', '-', '!', '@', '~', '"', '&', '/', '^', '$', '=');
+        $to   = array('\\\\', '\(', '\)', '\|', '\-', '\!', '\@', '\~', '\"', '\&', '\/', '\^', '\$', '\=');
+
+        return str_replace($from, $to, $string);
+    }
+
+    /////////////////////////////////////////////////////////////////////////////
+    // attribute updates
+    /////////////////////////////////////////////////////////////////////////////
+
+    /// batch update given attributes in given rows in given indexes
+    /// returns amount of updated documents (0 or more) on success, or -1 on failure
+    public function UpdateAttributes($index, $attrs, $values, $mva = false)
+    {
+        // verify everything
+        assert(is_string($index));
+        assert(is_bool($mva));
+
+        assert(is_array($attrs));
+        foreach ($attrs as $attr)
+            assert(is_string($attr));
+
+        assert(is_array($values));
+        foreach ($values as $id=>$entry)
+        {
+            assert(is_numeric($id));
+            assert(is_array($entry));
+            assert(count($entry) == count($attrs));
+            foreach ($entry as $v)
+            {
+                if ($mva)
+                {
+                    assert(is_array($v));
+                    foreach ($v as $vv)
+                        assert(is_int($vv));
+                } else
+                    assert(is_int($v));
+            }
+        }
+
+        // build request
+        $this->_MBPush();
+        $req = pack("N", strlen($index)).$index;
+
+        $req .= pack("N", count($attrs));
+        foreach ($attrs as $attr)
+        {
+            $req .= pack("N", strlen($attr)).$attr;
+            $req .= pack("N", $mva ? 1 : 0);
+        }
+
+        $req .= pack("N", count($values));
+        foreach ($values as $id=>$entry)
+        {
+            $req .= sphPackU64($id);
+            foreach ($entry as $v)
+            {
+                $req .= pack("N", $mva ? count($v) : $v);
+                if ($mva)
+                    foreach ($v as $vv)
+                        $req .= pack("N", $vv);
+            }
+        }
+
+        // connect, send query, get response
+        if (!($fp = $this->_Connect()))
+        {
+            $this->_MBPop();
+            return -1;
+        }
+
+        $len = strlen($req);
+        $req = pack("nnN", SEARCHD_COMMAND_UPDATE, VER_COMMAND_UPDATE, $len).$req; // add header
+        if (!$this->_Send($fp, $req, $len + 8))
+        {
+            $this->_MBPop();
+            return -1;
+        }
+
+        if (!($response = $this->_GetResponse($fp, VER_COMMAND_UPDATE)))
+        {
+            $this->_MBPop();
+            return -1;
+        }
+
+        // parse response
+        list(,$updated) = unpack("N*", substr($response, 0, 4));
+        $this->_MBPop();
+        return $updated;
+    }
+
+    /////////////////////////////////////////////////////////////////////////////
+    // persistent connections
+    /////////////////////////////////////////////////////////////////////////////
+
+    public function Open()
+    {
+        if ($this->_socket !== false)
+        {
+            $this->_error = 'already connected';
+            return false;
+        }
+        if (!$fp = $this->_Connect())
+            return false;
+
+        // command, command version = 0, body length = 4, body = 1
+        $req = pack("nnNN", SEARCHD_COMMAND_PERSIST, 0, 4, 1);
+        if (!$this->_Send($fp, $req, 12))
+            return false;
+
+        $this->_socket = $fp;
+        return true;
+    }
+
+    public function Close()
+    {
+        if ($this->_socket === false)
+        {
+            $this->_error = 'not connected';
+            return false;
+        }
+
+        fclose($this->_socket);
+        $this->_socket = false;
+
+        return true;
+    }
+
+    //////////////////////////////////////////////////////////////////////////
+    // status
+    //////////////////////////////////////////////////////////////////////////
+
+    public function Status()
+    {
+        $this->_MBPush();
+        if (!($fp = $this->_Connect()))
+        {
+            $this->_MBPop();
+            return false;
+        }
+
+        $req = pack("nnNN", SEARCHD_COMMAND_STATUS, VER_COMMAND_STATUS, 4, 1); // len=4, body=1
+        if (!($this->_Send($fp, $req, 12)) ||
+             !($response = $this->_GetResponse($fp, VER_COMMAND_STATUS)))
+        {
+            $this->_MBPop();
+            return false;
+        }
+
+        $res = substr($response, 4); // just ignore length, error handling, etc
+        $p = 0;
+        list ($rows, $cols) = array_values(unpack("N*N*", substr($response, $p, 8))); $p += 8;
+
+        $res = array();
+        for ($i = 0; $i < $rows; $i++)
+            for ($j = 0; $j < $cols; $j++)
+        {
+            list(,$len) = unpack("N*", substr($response, $p, 4)); $p += 4;
+            $res[$i][] = substr($response, $p, $len); $p += $len;
+        }
+
+        $this->_MBPop();
+        return $res;
+    }
+
+    //////////////////////////////////////////////////////////////////////////
+    // flush
+    //////////////////////////////////////////////////////////////////////////
+
+    public function FlushAttributes()
+    {
+        $this->_MBPush();
+        if (!($fp = $this->_Connect()))
+        {
+            $this->_MBPop();
+            return -1;
+        }
+
+        $req = pack("nnN", SEARCHD_COMMAND_FLUSHATTRS, VER_COMMAND_FLUSHATTRS, 0); // len=0
+        if (!($this->_Send($fp, $req, 8)) ||
+             !($response = $this->_GetResponse($fp, VER_COMMAND_FLUSHATTRS)))
+        {
+            $this->_MBPop();
+            return -1;
+        }
+
+        $tag = -1;
+        if (strlen($response) == 4)
+            list(,$tag) = unpack("N*", $response);
+        else
+            $this->_error = "unexpected response length";
+
+        $this->_MBPop();
+        return $tag;
+    }
 }
 
 //

Switch Indentation +19 added lines, -19 removed lines

@@ -1003,22 +1003,22 @@ 
 			$req .= pack("N", $filter["type"]);
 			switch ($filter["type"])
 			{
-				case SPH_FILTER_VALUES:
-					$req .= pack("N", count($filter["values"]));
-					foreach ($filter["values"] as $value)
-						$req .= sphPackI64($value);
-					break;
-
-				case SPH_FILTER_RANGE:
-					$req .= sphPackI64($filter["min"]).sphPackI64($filter["max"]);
-					break;
-
-				case SPH_FILTER_FLOATRANGE:
-					$req .= $this->_PackFloat($filter["min"]).$this->_PackFloat($filter["max"]);
-					break;
-
-				default:
-					assert(0 && "internal error: unhandled filter type");
+			case SPH_FILTER_VALUES:
+				$req .= pack("N", count($filter["values"]));
+				foreach ($filter["values"] as $value)
+					$req .= sphPackI64($value);
+				break;
+
+			case SPH_FILTER_RANGE:
+				$req .= sphPackI64($filter["min"]).sphPackI64($filter["max"]);
+				break;
+
+			case SPH_FILTER_FLOATRANGE:
+				$req .= $this->_PackFloat($filter["min"]).$this->_PackFloat($filter["max"]);
+				break;
+
+			default:
+				assert(0 && "internal error: unhandled filter type");
 			}
 			$req .= pack("N", $filter["exclude"]);
 		}
@@ -1073,9 +1073,9 @@ 
 				$req .= sphPackU64($id);
 				switch ($entry["type"])
 				{
-					case SPH_ATTR_FLOAT:	$req .= $this->_PackFloat($val); break;
-					case SPH_ATTR_BIGINT:	$req .= sphPackI64($val); break;
-					default:				$req .= pack("N", $val); break;
+				case SPH_ATTR_FLOAT:	$req .= $this->_PackFloat($val); break;
+				case SPH_ATTR_BIGINT:	$req .= sphPackI64($val); break;
+				default:				$req .= pack("N", $val); break;
 				}
 			}
 		}

Braces +241 added lines, -134 removed lines

@@ -133,14 +133,16 @@ 
 	}
 
 	// x32, int
-	if (is_int($v))
-		return pack("NN", $v < 0 ? -1 : 0, $v);
+	if (is_int($v)) {
+			return pack("NN", $v < 0 ? -1 : 0, $v);
+	}
 
 	// x32, bcmath
 	if (function_exists("bcmul"))
 	{
-		if (bccomp($v, 0) == -1)
-			$v = bcadd("18446744073709551616", $v);
+		if (bccomp($v, 0) == -1) {
+					$v = bcadd("18446744073709551616", $v);
+		}
 		$h = bcdiv($v, "4294967296", 0);
 		$l = bcmod($v, "4294967296");
 		return pack("NN", (float) $h, (float) $l); // conversion to float is intentional; int would lose 31st bit
@@ -158,9 +160,9 @@ 
 
 	if ($v < 0)
 	{
-		if ($l == 0)
-			$h = 4294967296.0 - $h;
-		else
+		if ($l == 0) {
+					$h = 4294967296.0 - $h;
+		} else
 		{
 			$h = 4294967295.0 - $h;
 			$l = 4294967296.0 - $l;
@@ -180,8 +182,9 @@ 
 		assert($v >= 0);
 
 		// x64, int
-		if (is_int($v))
-			return pack("NN", $v >> 32, $v & 0xFFFFFFFF);
+		if (is_int($v)) {
+					return pack("NN", $v >> 32, $v & 0xFFFFFFFF);
+		}
 
 		// x64, bcmath
 		if (function_exists("bcmul"))
@@ -204,8 +207,9 @@ 
 	}
 
 	// x32, int
-	if (is_int($v))
-		return pack("NN", 0, $v);
+	if (is_int($v)) {
+			return pack("NN", 0, $v);
+	}
 
 	// x32, bcmath
 	if (function_exists("bcmul"))
@@ -235,16 +239,23 @@ 
 
 	if (PHP_INT_SIZE >= 8)
 	{
-		if ($hi < 0) $hi += (1 << 32); // because php 5.2.2 to 5.2.5 is totally fucked up again
-		if ($lo < 0) $lo += (1 << 32);
+		if ($hi < 0) {
+		    $hi += (1 << 32);
+		}
+		// because php 5.2.2 to 5.2.5 is totally fucked up again
+		if ($lo < 0) {
+		    $lo += (1 << 32);
+		}
 
 		// x64, int
-		if ($hi <= 2147483647)
-			return ($hi << 32) + $lo;
+		if ($hi <= 2147483647) {
+					return ($hi << 32) + $lo;
+		}
 
 		// x64, bcmath
-		if (function_exists("bcmul"))
-			return bcadd($lo, bcmul($hi, "4294967296"));
+		if (function_exists("bcmul")) {
+					return bcadd($lo, bcmul($hi, "4294967296"));
+		}
 
 		// x64, no-bcmath
 		$C = 100000;
@@ -256,16 +267,18 @@ 
 			$l  = $l % $C;
 		}
 
-		if ($h == 0)
-			return $l;
+		if ($h == 0) {
+					return $l;
+		}
 		return sprintf("%d%05d", $h, $l);
 	}
 
 	// x32, int
 	if ($hi == 0)
 	{
-		if ($lo > 0)
-			return $lo;
+		if ($lo > 0) {
+					return $lo;
+		}
 		return sprintf("%u", $lo);
 	}
 
@@ -273,8 +286,9 @@ 
 	$lo = sprintf("%u", $lo);
 
 	// x32, bcmath
-	if (function_exists("bcmul"))
-		return bcadd($lo, bcmul($hi, "4294967296"));
+	if (function_exists("bcmul")) {
+			return bcadd($lo, bcmul($hi, "4294967296"));
+	}
 
 	// x32, no-bcmath
 	$hi = (float) $hi;
@@ -289,8 +303,9 @@ 
 
 	$h = sprintf("%.0f", $h);
 	$l = sprintf("%07.0f", $l);
-	if ($h == "0")
-		return sprintf("%.0f", (float) $l);
+	if ($h == "0") {
+			return sprintf("%.0f", (float) $l);
+	}
 	return $h.$l;
 }
 
@@ -302,8 +317,13 @@ 
 	// x64
 	if (PHP_INT_SIZE >= 8)
 	{
-		if ($hi < 0) $hi += (1 << 32); // because php 5.2.2 to 5.2.5 is totally fucked up again
-		if ($lo < 0) $lo += (1 << 32);
+		if ($hi < 0) {
+		    $hi += (1 << 32);
+		}
+		// because php 5.2.2 to 5.2.5 is totally fucked up again
+		if ($lo < 0) {
+		    $lo += (1 << 32);
+		}
 
 		return ($hi << 32) + $lo;
 	}
@@ -311,15 +331,17 @@ 
 	// x32, int
 	if ($hi == 0)
 	{
-		if ($lo > 0)
-			return $lo;
+		if ($lo > 0) {
+					return $lo;
+		}
 		return sprintf("%u", $lo);
 	}
 	// x32, int
 	elseif ($hi == -1)
 	{
-		if ($lo < 0)
-			return $lo;
+		if ($lo < 0) {
+					return $lo;
+		}
 		return sprintf("%.0f", $lo - 4294967296.0);
 	}
 
@@ -337,8 +359,9 @@ 
 	$lo = sprintf("%u", $lo);
 
 	// x32, bcmath
-	if (function_exists("bcmul"))
-		return $neg.bcadd(bcadd($lo, bcmul($hi, "4294967296")), $c);
+	if (function_exists("bcmul")) {
+			return $neg.bcadd(bcadd($lo, bcmul($hi, "4294967296")), $c);
+	}
 
 	// x32, no-bcmath
 	$hi = (float) $hi;
@@ -358,8 +381,9 @@ 
 
 	$h = sprintf("%.0f", $h);
 	$l = sprintf("%07.0f", $l);
-	if ($h == "0")
-		return $neg.sprintf("%.0f", (float) $l);
+	if ($h == "0") {
+			return $neg.sprintf("%.0f", (float) $l);
+	}
 	return $neg.$h.$l;
 }
 
@@ -369,10 +393,11 @@ 
 	if (PHP_INT_SIZE >= 8)
 	{
 		// x64 route, workaround broken unpack() in 5.2.2+
-		if ($value < 0) $value += (1 << 32);
+		if ($value < 0) {
+		    $value += (1 << 32);
+		}
 		return $value;
-	}
-	else
+	} else
 	{
 		// x32 route, workaround php signed/unsigned braindamage
 		return sprintf("%u", $value);
@@ -470,8 +495,9 @@ 
 
 	public function __destruct()
 	{
-		if ($this->_socket !== false)
-			fclose($this->_socket);
+		if ($this->_socket !== false) {
+					fclose($this->_socket);
+		}
 	}
 
 	/// get last error message (string)
@@ -549,8 +575,9 @@ 
 	/// leave mbstring workaround mode
 	public function _MBPop()
 	{
-		if ($this->_mbenc)
-			mb_internal_encoding($this->_mbenc);
+		if ($this->_mbenc) {
+					mb_internal_encoding($this->_mbenc);
+		}
 	}
 
 	/// connect to searchd server
@@ -560,8 +587,9 @@ 
 		{
 			// we are in persistent connection mode, so we have a socket
 			// however, need to check whether it's still alive
-			if (!@feof($this->_socket))
-				return $this->_socket;
+			if (!@feof($this->_socket)) {
+							return $this->_socket;
+			}
 
 			// force reopen
 			$this->_socket = false;
@@ -575,24 +603,25 @@ 
 		{
 			$host = $this->_path;
 			$port = 0;
-		}
-		else
+		} else
 		{
 			$host = $this->_host;
 			$port = $this->_port;
 		}
 
-		if ($this->_timeout <= 0)
-			$fp = @fsockopen($host, $port, $errno, $errstr);
-		else
-			$fp = @fsockopen($host, $port, $errno, $errstr, $this->_timeout);
+		if ($this->_timeout <= 0) {
+					$fp = @fsockopen($host, $port, $errno, $errstr);
+		} else {
+					$fp = @fsockopen($host, $port, $errno, $errstr, $this->_timeout);
+		}
 
 		if (!$fp)
 		{
-			if ($this->_path)
-				$location = $this->_path;
-			else
-				$location = "{$this->_host}:{$this->_port}";
+			if ($this->_path) {
+							$location = $this->_path;
+			} else {
+							$location = "{$this->_host}:{$this->_port}";
+			}
 
 			$errstr = trim($errstr);
 			$this->_error = "connection to $location failed (errno=$errno, msg=$errstr)";
@@ -645,8 +674,9 @@ 
 				}
 			}
 		}
-		if ($this->_socket === false)
-			fclose($fp);
+		if ($this->_socket === false) {
+					fclose($fp);
+		}
 
 		// check response
 		$read = strlen($response);
@@ -706,10 +736,12 @@ 
 		assert($max >= 0);
 		$this->_offset = $offset;
 		$this->_limit = $limit;
-		if ($max > 0)
-			$this->_maxmatches = $max;
-		if ($cutoff > 0)
-			$this->_cutoff = $cutoff;
+		if ($max > 0) {
+					$this->_maxmatches = $max;
+		}
+		if ($cutoff > 0) {
+					$this->_cutoff = $cutoff;
+		}
 	}
 
 	/// set maximum query time, in milliseconds, per-index
@@ -763,8 +795,9 @@ 
 	public function SetWeights($weights)
 	{
 		assert(is_array($weights));
-		foreach ($weights as $weight)
-			assert(is_int($weight));
+		foreach ($weights as $weight) {
+					assert(is_int($weight));
+		}
 
 		$this->_weights = $weights;
 	}
@@ -814,8 +847,9 @@ 
 
 		if (is_array($values) && count($values))
 		{
-			foreach ($values as $value)
-				assert(is_numeric($value));
+			foreach ($values as $value) {
+							assert(is_numeric($value));
+			}
 
 			$this->_filters[] = array("type"=>SPH_FILTER_VALUES, "attr"=>$attribute, "exclude"=>$exclude, "values"=>$values);
 		}
@@ -954,15 +988,18 @@ 
 		$results = $this->RunQueries();
 		$this->_reqs = array(); // just in case it failed too early
 
-		if (!is_array($results))
-			return false; // probably network error; error message should be already filled
+		if (!is_array($results)) {
+					return false;
+		}
+		// probably network error; error message should be already filled
 
 		$this->_error = $results[0]["error"];
 		$this->_warning = $results[0]["warning"];
-		if ($results[0]["status"] == SEARCHD_ERROR)
-			return false;
-		else
-			return $results[0];
+		if ($results[0]["status"] == SEARCHD_ERROR) {
+					return false;
+		} else {
+					return $results[0];
+		}
 	}
 
 	/// helper to pack floats in network byte order
@@ -989,8 +1026,9 @@ 
 		$req .= pack("N", strlen($this->_sortby)).$this->_sortby;
 		$req .= pack("N", strlen($query)).$query; // query itself
 		$req .= pack("N", count($this->_weights)); // weights
-		foreach ($this->_weights as $weight)
-			$req .= pack("N", (int) $weight);
+		foreach ($this->_weights as $weight) {
+					$req .= pack("N", (int) $weight);
+		}
 		$req .= pack("N", strlen($index)).$index; // indexes
 		$req .= pack("N", 1); // id64 range marker
 		$req .= sphPackU64($this->_min_id).sphPackU64($this->_max_id); // id64 range
@@ -1005,8 +1043,9 @@ 
 			{
 				case SPH_FILTER_VALUES:
 					$req .= pack("N", count($filter["values"]));
-					foreach ($filter["values"] as $value)
-						$req .= sphPackI64($value);
+					foreach ($filter["values"] as $value) {
+											$req .= sphPackI64($value);
+					}
 					break;
 
 				case SPH_FILTER_RANGE:
@@ -1045,16 +1084,18 @@ 
 
 		// per-index weights
 		$req .= pack("N", count($this->_indexweights));
-		foreach ($this->_indexweights as $idx=>$weight)
-			$req .= pack("N", strlen($idx)).$idx.pack("N", $weight);
+		foreach ($this->_indexweights as $idx=>$weight) {
+					$req .= pack("N", strlen($idx)).$idx.pack("N", $weight);
+		}
 
 		// max query time
 		$req .= pack("N", $this->_maxquerytime);
 
 		// per-field weights
 		$req .= pack("N", count($this->_fieldweights));
-		foreach ($this->_fieldweights as $field=>$weight)
-			$req .= pack("N", strlen($field)).$field.pack("N", $weight);
+		foreach ($this->_fieldweights as $field=>$weight) {
+					$req .= pack("N", strlen($field)).$field.pack("N", $weight);
+		}
 
 		// comment
 		$req .= pack("N", strlen($comment)).$comment;
@@ -1200,8 +1241,7 @@ 
 				{
 					$doc = sphUnpackU64(substr($response, $p, 8)); $p += 8;
 					list(,$weight) = unpack("N*", substr($response, $p, 4)); $p += 4;
-				}
-				else
+				} else
 				{
 					list ($doc, $weight) = array_values(unpack("N*N*",
 						substr($response, $p, 8)));
@@ -1211,10 +1251,11 @@ 
 				$weight = sprintf("%u", $weight);
 
 				// create match entry
-				if ($this->_arrayresult)
-					$result["matches"][$idx] = array("id"=>$doc, "weight"=>$weight);
-				else
-					$result["matches"][$doc]["weight"] = $weight;
+				if ($this->_arrayresult) {
+									$result["matches"][$idx] = array("id"=>$doc, "weight"=>$weight);
+				} else {
+									$result["matches"][$doc]["weight"] = $weight;
+				}
 
 				// parse and create attributes
 				$attrvals = array();
@@ -1257,10 +1298,11 @@ 
 					}
 				}
 
-				if ($this->_arrayresult)
-					$result["matches"][$idx]["attrs"] = $attrvals;
-				else
-					$result["matches"][$doc]["attrs"] = $attrvals;
+				if ($this->_arrayresult) {
+									$result["matches"][$idx]["attrs"] = $attrvals;
+				} else {
+									$result["matches"][$doc]["attrs"] = $attrvals;
+				}
 			}
 
 			list ($total, $total_found, $msecs, $words) =
@@ -1311,25 +1353,63 @@ 
 		// fixup options
 		/////////////////
 
-		if (!isset($opts["before_match"]))		$opts["before_match"] = "<b>";
-		if (!isset($opts["after_match"]))			$opts["after_match"] = "</b>";
-		if (!isset($opts["chunk_separator"]))		$opts["chunk_separator"] = " ... ";
-		if (!isset($opts["limit"]))				$opts["limit"] = 256;
-		if (!isset($opts["limit_passages"]))		$opts["limit_passages"] = 0;
-		if (!isset($opts["limit_words"]))			$opts["limit_words"] = 0;
-		if (!isset($opts["around"]))				$opts["around"] = 5;
-		if (!isset($opts["exact_phrase"]))		$opts["exact_phrase"] = false;
-		if (!isset($opts["single_passage"]))		$opts["single_passage"] = false;
-		if (!isset($opts["use_boundaries"]))		$opts["use_boundaries"] = false;
-		if (!isset($opts["weight_order"]))		$opts["weight_order"] = false;
-		if (!isset($opts["query_mode"]))			$opts["query_mode"] = false;
-		if (!isset($opts["force_all_words"]))		$opts["force_all_words"] = false;
-		if (!isset($opts["start_passage_id"]))	$opts["start_passage_id"] = 1;
-		if (!isset($opts["load_files"]))			$opts["load_files"] = false;
-		if (!isset($opts["html_strip_mode"]))		$opts["html_strip_mode"] = "index";
-		if (!isset($opts["allow_empty"]))			$opts["allow_empty"] = false;
-		if (!isset($opts["passage_boundary"]))	$opts["passage_boundary"] = "none";
-		if (!isset($opts["emit_zones"]))			$opts["emit_zones"] = false;
+		if (!isset($opts["before_match"])) {
+		    $opts["before_match"] = "<b>";
+		}
+		if (!isset($opts["after_match"])) {
+		    $opts["after_match"] = "</b>";
+		}
+		if (!isset($opts["chunk_separator"])) {
+		    $opts["chunk_separator"] = " ... ";
+		}
+		if (!isset($opts["limit"])) {
+		    $opts["limit"] = 256;
+		}
+		if (!isset($opts["limit_passages"])) {
+		    $opts["limit_passages"] = 0;
+		}
+		if (!isset($opts["limit_words"])) {
+		    $opts["limit_words"] = 0;
+		}
+		if (!isset($opts["around"])) {
+		    $opts["around"] = 5;
+		}
+		if (!isset($opts["exact_phrase"])) {
+		    $opts["exact_phrase"] = false;
+		}
+		if (!isset($opts["single_passage"])) {
+		    $opts["single_passage"] = false;
+		}
+		if (!isset($opts["use_boundaries"])) {
+		    $opts["use_boundaries"] = false;
+		}
+		if (!isset($opts["weight_order"])) {
+		    $opts["weight_order"] = false;
+		}
+		if (!isset($opts["query_mode"])) {
+		    $opts["query_mode"] = false;
+		}
+		if (!isset($opts["force_all_words"])) {
+		    $opts["force_all_words"] = false;
+		}
+		if (!isset($opts["start_passage_id"])) {
+		    $opts["start_passage_id"] = 1;
+		}
+		if (!isset($opts["load_files"])) {
+		    $opts["load_files"] = false;
+		}
+		if (!isset($opts["html_strip_mode"])) {
+		    $opts["html_strip_mode"] = "index";
+		}
+		if (!isset($opts["allow_empty"])) {
+		    $opts["allow_empty"] = false;
+		}
+		if (!isset($opts["passage_boundary"])) {
+		    $opts["passage_boundary"] = "none";
+		}
+		if (!isset($opts["emit_zones"])) {
+		    $opts["emit_zones"] = false;
+		}
 
 		/////////////////
 		// build request
@@ -1337,15 +1417,33 @@ 
 
 		// v.1.2 req
 		$flags = 1; // remove spaces
-		if ($opts["exact_phrase"])	$flags |= 2;
-		if ($opts["single_passage"])	$flags |= 4;
-		if ($opts["use_boundaries"])	$flags |= 8;
-		if ($opts["weight_order"])	$flags |= 16;
-		if ($opts["query_mode"])		$flags |= 32;
-		if ($opts["force_all_words"])	$flags |= 64;
-		if ($opts["load_files"])		$flags |= 128;
-		if ($opts["allow_empty"])		$flags |= 256;
-		if ($opts["emit_zones"])		$flags |= 512;
+		if ($opts["exact_phrase"]) {
+		    $flags |= 2;
+		}
+		if ($opts["single_passage"]) {
+		    $flags |= 4;
+		}
+		if ($opts["use_boundaries"]) {
+		    $flags |= 8;
+		}
+		if ($opts["weight_order"]) {
+		    $flags |= 16;
+		}
+		if ($opts["query_mode"]) {
+		    $flags |= 32;
+		}
+		if ($opts["force_all_words"]) {
+		    $flags |= 64;
+		}
+		if ($opts["load_files"]) {
+		    $flags |= 128;
+		}
+		if ($opts["allow_empty"]) {
+		    $flags |= 256;
+		}
+		if ($opts["emit_zones"]) {
+		    $flags |= 512;
+		}
 		$req = pack("NN", 0, $flags); // mode=0, flags=$flags
 		$req .= pack("N", strlen($index)).$index; // req index
 		$req .= pack("N", strlen($words)).$words; // req words
@@ -1512,8 +1610,9 @@ 
 		assert(is_bool($mva));
 
 		assert(is_array($attrs));
-		foreach ($attrs as $attr)
-			assert(is_string($attr));
+		foreach ($attrs as $attr) {
+					assert(is_string($attr));
+		}
 
 		assert(is_array($values));
 		foreach ($values as $id=>$entry)
@@ -1526,10 +1625,12 @@ 
 				if ($mva)
 				{
 					assert(is_array($v));
-					foreach ($v as $vv)
-						assert(is_int($vv));
-				} else
-					assert(is_int($v));
+					foreach ($v as $vv) {
+											assert(is_int($vv));
+					}
+				} else {
+									assert(is_int($v));
+				}
 			}
 		}
 
@@ -1551,9 +1652,10 @@ 
 			foreach ($entry as $v)
 			{
 				$req .= pack("N", $mva ? count($v) : $v);
-				if ($mva)
-					foreach ($v as $vv)
+				if ($mva) {
+									foreach ($v as $vv)
 						$req .= pack("N", $vv);
+				}
 			}
 		}
 
@@ -1595,13 +1697,15 @@ 
 			$this->_error = 'already connected';
 			return false;
 		}
-		if (!$fp = $this->_Connect())
-			return false;
+		if (!$fp = $this->_Connect()) {
+					return false;
+		}
 
 		// command, command version = 0, body length = 4, body = 1
 		$req = pack("nnNN", SEARCHD_COMMAND_PERSIST, 0, 4, 1);
-		if (!$this->_Send($fp, $req, 12))
-			return false;
+		if (!$this->_Send($fp, $req, 12)) {
+					return false;
+		}
 
 		$this->_socket = $fp;
 		return true;
@@ -1647,8 +1751,10 @@ 
 		list ($rows, $cols) = array_values(unpack("N*N*", substr($response, $p, 8))); $p += 8;
 
 		$res = array();
-		for ($i = 0; $i < $rows; $i++)
-			for ($j = 0; $j < $cols; $j++)
+		for ($i = 0; $i < $rows; $i++) {
+					for ($j = 0;
+		}
+		$j < $cols; $j++)
 		{
 			list(,$len) = unpack("N*", substr($response, $p, 4)); $p += 4;
 			$res[$i][] = substr($response, $p, $len); $p += $len;
@@ -1680,10 +1786,11 @@ 
 		}
 
 		$tag = -1;
-		if (strlen($response) == 4)
-			list(,$tag) = unpack("N*", $response);
-		else
-			$this->_error = "unexpected response length";
+		if (strlen($response) == 4) {
+					list(,$tag) = unpack("N*", $response);
+		} else {
+					$this->_error = "unexpected response length";
+		}
 
 		$this->_MBPop();
 		return $tag;

plugins/af_proxy_http/init.php

Indentation +189 added lines, -189 removed lines

@@ -1,223 +1,223 @@ 
 <?php
 class Af_Proxy_Http extends Plugin {
 
-	/* @var PluginHost $host */
-	private $host;
+    /* @var PluginHost $host */
+    private $host;
 
-	/* @var DiskCache $cache */
-	private $cache;
+    /* @var DiskCache $cache */
+    private $cache;
 
-	public function about() {
-		return array(1.0,
-			"Loads media served over plain HTTP via built-in secure proxy",
-			"fox");
-	}
+    public function about() {
+        return array(1.0,
+            "Loads media served over plain HTTP via built-in secure proxy",
+            "fox");
+    }
 
-	private $ssl_known_whitelist = "imgur.com gfycat.com i.reddituploads.com pbs.twimg.com i.redd.it i.sli.mg media.tumblr.com";
+    private $ssl_known_whitelist = "imgur.com gfycat.com i.reddituploads.com pbs.twimg.com i.redd.it i.sli.mg media.tumblr.com";
 
-	public function is_public_method($method) {
-		return $method === "imgproxy";
-	}
+    public function is_public_method($method) {
+        return $method === "imgproxy";
+    }
 
-	public function init($host) {
-		$this->host = $host;
-		$this->cache = new DiskCache("images");
+    public function init($host) {
+        $this->host = $host;
+        $this->cache = new DiskCache("images");
 
-		$host->add_hook($host::HOOK_RENDER_ARTICLE, $this, 150);
-		$host->add_hook($host::HOOK_RENDER_ARTICLE_CDM, $this, 150);
-		$host->add_hook($host::HOOK_ENCLOSURE_ENTRY, $this);
+        $host->add_hook($host::HOOK_RENDER_ARTICLE, $this, 150);
+        $host->add_hook($host::HOOK_RENDER_ARTICLE_CDM, $this, 150);
+        $host->add_hook($host::HOOK_ENCLOSURE_ENTRY, $this);
 
-		$host->add_hook($host::HOOK_PREFS_TAB, $this);
-	}
+        $host->add_hook($host::HOOK_PREFS_TAB, $this);
+    }
 
-	public function hook_enclosure_entry($enc) {
-		if (preg_match("/image/", $enc["content_type"])) {
-			$proxy_all = $this->host->get($this, "proxy_all");
+    public function hook_enclosure_entry($enc) {
+        if (preg_match("/image/", $enc["content_type"])) {
+            $proxy_all = $this->host->get($this, "proxy_all");
 
-			$enc["content_url"] = $this->rewrite_url_if_needed($enc["content_url"], $proxy_all);
-		}
+            $enc["content_url"] = $this->rewrite_url_if_needed($enc["content_url"], $proxy_all);
+        }
 
-		return $enc;
-	}
+        return $enc;
+    }
 
-	public function hook_render_article($article) {
-		return $this->hook_render_article_cdm($article);
-	}
+    public function hook_render_article($article) {
+        return $this->hook_render_article_cdm($article);
+    }
 
-	public function imgproxy() {
+    public function imgproxy() {
 
-		$url = rewrite_relative_url(get_self_url_prefix(), $_REQUEST["url"]);
+        $url = rewrite_relative_url(get_self_url_prefix(), $_REQUEST["url"]);
 
-		// called without user context, let's just redirect to original URL
-		if (!$_SESSION["uid"]) {
-			header("Location: $url");
-			return;
-		}
+        // called without user context, let's just redirect to original URL
+        if (!$_SESSION["uid"]) {
+            header("Location: $url");
+            return;
+        }
 
-		$local_filename = sha1($url);
+        $local_filename = sha1($url);
 
-		if ($this->cache->exists($local_filename)) {
-			header("Location: ".$this->cache->getUrl($local_filename));
-			return;
-			//$this->cache->send($local_filename);
-		} else {
-			$data = fetch_file_contents(["url" => $url, "max_size" => MAX_CACHE_FILE_SIZE]);
+        if ($this->cache->exists($local_filename)) {
+            header("Location: ".$this->cache->getUrl($local_filename));
+            return;
+            //$this->cache->send($local_filename);
+        } else {
+            $data = fetch_file_contents(["url" => $url, "max_size" => MAX_CACHE_FILE_SIZE]);
 
-			if ($data) {
+            if ($data) {
 
-				$disable_cache = $this->host->get($this, "disable_cache");
+                $disable_cache = $this->host->get($this, "disable_cache");
 
-				if (!$disable_cache) {
-					if ($this->cache->put($local_filename, $data)) {
-						header("Location: ".$this->cache->getUrl($local_filename));
-						return;
-					}
-				}
-
-				print $data;
-			} else {
-				global $fetch_last_error;
-				global $fetch_last_error_code;
-				global $fetch_last_error_content;
-
-				if (function_exists("imagecreate") && !isset($_REQUEST["text"])) {
-					$img = imagecreate(450, 75);
-
-					/*$bg =*/ imagecolorallocate($img, 255, 255, 255);
-					$textcolor = imagecolorallocate($img, 255, 0, 0);
+                if (!$disable_cache) {
+                    if ($this->cache->put($local_filename, $data)) {
+                        header("Location: ".$this->cache->getUrl($local_filename));
+                        return;
+                    }
+                }
 
-					imagerectangle($img, 0, 0, 450 - 1, 75 - 1, $textcolor);
+                print $data;
+            } else {
+                global $fetch_last_error;
+                global $fetch_last_error_code;
+                global $fetch_last_error_content;
 
-					imagestring($img, 5, 5, 5, "Proxy request failed", $textcolor);
-					imagestring($img, 5, 5, 30, truncate_middle($url, 46, "..."), $textcolor);
-					imagestring($img, 5, 5, 55, "HTTP Code: $fetch_last_error_code", $textcolor);
+                if (function_exists("imagecreate") && !isset($_REQUEST["text"])) {
+                    $img = imagecreate(450, 75);
 
-					header("Content-type: image/png");
-					print imagepng($img);
-					imagedestroy($img);
+                    /*$bg =*/ imagecolorallocate($img, 255, 255, 255);
+                    $textcolor = imagecolorallocate($img, 255, 0, 0);
 
-				} else {
-					header("Content-type: text/html");
-
-					http_response_code(400);
-
-					print "<h1>Proxy request failed.</h1>";
-					print "<p>Fetch error $fetch_last_error ($fetch_last_error_code)</p>";
-					print "<p>URL: $url</p>";
-					print "<textarea cols='80' rows='25'>".htmlspecialchars($fetch_last_error_content)."</textarea>";
-				}
-			}
-		}
-	}
+                    imagerectangle($img, 0, 0, 450 - 1, 75 - 1, $textcolor);
 
-	private function rewrite_url_if_needed($url, $all_remote = false) {
-		/* we don't need to handle URLs where local cache already exists, tt-rss rewrites those automatically */
-		if (!$this->cache->exists(sha1($url))) {
+                    imagestring($img, 5, 5, 5, "Proxy request failed", $textcolor);
+                    imagestring($img, 5, 5, 30, truncate_middle($url, 46, "..."), $textcolor);
+                    imagestring($img, 5, 5, 55, "HTTP Code: $fetch_last_error_code", $textcolor);
 
-			$scheme = parse_url($url, PHP_URL_SCHEME);
+                    header("Content-type: image/png");
+                    print imagepng($img);
+                    imagedestroy($img);
 
-			if ($all_remote) {
-				$host = parse_url($url, PHP_URL_HOST);
-				$self_host = parse_url(get_self_url_prefix(), PHP_URL_HOST);
+                } else {
+                    header("Content-type: text/html");
 
-				$is_remote = $host != $self_host;
-			} else {
-				$is_remote = false;
-			}
+                    http_response_code(400);
 
-			if (($scheme != 'https' && $scheme != "") || $is_remote) {
-				if (strpos($url, "data:") !== 0) {
-					$parts = parse_url($url);
-
-					foreach (explode(" ", $this->ssl_known_whitelist) as $host) {
-						if (substr(strtolower($parts['host']), -strlen($host)) === strtolower($host)) {
-							$parts['scheme'] = 'https';
-							$url = build_url($parts);
-							if ($all_remote && $is_remote) {
-								break;
-							} else {
-								return $url;
-							}
-						}
-					}
+                    print "<h1>Proxy request failed.</h1>";
+                    print "<p>Fetch error $fetch_last_error ($fetch_last_error_code)</p>";
+                    print "<p>URL: $url</p>";
+                    print "<textarea cols='80' rows='25'>".htmlspecialchars($fetch_last_error_content)."</textarea>";
+                }
+            }
+        }
+    }
 
-					return $this->host->get_public_method_url($this, "imgproxy", ["url" => $url]);
-				}
-			}
-		}
+    private function rewrite_url_if_needed($url, $all_remote = false) {
+        /* we don't need to handle URLs where local cache already exists, tt-rss rewrites those automatically */
+        if (!$this->cache->exists(sha1($url))) {
 
-		return $url;
-	}
+            $scheme = parse_url($url, PHP_URL_SCHEME);
 
-	/**
-	 * @SuppressWarnings(PHPMD.UnusedFormalParameter)
-	 */
-	public function hook_render_article_cdm($article, $api_mode = false) {
+            if ($all_remote) {
+                $host = parse_url($url, PHP_URL_HOST);
+                $self_host = parse_url(get_self_url_prefix(), PHP_URL_HOST);
 
-		$need_saving = false;
-		$proxy_all = $this->host->get($this, "proxy_all");
+                $is_remote = $host != $self_host;
+            } else {
+                $is_remote = false;
+            }
 
-		$doc = new DOMDocument();
-		if (@$doc->loadHTML('<?xml encoding="UTF-8">'.$article["content"])) {
-			$xpath = new DOMXPath($doc);
-			$imgs = $xpath->query("//img[@src]");
+            if (($scheme != 'https' && $scheme != "") || $is_remote) {
+                if (strpos($url, "data:") !== 0) {
+                    $parts = parse_url($url);
 
-			foreach ($imgs as $img) {
-				$new_src = $this->rewrite_url_if_needed($img->getAttribute("src"), $proxy_all);
+                    foreach (explode(" ", $this->ssl_known_whitelist) as $host) {
+                        if (substr(strtolower($parts['host']), -strlen($host)) === strtolower($host)) {
+                            $parts['scheme'] = 'https';
+                            $url = build_url($parts);
+                            if ($all_remote && $is_remote) {
+                                break;
+                            } else {
+                                return $url;
+                            }
+                        }
+                    }
 
-				if ($new_src != $img->getAttribute("src")) {
-					$img->setAttribute("src", $new_src);
-					$img->removeAttribute("srcset");
+                    return $this->host->get_public_method_url($this, "imgproxy", ["url" => $url]);
+                }
+            }
+        }
 
-					$need_saving = true;
-				}
-			}
+        return $url;
+    }
+
+    /**
+     * @SuppressWarnings(PHPMD.UnusedFormalParameter)
+     */
+    public function hook_render_article_cdm($article, $api_mode = false) {
 
-			$vids = $xpath->query("(//video|//picture)");
+        $need_saving = false;
+        $proxy_all = $this->host->get($this, "proxy_all");
+
+        $doc = new DOMDocument();
+        if (@$doc->loadHTML('<?xml encoding="UTF-8">'.$article["content"])) {
+            $xpath = new DOMXPath($doc);
+            $imgs = $xpath->query("//img[@src]");
 
-			foreach ($vids as $vid) {
-				if ($vid->hasAttribute("poster")) {
-					$new_src = $this->rewrite_url_if_needed($vid->getAttribute("poster"), $proxy_all);
+            foreach ($imgs as $img) {
+                $new_src = $this->rewrite_url_if_needed($img->getAttribute("src"), $proxy_all);
 
-					if ($new_src != $vid->getAttribute("poster")) {
-						$vid->setAttribute("poster", $new_src);
+                if ($new_src != $img->getAttribute("src")) {
+                    $img->setAttribute("src", $new_src);
+                    $img->removeAttribute("srcset");
+
+                    $need_saving = true;
+                }
+            }
 
-						$need_saving = true;
-					}
-				}
+            $vids = $xpath->query("(//video|//picture)");
 
-				$vsrcs = $xpath->query("source", $vid);
+            foreach ($vids as $vid) {
+                if ($vid->hasAttribute("poster")) {
+                    $new_src = $this->rewrite_url_if_needed($vid->getAttribute("poster"), $proxy_all);
 
-				foreach ($vsrcs as $vsrc) {
-					$new_src = $this->rewrite_url_if_needed($vsrc->getAttribute("src"), $proxy_all);
+                    if ($new_src != $vid->getAttribute("poster")) {
+                        $vid->setAttribute("poster", $new_src);
 
-					if ($new_src != $vsrc->getAttribute("src")) {
-						$vid->setAttribute("src", $new_src);
+                        $need_saving = true;
+                    }
+                }
 
-						$need_saving = true;
-					}
-				}
-			}
-		}
+                $vsrcs = $xpath->query("source", $vid);
 
-		if ($need_saving) {
-		    $article["content"] = $doc->saveHTML();
-		}
+                foreach ($vsrcs as $vsrc) {
+                    $new_src = $this->rewrite_url_if_needed($vsrc->getAttribute("src"), $proxy_all);
 
-		return $article;
-	}
+                    if ($new_src != $vsrc->getAttribute("src")) {
+                        $vid->setAttribute("src", $new_src);
+
+                        $need_saving = true;
+                    }
+                }
+            }
+        }
+
+        if ($need_saving) {
+            $article["content"] = $doc->saveHTML();
+        }
+
+        return $article;
+    }
 
-	public function hook_prefs_tab($args) {
-		if ($args != "prefFeeds") {
-		    return;
-		}
+    public function hook_prefs_tab($args) {
+        if ($args != "prefFeeds") {
+            return;
+        }
 
-		print "<div dojoType=\"dijit.layout.AccordionPane\"
+        print "<div dojoType=\"dijit.layout.AccordionPane\"
 			title=\"<i class='material-icons'>extension</i> ".__('Image proxy settings (af_proxy_http)')."\">";
 
-		print "<form dojoType=\"dijit.form.Form\">";
+        print "<form dojoType=\"dijit.form.Form\">";
 
-		print "<script type=\"dojo/method\" event=\"onSubmit\" args=\"evt\">
+        print "<script type=\"dojo/method\" event=\"onSubmit\" args=\"evt\">
 			evt.preventDefault();
 			if (this.validate()) {
 				console.log(dojo.objectToQuery(this.getValues()));
@@ -231,36 +231,36 @@ 
 			}
 			</script>";
 
-		print_hidden("op", "pluginhandler");
-		print_hidden("method", "save");
-		print_hidden("plugin", "af_proxy_http");
+        print_hidden("op", "pluginhandler");
+        print_hidden("method", "save");
+        print_hidden("plugin", "af_proxy_http");
 
-		$proxy_all = $this->host->get($this, "proxy_all");
-		print_checkbox("proxy_all", $proxy_all);
-		print "&nbsp;<label for=\"proxy_all\">".__("Enable proxy for all remote images.")."</label><br/>";
+        $proxy_all = $this->host->get($this, "proxy_all");
+        print_checkbox("proxy_all", $proxy_all);
+        print "&nbsp;<label for=\"proxy_all\">".__("Enable proxy for all remote images.")."</label><br/>";
 
-		$disable_cache = $this->host->get($this, "disable_cache");
-		print_checkbox("disable_cache", $disable_cache);
-		print "&nbsp;<label for=\"disable_cache\">".__("Don't cache files locally.")."</label>";
+        $disable_cache = $this->host->get($this, "disable_cache");
+        print_checkbox("disable_cache", $disable_cache);
+        print "&nbsp;<label for=\"disable_cache\">".__("Don't cache files locally.")."</label>";
 
-		print "<p>"; print_button("submit", __("Save"));
+        print "<p>"; print_button("submit", __("Save"));
 
-		print "</form>";
+        print "</form>";
 
-		print "</div>";
-	}
+        print "</div>";
+    }
 
-	public function save() {
-		$proxy_all = checkbox_to_sql_bool($_POST["proxy_all"]);
-		$disable_cache = checkbox_to_sql_bool($_POST["disable_cache"]);
+    public function save() {
+        $proxy_all = checkbox_to_sql_bool($_POST["proxy_all"]);
+        $disable_cache = checkbox_to_sql_bool($_POST["disable_cache"]);
 
-		$this->host->set($this, "proxy_all", $proxy_all, false);
-		$this->host->set($this, "disable_cache", $disable_cache);
+        $this->host->set($this, "proxy_all", $proxy_all, false);
+        $this->host->set($this, "disable_cache", $disable_cache);
 
-		echo __("Configuration saved");
-	}
+        echo __("Configuration saved");
+    }
 
-	public function api_version() {
-		return 2;
-	}
+    public function api_version() {
+        return 2;
+    }
 }

plugins/af_unburn/init.php

Indentation +60 added lines, -60 removed lines

@@ -1,87 +1,87 @@
 <?php
 class Af_Unburn extends Plugin {
-	private $host;
+    private $host;
 
-	public function about() {
-		return array(1.0,
-			"Resolves feedburner and similar feed redirector URLs (requires CURL)",
-			"fox");
-	}
+    public function about() {
+        return array(1.0,
+            "Resolves feedburner and similar feed redirector URLs (requires CURL)",
+            "fox");
+    }
 
-	public function flags() {
-		return array("needs_curl" => true);
-	}
+    public function flags() {
+        return array("needs_curl" => true);
+    }
 
-	public function init($host) {
-		$this->host = $host;
+    public function init($host) {
+        $this->host = $host;
 
-		$host->add_hook($host::HOOK_ARTICLE_FILTER, $this);
-	}
+        $host->add_hook($host::HOOK_ARTICLE_FILTER, $this);
+    }
 
-	public function hook_article_filter($article) {
-		$owner_uid = $article["owner_uid"];
+    public function hook_article_filter($article) {
+        $owner_uid = $article["owner_uid"];
 
-		if (defined('NO_CURL') || !function_exists("curl_init") || ini_get("open_basedir")) {
-					return $article;
-		}
+        if (defined('NO_CURL') || !function_exists("curl_init") || ini_get("open_basedir")) {
+                    return $article;
+        }
 
-		if ((strpos($article["link"], "feedproxy.google.com") !== false ||
-		  		strpos($article["link"], "/~r/") !== false ||
-				strpos($article["link"], "feedsportal.com") !== false)) {
+        if ((strpos($article["link"], "feedproxy.google.com") !== false ||
+                  strpos($article["link"], "/~r/") !== false ||
+                strpos($article["link"], "feedsportal.com") !== false)) {
 
-				$ch = curl_init($article["link"]);
+                $ch = curl_init($article["link"]);
 
-				curl_setopt($ch, CURLOPT_TIMEOUT, 5);
-				curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
-				curl_setopt($ch, CURLOPT_HEADER, true);
-				curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);
-				curl_setopt($ch, CURLOPT_NOBODY, true);
-				curl_setopt($ch, CURLOPT_USERAGENT, SELF_USER_AGENT);
+                curl_setopt($ch, CURLOPT_TIMEOUT, 5);
+                curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
+                curl_setopt($ch, CURLOPT_HEADER, true);
+                curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);
+                curl_setopt($ch, CURLOPT_NOBODY, true);
+                curl_setopt($ch, CURLOPT_USERAGENT, SELF_USER_AGENT);
 
-				if (defined('_CURL_HTTP_PROXY')) {
-					curl_setopt($ch, CURLOPT_PROXY, _CURL_HTTP_PROXY);
-				}
+                if (defined('_CURL_HTTP_PROXY')) {
+                    curl_setopt($ch, CURLOPT_PROXY, _CURL_HTTP_PROXY);
+                }
 
-				@curl_exec($ch);
+                @curl_exec($ch);
 
-				$real_url = curl_getinfo($ch, CURLINFO_EFFECTIVE_URL);
+                $real_url = curl_getinfo($ch, CURLINFO_EFFECTIVE_URL);
 
-				curl_close($ch);
+                curl_close($ch);
 
-				if ($real_url) {
-					/* remove the rest of it */
+                if ($real_url) {
+                    /* remove the rest of it */
 
-					$query = parse_url($real_url, PHP_URL_QUERY);
+                    $query = parse_url($real_url, PHP_URL_QUERY);
 
-					if ($query && strpos($query, "utm_source") !== false) {
-						$args = array();
-						parse_str($query, $args);
+                    if ($query && strpos($query, "utm_source") !== false) {
+                        $args = array();
+                        parse_str($query, $args);
 
-						foreach (array("utm_source", "utm_medium", "utm_campaign") as $param) {
-							if (isset($args[$param])) {
-							    unset($args[$param]);
-							}
-						}
+                        foreach (array("utm_source", "utm_medium", "utm_campaign") as $param) {
+                            if (isset($args[$param])) {
+                                unset($args[$param]);
+                            }
+                        }
 
-						$new_query = http_build_query($args);
+                        $new_query = http_build_query($args);
 
-						if ($new_query != $query) {
-							$real_url = str_replace("?$query", "?$new_query", $real_url);
-						}
-					}
+                        if ($new_query != $query) {
+                            $real_url = str_replace("?$query", "?$new_query", $real_url);
+                        }
+                    }
 
-					$real_url = preg_replace("/\?$/", "", $real_url);
+                    $real_url = preg_replace("/\?$/", "", $real_url);
 
-					$article["plugin_data"] = "unburn,$owner_uid:".$article["plugin_data"];
-					$article["link"] = $real_url;
-				}
-		}
+                    $article["plugin_data"] = "unburn,$owner_uid:".$article["plugin_data"];
+                    $article["link"] = $real_url;
+                }
+        }
 
-		return $article;
-	}
+        return $article;
+    }
 
-	public function api_version() {
-		return 2;
-	}
+    public function api_version() {
+        return 2;
+    }
 
 }

plugins/note/init.php

Indentation +46 added lines, -46 removed lines

@@ -1,78 +1,78 @@
 <?php
 class Note extends Plugin {
 
-	/* @var PluginHost $host */
-	private $host;
+    /* @var PluginHost $host */
+    private $host;
 
-	public function about() {
-		return array(1.0,
-			"Adds support for setting article notes",
-			"fox");
-	}
+    public function about() {
+        return array(1.0,
+            "Adds support for setting article notes",
+            "fox");
+    }
 
-	public function init($host) {
-		$this->host = $host;
+    public function init($host) {
+        $this->host = $host;
 
-		$host->add_hook($host::HOOK_ARTICLE_BUTTON, $this);
-	}
+        $host->add_hook($host::HOOK_ARTICLE_BUTTON, $this);
+    }
 
-	public function get_js() {
-		return file_get_contents(dirname(__FILE__)."/note.js");
-	}
+    public function get_js() {
+        return file_get_contents(dirname(__FILE__)."/note.js");
+    }
 
 
-	public function hook_article_button($line) {
-		return "<i class='material-icons' onclick=\"Plugins.Note.edit(".$line["id"].")\"
+    public function hook_article_button($line) {
+        return "<i class='material-icons' onclick=\"Plugins.Note.edit(".$line["id"].")\"
 			style='cursor : pointer' title='".__('Edit article note')."'>note</i>";
-	}
+    }
 
-	public function edit() {
-		$param = $_REQUEST['param'];
+    public function edit() {
+        $param = $_REQUEST['param'];
 
-		$sth = $this->pdo->prepare("SELECT note FROM ttrss_user_entries WHERE
+        $sth = $this->pdo->prepare("SELECT note FROM ttrss_user_entries WHERE
 			ref_id = ? AND owner_uid = ?");
-		$sth->execute([$param, $_SESSION['uid']]);
+        $sth->execute([$param, $_SESSION['uid']]);
 
-		if ($row = $sth->fetch()) {
+        if ($row = $sth->fetch()) {
 
-			$note = $row['note'];
+            $note = $row['note'];
 
-			print_hidden("id", "$param");
-			print_hidden("op", "pluginhandler");
-			print_hidden("method", "setNote");
-			print_hidden("plugin", "note");
+            print_hidden("id", "$param");
+            print_hidden("op", "pluginhandler");
+            print_hidden("method", "setNote");
+            print_hidden("plugin", "note");
 
-			print "<textarea dojoType='dijit.form.SimpleTextarea'
+            print "<textarea dojoType='dijit.form.SimpleTextarea'
 				style='font-size : 12px; width : 98%; height: 100px;'
 				name='note'>$note</textarea>";
 
-		}
+        }
 
-		print "<footer class='text-center'>";
-		print "<button dojoType=\"dijit.form.Button\"
+        print "<footer class='text-center'>";
+        print "<button dojoType=\"dijit.form.Button\"
 			onclick=\"dijit.byId('editNoteDlg').execute()\">".__('Save')."</button> ";
-		print "<button dojoType=\"dijit.form.Button\"
+        print "<button dojoType=\"dijit.form.Button\"
 			onclick=\"dijit.byId('editNoteDlg').hide()\">".__('Cancel')."</button>";
-		print "</footer>";
+        print "</footer>";
 
-	}
+    }
 
-	public function setNote() {
-		$id = $_REQUEST["id"];
-		$note = trim(strip_tags($_REQUEST["note"]));
+    public function setNote() {
+        $id = $_REQUEST["id"];
+        $note = trim(strip_tags($_REQUEST["note"]));
 
-		$sth = $this->pdo->prepare("UPDATE ttrss_user_entries SET note = ?
+        $sth = $this->pdo->prepare("UPDATE ttrss_user_entries SET note = ?
 			WHERE ref_id = ? AND owner_uid = ?");
-		$sth->execute([$note, $id, $_SESSION['uid']]);
+        $sth->execute([$note, $id, $_SESSION['uid']]);
 
-		$formatted_note = Article::format_article_note($id, $note);
+        $formatted_note = Article::format_article_note($id, $note);
 
-		print json_encode(array("note" => $formatted_note,
-				"raw_length" => mb_strlen($note)));
-	}
+        print json_encode(array("note" => $formatted_note,
+                "raw_length" => mb_strlen($note)));
+    }
 
-	public function api_version() {
-		return 2;
-	}
+    public function api_version() {
+        return 2;
+    }
 
 }