Changeset 15586

Show
Ignore:
Timestamp:
20.05.2008 11:16:23 (11 years ago)
Author:
mdewsnip
Message:

(Adding new DB support) Changed userdbclass and keydbclass so they can use a general dbclass rather than specifically using gdbmclass.

Location:
gsdl/trunk/src/recpt
Files:
2 modified

Legend:

Unmodified
Added
Removed
  • gsdl/trunk/src/recpt/userdb.cpp

    r15207 r15586  
    2626#include "gsdlconf.h" 
    2727#include "userdb.h" 
     28#include "gdbmclass.h" 
    2829#include "gsdltimes.h" 
    2930#include "fileutil.h" 
     
    7879{ 
    7980  storeduserdbfilename = userdbfilename; 
    80   activated = (!userdb.opendatabase(storeduserdbfilename, GDBM_READER, 1000, true)) ? false : true; 
     81  userdb = new gdbmclass(); 
     82  activated = (!userdb->opendatabase(storeduserdbfilename, DB_READER, 1000, true)) ? false : true; 
    8183  if (activated == false)  
    8284    { 
    83       activated = (!userdb.opendatabase(storeduserdbfilename, GDBM_WRCREAT, 1000, true)) ? false : true; 
     85      activated = (!userdb->opendatabase(storeduserdbfilename, DB_WRITER_CREATE, 1000, true)) ? false : true; 
    8486      if (activated == true) 
    8587        { 
    86           userdb.closedatabase(); 
    87           activated = (!userdb.opendatabase(storeduserdbfilename, GDBM_READER, 1000, true)) ? false : true; 
     88          userdb->closedatabase(); 
     89          activated = (!userdb->opendatabase(storeduserdbfilename, DB_READER, 1000, true)) ? false : true; 
    8890        } 
    8991    } 
     
    9294} 
    9395 
    94 userdbclass::userdbclass(const gdbmclass &external_userdb) 
    95 { 
    96   userdb = external_userdb; 
    97   activated = true; 
    98   external_db = true; 
    99 } 
    100  
    10196userdbclass::~userdbclass() 
    10297{ 
    103   if (external_db == false) { userdb.closedatabase();} 
     98  if (external_db == false) 
     99  { 
     100    userdb->closedatabase(); 
     101    delete userdb; 
     102  } 
    104103} 
    105104 
     
    207206      infodbclass info; 
    208207      // See if we can get the user's infomration 
    209       if (userdb.getinfo (username, info))  
     208      if (userdb->getinfo (username, info))  
    210209        { 
    211210          userinfo.username = info["username"]; 
     
    248247      info["groups"] = userinfo.groups; 
    249248      info["comment"] = userinfo.comment; 
    250       userdb.closedatabase(); 
    251       userdb.opendatabase(storeduserdbfilename, GDBM_WRCREAT, 1000, true); 
    252       int result = (userdb.setinfo (username, info)) ? ERRNO_SUCCEED : ERRNO_GDBMACTIONFILED; 
    253       userdb.closedatabase(); 
    254       userdb.opendatabase(storeduserdbfilename, GDBM_READER, 1000, true);          
     249      userdb->closedatabase(); 
     250      userdb->opendatabase(storeduserdbfilename, DB_WRITER_CREATE, 1000, true); 
     251      int result = (userdb->setinfo (username, info)) ? ERRNO_SUCCEED : ERRNO_DBACTIONFAILED; 
     252      userdb->closedatabase(); 
     253      userdb->opendatabase(storeduserdbfilename, DB_READER, 1000, true);          
    255254      return  result; 
    256255    } 
     
    278277    { 
    279278      infodbclass info; 
    280       if (userdb.getinfo (userinfo.username, info))  
     279      if (userdb->getinfo (userinfo.username, info))  
    281280        { 
    282281          // There is an existing username already 
     
    297296    { 
    298297      infodbclass info; 
    299       if (userdb.getinfo (userinfo.username, info))  
     298      if (userdb->getinfo (userinfo.username, info))  
    300299        { 
    301300          return set_user_info(userinfo.username, userinfo); 
     
    315314  if (activated == true) 
    316315    { 
    317       userdb.closedatabase(); 
    318       userdb.opendatabase(storeduserdbfilename, GDBM_WRCREAT, 1000, true); 
    319       userdb.deletekey (username); 
    320       userdb.closedatabase(); 
    321       userdb.opendatabase(storeduserdbfilename, GDBM_READER, 1000, true); 
     316      userdb->closedatabase(); 
     317      userdb->opendatabase(storeduserdbfilename, DB_WRITER_CREATE, 1000, true); 
     318      userdb->deletekey (username); 
     319      userdb->closedatabase(); 
     320      userdb->opendatabase(storeduserdbfilename, DB_READER, 1000, true); 
    322321      return ERRNO_SUCCEED; 
    323322    } 
     
    333332    { 
    334333      userinfo_array.erase(userinfo_array.begin(), userinfo_array.end()); 
    335       text_t user = userdb.getfirstkey(); 
     334      text_t user = userdb->getfirstkey(); 
    336335      while (!user.empty()) { 
    337336        userinfo_t one_userinfo; 
     
    339338        if (returned != ERRNO_SUCCEED) return returned; 
    340339        userinfo_array.push_back(one_userinfo); 
    341         user = userdb.getnextkey(user); 
     340        user = userdb->getnextkey(user); 
    342341      } 
    343342      return ERRNO_SUCCEED; 
     
    355354      userlist.erase (userlist.begin(), userlist.end()); 
    356355       
    357       text_t user = userdb.getfirstkey (); 
     356      text_t user = userdb->getfirstkey (); 
    358357      while (!user.empty()) { 
    359358        userlist.push_back(user); 
    360         user = userdb.getnextkey (user); 
     359        user = userdb->getnextkey (user); 
    361360      } 
    362361      return ERRNO_SUCCEED; 
     
    374373{ 
    375374  storedkeydbfilename = keydbfilename; 
    376   activated = keydb.opendatabase(storedkeydbfilename, GDBM_READER, 1000, true); 
     375  keydb = new gdbmclass(); 
     376  activated = keydb->opendatabase(storedkeydbfilename, DB_READER, 1000, true); 
    377377  if (activated == false)  
    378378    { 
    379       activated = keydb.opendatabase(storedkeydbfilename, GDBM_WRCREAT, 1000, true); 
     379      activated = keydb->opendatabase(storedkeydbfilename, DB_WRITER_CREATE, 1000, true); 
    380380      if (activated == true) 
    381381        { 
    382           keydb.closedatabase(); 
    383           activated = keydb.opendatabase(storedkeydbfilename, GDBM_READER, 1000, true); 
     382          keydb->closedatabase(); 
     383          activated = keydb->opendatabase(storedkeydbfilename, DB_READER, 1000, true); 
    384384        } 
    385385    } 
     
    387387} 
    388388 
    389 keydbclass::keydbclass(const gdbmclass &external_keydb) 
    390 { 
    391   keydb = external_keydb; 
    392   activated = true; 
    393   external_db = true; 
    394 } 
    395  
    396389keydbclass::~keydbclass() 
    397390{ 
    398   if (external_db == false) { keydb.closedatabase();} 
    399 } 
     391  if (external_db == false) 
     392  { 
     393    keydb->closedatabase(); 
     394    delete keydb; 
     395  } 
     396} 
     397 
    400398// generates a random key for the user, stores it in the database and 
    401399// returns it so that it can be used in page generation 
     
    423421        // make sure this key is not in the database 
    424422        crypt_userkey = userdbclass::crypt_text(userkey); 
    425         if (keydb.exists (crypt_userkey)) userkey.clear(); 
     423        if (keydb->exists (crypt_userkey)) userkey.clear(); 
    426424      } while (userkey.empty()); 
    427425       
     
    431429      keydata["time"] = time2text(time(NULL)); 
    432430       
    433       keydb.closedatabase(); 
    434       keydb.opendatabase(storedkeydbfilename, GDBM_WRCREAT, 1000, true); 
    435       if (!keydb.setinfo (crypt_userkey, keydata))  
     431      keydb->closedatabase(); 
     432      keydb->opendatabase(storedkeydbfilename, DB_WRITER_CREATE, 1000, true); 
     433      if (!keydb->setinfo (crypt_userkey, keydata))  
    436434        { 
    437435          userkey.clear(); // failed 
    438436        } 
    439       keydb.closedatabase(); 
    440       keydb.opendatabase(storedkeydbfilename, GDBM_READER, 1000, true);  
     437      keydb->closedatabase(); 
     438      keydb->opendatabase(storedkeydbfilename, DB_READER, 1000, true);  
    441439       
    442440      return userkey; 
     
    463461      text_t crypt_key = userdbclass::crypt_text(key); 
    464462      infodbclass info; 
    465       if (keydb.getinfo (crypt_key, info))  { 
     463      if (keydb->getinfo (crypt_key, info))  { 
    466464        if (info["user"] == thisuser.username) { 
    467465          time_t keycreation = text2time (info["time"]); 
     
    470468            // succeeded, update the key's time 
    471469            info["time"] = time2text(time(NULL)); 
    472             keydb.closedatabase(); 
    473             keydb.opendatabase(storedkeydbfilename, GDBM_WRCREAT, 1000, true); 
    474             keydb.setinfo (crypt_key, info); 
    475             keydb.closedatabase(); 
    476             keydb.opendatabase(storedkeydbfilename, GDBM_READER, 1000, true);  
     470            keydb->closedatabase(); 
     471            keydb->opendatabase(storedkeydbfilename, DB_WRITER_CREATE, 1000, true); 
     472            keydb->setinfo (crypt_key, info); 
     473            keydb->closedatabase(); 
     474            keydb->opendatabase(storedkeydbfilename, DB_READER, 1000, true);  
    477475            return true; 
    478476          } 
     
    492490      // get a list of keys created more than keydecay seconds agon 
    493491      text_tarray oldkeys; 
    494       text_t key = keydb.getfirstkey (); 
     492      text_t key = keydb->getfirstkey (); 
    495493      infodbclass info; 
    496494      time_t timenow = text2time(time2text(time(NULL))); 
    497495      time_t keycreation = (time_t)-1; 
    498496      while (!key.empty()) { 
    499         if (keydb.getinfo (key, info))  { 
     497        if (keydb->getinfo (key, info))  { 
    500498          keycreation = text2time (info["time"]); 
    501499          if (keycreation != (time_t)-1 && difftime (timenow, keycreation) > keydecay) { 
     
    505503        } 
    506504         
    507         key = keydb.getnextkey (key); 
     505        key = keydb->getnextkey (key); 
    508506      } 
    509507       
    510508      // delete the old keys 
    511509      if (oldkeys.size() > 0) { 
    512     keydb.closedatabase(); 
    513     keydb.opendatabase(storedkeydbfilename, GDBM_WRCREAT, 1000, true); 
     510    keydb->closedatabase(); 
     511    keydb->opendatabase(storedkeydbfilename, DB_WRITER_CREATE, 1000, true); 
    514512    text_tarray::iterator keys_here = oldkeys.begin(); 
    515513    text_tarray::iterator keys_end = oldkeys.end(); 
    516514    while (keys_here != keys_end) { 
    517       keydb.deletekey(*keys_here); 
     515      keydb->deletekey(*keys_here); 
    518516      ++keys_here; 
    519517    } 
    520     keydb.closedatabase(); 
    521     keydb.opendatabase(storedkeydbfilename, GDBM_READER, 1000, true); 
     518    keydb->closedatabase(); 
     519    keydb->opendatabase(storedkeydbfilename, DB_READER, 1000, true); 
    522520      } 
    523521    } 
  • gsdl/trunk/src/recpt/userdb.h

    r15432 r15586  
    3434#define ERRNO_MISSINGPASSWORD  -4 
    3535#define ERRNO_PASSWORDMISMATCH -5 
    36 #define ERRNO_GDBMACTIONFILED  -6 
     36#define ERRNO_DBACTIONFAILED   -6 
    3737 
    3838 
    39 #include "gdbmclass.h" 
     39#include "dbclass.h" 
    4040 
    4141// The user information object and it provides basic functions for the information object, such as clear and copy (=) functions; 
     
    6161 protected: 
    6262  // The internal storage for the userdbfilename and the userdb object 
    63   gdbmclass userdb; 
     63  dbclass* userdb; 
    6464  bool external_db; 
    6565  bool activated; 
     
    6868 public: 
    6969  userdbclass (const text_t &userdbfilename); 
    70   userdbclass (const gdbmclass &external_userdb); 
    7170  virtual ~userdbclass(); 
    7271 
     
    121120 protected: 
    122121  // The internal storage for the userdbfilename and the userdb object 
    123   gdbmclass keydb; 
     122  dbclass* keydb; 
    124123  bool external_db; 
    125124  bool activated; 
     
    128127 public: 
    129128  keydbclass (const text_t &keydbfilename); 
    130   keydbclass (const gdbmclass &external_keydb); 
    131129  virtual ~keydbclass(); 
    132130  // functions dealing with databases of temporary keys