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

now use templates

parent 9ee106d3
Loading
Loading
Loading
Loading
Loading
+14 −5
Changes for src/authdb.h: 14 added lines, 5 removed lines.
Original line number Diff line number Diff line
@@ -30,6 +30,7 @@
#include <uuid/uuid.h>

#include "backend.h"
#include "types.h"

#pragma once

@@ -63,6 +64,7 @@ namespace authdb {
            char   fieldname[255];
            size_t datasize = 0;
            char  *data;
            size_t count = 0;
        } *Data;

        bool empty();
@@ -81,7 +83,8 @@ namespace authdb {
    };

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

        const AuthData *curec=dat;
@@ -120,13 +123,19 @@ namespace authdb {

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

        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),&value[i],sizeof(Y));
            memcpy(start+(sizeof(Y)*i),vstart+(sizeof(Y)*i),sizeof(Y));
        }


        *varclass=target;
    }

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

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

const char * authdb::DomainData::getDomainName(){
@@ -53,7 +53,7 @@ const char * authdb::DomainData::getDomainName(){


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

@@ -62,8 +62,8 @@ const int authdb::DomainData::getStorageType(){
}

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

const char * authdb::DomainData::getStorageOptions(){
+13 −143
Changes for src/gpo.cpp: 13 added lines, 143 removed lines.
Original line number Diff line number Diff line
@@ -30,166 +30,36 @@
#include "types.h"
#include "gpo.h"

namespace authdb {
        inline void setGpoData(AuthData *dat,AuthData::Record **varclass,const char *varname,const char *value){
        AuthData::Record *target=*varclass;

        AuthData *curec=dat;

        uuid_t fuuid;

        uuid_copy(fuuid,dat->Data->uuid);

        if(!target){
            while(curec){
                if(curec->Data->type == authdb::PolicyData &&
                    uuid_compare(curec->Data->uuid,fuuid)==0 &&
                    strcmp(curec->Data->fieldname,varname)==0
                ){

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

        if(!target){
            target=new AuthData::Record;
            *varclass=dat->append(*target)->Data;
            target=*varclass;
        }

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

        target->start=0xFE;
        uuid_copy(target->uuid,fuuid);
        target->type=DataType::PolicyData;
        target->storage=StorageType::TextStorage;

        snprintf(target->fieldname,255,"%s",varname);
        target->datasize=strlen(value)+1;
        target->data= new char[target->datasize];
        strcpy(target->data,value);


    }

    inline const char *getGpoData(const AuthData *dat,AuthData::Record **varclass,const char *varname){
        if(*varclass && (*varclass)->data ){
            return (*varclass)->data;
        }else{
            for(const AuthData *curdat=dat; curdat; curdat=curdat->next()){
                if(curdat->Data && curdat->Data->storage == StorageType::TextStorage &&
                    curdat->Data->type==DataType::PolicyData
                    && strcmp(curdat->Data->fieldname,varname)==0){
                    *varclass=curdat->Data;
                    return curdat->Data->data;
                }
            }
        }
        std::string err;
        err=varname;
        err+=" data not found !";
        throw(authdb::AuthBackendError(err.c_str()));
    }

    inline void setGpoData(AuthData *dat,AuthData::Record **varclass,const char *varname,bool value){
        AuthData::Record *target=*varclass;

        AuthData *curec=dat;

        uuid_t fuuid;

        uuid_copy(fuuid,dat->Data->uuid);

        if(!target){
            while(curec){
                if(curec->Data->type == authdb::PolicyData &&
                    uuid_compare(curec->Data->uuid,fuuid)==0 &&
                    strcmp(curec->Data->fieldname,varname)==0
                ){

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

        if(!target){
            target=new AuthData::Record;
            *varclass=dat->append(*target)->Data;
            target=*varclass;
        }

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

        target->start=0xFE;
        uuid_copy(target->uuid,fuuid);
        target->type=DataType::PolicyData;
        target->storage=StorageType::BoolStorage;

        snprintf(target->fieldname,255,"%s",varname);
        target->datasize=sizeof(bool);
        target->data= new char[target->datasize];
        memcpy(target->data,&value,target->datasize);
    }

    inline bool getBoolGpoData(const AuthData *dat,AuthData::Record **varclass,const char *varname){
        if(*varclass && (*varclass)->data ){
            return *(*varclass)->data;
        }else{
            for(const AuthData *curdat=dat; curdat; curdat=curdat->next()){
                if(curdat->Data && curdat->Data->storage == StorageType::BoolStorage &&
                    curdat->Data->type==DataType::PolicyData
                    && strcmp(curdat->Data->fieldname,varname)==0){
                    *varclass=curdat->Data;
                    bool ret=false;
                    memcpy(&ret,curdat->Data->data,sizeof(bool));
                    return ret;
                }
            }
        }
        std::string err;
        err=varname;
        err+=" data not found !";
        throw(authdb::AuthBackendError(err.c_str()));
    }
}

void authdb::GpoData::setName(const char* src){
    setGpoData(this,&_Name,"gponame",src);
    setAuthData<char,char>(DataType::PolicyData,StorageType::TextStorage,
                              this,&_Name,"gponame",src,strlen(src));
}

const char * authdb::GpoData::getName(){
    return getGpoData(this,&_Name,"gponame");
    return getAuthData<char>(DataType::PolicyData,StorageType::TextStorage,
                             this,&_Name,"gponame");
}

void authdb::GpoData::setDesc(const char* src){
    setGpoData(this,&_Desc,"gpodesc",src);
    setAuthData<char,char>(DataType::PolicyData,StorageType::TextStorage,
                              this,&_Desc,"gpodesc",src,strlen(src));
}

const char * authdb::GpoData::getDesc(){
    return getGpoData(this,&_Desc,"gpodesc");
    return getAuthData<char>(DataType::PolicyData,StorageType::TextStorage,
                             this,&_Desc,"gpodesc");
}

void authdb::GpoData::setGpoValue(bool dest){
    setGpoData(this,&_GpoDefault,"gpodefault",dest);
void authdb::GpoData::setGpoValue(const bool dest){
    setAuthData<bool,bool>(DataType::PolicyData,StorageType::BoolStorage,
                              this,&_GpoDefault,"gpodefault",&dest,1);
}

bool authdb::GpoData::getGpoValue(){
    return getBoolGpoData(this,&_GpoDefault,"gpodefault");
    return *getAuthData<bool>(DataType::PolicyData,StorageType::BoolStorage,
                              this,&_GpoDefault,"gpodefault");
}



void authdb::GpoData::setAllowed(Allow *allowed){
        AuthData *curec=this;
        uuid_t fuuid;
+1 −1
Changes for src/gpo.h: 1 added line, 1 removed line.
Original line number Diff line number Diff line
@@ -45,7 +45,7 @@ namespace authdb {
        void setDesc(const char *src);
        const char *getDesc();

        void setGpoValue(bool dest);
        void setGpoValue(const bool dest);
        bool getGpoValue();

        struct Allow {
+9 −114
Changes for src/group.cpp: 9 added lines, 114 removed lines.
Original line number Diff line number Diff line
@@ -31,72 +31,6 @@
#include "types.h"
#include "group.h"

namespace authdb{
    inline void setGroupData(AuthData *dat,AuthData::Record **varclass,const char *varname,const char *value){
        AuthData::Record *target=*varclass;

        const AuthData *curec=dat;

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

        if(!target){
            while(curec){
                if(curec->Data->type == authdb::GroupData &&
                    uuid_compare(curec->Data->uuid,target->uuid)==0 &&
                    strcmp(curec->Data->fieldname,varname)==0
                ){

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

        if(!target){
            AuthData::Record tmp;
            target=dat->append(tmp)->Data;
        }

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

        target->start=0xFE;
        uuid_copy(target->uuid,gid);
        target->type=DataType::GroupData;
        target->storage=StorageType::TextStorage;

        snprintf(target->fieldname,255,"%s",varname);
        target->datasize=strlen(value)+1;
        target->data= new char[target->datasize];
        strcpy(target->data,value);

        *varclass=target;
    }

    inline const char *getGroupData(const AuthData *dat,AuthData::Record **varclass,const char *varname){
        if(*varclass && (*varclass)->data ){
            return (*varclass)->data;
        }else{
            for(const AuthData *curdat=dat; curdat; curdat=curdat->next()){
                if(curdat->Data && curdat->Data->storage == StorageType::TextStorage &&
                    curdat->Data->type==DataType::GroupData
                    && strcmp(curdat->Data->fieldname,varname)==0){
                    *varclass=curdat->Data;
                    return curdat->Data->data;
                }
            }
        }
        std::string err;
        err=varname;
        err+=" data not found !";
        throw(authdb::AuthBackendError(err.c_str()));
    }
};

authdb::GroupData::GroupData(uuid_t gid) : AuthData(gid){
    _Name=nullptr;
    _Members=nullptr;
@@ -112,56 +46,18 @@ authdb::GroupData::~GroupData(){
}

void authdb::GroupData::setName(const char* name){
    setGroupData(this,&_Name,"groupname",name);
    setAuthData<char,char>(DataType::GroupData,StorageType::TextStorage,
                                this,&_Name,"groupname",name,strlen(name));
}

const char* authdb::GroupData::getName(){
    return getGroupData(this,&_Name,"groupname");
    return getAuthData<char>(DataType::GroupData,StorageType::TextStorage,
                             this,&_Name,"groupname");
}

void authdb::GroupData::addMember(const MemberUids &uid){
        AuthData *curec=this;

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

        if(!_Members){
            while(curec){
                if(curec->Data->type == authdb::GroupData &&
                    uuid_compare(curec->Data->uuid,Data->uuid)==0 &&
                    strcmp(curec->Data->fieldname,"groupmembers")==0
                ){
                    _Members=curec->Data;
                    _Members->datasize=0;
                    delete[] _Members->data;
                    _Members->data=nullptr;
                    break;
                }
                curec=curec->next();
            }
        }

        if(!_Members){
            AuthData::Record rec;
            _Members=append(rec)->Data;
        }

        memset(_Members,0,sizeof(AuthData::Record));

        _Members->start=0xFE;
        uuid_copy(_Members->uuid,gid);
        _Members->type=DataType::GroupData;
        _Members->storage=StorageType::BinaryStorage;

        snprintf(_Members->fieldname,255,"%s","groupmembers");
        _Members->datasize = sizeof(GroupData::MemberUids)+(sizeof(uuid_t)*uid.count);
        _Members->data=new char [_Members->datasize];
        memset(_Members->data,0,_Members->datasize);
        memcpy(_Members->data,&uid,sizeof(GroupData::MemberUids));
        char *start =_Members->data+sizeof(GroupData::MemberUids);
        for(int i=0; i< uid.count; ++i){
            memcpy(start+(sizeof(uuid_t)*i),uid.uid[i],sizeof(uuid_t));
        }
    setAuthData<MemberUids,uuid_t>(DataType::GroupData,StorageType::BinaryStorage,
                                this,&_Members,"groupmembers",&uid,uid.count);
}

bool authdb::GroupData::isMember(const uuid_t uid){
@@ -191,14 +87,14 @@ bool authdb::Group::exits(AuthBackend& backend, uuid_t* gid, const char* name, i
        backend.setPos(rd);
        backend.read((unsigned char*)&cur,sizeof(AuthData::Record));
        rd=backend.getPos()+cur.datasize;
        if(strcmp(cur.fieldname,"groupname")==0 ){
        if(cur.type == DataType::GroupData &&
            strcmp(cur.fieldname,"groupname")==0 ){
            cur.data=new char[cur.datasize];
            backend.read((unsigned char*)cur.data,cur.datasize);
            if(name && strcmp(cur.data,name) == 0){
                delete[] cur.data;
                ret=1;
                return true;

            }else if(gid && uuid_compare(cur.uuid,*gid)==0){
                delete[] cur.data;
                ret=2;
@@ -245,8 +141,7 @@ void authdb::Group::info(AuthBackend &backend, class GroupData& dat, size_t &pos
        backend.setPos(pos);
        backend.read((unsigned char*)cur,sizeof(AuthData::Record));
        pos=backend.getPos()+cur->datasize;
        if(cur->type == GroupData && uuid_compare(dat.Data->uuid,cur->uuid) == 0 &&
            strcmp(cur->fieldname,"groupname") == 0
        if(cur->type == GroupData && uuid_compare(dat.Data->uuid,cur->uuid) == 0
        ){

            if(!getRecord(backend,dat,DataType::GroupData))
Loading