source/lib/tdb/tdb.i

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    Swig interface to tdb.
   5
   6    Copyright (C) 2004-2006 Tim Potter <tpot@samba.org>
   7    Copyright (C) 2007 Jelmer Vernooij <jelmer@samba.org>
   8
   9      ** NOTE! The following LGPL license applies to the tdb
  10      ** library. This does NOT imply that all of Samba is released
  11      ** under the LGPL
  12
  13    This library is free software; you can redistribute it and/or
  14    modify it under the terms of the GNU Lesser General Public
  15    License as published by the Free Software Foundation; either
  16    version 3 of the License, or (at your option) any later version.
  17
  18    This library is distributed in the hope that it will be useful,
  19    but WITHOUT ANY WARRANTY; without even the implied warranty of
  20    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21    Lesser General Public License for more details.
  22
  23    You should have received a copy of the GNU Lesser General Public
  24    License along with this library; if not, see <http://www.gnu.org/licenses/>.
  25 */
  26
  27 %module tdb
  28
  29 %{
  30
  31 /* This symbol is used in both includes.h and Python.h which causes an
  32    annoying compiler warning. */
  33
  34 #ifdef HAVE_FSTAT
  35 #undef HAVE_FSTAT
  36 #endif
  37
  38 /* Include tdb headers */
  39 #include <stdint.h>
  40 #include <signal.h>
  41 #include <tdb.h>
  42 #include <fcntl.h>
  43
  44 typedef TDB_CONTEXT tdb;
  45 %}
  46
  47 /* The tdb functions will crash if a NULL tdb context is passed */
  48
  49 %import exception.i
  50 %import stdint.i
  51
  52 %typemap(check,noblock=1) TDB_CONTEXT* {
  53         if ($1 == NULL)
  54                 SWIG_exception(SWIG_ValueError,
  55                         "tdb context must be non-NULL");
  56 }
  57
  58 /* In and out typemaps for the TDB_DATA structure.  This is converted to
  59    and from the Python string type which can contain arbitrary binary
  60    data.. */
  61
  62 %typemap(in,noblock=1) TDB_DATA {
  63     if ($input == Py_None) {
  64         $1.dsize = 0;
  65         $1.dptr = NULL;
  66     } else if (!PyString_Check($input)) {
  67                 PyErr_SetString(PyExc_TypeError, "string arg expected");
  68                 return NULL;
  69         } else {
  70         $1.dsize = PyString_Size($input);
  71         $1.dptr = (uint8_t *)PyString_AsString($input);
  72     }
  73 }
  74
  75 %typemap(out,noblock=1) TDB_DATA {
  76         if ($1.dptr == NULL && $1.dsize == 0) {
  77                 $result = Py_None;
  78         } else {
  79                 $result = PyString_FromStringAndSize((const char *)$1.dptr, $1.dsize);
  80                 free($1.dptr);
  81     }
  82 }
  83
  84 /* Treat a mode_t as an unsigned integer */
  85 typedef int mode_t;
  86
  87 /* flags to tdb_store() */
  88 %constant int REPLACE = TDB_REPLACE;
  89 %constant int INSERT = TDB_INSERT;
  90 %constant int MODIFY = TDB_MODIFY;
  91
  92 /* flags for tdb_open() */
  93 %constant int DEFAULT = TDB_DEFAULT;
  94 %constant int CLEAR_IF_FIRST = TDB_CLEAR_IF_FIRST;
  95 %constant int INTERNAL = TDB_INTERNAL;
  96 %constant int NOLOCK = TDB_NOLOCK;
  97 %constant int NOMMAP = TDB_NOMMAP;
  98 %constant int CONVERT = TDB_CONVERT;
  99 %constant int BIGENDIAN = TDB_BIGENDIAN;
 100
 101 enum TDB_ERROR {
 102      TDB_SUCCESS=0,
 103      TDB_ERR_CORRUPT,
 104      TDB_ERR_IO,
 105      TDB_ERR_LOCK,
 106      TDB_ERR_OOM,
 107      TDB_ERR_EXISTS,
 108      TDB_ERR_NOLOCK,
 109      TDB_ERR_LOCK_TIMEOUT,
 110      TDB_ERR_NOEXIST,
 111      TDB_ERR_EINVAL,
 112      TDB_ERR_RDONLY
 113 };
 114
 115 %rename(lock_all) tdb_context::lockall;
 116 %rename(unlock_all) tdb_context::unlockall;
 117
 118 %rename(read_lock_all) tdb_context::lockall_read;
 119 %rename(read_unlock_all) tdb_context::unlockall_read;
 120
 121 %typemap(default,noblock=1) int tdb_flags {
 122     $1 = TDB_DEFAULT;
 123 }
 124
 125 %typemap(default,noblock=1) int open_flags {
 126     $1 = O_RDWR;
 127 }
 128
 129 %typemap(default,noblock=1) int hash_size {
 130     $1 = 0;
 131 }
 132
 133 %typemap(default,noblock=1) mode_t mode {
 134     $1 = 0600;
 135 }
 136
 137 %typemap(default,noblock=1) int flag {
 138     $1 = TDB_REPLACE;
 139 }
 140
 141 %rename(Tdb) tdb;
 142 %typemap(out,noblock=1) tdb * {
 143     /* Throw an IOError exception from errno if tdb_open() returns NULL */
 144     if ($1 == NULL) {
 145         PyErr_SetFromErrno(PyExc_IOError);
 146         SWIG_fail;
 147     }
 148     $result = SWIG_NewPointerObj($1, $1_descriptor, 0);
 149 }
 150
 151 typedef struct tdb_context {
 152     %extend {
 153         tdb(const char *name, int hash_size, int tdb_flags, int flags, mode_t mode) {
 154             return tdb_open(name, hash_size, tdb_flags, flags, mode);
 155         }
 156         enum TDB_ERROR error();
 157         ~tdb() { tdb_close($self); }
 158         int close();
 159         int append(TDB_DATA key, TDB_DATA new_dbuf);
 160         const char *errorstr();
 161         %rename(get) fetch;
 162         TDB_DATA fetch(TDB_DATA key);
 163         int delete(TDB_DATA key);
 164         int store(TDB_DATA key, TDB_DATA dbuf, int flag);
 165         int exists(TDB_DATA key);
 166         TDB_DATA firstkey();
 167         TDB_DATA nextkey(TDB_DATA key);
 168         int lockall();
 169         int unlockall();
 170         int lockall_read();
 171         int unlockall_read();
 172         int reopen();
 173         int transaction_start();
 174         int transaction_commit();
 175         int transaction_cancel();
 176         int transaction_recover();
 177         int hash_size();
 178         size_t map_size();
 179         int get_flags();
 180         void set_max_dead(int max_dead);
 181         const char *name();
 182     }
 183
 184     %pythoncode {
 185     def __str__(self):
 186         return self.name()
 187
 188     # Random access to keys, values
 189     def __getitem__(self, key):
 190         result = self.get(key)
 191         if result is None:
 192             raise KeyError, '%s: %s' % (key, self.errorstr())
 193         return result
 194
 195     def __setitem__(self, key, item):
 196         if self.store(key, item) == -1:
 197             raise IOError, self.errorstr()
 198
 199     def __delitem__(self, key):
 200         if not self.exists(key):
 201             raise KeyError, '%s: %s' % (key, self.errorstr())
 202         self.delete(key)
 203
 204     def __contains__(self, key):
 205         return self.exists(key) != 0
 206
 207     def has_key(self, key):
 208         return self.exists(key) != 0
 209
 210     def fetch_uint32(self, key):
 211         data = self.get(key)
 212         if data is None:
 213             return None
 214         import struct
 215         return struct.unpack("<L", data)[0]
 216
 217     def fetch_int32(self, key):
 218         data = self.get(key)
 219         if data is None:
 220             return None
 221         import struct
 222         return struct.unpack("<l", data)[0]
 223
 224     # Tdb iterator
 225     class TdbIterator:
 226         def __init__(self, tdb):
 227             self.tdb = tdb
 228             self.key = None
 229
 230         def __iter__(self):
 231             return self
 232
 233         def next(self):
 234             if self.key is None:
 235                 self.key = self.tdb.firstkey()
 236                 if self.key is None:
 237                     raise StopIteration
 238                 return self.key
 239             else:
 240                 self.key = self.tdb.nextkey(self.key)
 241                 if self.key is None:
 242                     raise StopIteration
 243                 return self.key
 244
 245     def __iter__(self):
 246         return self.TdbIterator(self)
 247
 248     # Implement other dict functions using TdbIterator
 249
 250     def keys(self):
 251         return [k for k in iter(self)]
 252
 253     def values(self):
 254         return [self[k] for k in iter(self)]
 255
 256     def items(self):
 257         return [(k, self[k]) for k in iter(self)]
 258
 259     def __len__(self):
 260         return len(self.keys())
 261
 262     def clear(self):
 263         for k in iter(self):
 264             del(self[k])
 265
 266     # TODO: iterkeys, itervalues, iteritems
 267
 268     # TODO: any other missing methods for container types
 269     }
 270 } tdb;