Commit e11addf7 authored by jan.koester's avatar jan.koester
Browse files

fixed session.cpp

parent 0556bb7c
Loading
Loading
Loading
Loading
Loading
+26 −26
Changes for src/authdb.cpp: 26 added lines, 26 removed lines.
Original line number Diff line number Diff line
@@ -331,13 +331,12 @@ namespace authdb {
            brd=rd;
        }
VALUEFOUND:
        delete user;
        return brd;
    }

    AuthData::AuthData(const uuid_t id){
         Data = new struct AuthData::Record;
         memset(Data,0,sizeof(AuthData::Record));
         Data = std::make_shared<AuthData::Record>();
         memset(Data.get(),0,sizeof(AuthData::Record));
         uuid_copy(Data->uuid,id);
         Data->start=0xFE;
         Data->storage=EmptyStorage;
@@ -349,25 +348,26 @@ VALUEFOUND:
    }

    AuthData::AuthData(const AuthData &src) : AuthData(src.Data->uuid){
        AuthData *dest=this;
        std::shared_ptr<AuthData> dest(this);

        for(const AuthData *cursrc=&src; cursrc; cursrc=cursrc->next()){
            memcpy(dest->Data,cursrc->Data,sizeof(AuthData::Record));
        for(std::shared_ptr<AuthData> cursrc=std::make_shared<AuthData>(src); cursrc!=nullptr;
            cursrc=cursrc->_next){

            memcpy(dest->Data.get(),cursrc->Data.get(),sizeof(AuthData::Record));
            dest->Data->datasize=cursrc->Data->datasize;
            dest->Data->data=new char[dest->Data->datasize];
            memcpy(dest->Data->data,cursrc->Data->data,cursrc->Data->datasize);
            if(cursrc->next()){
                dest->_next=new AuthData(cursrc->Data->uuid);
                dest->_next=std::make_shared<AuthData>(cursrc->Data->uuid);
                dest=dest->_next;
            }
        }
    }

    AuthData::~AuthData(){
        delete Data;
    }

    AuthData *AuthData::next() const{
    std::shared_ptr<AuthData> AuthData::next() const{
        return _next;
    };

@@ -377,10 +377,10 @@ VALUEFOUND:
        return false;
    };

    AuthData *AuthData::append(const AuthData &src){
        AuthData *curec=this,*next=this;
    std::shared_ptr<AuthData> AuthData::append(const AuthData &src){
        std::shared_ptr<AuthData> curec(this),next(this);
        if(!curec->_next && curec->Data->datasize==0){
            for(const AuthData *cursrc=&src; cursrc; cursrc=cursrc->next()){
            for(std::shared_ptr<AuthData> cursrc=std::make_shared<AuthData>(src); cursrc; cursrc=cursrc->next()){
                next=next->append(*cursrc->Data);
            }
            return curec;
@@ -388,7 +388,7 @@ VALUEFOUND:

        while(curec){
            if(!curec->_next){
                curec->_next=new AuthData(src);
                curec->_next= std::make_shared<AuthData>(src);
                curec=curec->_next;
                break;
            }
@@ -398,11 +398,11 @@ VALUEFOUND:
        return curec;
    }

    AuthData *AuthData::append(const AuthData::Record &src){
        AuthData *curec=this;
    std::shared_ptr<AuthData> AuthData::append(const AuthData::Record &src){
        std::shared_ptr<AuthData> curec(this);

        if(!curec->_next && curec->Data->datasize==0){
            memcpy(curec->Data,&src,sizeof(AuthData::Record));
            memcpy(curec->Data.get(),&src,sizeof(AuthData::Record));
            curec->Data->data=new char[curec->Data->datasize];
            memcpy(curec->Data->data,src.data,curec->Data->datasize);
            return curec;
@@ -410,7 +410,7 @@ VALUEFOUND:

        while(curec){
            if(!curec->_next){
                curec->_next=new AuthData(Data->uuid);
                curec->_next=std::make_shared<AuthData>(Data->uuid);
                curec=curec->_next;
                curec->append(src);
                break;
@@ -447,27 +447,27 @@ VALUEFOUND:
    bool editRecord(AuthBackend &backend,AuthData &rec,int type){
        AuthData old(rec.Data->uuid);

        std::vector<AuthData::Record*> changemap; //use fieldname;
        std::vector<AuthData::Record*> newmap;
        std::vector<std::shared_ptr<AuthData::Record>> changemap; //use fieldname;
        std::vector<std::shared_ptr<AuthData::Record>> newmap;

        getRecord(backend,old,type);

        for(const AuthData *curdat=&rec; curdat; curdat=curdat->_next){
        for(std::shared_ptr<AuthData> curdat=std::make_shared<AuthData>(rec); curdat; curdat=curdat->_next){
            bool newentry=true;
            if(rec.Data->datasize==0)
                continue;

            for(const AuthData *olddat=&old; olddat; olddat=olddat->_next){
            for(std::shared_ptr<AuthData> olddat=std::make_shared<AuthData>(old); olddat; olddat=olddat->_next){
                if(uuid_compare(olddat->Data->uuid,curdat->Data->uuid)==0
                    && strcmp(olddat->Data->fieldname,curdat->Data->fieldname)==0
                ){
                    size_t end = olddat->Data->datasize;
                    if(end!=curdat->Data->datasize){
                        changemap.push_back(curdat->Data);
                        changemap.emplace_back(curdat->Data);
                    }else{
                        for(size_t i=0; i<end; ++i){
                            if(olddat->Data->data[i]!=curdat->Data->data[i]){
                                changemap.push_back(curdat->Data);
                                changemap.emplace_back(curdat->Data);
                                break;
                            }
                        }
@@ -477,14 +477,14 @@ VALUEFOUND:
            }

            if(newentry){
                newmap.push_back(curdat->Data);
                newmap.emplace_back(curdat->Data);
            }

        }

        for(auto newel : newmap){
            backend.setPos(backend.end());
            backend.write((unsigned char*)newel,sizeof(AuthData::Record));;
            backend.write((unsigned char*)newel.get(),sizeof(AuthData::Record));;
            backend.write((unsigned char*)newel->data,newel->datasize);
        }

@@ -499,7 +499,7 @@ VALUEFOUND:
                backend.read((unsigned char*)rdrec,sizeof(AuthData::Record));
                if(uuid_compare(rdrec->uuid,rec.Data->uuid)==0 && strcmp(rdrec->fieldname,chel->fieldname)==0){
                    backend.setPos(backend.end());
                    backend.write((const unsigned char*)chel,sizeof(AuthData::Record));
                    backend.write((const unsigned char*)chel.get(),sizeof(AuthData::Record));
                    backend.write((const unsigned char*)chel->data,chel->datasize);
                    size_t dsize=rdrec->datasize;
                    memset(rdrec,0,sizeof(AuthData::Record));
+18 −16
Changes for src/authdb.h: 18 added lines, 16 removed lines.
Original line number Diff line number Diff line
@@ -26,6 +26,7 @@
 *******************************************************************************/

#include <cstring>
#include <memory>

#include <uuid/uuid.h>

@@ -54,7 +55,7 @@ namespace authdb {

        ~AuthData();

        AuthData *next() const;
        std::shared_ptr<AuthData> next() const;

        struct Record {
            char   start = 0xFE;
@@ -65,17 +66,18 @@ namespace authdb {
            size_t datasize = 0;
            char  *data = nullptr;
            size_t count = 0;
        } *Data;
        };

        std::shared_ptr<Record> Data;

        bool empty();

        AuthData *append(const AuthData &src);
        AuthData *append(const AuthData::Record &src);
        std::shared_ptr<AuthData> append(const AuthData &src);
        std::shared_ptr<AuthData> append(const AuthData::Record &src);

    protected:
        AuthData *_next;
        std::shared_ptr<AuthData> _next;
    private:

        friend    int  searchValue(authdb::AuthBackend &backend,const char*fieldname,const char *value);
        friend    bool getRecord(authdb::AuthBackend &backend,AuthData &rec,int type);
        friend    bool editRecord(AuthBackend &backend,AuthData &rec,int type);
@@ -83,11 +85,11 @@ namespace authdb {
    };

    template<class T,class Y>
    void setAuthData(int type,int storage,AuthData *dat,AuthData::Record **varclass,
    void setAuthData(int type,int storage,AuthData *dat,std::shared_ptr<AuthData::Record> varclass,
                     const char *varname,const T *value,size_t count){
        AuthData::Record *target=*varclass;
        std::shared_ptr<AuthData::Record> target(varclass);

        const AuthData *curec=dat;
        std::shared_ptr<AuthData> curec(dat);

        uuid_t gid;
        uuid_copy(gid,dat->Data->uuid);
@@ -114,7 +116,7 @@ namespace authdb {
            target=dat->append(tmp)->Data;
        }

        memset(target,0,sizeof(AuthData::Record));
        memset(target.get(),0,sizeof(AuthData::Record));

        target->start=0xFE;
        uuid_copy(target->uuid,gid);
@@ -136,18 +138,18 @@ namespace authdb {
        }


        *varclass=target;
        varclass=target;
    }

    template<class T>
    inline const T *getAuthData(int type,int storage,const AuthData *dat,AuthData::Record **varclass,const char *varname){
        if(*varclass && (*varclass)->data ){
            return (T*)(*varclass)->data;
    inline const T *getAuthData(int type,int storage,class AuthData *dat,std::shared_ptr<AuthData::Record> varclass,const char *varname){
        if(varclass !=nullptr && varclass->data ){
            return (T*)varclass->data;
        }else{
            for(const AuthData *curdat=dat; curdat; curdat=curdat->next()){
            for(std::shared_ptr<AuthData> curdat(dat); curdat; curdat=curdat->next()){
                if(curdat->Data && curdat->Data->type==type && curdat->Data->storage==storage
                    && strcmp(curdat->Data->fieldname,varname)==0){
                    *varclass=curdat->Data;
                    varclass=curdat->Data;
                    return (T*)curdat->Data->data;
                }
            }
+6 −6
Changes for src/client.cpp: 6 added lines, 6 removed lines.
Original line number Diff line number Diff line
@@ -38,23 +38,23 @@ authdb::ClientData::~ClientData()

void authdb::ClientData::setKey(const char *key){
    setAuthData<char,char>(DataType::ClientData,StorageType::TextStorage,
                           this,&ClientKey,"clientkey",key,strlen(key)+1);
                           this,ClientKey,"clientkey",key,strlen(key)+1);
}

const char *authdb::ClientData::getKey(){
    return getAuthData<char>(DataType::ClientData,StorageType::TextStorage,
                             this,&ClientKey,"clientkey");
                             this,ClientKey,"clientkey");
}

void authdb::ClientData::setName(const char* name){
    setAuthData<char,char>(DataType::ClientData,StorageType::TextStorage,
                           this,&ClientName,"clientname",name,strlen(name)+1);
                           this,ClientName,"clientname",name,strlen(name)+1);
}


const char *authdb::ClientData::getName(){
    return getAuthData<char>(DataType::ClientData,StorageType::TextStorage,
                             this,&ClientName,"clientname");
                             this,ClientName,"clientname");
}

void authdb::Client::create(AuthBackend& backend, class ClientData* data){
@@ -71,10 +71,10 @@ void authdb::Client::create(AuthBackend& backend, class ClientData* data){

    size_t wd=backend.end();

    for(AuthData *curec=data; curec; curec=curec->next()){
    for(std::shared_ptr<AuthData> curec(data); curec; curec=curec->next()){
        curec->Data->type=ClientData;
        backend.setPos(wd);
        backend.write((unsigned char*)curec->Data,sizeof(struct AuthData::Record));
        backend.write((unsigned char*)curec->Data.get(),sizeof(struct AuthData::Record));
        backend.write((unsigned char*)curec->Data->data,curec->Data->datasize);
        wd=backend.end();
    }
+2 −2
Changes for src/client.h: 2 added lines, 2 removed lines.
Original line number Diff line number Diff line
@@ -42,8 +42,8 @@ namespace authdb {
        void setKey(const char *key);
        const char *getKey();
    private:
        AuthData::Record *ClientName;
        AuthData::Record *ClientKey;
        std::shared_ptr<AuthData::Record> ClientName;
        std::shared_ptr<AuthData::Record> ClientKey;
        friend class Client;
    };

+8 −8
Changes for src/domain.cpp: 8 added lines, 8 removed lines.
Original line number Diff line number Diff line
@@ -44,31 +44,31 @@ authdb::DomainData::~DomainData(){

void authdb::DomainData::setDomainName(const char* name){
    setAuthData<char,char>(DataType::DomainData,StorageType::TextStorage,
                                 this,&_name,"domainname",name,strlen(name));
                                 this,_name,"domainname",name,strlen(name));
}

const char * authdb::DomainData::getDomainName(){
    return getAuthData<char>(DataType::DomainData,StorageType::TextStorage,this,&_name,"domainname");
    return getAuthData<char>(DataType::DomainData,StorageType::TextStorage,this,_name,"domainname");
}


void authdb::DomainData::setStorageType(const int type){
    setAuthData<int,int>(DataType::DomainData,StorageType::IntStorage,
                                this,&_storageType,"domainstorage",&type,1);
                                this,_storageType,"domainstorage",&type,1);
}

const int authdb::DomainData::getStorageType(){
    return *getAuthData<int>(DataType::DomainData,StorageType::IntStorage,this,&_storageType,"domainstorage");
    return *getAuthData<int>(DataType::DomainData,StorageType::IntStorage,this,_storageType,"domainstorage");
}

void authdb::DomainData::setStorageOptions(const char *opts){
    return setAuthData<char,char>(DataType::DomainData,StorageType::TextStorage,
                                        this,&_storageOptions,"domainoptions",opts,strlen(opts));
                                        this,_storageOptions,"domainoptions",opts,strlen(opts));
}

const char * authdb::DomainData::getStorageOptions(){
    return getAuthData<char>(DataType::DomainData,StorageType::TextStorage,
                             this,&_storageOptions,"domainoptions");
                             this,_storageOptions,"domainoptions");
}

void authdb::Domain::create(authdb::AuthBackend& backend,class DomainData *data){
@@ -86,10 +86,10 @@ void authdb::Domain::create(authdb::AuthBackend& backend,class DomainData *data)

    size_t wd=backend.end();

    for(AuthData *curec=data; curec; curec=curec->next()){
    for(std::shared_ptr<AuthData> curec(data); curec; curec=curec->next()){
         curec->Data->type=DataType::DomainData;
         backend.setPos(wd);
         backend.write((unsigned char*)curec->Data,sizeof(struct AuthData::Record));
         backend.write((unsigned char*)curec->Data.get(),sizeof(struct AuthData::Record));
         backend.write((unsigned char*)curec->Data->data,curec->Data->datasize);
         wd=backend.end();
    }
Loading