Commit 5fb67bfc authored by jan.koester's avatar jan.koester
Browse files

back to real c++

parent 0b58bc98
Loading
Loading
Loading
Loading
+1 −0
Changes for src/CMakeLists.txt: 1 added line, 0 removed lines.
Original line number Diff line number Diff line
@@ -18,6 +18,7 @@ list(APPEND authdbSrcs
    client.cpp
    hash.cpp
    api.cpp
    uuid.cpp
    hash/sha512.cpp
)

+55 −56
Changes for src/admin.cpp: 55 added lines, 56 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;
                     }
                }

@@ -2636,11 +2636,10 @@ URLNOTFOUND:
    };

    AdminInterface::AdminInterface(AuthBackend &bck,netplus::socket *ssock) : _bck(bck) {
        _ctl = new AdminController(bck,ssock);
        _ctl = std::make_shared<AdminController>(bck,ssock);
    }

    AdminInterface::~AdminInterface(){
        delete _ctl;
    }

    void AdminInterface::Request(libhttppp::HttpRequest *curreq, const int tid, ULONG_PTR args){
+3 −1
Changes for src/admin.h: 3 added lines, 1 removed line.
Original line number Diff line number Diff line
@@ -25,6 +25,8 @@
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *******************************************************************************/

#include <memory>

#include <httppp/http.h>

#include "backend.h"
@@ -40,7 +42,7 @@ namespace authdb {
        ~AdminInterface();
        void Request(libhttppp::HttpRequest *curreq, const int tid, ULONG_PTR args);
    public:
        AdminController *_ctl;
        std::shared_ptr<AdminController>  _ctl;
        AuthBackend                      &_bck;
    };
};
+69 −74
Changes for src/authdb.cpp: 69 added lines, 74 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,121 +322,119 @@ 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;
        }
VALUEFOUND:
        delete user;
        return brd;
    }

    AuthData::AuthData(const uuid_t id){
         Data = new struct AuthData::Record;
         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;
         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){
        AuthData *dest=this;

        for(const AuthData *cursrc=&src; cursrc; 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);
        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;
                dest->_next=std::make_shared<AuthData>(cursrc->Data.uuid);
                dest=dest->next();
            }
        }
    }

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

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

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

    AuthData *AuthData::append(const AuthData &src){
    const 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);
        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)));
            }
            return curec;
            return *curec;
        }

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

        return curec;
        return *curec;
    }

    AuthData *AuthData::append(const AuthData::Record &src){
    const 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;
        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;
            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);
            if(curec->next()){
                curec->_next=std::shared_ptr<AuthData>( new AuthData(curec->Data.uuid));
                curec=curec->next();
                break;
            }
            curec=curec->_next;
            curec=curec->next();
        };

        return curec;
        return *curec;
    }

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

        while(rd<end){
            AuthData::Record cur;
            memset(&cur,0,sizeof(AuthData::Record));
            backend.setPos(rd);
            backend.read((unsigned char*)&cur,sizeof(AuthData::Record));
            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){
            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);
                backend.read(reinterpret_cast<unsigned char*>(cur.data),cur.datasize);
                rec.append(cur);
                delete[] cur.data;
                found=true;
                delete[] cur.data;
            }
        }

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

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

        std::vector<AuthData::Record*> changemap; //use fieldname;
        std::vector<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)
            if(rec.Data.datasize==0)
                continue;

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

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

        }
@@ -494,19 +491,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,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);
                    }
@@ -514,7 +511,6 @@ VALUEFOUND:
                }else{
                    rd=backend.getPos()+rdrec->datasize;
                }
                delete rdrec;
            }
        }

@@ -530,24 +526,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;
        }
    }

+40 −47

File changed.

Preview size limit exceeded, changes collapsed.

Loading