/** @fn void mock_message(void)
* @brief Generate a test Remos Query randomly
*
* Here we generate a mock query statically, incrementing the request
* ID every time we are invoked. We instantiate a struct Query_struct,
* populate it, and use a QMS_Remos_Msg object to facilitate
* conversion to XML
*/
void
mock_message(void)
{
QMS_Trace ("mock_message", __LINE__, __FILE__);
Query_struct query;
ACE_Write_Guard<ACE_Thread_Mutex> guard(TD_asset_guard);
{
query.request_id = count++;
}
query.request_id = 0;
query.repeat_count = 5;
query.refresh_rate = 2.45;
query.type = Query_struct::link;
query.host_names = "skywalker_t.stdc.com,kenobee_t.stdc.com,c3po_t.stdc.com";
DEBUG0 (DEBUG_L_CALL, "DEBUG Created Query\n");
cout << "============================================================"
<<endl;
print_query(&query);
cout << "============================================================"
<<endl;
QMS_Remos_Msg message;
message.insert(query);
string data = message.as_string();
qms_api.send(data);
DEBUG0 (DEBUG_L_LEAVE, "DEBUG Sending all done\n");
}
void query() {
while (1) {
printf("Please enter SID or name. Enter 0 to finish.\n");
char id_or_name[12];
scanf("%s", id_or_name);
if (strcmp(id_or_name, "0") == 0) return;
if (isdigit(id_or_name[0])) {
for (int i = 0; i < stu_num; i++) {
if (strcmp(stu[i].sid, id_or_name) == 0) {
print_query(i);
}
}
}
else {
for (int i = 0; i < stu_num; i++) {
if (strcmp(stu[i].name, id_or_name) == 0) {
print_query(i);
}
}
}
}
}
int db_redis_append_command_argv(km_redis_con_t *con, redis_key_t *query, int queue) {
char **argv = NULL;
int ret, argc;
print_query(query);
if (queue > 0 && db_redis_push_query(con, query) != 0) {
LM_ERR("Failed to queue redis command\n");
return -1;
}
argc = db_redis_key_list2arr(query, &argv);
if (argc < 0) {
LM_ERR("Failed to allocate memory for query array\n");
return -1;
}
LM_DBG("query has %d args\n", argc);
ret = redisAppendCommandArgv(con->con, argc, (const char**)argv, NULL);
// this should actually never happen, because if all replies
// are properly consumed for the previous command, it won't send
// out a new query until redisGetReply is called
if (con->con->err == REDIS_ERR_EOF) {
if (db_redis_connect(con) != 0) {
LM_ERR("Failed to reconnect to redis db\n");
pkg_free(argv);
if (con->con) {
redisFree(con->con);
con->con = NULL;
}
return ret;
}
ret = redisAppendCommandArgv(con->con, argc, (const char**)argv, NULL);
}
pkg_free(argv);
if (!con->con->err) {
con->append_counter++;
}
return ret;
}
int main(int argc, char **argv) {
Node **head = malloc(sizeof(Node *));
Node *word_node;
char **filenames = init_filenames();
char ch;
char *indexfile = "index";
char *namefile = "filenames";
char *word;
while((ch = getopt(argc, argv, "i:n:")) != -1) {
switch (ch) {
case 'i':
indexfile = optarg;
break;
case 'n':
namefile = optarg;
break;
default:
fprintf(stderr, "Usage: indexfile [-i FILE] [-n FILE ] FILE...\n");
exit(1);
}
}
if (argv[optind] == NULL) { // No word arguments were given.
fprintf(stderr, "Usage: indexfile [-u FILE] [-n FILE] FILE...\n");
exit(1);
}
word = argv[optind];
read_list(namefile, indexfile, head, filenames);
word_node = find_word_node(*head, word);
if (word_node != NULL) {
print_query(word_node, filenames);
}
else { // The word does not exist in the linked list.
printf("indexfile %s: word not found\n", argv[optind]);
}
return 0;
}
int
exec_query(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;
while ((ch = getopt(argc, argv, "agxXf:")) != -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 'f':
pkgname = 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) && pkgname == NULL) {
usage_query();
return (EX_USAGE);
}
if (analyse_query_string(argv[0], &query_flags, &multiline) != EPKG_OK)
return (EX_USAGE);
if (pkgname != NULL) {
if (pkg_open(&pkg, pkgname, NULL) != EPKG_OK) {
return (1);
}
print_query(pkg, argv[0], multiline);
pkg_free(pkg);
return (0);
}
if (pkgdb_open(&db, PKGDB_DEFAULT) != EPKG_OK)
return (EX_IOERR);
if (match == MATCH_ALL) {
if ((it = pkgdb_query(db, NULL, match)) == 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_query(db, pkgname, match)) == 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);
}
int
exec_query(int argc, char **argv)
{
struct pkgdb *db = NULL;
struct pkgdb_it *it = NULL;
struct pkg *pkg = NULL;
struct pkg_manifest_key *keys = NULL;
char *pkgname = NULL;
int query_flags = PKG_LOAD_BASIC;
match_t match = MATCH_EXACT;
int ch;
int ret;
int retcode = EX_OK;
int i;
char multiline = 0;
char *condition = NULL;
struct sbuf *sqlcond = NULL;
const unsigned int q_flags_len = NELEM(accepted_query_flags);
struct option longopts[] = {
{ "all", no_argument, NULL, 'a' },
{ "case-sensitive", no_argument, NULL, 'C' },
{ "evaluate", required_argument, NULL, 'e' },
{ "file", required_argument, NULL, 'F' },
{ "glob", no_argument, NULL, 'g' },
{ "case-insensitive", no_argument, NULL, 'i' },
{ "regex", no_argument, NULL, 'x' },
{ NULL, 0, NULL, 0 },
};
while ((ch = getopt_long(argc, argv, "+aCe:F:gix", longopts, NULL)) != -1) {
switch (ch) {
case 'a':
match = MATCH_ALL;
break;
case 'C':
pkgdb_set_case_sensitivity(true);
break;
case 'e':
match = MATCH_CONDITION;
condition = optarg;
break;
case 'F':
pkgname = optarg;
break;
case 'g':
match = MATCH_GLOB;
break;
case 'i':
pkgdb_set_case_sensitivity(false);
break;
case 'x':
match = MATCH_REGEX;
break;
default:
usage_query();
return (EX_USAGE);
}
}
argc -= optind;
argv += optind;
if (argc == 0) {
usage_query();
return (EX_USAGE);
}
/* Default to all packages if no pkg provided */
if (argc == 1 && pkgname == NULL && condition == NULL && match == MATCH_EXACT) {
match = MATCH_ALL;
} else if (((argc == 1) ^ (match == MATCH_ALL)) && pkgname == NULL
&& condition == NULL) {
usage_query();
return (EX_USAGE);
}
if (analyse_query_string(argv[0], accepted_query_flags, q_flags_len,
&query_flags, &multiline) != EPKG_OK)
return (EX_USAGE);
if (pkgname != NULL) {
pkg_manifest_keys_new(&keys);
if (pkg_open(&pkg, pkgname, keys, 0) != EPKG_OK) {
return (EX_IOERR);
}
pkg_manifest_keys_free(keys);
print_query(pkg, argv[0], multiline);
pkg_free(pkg);
return (EX_OK);
}
if (condition != NULL) {
sqlcond = sbuf_new_auto();
if (format_sql_condition(condition, sqlcond, false) != EPKG_OK) {
sbuf_delete(sqlcond);
return (EX_USAGE);
}
sbuf_finish(sqlcond);
}
ret = pkgdb_access(PKGDB_MODE_READ, PKGDB_DB_LOCAL);
if (ret == EPKG_ENOACCESS) {
warnx("Insufficient privileges to query the package database");
return (EX_NOPERM);
} else if (ret == EPKG_ENODB) {
if (!quiet)
warnx("No packages installed");
return (EX_OK);
} else if (ret != EPKG_OK)
return (EX_IOERR);
ret = pkgdb_open(&db, PKGDB_DEFAULT);
if (ret != EPKG_OK)
return (EX_IOERR);
if (pkgdb_obtain_lock(db, PKGDB_LOCK_READONLY) != EPKG_OK) {
pkgdb_close(db);
warnx("Cannot get a read lock on a database, it is locked by another process");
return (EX_TEMPFAIL);
}
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)
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 {
int nprinted = 0;
for (i = 1; i < argc; i++) {
pkgname = argv[i];
if ((it = pkgdb_query(db, pkgname, match)) == NULL) {
retcode = EX_IOERR;
goto cleanup;
}
while ((ret = pkgdb_it_next(it, &pkg, query_flags)) == EPKG_OK) {
nprinted++;
print_query(pkg, argv[0], multiline);
}
if (ret != EPKG_END) {
retcode = EX_SOFTWARE;
break;
}
pkgdb_it_free(it);
}
if (nprinted == 0 && retcode == EX_OK) {
/* ensure to return a non-zero status when no package
were found. */
retcode = EX_UNAVAILABLE;
}
}
cleanup:
pkg_free(pkg);
pkgdb_release_lock(db, PKGDB_LOCK_READONLY);
pkgdb_close(db);
return (retcode);
}
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 = EX_OK;
int i;
char multiline = 0;
char *condition = NULL;
const char *portsdir;
struct sbuf *sqlcond = NULL;
const unsigned int q_flags_len = NELEM(accepted_rquery_flags);
const char *reponame = NULL;
bool auto_update;
bool onematched = false;
bool old_quiet;
bool index_output = false;
struct option longopts[] = {
{ "all", no_argument, NULL, 'a' },
{ "case-sensitive", no_argument, NULL, 'C' },
{ "evaluate", required_argument, NULL, 'e' },
{ "glob", no_argument, NULL, 'g' },
{ "case-insensitive", no_argument, NULL, 'i' },
{ "index-line", no_argument, NULL, 'I' },
{ "repository", required_argument, NULL, 'r' },
{ "no-repo-update", no_argument, NULL, 'U' },
{ "regex", no_argument, NULL, 'x' },
{ NULL, 0, NULL, 0 },
};
portsdir = pkg_object_string(pkg_config_get("PORTSDIR"));
while ((ch = getopt_long(argc, argv, "+aCgiIxe:r:U", longopts, NULL)) != -1) {
switch (ch) {
case 'a':
match = MATCH_ALL;
break;
case 'C':
pkgdb_set_case_sensitivity(true);
break;
case 'e':
match = MATCH_CONDITION;
condition = optarg;
break;
case 'g':
match = MATCH_GLOB;
break;
case 'i':
pkgdb_set_case_sensitivity(false);
break;
case 'I':
index_output = true;
break;
case 'r':
reponame = optarg;
break;
case 'U':
auto_update = false;
break;
case 'x':
match = MATCH_REGEX;
break;
default:
usage_rquery();
return (EX_USAGE);
}
}
argc -= optind;
argv += optind;
if (argc == 0 && !index_output) {
usage_rquery();
return (EX_USAGE);
}
/* Default to all packages if no pkg provided */
if (!index_output) {
if (argc == 1 && condition == NULL && match == MATCH_EXACT) {
match = MATCH_ALL;
} else if (((argc == 1) ^ (match == MATCH_ALL )) && condition == NULL) {
usage_rquery();
return (EX_USAGE);
}
} else {
if (argc == 0)
match = MATCH_ALL;
}
if (!index_output && 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, true) != EPKG_OK)
return (EX_USAGE);
sbuf_finish(sqlcond);
}
ret = pkgdb_access(PKGDB_MODE_READ, PKGDB_DB_REPO);
if (ret == EPKG_ENOACCESS) {
warnx("Insufficient privileges to query the package database");
return (EX_NOPERM);
} else if (ret != EPKG_OK)
return (EX_IOERR);
/* first update the remote repositories if needed */
old_quiet = quiet;
quiet = true;
if (auto_update && (ret = pkgcli_update(false, false, reponame)) != EPKG_OK)
return (ret);
quiet = old_quiet;
ret = pkgdb_open_all(&db, PKGDB_REMOTE, reponame);
if (ret != EPKG_OK)
return (EX_IOERR);
if (index_output)
query_flags = PKG_LOAD_BASIC|PKG_LOAD_CATEGORIES|PKG_LOAD_DEPS;
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_repo_query(db, condition_sql, match, reponame)) == NULL)
return (EX_IOERR);
while ((ret = pkgdb_it_next(it, &pkg, query_flags)) == EPKG_OK) {
if (index_output)
print_index(pkg, portsdir);
else
print_query(pkg, argv[0], multiline);
}
if (ret != EPKG_END)
retcode = EX_SOFTWARE;
pkgdb_it_free(it);
} else {
for (i = (index_output ? 0 : 1); i < argc; i++) {
pkgname = argv[i];
if ((it = pkgdb_repo_query(db, pkgname, match, reponame)) == NULL)
return (EX_IOERR);
while ((ret = pkgdb_it_next(it, &pkg, query_flags)) == EPKG_OK) {
onematched = true;
if (index_output)
print_index(pkg, portsdir);
else
print_query(pkg, argv[0], multiline);
}
if (ret != EPKG_END) {
retcode = EX_SOFTWARE;
break;
}
pkgdb_it_free(it);
}
if (!onematched && retcode == EX_OK)
retcode = EX_UNAVAILABLE;
}
pkg_free(pkg);
pkgdb_close(db);
return (retcode);
}
int
exec_query(int argc, char **argv)
{
struct pkgdb *db = NULL;
struct pkgdb_it *it = NULL;
struct pkg *pkg = NULL;
struct pkg_manifest_key *keys = NULL;
char *pkgname = NULL;
int query_flags = PKG_LOAD_BASIC;
match_t match = MATCH_EXACT;
int ch;
int ret;
int retcode = EX_OK;
int i;
char multiline = 0;
char *condition = NULL;
struct sbuf *sqlcond = NULL;
const unsigned int q_flags_len = (sizeof(accepted_query_flags)/sizeof(accepted_query_flags[0]));
while ((ch = getopt(argc, argv, "agixF:e:")) != -1) {
switch (ch) {
case 'a':
match = MATCH_ALL;
break;
case 'g':
match = MATCH_GLOB;
break;
case 'i':
pkgdb_set_case_sensitivity(false);
break;
case 'x':
match = MATCH_REGEX;
break;
case 'F':
pkgname = optarg;
break;
case 'e':
match = MATCH_CONDITION;
condition = optarg;
break;
default:
usage_query();
return (EX_USAGE);
}
}
argc -= optind;
argv += optind;
if (argc == 0) {
usage_query();
return (EX_USAGE);
}
/* Default to all packages if no pkg provided */
if (argc == 1 && pkgname == NULL && condition == NULL && match == MATCH_EXACT) {
match = MATCH_ALL;
} else if ((argc == 1) ^ (match == MATCH_ALL) && pkgname == NULL && condition == NULL) {
usage_query();
return (EX_USAGE);
}
if (analyse_query_string(argv[0], accepted_query_flags, q_flags_len, &query_flags, &multiline) != EPKG_OK)
return (EX_USAGE);
if (pkgname != NULL) {
pkg_manifest_keys_new(&keys);
if (pkg_open(&pkg, pkgname, keys, 0) != EPKG_OK) {
return (EX_IOERR);
}
pkg_manifest_keys_free(keys);
print_query(pkg, argv[0], multiline);
pkg_free(pkg);
return (EX_OK);
}
if (condition != NULL) {
sqlcond = sbuf_new_auto();
if (format_sql_condition(condition, sqlcond, false) != EPKG_OK) {
sbuf_delete(sqlcond);
return (EX_USAGE);
}
sbuf_finish(sqlcond);
}
ret = pkgdb_access(PKGDB_MODE_READ, PKGDB_DB_LOCAL);
if (ret == EPKG_ENOACCESS) {
warnx("Insufficient privilege to query package database");
return (EX_NOPERM);
} else if (ret == EPKG_ENODB) {
if (!quiet)
warnx("No packages installed");
return (EX_OK);
} else if (ret != EPKG_OK)
return (EX_IOERR);
ret = pkgdb_open(&db, PKGDB_DEFAULT);
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_query(db, condition_sql, match)) == 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 {
int nprinted = 0;
for (i = 1; i < argc; i++) {
pkgname = argv[i];
if ((it = pkgdb_query(db, pkgname, match)) == NULL)
return (EX_IOERR);
while ((ret = pkgdb_it_next(it, &pkg, query_flags)) == EPKG_OK) {
nprinted++;
print_query(pkg, argv[0], multiline);
}
if (ret != EPKG_END) {
retcode = EX_SOFTWARE;
break;
}
pkgdb_it_free(it);
}
if (nprinted == 0 && retcode == EX_OK) {
/* ensure to return a non-zero status when no package
were found. */
retcode = EX_UNAVAILABLE;
}
}
pkg_free(pkg);
pkgdb_close(db);
return (retcode);
}
/**
* @brief The main entry point
* @param argc Number of command line arguments
* @param argv Array of command line arguments
*
* Usage: [CORBA OPTIONS] [OPTIONS]
* - -help : This help text
* - -h : This help text
* - -version : Prints out the version
* - -v : Prints out the version
*/
int
main (int argc, char *argv[])
{
QMS_Trace ("main", __LINE__, __FILE__);
DEBUG0 (DEBUG_L_ENTER, "DEBUG: starting\n");
signal(SIGTERM,sig_handler);
signal(SIGINT,sig_handler);
signal(SIGABRT,sig_handler);
signal(SIGHUP,sig_handler);
DEBUG0 (DEBUG_L_CALL, "DEBUG: added signal handling\n");
DEBUG0 (DEBUG_L_CALL, "DEBUG: parsing arguments\n");
for (int i = 0; i < argc; i++)
{
if (!argv[i]) { break; }
if (argv[i][0] != '-') { continue; }
int j = 1;
if (argv[i][1] == '-') {
if (argv[i][2] == 0) { break; } // handle -- end of options
j = 2; // handle --argument
}
if (strstr((argv[i] + j), "ORB")) { continue; }
if (! strcmp((argv[i] + j), "help") || strchr((argv[i] + j), 'h'))
{ // -h or --help
cout << argv[0] << version << endl
<< "Usage: " << argv[0] << "[CORBA OPTIONS] [OPTIONS]"
<< endl
<< "\t-h : This help text" << endl
<< "\t-v : Prints out the version" << endl
;
exit (0);
}
if (! strcmp((argv[i] + j), "version") || strchr((argv[i] + j), 'v'))
{
cout << argv[0] << ": version " << version << endl;
exit (0);
}
else
{
DEBUG1 (DEBUG_L_ENTER, "unknown argument %s\n", argv[i]);
}
}
Data_struct data;
data.request_id = 0;
data.data_id = 4;
data.refresh_rate = 2.45;
data.latency = 0.235;
data.available_bandwidth = 100000.0;
data.maximum_bandwidth = 200000.0;
data.type = Data_struct::link;
data.source = "Host One";
data.destination = "Host Two";
cerr << "=================================print_data================="
<<endl;
print_data(&data);
cerr << "============================Message_as_string=============="
<<endl;
QMS_Remos_Msg data_msg;
data_msg.insert(data);
cout << data_msg.as_string();
cerr << "==========================print_data==========================="
<<endl;
struct Data_struct *new_data_p = data_msg.extract_data();
print_data(new_data_p);
cerr << "=========================================================="
<<endl;
Query_struct query;
query.request_id = 0;
query.repeat_count = 5;
query.refresh_rate = 2.45;
query.type = Query_struct::link;
query.host_names = "skywalker_t.stdc.com,kenobee_t.stdc.com,c3po_t.stdc.com";
cerr << "================================print_query===================="
<<endl;
print_query(&query);
cerr << "============================query as string===================="
<<endl;
data_msg.erase();
QMS_Remos_Msg query_msg;
query_msg.insert(query);
cout << query_msg.as_string();
cerr << "================================print query=================="
<<endl;
struct Query_struct *new_query_p = query_msg.extract_query();
print_query(new_query_p);
exit (0);
}
int main(int argc, char *argv[])
{
char query[MAX_BOOTSTRAP_QUERY_SIZE];
char* struct_name= argv[1];
char* infile_name= argv[2];
char* outfile_name= argv[3];
int rc;
int query_length;
int error= 0;
char *err_ptr;
if (argc != 4)
die("Usage: comp_sql <struct_name> <sql_filename> <c_filename>");
/* Open input and output file */
if (!(in= fopen(infile_name, "r")))
die("Failed to open SQL file '%s'", infile_name);
if (!(out= fopen(outfile_name, "w")))
die("Failed to open output file '%s'", outfile_name);
fprintf(out, "/*\n");
fprintf(out, " Do not edit this file, it is automatically generated from:\n");
fprintf(out, " <%s>\n", infile_name);
fprintf(out, "*/\n");
fprintf(out, "#include <stdlib.h>\n"); /* NULL */
fprintf(out, "const char* %s[]={\n", struct_name);
for ( ; ; )
{
rc= read_bootstrap_query(query, &query_length,
(fgets_input_t) in, fgets_fn, &error);
if (rc == READ_BOOTSTRAP_EOF)
break;
if (rc != READ_BOOTSTRAP_SUCCESS)
{
/* Get the most recent query text for reference. */
err_ptr= query + (query_length <= MAX_BOOTSTRAP_ERROR_LEN ?
0 : (query_length - MAX_BOOTSTRAP_ERROR_LEN));
switch (rc)
{
case READ_BOOTSTRAP_ERROR:
die("Failed to read the bootstrap input file. Return code (%d).\n"
"Last query: '%s'\n", error, err_ptr);
break;
case READ_BOOTSTRAP_QUERY_SIZE:
die("Failed to read the boostrap input file. Query size exceeded %d bytes.\n"
"Last query: '%s'.\n", MAX_BOOTSTRAP_LINE_SIZE, err_ptr);
break;
default:
die("Failed to read the boostrap input file. Unknown error.\n");
break;
}
}
print_query(out, query);
}
fprintf(out, "NULL\n};\n");
fclose(in);
fclose(out);
exit(0);
}
int
exec_query(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 = EX_OK;
int i;
char multiline = 0;
char *condition = NULL;
struct sbuf *sqlcond = NULL;
const unsigned int q_flags_len = (sizeof(accepted_query_flags)/sizeof(accepted_query_flags[0]));
while ((ch = getopt(argc, argv, "agxXF:e:")) != -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 'F':
pkgname = optarg;
break;
case 'e':
match = MATCH_CONDITION;
condition = optarg;
break;
default:
usage_query();
return (EX_USAGE);
}
}
argc -= optind;
argv += optind;
if (argc == 0) {
usage_query();
return (EX_USAGE);
}
/* Default to all packages if no pkg provided */
if (argc == 1 && pkgname == NULL && condition == NULL && match == MATCH_EXACT) {
match = MATCH_ALL;
} else if ((argc == 1) ^ (match == MATCH_ALL) && pkgname == NULL && condition == NULL) {
usage_query();
return (EX_USAGE);
}
if (analyse_query_string(argv[0], accepted_query_flags, q_flags_len, &query_flags, &multiline) != EPKG_OK)
return (EX_USAGE);
if (pkgname != NULL) {
if (pkg_open(&pkg, pkgname) != EPKG_OK) {
return (EX_IOERR);
}
print_query(pkg, argv[0], multiline);
pkg_free(pkg);
return (EX_OK);
}
if (condition != NULL) {
sqlcond = sbuf_new_auto();
if (format_sql_condition(condition, sqlcond, false) != EPKG_OK) {
sbuf_delete(sqlcond);
return (EX_USAGE);
}
sbuf_finish(sqlcond);
}
ret = pkgdb_open(&db, PKGDB_DEFAULT);
if (ret == EPKG_ENODB) {
if (geteuid() == 0)
return (EX_IOERR);
/* do not fail if run as a user */
return (EX_OK);
}
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_query(db, condition_sql, match)) == 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_query(db, pkgname, match)) == 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);
}
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 = EX_OK;
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;
bool auto_update;
bool onematched = false;
bool old_quiet;
pkg_config_bool(PKG_CONFIG_REPO_AUTOUPDATE, &auto_update);
while ((ch = getopt(argc, argv, "agixe:r:U")) != -1) {
switch (ch) {
case 'a':
match = MATCH_ALL;
break;
case 'g':
match = MATCH_GLOB;
break;
case 'i':
pkgdb_set_case_sensitivity(false);
break;
case 'x':
match = MATCH_REGEX;
break;
case 'e':
match = MATCH_CONDITION;
condition = optarg;
break;
case 'r':
reponame = optarg;
break;
case 'U':
auto_update = false;
break;
default:
usage_rquery();
return (EX_USAGE);
}
}
argc -= optind;
argv += optind;
if (argc == 0) {
usage_rquery();
return (EX_USAGE);
}
/* Default to all packages if no pkg provided */
if (argc == 1 && pkgname == NULL && condition == NULL && match == MATCH_EXACT) {
match = MATCH_ALL;
} else if ((argc == 1) ^ (match == MATCH_ALL) && condition == NULL) {
usage_rquery();
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, true) != EPKG_OK)
return (EX_USAGE);
sbuf_finish(sqlcond);
}
ret = pkgdb_access(PKGDB_MODE_READ, PKGDB_DB_REPO);
if (ret == EPKG_ENOACCESS) {
warnx("Insufficient privilege to query package database");
return (EX_NOPERM);
} else if (ret != EPKG_OK)
return (EX_IOERR);
/* first update the remote repositories if needed */
old_quiet = quiet;
quiet = true;
if (auto_update && (ret = pkgcli_update(false)) != EPKG_OK)
return (ret);
quiet = old_quiet;
ret = pkgdb_open(&db, PKGDB_REMOTE);
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) {
onematched = true;
print_query(pkg, argv[0], multiline);
}
if (ret != EPKG_END) {
retcode = EX_SOFTWARE;
break;
}
pkgdb_it_free(it);
}
if (!onematched && retcode == EX_OK)
retcode = EX_UNAVAILABLE;
}
pkg_free(pkg);
pkgdb_close(db);
return (retcode);
}
const struct choice *
selected_choice(void)
{
char buf[6];
int key, selection = 0, visible_choices_count;
int word_position;
size_t cursor_position, length, query_length, scroll;
cursor_position = query_length = strlen(query);
filter_choices();
init_tty();
if (cursor_position >= (size_t)columns)
scroll = cursor_position - columns + 1;
else
scroll = 0;
visible_choices_count = print_choices(selection);
print_query(query, query_length, cursor_position, scroll);
tty_putp(cursor_normal);
for (;;) {
fflush(tty_out);
memset(buf, 0, sizeof(buf));
key = get_key(buf, sizeof(buf), &length);
switch (key) {
case ENTER:
if (visible_choices_count > 0) {
restore_tty();
if (selection >= 0 && selection < (ssize_t)choices.length)
return &choices.v[selection];
else
return NULL;
}
break;
case ALT_ENTER:
restore_tty();
choices.v[choices.length].string = query;
choices.v[choices.length].description = "";
return &choices.v[choices.length];
case DEL:
if (cursor_position > 0) {
for (length = 1;
isu8cont(query[cursor_position - length]);
length++);
delete_between(
query,
query_length,
cursor_position - length,
cursor_position);
cursor_position -= length;
query_length -= length;
filter_choices();
selection = 0;
}
break;
case CTRL_D:
if (cursor_position < query_length) {
for (length = 1;
isu8cont(query[cursor_position + length]);
length++);
delete_between(
query,
query_length,
cursor_position,
cursor_position + length);
query_length -= length;
filter_choices();
selection = 0;
}
break;
case CTRL_U:
delete_between(
query,
query_length,
0,
cursor_position);
query_length -= cursor_position;
cursor_position = 0;
filter_choices();
selection = 0;
break;
case CTRL_K:
delete_between(
query,
query_length,
cursor_position,
query_length);
query_length = cursor_position;
filter_choices();
selection = 0;
break;
case CTRL_W:
if (cursor_position == 0)
break;
for (word_position = cursor_position;;) {
while (isu8cont(query[--word_position]));
if (word_position < 1)
break;
if (query[word_position] != ' '
&& query[word_position - 1] == ' ')
break;
}
delete_between(
query,
query_length,
word_position,
cursor_position);
query_length -= cursor_position - word_position;
cursor_position = word_position;
filter_choices();
selection = 0;
break;
case CTRL_A:
cursor_position = 0;
break;
case CTRL_E:
cursor_position = query_length;
break;
case DOWN:
if (selection < visible_choices_count - 1)
++selection;
break;
case UP:
if (selection > 0)
--selection;
break;
case LEFT:
while (cursor_position > 0
&& isu8cont(query[--cursor_position]));
break;
case RIGHT:
while (cursor_position < query_length
&& isu8cont(query[++cursor_position]));
break;
default:
if (!isu8start(buf[0]) && !isprint(buf[0]))
continue;
if (query_size < query_length + length) {
query_size = 2*query_length + length;
if ((query = reallocarray(query, query_size,
sizeof(char))) == NULL)
err(1, NULL);
}
if (cursor_position < query_length)
memmove(query + cursor_position + length,
query + cursor_position,
query_length - cursor_position);
memcpy(query + cursor_position, buf, length);
cursor_position += length;
query_length += length;
query[query_length] = '\0';
filter_choices();
selection = 0;
break;
}
tty_putp(cursor_invisible);
visible_choices_count = print_choices(selection);
if (cursor_position >= scroll + columns)
scroll = cursor_position - columns + 1;
if (cursor_position < scroll)
scroll = cursor_position;
print_query(query, query_length, cursor_position, scroll);
tty_putp(cursor_normal);
}
}
void *db_redis_command_argv(km_redis_con_t *con, redis_key_t *query) {
char **argv = NULL;
int argc;
print_query(query);
argc = db_redis_key_list2arr(query, &argv);
if (argc < 0) {
LM_ERR("Failed to allocate memory for query array\n");
return NULL;
}
LM_DBG("query has %d args\n", argc);
redisReply *reply = redisCommandArgv(con->con, argc, (const char**)argv, NULL);
if (con->con->err == REDIS_ERR_EOF) {
if (db_redis_connect(con) != 0) {
LM_ERR("Failed to reconnect to redis db\n");
pkg_free(argv);
if (con->con) {
redisFree(con->con);
con->con = NULL;
}
return NULL;
}
reply = redisCommandArgv(con->con, argc, (const char**)argv, NULL);
}
pkg_free(argv);
return reply;
}
