int
param_main(int argc, char *argv[])
{
if (argc >= 2) {
if (!strcmp(argv[1], "save")) {
if (argc >= 3) {
do_save(argv[2]);
} else {
do_save(param_get_default_file());
}
}
if (!strcmp(argv[1], "load")) {
if (argc >= 3) {
do_load(argv[2]);
} else {
do_load(param_get_default_file());
}
}
if (!strcmp(argv[1], "import")) {
if (argc >= 3) {
do_import(argv[2]);
} else {
do_import(param_get_default_file());
}
}
if (!strcmp(argv[1], "select")) {
if (argc >= 3) {
param_set_default_file(argv[2]);
} else {
param_set_default_file(NULL);
}
warnx("selected parameter default file %s", param_get_default_file());
exit(0);
}
if (!strcmp(argv[1], "show"))
if (argc >= 3) {
do_show(argv[2]);
} else {
do_show(NULL);
}
}
errx(1, "expected a command, try 'load', 'import', 'show', 'select' or 'save'");
}
void SFunctionImport::
DoApply(int paramsc, const SReference paramsv[], IntelibContinuation& lf) const
// <symbol(s)> <package>
{
SExpressionHashPackage *pkg =
paramsv[1].DynamicCastGetPtr<SExpressionHashPackage>();
INTELIB_ASSERT(pkg, IntelibX_not_a_package(paramsv[1]));
SExpressionCons *dp = paramsv[0].DynamicCastGetPtr<SExpressionCons>();
if(dp) {
do_import(pkg, dp->Car(), dp->Cdr());
} else {
do_import(pkg, paramsv[0], *PTheEmptyList);
}
lf.RegularReturn(lf.True());
}
static void*
handle_import(enum mg_event event,
struct mg_connection *conn,
const struct mg_request_info *request_info) {
std::string file = get_qs(request_info, "file");
int sorted = atoi(get_qs(request_info, "sorted").c_str());
uint_t limit = atoi(get_qs(request_info, "limit").c_str());
int nadded, nlines;
const time_t start_time = time(NULL);
if (!limit) {
limit = minus_one;
}
int ret = do_import(file, sorted, limit, nadded, nlines);
if (ret < 0) {
switch (-ret) {
case IMPORT_FILE_NOT_FOUND:
print_HTTP_response(conn, 404, "Not Found");
break;
default:
cerr<<"ERROR::Unknown error: "<<ret<<endl;
}
}
else {
print_HTTP_response(conn, 200, "OK");
mg_printf(conn, "Successfully added %d/%d records from \"%s\" in %d second(s)\n",
nadded, nlines, file.c_str(), time(NULL) - start_time);
}
return (void*)"";
}
static void import_float_spec_colors( GLcontext *ctx )
{
struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
struct gl_client_array *to = &SWSETUP_CONTEXT(ctx)->ChanSecondaryColor;
do_import( VB, to, VB->SecondaryColorPtr[0] );
VB->SecondaryColorPtr[0] = to;
}
static NMConnection *
import (NMVpnEditorPlugin *iface, const char *path, GError **error)
{
NMConnection *connection = NULL;
char *contents = NULL;
char *ext;
gsize contents_len;
ext = strrchr (path, '.');
if (!ext || ( !g_str_has_suffix (ext, ".ovpn")
&& !g_str_has_suffix (ext, ".conf")
&& !g_str_has_suffix (ext, ".cnf")
&& !g_str_has_suffix (ext, ".ovpntest"))) { /* Special extension for testcases */
g_set_error_literal (error,
NMV_EDITOR_PLUGIN_ERROR,
NMV_EDITOR_PLUGIN_ERROR_FILE_NOT_VPN,
_("unknown OpenVPN file extension"));
goto out;
}
if (!g_file_get_contents (path, &contents, &contents_len, error))
return NULL;
connection = do_import (path, contents, contents_len, error);
out:
g_free (contents);
return connection;
}
static __inline__ void ffbImportColors(ffbContextPtr fmesa, GLcontext *ctx, int index)
{
struct gl_client_array *to = &fmesa->FloatColor;
struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
do_import(VB, to, VB->ColorPtr[index]);
VB->ColorPtr[index] = to;
}
IMPORT_QUALIFIER void TAG(import_float_spec_colors)( GLcontext *ctx )
{
LOCALVARS
struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
struct gl_client_array *to = GET_UBYTE_SPEC_COLOR_STORE();
do_import( VB, to, VB->SecondaryColorPtr[0] );
VB->SecondaryColorPtr[0] = to;
}
/*=================================================
* import_from_file -- Read GEDCOM file to database
* ifeed: [IN] output methods
* fp: [I/O] GEDCOM file whence to load data
*===============================================*/
BOOLEAN
import_from_gedcom_file (IMPORT_FEEDBACK ifeed, FILE *fp)
{
BOOLEAN rtn=FALSE;
flineno = 0;
rtn = do_import(ifeed, fp);
return rtn;
}
static PyObject *
import_module(PyObject *self, PyObject *args)
{
char *initfuncname;
char *modname;
char *pathname;
HMODULE hmem;
FARPROC init_func;
ULONG_PTR cookie = 0;
PyObject *findproc;
/* code, initfuncname, fqmodulename, path */
if (!PyArg_ParseTuple(args, "sssO:import_module",
&modname, &pathname,
&initfuncname,
&findproc))
return NULL;
cookie = _My_ActivateActCtx();//try some windows manifest magic...
hmem = MyLoadLibrary(pathname, NULL, findproc);
_My_DeactivateActCtx(cookie);
if (!hmem) {
char *msg;
FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
NULL,
GetLastError(),
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(void *)&msg,
0,
NULL);
msg[strlen(msg)-2] = '\0';
PyErr_Format(PyExc_ImportError,
"MemoryLoadLibrary failed loading %s: %s (%d)",
pathname, msg, GetLastError());
LocalFree(msg);
/* PyErr_Format(PyExc_ImportError, */
/* "MemoryLoadLibrary failed loading %s (Error %d loading %s)", */
/* pathname, GetLastError(), LastErrorString); */
/* PyErr_Format(PyExc_ImportError, */
/* "MemoryLoadLibrary failed loading %s", pathname); */
return NULL;
}
init_func = MyGetProcAddress(hmem, initfuncname);
if (do_import(init_func, modname) < 0) {
MyFreeLibrary(hmem);
return NULL;
}
/* Retrieve from sys.modules */
return PyImport_ImportModule(modname);
}
int main( int argc, char **argv )
{
progname = argv[0];
if(argc > 1 && !strcmp(argv[1], "import")){
do_import(argc, argv);
} else if(argc > 1 && !strcmp(argv[1], "export")){
do_export(argc, argv);
} else {
usage();
}
return 0;
}
static void do_import(SExpressionHashPackage *pkg,
const SReference &a,
const SReference &d)
{
SReference la(a);
if(!pkg->Import(la)) {
throw IntelibX_package_conflict(a);
}
if(d.IsEmptyList()) return;
SExpressionCons *dp = d.DynamicCastGetPtr<SExpressionCons>();
INTELIB_ASSERT(dp, IntelibX_not_a_list(d));
do_import(pkg, dp->Car(), dp->Cdr());
}
h2o_socket_t *h2o_socket_import(h2o_loop_t *loop, h2o_socket_export_t *info)
{
h2o_socket_t *sock;
assert(info->fd != -1);
sock = do_import(loop, info);
info->fd = -1; /* just in case */
if ((sock->ssl = info->ssl) != NULL)
h2o_buffer_set_prototype(&sock->ssl->input.encrypted, &h2o_socket_buffer_prototype);
sock->input = info->input;
h2o_buffer_set_prototype(&sock->input, &h2o_socket_buffer_prototype);
return sock;
}
int
param_main(int argc, char *argv[])
{
if (argc >= 2) {
if (!strcmp(argv[1], "save")) {
if (argc >= 3) {
do_save(argv[2]);
} else {
do_save(param_file_name_default);
}
}
if (!strcmp(argv[1], "load")) {
if (argc >= 3) {
do_load(argv[2]);
} else {
do_load(param_file_name_default);
}
}
if (!strcmp(argv[1], "import")) {
if (argc >= 3) {
do_import(argv[2]);
} else {
do_import(param_file_name_default);
}
}
if (!strcmp(argv[1], "show")) {
do_show();
}
}
errx(1, "expected a command, try 'load', 'import', 'show' or 'save'\n");
}
int
main(int argc, char* argv[]) {
parse_options(argc, argv);
if (opt_show_help) {
show_usage(argv);
return 0;
}
started_at = time(NULL);
cerr<<"INFO::Starting lib-face on port '"<<port<<"'\n";
if (ac_file) {
int nadded, nlines;
const time_t start_time = time(NULL);
int ret = do_import(ac_file, line_limit, nadded, nlines);
if (ret < 0) {
switch (-ret) {
case IMPORT_FILE_NOT_FOUND:
fprintf(stderr, "The file '%s' was not found\n", ac_file);
break;
case IMPORT_MUNMAP_FAILED:
fprintf(stderr, "munmap(2) on file '%s' failed\n", ac_file);
break;
case IMPORT_MMAP_FAILED:
fprintf(stderr, "mmap(2) on file '%s' failed\n", ac_file);
break;
default:
cerr<<"ERROR::Unknown error: "<<ret<<endl;
}
return 1;
}
else {
fprintf(stderr, "INFO::Successfully added %d/%d records from \"%s\" in %d second(s)\n",
nadded, nlines, ac_file, (int)(time(NULL) - start_time));
}
}
int r = httpserver_start(&serve_request, "0.0.0.0", port);
if (r != 0) {
fprintf(stderr, "ERROR::Could not start the web server\n");
return 1;
}
return 0;
}
int
param_main(int argc, char *argv[])
{
if (argc >= 2) {
if (!strcmp(argv[1], "save"))
do_save();
if (!strcmp(argv[1], "load"))
do_load();
if (!strcmp(argv[1], "import"))
do_import();
if (!strcmp(argv[1], "show"))
do_show();
}
errx(1, "expected a command, try 'load', 'import', 'show' or 'save'\n");
}
static void handle_import(client_t *client, parsed_url_t &url) {
std::string body;
headers_t headers;
headers["Cache-Control"] = "no-cache";
std::string file = unescape_query(url.query["file"]);
uint_t limit = atoi(url.query["limit"].c_str());
int nadded, nlines;
const time_t start_time = time(NULL);
if (!limit) {
limit = minus_one;
}
int ret = do_import(file, limit, nadded, nlines);
if (ret < 0) {
switch (-ret) {
case IMPORT_FILE_NOT_FOUND:
body = "The file '" + file + "' was not found";
write_response(client, 404, "Not Found", headers, body);
break;
case IMPORT_MUNMAP_FAILED:
body = "munmap(2) failed";
write_response(client, 500, "Internal Server Error", headers, body);
break;
case IMPORT_MMAP_FAILED:
body = "mmap(2) failed";
write_response(client, 500, "Internal Server Error", headers, body);
break;
default:
body = "Unknown Error";
write_response(client, 500, "Internal Server Error", headers, body);
cerr<<"ERROR::Unknown error: "<<ret<<endl;
}
}
else {
std::ostringstream os;
os << "Successfully added " << nadded << "/" << nlines
<< "records from '" << file << "' in " << (time(NULL) - start_time)
<< "second(s)\n";
body = os.str();
write_response(client, 200, "OK", headers, body);
}
}
static NMConnection *
import (NMVpnPluginUiInterface *iface, const char *path, GError **error)
{
NMConnection *connection = NULL;
char *contents = NULL;
char **lines = NULL;
char *ext;
ext = strrchr (path, '.');
if (!ext) {
g_set_error (error,
L2TP_PLUGIN_UI_ERROR,
L2TP_PLUGIN_UI_ERROR_FILE_NOT_L2TP,
"unknown L2TP file extension");
goto out;
}
if (strcmp (ext, ".conf") && strcmp (ext, ".cnf")) {
g_set_error (error,
L2TP_PLUGIN_UI_ERROR,
L2TP_PLUGIN_UI_ERROR_FILE_NOT_L2TP,
"unknown L2TP file extension");
goto out;
}
if (!g_file_get_contents (path, &contents, NULL, error))
return NULL;
lines = g_strsplit_set (contents, "\r\n", 0);
if (g_strv_length (lines) <= 1) {
g_set_error (error,
L2TP_PLUGIN_UI_ERROR,
L2TP_PLUGIN_UI_ERROR_FILE_NOT_READABLE,
"not a valid L2TP configuration file");
goto out;
}
connection = do_import (path, lines, error);
out:
if (lines)
g_strfreev (lines);
g_free (contents);
return connection;
}
/*
* Like JSResolveOp, but flags provide contextual information as follows:
*
* JSRESOLVE_QUALIFIED a qualified property id: obj.id or obj[id], not id
* JSRESOLVE_ASSIGNING obj[id] is on the left-hand side of an assignment
* JSRESOLVE_DETECTING 'if (o.p)...' or similar detection opcode sequence
* JSRESOLVE_DECLARING var, const, or function prolog declaration opcode
* JSRESOLVE_CLASSNAME class name used when constructing
*
* The *objp out parameter, on success, should be null to indicate that id
* was not resolved; and non-null, referring to obj or one of its prototypes,
* if id was resolved.
*/
static JSBool
importer_new_resolve(JSContext *context,
JSObject **obj,
jsid *id,
unsigned flags,
JSObject **objp)
{
Importer *priv;
char *name;
JSBool ret = JS_TRUE;
jsid module_init_name;
*objp = NULL;
module_init_name = gjs_context_get_const_string(context, GJS_STRING_MODULE_INIT);
if (*id == module_init_name)
return JS_TRUE;
if (!gjs_get_string_id(context, *id, &name))
return JS_FALSE;
/* let Object.prototype resolve these */
if (strcmp(name, "valueOf") == 0 ||
strcmp(name, "toString") == 0 ||
strcmp(name, "__iterator__") == 0)
goto out;
priv = priv_from_js(context, *obj);
gjs_debug_jsprop(GJS_DEBUG_IMPORTER,
"Resolve prop '%s' hook obj %p priv %p",
name, (void *)obj, priv);
if (priv == NULL) /* we are the prototype, or have the wrong class */
goto out;
JS_BeginRequest(context);
if (do_import(context, *obj, priv, name)) {
*objp = *obj;
} else {
ret = JS_FALSE;
}
JS_EndRequest(context);
out:
g_free(name);
return ret;
}
int
main(int argc, char* argv[]) {
parse_options(argc, argv);
if (opt_show_help) {
show_usage(argv);
return 0;
}
struct mg_context *ctx;
const char *options[] = {"listening_ports", port, NULL};
started_at = time(NULL);
cerr<<"INFO::Starting lib-face on port '"<<port<<"'\n";
if (ac_file) {
int nadded, nlines;
const time_t start_time = time(NULL);
int ret = do_import(ac_file, ac_sorted, minus_one, nadded, nlines);
if (ret < 0) {
fprintf(stderr, "ERROR::Could not add lines in file '%s'\n", ac_file);
}
else {
fprintf(stderr, "INFO::Successfully added %d/%d records from \"%s\" in %d second(s)\n",
nadded, nlines, ac_file, (int)(time(NULL) - start_time));
}
}
ctx = mg_start(&callback, NULL, options);
if (!ctx) {
fprintf(stderr, "ERROR::Could not start the web server\n");
return 1;
}
while (1) {
// Never stop
sleep(100);
}
mg_stop(ctx);
return 0;
}
/*
* Like JSResolveOp, but flags provide contextual information as follows:
*
* JSRESOLVE_QUALIFIED a qualified property id: obj.id or obj[id], not id
* JSRESOLVE_ASSIGNING obj[id] is on the left-hand side of an assignment
* JSRESOLVE_DETECTING 'if (o.p)...' or similar detection opcode sequence
* JSRESOLVE_DECLARING var, const, or function prolog declaration opcode
* JSRESOLVE_CLASSNAME class name used when constructing
*
* The *objp out parameter, on success, should be null to indicate that id
* was not resolved; and non-null, referring to obj or one of its prototypes,
* if id was resolved.
*/
static JSBool
importer_new_resolve(JSContext *context,
JS::HandleObject obj,
JS::HandleId id,
unsigned flags,
JS::MutableHandleObject objp)
{
Importer *priv;
std::string name;
JSBool ret = JS_TRUE;
jsid module_init_name;
module_init_name = gjs_context_get_const_string(context, GJS_STRING_MODULE_INIT);
if (id == module_init_name)
return JS_TRUE;
if (!gjs_get_string_id(context, id, name))
return JS_FALSE;
/* let Object.prototype resolve these */
if (name == "valueOf" ||
name == "toString" ||
name == "__iterator__")
goto out;
priv = priv_from_js(context, obj);
// std::cout << "Resolve prop '" << name << "' hook obj " << (uint32_t)*obj << " priv " << (uint32_t)priv << "\n";
if (priv == NULL) /* we are the prototype, or have the wrong class */
goto out;
JS_BeginRequest(context);
if (do_import(context, obj, priv, name)) {
objp.set(obj);
} else {
ret = JS_FALSE;
}
JS_EndRequest(context);
out:
return ret;
}
/*
* Like JSResolveOp, but flags provide contextual information as follows:
*
* JSRESOLVE_QUALIFIED a qualified property id: obj.id or obj[id], not id
* JSRESOLVE_ASSIGNING obj[id] is on the left-hand side of an assignment
* JSRESOLVE_DETECTING 'if (o.p)...' or similar detection opcode sequence
* JSRESOLVE_DECLARING var, const, or function prolog declaration opcode
* JSRESOLVE_CLASSNAME class name used when constructing
*
* The *objp out parameter, on success, should be null to indicate that id
* was not resolved; and non-null, referring to obj or one of its prototypes,
* if id was resolved.
*/
static JSBool
importer_new_resolve(JSContext *context,
JSObject *obj,
jsid id,
uintN flags,
JSObject **objp)
{
Importer *priv;
char *name;
JSBool ret = JS_TRUE;
*objp = NULL;
if (!gjs_get_string_id(context, id, &name))
return JS_FALSE;
/* let Object.prototype resolve these */
if (strcmp(name, "valueOf") == 0 ||
strcmp(name, "toString") == 0 ||
strcmp(name, "__iterator__") == 0)
goto out;
priv = priv_from_js(context, obj);
gjs_debug_jsprop(GJS_DEBUG_IMPORTER, "Resolve prop '%s' hook obj %p priv %p", name, obj, priv);
if (priv == NULL) /* we are the prototype, or have the wrong class */
goto out;
JS_BeginRequest(context);
if (do_import(context, obj, priv, name)) {
*objp = obj;
} else {
ret = JS_FALSE;
}
JS_EndRequest(context);
out:
g_free(name);
return ret;
}
/* read second linker member and process all archive members */
static int
read_link_member (struct ar_hdr *hdr, FILE *f)
{
uint32 n_memb;
uint32 n_syms;
uint32 *ofs;
uint16 *idx;
char *buf;
char *sym;
uint32 n;
uint16 i;
/* FIXME: are offsets and sizes in host endianness? Currently we
assume so. */
/* get number of archive members */
if (fread (&n_memb, 4, 1, f) != 1)
return 0;
if (only_symbols)
{
/* if we only dump symbols there is no need to read the offset
* and index tables */
if (fseek (f, 4 * n_memb, SEEK_CUR) != 0)
return 0;
if (fread (&n_syms, 4, 1, f) != 1)
return 0;
if (fseek (f, 2 * n_syms, SEEK_CUR) != 0)
return 0;
ofs = NULL;
idx = NULL;
}
else
{
/* suck in everything from the archive */
ofs = xmalloc (4 * n_memb);
if (fread (ofs, 4, n_memb, f) != n_memb)
{
free (ofs);
return 0;
}
if (fread (&n_syms, 4, 1, f) != 1)
{
free (ofs);
return 0;
}
idx = xmalloc (2 * n_syms);
if (fread (idx, 2, n_syms, f) != n_syms)
{
free (ofs);
free (idx);
return 0;
}
}
/* calculate size of symbol string table */
n = strtol (hdr->ar_size, NULL, 10);
n = n - (4 + 4 + 2 * n_syms + 4 * n_memb);
/* allocate memory for string table */
buf = xmalloc (n);
/* read symbol string table */
if (fread (buf, n, 1, f) != 1)
{
free (ofs);
free (idx);
return 0;
}
/* look for long-names member */
ar_read_header (hdr, f);
/* read symbols */
for (n = 0, sym = buf; n < n_syms; n++)
{
if (is_import (sym))
{
if (only_symbols)
puts (sym);
else
{
i = idx[n];
do_import (sym, ofs[i-1], f);
}
}
sym += strlen (sym) + 1;
}
free (buf);
free (ofs);
free (idx);
return 1;
}
static int
zpool_import_by_guid(uint64_t searchguid)
{
int err = 0;
nvlist_t *pools = NULL;
nvpair_t *elem;
nvlist_t *config;
nvlist_t *found_config = NULL;
nvlist_t *policy = NULL;
boolean_t first;
int flags = ZFS_IMPORT_NORMAL;
uint32_t rewind_policy = ZPOOL_NO_REWIND;
uint64_t pool_state, txg = -1ULL;
importargs_t idata = { 0 };
#ifdef ZFS_AUTOIMPORT_ZPOOL_STATUS_OK_ONLY
char *msgid;
zpool_status_t reason;
zpool_errata_t errata;
#endif
if ((g_zfs = libzfs_init()) == NULL)
return (1);
idata.unique = B_TRUE;
/* In the future, we can capture further policy and include it here */
if (nvlist_alloc(&policy, NV_UNIQUE_NAME, 0) != 0 ||
nvlist_add_uint64(policy, ZPOOL_REWIND_REQUEST_TXG, txg) != 0 ||
nvlist_add_uint32(policy, ZPOOL_REWIND_REQUEST, rewind_policy) != 0)
goto error;
if (!priv_ineffect(PRIV_SYS_CONFIG)) {
printf("cannot discover pools: permission denied\n");
nvlist_free(policy);
return (1);
}
idata.guid = searchguid;
pools = zpool_search_import(g_zfs, &idata);
if (pools == NULL && idata.exists) {
printf("cannot import '%llu': a pool with that guid is already "
"created/imported\n", searchguid);
err = 1;
} else if (pools == NULL) {
printf("cannot import '%llu': no such pool available\n",
searchguid);
err = 1;
}
if (err == 1) {
nvlist_free(policy);
return (1);
}
/*
* At this point we have a list of import candidate configs. Even though
* we were searching by guid, we still need to post-process the list to
* deal with pool state.
*/
err = 0;
elem = NULL;
first = B_TRUE;
while ((elem = nvlist_next_nvpair(pools, elem)) != NULL) {
verify(nvpair_value_nvlist(elem, &config) == 0);
verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_STATE,
&pool_state) == 0);
if (pool_state == POOL_STATE_DESTROYED)
continue;
verify(nvlist_add_nvlist(config, ZPOOL_REWIND_POLICY,
policy) == 0);
uint64_t guid;
/*
* Search for a pool by guid.
*/
verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID,
&guid) == 0);
if (guid == searchguid)
found_config = config;
}
/*
* If we were searching for a specific pool, verify that we found a
* pool, and then do the import.
*/
if (err == 0) {
if (found_config == NULL) {
printf("cannot import '%llu': no such pool available\n",
searchguid);
err = B_TRUE;
} else {
#ifdef ZFS_AUTOIMPORT_ZPOOL_STATUS_OK_ONLY
reason = zpool_import_status(config, &msgid, &errata);
if (reason == ZPOOL_STATUS_OK)
err |= do_import(found_config, NULL, NULL, NULL,
flags);
else
err = 1;
#else
err |= do_import(found_config, NULL, NULL, NULL, flags);
#endif
}
}
error:
nvlist_free(pools);
nvlist_free(policy);
libzfs_fini(g_zfs);
return (err ? 1 : 0);
}
int
param_main(int argc, char *argv[])
{
if (argc >= 2) {
if (!strcmp(argv[1], "save")) {
if (argc >= 3) {
return do_save(argv[2]);
} else {
int ret = do_save_default();
if (ret) {
PX4_ERR("Param save failed (%i)", ret);
return 1;
} else {
return 0;
}
}
}
if (!strcmp(argv[1], "load")) {
if (argc >= 3) {
return do_load(argv[2]);
} else {
return do_load(param_get_default_file());
}
}
if (!strcmp(argv[1], "import")) {
if (argc >= 3) {
return do_import(argv[2]);
} else {
return do_import(param_get_default_file());
}
}
if (!strcmp(argv[1], "select")) {
if (argc >= 3) {
param_set_default_file(argv[2]);
} else {
param_set_default_file(NULL);
}
PX4_INFO("selected parameter default file %s", param_get_default_file());
return 0;
}
if (!strcmp(argv[1], "show")) {
if (argc >= 3) {
// optional argument -c to show only non-default params
if (!strcmp(argv[2], "-c")) {
if (argc >= 4) {
return do_show(argv[3], true);
} else {
return do_show(NULL, true);
}
} else {
return do_show(argv[2], false);
}
} else {
return do_show(NULL, false);
}
}
if (!strcmp(argv[1], "set")) {
if (argc >= 5) {
/* if the fail switch is provided, fails the command if not found */
bool fail = !strcmp(argv[4], "fail");
return do_set(argv[2], argv[3], fail);
} else if (argc >= 4) {
return do_set(argv[2], argv[3], false);
} else {
PX4_ERR("not enough arguments.\nTry 'param set PARAM_NAME 3 [fail]'");
return 1;
}
}
if (!strcmp(argv[1], "compare")) {
if (argc >= 4) {
return do_compare(argv[2], &argv[3], argc - 3, COMPARE_OPERATOR_EQUAL);
} else {
PX4_ERR("not enough arguments.\nTry 'param compare PARAM_NAME 3'");
return 1;
}
}
if (!strcmp(argv[1], "greater")) {
if (argc >= 4) {
return do_compare(argv[2], &argv[3], argc - 3, COMPARE_OPERATOR_GREATER);
} else {
PX4_ERR("not enough arguments.\nTry 'param greater PARAM_NAME 3'");
return 1;
}
}
if (!strcmp(argv[1], "reset")) {
if (argc >= 3) {
return do_reset((const char **) &argv[2], argc - 2);
} else {
return do_reset(NULL, 0);
}
}
if (!strcmp(argv[1], "reset_nostart")) {
if (argc >= 3) {
return do_reset_nostart((const char **) &argv[2], argc - 2);
} else {
return do_reset_nostart(NULL, 0);
}
}
if (!strcmp(argv[1], "index_used")) {
if (argc >= 3) {
return do_show_index(argv[2], true);
} else {
PX4_ERR("no index provided");
return 1;
}
}
if (!strcmp(argv[1], "index")) {
if (argc >= 3) {
return do_show_index(argv[2], false);
} else {
PX4_ERR("no index provided");
return 1;
}
}
if (!strcmp(argv[1], "find")) {
if (argc >= 3) {
return do_find(argv[2]);
} else {
PX4_ERR("not enough arguments.\nTry 'param find PARAM_NAME'");
return 1;
}
}
}
PX4_INFO("expected a command, try 'load', 'import', 'show [-c] [<filter>]', 'set <param> <value>', 'compare',\n'index', 'index_used', 'find', 'greater', 'select', 'save', or 'reset' ");
return 1;
}
int
param_main(int argc, char *argv[])
{
if (argc >= 2) {
if (!strcmp(argv[1], "save")) {
if (argc >= 3) {
return do_save(argv[2]);
} else {
if (param_save_default()) {
warnx("Param export failed.");
return 1;
} else {
return 0;
}
}
}
if (!strcmp(argv[1], "load")) {
if (argc >= 3) {
return do_load(argv[2]);
} else {
return do_load(param_get_default_file());
}
}
if (!strcmp(argv[1], "import")) {
if (argc >= 3) {
return do_import(argv[2]);
} else {
return do_import(param_get_default_file());
}
}
if (!strcmp(argv[1], "select")) {
if (argc >= 3) {
param_set_default_file(argv[2]);
} else {
param_set_default_file(NULL);
}
warnx("selected parameter default file %s", param_get_default_file());
return 0;
}
if (!strcmp(argv[1], "show")) {
if (argc >= 3) {
do_show(argv[2]);
return 0;
} else {
do_show(NULL);
return 0;
}
}
if (!strcmp(argv[1], "set")) {
if (argc >= 5) {
/* if the fail switch is provided, fails the command if not found */
bool fail = !strcmp(argv[4], "fail");
return do_set(argv[2], argv[3], fail);
} else if (argc >= 4) {
return do_set(argv[2], argv[3], false);
} else {
warnx("not enough arguments.\nTry 'param set PARAM_NAME 3 [fail]'");
return 1;
}
}
if (!strcmp(argv[1], "compare")) {
if (argc >= 4) {
return do_compare(argv[2], &argv[3], argc - 3);
} else {
warnx("not enough arguments.\nTry 'param compare PARAM_NAME 3'");
return 1;
}
}
if (!strcmp(argv[1], "reset")) {
if (argc >= 3) {
return do_reset((const char **) &argv[2], argc - 2);
} else {
return do_reset(NULL, 0);
}
}
if (!strcmp(argv[1], "reset_nostart")) {
if (argc >= 3) {
return do_reset_nostart((const char **) &argv[2], argc - 2);
} else {
return do_reset_nostart(NULL, 0);
}
}
if (!strcmp(argv[1], "index_used")) {
if (argc >= 3) {
do_show_index(argv[2], true);
} else {
warnx("no index provided");
return 1;
}
}
if (!strcmp(argv[1], "index")) {
if (argc >= 3) {
do_show_index(argv[2], false);
} else {
warnx("no index provided");
return 1;
}
}
}
warnx("expected a command, try 'load', 'import', 'show', 'set', 'compare', 'select' or 'save'");
return 1;
}
int main(int argc, char *argv[]) {
char *format = "auto";
char *optstring = "m:M:f:";
int c, opt_index = 0;
int files = 0;
char *kb_name = NULL;
char *model[argc], *uri[argc];
char *model_default = NULL;
int help=0;
static struct option long_options[] = {
{ "model", 1, 0, 'm' },
{ "model-default", 1, 0, 'M' },
{ "format", 1, 0, 'f' },
};
for (int i= 0; i < argc; ++i) {
model[i] = NULL;
}
while ((c = getopt_long (argc, argv, optstring, long_options, &opt_index)) != -1) {
if (c == 'm') {
model[files++] = optarg;
} else if (c == 'M') {
model_default = optarg;
} else if (c == 'f') {
format = optarg;
} else {
help = 1;
fprintf(stderr, "Unknown parameter '%c' \n", c);
fprintf(stderr, "Usage: %s <kbname> <rdf file/URI> ...\n", argv[0]);
fprintf(stderr, " -m --model specify a model URI for the next RDF file\n");
fprintf(stderr, " -M --model-default specify a model URI for all RDF files\n");
fprintf(stderr, " -f --format specify an RDF syntax for the import\n");
exit(1);
}
}
files = 0;
for (int k = optind; k < argc; ++k) {
if (!kb_name) {
kb_name = argv[k];
} else {
uri[files] = g_strdup(argv[k]);
if (!model[files]) {
if (!model_default) {
model[files] = uri[files];
} else {
model[files] = model_default;
}
}
files++;
}
}
if (help || !kb_name || files == 0) {
help = 1;
fprintf(stderr, "Usage: %s <kbname> <rdf file/URI> ...\n", argv[0]);
fprintf(stderr, " -m --model specify a model URI for the next RDF file\n");
fprintf(stderr, " -M --model-default specify a model URI for all RDF files\n");
fprintf(stderr, " -f --format specify an RDF syntax for the import\n");
exit(1);
}
if (!g_thread_get_initialized())
g_thread_init(NULL);
if (!fs_hash_uri)
fs_hash_init();
//g_mem_set_vtable(glib_mem_profiler_table);
//g_atexit(g_mem_profile);
int res = do_import(kb_name,uri,model,format,files);
#if 0
printf("press enter\n");
char foo;
#endif
exit(res);
}
int
param_main(int argc, char *argv[])
{
if (argc >= 2) {
if (!strcmp(argv[1], "save")) {
if (argc >= 3) {
do_save(argv[2]);
} else {
if (param_save_default()) {
warnx("Param export failed.");
exit(1);
} else {
exit(0);
}
}
}
if (!strcmp(argv[1], "load")) {
if (argc >= 3) {
do_load(argv[2]);
} else {
do_load(param_get_default_file());
}
}
if (!strcmp(argv[1], "import")) {
if (argc >= 3) {
do_import(argv[2]);
} else {
do_import(param_get_default_file());
}
}
if (!strcmp(argv[1], "select")) {
if (argc >= 3) {
param_set_default_file(argv[2]);
} else {
param_set_default_file(NULL);
}
warnx("selected parameter default file %s", param_get_default_file());
exit(0);
}
if (!strcmp(argv[1], "show")) {
if (argc >= 3) {
do_show(argv[2]);
} else {
do_show(NULL);
}
}
if (!strcmp(argv[1], "set")) {
if (argc >= 4) {
do_set(argv[2], argv[3]);
} else {
errx(1, "not enough arguments.\nTry 'param set PARAM_NAME 3'");
}
}
if (!strcmp(argv[1], "compare")) {
if (argc >= 4) {
do_compare(argv[2], &argv[3], argc - 3);
} else {
errx(1, "not enough arguments.\nTry 'param compare PARAM_NAME 3'");
}
}
}
errx(1, "expected a command, try 'load', 'import', 'show', 'set', 'compare', 'select' or 'save'");
}
void import_dialog(GtkWidget *w, gpointer data)
{
int result;
GtkWidget *dialog, *hbox, *vbox, *label;
GtkComboBox *computer;
GtkEntry *device;
GtkWidget *XMLchooser;
device_data_t devicedata = {
.devname = NULL,
};
dialog = gtk_dialog_new_with_buttons("Import from dive computer",
GTK_WINDOW(main_window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
NULL);
vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
label = gtk_label_new("Import: \nLoad XML file or import directly from dive computer");
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, TRUE, 3);
XMLchooser = xml_file_selector(vbox, dialog);
computer = dive_computer_selector(vbox);
device = dive_computer_device(vbox);
hbox = gtk_hbox_new(FALSE, 6);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 3);
devicedata.progress.bar = gtk_progress_bar_new();
gtk_container_add(GTK_CONTAINER(hbox), devicedata.progress.bar);
gtk_widget_show_all(dialog);
result = gtk_dialog_run(GTK_DIALOG(dialog));
switch (result) {
int type;
GtkTreeIter iter;
GtkTreeModel *model;
const char *comp;
GSList *list;
case GTK_RESPONSE_ACCEPT:
/* what happened - did the user pick a file? In that case
* we ignore whether a dive computer model was picked */
list = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(XMLchooser));
if (g_slist_length(list) == 0) {
if (!gtk_combo_box_get_active_iter(computer, &iter))
break;
model = gtk_combo_box_get_model(computer);
gtk_tree_model_get(model, &iter,
0, &comp,
1, &type,
-1);
devicedata.type = type;
devicedata.name = comp;
devicedata.devname = gtk_entry_get_text(device);
do_import(&devicedata);
} else {
g_slist_foreach(list,do_import_file,NULL);
g_slist_free(list);
}
break;
default:
break;
}
gtk_widget_destroy(dialog);
report_dives(TRUE);
}
void do_numpy_init_package()
{
do_import();
}
