int _sasldb_putdata(const sasl_utils_t *utils,
sasl_conn_t *context,
const char *authid,
const char *realm,
const char *propName,
const char *data_in, size_t data_len)
{
int result = SASL_OK;
char *key;
size_t key_len;
DBT dbkey;
DB *mbdb = NULL;
if (!utils) return SASL_BADPARAM;
if (!authid || !realm || !propName) {
utils->seterror(context, 0,
"Bad parameter in db_berkeley.c: _sasldb_putdata");
return SASL_BADPARAM;
}
if (!db_ok) {
utils->seterror(context, 0,
"Database not checked");
return SASL_FAIL;
}
result = _sasldb_alloc_key(utils, authid, realm, propName,
&key, &key_len);
if (result != SASL_OK) {
utils->seterror(context, 0,
"Could not allocate key in _sasldb_putdata");
return result;
}
/* open the db */
result=berkeleydb_open(utils, context, 1, &mbdb);
if (result!=SASL_OK) goto cleanup;
/* create the db key */
memset(&dbkey, 0, sizeof(dbkey));
dbkey.data = key;
dbkey.size = key_len;
if (data_in) { /* putting secret */
DBT data;
memset(&data, 0, sizeof(data));
data.data = (char *)data_in;
if(!data_len) data_len = strlen(data_in);
data.size = data_len;
result = mbdb->put(mbdb, NULL, &dbkey, &data, 0);
if (result != 0)
{
utils->log(NULL, SASL_LOG_ERR,
"error updating sasldb: %s", db_strerror(result));
utils->seterror(context, SASL_NOLOG,
"Couldn't update db");
result = SASL_FAIL;
goto cleanup;
}
} else { /* removing secret */
result=mbdb->del(mbdb, NULL, &dbkey, 0);
if (result != 0)
{
utils->log(NULL, SASL_LOG_ERR,
"error deleting entry from sasldb: %s", db_strerror(result));
utils->seterror(context, SASL_NOLOG,
"Couldn't update db");
if (result == DB_NOTFOUND)
result = SASL_NOUSER;
else
result = SASL_FAIL;
goto cleanup;
}
}
cleanup:
if (mbdb != NULL) berkeleydb_close(utils, mbdb);
utils->free(key);
return result;
}
/*
* Retrieve the secret from the database.
*
* Return SASL_NOUSER if entry doesn't exist
*
*/
int _sasldb_getdata(const sasl_utils_t *utils,
sasl_conn_t *context,
const char *auth_identity,
const char *realm,
const char *propName,
char *out, const size_t max_out, size_t *out_len)
{
int result = SASL_OK;
char *key;
size_t key_len;
DBT dbkey, data;
DB *mbdb = NULL;
if(!utils) return SASL_BADPARAM;
/* check parameters */
if (!auth_identity || !realm || !propName || !out || !max_out) {
utils->seterror(context, 0,
"Bad parameter in db_berkeley.c: _sasldb_getdata");
return SASL_BADPARAM;
}
if (!db_ok) {
utils->seterror(context, 0,
"Database not checked");
return SASL_FAIL;
}
/* allocate a key */
result = _sasldb_alloc_key(utils, auth_identity, realm, propName,
&key, &key_len);
if (result != SASL_OK) {
utils->seterror(context, 0,
"Could not allocate key in _sasldb_getdata");
return result;
}
/* open the db */
result = berkeleydb_open(utils, context, 0, &mbdb);
if (result != SASL_OK) goto cleanup;
/* zero out and create the key to search for */
memset(&dbkey, 0, sizeof(dbkey));
memset(&data, 0, sizeof(data));
dbkey.data = key;
dbkey.size = key_len;
/* ask berkeley db for the entry */
result = mbdb->get(mbdb, NULL, &dbkey, &data, 0);
switch (result) {
case 0:
/* success */
break;
case DB_NOTFOUND:
result = SASL_NOUSER;
utils->seterror(context, SASL_NOLOG,
"user: %s@%s property: %s not found in sasldb",
auth_identity,realm,propName);
goto cleanup;
break;
default:
utils->seterror(context, 0,
"error fetching from sasldb: %s",
db_strerror(result));
result = SASL_FAIL;
goto cleanup;
break;
}
if(data.size > max_out + 1)
return SASL_BUFOVER;
if(out_len) *out_len = data.size;
memcpy(out, data.data, data.size);
out[data.size] = '\0';
cleanup:
if (mbdb != NULL) berkeleydb_close(utils, mbdb);
utils->free(key);
return result;
}
int _sasldb_putdata(const sasl_utils_t *utils,
sasl_conn_t *context,
const char *authid,
const char *realm,
const char *propName,
const char *data_in, size_t data_len)
{
int result = SASL_OK;
char *key;
size_t key_len;
MDB_val dbkey;
MDB_txn *txn = NULL;
if (!utils) return SASL_BADPARAM;
if (!authid || !realm || !propName) {
utils->seterror(context, 0,
"Bad parameter in db_mdb.c: _sasldb_putdata");
return SASL_BADPARAM;
}
if (!db_ok) {
utils->seterror(context, 0,
"Database not checked");
return SASL_FAIL;
}
result = _sasldb_alloc_key(utils, authid, realm, propName,
&key, &key_len);
if (result != SASL_OK) {
utils->seterror(context, 0,
"Could not allocate key in _sasldb_putdata");
return result;
}
/* open the db */
result=do_open(utils, context, 1, &txn);
if (result!=SASL_OK) goto cleanup;
/* create the db key */
dbkey.mv_data = key;
dbkey.mv_size = key_len;
if (data_in) { /* putting secret */
MDB_val data;
data.mv_data = (char *)data_in;
if(!data_len) data_len = strlen(data_in);
data.mv_size = data_len;
result = mdb_put(txn, db_dbi, &dbkey, &data, 0);
if (result != 0)
{
utils->log(NULL, SASL_LOG_ERR,
"error updating sasldb: %s", mdb_strerror(result));
utils->seterror(context, SASL_NOLOG,
"Couldn't update db");
result = SASL_FAIL;
goto cleanup;
}
} else { /* removing secret */
result=mdb_del(txn, db_dbi, &dbkey, NULL);
if (result != 0)
{
utils->log(NULL, SASL_LOG_ERR,
"error deleting entry from sasldb: %s", mdb_strerror(result));
utils->seterror(context, SASL_NOLOG,
"Couldn't update db");
if (result == MDB_NOTFOUND)
result = SASL_NOUSER;
else
result = SASL_FAIL;
goto cleanup;
}
}
result = mdb_txn_commit(txn);
if (result) {
utils->log(NULL, SASL_LOG_ERR,
"error committing to sasldb: %s", mdb_strerror(result));
utils->seterror(context, SASL_NOLOG,
"Couldn't update db");
result = SASL_FAIL;
}
txn = NULL;
cleanup:
mdb_txn_abort(txn);
utils->free(key);
return result;
}
/*
* Retrieve the secret from the database.
*
* Return SASL_NOUSER if the entry doesn't exist,
* SASL_OK on success.
*
*/
int _sasldb_getdata(const sasl_utils_t *utils,
sasl_conn_t *context,
const char *auth_identity,
const char *realm,
const char *propName,
char *out, const size_t max_out, size_t *out_len)
{
int result = SASL_OK;
char *key;
size_t key_len;
MDB_val dbkey, data;
MDB_txn *txn = NULL;
if(!utils) return SASL_BADPARAM;
/* check parameters */
if (!auth_identity || !realm || !propName || !out || !max_out) {
utils->seterror(context, 0,
"Bad parameter in db_mdb.c: _sasldb_getdata");
return SASL_BADPARAM;
}
if (!db_ok) {
utils->seterror(context, 0,
"Database not checked");
return SASL_FAIL;
}
/* allocate a key */
result = _sasldb_alloc_key(utils, auth_identity, realm, propName,
&key, &key_len);
if (result != SASL_OK) {
utils->seterror(context, 0,
"Could not allocate key in _sasldb_getdata");
return result;
}
/* open the db */
result = do_open(utils, context, 0, &txn);
if (result != SASL_OK) goto cleanup;
/* create the key to search for */
dbkey.mv_data = key;
dbkey.mv_size = key_len;
/* ask MDB for the entry */
result = mdb_get(txn, db_dbi, &dbkey, &data);
switch (result) {
case 0:
/* success */
break;
case MDB_NOTFOUND:
result = SASL_NOUSER;
utils->seterror(context, SASL_NOLOG,
"user: %s@%s property: %s not found in sasldb",
auth_identity,realm,propName);
goto cleanup;
break;
default:
utils->seterror(context, 0,
"error fetching from sasldb: %s",
mdb_strerror(result));
result = SASL_FAIL;
goto cleanup;
break;
}
if(data.mv_size > max_out + 1)
return SASL_BUFOVER;
if(out_len) *out_len = data.mv_size;
memcpy(out, data.mv_data, data.mv_size);
out[data.mv_size] = '\0';
cleanup:
mdb_txn_abort(txn);
utils->free(key);
return result;
}
/* This provides a version of _sasl_db_getsecret and
* _sasl_db_putsecret which work with ndbm. */
int _sasldb_getdata(const sasl_utils_t *utils,
sasl_conn_t *conn,
const char *authid,
const char *realm,
const char *propName,
char *out, const size_t max_out, size_t *out_len)
{
int result = SASL_OK;
char *key;
size_t key_len;
DBM *db;
datum dkey, dvalue;
void *cntxt;
sasl_getopt_t *getopt;
const char *path = SASL_DB_PATH;
if (!utils) return SASL_BADPARAM;
if (!authid || !propName || !realm || !out || !max_out) {
utils->seterror(conn, 0,
"Bad parameter in db_ndbm.c: _sasldb_getdata");
return SASL_BADPARAM;
}
if (!db_ok) {
utils->seterror(conn, 0, "Database not checked");
return SASL_FAIL;
}
result = _sasldb_alloc_key(utils, authid, realm, propName,
&key, &key_len);
if (result != SASL_OK) {
utils->seterror(conn, 0,
"Could not allocate key in _sasldb_getdata");
return result;
}
if (utils->getcallback(conn, SASL_CB_GETOPT,
(sasl_callback_ft *)&getopt, &cntxt) == SASL_OK) {
const char *p;
if (getopt(cntxt, NULL, "sasldb_path", &p, NULL) == SASL_OK
&& p != NULL && *p != 0) {
path = p;
}
}
db = dbm_open(path, O_RDONLY, S_IRUSR | S_IWUSR);
if (! db) {
utils->seterror(cntxt, 0, "Could not open db");
result = SASL_FAIL;
goto cleanup;
}
dkey.dptr = key;
dkey.dsize = key_len;
dvalue = dbm_fetch(db, dkey);
if (! dvalue.dptr) {
utils->seterror(cntxt, SASL_NOLOG,
"user: %s@%s property: %s not found in sasldb",
authid, realm, propName);
result = SASL_NOUSER;
goto cleanup;
}
if((size_t)dvalue.dsize > max_out + 1) {
utils->seterror(cntxt, 0, "buffer overflow");
return SASL_BUFOVER;
}
if(out_len) *out_len = dvalue.dsize;
memcpy(out, dvalue.dptr, dvalue.dsize);
out[dvalue.dsize] = '\0';
#if NDBM_FREE
/* Note: not sasl_FREE! This is memory allocated by ndbm,
* which is using libc malloc/free. */
free(dvalue.dptr);
#endif
cleanup:
utils->free(key);
if(db)
dbm_close(db);
return result;
}
int _sasldb_putdata(const sasl_utils_t *utils,
sasl_conn_t *conn,
const char *authid,
const char *realm,
const char *propName,
const char *data, size_t data_len)
{
int result = SASL_OK;
char *key;
size_t key_len;
DBM *db;
datum dkey;
void *cntxt;
sasl_getopt_t *getopt;
const char *path = SASL_DB_PATH;
if (!utils) return SASL_BADPARAM;
if (!authid || !realm || !propName) {
utils->seterror(conn, 0,
"Bad parameter in db_ndbm.c: _sasldb_putdata");
return SASL_BADPARAM;
}
result = _sasldb_alloc_key(utils, authid, realm, propName,
&key, &key_len);
if (result != SASL_OK) {
utils->seterror(conn, 0,
"Could not allocate key in _sasldb_putdata");
return result;
}
if (utils->getcallback(conn, SASL_CB_GETOPT,
(sasl_callback_ft *)&getopt, &cntxt) == SASL_OK) {
const char *p;
if (getopt(cntxt, NULL, "sasldb_path", &p, NULL) == SASL_OK
&& p != NULL && *p != 0) {
path = p;
}
}
db = dbm_open(path,
O_RDWR | O_CREAT,
S_IRUSR | S_IWUSR);
if (! db) {
utils->log(conn, SASL_LOG_ERR,
"SASL error opening password file. "
"Do you have write permissions?\n");
utils->seterror(conn, 0, "Could not open db for write");
result = SASL_FAIL;
goto cleanup;
}
dkey.dptr = key;
dkey.dsize = key_len;
if (data) {
datum dvalue;
dvalue.dptr = (void *)data;
if(!data_len) data_len = strlen(data);
dvalue.dsize = data_len;
if (dbm_store(db, dkey, dvalue, DBM_REPLACE)) {
utils->seterror(conn, 0,
"Couldn't update db");
result = SASL_FAIL;
}
} else {
if (dbm_delete(db, dkey)) {
utils->seterror(conn, 0,
"Couldn't update db");
result = SASL_NOUSER;
}
}
dbm_close(db);
cleanup:
utils->free(key);
return result;
}
