/* Register a filename for plain keybox files. Returns a pointer to
be used to create a handles and so on. Returns NULL to indicate
that FNAME has already been registered. */
void *
keybox_register_file (const char *fname, int secret)
{
KB_NAME kr;
for (kr=kb_names; kr; kr = kr->next)
{
if (same_file_p (kr->fname, fname) )
return NULL; /* Already registered. */
}
kr = xtrymalloc (sizeof *kr + strlen (fname));
if (!kr)
return NULL;
strcpy (kr->fname, fname);
kr->secret = !!secret;
kr->handle_table = NULL;
kr->handle_table_size = 0;
/* kr->lockhd = NULL;*/
kr->is_locked = 0;
kr->did_full_scan = 0;
/* keep a list of all issued pointers */
kr->next = kb_names;
kb_names = kr;
/* create the offset table the first time a function here is used */
/* if (!kb_offtbl) */
/* kb_offtbl = new_offset_hash_table (); */
return kr;
}
/*
* Register a filename for plain keyring files. ptr is set to a
* pointer to be used to create a handles etc, or the already-issued
* pointer if it has already been registered. The function returns 1
* if a new keyring was registered.
*/
int
keyring_register_filename (const char *fname, int secret, int readonly,
void **ptr)
{
KR_NAME kr;
if (active_handles)
BUG (); /* We don't allow that */
for (kr=kr_names; kr; kr = kr->next)
{
if (same_file_p (kr->fname, fname))
{
/* Already registered. */
if (readonly)
kr->readonly = 1;
*ptr=kr;
return 0;
}
}
if (secret)
register_secured_file (fname);
kr = xmalloc (sizeof *kr + strlen (fname));
strcpy (kr->fname, fname);
kr->secret = !!secret;
kr->readonly = readonly;
kr->lockhd = NULL;
kr->is_locked = 0;
kr->did_full_scan = 0;
/* keep a list of all issued pointers */
kr->next = kr_names;
kr_names = kr;
/* create the offset table the first time a function here is used */
if (!kr_offtbl)
kr_offtbl = new_offset_hash_table ();
*ptr=kr;
return 1;
}
/*
* Register a filename for plain keyring files. ptr is set to a
* pointer to be used to create a handles etc, or the already-issued
* pointer if it has already been registered. The function returns 1
* if a new keyring was registered.
*/
int
keyring_register_filename (const char *fname, int read_only, void **ptr)
{
KR_RESOURCE kr;
if (active_handles)
/* There are open handles. */
BUG ();
for (kr=kr_resources; kr; kr = kr->next)
{
if (same_file_p (kr->fname, fname))
{
/* Already registered. */
if (read_only)
kr->read_only = 1;
*ptr=kr;
return 0;
}
}
kr = xmalloc (sizeof *kr + strlen (fname));
strcpy (kr->fname, fname);
kr->read_only = read_only;
kr->lockhd = NULL;
kr->is_locked = 0;
kr->did_full_scan = 0;
/* keep a list of all issued pointers */
kr->next = kr_resources;
kr_resources = kr;
/* create the offset table the first time a function here is used */
if (!key_present_hash)
key_present_hash = key_present_hash_new ();
*ptr=kr;
return 1;
}
void
kpathsea_init_db (kpathsea kpse)
{
const_string db_path;
string *db_files;
string *orig_db_files;
str_list_type unique_list;
int dbi;
boolean ok = false;
assert (sizeof(DB_NAME) == sizeof(DB_NAME_LC));
db_path = kpathsea_init_format (kpse, kpse_db_format);
db_files = kpathsea_path_search_list_generic (kpse, db_path, db_names,
true, true);
orig_db_files = db_files;
/* Mac OS X and others can use a case-insensitive, case-preserving
filesystem by default, in which case ls-R and ls-r point to the
same file. Also, Windows is case-insensitive. In these cases,
we want to avoid reading the same file multiple times. */
dbi = 0;
unique_list = str_list_init ();
while (db_files[dbi] != NULL) {
string path1 = db_files[dbi];
string path2 = db_files[dbi + 1];
/* first-pass check in case path1/path2 aren't even
potentially equal; mainly in case the order from
kpathsea_path_search_list_generic changes. */
if (path2
&& strcasecmp (path1, path2) == 0
&& same_file_p (path1, path2)) {
/* they are the same, skip over path1, we'll add path2
on the next iteration (when it's path1). */
#ifdef KPSE_DEBUG
if (KPATHSEA_DEBUG_P (KPSE_DEBUG_HASH)) {
DEBUGF2 ("db:init(): skipping db same_file_p %s, will add %s.\n",
path1, path2);
}
#endif
free (path1);
} else {
/* they are not the same, add path1. */
#ifdef KPSE_DEBUG
if (KPATHSEA_DEBUG_P (KPSE_DEBUG_HASH)) {
DEBUGF1 ("db:init(): using db file %s.\n", path1);
}
#endif
str_list_add (&unique_list, path1);
}
/* could be more clever and increment by two, but then would
have to avoid jumping off the end of db_files */
dbi++;
}
/* always add a NULL terminator. */
str_list_add (&unique_list, NULL);
free (orig_db_files);
db_files = STR_LIST (unique_list);
orig_db_files = db_files;
/* Must do this after the path searching (which ends up calling
kpse_db_search recursively), so kpse->db.buckets stays NULL. */
kpse->db = hash_create (DB_HASH_SIZE);
while (db_files && *db_files) {
if (db_build (kpse, &(kpse->db), *db_files))
ok = true;
free (*db_files);
db_files++;
}
if (!ok) {
/* If db can't be built, leave `size' nonzero (so we don't
rebuild it), but clear `buckets' (so we don't look in it). */
free (kpse->db.buckets);
kpse->db.buckets = NULL;
}
free (orig_db_files);
/* Add the content of any alias databases. There may exist more than
one alias file along DB_NAME files. This duplicates the above code
-- should be a function. */
ok = false;
db_files = kpathsea_all_path_search (kpse, db_path, ALIAS_NAME);
orig_db_files = db_files;
kpse->alias_db = hash_create (ALIAS_HASH_SIZE);
while (db_files && *db_files) {
if (alias_build (kpse, &(kpse->alias_db), *db_files))
ok = true;
free (*db_files);
db_files++;
}
if (!ok) {
free (kpse->alias_db.buckets);
kpse->alias_db.buckets = NULL;
}
free (orig_db_files);
}