Commit 210c7b31 authored by jan.koester's avatar jan.koester
Browse files

some changes

parent 9f14fd58
Loading
Loading
Loading
Loading
Loading
+54 −54
Changes for src/admin.cpp: 54 added lines, 54 removed lines.
Original line number Diff line number Diff line
@@ -403,8 +403,8 @@ namespace authdb {

                    AuthData curec(uid);

                    curec.Data->type=UserData;
                    curec.Data->storage=EmptyStorage;
                    curec.Data.type=UserData;
                    curec.Data.storage=EmptyStorage;

                    for(libhttppp::HttpForm::MultipartForm::Data::ContentDisposition *curdispo=curformdat->getDisposition();
                        curdispo; curdispo=curdispo->nextContentDisposition()
@@ -427,15 +427,15 @@ namespace authdb {
                                       [](unsigned char c){ return std::tolower(c); });

                        if(key=="name"){
                            strcpy(curec.Data->fieldname,curdispo->getValue());
                            strcpy(curec.Data.fieldname,curdispo->getValue());
                        }

                        if(key=="filename"){
                            curec.Data->storage=BinaryStorage;
                            curec.Data.storage=BinaryStorage;
                        }
                    }

                    if(curec.Data->storage==EmptyStorage){
                    if(curec.Data.storage==EmptyStorage){
                        bool numeric=true;

                        for(auto t : curformdat->Value){
@@ -446,55 +446,55 @@ namespace authdb {
                        }

                        if(numeric)
                            curec.Data->storage=IntStorage;
                            curec.Data.storage=IntStorage;
                        else
                            curec.Data->storage=TextStorage;
                            curec.Data.storage=TextStorage;
                    }



                    if(curec.Data->storage==TextStorage) {
                    if(curec.Data.storage==TextStorage) {
                        curformdat->Value.push_back('\0');
                        if(strcmp(curec.Data->fieldname,"pwhash")==0){
                        if(strcmp(curec.Data.fieldname,"pwhash")==0){
                            Hash hash;
                            std::string pwhash,inpw;
                            std::copy(curformdat->Value.begin(),curformdat->Value.end(),
                                      std::back_inserter(inpw));
                            hash.hash(inpw,pwhash);
                            curec.Data->datasize=pwhash.length()+1;
                            curec.Data->data=new char[curec.Data->datasize];
                            std::copy(pwhash.begin(),pwhash.end(),curec.Data->data);
                            curec.Data->data[pwhash.length()]='\0';
                            curec.Data.datasize=pwhash.length()+1;
                            curec.Data.data=new char[curec.Data.datasize];
                            std::copy(pwhash.begin(),pwhash.end(),curec.Data.data);
                            curec.Data.data[pwhash.length()]='\0';
                            editrec.append(curec);
                            delete[] curec.Data->data;
                            delete[] curec.Data.data;
                        }else{
                            curec.Data->datasize=curformdat->Value.size();
                            curec.Data->data=new char[curec.Data->datasize];
                            curec.Data.datasize=curformdat->Value.size();
                            curec.Data.data=new char[curec.Data.datasize];
                            std::copy(curformdat->Value.begin(),
                                        curformdat->Value.end(),curec.Data->data);
                                        curformdat->Value.end(),curec.Data.data);

                            editrec.append(curec);
                            delete[] curec.Data->data;
                            delete[] curec.Data.data;
                        }
                    }else if(curec.Data->storage==BinaryStorage){
                        curec.Data->datasize=curformdat->Value.size();
                        curec.Data->data=new char[curec.Data->datasize];
                        memcpy(curec.Data->data,curformdat->Value.data(),
                    }else if(curec.Data.storage==BinaryStorage){
                        curec.Data.datasize=curformdat->Value.size();
                        curec.Data.data=new char[curec.Data.datasize];
                        memcpy(curec.Data.data,curformdat->Value.data(),
                               curformdat->Value.size());

                        editrec.append(curec);
                        delete[] curec.Data->data;
                    }else if(curec.Data->storage==IntStorage){
                        delete[] curec.Data.data;
                    }else if(curec.Data.storage==IntStorage){
                        curformdat->Value.push_back('\0');

                        curec.Data->datasize=sizeof(int);
                        curec.Data->data=(char*)new int;
                        curec.Data.datasize=sizeof(int);
                        curec.Data.data=(char*)new int;
                        int val=atoi(curformdat->Value.data());
                        memcpy(curec.Data->data,&val,
                               curec.Data->datasize);
                        memcpy(curec.Data.data,&val,
                               curec.Data.datasize);

                        editrec.append(curec);
                        delete[] (int*)curec.Data->data;
                        delete[] (int*)curec.Data.data;
                    }

            }
@@ -1183,8 +1183,8 @@ namespace authdb {

                     AuthData curec(gid);

                     curec.Data->type=GroupData;
                     curec.Data->storage=EmptyStorage;
                     curec.Data.type=GroupData;
                     curec.Data.storage=EmptyStorage;

                     for(libhttppp::HttpForm::MultipartForm::Data::ContentDisposition *curdispo=curformdat->getDisposition();
                         curdispo; curdispo=curdispo->nextContentDisposition()
@@ -1200,15 +1200,15 @@ namespace authdb {
                                        [](unsigned char c){ return std::tolower(c); });

                         if(key=="name"){
                             strcpy(curec.Data->fieldname,curdispo->getValue());
                             strcpy(curec.Data.fieldname,curdispo->getValue());
                         }

                         if(key=="filename"){
                             curec.Data->storage=BinaryStorage;
                             curec.Data.storage=BinaryStorage;
                         }
                     }

                     if(curec.Data->storage==EmptyStorage){
                     if(curec.Data.storage==EmptyStorage){
                         bool numeric=true;

                         for(auto t : curformdat->Value){
@@ -1219,45 +1219,45 @@ namespace authdb {
                         }

                         if(numeric)
                             curec.Data->storage=IntStorage;
                             curec.Data.storage=IntStorage;
                         else
                             curec.Data->storage=TextStorage;
                             curec.Data.storage=TextStorage;
                     }

                     if(curec.Data->storage==TextStorage &&
                         strcmp(curec.Data->fieldname,"groupmembers")==0){
                     if(curec.Data.storage==TextStorage &&
                         strcmp(curec.Data.fieldname,"groupmembers")==0){
                         if(count >= members.count)
                            throw AuthBackendError("Edit groups to much entries !");
                         curformdat->Value.push_back('\0');
                         uuid_parse(curformdat->Value.data(),members.uid[count++]);
                     }else if(curec.Data->storage==TextStorage) {
                     }else if(curec.Data.storage==TextStorage) {
                         curformdat->Value.push_back('\0');
                         curec.Data->datasize=curformdat->Value.size();
                         curec.Data->data=new char[curec.Data->datasize];
                         curec.Data.datasize=curformdat->Value.size();
                         curec.Data.data=new char[curec.Data.datasize];
                         std::copy(curformdat->Value.begin(),
                                   curformdat->Value.end(),curec.Data->data);
                                   curformdat->Value.end(),curec.Data.data);

                         editrec.append(curec);
                         delete[] curec.Data->data;
                     }else if(curec.Data->storage==BinaryStorage){
                         curec.Data->datasize=curformdat->Value.size();
                         curec.Data->data=new char[curec.Data->datasize];
                         memcpy(curec.Data->data,curformdat->Value.data(),
                         delete[] curec.Data.data;
                     }else if(curec.Data.storage==BinaryStorage){
                         curec.Data.datasize=curformdat->Value.size();
                         curec.Data.data=new char[curec.Data.datasize];
                         memcpy(curec.Data.data,curformdat->Value.data(),
                                curformdat->Value.size());

                         editrec.append(curec);
                         delete[] curec.Data->data;
                     }else if(curec.Data->storage==IntStorage){
                         delete[] curec.Data.data;
                     }else if(curec.Data.storage==IntStorage){
                         curformdat->Value.push_back('\0');

                         curec.Data->datasize=sizeof(int);
                         curec.Data->data=(char*)new int;
                         curec.Data.datasize=sizeof(int);
                         curec.Data.data=(char*)new int;
                         int val=atoi(curformdat->Value.data());
                         memcpy(curec.Data->data,&val,
                                curec.Data->datasize);
                         memcpy(curec.Data.data,&val,
                                curec.Data.datasize);

                         editrec.append(curec);
                         delete[] (int*)curec.Data->data;
                         delete[] (int*)curec.Data.data;
                     }
                }

+54 −58
Changes for src/authdb.cpp: 54 added lines, 58 removed lines.
Original line number Diff line number Diff line
@@ -294,7 +294,6 @@ namespace authdb {
                    rep.setContentType(ctype);
                    rep.send(curreq,cur.data,cur.datasize);
                    end=0;
                    delete[] cur.data;
                }
            }

@@ -323,10 +322,8 @@ namespace authdb {
                user->data = new char[user->datasize];
                backend.read((unsigned char*)user->data,user->datasize);
                if(strcmp(user->data,value) == 0){
                    delete[] user->data;
                    goto VALUEFOUND;
                }
                delete[] user->data;
            }
            brd=rd;
        }
@@ -335,36 +332,36 @@ VALUEFOUND:
    }

    AuthData::AuthData(const uuid_t id){
         Data = std::make_shared<AuthData::Record>();
         memset(Data.get(),0,sizeof(AuthData::Record));
         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;
         memset(&Data,0,sizeof(AuthData::Record));
         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::AuthData(const AuthData &src) : AuthData(src.Data.uuid){
        std::shared_ptr<AuthData> dest(this);

        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);
            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=std::make_shared<AuthData>(cursrc->Data->uuid);
                dest->_next=std::make_shared<AuthData>(cursrc->Data.uuid);
                dest=dest->_next;
            }
        }
    }

    AuthData::~AuthData(){
        delete[] Data.data;
    }

    std::shared_ptr<AuthData> AuthData::next() const{
@@ -372,18 +369,18 @@ VALUEFOUND:
    };

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

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

        while(curec){
@@ -395,22 +392,22 @@ VALUEFOUND:
            curec=curec->_next;
        };

        return curec;
        return *curec;
    }

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

        if(!curec->_next && curec->Data->datasize==0){
            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;
        if(!curec->_next && curec->Data.datasize==0){
            curec->Data=src;
            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::make_shared<AuthData>(Data->uuid);
                curec->_next=std::make_shared<AuthData>(Data.uuid);
                curec=curec->_next;
                curec->append(src);
                break;
@@ -418,7 +415,7 @@ VALUEFOUND:
            curec=curec->_next;
        };

        return curec;
        return *curec;
    }

    bool getRecord(authdb::AuthBackend &backend,AuthData &rec,int type){
@@ -430,11 +427,12 @@ VALUEFOUND:
            backend.setPos(rd);
            backend.read(reinterpret_cast<unsigned char*>(cur.get()),sizeof(AuthData::Record));
            rd=backend.getPos()+cur->datasize;
            if(uuid_compare(cur->uuid,rec.Data->uuid) == 0 && cur->type == type){
            if(uuid_compare(cur->uuid,rec.Data.uuid) == 0 && cur->type == type){
                cur->data=new char[cur->datasize];
                backend.read((unsigned char*)cur->data,cur->datasize);
                rec.append(*cur);
                found=true;
                cur->data=nullptr;
            }
        }

@@ -442,29 +440,29 @@ VALUEFOUND:
    }

    bool editRecord(AuthBackend &backend,AuthData &rec,int type){
        AuthData old(rec.Data->uuid);
        AuthData old(rec.Data.uuid);

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

        getRecord(backend,old,type);

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

            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
                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);
                    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);
                            if(olddat->Data.data[i]!=curdat->Data.data[i]){
                                changemap.emplace_back(&curdat->Data);
                                break;
                            }
                        }
@@ -474,14 +472,14 @@ VALUEFOUND:
            }

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

        }

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

@@ -491,19 +489,19 @@ VALUEFOUND:
        for(auto chel : changemap){
            size_t rd=sizeof(authdb::AuthHeader),end=backend.end();
            while(rd<end){
                authdb::AuthData::Record *rdrec=new AuthData::Record;
                std::shared_ptr<authdb::AuthData::Record> rdrec(new AuthData::Record);
                backend.setPos(rd);
                backend.read((unsigned char*)rdrec,sizeof(AuthData::Record));
                if(uuid_compare(rdrec->uuid,rec.Data->uuid)==0 && strcmp(rdrec->fieldname,chel->fieldname)==0){
                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.get(),sizeof(AuthData::Record));
                    backend.write((const unsigned char*)chel,sizeof(AuthData::Record));
                    backend.write((const unsigned char*)chel->data,chel->datasize);
                    size_t dsize=rdrec->datasize;
                    memset(rdrec,0,sizeof(AuthData::Record));
                    memset(rdrec.get(),0,sizeof(AuthData::Record));
                    rdrec->start = 0xFE;
                    rdrec->datasize=dsize;
                    backend.setPos(rd);
                    backend.write((const unsigned char*)rdrec,sizeof(AuthData::Record));
                    backend.write(reinterpret_cast<unsigned char*>(rdrec.get()),sizeof(AuthData::Record));
                    for(size_t i =0; i<rdrec->datasize; ++i){
                        backend.write(&zero,1);
                    }
@@ -511,7 +509,6 @@ VALUEFOUND:
                }else{
                    rd=backend.getPos()+rdrec->datasize;
                }
                delete rdrec;
            }
        }

@@ -527,24 +524,23 @@ VALUEFOUND:
            throw AuthBackendError("user info uid required!");

        while(rd<end){
            authdb::AuthData::Record *cur=new AuthData::Record;
            std::shared_ptr<authdb::AuthData::Record> cur(new AuthData::Record);
            backend.setPos(rd);
            size_t wr=backend.getPos();
            backend.read((unsigned char*)cur,sizeof(AuthData::Record));
            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;
                memset(cur,0,sizeof(AuthData::Record));
                memset(cur.get(),0,sizeof(AuthData::Record));
                cur->start = 0xFE;
                cur->datasize=dsize;
                backend.setPos(wr);
                backend.write((unsigned char*)cur,sizeof(AuthData::Record));
                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);
                }
            }
            delete cur;
        }
    }

+13 −15
Changes for src/authdb.h: 13 added lines, 15 removed lines.
Original line number Diff line number Diff line
@@ -66,14 +66,12 @@ namespace authdb {
            size_t datasize = 0;
            char  *data = nullptr;
            size_t count = 0;
        };

        std::shared_ptr<Record> Data;
        } Data;

        bool empty();

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

    protected:
        std::shared_ptr<AuthData> _next;
@@ -92,16 +90,16 @@ namespace authdb {
        std::shared_ptr<AuthData> curec(dat);

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

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

                    target=curec->Data;
                    target=std::make_shared<AuthData::Record>(curec->Data);
                    target->datasize=0;
                    delete[] target->data;
                    target->data=nullptr;
@@ -113,7 +111,7 @@ namespace authdb {

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

        memset(target.get(),0,sizeof(AuthData::Record));
@@ -147,10 +145,10 @@ namespace authdb {
            return (T*)varclass->data;
        }else{
            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;
                    return (T*)curdat->Data->data;
                if(curdat->Data.type==type && curdat->Data.storage==storage
                    && strcmp(curdat->Data.fieldname,varname)==0){
                    varclass=std::make_shared<AuthData::Record>(curdat->Data);
                    return (T*)curdat->Data.data;
                }
            }
        }
+10 −10

File changed.

Preview size limit exceeded, changes collapsed.

+9 −9
Changes for src/domain.cpp: 9 added lines, 9 removed lines.
Original line number Diff line number Diff line
@@ -87,10 +87,10 @@ void authdb::Domain::create(authdb::AuthBackend& backend,class DomainData *data)
    size_t wd=backend.end();

    for(std::shared_ptr<AuthData> curec(data); curec; curec=curec->next()){
         curec->Data->type=DataType::DomainData;
         curec->Data.type=DataType::DomainData;
         backend.setPos(wd);
         backend.write((unsigned char*)curec->Data.get(),sizeof(struct AuthData::Record));
         backend.write((unsigned char*)curec->Data->data,curec->Data->datasize);
         backend.write((unsigned char*)&curec->Data,sizeof(struct AuthData::Record));
         backend.write((unsigned char*)curec->Data.data,curec->Data.datasize);
         wd=backend.end();
    }
}
@@ -168,12 +168,12 @@ void authdb::Domain::info(AuthBackend& backend, class DomainData& dat, size_t& p
            if(!getRecord(backend,dat,DataType::DomainData))
                continue;

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