Commit 74f4abf2 authored by jan.koester's avatar jan.koester
Browse files

working again

parent 53fbd9f9
Loading
Loading
Loading
Loading
Loading
+19 −23
Changes for src/authdb.cpp: 19 added lines, 23 removed lines.
Original line number Diff line number Diff line
@@ -352,7 +352,7 @@ VALUEFOUND:
            dest->Data.data=new char[dest->Data.datasize];
            memcpy(dest->Data.data,cursrc->Data.data,cursrc->Data.datasize);
            if(cursrc->next()){
                dest->_next=std::make_shared<AuthData>(cursrc->Data.uuid);
                dest->_next=new AuthData(cursrc->Data.uuid);
                dest=dest->next();
            }
        }
@@ -362,7 +362,7 @@ VALUEFOUND:
    }

    AuthData *AuthData::next() const{
        return _next.get();
        return _next;
    };

    bool authdb::AuthData::empty(){
@@ -371,50 +371,46 @@ VALUEFOUND:
        return false;
    };

    const authdb::AuthData& AuthData::append(const AuthData &src){
    authdb::AuthData& AuthData::append(const AuthData &src){
        AuthData *curec=this,*next=this;
        if(!curec->_next && curec->Data.datasize==0){
            for(const AuthData *cursrc=curec; cursrc; cursrc=cursrc->next()){
                *next=static_cast<AuthData>(next->append(static_cast<const AuthData::Record&>(cursrc->Data)));
            for(const AuthData *cursrc=&src; cursrc; cursrc=cursrc->next()){
                next=&next->append(cursrc->Data);
            }
            return *curec;
        }

        while(curec){
            if(!curec->_next){
                curec->_next->append(src);
                curec=curec->next();
                curec->_next=new AuthData(src);
                curec=curec->_next;
                break;
            }
            curec=curec->next();
            curec=curec->_next;
        };

        return *curec;

    }

    const authdb::AuthData& AuthData::append(const AuthData::Record &src){
    authdb::AuthData& AuthData::append(const AuthData::Record &src){
        AuthData *curec=this;

        if(curec->Data.datasize==0){
            uuid_copy(curec->Data.uuid,src.uuid);
            curec->Data.count=src.count;
            snprintf(curec->Data.fieldname,255,"%s",src.fieldname);
            curec->Data.start=src.start;
            curec->Data.storage=src.storage;
            curec->Data.type=src.type;
            curec->Data.datasize=src.datasize;
        if(!curec->_next && curec->Data.datasize==0){
            memcpy(&curec->Data,&src,sizeof(AuthData::Record));
            curec->Data.data=new char[curec->Data.datasize];
            memcpy(curec->Data.data,src.data,curec->Data.datasize);
            return *curec;
        }

        while(curec){
            if(curec->next()){
                curec->_next=std::shared_ptr<AuthData>( new AuthData(curec->Data.uuid));
                curec=curec->next();
            if(!curec->_next){
                curec->_next=new AuthData(Data.uuid);
                curec=curec->_next;
                curec->append(src);
                break;
            }
            curec=curec->next();
            curec=curec->_next;
        };

        return *curec;
@@ -449,12 +445,12 @@ VALUEFOUND:

        getRecord(backend,old,type);

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

            for(std::shared_ptr<AuthData> olddat=std::make_shared<AuthData>(old); olddat; olddat=olddat->_next){
            for(AuthData *olddat=&old; olddat; olddat=olddat->_next){
                if(uuid_compare(olddat->Data.uuid,curdat->Data.uuid)==0
                    && strcmp(olddat->Data.fieldname,curdat->Data.fieldname)==0
                ){
+31 −26
Changes for src/authdb.h: 31 added lines, 26 removed lines.
Original line number Diff line number Diff line
@@ -70,11 +70,11 @@ namespace authdb {

        bool empty();

        const AuthData& append(const AuthData &src);
        const AuthData& append(const AuthData::Record &src);
        AuthData& append(const AuthData &src);
        AuthData& append(const AuthData::Record &src);

    protected:
        std::shared_ptr<AuthData> _next;
        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);
@@ -83,64 +83,69 @@ namespace authdb {
    };

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

        AuthData *curec=dat;

        uuid_t gid;
        uuid_copy(gid,dat->Data.uuid);

        if(!varclass){
        if(!target){
            while(curec){
                if(curec->Data.type == type &&
                    uuid_compare(curec->Data.uuid,gid)==0 &&
                    strcmp(curec->Data.fieldname,varname)==0
                ){

                    varclass.reset(&curec->Data);
                    varclass->datasize=0;
                    delete[] varclass->data;
                    varclass->data=nullptr;
                    target=&curec->Data;
                    target->datasize=0;
                    delete[] target->data;
                    target->data=nullptr;
                    break;
                }
                curec=curec->next();
            }
        }

        if(!varclass){
        if(!target){
            AuthData::Record tmp;
            varclass=std::shared_ptr<AuthData::Record>(new AuthData::Record(dat->append(tmp).Data));
            target=&dat->append(tmp).Data;
        }

        varclass->start=0xFE;
        uuid_copy(varclass->uuid,gid);
        varclass->type=type;
        varclass->storage=storage;
        memset(varclass->fieldname,0,255);
        snprintf(varclass->fieldname,255,"%s",varname);
        varclass->datasize = sizeof(T)+(sizeof(Y)*count);
        varclass->data=new char[varclass->datasize];
        memset(varclass->data,0,varclass->datasize);
        memcpy(varclass->data,(char*)value,sizeof(T));
        memset(target,0,sizeof(AuthData::Record));

        target->start=0xFE;
        uuid_copy(target->uuid,gid);
        target->type=type;
        target->storage=storage;

        snprintf(target->fieldname,255,"%s",varname);
        target->datasize = sizeof(T)+(sizeof(Y)*count);
        target->data=new char[target->datasize];
        memset(target->data,0,target->datasize);
        memcpy(target->data,(char*)value,sizeof(T));

        char *start= (char*) varclass->data+sizeof(T)-sizeof(Y);
        char *start= (char*) target->data+sizeof(T)-sizeof(Y);

        char *vstart = (char*) value+(sizeof(T)-sizeof(Y));

        for(int i=0; i< count; ++i){
            memcpy(start+(sizeof(Y)*i),vstart+(sizeof(Y)*i),sizeof(Y));
        }
        *varclass=target;
    }

    template<class T>
    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;
    inline const T *getAuthData(int type,int storage,class AuthData *dat,AuthData::Record **varclass,const char *varname){
        if(*varclass !=nullptr && (*varclass)->data ){
            return (T*)(*varclass)->data;
        }else{
            for(AuthData *curdat=dat; curdat; curdat=curdat->next()){
                if(curdat->Data.type==type && curdat->Data.storage==storage
                    && strcmp(curdat->Data.fieldname,varname)==0){
                    varclass.reset(&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){
@@ -128,9 +128,9 @@ void authdb::Client::info(AuthBackend& backend, class ClientData& dat, size_t& p
                continue;

            if(strcmp(dat.Data.fieldname,"clientname")==0){
                dat.ClientName=std::make_shared<AuthData::Record>(dat.Data);
                dat.ClientName=&dat.Data;
            }else if(strcmp(dat.Data.fieldname,"clientkey")==0){
                dat.ClientKey=std::make_shared<AuthData::Record>(dat.Data);
                dat.ClientKey=&dat.Data;
            }
        }
        delete cur;
+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:
        std::shared_ptr<AuthData::Record> ClientName;
        std::shared_ptr<AuthData::Record> ClientKey;
        AuthData::Record *ClientName;
        AuthData::Record *ClientKey;
        friend class Client;
    };

+9 −9
Changes for src/domain.cpp: 9 added lines, 9 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){
@@ -169,11 +169,11 @@ void authdb::Domain::info(AuthBackend& backend, class DomainData& dat, size_t& p
                continue;

            if(strcmp(dat.Data.fieldname,"domainname")==0){
                dat._name=std::make_shared<AuthData::Record>(dat.Data);
                dat._name=&dat.Data;
            }else if(strcmp(dat.Data.fieldname,"domainstorage")==0){
                dat._storageType=std::make_shared<AuthData::Record>(dat.Data);
                dat._storageType=&dat.Data;
            }else if(strcmp(dat.Data.fieldname,"domainoptions")==0){
                dat._storageOptions=std::make_shared<AuthData::Record>(dat.Data);
                dat._storageOptions=&dat.Data;
            }
        }
        delete cur;
Loading