+ 'title' => 'ACP_EXTENSIONS_MANAGEMENT',

+ 'main' => array('title' => 'ACP_EXTENSIONS', 'auth' => 'acl_a_extensions', 'cat' => array('ACP_EXTENSIONS_MANAGEMENT')),

+ 'lang_packs' => array('title' => 'ACP_LANGUAGE_PACKS', 'auth' => 'acl_a_language', 'cat' => array('ACP_LANGUAGE')),

+ $template = new phpbb_template($phpbb_root_path, $phpEx, $config, $user, $style_resource_locator, new phpbb_template_context(), $phpbb_extension_manager);

+ * {@inheritDoc}

+ function sql_save(phpbb_db_driver $db, $query, $query_result, $ttl)

+ * @param phpbb_db_driver $db Database connection

+ public function sql_save(phpbb_db_driver $db, $query, $query_result, $ttl);

+ * {@inheritDoc}

+ function sql_save(phpbb_db_driver $db, $query, $query_result, $ttl)

+ * {@inheritDoc}

+ function sql_save(phpbb_db_driver $db, $query, $query_result, $ttl)

+ * @var phpbb_db_driver

+ * @param phpbb_db_driver $db Database connection

+ public function __construct(phpbb_db_driver $db, phpbb_cache_driver_interface $cache, $table)

+ * @param phpbb_db_driver $db The db connection

+ public function __construct($phpbb_root_path, $php_ext, phpbb_config $config, phpbb_db_driver $db)

+ * @param phpbb_db_driver $db The db connection

+ public function __construct($phpbb_root_path, $php_ext, phpbb_config $config, phpbb_db_driver $db)

+ * @param phpbb_db_driver $db The db connection

+ public function __construct($phpbb_root_path, $php_ext, phpbb_auth $auth, phpbb_config $config, phpbb_db_driver $db, phpbb_user $user)

+ * @param phpbb_db_driver $db Database connection

+class phpbb_db_driver

+ function __construct()

+ 'cached' => 0,

+ 'normal' => 0,

+ 'total' => 0,

+ $this->sql_layer = substr(get_class($this), strlen('phpbb_db_driver_'));

+class phpbb_db_driver_firebird extends phpbb_db_driver

+ $this->query_result = $cache->sql_save($this, $query, $this->query_result, $cache_ttl);

+class phpbb_db_driver_mssql extends phpbb_db_driver

+ $this->query_result = $cache->sql_save($this, $query, $this->query_result, $cache_ttl);

+class phpbb_db_driver_mssql_odbc extends phpbb_db_driver

+ $this->query_result = $cache->sql_save($this, $query, $this->query_result, $cache_ttl);

+class phpbb_db_driver_mssqlnative extends phpbb_db_driver

+ $this->query_result = $cache->sql_save($this, $query, $this->query_result, $cache_ttl);

+class phpbb_db_driver_mysql extends phpbb_db_driver

+ $this->query_result = $cache->sql_save($this, $query, $this->query_result, $cache_ttl);

+class phpbb_db_driver_mysqli extends phpbb_db_driver

+ $this->query_result = $cache->sql_save($this, $query, $this->query_result, $cache_ttl);

+class phpbb_db_driver_oracle extends phpbb_db_driver

+ $this->query_result = $cache->sql_save($this, $query, $this->query_result, $cache_ttl);

+class phpbb_db_driver_postgres extends phpbb_db_driver

+ $this->query_result = $cache->sql_save($this, $query, $this->query_result, $cache_ttl);

+class phpbb_db_driver_sqlite extends phpbb_db_driver

+ $this->query_result = $cache->sql_save($this, $query, $this->query_result, $cache_ttl);

+ $container->setParameter('cache.driver.class', $this->convert_30_acm_type($acm_type));

+ $container->setParameter('dbal.driver.class', phpbb_convert_30_dbms_to_31($dbms));

+ * Convert 3.0 ACM type to 3.1 cache driver class name

+ * @param string $acm_type ACM type

+ * @return cache driver class

+ protected function convert_30_acm_type($acm_type)

+ * @param phpbb_db_driver $db A database connection

+ public function __construct(phpbb_db_driver $db, phpbb_config $config, $extension_table, $phpbb_root_path, $php_ext = '.php', phpbb_cache_driver_interface $cache = null, $cache_name = '_ext')

+ * @param phpbb_db_driver $db A database connection

+ public function __construct($ext_name, phpbb_db_driver $db, phpbb_extension_manager $extension_manager, $phpbb_root_path, $phpEx = '.php', phpbb_template $template, phpbb_config $config)

+* Convert either 3.0 dbms or 3.1 db driver class name to 3.1 db driver class name.

+*

+* If $dbms is a valid 3.1 db driver class name, returns it unchanged.

+* Otherwise prepends phpbb_db_driver_ to the dbms to convert a 3.0 dbms

+* to 3.1 db driver class name.

+*

+* @param string $dbms dbms parameter

+* @return db driver class

+*/

+function phpbb_convert_30_dbms_to_31($dbms)

+{

+ // Note: this check is done first because mysqli extension

+ // supplies a mysqli class, and class_exists($dbms) would return

+ // true for mysqli class.

+ // However, per the docblock any valid 3.1 driver name should be

+ // recognized by this function, and have priority over 3.0 dbms.

+ if (class_exists('phpbb_db_driver_' . $dbms))

+ {

+ return 'phpbb_db_driver_' . $dbms;

+ }

+

+ if (class_exists($dbms))

+ {

+ // Additionally we could check that $dbms extends phpbb_db_driver.

+ // http://php.net/manual/en/class.reflectionclass.php

+ // Beware of possible performance issues:

+ // http://stackoverflow.com/questions/294582/php-5-reflection-api-performance

+ // We could check for interface implementation in all paths or

+ // only when we do not prepend phpbb_db_driver_.

+

+ /*

+ $reflection = new \ReflectionClass($dbms);

+

+ if ($reflection->isSubclassOf('phpbb_db_driver'))

+ {

+ return $dbms;

+ }

+ */

+

+ return $dbms;

+ }

+

+ throw new \RuntimeException("You have specified an invalid dbms driver: $dbms");

+}

+

+/**

+<?php

+/**

+*

+* @package phpBB3

+* @copyright (c) 2012 phpBB Group

+* @license http://opensource.org/licenses/gpl-2.0.php GNU General Public License v2

+*

+*/

+

+/**

+* @ignore

+*/

+if (!defined('IN_PHPBB'))

+{

+ exit;

+}

+

+/**

+* Updates rows in given table from a set of values to a new value.

+* If this results in rows violating uniqueness constraints, the duplicate

+* rows are eliminated.

+*

+* The only supported table is bookmarks.

+*

+* @param phpbb_db_driver $db Database object

+* @param string $table Table on which to perform the update

+* @param string $column Column whose values to change

+* @param array $from_values An array of values that should be changed

+* @param int $to_value The new value

+* @return null

+*/

+function phpbb_update_rows_avoiding_duplicates(phpbb_db_driver $db, $table, $column, $from_values, $to_value)

+{

+ $sql = "SELECT $column, user_id

+ FROM $table

+ WHERE " . $db->sql_in_set($column, $from_values);

+ $result = $db->sql_query($sql);

+

+ $old_user_ids = array();

+ while ($row = $db->sql_fetchrow($result))

+ {

+ $old_user_ids[$row[$column]][] = (int) $row['user_id'];

+ }

+ $db->sql_freeresult($result);

+

+ $sql = "SELECT $column, user_id

+ FROM $table

+ WHERE $column = " . (int) $to_value;

+ $result = $db->sql_query($sql);

+

+ $new_user_ids = array();

+ while ($row = $db->sql_fetchrow($result))

+ {

+ $new_user_ids[$row[$column]][] = (int) $row['user_id'];

+ }

+ $db->sql_freeresult($result);

+

+ $queries = array();

+ foreach ($from_values as $from_value)

+ {

+ if (!isset($old_user_ids[$from_value]))

+ {

+ continue;

+ }

+ if (empty($new_user_ids))

+ {

+ $sql = "UPDATE $table

+ SET $column = " . (int) $to_value . "

+ WHERE $column = '" . $db->sql_escape($from_value) . "'";

+ $queries[] = $sql;

+ }

+ else

+ {

+ $different_user_ids = array_diff($old_user_ids[$from_value], $new_user_ids[$to_value]);

+ if (!empty($different_user_ids))

+ {

+ $sql = "UPDATE $table

+ SET $column = " . (int) $to_value . "

+ WHERE $column = '" . $db->sql_escape($from_value) . "'

+ AND " . $db->sql_in_set('user_id', $different_user_ids);

+ $queries[] = $sql;

+ }

+ }

+ }

+

+ if (!empty($queries))

+ {

+ $db->sql_transaction('begin');

+

+ foreach ($queries as $sql)

+ {

+ $db->sql_query($sql);

+ }

+

+ $sql = "DELETE FROM $table

+ WHERE " . $db->sql_in_set($column, $from_values);

+ $db->sql_query($sql);

+

+ $db->sql_transaction('commit');

+ }

+}

+

+/**

+* Updates rows in given table from a set of values to a new value.

+* If this results in rows violating uniqueness constraints, the duplicate

+* rows are merged respecting notify_status (0 takes precedence over 1).

+*

+* The only supported table is topics_watch.

+*

+* @param phpbb_db_driver $db Database object

+* @param string $table Table on which to perform the update

+* @param string $column Column whose values to change

+* @param array $from_values An array of values that should be changed

+* @param int $to_value The new value

+* @return null

+*/

+function phpbb_update_rows_avoiding_duplicates_notify_status(phpbb_db_driver $db, $table, $column, $from_values, $to_value)

+{

+ $sql = "SELECT $column, user_id, notify_status

+ FROM $table

+ WHERE " . $db->sql_in_set($column, $from_values);

+ $result = $db->sql_query($sql);

+

+ $old_user_ids = array();

+ while ($row = $db->sql_fetchrow($result))

+ {

+ $old_user_ids[(int) $row['notify_status']][$row[$column]][] = (int) $row['user_id'];

+ }

+ $db->sql_freeresult($result);

+

+ $sql = "SELECT $column, user_id

+ FROM $table

+ WHERE $column = " . (int) $to_value;

+ $result = $db->sql_query($sql);

+

+ $new_user_ids = array();

+ while ($row = $db->sql_fetchrow($result))

+ {

+ $new_user_ids[$row[$column]][] = (int) $row['user_id'];

+ }

+ $db->sql_freeresult($result);

+

+ $queries = array();

+ $extra_updates = array(

+ 0 => 'notify_status = 0',

+ 1 => '',

+ );

+ foreach ($from_values as $from_value)

+ {

+ foreach ($extra_updates as $notify_status => $extra_update)

+ {

+ if (!isset($old_user_ids[$notify_status][$from_value]))

+ {

+ continue;

+ }

+ if (empty($new_user_ids))

+ {

+ $sql = "UPDATE $table

+ SET $column = " . (int) $to_value . "

+ WHERE $column = '" . $db->sql_escape($from_value) . "'";

+ $queries[] = $sql;

+ }

+ else

+ {

+ $different_user_ids = array_diff($old_user_ids[$notify_status][$from_value], $new_user_ids[$to_value]);

+ if (!empty($different_user_ids))

+ {

+ $sql = "UPDATE $table

+ SET $column = " . (int) $to_value . "

+ WHERE $column = '" . $db->sql_escape($from_value) . "'

+ AND " . $db->sql_in_set('user_id', $different_user_ids);

+ $queries[] = $sql;

+ }

+

+ if ($extra_update)

+ {

+ $same_user_ids = array_diff($old_user_ids[$notify_status][$from_value], $different_user_ids);

+ if (!empty($same_user_ids))

+ {

+ $sql = "UPDATE $table

+ SET $extra_update

+ WHERE $column = '" . (int) $to_value . "'

+ AND " . $db->sql_in_set('user_id', $same_user_ids);

+ $queries[] = $sql;

+ }

+ }

+ }

+ }

+ }

+

+ if (!empty($queries))

+ {

+ $db->sql_transaction('begin');

+

+ foreach ($queries as $sql)

+ {

+ $db->sql_query($sql);

+ }

+

+ $sql = "DELETE FROM $table

+ WHERE " . $db->sql_in_set($column, $from_values);

+ $db->sql_query($sql);

+

+ $db->sql_transaction('commit');

+ }

+}

+ if ($request->is_ajax())

+ {

+ // Tell the ajax script what language vars and URL need to be replaced

+ $data = array(

+ 'NO_UNREAD_POSTS' => $user->lang['NO_UNREAD_POSTS'],

+ 'UNREAD_POSTS' => $user->lang['UNREAD_POSTS'],

+ 'U_MARK_FORUMS' => ($user->data['is_registered'] || $config['load_anon_lastread']) ? append_sid("{$phpbb_root_path}index.$phpEx", 'hash=' . generate_link_hash('global') . '&mark=forums&mark_time=' . time()) : '',

+ 'MESSAGE_TITLE' => $user->lang['INFORMATION'],

+ 'MESSAGE_TEXT' => $user->lang['FORUMS_MARKED']

+ );

+ $json_response = new phpbb_json_response();

+ $json_response->send($data);

+ }

+

+ if ($request->is_ajax())

+ {

+ // Tell the ajax script what language vars and URL need to be replaced

+ $data = array(

+ 'NO_UNREAD_POSTS' => $user->lang['NO_UNREAD_POSTS'],

+ 'UNREAD_POSTS' => $user->lang['UNREAD_POSTS'],

+ 'U_MARK_FORUMS' => ($user->data['is_registered'] || $config['load_anon_lastread']) ? append_sid("{$phpbb_root_path}viewforum.$phpEx", 'hash=' . generate_link_hash('global') . '&f=' . $root_data['forum_id'] . '&mark=forums&mark_time=' . time()) : '',

+ 'MESSAGE_TITLE' => $user->lang['INFORMATION'],

+ 'MESSAGE_TEXT' => $user->lang['FORUMS_MARKED']

+ );

+ $json_response = new phpbb_json_response();

+ $json_response->send($data);

+ }

+

+* @param phpbb_db_driver $db The database object

+* @param phpbb_db_driver $db The database object

+* @param phpbb_db_driver $db The database object

+* @param phpbb_db_driver $db The database object

+ 'DRIVER' => 'phpbb_db_driver_firebird',

+ 'DRIVER' => 'phpbb_db_driver_mysqli',

+ 'DRIVER' => 'phpbb_db_driver_mysql',

+ 'DRIVER' => 'phpbb_db_driver_mssql',

+ 'DRIVER' => 'phpbb_db_driver_mssql_odbc',

+ 'DRIVER' => 'phpbb_db_driver_mssqlnative',

+ 'DRIVER' => 'phpbb_db_driver_oracle',

+ 'DRIVER' => 'phpbb_db_driver_postgres',

+ 'DRIVER' => 'phpbb_db_driver_sqlite',

+ $db = new $dbms();

+ if ($dbms_details['DRIVER'] != 'phpbb_db_driver_sqlite' && $dbms_details['DRIVER'] != 'phpbb_db_driver_oracle' && $dbname === '')

+ if ($dbms_details['DRIVER'] == 'phpbb_db_driver_sqlite' && stripos(phpbb_realpath($dbhost), phpbb_realpath('../')) === 0)

+ case 'phpbb_db_driver_mysql':

+ case 'phpbb_db_driver_mysqli':

+ case 'phpbb_db_driver_postgres':

+ case 'phpbb_db_driver_mssql':

+ case 'phpbb_db_driver_mssql_odbc':

+ case 'phpbb_db_driver_mssqlnative':

+ case 'phpbb_db_driver_sqlite':

+ case 'phpbb_db_driver_firebird':

+ case 'phpbb_db_driver_oracle':

+ case 'phpbb_db_driver_mysqli':

+ case 'phpbb_db_driver_sqlite':

+ case 'phpbb_db_driver_firebird':

+ case 'phpbb_db_driver_oracle':

+ case 'phpbb_db_driver_postgres':

+ $tpl = new phpbb_template($phpbb_root_path, $phpEx, $config, $user, $style_resource_locator, new phpbb_template_context(), $phpbb_extension_manager);

+ $style->set_custom_style($template_lang . '_email', array($template_path, $fallback_template_path), array(), '');

+ // Check the permissions for post approval.

+ // Moderators must go through post approval like ordinary users.

+ if (!$auth->acl_get('f_noapprove', $data['forum_id']))

+ $this->extension = strtolower(self::get_extension($this->realname));

+ *

+ * @param string Filename that needs to be checked

+ * @return string Extension of the supplied filename

+ static public function get_extension($filename)

+ $types = fileupload::image_types();

+ * Get image type/extension mapping

+ *

+ * @return array Array containing the image types and their extensions

+ static public function image_types()

+ * @var phpbb_db_driver

+ * @param phpbb_db_driver $db A database connection

+ public function __construct($config_name, phpbb_config $config, phpbb_db_driver $db)

+ if (!function_exists('phpbb_update_rows_avoiding_duplicates_notify_status'))

+ {

+ include($phpbb_root_path . 'includes/functions_database_helper.' . $phpEx);

+ }

+

+ // Update the topic watch table.

+ phpbb_update_rows_avoiding_duplicates_notify_status($db, TOPICS_WATCH_TABLE, 'topic_id', $topic_ids, $to_topic_id);

+ // Update the bookmarks table.

+ phpbb_update_rows_avoiding_duplicates($db, BOOKMARKS_TABLE, 'topic_id', $topic_ids, $to_topic_id);

+ // Copy topic subscriptions to new topic

+

+ // Copy bookmarks to new topic

+ $sql = 'SELECT user_id

+ FROM ' . BOOKMARKS_TABLE . '

+ WHERE topic_id = ' . $topic_id;

+ $result = $db->sql_query($sql);

+

+ $sql_ary = array();

+ while ($row = $db->sql_fetchrow($result))

+ {

+ $sql_ary[] = array(

+ 'topic_id' => (int) $new_topic_id,

+ 'user_id' => (int) $row['user_id'],

+ );

+ }

+ $db->sql_freeresult($result);

+

+ if (sizeof($sql_ary))

+ {

+ $db->sql_multi_insert(BOOKMARKS_TABLE, $sql_ary);

+ }

+ // Copy topic subscriptions to new topic

+ $sql = 'SELECT user_id, notify_status

+ FROM ' . TOPICS_WATCH_TABLE . '

+ WHERE topic_id = ' . $topic_id;

+ $result = $db->sql_query($sql);

+

+ $sql_ary = array();

+ while ($row = $db->sql_fetchrow($result))

+ {

+ $sql_ary[] = array(

+ 'topic_id' => (int) $to_topic_id,

+ 'user_id' => (int) $row['user_id'],

+ 'notify_status' => (int) $row['notify_status'],

+ );

+ }

+ $db->sql_freeresult($result);

+

+ if (sizeof($sql_ary))

+ {

+ $db->sql_multi_insert(TOPICS_WATCH_TABLE, $sql_ary);

+ }

+

+ // Copy bookmarks to new topic

+ $sql = 'SELECT user_id

+ FROM ' . BOOKMARKS_TABLE . '

+ WHERE topic_id = ' . $topic_id;

+ $result = $db->sql_query($sql);

+

+ $sql_ary = array();

+ while ($row = $db->sql_fetchrow($result))

+ {

+ $sql_ary[] = array(

+ 'topic_id' => (int) $to_topic_id,

+ 'user_id' => (int) $row['user_id'],

+ );

+ }

+ $db->sql_freeresult($result);

+

+ if (sizeof($sql_ary))

+ {

+ $db->sql_multi_insert(BOOKMARKS_TABLE, $sql_ary);

+ }

+

+ if (!function_exists('phpbb_update_rows_avoiding_duplicates_notify_status'))

+ {

+ include($phpbb_root_path . 'includes/functions_database_helper.' . $phpEx);

+ }

+

+ phpbb_update_rows_avoiding_duplicates_notify_status($db, TOPICS_WATCH_TABLE, 'topic_id', $topic_ids, $to_topic_id);

+ // If the topic no longer exist, we will update the bookmarks table.

+ phpbb_update_rows_avoiding_duplicates($db, BOOKMARKS_TABLE, 'topic_id', $topic_id, $to_topic_id);

+ $dbms = phpbb_convert_30_dbms_to_31($dbms);

+

+ * Database connection

+ * @var phpbb_db_driver

+ * Database connection

+ * @var phpbb_db_driver

+ * Database connection

+ * @var phpbb_db_driver

+ * Database connection

+ * @var phpbb_db_driver

+ <dd><input id="fulltext_sphinx_indexer_mem_limit" type="text" size="4" maxlength="10" name="config[fulltext_sphinx_indexer_mem_limit]" value="' . $this->config['fulltext_sphinx_indexer_mem_limit'] . '" /> ' . $this->user->lang['MIB'] . '</dd>

+<?php

+

+//

+// $Id: sphinxapi.php 3087 2012-01-30 23:07:35Z shodan $

+//

+

+//

+// Copyright (c) 2001-2012, Andrew Aksyonoff

+// Copyright (c) 2008-2012, Sphinx Technologies Inc

+// All rights reserved

+//

+// This program is free software; you can redistribute it and/or modify

+// it under the terms of the GNU General Public License. You should have

+// received a copy of the GPL license along with this program; if you

+// did not, you can find it at http://www.gnu.org/

+//

+

+/////////////////////////////////////////////////////////////////////////////

+// PHP version of Sphinx searchd client (PHP API)

+/////////////////////////////////////////////////////////////////////////////

+

+/// known searchd commands

+define ( "SEARCHD_COMMAND_SEARCH", 0 );

+define ( "SEARCHD_COMMAND_EXCERPT", 1 );

+define ( "SEARCHD_COMMAND_UPDATE", 2 );

+define ( "SEARCHD_COMMAND_KEYWORDS", 3 );

+define ( "SEARCHD_COMMAND_PERSIST", 4 );

+define ( "SEARCHD_COMMAND_STATUS", 5 );

+define ( "SEARCHD_COMMAND_FLUSHATTRS", 7 );

+

+/// current client-side command implementation versions

+define ( "VER_COMMAND_SEARCH", 0x119 );

+define ( "VER_COMMAND_EXCERPT", 0x104 );

+define ( "VER_COMMAND_UPDATE", 0x102 );

+define ( "VER_COMMAND_KEYWORDS", 0x100 );

+define ( "VER_COMMAND_STATUS", 0x100 );

+define ( "VER_COMMAND_QUERY", 0x100 );

+define ( "VER_COMMAND_FLUSHATTRS", 0x100 );

+

+/// known searchd status codes

+define ( "SEARCHD_OK", 0 );

+define ( "SEARCHD_ERROR", 1 );

+define ( "SEARCHD_RETRY", 2 );

+define ( "SEARCHD_WARNING", 3 );

+

+/// known match modes

+define ( "SPH_MATCH_ALL", 0 );

+define ( "SPH_MATCH_ANY", 1 );

+define ( "SPH_MATCH_PHRASE", 2 );

+define ( "SPH_MATCH_BOOLEAN", 3 );

+define ( "SPH_MATCH_EXTENDED", 4 );

+define ( "SPH_MATCH_FULLSCAN", 5 );

+define ( "SPH_MATCH_EXTENDED2", 6 ); // extended engine V2 (TEMPORARY, WILL BE REMOVED)

+

+/// known ranking modes (ext2 only)

+define ( "SPH_RANK_PROXIMITY_BM25", 0 ); ///< default mode, phrase proximity major factor and BM25 minor one

+define ( "SPH_RANK_BM25", 1 ); ///< statistical mode, BM25 ranking only (faster but worse quality)

+define ( "SPH_RANK_NONE", 2 ); ///< no ranking, all matches get a weight of 1

+define ( "SPH_RANK_WORDCOUNT", 3 ); ///< simple word-count weighting, rank is a weighted sum of per-field keyword occurence counts

+define ( "SPH_RANK_PROXIMITY", 4 );

+define ( "SPH_RANK_MATCHANY", 5 );

+define ( "SPH_RANK_FIELDMASK", 6 );

+define ( "SPH_RANK_SPH04", 7 );

+define ( "SPH_RANK_EXPR", 8 );

+define ( "SPH_RANK_TOTAL", 9 );

+

+/// known sort modes

+define ( "SPH_SORT_RELEVANCE", 0 );

+define ( "SPH_SORT_ATTR_DESC", 1 );

+define ( "SPH_SORT_ATTR_ASC", 2 );

+define ( "SPH_SORT_TIME_SEGMENTS", 3 );

+define ( "SPH_SORT_EXTENDED", 4 );

+define ( "SPH_SORT_EXPR", 5 );

+

+/// known filter types

+define ( "SPH_FILTER_VALUES", 0 );

+define ( "SPH_FILTER_RANGE", 1 );

+define ( "SPH_FILTER_FLOATRANGE", 2 );

+

+/// known attribute types

+define ( "SPH_ATTR_INTEGER", 1 );

+define ( "SPH_ATTR_TIMESTAMP", 2 );

+define ( "SPH_ATTR_ORDINAL", 3 );

+define ( "SPH_ATTR_BOOL", 4 );

+define ( "SPH_ATTR_FLOAT", 5 );

+define ( "SPH_ATTR_BIGINT", 6 );

+define ( "SPH_ATTR_STRING", 7 );

+define ( "SPH_ATTR_MULTI", 0x40000001 );

+define ( "SPH_ATTR_MULTI64", 0x40000002 );

+

+/// known grouping functions

+define ( "SPH_GROUPBY_DAY", 0 );

+define ( "SPH_GROUPBY_WEEK", 1 );

+define ( "SPH_GROUPBY_MONTH", 2 );

+define ( "SPH_GROUPBY_YEAR", 3 );

+define ( "SPH_GROUPBY_ATTR", 4 );

+define ( "SPH_GROUPBY_ATTRPAIR", 5 );

+

+// important properties of PHP's integers:

+// - always signed (one bit short of PHP_INT_SIZE)

+// - conversion from string to int is saturated

+// - float is double

+// - div converts arguments to floats

+// - mod converts arguments to ints

+

+// the packing code below works as follows:

+// - when we got an int, just pack it

+// if performance is a problem, this is the branch users should aim for

+//

+// - otherwise, we got a number in string form

+// this might be due to different reasons, but we assume that this is

+// because it didn't fit into PHP int

+//

+// - factor the string into high and low ints for packing

+// - if we have bcmath, then it is used

+// - if we don't, we have to do it manually (this is the fun part)

+//

+// - x64 branch does factoring using ints

+// - x32 (ab)uses floats, since we can't fit unsigned 32-bit number into an int

+//

+// unpacking routines are pretty much the same.

+// - return ints if we can

+// - otherwise format number into a string

+

+/// 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 );

+}

+

+/// 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 );

+}

+

+// 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;

+}

+

+// 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;

+}

+

+

+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 );

+ }

+}

+

+

+/// 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 $_rankexpr; ///< ranking mode expression (for SPH_RANK_EXPR)

+ 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

+ function SphinxClient ()

+ {

+ // 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->_rankexpr = "";

+ $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;

+ }

+

+ function __destruct()

+ {

+ if ( $this->_socket !== false )

+ fclose ( $this->_socket );

+ }

+

+ /// get last error message (string)

+ function GetLastError ()

+ {

+ return $this->_error;

+ }

+

+ /// get last warning message (string)

+ function GetLastWarning ()

+ {

+ return $this->_warning;

+ }

+

+ /// get last error flag (to tell network connection errors from searchd errors or broken responses)

+ function IsConnectError()

+ {

+ return $this->_connerror;

+ }

+

+ /// set searchd host name (string) and port (integer)

+ 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)

+ function SetConnectTimeout ( $timeout )

+ {

+ assert ( is_numeric($timeout) );

+ $this->_timeout = $timeout;

+ }

+

+

+ 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

+ function _MBPush ()

+ {

+ $this->_mbenc = "";

+ if ( ini_get ( "mbstring.func_overload" ) & 2 )

+ {

+ $this->_mbenc = mb_internal_encoding();

+ mb_internal_encoding ( "latin1" );

+ }

+ }

+

+ /// leave mbstring workaround mode

+ function _MBPop ()

+ {

+ if ( $this->_mbenc )

+ mb_internal_encoding ( $this->_mbenc );

+ }

+

+ /// connect to searchd server

+ 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

+ 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

+ 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"

+ function SetMaxQueryTime ( $max )

+ {

+ assert ( is_int($max) );

+ assert ( $max>=0 );

+ $this->_maxquerytime = $max;

+ }

+

+ /// set matching mode

+ 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

+ function SetRankingMode ( $ranker, $rankexpr="" )

+ {

+ assert ( $ranker>=0 && $ranker<SPH_RANK_TOTAL );

+ assert ( is_string($rankexpr) );

+ $this->_ranker = $ranker;

+ $this->_rankexpr = $rankexpr;

+ }

+

+ /// set matches sorting mode

+ 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

+ function SetWeights ( $weights )

+ {

+ assert ( is_array($weights) );

+ foreach ( $weights as $weight )

+ assert ( is_int($weight) );

+

+ $this->_weights = $weights;

+ }

+

+ /// bind per-field weights by name

+ 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

+ 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)

+ 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

+ 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)

+ 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)

+ 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

+ 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

+ 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

+ function SetGroupDistinct ( $attribute )

+ {

+ assert ( is_string($attribute) );

+ $this->_groupdistinct = $attribute;

+ }

+

+ /// set distributed retries count and delay

+ 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

+ 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

+ 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

+ function SetSelect ( $select )

+ {

+ assert ( is_string ( $select ) );

+ $this->_select = $select;

+ }

+

+ //////////////////////////////////////////////////////////////////////////////

+

+ /// clear all filters (for multi-queries)

+ function ResetFilters ()

+ {

+ $this->_filters = array();

+ $this->_anchor = array();

+ }

+

+ /// clear groupby settings (for multi-queries)

+ function ResetGroupBy ()

+ {

+ $this->_groupby = "";

+ $this->_groupfunc = SPH_GROUPBY_DAY;

+ $this->_groupsort = "@group desc";

+ $this->_groupdistinct= "";

+ }

+

+ /// clear all attribute value overrides (for multi-queries)

+ function ResetOverrides ()

+ {

+ $this->_overrides = array ();

+ }

+

+ //////////////////////////////////////////////////////////////////////////////

+

+ /// connect to searchd server, run given search query through given indexes,

+ /// and return the search results

+ 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

+ function _PackFloat ( $f )

+ {

+ $t1 = pack ( "f", $f ); // machine order

+ list(,$t2) = unpack ( "L*", $t1 ); // int in machine order

+ return pack ( "N", $t2 );

+ }

+

+ /// add query to multi-query batch

+ /// returns index into results array from RunQueries() call

+ function AddQuery ( $query, $index="*", $comment="" )

+ {

+ // mbstring workaround

+ $this->_MBPush ();

+

+ // build request

+ $req = pack ( "NNNN", $this->_offset, $this->_limit, $this->_mode, $this->_ranker );

+ if ( $this->_ranker==SPH_RANK_EXPR )

+ $req .= pack ( "N", strlen($this->_rankexpr) ) . $this->_rankexpr;

+ $req .= pack ( "N", $this->_sort ); // (deprecated) sort mode

+ $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

+ 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

+ 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_MULTI64 )

+ {

+ $attrvals[$attr] = array ();

+ $nvalues = $val;

+ while ( $nvalues>0 && $p<$max )

+ {

+ $attrvals[$attr][] = sphUnpackU64 ( substr ( $response, $p, 8 ) ); $p += 8;

+ $nvalues -= 2;

+ }

+ } 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

+ 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;

+ if ( !isset($opts["load_files_scattered"]) ) $opts["load_files_scattered"] = 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;

+ if ( $opts["load_files_scattered"] ) $flags |= 1024;

+ $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

+ 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;

+ }

+

+ 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

+ 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

+ /////////////////////////////////////////////////////////////////////////////

+

+ 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;

+ }

+

+ function Close()

+ {

+ if ( $this->_socket === false )

+ {

+ $this->_error = 'not connected';

+ return false;

+ }

+

+ fclose ( $this->_socket );

+ $this->_socket = false;

+

+ return true;

+ }

+

+ //////////////////////////////////////////////////////////////////////////

+ // status

+ //////////////////////////////////////////////////////////////////////////

+

+ 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

+ //////////////////////////////////////////////////////////////////////////

+

+ 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;

+ }

+}

+

+//

+// $Id: sphinxapi.php 3087 2012-01-30 23:07:35Z shodan $

+//

+

+ $names = array($style_path);

+ $names[] = $dir;

+ // Add 'all' path, used as last fallback path by events and extensions

+ //$names[] = 'all';

+ $paths = array();

+ foreach ($names as $name)

+ {

+ $paths[] = $this->get_style_path($name);

+ }

+ return $this->set_custom_style($style_path, $paths, $names);

+ * @param array $names Array of names of templates in inheritance tree order, used by extensions. If empty, $name will be used.

+ public function set_custom_style($name, $paths, $names = array(), $template_path = false)

+ if (empty($names))

+ {

+ $names = array($name);

+ }

+ $this->names = $names;

+

+ $this->template->set_style_names($names);

+

+ * @param bool $allow_php Whether PHP code will be allowed in templates (inline PHP code, PHP tag and INCLUDEPHP tag)

+ * @param array $style_names Name of style to which the template being compiled belongs and parents in style tree order

+ * @param phpbb_extension_manager $extension_manager Extension manager to use for finding template fragments in extensions; if null, template events will not be invoked

+ * @param phpbb_user $user Current user

+ public function __construct($allow_php, $style_names, $locator, $phpbb_root_path, $extension_manager = null, $user = null)

+ 'style_names' => $style_names,

+ 'phpbb_root_path' => $phpbb_root_path,

+ 'extension_manager' => $extension_manager,

+ 'user' => $user,

+ 'template_compile' => $this,

+ * Name of the style that the template being compiled and/or rendered

+ * belongs to, and its parents, in inheritance tree order.

+ *

+ * Used to invoke style-specific template events.

+ *

+ * @var array

+ */

+ private $style_names;

+

+ /**

+ * Extension manager.

+ *

+ * @var phpbb_extension_manager

+ */

+ private $extension_manager;

+

+ /**

+ * Current user

+ *

+ * @var phpbb_user

+ */

+ private $user;

+

+ /**

+ * Template compiler.

+ *

+ * @var phpbb_template_compile

+ */

+ private $template_compile;

+

+ /**

+ * Get the allow_php option, style_names, root directory and locator from params,

+ *

+ * @return boolean Returns true

+ $this->style_names = $this->params['style_names'];

+ $this->extension_manager = $this->params['extension_manager'];

+ if (isset($this->params['user']))

+ {

+ $this->user = $this->params['user'];

+ }

+ $this->template_compile = $this->params['template_compile'];

+ * Callback for replacing matched tokens with compiled template code.

+ *

+ * Compiled template code is an HTML stream with embedded PHP.

+ case 'EVENT':

+ return '<?php ' . $this->compile_tag_event($matches[2]) . '?>';

+ break;

+

+ * Compile EVENT tag.

+ *

+ * $tag_args should be a single string identifying the event.

+ * The event name can contain letters, numbers and underscores only.

+ * If an invalid event name is specified, an E_USER_ERROR will be

+ * triggered.

+ *

+ * Event tags are only functional when the template engine has

+ * an instance of the extension manager. Extension manager would

+ * be called upon to find all extensions listening for the specified

+ * event, and to obtain additional template fragments. All such

+ * template fragments will be compiled and included in the generated

+ * compiled template code for the current template being compiled.

+ *

+ * The above means that whenever an extension is enabled or disabled,

+ * template cache should be cleared in order to update the compiled

+ * template code for the active set of template event listeners.

+ *

+ * This also means that extensions cannot return different template

+ * fragments at different times. Once templates are compiled, changing

+ * such template fragments would have no effect.

+ *

+ * @param string $tag_args EVENT tag arguments, as a string - for EVENT this is the event name

+ * @return string compiled template code

+ */

+ private function compile_tag_event($tag_args)

+ {

+ if (!preg_match('/^\w+$/', $tag_args))

+ {

+ // The event location is improperly formatted,

+ if ($this->user)

+ {

+ trigger_error($this->user->lang('ERR_TEMPLATE_EVENT_LOCATION', $tag_args), E_USER_ERROR);

+ }

+ else

+ {

+ trigger_error(sprintf('The specified template event location <em>[%s]</em> is improperly formatted.', $tag_args), E_USER_ERROR);

+ }

+ }

+ $location = $tag_args;

+

+ if ($this->extension_manager)

+ {

+ $finder = $this->extension_manager->get_finder();

+

+ $files = $finder

+ ->extension_prefix($location)

+ ->extension_suffix('.html')

+ ->extension_directory("/styles/all/template")

+ ->get_files();

+

+ foreach ($this->style_names as $style_name)

+ {

+ $more_files = $finder

+ ->extension_prefix($location)

+ ->extension_suffix('.html')

+ ->extension_directory("/styles/" . $style_name . "/template")

+ ->get_files();

+ if (!empty($more_files))

+ {

+ $files = array_merge($files, $more_files);

+ break;

+ }

+ }

+

+ $all_compiled = '';

+ foreach ($files as $file)

+ {

+ $compiled = $this->template_compile->compile_file($file);

+

+ if ($compiled === false)

+ {

+ if ($this->user)

+ {

+ trigger_error($this->user->lang('ERR_TEMPLATE_COMPILATION', phpbb_filter_root_path($file)), E_USER_ERROR);

+ }

+ else

+ {

+ trigger_error(sprintf('The file could not be compiled: %s', phpbb_filter_root_path($file)), E_USER_ERROR);

+ }

+ }

+

+ $all_compiled .= $compiled;

+ }

+ // Need spaces inside php tags as php cannot grok

+ // < ?php? > sans the spaces

+ return ' ?' . '>' . $all_compiled . '<?php ';

+ }

+ }

+

+ /**

+ * @param array $filename_array Should be a hash of handle => filename pairs.

+ * guaranteed to exist (which might come from the parent style

+ * Extension manager.

+ *

+ * @var phpbb_extension_manager

+ */

+ private $extension_manager;

+

+ /**

+ * Name of the style that the template being compiled and/or rendered

+ * belongs to, and its parents, in inheritance tree order.

+ *

+ * Used to invoke style-specific template events.

+ *

+ * @var array

+ */

+ private $style_names;

+

+ /**

+ * @param phpbb_extension_manager $extension_manager extension manager, if null then template events will not be invoked

+ public function __construct($phpbb_root_path, $php_ext, $config, $user, phpbb_template_locator $locator, phpbb_template_context $context, phpbb_extension_manager $extension_manager = null)

+ $this->extension_manager = $extension_manager;

+ * @param array $filename_array Should be a hash of handle => filename pairs.

+ * Sets the style names corresponding to style hierarchy being compiled

+ * and/or rendered.

+ *

+ * @param array $style_names List of style names in inheritance tree order

+ * @return null

+ */

+ public function set_style_names(array $style_names)

+ {

+ $this->style_names = $style_names;

+ }

+

+ /**

+ $compile = new phpbb_template_compile($this->config['tpl_allow_php'], $this->style_names, $this->locator, $this->phpbb_root_path, $this->extension_manager, $this->user);