ext/ODBM_File/ODBM_File.xs

   1 #include "EXTERN.h"
   2 #include "perl.h"
   3 #include "XSUB.h"
   4
   5 #ifdef NULL
   6 #undef NULL  /* XXX Why? */
   7 #endif
   8 #ifdef I_DBM
   9 #  include <dbm.h>
  10 #else
  11 #  ifdef I_RPCSVC_DBM
  12 #    include <rpcsvc/dbm.h>
  13 #  endif
  14 #endif
  15
  16 #ifdef DBM_BUG_DUPLICATE_FREE
  17 /*
  18  * DBM on at least Ultrix and HPUX call dbmclose() from dbminit(),
  19  * resulting in duplicate free() because dbmclose() does *not*
  20  * check if it has already been called for this DBM.
  21  * If some malloc/free calls have been done between dbmclose() and
  22  * the next dbminit(), the memory might be used for something else when
  23  * it is freed.
  24  * Verified to work on ultrix4.3.  Probably will work on HP/UX.
  25  * Set DBM_BUG_DUPLICATE_FREE in the extension hint file.
  26  */
  27 /* Close the previous dbm, and fail to open a new dbm */
  28 #define dbmclose()      ((void) dbminit("/tmp/x/y/z/z/y"))
  29 #endif
  30
  31 #include <fcntl.h>
  32
  33 typedef struct {
  34         void *  dbp ;
  35         SV *    filter_fetch_key ;
  36         SV *    filter_store_key ;
  37         SV *    filter_fetch_value ;
  38         SV *    filter_store_value ;
  39         int     filtering ;
  40         } ODBM_File_type;
  41
  42 typedef ODBM_File_type * ODBM_File ;
  43 typedef datum datum_key ;
  44 typedef datum datum_value ;
  45
  46 #define ckFilter(arg,type,name)                                 \
  47         if (db->type) {                                         \
  48             SV * save_defsv ;                                   \
  49             /* printf("filtering %s\n", name) ;*/               \
  50             if (db->filtering)                                  \
  51                 croak("recursion detected in %s", name) ;       \
  52             db->filtering = TRUE ;                              \
  53             save_defsv = newSVsv(DEFSV) ;                       \
  54             sv_setsv(DEFSV, arg) ;                              \
  55             PUSHMARK(sp) ;                                      \
  56             (void) perl_call_sv(db->type, G_DISCARD|G_NOARGS);  \
  57             sv_setsv(arg, DEFSV) ;                              \
  58             sv_setsv(DEFSV, save_defsv) ;                       \
  59             SvREFCNT_dec(save_defsv) ;                          \
  60             db->filtering = FALSE ;                             \
  61             /*printf("end of filtering %s\n", name) ;*/         \
  62         }
  63
  64
  65 #define odbm_FETCH(db,key)                      fetch(key)
  66 #define odbm_STORE(db,key,value,flags)          store(key,value)
  67 #define odbm_DELETE(db,key)                     delete(key)
  68 #define odbm_FIRSTKEY(db)                       firstkey()
  69 #define odbm_NEXTKEY(db,key)                    nextkey(key)
  70
  71 static int dbmrefcnt;
  72
  73 #ifndef DBM_REPLACE
  74 #define DBM_REPLACE 0
  75 #endif
  76
  77 MODULE = ODBM_File      PACKAGE = ODBM_File     PREFIX = odbm_
  78
  79 #ifndef NULL
  80 #  define NULL 0
  81 #endif
  82
  83 ODBM_File
  84 odbm_TIEHASH(dbtype, filename, flags, mode)
  85         char *          dbtype
  86         char *          filename
  87         int             flags
  88         int             mode
  89         CODE:
  90         {
  91             char *tmpbuf;
  92             void * dbp ;
  93             if (dbmrefcnt++)
  94                 croak("Old dbm can only open one database");
  95             New(0, tmpbuf, strlen(filename) + 5, char);
  96             SAVEFREEPV(tmpbuf);
  97             sprintf(tmpbuf,"%s.dir",filename);
  98             if (stat(tmpbuf, &PL_statbuf) < 0) {
  99                 if (flags & O_CREAT) {
 100                     if (mode < 0 || close(creat(tmpbuf,mode)) < 0)
 101                         croak("ODBM_File: Can't create %s", filename);
 102                     sprintf(tmpbuf,"%s.pag",filename);
 103                     if (close(creat(tmpbuf,mode)) < 0)
 104                         croak("ODBM_File: Can't create %s", filename);
 105                 }
 106                 else
 107                     croak("ODBM_FILE: Can't open %s", filename);
 108             }
 109             dbp = (void*)(dbminit(filename) >= 0 ? &dbmrefcnt : 0);
 110             RETVAL = (ODBM_File)safemalloc(sizeof(ODBM_File_type)) ;
 111             Zero(RETVAL, 1, ODBM_File_type) ;
 112             RETVAL->dbp = dbp ;
 113             ST(0) = sv_mortalcopy(&PL_sv_undef);
 114             sv_setptrobj(ST(0), RETVAL, dbtype);
 115         }
 116
 117 void
 118 DESTROY(db)
 119         ODBM_File       db
 120         CODE:
 121         dbmrefcnt--;
 122         dbmclose();
 123         safefree(db);
 124
 125 datum_value
 126 odbm_FETCH(db, key)
 127         ODBM_File       db
 128         datum_key       key
 129
 130 int
 131 odbm_STORE(db, key, value, flags = DBM_REPLACE)
 132         ODBM_File       db
 133         datum_key       key
 134         datum_value     value
 135         int             flags
 136     CLEANUP:
 137         if (RETVAL) {
 138             if (RETVAL < 0 && errno == EPERM)
 139                 croak("No write permission to odbm file");
 140             croak("odbm store returned %d, errno %d, key \"%s\"",
 141                         RETVAL,errno,key.dptr);
 142         }
 143
 144 int
 145 odbm_DELETE(db, key)
 146         ODBM_File       db
 147         datum_key       key
 148
 149 datum_key
 150 odbm_FIRSTKEY(db)
 151         ODBM_File       db
 152
 153 datum_key
 154 odbm_NEXTKEY(db, key)
 155         ODBM_File       db
 156         datum_key       key
 157
 158
 159 #define setFilter(type)                                 \
 160         {                                               \
 161             if (db->type)                               \
 162                 RETVAL = sv_mortalcopy(db->type) ;      \
 163             ST(0) = RETVAL ;                            \
 164             if (db->type && (code == &PL_sv_undef)) {   \
 165                 SvREFCNT_dec(db->type) ;                \
 166                 db->type = Nullsv ;                     \
 167             }                                           \
 168             else if (code) {                            \
 169                 if (db->type)                           \
 170                     sv_setsv(db->type, code) ;          \
 171                 else                                    \
 172                     db->type = newSVsv(code) ;          \
 173             }                                           \
 174         }
 175
 176
 177
 178 SV *
 179 filter_fetch_key(db, code)
 180         ODBM_File       db
 181         SV *            code
 182         SV *            RETVAL = &PL_sv_undef ;
 183         CODE:
 184             setFilter(filter_fetch_key) ;
 185
 186 SV *
 187 filter_store_key(db, code)
 188         ODBM_File       db
 189         SV *            code
 190         SV *            RETVAL =  &PL_sv_undef ;
 191         CODE:
 192             setFilter(filter_store_key) ;
 193
 194 SV *
 195 filter_fetch_value(db, code)
 196         ODBM_File       db
 197         SV *            code
 198         SV *            RETVAL =  &PL_sv_undef ;
 199         CODE:
 200             setFilter(filter_fetch_value) ;
 201
 202 SV *
 203 filter_store_value(db, code)
 204         ODBM_File       db
 205         SV *            code
 206         SV *            RETVAL =  &PL_sv_undef ;
 207         CODE:
 208             setFilter(filter_store_value) ;
 209