Commit 807e8200 authored by jan.koester's avatar jan.koester
Browse files

cleanedup

parent 71afbbad
Loading
Loading
Loading
Loading
Loading
+4 −4
Changes for client/CMakeLists.txt: 4 added lines, 4 removed lines.
Original line number Diff line number Diff line
@@ -6,13 +6,13 @@ include_directories(

add_compile_definitions(DATAPATH="${DATAPATH}")

add_library(client SHARED client.cpp $<TARGET_OBJECTS:authobj>)
add_library(client SHARED client.cpp )

add_library(client-static STATIC client.cpp $<TARGET_OBJECTS:authobj>)
add_library(client-static STATIC client.cpp)

target_link_libraries(client PUBLIC netplus::netplus json-c::json-c httppp::httppp uuid)
target_link_libraries(client PRIVATE $<TARGET_OBJECTS:authobj> PUBLIC confplus::confplus netplus::netplus json-c::json-c httppp::httppp uuid fback)

target_link_libraries(client-static PUBLIC netplus::netplus json-c::json-c httppp::httppp uuid)
target_link_libraries(client-static PRIVATE $<TARGET_OBJECTS:authobj> PUBLIC confplus::confplus netplus::netplus json-c::json-c httppp::httppp uuid fback)

set_target_properties(client PROPERTIES
  INTERFACE_INCLUDE_DIRECTORIES "${CMAKE_INSTALL_PREFIX}/include/authdb"
+5 −4
Changes for src/CMakeLists.txt: 5 added lines, 4 removed lines.
Original line number Diff line number Diff line
@@ -7,8 +7,7 @@ add_compile_definitions(DATAPATH="${DATAPATH}")
add_library(fback SHARED backends/file.cpp)

list(APPEND authdbSrcs
    authdb.cpp
    admin.cpp
    data.cpp
    backend.cpp
    user.cpp
    domain.cpp
@@ -17,7 +16,6 @@ list(APPEND authdbSrcs
    gpo.cpp
    client.cpp
    hash.cpp
    api.cpp
    uuid.cpp
    hash/sha512.cpp
)
@@ -25,6 +23,9 @@ list(APPEND authdbSrcs
add_library( authobj OBJECT ${authdbSrcs})

add_executable(authdb
    admin.cpp
    authdb.cpp
    api.cpp
    $<TARGET_OBJECTS:authobj>
)

@@ -32,5 +33,5 @@ target_link_libraries(authdb PUBLIC fback json-c::json-c httppp::httppp netplus:

install(FILES uuid.h session.h authdb.h backend.h types.h group.h DESTINATION include/authdb)

install(TARGETS fback DESTINATION lib)
install(TARGETS fback DESTINATION lib EXPORT authdbTargets)
install(TARGETS authdb DESTINATION bin)
+0 −214
Changes for src/authdb.cpp: 0 added lines, 214 removed lines.
Original line number Diff line number Diff line
@@ -357,220 +357,6 @@ VALUEFOUND:
        return brd;
    }

    AuthData::AuthData(const uuid_t id){
         uuid_copy(Data.uuid,id);
         Data.start=0xFE;
         Data.storage=EmptyStorage;
         Data.type=DataType::EmptyData;
         Data.fieldname[0]='\0';
         Data.data=nullptr;
         Data.datasize=0;
        _next=nullptr;
    }

    AuthData::AuthData(const AuthData &src) : AuthData(src.Data.uuid){
        AuthData *dest=this;

        for(AuthData* cursrc=dest; cursrc!=nullptr; cursrc=cursrc->next()){
            memcpy(&dest->Data,&cursrc->Data,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=dest->next();
            }
        }
    }

    AuthData::~AuthData(){
    }

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

    bool authdb::AuthData::empty(){
        if(!Data.data)
            return true;
        return false;
    };

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

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

        return *curec;

    }

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

        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=new AuthData(Data.uuid);
                curec=curec->_next;
                curec->append(src);
                break;
            }
            curec=curec->_next;
        };

        return *curec;
    }

    bool getRecord(authdb::AuthBackend &backend,AuthData &rec,int type){
        bool found=false;
        int rd=sizeof(authdb::AuthHeader),end=backend.end();

        while(rd<end){
            AuthData::Record cur;
            backend.setPos(rd);
            backend.read(reinterpret_cast<unsigned char*>(&cur),sizeof(AuthData::Record));
            rd=backend.getPos()+cur.datasize;
            if(uuid_compare(cur.uuid,rec.Data.uuid) == 0 && cur.type == type){
                cur.data=new char[cur.datasize];
                backend.read(reinterpret_cast<unsigned char*>(cur.data),cur.datasize);
                rec.append(cur);
                found=true;
                delete[] cur.data;
            }
        }

        return found;
    }

    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;

        getRecord(backend,old,type);

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

            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
                ){
                    size_t end = olddat->Data.datasize;
                    if(end!=curdat->Data.datasize){
                        changemap.emplace_back(&curdat->Data);
                    }else{
                        for(size_t i=0; i<end; ++i){
                            if(olddat->Data.data[i]!=curdat->Data.data[i]){
                                changemap.emplace_back(&curdat->Data);
                                break;
                            }
                        }
                    }
                    newentry=false;
                }
            }

            if(newentry){
                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->data,newel->datasize);
        }

        const unsigned char zero = 0;


        for(auto chel : changemap){
            size_t rd=sizeof(authdb::AuthHeader),end=backend.end();
            while(rd<end){
                std::shared_ptr<authdb::AuthData::Record> rdrec(new AuthData::Record);
                backend.setPos(rd);
                backend.read(reinterpret_cast<unsigned char*>(rdrec.get()),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->data,chel->datasize);
                    size_t dsize=rdrec->datasize;
                    rdrec->start = 0xFE;
                    rdrec->datasize=dsize;
                    backend.setPos(rd);
                    backend.write(reinterpret_cast<unsigned char*>(rdrec.get()),sizeof(AuthData::Record));
                    for(size_t i =0; i<rdrec->datasize; ++i){
                        backend.write(&zero,1);
                    }
                    rd=backend.getPos();
                }else{
                    rd=backend.getPos()+rdrec->datasize;
                }
            }
        }

        if(!changemap.empty() || !newmap.empty())
            return true;
        return false;
    }

    void delRecord(AuthBackend &backend,const uuid_t uid,int type){
        size_t end=backend.end(),rd=sizeof(AuthHeader);

        if(!uid)
            throw AuthBackendError("user info uid required!");

        while(rd<end){
            std::shared_ptr<authdb::AuthData::Record> cur(new AuthData::Record);
            backend.setPos(rd);
            size_t wr=backend.getPos();
            backend.read(reinterpret_cast<unsigned char*>(cur.get()),sizeof(AuthData::Record));
            rd=backend.getPos()+cur->datasize;
            if(uuid_compare(uid,cur->uuid) == 0 && type == cur->type){
                size_t dsize=cur->datasize;
                cur->start = 0xFE;
                cur->data=new char[dsize];
                memset(cur->data,0,dsize);
                memset(&cur->fieldname,0,255);
                memset(cur->uuid,0,sizeof(uuid_t));
                cur->storage=StorageType::EmptyStorage;
                cur->type=DataType::EmptyData;
                cur->datasize=dsize;
                backend.setPos(wr);
                backend.write(reinterpret_cast<unsigned char*>(cur.get()),sizeof(AuthData::Record));
                const unsigned char zero=0;
                for(size_t i=0; i<dsize; ++i){
                    backend.write(&zero,1);
                }
            }
        }
    }

    DomainBackend::DomainBackend(authdb::AuthBackend &adminbck) : _adminbck(adminbck) {
        _domainbck=nullptr;
    }

src/data.cpp

0 → 100644
+220 −0
Changes for src/data.cpp: 220 added lines, 0 removed lines.
Original line number Diff line number Diff line
#include <vector>
#include <memory>

#include "authdb.h"

namespace authdb {
    AuthData::AuthData(const uuid_t id){
         uuid_copy(Data.uuid,id);
         Data.start=0xFE;
         Data.storage=EmptyStorage;
         Data.type=DataType::EmptyData;
         Data.fieldname[0]='\0';
         Data.data=nullptr;
         Data.datasize=0;
        _next=nullptr;
    }

    AuthData::AuthData(const AuthData &src) : AuthData(src.Data.uuid){
        AuthData *dest=this;

        for(AuthData* cursrc=dest; cursrc!=nullptr; cursrc=cursrc->next()){
            memcpy(&dest->Data,&cursrc->Data,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=dest->next();
            }
        }
    }

    AuthData::~AuthData(){
    }

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

    bool authdb::AuthData::empty(){
        if(!Data.data)
            return true;
        return false;
    };

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

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

        return *curec;

    }

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

        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=new AuthData(Data.uuid);
                curec=curec->_next;
                curec->append(src);
                break;
            }
            curec=curec->_next;
        };

        return *curec;
    }

    bool getRecord(authdb::AuthBackend &backend,AuthData &rec,int type){
        bool found=false;
        int rd=sizeof(authdb::AuthHeader),end=backend.end();

        while(rd<end){
            AuthData::Record cur;
            backend.setPos(rd);
            backend.read(reinterpret_cast<unsigned char*>(&cur),sizeof(AuthData::Record));
            rd=backend.getPos()+cur.datasize;
            if(uuid_compare(cur.uuid,rec.Data.uuid) == 0 && cur.type == type){
                cur.data=new char[cur.datasize];
                backend.read(reinterpret_cast<unsigned char*>(cur.data),cur.datasize);
                rec.append(cur);
                found=true;
                delete[] cur.data;
            }
        }

        return found;
    }

    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;

        getRecord(backend,old,type);

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

            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
                ){
                    size_t end = olddat->Data.datasize;
                    if(end!=curdat->Data.datasize){
                        changemap.emplace_back(&curdat->Data);
                    }else{
                        for(size_t i=0; i<end; ++i){
                            if(olddat->Data.data[i]!=curdat->Data.data[i]){
                                changemap.emplace_back(&curdat->Data);
                                break;
                            }
                        }
                    }
                    newentry=false;
                }
            }

            if(newentry){
                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->data,newel->datasize);
        }

        const unsigned char zero = 0;


        for(auto chel : changemap){
            size_t rd=sizeof(authdb::AuthHeader),end=backend.end();
            while(rd<end){
                std::shared_ptr<authdb::AuthData::Record> rdrec(new AuthData::Record);
                backend.setPos(rd);
                backend.read(reinterpret_cast<unsigned char*>(rdrec.get()),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->data,chel->datasize);
                    size_t dsize=rdrec->datasize;
                    rdrec->start = 0xFE;
                    rdrec->datasize=dsize;
                    backend.setPos(rd);
                    backend.write(reinterpret_cast<unsigned char*>(rdrec.get()),sizeof(AuthData::Record));
                    for(size_t i =0; i<rdrec->datasize; ++i){
                        backend.write(&zero,1);
                    }
                    rd=backend.getPos();
                }else{
                    rd=backend.getPos()+rdrec->datasize;
                }
            }
        }

        if(!changemap.empty() || !newmap.empty())
            return true;
        return false;
    }

    void delRecord(AuthBackend &backend,const uuid_t uid,int type){
        size_t end=backend.end(),rd=sizeof(AuthHeader);

        if(!uid)
            throw AuthBackendError("user info uid required!");

        while(rd<end){
            std::shared_ptr<authdb::AuthData::Record> cur(new AuthData::Record);
            backend.setPos(rd);
            size_t wr=backend.getPos();
            backend.read(reinterpret_cast<unsigned char*>(cur.get()),sizeof(AuthData::Record));
            rd=backend.getPos()+cur->datasize;
            if(uuid_compare(uid,cur->uuid) == 0 && type == cur->type){
                size_t dsize=cur->datasize;
                cur->start = 0xFE;
                cur->data=new char[dsize];
                memset(cur->data,0,dsize);
                memset(&cur->fieldname,0,255);
                memset(cur->uuid,0,sizeof(uuid_t));
                cur->storage=StorageType::EmptyStorage;
                cur->type=DataType::EmptyData;
                cur->datasize=dsize;
                backend.setPos(wr);
                backend.write(reinterpret_cast<unsigned char*>(cur.get()),sizeof(AuthData::Record));
                const unsigned char zero=0;
                for(size_t i=0; i<dsize; ++i){
                    backend.write(&zero,1);
                }
            }
        }
    }
};