ext/ODBM_File/ODBM_File.xs

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