MATCH_EREGEX,

	/**

	 * The argument is a WHERE clause to use as condition

	 */

	MATCH_CONDITION

struct pkgdb_it * pkgdb_rquery(struct pkgdb *db, const char *pattern, match_t type, const char *reponame);

struct pkgdb_it * pkgdb_search(struct pkgdb *db, const char *pattern,

static const char *

pkgdb_get_reponame(struct pkgdb *db, const char *repo)

{

	const char *reponame = NULL;

	bool multirepos_enabled = false;

	assert(db->type == PKGDB_REMOTE);

	/* Working on multiple repositories */

	pkg_config_bool(PKG_CONFIG_MULTIREPOS, &multirepos_enabled);

	if (multirepos_enabled) {

		if (repo != NULL) {

			if (!is_attached(db->sqlite, repo)) {

				pkg_emit_error("repository '%s' does not exist.", repo);

				return (NULL);

			}

			reponame = repo;

		} else {

			/* default repository in multi-repos is 'default' */

			reponame = "default";

		}

	} else {

		if (repo != NULL) {

			pkg_emit_error("PKG_MULTIREPOS is not enabled. -r flag not supported.", repo);

			return (NULL);

		}

		/* default repository in single-repo is 'remote' */

		reponame = "remote";

	}

	return (reponame);

}

static const char *

pkgdb_get_pattern_query(const char *pattern, match_t match)

	const char *comp = NULL;

	if (pattern != NULL) {

	}

	case MATCH_CONDITION:

		comp = pattern;

		break;

	return (comp);

}

static const char *

pkgdb_get_match_how(match_t match)

{

	const char *how = NULL;

	switch (match) {

		case MATCH_ALL:

			how = NULL;

			break;

		case MATCH_EXACT:

			how = "%s = ?1";

			break;

		case MATCH_GLOB:

			how = "%s GLOB ?1";

			break;

		case MATCH_REGEX:

			how = "%s REGEXP ?1";

			break;

		case MATCH_EREGEX:

			how = "EREGEXP(?1, %s)";

			break;

		case MATCH_CONDITION:

			/* This case should not be called by pkgdb_get_match_how() */

			assert(0);

			break;

	}

	return (how);

pkgdb_query(struct pkgdb *db, const char *pattern, match_t match)

	const char *comp = NULL;

	assert(match == MATCH_ALL || (pattern != NULL && pattern[0] != '\0'));

	comp = pkgdb_get_pattern_query(pattern, match);

			"SELECT id, origin, name, version, comment, desc, "

				"message, arch, maintainer, www, "

				"prefix, flatsize, licenselogic, automatic, "

				"time, infos "

			"FROM packages AS p%s "

			"ORDER BY p.name;", comp);

	if (match != MATCH_ALL && match != MATCH_CONDITION)

		sqlite3_bind_text(stmt, 1, pattern, -1, SQLITE_TRANSIENT);

	if (pkg->flags & PKG_LOAD_DEPS)

		return (EPKG_OK);

	if (pkg->type == PKG_REMOTE) {

		assert(db->type == PKGDB_REMOTE);

		pkg_get(pkg, PKG_REPONAME, &reponame);

	} else

	const char *reponame = NULL;

	char sql[BUFSIZ];

	const char *basesql = ""

		"FROM '%s'.packages AS p, '%s'.deps AS d "

	if (pkg->type == PKG_REMOTE) {

		assert(db->type == PKGDB_REMOTE);

		pkg_get(pkg, PKG_REPONAME, &reponame);

		snprintf(sql, sizeof(sql), basesql, reponame, reponame);

	} else

		snprintf(sql, sizeof(sql), basesql, "main", "main");

	assert(pkg->type == PKG_INSTALLED);

		assert(db->type == PKGDB_REMOTE);

		assert(db->type == PKGDB_REMOTE);

	assert(pkg->type == PKG_INSTALLED);

	assert(pkg->type == PKG_INSTALLED);

		assert(db->type == PKGDB_REMOTE);

		assert(db->type == PKGDB_REMOTE);

	assert(db->type == PKGDB_REMOTE);

	if ((reponame = pkgdb_get_reponame(db, repo)) == NULL) {

	assert(db->type == PKGDB_REMOTE);

	if ((reponame = pkgdb_get_reponame(db, repo)) == NULL) {

	how = pkgdb_get_match_how(match);

	assert(db->type == PKGDB_REMOTE);

	if ((reponame = pkgdb_get_reponame(db, repo)) == NULL) {

		return (NULL);

	assert(db->type == PKGDB_REMOTE);

	if ((reponame = pkgdb_get_reponame(db, repo)) == NULL) {

		return (NULL);

	how = pkgdb_get_match_how(match);

struct pkgdb_it *

pkgdb_rquery(struct pkgdb *db, const char *pattern, match_t match, const char *repo)

{

	sqlite3_stmt *stmt = NULL;

	struct sbuf *sql = NULL;

	bool multirepos_enabled = false;

	const char *reponame = NULL;

	const char *comp = NULL;

	char basesql[BUFSIZ] = ""

				"SELECT id, origin, name, version, comment, "

				"prefix, desc, arch, maintainer, www, "

				"licenselogic, flatsize AS newflatsize, pkgsize, "

				"cksum, path AS repopath, '%s' AS dbname "

				"FROM '%s'.packages p";

	assert(db != NULL);

	assert(match == MATCH_ALL || (pattern != NULL && pattern[0] != '\0'));

	if ((reponame = pkgdb_get_reponame(db, repo)) == NULL) {

		return (NULL);

	}

	sql = sbuf_new_auto();

	comp = pkgdb_get_pattern_query(pattern, match);

	if (comp && comp[0]) {

		strlcat(basesql, comp, sizeof(basesql));

	}

	pkg_config_bool(PKG_CONFIG_MULTIREPOS, &multirepos_enabled);

	/*

	 * Working on multiple remote repositories

	 */

	if (multirepos_enabled && !strcmp(reponame, "default")) {

		/* duplicate the query via UNION for all the attached databases */

		if (sql_on_all_attached_db(db->sqlite, sql, basesql) != EPKG_OK)

			return (NULL);

	} else {

		sbuf_printf(sql, basesql, reponame, reponame);

	}

	sbuf_cat(sql, " ORDER BY name;");

	sbuf_finish(sql);

	if (sqlite3_prepare_v2(db->sqlite, sbuf_get(sql), -1, &stmt, NULL) != SQLITE_OK) {

		ERROR_SQLITE(db->sqlite);

		return (NULL);

	}

	sbuf_delete(sql);

	if (match != MATCH_ALL && match != MATCH_CONDITION)

		sqlite3_bind_text(stmt, 1, pattern, -1, SQLITE_TRANSIENT);

	return (pkgdb_it_new(db, stmt, PKG_REMOTE));

}

pkgdb_search_build_search_query(struct sbuf *sql, match_t match, unsigned int field)

	how = pkgdb_get_match_how(match);

pkgdb_search(struct pkgdb *db, const char *pattern, match_t match, unsigned int field, const char *reponame)

	assert(db != NULL);

	assert(db->type == PKGDB_REMOTE);

	pkgdb_search_build_search_query(sql, match, field);

	sbuf_cat(sql, ";");

	sbuf_finish(sql);

	assert(db->type == PKGDB_REMOTE);

	if ((reponame = pkgdb_get_reponame(db, repo)) == NULL) {

	how = pkgdb_get_match_how(match);

		rquery.c \

	pkg-rquery.8 \

		it = pkgdb_search(db, origin, MATCH_EXACT, FIELD_ORIGIN, NULL);

	{ "rquery", "Query information from the remote repository", exec_rquery, usage_rquery},

.Xr pkg-rquery 8 ,

.Xr pkg-rquery 8 ,

.Xr pkg-rquery 8 ,

.Xr pkg-rquery 8 ,

.Xr pkg-rquery 8 ,

.Xr pkg-rquery 8 ,

.Xr pkg-rquery 8 ,

.Xr pkg-rquery 8 ,

.Xr pkg-rquery 8 ,

.Xr pkg-rquery 8 ,

.Xr pkg-rquery 8 ,

.Xr pkg-rquery 8 ,

.Xr pkg-rquery 8 ,

.Xr pkg-rquery 8 ,

.\"

.\" FreeBSD pkg - a next generation package for the installation and maintenance

.\" of non-core utilities.

.\"

.\" Redistribution and use in source and binary forms, with or without

.\" modification, are permitted provided that the following conditions

.\" are met:

.\" 1. Redistributions of source code must retain the above copyright

.\"    notice, this list of conditions and the following disclaimer.

.\" 2. Redistributions in binary form must reproduce the above copyright

.\"    notice, this list of conditions and the following disclaimer in the

.\"    documentation and/or other materials provided with the distribution.

.\"

.\"

.\"     @(#)pkg.8

.\" $FreeBSD$

.\"

.Dd March 2, 2012

.Dt PKG-RQUERY 8

.Os

.Sh NAME

.Nm "pkg rquery"

.Nd query information from remote repositories

.Sh SYNOPSIS

.Nm

.Ao query-format Ac Ao pkg-name Ac

.Nm

.Fl a

.Op Fl r Ar reponame

.Ao query-format Ac

.Nm

.Fl e Ao evaluation-condition Ac

.Op Fl r Ar reponame

.Ao query-format Ac

.Nm

.Op Fl gxX

.Op Fl r Ar reponame

.Ao query-format Ac Ao pattern Ac Ao ... Ac

.Sh DESCRIPTION

.Nm

is used for displaying information about remote packages.

.Sh OPTIONS

The following options are supported by

.Nm :

.Bl -tag -width F1

.It Fl a

Match all packages from the database

.It Fl e

Match packages using the given

.Ar evaluation-condition.

See EVALUATION FORMAT for details.

.It Fl r Ar reponame

Fetches packages from the given

.Ar reponame

if multiple repo support is enabled.

See

.Xr pkg.conf 5 .

.It Fl g

Treat

.Ao pattern Ac

as a glob pattern.

.It Fl x

Treat

.Ao pattern Ac

as a regular expression.

.It Fl X

Treat

.Ao pattern Ac

as an extended regular expression.

.El

.Sh QUERY FORMAT

There are two type of keyword for the query format: the multiline and the normal

one. Only one type of multiline pattern is accepted for a given query.

.Ss Normal patterns:

.Bl -tag -width F1

.It Cm \&%R

Name of the repository package is in

.It Cm \&%n

Name of the matched package

.It Cm \&%v

Version of the matched package

.It Cm \&%o

Origin of the matched package

.It Cm \&%p

Prefix of the matched package

.It Cm \&%m

Maintainer of the matched package

.It Cm \&%c

Comment of the matched package

.It Cm \&%i

Additionnal information about the package

.It Cm \&%w

Home page of the matched package

.It Cm \&%l

license logic of the matched package - nothing for single, & for AND, and | for OR

.It Cm \&%sh

The flat size in human readable format of the matched package

.It Cm \&%sb

The flat size in bytes of the matched package

.It Cm \&%a

Returns 1 if the matched package is an orphan package and can be pkg-autoremove(1)'d, 0 otherwise

.It Cm \&%M

message contain in the matched package

.It Cm \&%? Ns Op dCOLB

Returns 0 if the list is empty and 1 if the list has information to display

.Bl -tag -width indent

.It Cm d

for dependencies

.It Cm r

for reverse dependencies

.It Cm C

for categories

.It Cm O

for options

.It Cm L

for licenses

.It Cm B

for shared libraries

.El

.El

.Ss Multiline patterns:

.Bl -tag -width F1

.It Cm \&%d Ns Op nov

Expands to the list of dependencies for the matched package, where

.Cm n

stands for the package name,

.Cm o

for the package origin, and

.Cm v

for the package version.

.It Cm \&%C

Expands to the list of categories the matched package belongs to.

.It Cm \&%O Ns Op kv

Expands to the list of options of the matched package, where

.Cm k

stands for option key, and

.Cm v

for option value.

.It Cm \&%L

Expands to the list of license(s) for the matched package.

.It Cm \&%B

Expands to the list of shared libraries used by programs from the matched package.

.El

.Sh EVALUATION FORMAT

.Ss Variables

.Bl -tag -width F1

.It Cm \&%n

Name of the package (type string)

.It Cm \&%o

Origin of the package (type string)

.It Cm \&%p

Prefix of the package (type string)

.It Cm \&%m

Maintainer of the package (type string)

.It Cm \&%c

Comment of the package (type string)

.It Cm \&%w

WWW address of the package (type string)

.It Cm \&%s

Flatsize of the package (type integer)

.It Cm \&%a

Automatic status of the package (type integer)

.It Cm \&%M

Message of the package (type string)

.El

.Ss Operators

.Bl -tag -width F1

.It Cm ~

String glob pattern matching

.It Cm > Ns Op =

Integer comparison

.It Cm > Ns Op =

Integer comparison

.It Cm = Ns Op =

Integer or string comparison

.Sh ENVIRONMENT

The following environment variables affect the execution of

.Nm .

See

.Xr pkg.conf 5

for further description.

.Bl -tag -width ".Ev NO_DESCRIPTIONS"

.It Ev PKG_DBDIR

.El

.Sh FILES

See

.Xr pkg.conf 5 .

.Sh SEE ALSO

.Xr pkg 8 ,

.Xr pkg-add 8 ,

.Xr pkg-audit 8 ,

.Xr pkg-autoremove 8 ,

.Xr pkg-backup 8 ,

.Xr pkg-check 8 ,

.Xr pkg-clean 8 ,

.Xr pkg-create 8 ,

.Xr pkg-delete 8 ,

.Xr pkg-fetch 8 ,

.Xr pkg-info 8 ,

.Xr pkg-install 8 ,

.Xr pkg-query 8 ,

.Xr pkg-register 8 ,

.Xr pkg-repo 8 ,

.Xr pkg-search 8 ,

.Xr pkg-set 8 ,

.Xr pkg-shell 8 ,

.Xr pkg-shlib 8 ,

.Xr pkg-update 8 ,

.Xr pkg-updating 8 ,

.Xr pkg-upgrade 8 ,

.Xr pkg-version 8 ,

.Xr pkg-which 8 ,

.Xr pkg.conf 5

.Xr pkg-rquery 8 ,

.Xr pkg-rquery 8 ,

.Xr pkg-rquery 8 ,

.Xr pkg-rquery 8 ,

.Xr pkg-rquery 8 ,

.Xr pkg-rquery 8 ,

.Xr pkg-rquery 8 ,

.Xr pkg-rquery 8 ,

.Xr pkg-rquery 8 ,

.It Ic rquery

Query information for remote repositories.

.Xr pkg-rquery 8 ,

.Xr pkg-rquery 8 ,

/* pkg rquery */

int exec_rquery(int, char **);

void usage_rquery(void);

/* pkg-query / pkg-rquery */

struct query_flags {

	const char flag;

	const char *options;

	const unsigned multiline;

	const int dbflags;

};

typedef enum {

	NONE,

	NEXT_IS_INT,

	OPERATOR_INT,

	INT,

	NEXT_IS_STRING,

	OPERATOR_STRING,

	STRING,

	QUOTEDSTRING,

	SQUOTEDSTRING

} type_t;

void print_query(struct pkg *pkg, char *qstr, char multiline);

int format_sql_condition(const char *str, struct sbuf *sqlcond);

int analyse_query_string(char *qstr, struct query_flags *q_flags, const unsigned int q_flags_len, int *flags, char *multiline);

static struct query_flags accepted_query_flags[] = {

				case 'R':

					pkg_get(pkg, PKG_REPONAME, &tmp);

					if (tmp != NULL)

						sbuf_cat(dest, tmp);

					break;

void

int

	sbuf_cat(sqlcond, " WHERE ");

int

analyse_query_string(char *qstr, struct query_flags *q_flags, const unsigned int q_flags_len, int *flags, char *multiline)

			for (i = 0; i < q_flags_len; i++) {

						for (k = 0; k < q_flags_len; k++)

	const unsigned int q_flags_len = (sizeof(accepted_query_flags)/sizeof(accepted_query_flags[0]));

				match = MATCH_CONDITION;

	if (analyse_query_string(argv[0], accepted_query_flags, q_flags_len, &query_flags, &multiline) != EPKG_OK)

		sbuf_finish(sqlcond);

	if (match == MATCH_ALL || match == MATCH_CONDITION) {

		const char *condition_sql = NULL;

		if (match == MATCH_CONDITION && sqlcond)

			condition_sql = sbuf_data(sqlcond);

		if ((it = pkgdb_query(db, condition_sql, match)) == NULL)

/*

 * Copyright (c) 2011-2012 Baptiste Daroussin <bapt@FreeBSD.org>

 * Copyright (c) 2011-2012 Marin Atanasov Nikolov <dnaeon@gmail.com>

 * All rights reserved.

 * 

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer

 *    in this position and unchanged.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 * 

 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR

 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.

 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,

 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

#include <sys/types.h>

#include <sys/sbuf.h>

#include <ctype.h>

#include <inttypes.h>

#include <libutil.h>

#include <pkg.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <sysexits.h>

#include <unistd.h>

#include "pkgcli.h"

static struct query_flags accepted_rquery_flags[] = {

	{ 'd', "nov",		1, PKG_LOAD_DEPS },

	{ 'r', "nov",		1, PKG_LOAD_RDEPS },

	{ 'C', "",		1, PKG_LOAD_CATEGORIES },

	{ 'O', "kv",		1, PKG_LOAD_OPTIONS },

	{ 'L', "",		1, PKG_LOAD_LICENSES },

	{ 'B', "",		1, PKG_LOAD_SHLIBS },

	{ '?', "drCOLB",	1, PKG_LOAD_BASIC },	/* dbflags handled in analyse_query_string() */

	{ 's', "hb",		0, PKG_LOAD_BASIC },

	{ 'n', "",		0, PKG_LOAD_BASIC },

	{ 'v', "",		0, PKG_LOAD_BASIC },

	{ 'o', "",		0, PKG_LOAD_BASIC },

	{ 'R', "",		0, PKG_LOAD_BASIC },

	{ 'p', "",		0, PKG_LOAD_BASIC },

	{ 'm', "",		0, PKG_LOAD_BASIC },

	{ 'c', "",		0, PKG_LOAD_BASIC },

	{ 'w', "",		0, PKG_LOAD_BASIC },

	{ 'l', "",		0, PKG_LOAD_BASIC },

	{ 'a', "",		0, PKG_LOAD_BASIC },

	{ 'M', "",		0, PKG_LOAD_BASIC },

	{ 'i', "",		0, PKG_LOAD_BASIC },

	{ 't', "",		0, PKG_LOAD_BASIC },

};

void

usage_rquery(void)

{

	fprintf(stderr, "usage: pkg rquery [-r reponame] <query-format> <pkg-name>\n");

	fprintf(stderr, "       pkg rquery -a [-r reponame] <query-format>\n");

	fprintf(stderr, "       pkg rquery -e <evaluation> [-r reponame] <query-format>\n");

	fprintf(stderr, "       pkg rquery [-gxX] [-r reponame] <query-format> <pattern> <...>\n\n");

	fprintf(stderr, "For more information see 'pkg help rquery.'\n");

}

int

exec_rquery(int argc, char **argv)

{

	struct pkgdb *db = NULL;

	struct pkgdb_it *it = NULL;

	struct pkg *pkg = NULL;

	char *pkgname = NULL;

	int query_flags = PKG_LOAD_BASIC;

	match_t match = MATCH_EXACT;

	int ch;

	int ret = EPKG_OK;

	int retcode = EXIT_SUCCESS;

	int i;

	char multiline = 0;

	char *condition = NULL;

	struct sbuf *sqlcond = NULL;

	const unsigned int q_flags_len = (sizeof(accepted_rquery_flags)/sizeof(accepted_rquery_flags[0]));

	const char *reponame = NULL;

	while ((ch = getopt(argc, argv, "agxXe:r:")) != -1) {

		switch (ch) {

			case 'a':

				match = MATCH_ALL;

				break;

			case 'g':

				match = MATCH_GLOB;

				break;

			case 'x':

				match = MATCH_REGEX;

				break;

			case 'X':

				match = MATCH_EREGEX;

				break;

			case 'e':

				match = MATCH_CONDITION;

				condition = optarg;

				break;

			case 'r':

				reponame = optarg;

				break;

			default:

				usage_query();

				return (EX_USAGE);

		}

	}

	argc -= optind;

	argv += optind;

	if (argc == 0) {

		usage_query();

		return (EX_USAGE);

	}

	if ((argc == 1) ^ (match == MATCH_ALL) && condition == NULL) {

		usage_query();

		return (EX_USAGE);

	}

	if (analyse_query_string(argv[0], accepted_rquery_flags, q_flags_len, &query_flags, &multiline) != EPKG_OK)

		return (EX_USAGE);

	if (condition != NULL) {

		sqlcond = sbuf_new_auto();

		if (format_sql_condition(condition, sqlcond) != EPKG_OK)

			return (EX_USAGE);

		sbuf_finish(sqlcond);

	}

	ret = pkgdb_open(&db, PKGDB_REMOTE);

	if (ret == EPKG_ENODB) {

		if (geteuid() == 0)

			return (EX_IOERR);

		/* do not fail if run as a user */

		return (EXIT_SUCCESS);

	}

	if (ret != EPKG_OK)

		return (EX_IOERR);

	if (match == MATCH_ALL || match == MATCH_CONDITION) {

		const char *condition_sql = NULL;

		if (match == MATCH_CONDITION && sqlcond)

			condition_sql = sbuf_data(sqlcond);

		if ((it = pkgdb_rquery(db, condition_sql, match, reponame)) == NULL)

			return (EX_IOERR);

		while ((ret = pkgdb_it_next(it, &pkg, query_flags)) == EPKG_OK)

			print_query(pkg, argv[0],  multiline);

		if (ret != EPKG_END)

			retcode = EX_SOFTWARE;

		pkgdb_it_free(it);

	} else {

		for (i = 1; i < argc; i++) {

			pkgname = argv[i];

			if ((it = pkgdb_rquery(db, pkgname, match, reponame)) == NULL)

				return (EX_IOERR);

			while ((ret = pkgdb_it_next(it, &pkg, query_flags)) == EPKG_OK)

				print_query(pkg, argv[0], multiline);

			if (ret != EPKG_END) {

				retcode = EX_SOFTWARE;

				break;

			}

			pkgdb_it_free(it);

		}

	}

	pkg_free(pkg);

	pkgdb_close(db);

	return (retcode);

}

	if ((it = pkgdb_search(db, pattern, match, field, reponame)) == NULL) {