pfSense

<?php

 * pkg-utils.inc

 * Copyright (c) 2005-2006 Colin Smith (ethethlay@gmail.com)

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

	/* set up logging if needed */

	function pkg_debug($msg) {

		global $g, $debug, $fd_log;

		if (!$fd_log) {

		@fwrite($fd_log, $msg);

	}

}

function pkg_valid_name($pkgname) {

	global $g;

	$pattern = "/^{$g['pkg_prefix']}[a-zA-Z0-9\.\-_]+$/";

	return preg_match($pattern, $pkgname);

}

function pkg_remove_prefix(&$pkg_name) {

	global $g;

	if (substr($pkg_name, 0, strlen($g['pkg_prefix'])) == $g['pkg_prefix']) {

		$pkg_name = substr($pkg_name, strlen($g['pkg_prefix']));

	}

function pkg_update($force = false) {

	global $g;

		"FETCH_TIMEOUT" => 5,

		"FETCH_RETRY" => 2

		$http_proxy = $config['system']['proxyurl'];

		if (!empty($config['system']['proxyport'])) {

			$http_proxy .= ':' . $config['system']['proxyport'];

		}

		$pkg_env_vars['HTTP_PROXY'] = $http_proxy;

		if (!empty($config['system']['proxyuser']) && !empty($config['system']['proxypass'])) {

			$pkg_env_vars['HTTP_PROXY_AUTH'] = "basic:*:{$config['system']['proxyuser']}:{$config['system']['proxypass']}";

		}

		$pkg_env_vars['PKG_CACHEDIR'] = '/root/var/cache/pkg';

	}

		$pkg_env_vars[$key] = $value;

	}

}

		return false;

	}

		1 => array("pipe", "w"), /* stdout */

	if (!is_resource($process)) {

		return false;

	}

	stream_set_blocking($pipes[1], 0);

	stream_set_blocking($pipes[2], 0);

	/* XXX: should be a tunnable? */

	do {

		$write = array();

		$read = array($pipes[1], $pipes[2]);

		$except = array();

			foreach ($read as $pipe) {

				$content = stream_get_contents($pipe);

				if ($content == '') {

					continue;

				}

				if ($pipe === $pipes[1]) {

					if (!$mute) {

					flush();

				} else if ($pipe === $pipes[2]) {

					$error_log .= $content;

				}

			}

	} while ($status['running']);

	fclose($pipes[2]);

	proc_close($process);

	pkg_debug("pkg_call(): rc = {$rc}\n");

	if ($rc == 0) {

		return true;

	}

	pkg_debug("pkg_call(): error_log\n{$error_log}\n");

	if (!$mute) {

		    "ERROR!!! An error occurred on pkg execution (rc = %d) with parameters '%s':"),

		    $rc, $params) . "\n" . $error_log . "\n");

	if (empty($params)) {

		return -1;

	}

	$descriptorspec = array(

		1 => array("pipe", "w"), /* stdout */

	if (!is_resource($process)) {

		return -1;

	}

	$stdout = '';

	while (($l = fgets($pipes[1])) !== FALSE) {

		$stdout .= $l;

	}

	fclose($pipes[1]);

	$stderr = '';

	while (($l = fgets($pipes[2])) !== FALSE) {

		$stderr .= $l;

	}

	fclose($pipes[2]);

 * '=' - versions are the same

 * '>' - $v1 > $v2

 * '<' - $v1 < $v2

 * '?' - Error

 */

function pkg_version_compare($v1, $v2) {

	if (empty($v1) || empty($v2)) {

		return '?';

	}

	if ($rc != 0) {

		return '?';

	}

	return str_replace("\n", "", $stdout);

}

function is_pkg_installed($pkg_name) {

	global $g;

		return false;

	}

	pkg_remove_prefix($shortname);

	if ($force) {

		$pkg_force = "-f ";

	}

		pkg_call("clean -y");

function pkg_delete($pkg_name) {

	global $g;

	pkg_remove_prefix($shortname);

function is_package_installed($package_name) {

	return (get_package_id($package_name) != -1);

function get_package_id($package_name) {

		return -1;

	}

	foreach ($config['installedpackages']['package'] as $idx => $pkg) {

	}

function get_package_internal_name($package_data) {

	if (isset($package_data['internal_name']) && ($package_data['internal_name'] != "")) {

}

    $installed_pkgs_only = false) {

		$pkg_filter = $pkgs;

	} elseif ($pkgs == 'all') {

		$pkgs = $g['pkg_prefix'] . '*';

		// Return early if the caller wants just installed packages and there are none.

		// Saves doing any calls that might access a remote package repo.

		return array();

	}

		require_once("util.inc");

	}

	/* Do not run remote operations if pkg has a lock */

	if (is_subsystem_dirty('pkg')) {

	} else {

		$lock = true;

	}

	if ($lock) {

		mark_subsystem_dirty('pkg');

	}

		$extra_param = "-U ";

	}

	//    we want up-to-date remote repo info

	// then do a full pkg search

	if (!$installed_pkgs_only || !$remote_repo_usage_disabled) {

		    "search {$extra_param}-R --raw-format json-compact " .

		    $pkgs, $out, $err);

	}

	if (($installed_pkgs_only || $rc != 0) &&

	    $remote_repo_usage_disabled &&

	    is_pkg_installed($pkgs)) {

		 * Fall back on pkg info to return locally installed matching

		 * pkgs instead, if:

		 *       we would have accepted incomplete/outdated pkg info)

		 *       but it didn't have any contents, or for other reasons

		 *       returned an error.

		 *   AND

		 *   (3) at least some pkgs matching <pattern> are installed

		 * catalog, the local copy is wiped clear. Thereafter any

		 * "pkg search" will return an error until online+updated again.

		 * If the calling code would have accepted local copy info

		 * (which could be incomplete/out of date), then it makes sense

		 * to fall back on pkg info to at least return the known

		 * info about installed pkgs (pkg info should still work),

		 * instead of failing and returning no info at all. 

		 * For example, this at least enables offline view + management

		 * of installed pkgs in GUI/console.

		 *

		 * We skip this step if no matching pkgs are installed, because

		 * then pkg info would return a "no matching pkgs" RC code,

		 * even though this wouldn't be considered an "error" (and

		 * $out+$err would be correct empty strings if none match).

		 * <pattern> which is what we need here.

		// ok, 1 or more packages match, so pkg info can be safely called to get the pkg list  

		    $out, $err);

		clear_subsystem_dirty('pkg');

	}

		    "ERROR: Error trying to get packages list. Aborting...")

		    . "\n");

		update_status($err);

		    "ERROR: Error trying to get packages list. Aborting...") .

		    "\n";

		$input_errors[] = $err;

	}

	$result = array();

	$pkgs_info = explode("\n", $out);

	foreach ($pkgs_info as $pkg_info_json) {

		$pkg_info = json_decode($pkg_info_json, true);

		if (!isset($pkg_info['name'])) {

			continue;

		}

		    $pkg_filter)) {

		}

		pkg_remove_prefix($pkg_info['shortname']);

		/* XXX: Add it to globals.inc? */

		$pkg_info['changeloglink'] =

		    "https://github.com/pfsense/FreeBSD-ports/commits/devel/" .

		    $pkg_info['categories'][0] . '/' . $pkg_info['name'];

			$pkg_info['installed'] = true;

			    $err);

			if ($rc != 0) {

				    "ERROR: Error trying to get package version. Aborting...")

				    . "\n");

				update_status($err);

				    "ERROR: Error trying to get package version. Aborting...") .

				    "\n";

				$input_errors[] = $err;

			}

			    $out);

			$pkg_info['broken'] = true;

		    $pkg_info['desc']);

			$result[] = $pkg_info;

		}

	usort($result, function($a, $b) {

		return(strcasecmp ($a['name'], $b['name']));

	});

 * If binary pkg is installed but post-install tasks were not

 * build phase, and at this point, cannot find a running system

 * to register itself in config.xml and also execute custom

 * install functions

 */

function register_all_installed_packages() {

	global $g, $config, $pkg_interface;

		pkg_remove_prefix($pkg['name']);

		if (is_package_installed($pkg['name'])) {

			continue;

		}

		update_status(sprintf(gettext(

		    "Running last steps of %s installation.") . "\n",

		    $pkg['name']));

		install_package_xml($pkg['name']);

	}

}

 * resync_all_package_configs() Force packages to setup their configuration and rc.d files.

 * This function may also print output to the terminal indicating progress.

 */

function resync_all_package_configs($show_message = false) {

		if (empty($package['name'])) {

		if ($show_message == true) {

		if (platform_booting() != true) {

		stop_service($internal_name);

		delete_package_xml($package_name);

function sync_package($package_name) {

	global $config, $builder_package_install;

	// If this code is being called by pfspkg_installer

	if (($pkg_id = get_package_id($package_name)) == -1) {

		return; // This package doesn't really exist - exit the function.

	$package =& $config['installedpackages']['package'][$pkg_id];

	if (!empty($pkg_config['include_file'])) {

		$include_file = $pkg_config['include_file'];

			}

			if (file_exists($include_file)) {

				require_once($include_file);

			} else {

				return;

	if (!empty($pkg_config['custom_php_resync_config_command'])) {

function read_package_config($package_name) {

	global $g;

		return false;

	}

		return false;

	/* it always returns an array with 1 item */

	return $pkg_info['package'][0];

function read_package_configurationfile($package_name) {

	global $config, $g;

	$pkg_config = array();

	$id = get_package_id($package_name);

	if ($id < 0 || !isset($config['installedpackages']['package'][$id]['configurationfile'])) {

		return $pkg_config;

	}

	$pkg_configurationfile = $config['installedpackages']['package'][$id]['configurationfile'];

	if (empty($pkg_configurationfile) || !file_exists('/usr/local/pkg/' . $pkg_configurationfile)) {

		return $pkg_config;