static int db_migrate() {
int version;
if(db_version(&version) != 0) {
err_warn(0, "failed to get db version number");
return -1;
}
aug_log("db version: %d\n", version);
while(version < 2) {
switch(version) {
case 0:
if(db_migrate_v1() != 0)
return -1;
break;
case 1: /* fall through */
if(db_migrate_v2() != 0)
return -1;
break;
default:
err_warn(0, "dont know how to migrate from db version %d", version);
return -1;
}
if(db_version(&version) != 0) {
err_warn(0, "failed to get db version number");
return -1;
}
}
return 0;
}
/**
* Delete the indicated database record(s).
* Arrange to write "free storage" database markers in its place,
* positively erasing what had been there before.
*
* Returns:
* 0 on success
* non-zero on failure
*/
int
db_delete(struct db_i *dbip, struct directory *dp)
{
int i = 0;
RT_CK_DBI(dbip);
RT_CK_DIR(dp);
if (RT_G_DEBUG&DEBUG_DB) bu_log("db_delete(%s) %p, %p\n",
dp->d_namep, (void *)dbip, (void *)dp);
if (dp->d_flags & RT_DIR_INMEM) {
bu_free(dp->d_un.ptr, "db_delete d_un.ptr");
dp->d_un.ptr = NULL;
dp->d_len = 0;
return 0;
}
if (db_version(dbip) == 4) {
i = db_zapper(dbip, dp, 0);
rt_memfree(&(dbip->dbi_freep), (unsigned)dp->d_len, dp->d_addr/(sizeof(union record)));
} else if (db_version(dbip) == 5) {
i = db5_write_free(dbip, dp, dp->d_len);
rt_memfree(&(dbip->dbi_freep), dp->d_len, dp->d_addr);
} else {
bu_bomb("db_delete() unsupported database version\n");
}
dp->d_len = 0;
dp->d_addr = RT_DIR_PHONY_ADDR;
return i;
}
int
compare_attrs(struct directory *dp1, struct directory *dp2)
{
struct bu_vls vls = BU_VLS_INIT_ZERO;
Tcl_Obj *obj1, *obj2;
int different = 0;
if (db_version(dbip1) > 4) {
bu_vls_printf(&vls, "_db1 attr get %s", dp1->d_namep);
if (Tcl_Eval(INTERP, bu_vls_addr(&vls)) != TCL_OK) {
fprintf(stderr, "Cannot get attributes for %s\n", dp1->d_namep);
fprintf(stderr, "%s\n", Tcl_GetStringResult(INTERP));
bu_exit(1, NULL);
}
obj1 = Tcl_DuplicateObj(Tcl_GetObjResult(INTERP));
Tcl_ResetResult(INTERP);
if (dp1->d_flags & RT_DIR_REGION && verify_region_attribs) {
verify_region_attrs(dp1, dbip1, obj1);
}
} else {
obj1 = Tcl_NewObj();
}
if (db_version(dbip2) > 4) {
bu_vls_trunc(&vls, 0);
bu_vls_printf(&vls, "_db2 attr get %s", dp1->d_namep);
if (Tcl_Eval(INTERP, bu_vls_addr(&vls)) != TCL_OK) {
fprintf(stderr, "Cannot get attributes for %s\n", dp1->d_namep);
fprintf(stderr, "%s\n", Tcl_GetStringResult(INTERP));
bu_exit(1, NULL);
}
obj2 = Tcl_DuplicateObj(Tcl_GetObjResult(INTERP));
Tcl_ResetResult(INTERP);
if (dp1->d_flags & RT_DIR_REGION && verify_region_attribs) {
verify_region_attrs(dp2, dbip2, obj2);
}
} else {
obj2 = Tcl_NewObj();
}
if ((dp1->d_flags & RT_DIR_REGION) && (dp2->d_flags & RT_DIR_REGION)) {
/* don't complain about "region" attributes */
remove_region_attrs(obj1);
remove_region_attrs(obj2);
}
bu_vls_trunc(&vls, 0);
different = do_compare(ATTRS, &vls, obj1, obj2, dp1->d_namep);
printf("%s", bu_vls_addr(&vls));
bu_vls_free(&vls);
return different;
}
static void
initialize()
{
char *version;
int major, minor, patch;
policy_initialize();
version = db_version(&major, &minor, &patch);
if (DB_VERSION_MAJOR != major || DB_VERSION_MINOR != minor) {
syslog(LOG_ERR,
"This daemon was compiled with " DB_VERSION_STRING " (%d.%d.%d) definitions "
"but it is using %s (%d.%d.%d). This will not work! "
"Check that the version of the developpement files for Berkeley DB "
"match the version that used.",
DB_VERSION_MAJOR, DB_VERSION_MINOR, DB_VERSION_PATCH,
version, major, minor, patch);
abort();
}
if (DB_VERSION_PATCH != patch && (opt_verbose || debug_me))
syslog(LOG_INFO,
"Compiled with " DB_VERSION_STRING " (%d.%d.%d) definitions. "
"Running with %s (%d.%d.%d).",
DB_VERSION_MAJOR, DB_VERSION_MINOR, DB_VERSION_PATCH,
version, major, minor, patch);
else if (debug_me)
syslog(LOG_DEBUG,
"This daemon was compiled with " DB_VERSION_STRING " (%d.%d.%d) definitions.",
DB_VERSION_MAJOR, DB_VERSION_MINOR, DB_VERSION_PATCH);
dbdata.data = &triplet_data;
dbdata.size = sizeof triplet_data;
dbdata.ulen = sizeof triplet_data;
dbdata.flags = DB_DBT_USERMEM;
}
/* FIXME: This check should be abstracted into the DB back-end layer. */
static svn_error_t *
check_bdb_version(void)
{
int major, minor, patch;
db_version(&major, &minor, &patch);
/* First, check that we're using a reasonably correct of Berkeley DB. */
if ((major < SVN_FS_WANT_DB_MAJOR)
|| (major == SVN_FS_WANT_DB_MAJOR && minor < SVN_FS_WANT_DB_MINOR)
|| (major == SVN_FS_WANT_DB_MAJOR && minor == SVN_FS_WANT_DB_MINOR
&& patch < SVN_FS_WANT_DB_PATCH))
return svn_error_createf(SVN_ERR_FS_GENERAL, 0,
_("Bad database version: got %d.%d.%d,"
" should be at least %d.%d.%d"),
major, minor, patch,
SVN_FS_WANT_DB_MAJOR,
SVN_FS_WANT_DB_MINOR,
SVN_FS_WANT_DB_PATCH);
/* Now, check that the version we're running against is the same as
the one we compiled with. */
if (major != DB_VERSION_MAJOR || minor != DB_VERSION_MINOR)
return svn_error_createf(SVN_ERR_FS_GENERAL, 0,
_("Bad database version:"
" compiled with %d.%d.%d,"
" running against %d.%d.%d"),
DB_VERSION_MAJOR,
DB_VERSION_MINOR,
DB_VERSION_PATCH,
major, minor, patch);
return SVN_NO_ERROR;
}
int
rt_db_flip_endian(struct db_i *dbip)
{
struct counter cnt = {0, 0};
char *v4flip;
RT_CK_DBI(dbip);
/* does not apply to v5 geometry database */
if (db_version(dbip) > 4)
return 0;
/* provide the user some means to override this automatic behavior */
v4flip = getenv("LIBRT_V4FLIP");
if (v4flip)
return bu_str_true(v4flip);
/* iterate over all database objects looking for signs of
* corruption keeping a tally of whether flipping the record fixed
* the problem.
*/
db_scan(dbip, db_corrupt_handler, 0, &cnt);
/* it has to help more than it hurts */
if (cnt.found > 0 && (double)cnt.fixed > ((double)cnt.found / 2.0)) {
if (cnt.fixed != cnt.found)
bu_log("%zu of %zu objects were NOT fixed by flipping endian interpretation. Manual inspection and repair required.\n", cnt.found - cnt.fixed, cnt.found);
return 1;
}
return 0;
}
/**
* make n copies of a database combination by adding it to our
* book-keeping list, adding it to the directory, then writing it out
* to the db.
*/
static void
copy_comb(struct db_i *_dbip, struct directory *proto, genptr_t state)
{
int idx;
if (is_in_list(obj_list, proto->d_namep)) {
bu_log("Combination %s already cloned?\n", proto->d_namep);
return;
}
idx = add_to_list(&obj_list, proto->d_namep);
/* sanity check that the item was really added to our bookkeeping */
if ((idx < 0) || !is_in_list(obj_list, proto->d_namep)) {
bu_log("ERROR: clone internal error copying %s\n", proto->d_namep);
return;
}
if (db_version(_dbip) < 5)
(void)copy_v4_comb(_dbip, proto, (struct clone_state *)state, idx);
else
(void)copy_v5_comb(_dbip, proto, (struct clone_state *)state, idx);
return;
}
/* {{{ rberkeley_db_version */
SEXP rberkeley_db_version ()
{
int major, minor, patch;
major = minor = patch = 1;
char *version;
version = db_version(&major, &minor, &patch);
SEXP Version, names;
PROTECT(Version = allocVector(VECSXP, 4));
SET_VECTOR_ELT(Version, 0, mkString(version));
SET_VECTOR_ELT(Version, 1, ScalarInteger(major));
SET_VECTOR_ELT(Version, 2, ScalarInteger(minor));
SET_VECTOR_ELT(Version, 3, ScalarInteger(patch));
PROTECT(names = allocVector(STRSXP, 4));
SET_STRING_ELT(names, 0, mkChar("Version"));
SET_STRING_ELT(names, 1, mkChar("major"));
SET_STRING_ELT(names, 2, mkChar("minor"));
SET_STRING_ELT(names, 3, mkChar("patch"));
setAttrib(Version, R_NamesSymbol, names);
UNPROTECT(2);
return Version;
}
static void
dup_dir_check5(struct db_i *input_dbip,
const struct db5_raw_internal *rip,
off_t addr,
void *ptr)
{
char *name;
struct directory *dupdp;
struct bu_vls local = BU_VLS_INIT_ZERO;
struct dir_check_stuff *dcsp = (struct dir_check_stuff *)ptr;
if (dcsp->main_dbip == DBI_NULL)
return;
RT_CK_DBI(input_dbip);
RT_CK_RIP(rip);
if (rip->h_dli == DB5HDR_HFLAGS_DLI_HEADER_OBJECT) return;
if (rip->h_dli == DB5HDR_HFLAGS_DLI_FREE_STORAGE) return;
name = (char *)rip->name.ext_buf;
if (name == (char *)NULL) return;
if (addr == 0) return;
/* do not compare _GLOBAL */
if (rip->major_type == DB5_MAJORTYPE_ATTRIBUTE_ONLY &&
rip->minor_type == 0)
return;
/* Add the prefix, if any */
if (db_version(dcsp->main_dbip) < 5) {
if (dcsp->wdbp->wdb_ncharadd > 0) {
bu_vls_strncpy(&local, bu_vls_addr(&dcsp->wdbp->wdb_prestr), dcsp->wdbp->wdb_ncharadd);
bu_vls_strcat(&local, name);
} else {
bu_vls_strncpy(&local, name, _GED_V4_MAXNAME);
}
bu_vls_trunc(&local, _GED_V4_MAXNAME);
} else {
if (dcsp->wdbp->wdb_ncharadd > 0) {
(void)bu_vls_vlscat(&local, &dcsp->wdbp->wdb_prestr);
(void)bu_vls_strcat(&local, name);
} else {
(void)bu_vls_strcat(&local, name);
}
}
/* Look up this new name in the existing (main) database */
if ((dupdp = db_lookup(dcsp->main_dbip, bu_vls_addr(&local), LOOKUP_QUIET)) != RT_DIR_NULL) {
/* Duplicate found, add it to the list */
dcsp->wdbp->wdb_num_dups++;
*dcsp->dup_dirp++ = dupdp;
}
bu_vls_free(&local);
return;
}
int ldbm_initialize( const char* home )
{
#if DB_VERSION_MAJOR < 3
int err;
u_int32_t envFlags;
#endif
if(ldbm_initialized++) return 1;
{
char *version;
int major, minor, patch;
version = db_version( &major, &minor, &patch );
if( major != DB_VERSION_MAJOR ||
minor < DB_VERSION_MINOR )
{
#ifdef LDAP_SYSLOG
syslog( LOG_INFO,
"ldbm_initialize(): version mismatch\nexpected: %s\ngot: %s\n",
DB_VERSION_STRING, version );
#endif
return 1;
}
}
#if DB_VERSION_MAJOR < 3
ldbm_Env = calloc( 1, sizeof( DB_ENV ));
if( ldbm_Env == NULL ) return 1;
ldbm_Env->db_errcall = ldbm_db_errcall;
ldbm_Env->db_errpfx = "==>";
envFlags = DB_CREATE | DB_USE_ENVIRON;
/* add optional flags */
#ifdef DB_PRIVATE
envFlags |= DB_PRIVATE;
#endif
#ifdef HAVE_BERKELEY_DB_THREAD
envFlags |= DB_THREAD;
#endif
err = db_appinit( home, NULL, ldbm_Env, envFlags );
if ( err ) {
#ifdef LDAP_SYSLOG
syslog( LOG_INFO, "ldbm_initialize(): "
"FATAL error (%d) in db_appinit()\n", err );
#endif
return( 1 );
}
#endif
LDBM_RWLOCK_INIT;
return 0;
}
DAAP_BLOCK *daap_response_update(int fd, int clientver) {
DAAP_BLOCK *root;
int g=1;
fd_set rset;
struct timeval tv;
int result;
DPRINTF(E_DBG,L_DAAP,"Preparing to send update response\n");
while(clientver == db_version()) {
FD_ZERO(&rset);
FD_SET(fd,&rset);
tv.tv_sec=30;
tv.tv_usec=0;
result=select(fd+1,&rset,NULL,NULL,&tv);
if(FD_ISSET(fd,&rset)) {
/* can't be ready for read, must be error */
DPRINTF(E_DBG,L_DAAP,"Socket closed?\n");
return NULL;
}
}
root=daap_add_empty(NULL,"mupd");
if(root) {
g = (int)daap_add_int(root,"mstt",200);
/* theoretically, this would go up if the db changes? */
g = g && daap_add_int(root,"musr",db_version());
}
if(!g) {
daap_free(root);
return NULL;
}
return root;
}
int
db_dump(struct rt_wdb *wdbp, struct db_i *dbip)
/* output */
/* input */
{
register int i;
register struct directory *dp;
struct bu_external ext;
RT_CK_DBI(dbip);
RT_CK_WDB(wdbp);
/* just in case since we don't actually handle it below */
if (db_version(dbip) != db_version(wdbp->dbip)) {
bu_log("Internal Error: dumping a v%d database into a v%d database is untested\n", db_version(dbip), db_version(wdbp->dbip));
return -1;
}
/* Output all directory entries */
for (i = 0; i < RT_DBNHASH; i++) {
for (dp = dbip->dbi_Head[i]; dp != RT_DIR_NULL; dp = dp->d_forw) {
RT_CK_DIR(dp);
/* XXX Need to go to internal form, if database versions don't match */
if (db_get_external(&ext, dp, dbip) < 0) {
bu_log("db_dump() read failed on %s, skipping\n", dp->d_namep);
continue;
}
if (wdb_export_external(wdbp, &ext, dp->d_namep, dp->d_flags & ~(RT_DIR_INMEM), dp->d_minor_type) < 0) {
bu_log("db_dump() write failed on %s, aborting\n", dp->d_namep);
bu_free_external(&ext);
return -1;
}
bu_free_external(&ext);
}
}
return 0;
}
int
dbtp_readOne(DBTPD * dbtp, u_char how, int ai, void * ptr, int is_network)
{
int major, minor, patch;
u_int32_t cursor;
u_char * vp;
if (how) {
/* it is a normal record access since 0 is never a valid record number */
if (is_network)
cursor = ntohl(*(u_int32_t *)ptr);
else
cursor = *(u_int32_t *)ptr;
if (cursor)
dbtp->dberr = dbtp_getrecno(dbtp,ai,cursor);
else {
/* send back the number of keys in the database and the version number
* All the data is stuffed into the DBT structure since it is not used to get the data
*
* generate the version info
*/
(void)db_version(&major,&minor,&patch);
vp = (u_char *)&dbtp->keydbt.flags;
dbtp->keydbt.data = vp;
dbtp->keydbt.size = (u_int32_t)sizeof(u_int32_t); /* size of IPv4 netaddr */
*vp++ = 0;
*vp++ = (u_char)major;
*vp++ = (u_char)minor;
*vp++ = (u_char)patch;
/* generate the number of keys/records in the database */
dbtp->mgdbt.data = &dbtp->mgdbt.flags;
dbtp->mgdbt.size = (u_int32_t)sizeof(u_int32_t);
dbtp->mgdbt.flags = dbtp_stati(dbtp,ai);
if (is_network)
dbtp->mgdbt.flags = htonl(dbtp->mgdbt.flags);
return(0);
}
}
else
dbtp->dberr = dbtp_get(dbtp,ai,ptr,sizeof(void *));
if (dbtp->mgdbt.size == sizeof(u_int32_t)) { /* is this a u_int32_t ??, all other records are larger */
if (is_network)
*(u_int32_t *)(dbtp->mgdbt.data) = htonl(*(u_int32_t *)(dbtp->mgdbt.data));
}
return(dbtp->dberr);
}
static void
version_check()
{
int v_major, v_minor, v_patch;
/* Make sure we're loaded with the right version of the DB library. */
(void)db_version(&v_major, &v_minor, &v_patch);
if (v_major != DB_VERSION_MAJOR ||
v_minor != DB_VERSION_MINOR || v_patch != DB_VERSION_PATCH) {
fprintf(stderr,
"%s: version %d.%d.%d doesn't match library version %d.%d.%d\n",
prog, DB_VERSION_MAJOR, DB_VERSION_MINOR,
DB_VERSION_PATCH, v_major, v_minor, v_patch);
exit(EXIT_FAILURE);
}
}
int
rt_db_put_internal(
struct directory *dp,
struct db_i *dbip,
struct rt_db_internal *ip,
struct resource *resp)
{
struct bu_external ext;
int ret;
RT_CK_DB_INTERNAL(ip);
if (db_version(dbip) > 4)
return rt_db_put_internal5(dp, dbip, ip, resp,
DB5_MAJORTYPE_BRLCAD);
BU_EXTERNAL_INIT(&ext);
/* Scale change on export is 1.0 -- no change */
ret = -1;
if (ip->idb_meth->ft_export4) {
ret = ip->idb_meth->ft_export4(&ext, ip, 1.0, dbip, resp);
}
if (ret < 0) {
bu_log("rt_db_put_internal(%s): solid export failure\n",
dp->d_namep);
rt_db_free_internal(ip);
bu_free_external(&ext);
return -2; /* FAIL */
}
rt_db_free_internal(ip);
if (db_put_external(&ext, dp, dbip) < 0) {
bu_free_external(&ext);
return -1; /* FAIL */
}
bu_free_external(&ext);
return 0; /* OK */
}
/**
*@brief
* Check a name against the global directory.
*/
static int
dup_dir_check(struct db_i *input_dbip, const char *name, off_t UNUSED(laddr), size_t UNUSED(len), int UNUSED(flags), void *ptr)
{
struct directory *dupdp;
struct bu_vls local = BU_VLS_INIT_ZERO;
struct dir_check_stuff *dcsp = (struct dir_check_stuff *)ptr;
if (dcsp->main_dbip == DBI_NULL)
return 0;
RT_CK_DBI(input_dbip);
/* Add the prefix, if any */
if (db_version(dcsp->main_dbip) < 5) {
if (dcsp->wdbp->wdb_ncharadd > 0) {
bu_vls_strncpy(&local, bu_vls_addr(&dcsp->wdbp->wdb_prestr), dcsp->wdbp->wdb_ncharadd);
bu_vls_strcat(&local, name);
} else {
bu_vls_strncpy(&local, name, _GED_V4_MAXNAME);
}
bu_vls_trunc(&local, _GED_V4_MAXNAME);
} else {
if (dcsp->wdbp->wdb_ncharadd > 0) {
bu_vls_vlscat(&local, &dcsp->wdbp->wdb_prestr);
bu_vls_strcat(&local, name);
} else {
bu_vls_strcat(&local, name);
}
}
/* Look up this new name in the existing (main) database */
if ((dupdp = db_lookup(dcsp->main_dbip, bu_vls_addr(&local), LOOKUP_QUIET)) != RT_DIR_NULL) {
/* Duplicate found, add it to the list */
dcsp->wdbp->wdb_num_dups++;
*dcsp->dup_dirp++ = dupdp;
}
bu_vls_free(&local);
return 0;
}
int
ged_unhide(struct ged *gedp, int argc, const char *argv[])
{
struct directory *dp;
struct db_i *dbip;
struct bu_external ext;
struct bu_external tmp;
struct db5_raw_internal raw;
int i;
static const char *usage = "object(s)";
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_READ_ONLY(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
/* must be wanting help */
if (argc == 1) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_HELP;
}
dbip = gedp->ged_wdbp->dbip;
if (db_version(dbip) < 5) {
bu_vls_printf(gedp->ged_result_str, "Database was created with a previous release of BRL-CAD.\nSelect \"Tools->Upgrade Database...\" to enable support for this feature.");
return GED_ERROR;
}
for (i = 1; i < argc; i++) {
if ((dp = db_lookup(dbip, argv[i], LOOKUP_NOISY)) == RT_DIR_NULL) {
continue;
}
RT_CK_DIR(dp);
BU_EXTERNAL_INIT(&ext);
if (db_get_external(&ext, dp, dbip) < 0) {
bu_vls_printf(gedp->ged_result_str, "db_get_external failed for %s\n", dp->d_namep);
continue;
}
if (db5_get_raw_internal_ptr(&raw, ext.ext_buf) == NULL) {
bu_vls_printf(gedp->ged_result_str, "db5_get_raw_internal_ptr() failed for %s\n", dp->d_namep);
bu_free_external(&ext);
continue;
}
raw.h_name_hidden = (unsigned char)(0x0);
BU_EXTERNAL_INIT(&tmp);
db5_export_object3(&tmp, DB5HDR_HFLAGS_DLI_APPLICATION_DATA_OBJECT,
dp->d_namep,
raw.h_name_hidden,
&raw.attributes,
&raw.body,
raw.major_type, raw.minor_type,
raw.a_zzz, raw.b_zzz);
bu_free_external(&ext);
if (db_put_external(&tmp, dp, dbip)) {
bu_vls_printf(gedp->ged_result_str, "db_put_external() failed for %s\n", dp->d_namep);
bu_free_external(&tmp);
continue;
}
bu_free_external(&tmp);
dp->d_flags &= (~RT_DIR_HIDDEN);
}
return GED_OK;
}
int
ged_keep(struct ged *gedp, int argc, const char *argv[])
{
int i;
struct keep_node_data knd;
struct rt_wdb *keepfp;
struct directory *dp;
struct bu_vls title = BU_VLS_INIT_ZERO;
struct db_i *new_dbip;
const char *cmd = argv[0];
static const char *usage = "[-R] file object(s)";
int c;
int flag_R = 0;
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
/* must be wanting help */
if (argc == 1) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", cmd, usage);
return GED_HELP;
}
/* check for options */
bu_optind = 1;
while ((c = bu_getopt(argc, (char * const *)argv, "R")) != -1) {
switch (c) {
case 'R':
/* not recursively */
flag_R = 1;
break;
default:
bu_vls_printf(gedp->ged_result_str, "Unrecognized option - %c", c);
return GED_ERROR;
}
}
/* skip options processed plus command name */
argc -= bu_optind;
argv += bu_optind;
if (argc < 2) {
bu_vls_printf(gedp->ged_result_str, "ERROR: missing file or object names\n");
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", cmd, usage);
return GED_ERROR;
}
/* First, clear any existing counts */
for (i = 0; i < RT_DBNHASH; i++) {
for (dp = gedp->ged_wdbp->dbip->dbi_Head[i]; dp != RT_DIR_NULL; dp = dp->d_forw)
dp->d_nref = 0;
}
/* Alert user if named file already exists */
new_dbip = db_open(argv[0], DB_OPEN_READWRITE);
if (new_dbip != DBI_NULL) {
if (db_version(new_dbip) != db_version(gedp->ged_wdbp->dbip)) {
bu_vls_printf(gedp->ged_result_str, "%s: File format mismatch between '%s' and '%s'\n",
cmd, argv[0], gedp->ged_wdbp->dbip->dbi_filename);
return GED_ERROR;
}
if ((keepfp = wdb_dbopen(new_dbip, RT_WDB_TYPE_DB_DISK)) == NULL) {
bu_vls_printf(gedp->ged_result_str, "%s: Error opening '%s'\n", cmd, argv[0]);
return GED_ERROR;
} else {
bu_vls_printf(gedp->ged_result_str, "%s: Appending to '%s'\n", cmd, argv[0]);
/* --- Scan geometry database and build in-memory directory --- */
db_dirbuild(new_dbip);
}
} else {
/* Create a new database */
keepfp = wdb_fopen_v(argv[0], db_version(gedp->ged_wdbp->dbip));
if (keepfp == NULL) {
perror(argv[0]);
return GED_ERROR;
}
}
knd.wdbp = keepfp;
knd.gedp = gedp;
/* ident record */
if (bu_strncmp(gedp->ged_wdbp->dbip->dbi_title, "Parts of: ", 10) != 0) {
bu_vls_strcat(&title, "Parts of: ");
}
bu_vls_strcat(&title, gedp->ged_wdbp->dbip->dbi_title);
if (db_update_ident(keepfp->dbip, bu_vls_addr(&title), gedp->ged_wdbp->dbip->dbi_local2base) < 0) {
perror("fwrite");
bu_vls_printf(gedp->ged_result_str, "db_update_ident() failed\n");
wdb_close(keepfp);
bu_vls_free(&title);
return GED_ERROR;
}
bu_vls_free(&title);
for (i = 1; i < argc; i++) {
if ((dp = db_lookup(gedp->ged_wdbp->dbip, argv[i], LOOKUP_NOISY)) == RT_DIR_NULL)
continue;
if (!flag_R) {
/* recursively keep objects */
db_functree(gedp->ged_wdbp->dbip, dp, node_write, node_write, &rt_uniresource, (void *)&knd);
} else {
/* keep just this object */
node_write(gedp->ged_wdbp->dbip, dp, (void *)&knd);
}
}
wdb_close(keepfp);
return GED_OK;
}
/*
* Output the ID response.
* We do NOT close the parameter list so other stuff can be added later.
*/
EXPORTED void id_response(struct protstream *pout)
{
struct utsname os;
const char *sasl_imp;
int sasl_ver;
char env_buf[MAXIDVALUELEN+1];
prot_printf(pout, "* ID ("
"\"name\" \"Cyrus IMAPD\""
" \"version\" \"%s\""
" \"vendor\" \"Project Cyrus\""
" \"support-url\" \"https://www.cyrusimap.org\"",
CYRUS_VERSION);
/* add the os info */
if (uname(&os) != -1)
prot_printf(pout,
" \"os\" \"%s\""
" \"os-version\" \"%s\"",
os.sysname, os.release);
#ifdef ID_SAVE_CMDLINE
/* add the command line info */
prot_printf(pout, " \"command\" \"%s\"", id_resp_command);
if (strlen(id_resp_arguments)) {
prot_printf(pout, " \"arguments\" \"%s\"", id_resp_arguments);
} else {
prot_printf(pout, " \"arguments\" NIL");
}
#endif
/* SASL information */
snprintf(env_buf, MAXIDVALUELEN,"Built w/Cyrus SASL %d.%d.%d",
SASL_VERSION_MAJOR, SASL_VERSION_MINOR, SASL_VERSION_STEP);
sasl_version(&sasl_imp, &sasl_ver);
snprintf(env_buf + strlen(env_buf), MAXIDVALUELEN - strlen(env_buf),
"; Running w/%s %d.%d.%d", sasl_imp,
(sasl_ver & 0xFF000000) >> 24,
(sasl_ver & 0x00FF0000) >> 16,
(sasl_ver & 0x0000FFFF));
/* add the environment info */
#ifdef DB_VERSION_STRING
snprintf(env_buf + strlen(env_buf), MAXIDVALUELEN - strlen(env_buf),
"; Built w/%s", DB_VERSION_STRING);
snprintf(env_buf + strlen(env_buf), MAXIDVALUELEN - strlen(env_buf),
"; Running w/%s", db_version(NULL, NULL, NULL));
#endif
#ifdef HAVE_SSL
snprintf(env_buf + strlen(env_buf), MAXIDVALUELEN - strlen(env_buf),
"; Built w/%s", OPENSSL_VERSION_TEXT);
snprintf(env_buf + strlen(env_buf), MAXIDVALUELEN - strlen(env_buf),
"; Running w/%s", SSLeay_version(SSLEAY_VERSION));
#ifdef EGD_SOCKET
snprintf(env_buf + strlen(env_buf), MAXIDVALUELEN - strlen(env_buf),
" (with EGD)");
#endif
#endif
#ifdef HAVE_ZLIB
snprintf(env_buf + strlen(env_buf), MAXIDVALUELEN - strlen(env_buf),
"; Built w/zlib %s", ZLIB_VERSION);
snprintf(env_buf + strlen(env_buf), MAXIDVALUELEN - strlen(env_buf),
"; Running w/zlib %s", zlibVersion());
#endif
#ifdef USE_SIEVE
snprintf(env_buf + strlen(env_buf), MAXIDVALUELEN - strlen(env_buf),
"; %s", SIEVE_VERSION);
#endif
#ifdef HAVE_LIBWRAP
snprintf(env_buf + strlen(env_buf), MAXIDVALUELEN - strlen(env_buf),
"; TCP Wrappers");
#endif
#ifdef HAVE_UCDSNMP
snprintf(env_buf + strlen(env_buf), MAXIDVALUELEN - strlen(env_buf),
"; UCD-SNMP %s", VersionInfo);
#endif
#ifdef HAVE_NETSNMP
snprintf(env_buf + strlen(env_buf), MAXIDVALUELEN - strlen(env_buf),
"; NET-SNMP");
#endif
snprintf(env_buf + strlen(env_buf), MAXIDVALUELEN - strlen(env_buf),
"; mmap = %s", map_method_desc);
snprintf(env_buf + strlen(env_buf), MAXIDVALUELEN - strlen(env_buf),
"; lock = %s", lock_method_desc);
snprintf(env_buf + strlen(env_buf), MAXIDVALUELEN - strlen(env_buf),
"; nonblock = %s", nonblock_method_desc);
#ifdef HAVE_KRB
snprintf(env_buf + strlen(env_buf), MAXIDVALUELEN - strlen(env_buf),
" (%s)", krb4_version);
#endif
if (idle_method_desc)
snprintf(env_buf + strlen(env_buf), MAXIDVALUELEN - strlen(env_buf),
"; idle = %s", idle_method_desc);
prot_printf(pout, " \"environment\" \"%s\"", env_buf);
}
/*
* used by the 'color' command when provided the -e option
*/
static int
edcolor(struct ged *gedp, int argc, const char *argv[])
{
struct mater *mp;
struct mater *zot;
FILE *fp;
int c;
char line[128];
static char hdr[] = "LOW\tHIGH\tRed\tGreen\tBlue\n";
char tmpfil[MAXPATHLEN];
char *editstring = NULL;
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_READ_ONLY(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
bu_optind = 1;
/* First, grab the editstring off of the argv list */
while ((c = bu_getopt(argc, (char * const *)argv, "E:")) != -1) {
switch (c) {
case 'E' :
editstring = bu_optarg;
break;
default :
break;
}
}
argc -= bu_optind - 1;
argv += bu_optind - 1;
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
fp = bu_temp_file(tmpfil, MAXPATHLEN);
if (fp == NULL) {
bu_vls_printf(gedp->ged_result_str, "%s: could not create tmp file", argv[0]);
return GED_ERROR;
}
fprintf(fp, "%s", hdr);
for (mp = rt_material_head(); mp != MATER_NULL; mp = mp->mt_forw) {
fprintf(fp, "%d\t%d\t%3d\t%3d\t%3d",
mp->mt_low, mp->mt_high,
mp->mt_r, mp->mt_g, mp->mt_b);
fprintf(fp, "\n");
}
(void)fclose(fp);
if (!_ged_editit(editstring, (const char *)tmpfil)) {
bu_vls_printf(gedp->ged_result_str, "%s: editor returned bad status. Aborted\n", argv[0]);
return GED_ERROR;
}
/* Read file and process it */
if ((fp = fopen(tmpfil, "r")) == NULL) {
perror(tmpfil);
return GED_ERROR;
}
if (bu_fgets(line, sizeof (line), fp) == NULL ||
line[0] != hdr[0]) {
bu_vls_printf(gedp->ged_result_str, "%s: Header line damaged, aborting\n", argv[0]);
(void)fclose(fp);
return GED_ERROR;
}
if (db_version(gedp->ged_wdbp->dbip) < 5) {
/* Zap all the current records, both in core and on disk */
while (rt_material_head() != MATER_NULL) {
zot = rt_material_head();
rt_new_material_head(zot->mt_forw);
color_zaprec(gedp, zot);
bu_free((void *)zot, "mater rec");
}
while (bu_fgets(line, sizeof (line), fp) != NULL) {
int cnt;
int low, hi, r, g, b;
/* character-separated numbers (ideally a space) */
cnt = sscanf(line, "%d%*c%d%*c%d%*c%d%*c%d",
&low, &hi, &r, &g, &b);
if (cnt != 9) {
bu_vls_printf(gedp->ged_result_str, "%s: Discarding %s\n", argv[0], line);
continue;
}
BU_ALLOC(mp, struct mater);
mp->mt_low = low;
mp->mt_high = hi;
mp->mt_r = r;
mp->mt_g = g;
mp->mt_b = b;
mp->mt_daddr = MATER_NO_ADDR;
rt_insert_color(mp);
color_putrec(gedp, mp);
}
} else {
struct bu_vls vls = BU_VLS_INIT_ZERO;
/* free colors in rt_material_head */
rt_color_free();
while (bu_fgets(line, sizeof (line), fp) != NULL) {
int cnt;
int low, hi, r, g, b;
/* character-separated numbers (ideally a space) */
cnt = sscanf(line, "%d%*c%d%*c%d%*c%d%*c%d",
&low, &hi, &r, &g, &b);
/* check to see if line is reasonable */
if (cnt != 5) {
bu_vls_printf(gedp->ged_result_str, "%s: Discarding %s\n", argv[0], line);
continue;
}
bu_vls_printf(&vls, "{%d %d %d %d %d} ", low, hi, r, g, b);
}
db5_update_attribute("_GLOBAL", "regionid_colortable", bu_vls_addr(&vls), gedp->ged_wdbp->dbip);
db5_import_color_table(bu_vls_addr(&vls));
bu_vls_free(&vls);
}
(void)fclose(fp);
bu_file_delete(tmpfil);
/* if there are drawables, update their colors */
if (gedp->ged_gdp)
ged_color_soltab(gedp->ged_gdp->gd_headDisplay);
return GED_OK;
}
int
ged_bo(struct ged *gedp, int argc, const char *argv[])
{
int c;
unsigned int minor_type=0;
char *obj_name;
char *file_name;
int input_mode=0;
int output_mode=0;
struct rt_binunif_internal *bip;
struct rt_db_internal intern;
struct directory *dp;
const char *argv0;
static const char *usage = "{-i major_type minor_type | -o} dest source";
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_READ_ONLY(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
argv0 = argv[0];
/* must be wanting help */
if (argc == 1) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv0, usage);
return GED_HELP;
}
/* check that we are using a version 5 database */
if (db_version(gedp->ged_wdbp->dbip) < 5) {
bu_vls_printf(gedp->ged_result_str, "This is an older database version.\nIt does not support binary objects.Use \"dbupgrade\" to upgrade this database to the current version.\n");
return GED_ERROR;
}
bu_optind = 1; /* re-init bu_getopt() */
bu_opterr = 0; /* suppress bu_getopt()'s error message */
while ((c=bu_getopt(argc, (char * const *)argv, "iou:")) != -1) {
switch (c) {
case 'i':
input_mode = 1;
break;
case 'o':
output_mode = 1;
break;
default:
bu_vls_printf(gedp->ged_result_str, "Unrecognized option - %c", c);
return GED_ERROR;
}
}
if (input_mode + output_mode != 1) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv0, usage);
return GED_ERROR;
}
argc -= bu_optind;
argv += bu_optind;
if ((input_mode && argc != 4) || (output_mode && argc != 2)) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv0, usage);
return GED_ERROR;
}
if (input_mode) {
if (argv[0][0] == 'u') {
if (argv[1][1] != '\0') {
bu_vls_printf(gedp->ged_result_str, "Unrecognized minor type: %s", argv[1]);
return GED_ERROR;
}
switch ((int)argv[1][0]) {
case 'f':
minor_type = DB5_MINORTYPE_BINU_FLOAT;
break;
case 'd':
minor_type = DB5_MINORTYPE_BINU_DOUBLE;
break;
case 'c':
minor_type = DB5_MINORTYPE_BINU_8BITINT;
break;
case 's':
minor_type = DB5_MINORTYPE_BINU_16BITINT;
break;
case 'i':
minor_type = DB5_MINORTYPE_BINU_32BITINT;
break;
case 'l':
minor_type = DB5_MINORTYPE_BINU_64BITINT;
break;
case 'C':
minor_type = DB5_MINORTYPE_BINU_8BITINT_U;
break;
case 'S':
minor_type = DB5_MINORTYPE_BINU_16BITINT_U;
break;
case 'I':
minor_type = DB5_MINORTYPE_BINU_32BITINT_U;
break;
case 'L':
minor_type = DB5_MINORTYPE_BINU_64BITINT_U;
break;
default:
bu_vls_printf(gedp->ged_result_str, "Unrecognized minor type: %s", argv[1]);
return GED_ERROR;
}
} else {
bu_vls_printf(gedp->ged_result_str, "Unrecognized major type: %s", argv[0]);
return GED_ERROR;
}
/* skip past major_type and minor_type */
argc -= 2;
argv += 2;
if (minor_type == 0) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv0, usage);
return GED_ERROR;
}
obj_name = (char *)*argv;
GED_CHECK_EXISTS(gedp, obj_name, LOOKUP_QUIET, GED_ERROR);
argc--;
argv++;
file_name = (char *)*argv;
/* make a binunif of the entire file */
if (rt_mk_binunif (gedp->ged_wdbp, obj_name, file_name, minor_type, 0)) {
bu_vls_printf(gedp->ged_result_str, "Error creating %s", obj_name);
return GED_ERROR;
}
} else if (output_mode) {
FILE *fp;
file_name = (char *)*argv;
argc--;
argv++;
obj_name = (char *)*argv;
if ((dp=db_lookup(gedp->ged_wdbp->dbip, obj_name, LOOKUP_NOISY)) == RT_DIR_NULL) {
return GED_ERROR;
}
if (!(dp->d_major_type & DB5_MAJORTYPE_BINARY_MASK)) {
bu_vls_printf(gedp->ged_result_str, "%s is not a binary object", obj_name);
return GED_ERROR;
}
if (dp->d_major_type != DB5_MAJORTYPE_BINARY_UNIF) {
bu_vls_printf(gedp->ged_result_str, "source must be a uniform binary object");
return GED_ERROR;
}
fp = fopen(file_name, "w+b");
if (fp == NULL) {
bu_vls_printf(gedp->ged_result_str, "Error: cannot open file %s for writing", file_name);
return GED_ERROR;
}
if (rt_db_get_internal(&intern, dp, gedp->ged_wdbp->dbip, NULL,
&rt_uniresource) < 0) {
bu_vls_printf(gedp->ged_result_str, "Error reading %s from database", dp->d_namep);
fclose(fp);
return GED_ERROR;
}
RT_CK_DB_INTERNAL(&intern);
bip = (struct rt_binunif_internal *)intern.idb_ptr;
if (bip->count < 1) {
bu_vls_printf(gedp->ged_result_str, "%s has no contents", obj_name);
fclose(fp);
rt_db_free_internal(&intern);
return GED_ERROR;
}
if (fwrite(bip->u.int8, bip->count * db5_type_sizeof_h_binu(bip->type),
1, fp) != 1) {
bu_vls_printf(gedp->ged_result_str, "Error writing contents to file");
fclose(fp);
rt_db_free_internal(&intern);
return GED_ERROR;
}
fclose(fp);
rt_db_free_internal(&intern);
} else {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv0, usage);
return GED_ERROR;
}
return GED_OK;
}
int
ged_color(struct ged *gedp, int argc, const char *argv[])
{
struct mater *newp;
struct mater *mp;
struct mater *next_mater;
static const char *usage = "[-e] [low high r g b]";
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_READ_ONLY(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
/* must be wanting help */
if (argc == 1) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_HELP;
}
if (argc != 6 && argc != 2) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
/* edcolor */
if (argc == 2) {
if (argv[1][0] == '-' && argv[1][1] == 'e' && argv[1][2] == '\0') {
return edcolor(gedp, argc, argv);
} else {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
}
if (db_version(gedp->ged_wdbp->dbip) < 5) {
/* Delete all color records from the database */
mp = rt_material_head();
while (mp != MATER_NULL) {
next_mater = mp->mt_forw;
color_zaprec(gedp, mp);
mp = next_mater;
}
/* construct the new color record */
BU_ALLOC(newp, struct mater);
newp->mt_low = atoi(argv[1]);
newp->mt_high = atoi(argv[2]);
newp->mt_r = atoi(argv[3]);
newp->mt_g = atoi(argv[4]);
newp->mt_b = atoi(argv[5]);
newp->mt_daddr = MATER_NO_ADDR; /* not in database yet */
/* Insert new color record in the in-memory list */
rt_insert_color(newp);
/* Write new color records for all colors in the list */
mp = rt_material_head();
while (mp != MATER_NULL) {
next_mater = mp->mt_forw;
color_putrec(gedp, mp);
mp = next_mater;
}
} else {
struct bu_vls colors = BU_VLS_INIT_ZERO;
/* construct the new color record */
BU_ALLOC(newp, struct mater);
newp->mt_low = atoi(argv[1]);
newp->mt_high = atoi(argv[2]);
newp->mt_r = atoi(argv[3]);
newp->mt_g = atoi(argv[4]);
newp->mt_b = atoi(argv[5]);
newp->mt_daddr = MATER_NO_ADDR; /* not in database yet */
/* Insert new color record in the in-memory list */
rt_insert_color(newp);
/*
* Gather color records from the in-memory list to build
* the _GLOBAL objects regionid_colortable attribute.
*/
rt_vls_color_map(&colors);
db5_update_attribute("_GLOBAL", "regionid_colortable", bu_vls_addr(&colors), gedp->ged_wdbp->dbip);
bu_vls_free(&colors);
}
return GED_OK;
}
/**
* Apply a 4x4 transformation matrix to the internal form of a solid.
*
* If "free" flag is non-zero, storage for the original solid is
* released. If "os" is same as "is", storage for the original solid
* is overwritten with the new, transformed solid.
*
* Returns -
* -1 FAIL
* 0 OK
*/
int
rt_generic_xform(
struct rt_db_internal *op,
const mat_t mat,
struct rt_db_internal *ip,
int release,
struct db_i *dbip,
struct resource *resp)
{
struct bu_external ext;
int id;
struct bu_attribute_value_set avs;
RT_CK_DB_INTERNAL(ip);
RT_CK_DBI(dbip);
RT_CK_RESOURCE(resp);
memset(&avs, 0, sizeof(struct bu_attribute_value_set));
id = ip->idb_type;
BU_EXTERNAL_INIT(&ext);
/* Scale change on export is 1.0 -- no change */
switch (db_version(dbip)) {
case 4:
if (OBJ[id].ft_export4(&ext, ip, 1.0, dbip, resp) < 0) {
bu_log("rt_generic_xform(): %s export failure\n",
OBJ[id].ft_name);
return -1; /* FAIL */
}
if ((release || op == ip)) rt_db_free_internal(ip);
RT_DB_INTERNAL_INIT(op);
if (OBJ[id].ft_import4(op, &ext, mat, dbip, resp) < 0) {
bu_log("rt_generic_xform(): solid import failure\n");
return -1; /* FAIL */
}
break;
case 5:
if (OBJ[id].ft_export5(&ext, ip, 1.0, dbip, resp) < 0) {
bu_log("rt_generic_xform(): %s export failure\n",
OBJ[id].ft_name);
return -1; /* FAIL */
}
if ((release || op == ip)) {
if (ip->idb_avs.magic == BU_AVS_MAGIC) {
/* grab the attributes before they are lost
* by rt_db_free_internal or RT_DB_INTERNAL_INIT
*/
bu_avs_init(&avs, ip->idb_avs.count, "avs");
bu_avs_merge(&avs, &ip->idb_avs);
}
rt_db_free_internal(ip);
}
RT_DB_INTERNAL_INIT(op);
if (!release && op != ip) {
/* just copy the attributes from ip to op */
if (ip->idb_avs.magic == BU_AVS_MAGIC) {
bu_avs_init(&op->idb_avs, ip->idb_avs.count, "avs");
bu_avs_merge(&op->idb_avs, &ip->idb_avs);
}
} else if (avs.magic == BU_AVS_MAGIC) {
/* put the saved attributes in the output */
bu_avs_init(&op->idb_avs, avs.count, "avs");
bu_avs_merge(&op->idb_avs, &avs);
bu_avs_free(&avs);
}
if (OBJ[id].ft_import5(op, &ext, mat, dbip, resp) < 0) {
bu_log("rt_generic_xform(): solid import failure\n");
return -1; /* FAIL */
}
break;
}
bu_free_external(&ext);
RT_CK_DB_INTERNAL(op);
return 0; /* OK */
}
int
bdb_back_initialize(
BackendInfo *bi )
{
int rc;
static char *controls[] = {
LDAP_CONTROL_ASSERT,
LDAP_CONTROL_MANAGEDSAIT,
LDAP_CONTROL_NOOP,
LDAP_CONTROL_PAGEDRESULTS,
LDAP_CONTROL_PRE_READ,
LDAP_CONTROL_POST_READ,
LDAP_CONTROL_SUBENTRIES,
LDAP_CONTROL_X_PERMISSIVE_MODIFY,
#ifdef LDAP_X_TXN
LDAP_CONTROL_X_TXN_SPEC,
#endif
NULL
};
/* initialize the underlying database system */
Debug( LDAP_DEBUG_TRACE,
LDAP_XSTRING(bdb_back_initialize) ": initialize "
BDB_UCTYPE " backend\n", 0, 0, 0 );
bi->bi_flags |=
SLAP_BFLAG_INCREMENT |
SLAP_BFLAG_SUBENTRIES |
SLAP_BFLAG_ALIASES |
SLAP_BFLAG_REFERRALS;
bi->bi_controls = controls;
{ /* version check */
int major, minor, patch, ver;
char *version = db_version( &major, &minor, &patch );
#ifdef HAVE_EBCDIC
char v2[1024];
/* All our stdio does an ASCII to EBCDIC conversion on
* the output. Strings from the BDB library are already
* in EBCDIC; we have to go back and forth...
*/
strcpy( v2, version );
__etoa( v2 );
version = v2;
#endif
ver = (major << 24) | (minor << 16) | patch;
if( ver != DB_VERSION_FULL ) {
/* fail if a versions don't match */
Debug( LDAP_DEBUG_ANY,
LDAP_XSTRING(bdb_back_initialize) ": "
"BDB library version mismatch:"
" expected " DB_VERSION_STRING ","
" got %s\n", version, 0, 0 );
return -1;
}
Debug( LDAP_DEBUG_TRACE, LDAP_XSTRING(bdb_back_initialize)
": %s\n", version, 0, 0 );
}
db_env_set_func_free( ber_memfree );
db_env_set_func_malloc( (db_malloc *)ber_memalloc );
db_env_set_func_realloc( (db_realloc *)ber_memrealloc );
#if !defined(NO_THREAD) && DB_VERSION_FULL <= 0x04070000
/* This is a no-op on a NO_THREAD build. Leave the default
* alone so that BDB will sleep on interprocess conflicts.
* Don't bother on BDB 4.7...
*/
db_env_set_func_yield( ldap_pvt_thread_yield );
#endif
bi->bi_open = 0;
bi->bi_close = 0;
bi->bi_config = 0;
bi->bi_destroy = 0;
bi->bi_db_init = bdb_db_init;
bi->bi_db_config = config_generic_wrapper;
bi->bi_db_open = bdb_db_open;
bi->bi_db_close = bdb_db_close;
bi->bi_db_destroy = bdb_db_destroy;
bi->bi_op_add = bdb_add;
bi->bi_op_bind = bdb_bind;
bi->bi_op_compare = bdb_compare;
bi->bi_op_delete = bdb_delete;
bi->bi_op_modify = bdb_modify;
bi->bi_op_modrdn = bdb_modrdn;
bi->bi_op_search = bdb_search;
bi->bi_op_unbind = 0;
bi->bi_extended = bdb_extended;
bi->bi_chk_referrals = bdb_referrals;
bi->bi_operational = bdb_operational;
bi->bi_has_subordinates = bdb_hasSubordinates;
bi->bi_entry_release_rw = bdb_entry_release;
bi->bi_entry_get_rw = bdb_entry_get;
/*
* hooks for slap tools
*/
bi->bi_tool_entry_open = bdb_tool_entry_open;
bi->bi_tool_entry_close = bdb_tool_entry_close;
bi->bi_tool_entry_first = backend_tool_entry_first;
bi->bi_tool_entry_first_x = bdb_tool_entry_first_x;
bi->bi_tool_entry_next = bdb_tool_entry_next;
bi->bi_tool_entry_get = bdb_tool_entry_get;
bi->bi_tool_entry_put = bdb_tool_entry_put;
bi->bi_tool_entry_reindex = bdb_tool_entry_reindex;
bi->bi_tool_sync = 0;
bi->bi_tool_dn2id_get = bdb_tool_dn2id_get;
bi->bi_tool_entry_modify = bdb_tool_entry_modify;
bi->bi_connection_init = 0;
bi->bi_connection_destroy = 0;
rc = bdb_back_init_cf( bi );
return rc;
}
int
ged_dbcopy(struct ged *from_gedp, struct ged *to_gedp, const char *from, const char *to, int fflag)
{
struct directory *from_dp;
struct bu_external external;
GED_CHECK_DATABASE_OPEN(from_gedp, GED_ERROR);
GED_CHECK_DATABASE_OPEN(to_gedp, GED_ERROR);
GED_CHECK_READ_ONLY(to_gedp, GED_ERROR);
/* initialize result */
bu_vls_trunc(from_gedp->ged_result_str, 0);
bu_vls_trunc(to_gedp->ged_result_str, 0);
GED_DB_LOOKUP(from_gedp, from_dp, from, LOOKUP_NOISY, GED_ERROR & GED_QUIET);
if (!fflag && db_lookup(to_gedp->ged_wdbp->dbip, to, LOOKUP_QUIET) != RT_DIR_NULL) {
bu_vls_printf(from_gedp->ged_result_str, "%s already exists.", to);
return GED_ERROR;
}
if (db_get_external(&external, from_dp, from_gedp->ged_wdbp->dbip)) {
bu_vls_printf(from_gedp->ged_result_str, "Database read error, aborting\n");
return GED_ERROR;
}
if (wdb_export_external(to_gedp->ged_wdbp, &external, to,
from_dp->d_flags, from_dp->d_minor_type) < 0) {
bu_free_external(&external);
bu_vls_printf(from_gedp->ged_result_str,
"Failed to write new object (%s) to database - aborting!!\n",
to);
return GED_ERROR;
}
bu_free_external(&external);
/* Need to do something extra for _GLOBAL */
if (db_version(to_gedp->ged_wdbp->dbip) > 4 && BU_STR_EQUAL(to, DB5_GLOBAL_OBJECT_NAME)) {
struct directory *to_dp;
struct bu_attribute_value_set avs;
const char *val;
GED_DB_LOOKUP(to_gedp, to_dp, to, LOOKUP_NOISY, GED_ERROR & GED_QUIET);
bu_avs_init_empty(&avs);
if (db5_get_attributes(to_gedp->ged_wdbp->dbip, &avs, to_dp)) {
bu_vls_printf(from_gedp->ged_result_str, "Cannot get attributes for object %s\n", to_dp->d_namep);
return GED_ERROR;
}
if ((val = bu_avs_get(&avs, "title")) != NULL)
to_gedp->ged_wdbp->dbip->dbi_title = strdup(val);
if ((val = bu_avs_get(&avs, "units")) != NULL) {
double loc2mm;
if ((loc2mm = bu_mm_value(val)) > 0) {
to_gedp->ged_wdbp->dbip->dbi_local2base = loc2mm;
to_gedp->ged_wdbp->dbip->dbi_base2local = 1.0 / loc2mm;
}
}
if ((val = bu_avs_get(&avs, "regionid_colortable")) != NULL) {
rt_color_free();
db5_import_color_table((char *)val);
}
bu_avs_free(&avs);
}
return GED_OK;
}
int
main(int argc, char **argv)
{
struct rt_wdb *fp;
struct db_i *dbip;
struct directory *dp;
long errors = 0;
struct bn_tol tol;
char name[17];
bu_setprogname(argv[0]);
/* FIXME: These need to be improved */
tol.magic = BN_TOL_MAGIC;
tol.dist = 0.0005;
tol.dist_sq = tol.dist * tol.dist;
tol.perp = 1e-6;
tol.para = 1 - tol.perp;
bu_debug = BU_DEBUG_COREDUMP;
rt_init_resource( &rt_uniresource, 0, NULL );
if ( argc != 3 ) {
fprintf(stderr, "Usage: %s v4.g v5.g\n", argv[0]);
return 1;
}
if ( (dbip = db_open(argv[1], DB_OPEN_READONLY)) == DBI_NULL ) {
perror( argv[1] );
return 2;
}
if ( (fp = wdb_fopen( argv[2] )) == NULL ) {
perror( argv[2] );
return 3;
}
if ( db_version(dbip) != 4 ) {
bu_log( "Input database must be a version 4 database!!!!\n" );
return 4;
}
RT_CK_DBI(dbip);
if ( db_dirbuild( dbip ) )
bu_exit(1, "db_dirbuild failed\n" );
db_update_ident( fp->dbip, dbip->dbi_title, dbip->dbi_local2base );
/* Retrieve every item in the input database */
FOR_ALL_DIRECTORY_START(dp, dbip) {
struct rt_db_internal intern;
int id;
int ret;
fprintf(stderr, "%.16s\n", dp->d_namep );
id = rt_db_get_internal( &intern, dp, dbip, NULL, &rt_uniresource );
if ( id < 0 ) {
fprintf(stderr,
"%s: rt_db_get_internal(%s) failure, skipping\n",
argv[0], dp->d_namep);
errors++;
continue;
}
if ( id == ID_COMBINATION ) {
struct rt_comb_internal *comb;
char *ptr;
comb = (struct rt_comb_internal *)intern.idb_ptr;
RT_CK_COMB( comb );
/* Convert "plastic" to "phong" in the shader string */
while ( (ptr=strstr( bu_vls_addr( &comb->shader), "plastic" )) != NULL ) {
ptr[0] = 'p'; /* p */
ptr[1] = 'h'; /* l */
ptr[2] = 'o'; /* a */
ptr[3] = 'n'; /* s */
ptr[4] = 'g'; /* t */
ptr[5] = ' '; /* i */
ptr[6] = ' '; /* c */
}
}
if ( id == ID_HF ) {
if (rt_hf_to_dsp( &intern )) {
fprintf(stderr,
"%s: Conversion from HF to DSP failed for solid %s\n",
argv[0], dp->d_namep );
errors++;
continue;
}
}
if ( id == ID_POLY)
{
if ( rt_pg_to_bot( &intern, &tol, &rt_uniresource ) )
{
fprintf( stderr, "%s: Conversion from polysolid to BOT failed for solid %s\n",
argv[0], dp->d_namep );
errors++;
continue;
}
}
/* to insure null termination */
bu_strlcpy( name, dp->d_namep, sizeof(name) );
ret = wdb_put_internal( fp, name, &intern, 1.0 );
if ( ret < 0 ) {
fprintf(stderr,
"%s: wdb_put_internal(%s) failure, skipping\n",
argv[0], dp->d_namep);
rt_db_free_internal(&intern);
errors++;
continue;
}
rt_db_free_internal(&intern);
} FOR_ALL_DIRECTORY_END
wdb_close( fp );
db_close( dbip );
fprintf(stderr, "%ld objects failed to convert\n", errors);
return 0;
}
int
ged_tops(struct ged *gedp, int argc, const char *argv[])
{
struct directory *dp;
int i;
struct directory **dirp;
struct directory **dirp0 = (struct directory **)NULL;
int c;
int no_decorate = 0;
int aflag = 0;
int hflag = 0;
int pflag = 0;
/* static const char *usage = "[-a|-h|-n|-p]"; */
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
/* process any options */
bu_optind = 1; /* re-init bu_getopt() */
while ((c = bu_getopt(argc, (char * const *)argv, "ahnp")) != -1) {
switch (c) {
case 'a':
aflag = 1;
break;
case 'h':
hflag = 1;
break;
case 'n':
no_decorate = 1;
break;
case 'p':
pflag = 1;
break;
default:
break;
}
}
argc -= (bu_optind - 1);
argv += (bu_optind - 1);
/* Can this be executed only sometimes?
Perhaps a "dirty bit" on the database? */
db_update_nref(gedp->ged_wdbp->dbip, &rt_uniresource);
/*
* Find number of possible entries and allocate memory
*/
dirp = _ged_dir_getspace(gedp->ged_wdbp->dbip, 0);
dirp0 = dirp;
if (db_version(gedp->ged_wdbp->dbip) < 5) {
for (i = 0; i < RT_DBNHASH; i++)
for (dp = gedp->ged_wdbp->dbip->dbi_Head[i];
dp != RT_DIR_NULL;
dp = dp->d_forw) {
if (dp->d_nref == 0)
*dirp++ = dp;
}
} else {
for (i = 0; i < RT_DBNHASH; i++)
for (dp = gedp->ged_wdbp->dbip->dbi_Head[i]; dp != RT_DIR_NULL; dp = dp->d_forw) {
if (dp->d_nref != 0) {
continue;
}
if ((aflag) ||
(hflag && (dp->d_flags & RT_DIR_HIDDEN)) ||
(pflag && dp->d_addr == RT_DIR_PHONY_ADDR)) {
/* add object because it matches an option */
*dirp++ = dp;
} else if (!aflag && !hflag && !pflag &&
!(dp->d_flags & RT_DIR_HIDDEN) &&
(dp->d_addr != RT_DIR_PHONY_ADDR)) {
/* add non-hidden real object */
*dirp++ = dp;
}
}
}
_ged_vls_col_pr4v(gedp->ged_result_str, dirp0, (int)(dirp - dirp0), no_decorate);
bu_free((void *)dirp0, "wdb_tops_cmd: wdb_dir_getspace");
return GED_OK;
}
// static method
char *DbEnv::version(int *major, int *minor, int *patch)
{
return (db_version(major, minor, patch));
}
int
ged_move_all(struct ged *gedp, int argc, const char *argv[])
{
int c;
int fflag = 0;
int nflag = 0;
static const char *usage = "[-n] {-f <mapping_file>|<from> <to>}";
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_READ_ONLY(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
/* must be wanting help */
if (argc == 1) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_HELP;
}
if (argc < 3 || 4 < argc) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
if (db_version(gedp->ged_wdbp->dbip) < 5 && (int)strlen(argv[2]) > NAMESIZE) {
bu_vls_printf(gedp->ged_result_str, "ERROR: name length limited to %zu characters in v4 databases\n", strlen(argv[2]));
return GED_ERROR;
}
bu_optind = 1;
while ((c = bu_getopt(argc, (char * const *)argv, "fn")) != -1) {
switch (c) {
case 'f':
fflag = 1;
break;
case 'n':
nflag = 1;
break;
default:
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
}
argc -= bu_optind;
argv += bu_optind;
if (fflag) {
if (argc != 1) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
return move_all_file(gedp, nflag, argv[0]);
}
if (argc != 2) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
return move_all_func(gedp, nflag, argv[0], argv[1]);
}
int
ged_constraint(struct ged *gedp, int argc, const char *argv[])
{
/* Potential constraint attributes:
*
* attr set c1 cad:description "this keeps our car on the ground"
* attr set c1 cad:plot 0|1
* attr set c1 cad:reference 0|1
* attr set c1 cad:format value|name|expression (name=value)
* attr set c1 cad:disabled 0|1
*/
static struct bu_cmdtab pc_cmds[] = {
{"set", constraint_set},
{"get", constraint_get},
{"show", constraint_show},
{"eval", constraint_eval},
{"help", constraint_help},
{(const char *)NULL, BU_CMD_NULL}
};
int ret;
int cmdret;
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
if (argc < 2) {
/* must be wanting help */
constraint_usage(gedp->ged_result_str, argv[0]);
return GED_HELP;
}
if (BU_STR_EQUIV(argv[1], "help")) {
constraint_help(gedp, argc, argv);
return GED_OK;
}
if (argc < 3) {
/* must be confused */
constraint_usage(gedp->ged_result_str, argv[0]);
return GED_HELP;
}
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
/* this is only valid for v5 databases */
if (db_version(gedp->ged_wdbp->dbip) < 5) {
bu_vls_printf(gedp->ged_result_str, "Attributes are not available for this database format.\nPlease upgrade your database format using \"dbupgrade\" to enable attributes.");
return GED_ERROR;
}
/* run our command */
ret = bu_cmd(pc_cmds, argc, argv, 1, gedp, &cmdret);
if (ret != BRLCAD_OK) {
constraint_usage(gedp->ged_result_str, argv[0]);
return GED_ERROR;
}
if (cmdret != BRLCAD_OK)
return GED_ERROR;
return GED_OK;
}
