/**
* open a database
*/
struct db_context *db_open(TALLOC_CTX *mem_ctx,
const char *name,
int hash_size, int tdb_flags,
int open_flags, mode_t mode)
{
struct db_context *result = NULL;
#ifdef CLUSTER_SUPPORT
const char *sockname = lp_ctdbd_socket();
if(!sockname || !*sockname) {
sockname = CTDB_PATH;
}
if (lp_clustering()) {
const char *partname;
if (!socket_exist(sockname)) {
DEBUG(1, ("ctdb socket does not exist - is ctdb not "
"running?\n"));
return NULL;
}
/* ctdb only wants the file part of the name */
partname = strrchr(name, '/');
if (partname) {
partname++;
} else {
partname = name;
}
/* allow ctdb for individual databases to be disabled */
if (lp_parm_bool(-1, "ctdb", partname, True)) {
result = db_open_ctdb(mem_ctx, partname, hash_size,
tdb_flags, open_flags, mode);
if (result == NULL) {
DEBUG(0,("failed to attach to ctdb %s\n",
partname));
if (errno == 0) {
errno = EIO;
}
return NULL;
}
}
}
#endif
if (result == NULL) {
result = db_open_tdb(mem_ctx, name, hash_size,
tdb_flags, open_flags, mode);
}
if ((result != NULL) && (result->fetch == NULL)) {
result->fetch = dbwrap_fallback_fetch;
}
if ((result != NULL) && (result->parse_record == NULL)) {
result->parse_record = dbwrap_fallback_parse_record;
}
return result;
}
static PyObject *py_wrap_getxattr(PyObject *self, PyObject *args)
{
char *filename, *attribute, *tdbname;
TALLOC_CTX *mem_ctx;
struct loadparm_context *lp_ctx;
DATA_BLOB blob;
PyObject *ret_obj;
int ret;
ssize_t xattr_size;
struct db_context *eadb = NULL;
struct file_id id;
struct stat sbuf;
if (!PyArg_ParseTuple(args, "sss", &tdbname, &filename, &attribute))
return NULL;
mem_ctx = talloc_new(NULL);
lp_ctx = py_default_loadparm_context(mem_ctx);
eadb = db_open_tdb(mem_ctx, tdbname, 50000,
lpcfg_tdb_flags(lp_ctx, TDB_DEFAULT),
O_RDWR|O_CREAT, 0600, DBWRAP_LOCK_ORDER_2,
DBWRAP_FLAG_NONE);
if (eadb == NULL) {
PyErr_SetFromErrno(PyExc_IOError);
talloc_free(mem_ctx);
return NULL;
}
ret = stat(filename, &sbuf);
if (ret < 0) {
PyErr_SetFromErrno(PyExc_IOError);
talloc_free(mem_ctx);
return NULL;
}
ZERO_STRUCT(id);
id.devid = sbuf.st_dev;
id.inode = sbuf.st_ino;
xattr_size = xattr_tdb_getattr(eadb, mem_ctx, &id, attribute, &blob);
if (xattr_size < 0) {
PyErr_SetFromErrno(PyExc_TypeError);
talloc_free(mem_ctx);
return NULL;
}
ret_obj = PyString_FromStringAndSize((char *)blob.data, xattr_size);
talloc_free(mem_ctx);
return ret_obj;
}
static PyObject *py_wrap_setxattr(PyObject *self, PyObject *args)
{
char *filename, *attribute, *tdbname;
DATA_BLOB blob;
int blobsize;
int ret;
TALLOC_CTX *mem_ctx;
struct loadparm_context *lp_ctx;
struct db_context *eadb = NULL;
struct file_id id;
struct stat sbuf;
if (!PyArg_ParseTuple(args, "ssss#", &tdbname, &filename, &attribute,
&blob.data, &blobsize))
return NULL;
blob.length = blobsize;
mem_ctx = talloc_new(NULL);
lp_ctx = py_default_loadparm_context(mem_ctx);
eadb = db_open_tdb(mem_ctx, tdbname, 50000,
lpcfg_tdb_flags(lp_ctx, TDB_DEFAULT),
O_RDWR|O_CREAT, 0600, DBWRAP_LOCK_ORDER_2,
DBWRAP_FLAG_NONE);
if (eadb == NULL) {
PyErr_SetFromErrno(PyExc_IOError);
talloc_free(mem_ctx);
return NULL;
}
ret = stat(filename, &sbuf);
if (ret < 0) {
PyErr_SetFromErrno(PyExc_IOError);
talloc_free(mem_ctx);
return NULL;
}
ZERO_STRUCT(id);
id.devid = sbuf.st_dev;
id.inode = sbuf.st_ino;
ret = xattr_tdb_setattr(eadb, &id, attribute, blob.data, blob.length, 0);
if (ret < 0) {
PyErr_SetFromErrno(PyExc_TypeError);
talloc_free(mem_ctx);
return NULL;
}
talloc_free(mem_ctx);
Py_RETURN_NONE;
}
struct db_context *dbwrap_local_open(TALLOC_CTX *mem_ctx,
const char *name,
int hash_size, int tdb_flags,
int open_flags, mode_t mode,
enum dbwrap_lock_order lock_order,
uint64_t dbwrap_flags)
{
struct db_context *db = NULL;
db = db_open_tdb(
mem_ctx,
name,
hash_size,
tdb_flags,
open_flags,
mode,
lock_order,
dbwrap_flags);
return db;
}
struct db_context *dbwrap_local_open(TALLOC_CTX *mem_ctx,
struct loadparm_context *lp_ctx,
const char *name,
int hash_size, int tdb_flags,
int open_flags, mode_t mode,
enum dbwrap_lock_order lock_order,
uint64_t dbwrap_flags)
{
struct db_context *db = NULL;
if (hash_size == 0) {
hash_size = lpcfg_tdb_hash_size(lp_ctx, name);
}
db = db_open_tdb(mem_ctx, name, hash_size,
lpcfg_tdb_flags(lp_ctx, tdb_flags),
open_flags, mode,
lock_order, dbwrap_flags);
return db;
}
/**
* If you use this you can only modify with a transaction
*/
struct db_context *db_open_trans(TALLOC_CTX *mem_ctx,
const char *name,
int hash_size, int tdb_flags,
int open_flags, mode_t mode)
{
bool use_tdb2 = lp_parm_bool(-1, "dbwrap", "use_tdb2", false);
#ifdef CLUSTER_SUPPORT
const char *sockname = lp_ctdbd_socket();
#endif
if (tdb_flags & TDB_CLEAR_IF_FIRST) {
DEBUG(0,("db_open_trans: called with TDB_CLEAR_IF_FIRST: %s\n",
name));
smb_panic("db_open_trans: called with TDB_CLEAR_IF_FIRST");
}
#ifdef CLUSTER_SUPPORT
if(!sockname || !*sockname) {
sockname = CTDB_PATH;
}
if (lp_clustering() && socket_exist(sockname)) {
const char *partname;
/* ctdb only wants the file part of the name */
partname = strrchr(name, '/');
if (partname) {
partname++;
} else {
partname = name;
}
/* allow ctdb for individual databases to be disabled */
if (lp_parm_bool(-1, "ctdb", partname, true)) {
struct db_context *result = NULL;
result = db_open_ctdb(mem_ctx, partname, hash_size,
tdb_flags, open_flags, mode);
if (result == NULL) {
DEBUG(0,("failed to attach to ctdb %s\n",
partname));
smb_panic("failed to attach to a ctdb "
"database");
}
return result;
}
}
#endif
if (use_tdb2) {
const char *partname;
/* tdb2 only wants the file part of the name */
partname = strrchr(name, '/');
if (partname) {
partname++;
} else {
partname = name;
}
/* allow ctdb for individual databases to be disabled */
if (lp_parm_bool(-1, "tdb2", partname, true)) {
return db_open_tdb2(mem_ctx, partname, hash_size,
tdb_flags, open_flags, mode);
}
}
return db_open_tdb(mem_ctx, name, hash_size,
tdb_flags, open_flags, mode);
}
