Ejemplo n.º 1
0
krb5_error_code
osa_adb_rename_db(char *filefrom, char *lockfrom, char *fileto, char *lockto,
                  int magic)
{
    osa_adb_db_t fromdb, todb;
    krb5_error_code ret;

    /* make sure todb exists */
    if ((ret = osa_adb_create_db(fileto, lockto, magic)) &&
            ret != EEXIST)
        return ret;

    if ((ret = osa_adb_init_db(&fromdb, filefrom, lockfrom, magic)))
        return ret;
    if ((ret = osa_adb_init_db(&todb, fileto, lockto, magic))) {
        (void) osa_adb_fini_db(fromdb, magic);
        return ret;
    }
    if ((ret = osa_adb_get_lock(fromdb, KRB5_DB_LOCKMODE_PERMANENT))) {
        (void) osa_adb_fini_db(fromdb, magic);
        (void) osa_adb_fini_db(todb, magic);
        return ret;
    }
    if ((ret = osa_adb_get_lock(todb, KRB5_DB_LOCKMODE_PERMANENT))) {
        (void) osa_adb_fini_db(fromdb, magic);
        (void) osa_adb_fini_db(todb, magic);
        return ret;
    }
    if ((rename(filefrom, fileto) < 0)) {
        (void) osa_adb_fini_db(fromdb, magic);
        (void) osa_adb_fini_db(todb, magic);
        return errno;
    }
    /*
     * Do not release the lock on fromdb because it is being renamed
     * out of existence; no one can ever use it again.
     */
    if ((ret = osa_adb_release_lock(todb))) {
        (void) osa_adb_fini_db(fromdb, magic);
        (void) osa_adb_fini_db(todb, magic);
        return ret;
    }

    (void) osa_adb_fini_db(fromdb, magic);
    (void) osa_adb_fini_db(todb, magic);
    return 0;
}
Ejemplo n.º 2
0
krb5_error_code
krb5_db2_init(krb5_context context)
{
    char   *filename = NULL;
    krb5_db2_context *db_ctx;
    krb5_error_code retval;
    char    policy_db_name[1024], policy_lock_name[1024];

    if (k5db2_inited(context))
        return 0;

    /* Check for presence of our context, if not present, allocate one. */
    if ((retval = k5db2_init_context(context)))
        return (retval);

    db_ctx = context->dal_handle->db_context;
    db_ctx->db = NULL;

    if (!(filename = gen_dbsuffix(db_ctx->db_name, db_ctx->tempdb
                                  ?KDB2_TEMP_LOCK_EXT:KDB2_LOCK_EXT)))
        return ENOMEM;
    db_ctx->db_lf_name = filename;      /* so it gets freed by clear_context */

    /*
     * should be opened read/write so that write locking can work with
     * POSIX systems
     */
    if ((db_ctx->db_lf_file = open(filename, O_RDWR, 0666)) < 0) {
        if ((db_ctx->db_lf_file = open(filename, O_RDONLY, 0666)) < 0) {
            retval = errno;
            goto err_out;
        }
    }
    set_cloexec_fd(db_ctx->db_lf_file);
    db_ctx->db_inited++;

    if ((retval = krb5_db2_get_age(context, NULL, &db_ctx->db_lf_time)))
        goto err_out;

    snprintf(policy_db_name, sizeof(policy_db_name), "%s%s.kadm5",
             db_ctx->db_name, db_ctx->tempdb ? "~" : "");
    snprintf(policy_lock_name, sizeof(policy_lock_name),
             "%s.lock", policy_db_name);

    if ((retval = osa_adb_init_db(&db_ctx->policy_db, policy_db_name,
                                  policy_lock_name, OSA_ADB_POLICY_DB_MAGIC)))
    {
        goto err_out;
    }
    return 0;

err_out:
    db_ctx->db = NULL;
    k5db2_clear_context(db_ctx);
    return (retval);
}
Ejemplo n.º 3
0
/* Initialize the lock file and policy database fields of dbc.  The db_name and
 * tempdb fields must already be set. */
static krb5_error_code
ctx_init(krb5_db2_context *dbc)
{
    krb5_error_code retval;
    char *polname = NULL, *plockname = NULL;

    retval = ctx_dbsuffix(dbc, SUFFIX_LOCK, &dbc->db_lf_name);
    if (retval)
        return retval;

    /*
     * should be opened read/write so that write locking can work with
     * POSIX systems
     */
    if ((dbc->db_lf_file = open(dbc->db_lf_name, O_RDWR, 0666)) < 0) {
        if ((dbc->db_lf_file = open(dbc->db_lf_name, O_RDONLY, 0666)) < 0) {
            retval = errno;
            goto cleanup;
        }
    }
    set_cloexec_fd(dbc->db_lf_file);
    dbc->db_inited++;

    retval = ctx_dbsuffix(dbc, SUFFIX_POLICY, &polname);
    if (retval)
        goto cleanup;
    retval = ctx_dbsuffix(dbc, SUFFIX_POLICY_LOCK, &plockname);
    if (retval)
        goto cleanup;
    retval = osa_adb_init_db(&dbc->policy_db, polname, plockname,
                             OSA_ADB_POLICY_DB_MAGIC);

cleanup:
    free(polname);
    free(plockname);
    if (retval)
        ctx_clear(dbc);
    return retval;
}
Ejemplo n.º 4
0
/* Initialize dbc by locking and creating the DB.  If the DB already exists,
 * clear it out if dbc->tempdb is set; otherwise return EEXIST. */
static krb5_error_code
ctx_create_db(krb5_context context, krb5_db2_context *dbc)
{
    krb5_error_code retval = 0;
    char *dbname = NULL, *polname = NULL, *plockname = NULL;

    retval = ctx_allfiles(dbc, &dbname, &dbc->db_lf_name, &polname,
                          &plockname);
    if (retval)
        return retval;

    dbc->db_lf_file = open(dbc->db_lf_name, O_CREAT | O_RDWR | O_TRUNC,
                           0600);
    if (dbc->db_lf_file < 0) {
        retval = errno;
        goto cleanup;
    }
    retval = krb5_lock_file(context, dbc->db_lf_file,
                            KRB5_LOCKMODE_EXCLUSIVE | KRB5_LOCKMODE_DONTBLOCK);
    if (retval != 0)
        goto cleanup;
    set_cloexec_fd(dbc->db_lf_file);
    dbc->db_lock_mode = KRB5_LOCKMODE_EXCLUSIVE;
    dbc->db_locks_held = 1;

    if (dbc->tempdb) {
        /* Temporary DBs are locked for their whole lifetime.  Since we have
         * the lock, any remnant files can be safely destroyed. */
        (void) destroy_file(dbname);
        (void) unlink(polname);
        (void) unlink(plockname);
    }

    dbc->db = open_db(dbc, O_RDWR | O_CREAT | O_EXCL, 0600);
    if (dbc->db == NULL) {
        retval = errno;
        goto cleanup;
    }

    /* Create the policy database, initialize a handle to it, and lock it. */
    retval = osa_adb_create_db(polname, plockname, OSA_ADB_POLICY_DB_MAGIC);
    if (retval)
        goto cleanup;
    retval = osa_adb_init_db(&dbc->policy_db, polname, plockname,
                             OSA_ADB_POLICY_DB_MAGIC);
    if (retval)
        goto cleanup;
    retval = osa_adb_get_lock(dbc->policy_db, KRB5_DB_LOCKMODE_EXCLUSIVE);
    if (retval)
        goto cleanup;

    dbc->db_inited = 1;

cleanup:
    if (retval) {
        if (dbc->db != NULL)
            dbc->db->close(dbc->db);
        if (dbc->db_locks_held > 0) {
            (void) krb5_lock_file(context, dbc->db_lf_file,
                                  KRB5_LOCKMODE_UNLOCK);
        }
        if (dbc->db_lf_file >= 0)
            close(dbc->db_lf_file);
        ctx_clear(dbc);
    }
    free(dbname);
    free(polname);
    free(plockname);
    return retval;
}