Commit 839529f3 authored by jan.koester's avatar jan.koester
Browse files

get template added

parent efc32f87
Loading
Loading
Loading
Loading
+120 −80
Changes for src/authdb.cpp: 120 added lines, 80 removed lines.
Original line number Diff line number Diff line
@@ -70,15 +70,18 @@ namespace authdb {
            userlist <<"<div><p>UserList:</p><table class=\"userlist\">";

            while(rd<end){
                authdb::AuthData *cur=new AuthData;
                authdb::AuthData::Record *cur=new AuthData::Record;

                _Backend.ReadAuthData(cur,rd);
                cur->type=EmptyData;

                _Backend.setPos(rd);
                _Backend.read((unsigned char*)cur,sizeof(AuthData::Record));

                rd=_Backend.getPos()+cur->datasize;

                uuid_t uid;
                uuid_parse(cur->uuid,uid);
                if(strcmp(cur->fieldname,"username")==0){
                if(cur->type == UserData && strcmp(cur->fieldname,"username")==0){
                    try {
                        size_t upos=sizeof(authdb::AuthHeader);
                        user.info(_Backend,uid,udat,upos);
@@ -126,32 +129,24 @@ namespace authdb {
                uuid_t uid;
                uuid_generate(uid);
                class UserData udat(uid);
                struct AuthData::Record *cudat=udat.Data->Data;

                for (libhttppp::HttpForm::MultipartForm::Data* curformdat = curform.MultipartFormData.getFormData();
                    curformdat; curformdat = curformdat->nextData()) {
                    for(libhttppp::HttpForm::MultipartForm::Data::ContentDisposition *curdispo=curformdat->getDisposition();
                        curdispo; curdispo=curdispo->nextContentDisposition()
                    ){
                        if(curformdat->Value.empty() || !curdispo->getValue())
                        if(curformdat->Value.empty() || strcmp(curdispo->getValue(),"name")!=0 )
                            continue;

                        std::vector<char> tmp;
                        if(strcmp(curdispo->getValue(),"avatar")!=0){
                            std::copy(curformdat->Value.begin(),curformdat->Value.end(),std::back_inserter(tmp));
                            tmp.push_back('\0');
                        }
                        strcpy(cudat->fieldname,curdispo->getValue());

                        if(strcmp(curdispo->getValue(),"username")==0){
                            udat.setUserName(tmp.data());
                        }else if(strcmp(curdispo->getValue(),"firstname")==0){
                            udat.setFirstName(tmp.data());
                        }else if(strcmp(curdispo->getValue(),"lastname")==0){
                            udat.setLastName(tmp.data());
                        }else if(strcmp(curdispo->getValue(),"mail")==0){
                            udat.setMail(tmp.data());
                        }else if(strcmp(curdispo->getValue(),"avatar")==0 && !curformdat->Value.empty()){
                            udat.setAvatar(curformdat->Value);
                        }
                        cudat->datasize=curformdat->Value.size();
                        cudat->data=new char[cudat->datasize];
                        memcpy(cudat->data,curformdat->Value.data(),
                               cudat->datasize);

                        cudat=udat.Data->append(*cudat)->Data;
                    }
                }

@@ -226,14 +221,15 @@ namespace authdb {

            _Backend.lock();

            authdb::AuthData *cur;
            authdb::AuthData::Record *cur;

            size_t rd=sizeof(authdb::AuthHeader),end=_Backend.end();

            while(rd<end){
                cur=new AuthData;
                cur=new AuthData::Record;
                cur->data=nullptr;
                _Backend.ReadAuthData(cur,rd);
                _Backend.setPos(rd);
                _Backend.read((unsigned char*)cur,sizeof(AuthData::Record));
                rd=_Backend.getPos()+cur->datasize;

                if(cur && strcmp(cur->uuid,uid)==0 && strcmp(cur->fieldname,"avatar")==0){
@@ -264,7 +260,7 @@ namespace authdb {

            sscanf(curreq->getRequestURL(),"/admin/edituser/%s",cuid);

            AuthDataRecord editrec,*curec=&editrec;
            AuthData editrec,&curec=editrec;

            bool data = false;

@@ -282,10 +278,10 @@ namespace authdb {

                        data = true;

                        strcpy(curec->Data->uuid,cuid);
                        strcpy(curec.Data->uuid,cuid);

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

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

                            if(key=="name"){
                                strcpy(curec->Data->fieldname,curdispo->getValue());
                                strcpy(curec.Data->fieldname,curdispo->getValue());
                            }else if(key=="content-type" && strncmp(curdispo->getValue(),"text/",5) != 0){
                                curec->Data->storage=BinaryStorage;
                                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());
                    }
                    if(curformdat->nextData()){
                            curec->_next=new AuthDataRecord;
                            curec=curec->_next;
                        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);
                    }
            }

@@ -320,7 +313,7 @@ namespace authdb {
            uuid_parse(cuid,uid);

            if(data){
                editRecord(_Backend,&editrec,uid,UserData);
                editRecord(_Backend,editrec,uid,UserData);
                _Backend.unlock();
                libhttppp::HttpResponse rep;
                rep.setState(HTTP307);
@@ -338,9 +331,10 @@ namespace authdb {
                  << "<table>";

            while(rd<end){
                authdb::AuthData *cur=new AuthData;
                authdb::AuthData::Record *cur=new AuthData::Record;

                _Backend.ReadAuthData(cur,rd);
                _Backend.setPos(rd);
                _Backend.read((unsigned char*)cur,sizeof(AuthData::Record));

                cur->data = new char[cur->datasize];
                _Backend.read((unsigned char*)cur->data,cur->datasize);
@@ -425,10 +419,11 @@ namespace authdb {
    };

    int searchValue(authdb::AuthBackend &backend,const char*fieldname,const char *value){
        authdb::AuthData *user=new AuthData;
        authdb::AuthData::Record *user=new AuthData::Record;
        int rd=sizeof(authdb::AuthHeader),brd=rd;
        while(rd>backend.end()){
            backend.ReadAuthData(user,rd);
            backend.setPos(rd);
            backend.read((unsigned char*)user,sizeof(AuthData::Record));
            rd=backend.getPos();
            if(strcmp(user->fieldname,fieldname) == 0){
                user->data = new char[user->datasize];
@@ -446,71 +441,111 @@ VALUEFOUND:
        return brd;
    }

    AuthDataRecord::AuthDataRecord(){
         Data = new AuthData;
    AuthData::AuthData(){
         Data = new AuthData::Record;
         memset((void*)Data,0,sizeof(AuthData));
         Data->start=0xFE;
        _next=nullptr;
    }

    AuthDataRecord::AuthDataRecord(const AuthDataRecord &src){
        Data = new AuthData;
        memcpy(&Data,&src.Data,sizeof(src.Data));
    AuthData::AuthData(const AuthData &src){
        Data = new AuthData::Record;
        memcpy(&Data,&src.Data,sizeof(AuthData::Record));
        Data->data=new char[src.Data->datasize];
        memcpy(Data->data,src.Data->data,src.Data->datasize);
        _next=nullptr;
    }

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

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

    AuthData *AuthData::append(const AuthData &src){
        AuthData *curec=this;
        do{
            if(!curec->_next){
                curec->_next=new AuthData;
                curec=curec->_next;
                break;
            }
            curec=curec->_next;
        }while(curec->_next);

        for(const AuthData *cuxrcrec=&src; cuxrcrec; cuxrcrec=cuxrcrec->next()){
            memcpy(curec,cuxrcrec,sizeof(AuthData::Record));
            curec->Data->data=new char[curec->Data->datasize];
            memcpy(curec->Data->data,cuxrcrec->Data->data,curec->Data->datasize);
            curec->_next=nullptr;
            if(cuxrcrec->next()){
                curec->_next=new AuthData;
                curec=curec->_next;
            }

        }
        return curec;
    }

    AuthData *AuthData::append(const AuthData::Record &src){
        AuthData *curec=this;
        do{
            if(!curec->_next){
                curec->_next=new AuthData;
                curec=curec->_next;
                break;
            }
            curec=curec->_next;
        }while(curec->_next);

        memcpy(curec->Data,&src,sizeof(src));
        return curec;
    }

    bool getRecord(authdb::AuthBackend &backend,AuthDataRecord *dest,const uuid_t id,int type){
    bool getRecord(authdb::AuthBackend &backend,AuthData &rec,const uuid_t id,int type){
        bool found=false;
        AuthData *cur=new AuthData;
        AuthData::Record cur;
        int rd=sizeof(authdb::AuthHeader),end=backend.end();

        char plainid[255];

        uuid_unparse(id,plainid);

        AuthDataRecord *curec=dest;
        AuthData *curec=&rec;

        while(rd<end){
            backend.ReadAuthData(cur,rd);
            rd=backend.getPos()+cur->datasize;
            if(strcmp(cur->uuid,plainid) == 0 && cur->type == type){
                memcpy(curec->Data,cur,sizeof(AuthData));
                curec->Data->data=new char[cur->datasize];
                backend.read((unsigned char*)curec->Data->data,cur->datasize);
                if(rd<backend.end()){
                    curec->_next=new AuthDataRecord;
                    curec=curec->_next;
                }
            memset(&cur,0,sizeof(AuthData));
            backend.setPos(rd);
            backend.read((unsigned char*)&cur,sizeof(AuthData::Record));
            rd=backend.getPos()+cur.datasize;
            if(strcmp(cur.uuid,plainid) == 0 && cur.type == type){
                std::cout << cur.fieldname << std::endl;
                if(found){
                    curec=curec->append(rec);
                }
                memcpy(curec->Data,&cur,sizeof(AuthData));
                curec->Data->data=new char[cur.datasize];
                backend.read((unsigned char*)curec->Data->data,cur.datasize);
                found=true;
            }
        }

        delete cur;

        return found;
    }

    bool editRecord(AuthBackend &backend,const AuthDataRecord *rec,const uuid_t uid,int type){
        AuthDataRecord old;
    bool editRecord(AuthBackend &backend,AuthData &rec,const uuid_t uid,int type){
        AuthData old;

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

        getRecord(backend,&old,uid,type);
        getRecord(backend,old,uid,type);

        for(const AuthDataRecord *curdat=rec; curdat; curdat=curdat->_next){
        for(const AuthData *curdat=&rec; curdat; curdat=curdat->_next){
            bool newentry=true;
            for(const AuthDataRecord *olddat=&old; olddat; olddat=olddat->_next){
            for(const AuthData *olddat=&old; olddat; olddat=olddat->_next){
                if(strcmp(olddat->Data->uuid,curdat->Data->uuid)==0
                    && strcmp(olddat->Data->fieldname,curdat->Data->fieldname)==0
                ){
@@ -536,9 +571,9 @@ VALUEFOUND:
        }

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

        char cuid[255];
@@ -549,16 +584,19 @@ VALUEFOUND:
        for(auto chel : changemap){
            size_t rd=sizeof(authdb::AuthHeader),end=backend.end();
            while(rd<end){
                authdb::AuthData *rdrec=new AuthData;
                backend.ReadAuthData(rdrec,rd);
                authdb::AuthData::Record *rdrec=new AuthData::Record;
                backend.setPos(rd);
                backend.read((unsigned char*)rdrec,sizeof(AuthData::Record));
                if(strcmp(rdrec->uuid,cuid)==0 && strcmp(rdrec->fieldname,chel->fieldname)==0){
                    backend.WriteAuthData(chel,backend.end());
                    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));
                    memset(rdrec,0,sizeof(AuthData::Record));
                    rdrec->start = 0xFE;
                    rdrec->datasize=dsize;
                    backend.WriteAuthData(rdrec,rd);
                    backend.setPos(rd);
                    backend.write((const unsigned char*)rdrec,sizeof(AuthData::Record));
                    for(size_t i =0; i<rdrec->datasize; ++i){
                        backend.write(&zero,1);
                    }
@@ -586,9 +624,10 @@ VALUEFOUND:
        uuid_unparse(uid,cuid);

        while(rd<end){
            authdb::AuthData *cur=new AuthData;
            authdb::AuthData::Record *cur=new AuthData::Record;
            size_t wr=backend.getPos();
            backend.ReadAuthData(cur,rd);
            backend.setPos(rd);
            backend.read((unsigned char*)cur,sizeof(AuthData::Record));
            rd=backend.getPos()+cur->datasize;
            if(strlen(cur->uuid) >0 &&
                strncmp(cuid,cur->uuid,strlen(cur->uuid)) == 0){
@@ -597,7 +636,8 @@ VALUEFOUND:
                memset(cur,0,sizeof(AuthData));
                cur->start = 0xFE;
                cur->datasize=dsize;
                backend.WriteAuthData(cur,wr);
                backend.setPos(wr);
                backend.write((unsigned char*)cur,sizeof(AuthData::Record));
                const unsigned char zero=0;
                for(size_t i=0; i<dsize; ++i){
                    backend.write(&zero,1);
+27 −20
Changes for src/authdb.h: 27 added lines, 20 removed lines.
Original line number Diff line number Diff line
@@ -27,6 +27,8 @@

#include <uuid/uuid.h>

#include "backend.h"

#pragma once

#define VERSION 1
@@ -39,7 +41,17 @@ namespace authdb {
        size_t Revesion;
    };

    struct AuthData {
    class AuthData {
    public:
        AuthData();

        AuthData(const AuthData &src);

        ~AuthData();

        AuthData *next() const;

        struct Record {
            char   start = 0xFE;
            char   uuid[255];
            int    type;
@@ -47,29 +59,24 @@ namespace authdb {
            char   fieldname[255];
            size_t datasize = 0;
            char  *data;
    };

    int searchValue(authdb::AuthBackend &backend,const char*fieldname,const char *value);

    class AuthDataRecord {
    public:
        AuthDataRecord();

        AuthDataRecord(const AuthDataRecord &src);
        } *Data;

        ~AuthDataRecord();
        AuthData *append(const AuthData &src);
        AuthData *append(const AuthData::Record &src);
    private:

        AuthDataRecord *next();
        AuthData *_next;

        AuthData *Data;

        AuthDataRecord    *_next;
        friend bool getRecord(authdb::AuthBackend &backend,AuthDataRecord *dest,const uuid_t id,int type);
        friend bool editRecord(AuthBackend &backend,const AuthDataRecord *rec,const uuid_t uid,int type);
        friend void delRecord(AuthBackend &backend,const uuid_t uid);
        friend    int searchValue(authdb::AuthBackend &backend,const char*fieldname,const char *value);
        friend    bool getRecord(authdb::AuthBackend &backend,AuthData &rec,const uuid_t id,int type);
        friend    bool editRecord(AuthBackend &backend,AuthData &rec,const uuid_t uid,int type);
        friend    void delRecord(authdb::AuthBackend &backend,const uuid_t uid);
    };

    bool getRecord(authdb::AuthBackend &backend,AuthDataRecord *dest,const uuid_t id,int type);
    bool editRecord(AuthBackend &backend,const AuthDataRecord *rec,const uuid_t uid,int type);

    bool getRecord(authdb::AuthBackend &backend,AuthData &rec,const uuid_t id,int type);
    bool editRecord(AuthBackend &backend,AuthData &rec,const uuid_t uid,int type);
    void delRecord(authdb::AuthBackend &backend,const uuid_t uid);

    int searchValue(authdb::AuthBackend &backend,const char*fieldname,const char *value);
};
+0 −11
Changes for src/backend.cpp: 0 added lines, 11 removed lines.
Original line number Diff line number Diff line
@@ -55,17 +55,6 @@ void authdb::AuthBackend::write(const unsigned char* dest, size_t destsize){
   _Api->write(dest,destsize);
}

void authdb::AuthBackend::ReadAuthData(struct AuthData *adata,int pos){
    setPos(pos);
    read((unsigned char*)adata,sizeof(authdb::AuthData));
}

void authdb::AuthBackend::WriteAuthData(const struct AuthData *adata,int pos){
    newRevesion();
    setPos(pos);
    write((unsigned char*)adata,sizeof(authdb::AuthData));
}

void authdb::AuthBackend::lock(){
    _Api->lock();
}
+1 −3
Changes for src/backend.h: 1 added line, 3 removed lines.
Original line number Diff line number Diff line
@@ -32,6 +32,7 @@
#pragma once

namespace authdb{
    struct Record;

    enum AuthBackendType{
        File=0,
@@ -62,9 +63,6 @@ namespace authdb{
        AuthBackend(const AuthBackend &backend);
        ~AuthBackend();

        void ReadAuthData(struct AuthData *adata,int pos);
        void WriteAuthData(const struct AuthData *adata,int pos);

        void lock();
        void unlock();

+210 −214

File changed.

Preview size limit exceeded, changes collapsed.

Loading