Commit 0309afcf authored by jan.koester's avatar jan.koester
Browse files

better api && better performence

parent 839529f3
Loading
Loading
Loading
Loading
+142 −107
Changes for src/authdb.cpp: 142 added lines, 107 removed lines.
Original line number Diff line number Diff line
@@ -65,45 +65,46 @@ namespace authdb {
            libhtmlpp::HtmlElement *content=root.getElementbyID("content");

            User user;
            class UserData udat;

            userlist <<"<div><p>UserList:</p><table class=\"userlist\">";

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

                cur->type=EmptyData;
                cur.type=EmptyData;

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

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

                uuid_t uid;
                uuid_parse(cur->uuid,uid);
                if(cur->type == UserData && strcmp(cur->fieldname,"username")==0){
                if(cur.type == UserData && strcmp(cur.fieldname,"username")==0){
                    class UserData udat(cur.uuid);
                    try {
                        size_t upos=sizeof(authdb::AuthHeader);
                        user.info(_Backend,uid,udat,upos);
                        user.info(_Backend,udat,upos);

                        char cruid[20];
                        uuid_unparse(cur.uuid,cruid);

                        userlist << "<tr><td class=\"list_username\">"
                        << udat.getUsername()
                        << "</td></tr>"
                        << "<tr><td><img class=\"list_picture\" style=\"height:100px;\" src=\"/admin/getavatar/" << cur->uuid << ".jpg\" alt=\"avatar\">"
                        << "<tr><td><img class=\"list_picture\" style=\"height:100px;\" src=\"/admin/getavatar/" << cruid << ".jpg\" alt=\"avatar\">"
                        << "</td><td><ul><li>"
                        << "uid: " << cur->uuid
                        << "uid: " << cruid
                        << "</li>"
                        << "<li><span>Firstname:</span><span>" << udat.getFirstname() << "</span></li>"
                        << "<li><span>Lastname:</span><span>" << udat.getLastname() << "</span></li>"
                        << "<li><span>Email:</span><span>" << udat.getMail() << "</span></li>"
                        << "</ul></td><td><ul class=\"usertoolbar\" >"
                        << "<li><a class=\"button\" href=\"/admin/edituser/" << cur->uuid << "\">EditUser</a></li>"
                        << "<li><a class=\"button\" href=\"/admin/removeuser/" << cur->uuid << "\">RemoveUser</a></li>"
                        << "<li><a class=\"button\" href=\"/admin/edituser/" << cruid << "\">EditUser</a></li>"
                        << "<li><a class=\"button\" href=\"/admin/removeuser/" << cruid << "\">RemoveUser</a></li>"
                        << "</ul></td></tr>";
                    }catch(AuthBackendError &e){
                        std::cerr << e.what() << std::endl;
                    }
                }
                delete cur;
            }

            _Backend.unlock();
@@ -125,36 +126,71 @@ namespace authdb {

            libhttppp::HttpForm curform;
            curform.parse(curreq);

            if (curform.getBoundary()) {
                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()) {

                    if(curformdat->Value.empty())
                        continue;

                    std::string name;
                    int stortype=TextStorage;

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

                        strcpy(cudat->fieldname,curdispo->getValue());
                        std::string tmp=curdispo->getKey();

                        std::transform(tmp.begin(), tmp.end(), tmp.begin(),
                                       [](unsigned char c){ return std::tolower(c); });

                        cudat->datasize=curformdat->Value.size();
                        cudat->data=new char[cudat->datasize];
                        memcpy(cudat->data,curformdat->Value.data(),
                               cudat->datasize);
                        if(tmp=="name")
                            name=curdispo->getValue();

                        cudat=udat.Data->append(*cudat)->Data;
                        if(tmp=="filename"){
                            stortype=BinaryStorage;
                        }
                    }

                    if(name.empty() || stortype == EmptyStorage)
                        continue;

                    struct AuthData::Record cudat;
                    memset(&cudat,0,sizeof(AuthData::Record));

                    cudat.start=0xFE;
                    uuid_copy(cudat.uuid,uid);

                    cudat.type=UserData;
                    cudat.storage=stortype;
                    strcpy(cudat.fieldname,name.c_str());

                    if(cudat.storage==BinaryStorage){
                        cudat.datasize=curformdat->Value.size();
                        cudat.data=new char[cudat.datasize];
                        memcpy(cudat.data,curformdat->Value.data(),
                               cudat.datasize);
                    }else{
                        cudat.datasize=curformdat->Value.size()+1;
                        cudat.data=new char[cudat.datasize];
                        memcpy(cudat.data,curformdat->Value.data(),
                               curformdat->Value.size());
                        cudat.data[curformdat->Value.size()]='\0';
                    }

                    udat.Data->append(cudat);
                    delete[] cudat.data;
                }
                _Backend.lock();
                User user;
                user.create(_Backend,&udat);
                _Backend.unlock();

                std::cout << "user created!" << std::endl;
            }

@@ -216,33 +252,32 @@ namespace authdb {

        void getAvatar(libhttppp::HttpRequest *curreq, const int tid, ULONG_PTR args){
            libhttppp::HttpResponse rep;
            char uid[255],ext[16];
            sscanf(curreq->getRequestURL(),"/admin/getavatar/%[^.].%s",uid,ext);
            char cuid[255],ext[16];
            sscanf(curreq->getRequestURL(),"/admin/getavatar/%[^.].%s",cuid,ext);

            _Backend.lock();
            uuid_t uid;
            uuid_parse(cuid,uid);

            authdb::AuthData::Record *cur;
            _Backend.lock();

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

            while(rd<end){
                cur=new AuthData::Record;
                cur->data=nullptr;
                authdb::AuthData::Record cur;
                _Backend.setPos(rd);
                _Backend.read((unsigned char*)cur,sizeof(AuthData::Record));
                rd=_Backend.getPos()+cur->datasize;
                _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){
                    cur->data = new char[cur->datasize];
                    _Backend.read((unsigned char*)cur->data,cur->datasize);
                if(uuid_compare(cur.uuid,uid)==0 && strcmp(cur.fieldname,"avatar")==0){
                    cur.data = new char[cur.datasize];
                    _Backend.read((unsigned char*)cur.data,cur.datasize);
                    char ctype[255];
                    snprintf(ctype,255,"image/%s",ext);
                    rep.setContentType(ctype);
                    rep.send(curreq,cur->data,cur->datasize);
                    rep.send(curreq,cur.data,cur.datasize);
                    end=0;
                    delete[] cur->data;
                    delete[] cur.data;
                }
                delete cur;
            }

            if(end!=0){
@@ -260,7 +295,11 @@ namespace authdb {

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

            AuthData editrec,&curec=editrec;

            uuid_t uid;
            uuid_parse(cuid,uid);

            AuthData editrec(uid);

            bool data = false;

@@ -268,18 +307,19 @@ namespace authdb {

            curform.parse(curreq);


            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()
                    ){
                        AuthData curec(uid);

                        if(curformdat->Value.empty() || !curdispo->getValue())
                            continue;

                        data = true;

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

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

@@ -291,13 +331,17 @@ namespace authdb {

                            if(curdispo->getKey())
                                key=curdispo->getKey();
                            else
                                continue;

                            std::transform(key.begin(), key.end(), key.begin(),
                                            [](unsigned char c){ return std::tolower(c); });

                            if(key=="name"){
                                strcpy(curec.Data->fieldname,curdispo->getValue());
                            }else if(key=="content-type" && strncmp(curdispo->getValue(),"text/",5) != 0){
                            }

                            if(key=="filename"){
                                curec.Data->storage=BinaryStorage;
                            }
                        }
@@ -306,14 +350,12 @@ namespace authdb {
                        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;
                    }
            }

            uuid_t uid;
            uuid_parse(cuid,uid);

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

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

                _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);
                _Backend.read((unsigned char*)&cur,sizeof(AuthData::Record));
                rd=_Backend.getPos()+cur.datasize;

                rd=_Backend.getPos();

                if(strcmp(cur->uuid,cuid)==0 && cur->type==UserData && cur->storage==TextStorage){
                if(uuid_compare(cur.uuid,uid)==0 && cur.type==UserData && cur.storage==TextStorage){
                    cur.data = new char[cur.datasize];
                    _Backend.read((unsigned char*)cur.data,cur.datasize);
                    try {
                        form  << "<tr><td><label for=\"username\">" << cur->fieldname << "</label></td>"
                              << "<td><input type=\"text\" name=\"" << cur->fieldname << "\" value=\""
                              << cur->data <<"\"></td></tr>";
                        form  << "<tr><td><label for=\"username\">" << cur.fieldname << "</label></td>"
                              << "<td><input type=\"text\" name=\"" << cur.fieldname << "\" value=\""
                              << cur.data <<"\"></td></tr>";
                    }catch(AuthBackendError &e){
                        std::cerr << e.what() << std::endl;
                    }
                    delete[] cur.data;
                }

                delete[] cur->data;
                delete cur;
            }
            _Backend.unlock();

@@ -441,19 +479,29 @@ VALUEFOUND:
        return brd;
    }

    AuthData::AuthData(){
    AuthData::AuthData(const uuid_t id){
         Data = new AuthData::Record;
         memset((void*)Data,0,sizeof(AuthData));
         Data->start=0xFE;
         Data->storage=EmptyStorage;
         uuid_copy(Data->uuid,id);
        _next=nullptr;
    }

    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;

        AuthData *dest=this;

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

    AuthData::~AuthData(){
@@ -466,22 +514,23 @@ VALUEFOUND:

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

        while(curec->Data->datasize!=0){
            if(!curec->_next){
                curec->_next=new AuthData;
                curec->_next=new AuthData(Data->uuid);
                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));
            memcpy(curec->Data,cuxrcrec->Data,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->_next=new AuthData(src.Data->uuid);
                curec=curec->_next;
            }

@@ -491,62 +540,56 @@ VALUEFOUND:

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

        while(curec->Data->datasize!=0){
            if(!curec->_next){
                curec->_next=new AuthData;
                curec->_next=new AuthData(Data->uuid);
                curec=curec->_next;
                break;
            }
            curec=curec->_next;
        }while(curec->_next);
        }

        memcpy(curec->Data,&src,sizeof(src));
        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;
    }

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

        char plainid[255];

        uuid_unparse(id,plainid);

        AuthData *curec=&rec;

        while(rd<end){
            memset(&cur,0,sizeof(AuthData));
            AuthData::Record cur;
            memset(&cur,0,sizeof(AuthData::Record));
            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;
            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);
                delete[] cur.data;
            }
        }

        return found;
    }

    bool editRecord(AuthBackend &backend,AuthData &rec,const uuid_t uid,int type){
        AuthData old;
    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,uid,type);
        getRecord(backend,old,type);

        for(const AuthData *curdat=&rec; curdat; curdat=curdat->_next){
            bool newentry=true;
            for(const AuthData *olddat=&old; olddat; olddat=olddat->_next){
                if(strcmp(olddat->Data->uuid,curdat->Data->uuid)==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;
@@ -576,10 +619,8 @@ VALUEFOUND:
            backend.write((unsigned char*)newel->data,newel->datasize);
        }

        char cuid[255];
        const unsigned char zero = 0;

        uuid_unparse(uid,cuid);

        for(auto chel : changemap){
            size_t rd=sizeof(authdb::AuthHeader),end=backend.end();
@@ -587,7 +628,7 @@ VALUEFOUND:
                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){
                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);
@@ -616,24 +657,18 @@ VALUEFOUND:
    void delRecord(AuthBackend &backend,const uuid_t uid){
        size_t end=backend.end(),rd=sizeof(AuthHeader);

        char cuid[255];

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

        uuid_unparse(uid,cuid);

        while(rd<end){
            authdb::AuthData::Record *cur=new AuthData::Record;
            size_t wr=backend.getPos();
            backend.setPos(rd);
            size_t wr=backend.getPos();
            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){
                // std::cout << cur->uuid << std::endl;
            if(uuid_compare(uid,cur->uuid) == 0){
                size_t dsize=cur->datasize;
                memset(cur,0,sizeof(AuthData));
                memset(cur,0,sizeof(AuthData::Record));
                cur->start = 0xFE;
                cur->datasize=dsize;
                backend.setPos(wr);
+6 −6
Changes for src/authdb.h: 6 added lines, 6 removed lines.
Original line number Diff line number Diff line
@@ -43,7 +43,7 @@ namespace authdb {

    class AuthData {
    public:
        AuthData();
        AuthData(const uuid_t id);

        AuthData(const AuthData &src);

@@ -53,7 +53,7 @@ namespace authdb {

        struct Record {
            char   start = 0xFE;
            char   uuid[255];
            uuid_t uuid;
            int    type;
            int    storage;
            char   fieldname[255];
@@ -68,14 +68,14 @@ namespace authdb {
        AuthData *_next;

        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    bool getRecord(authdb::AuthBackend &backend,AuthData &rec,int type);
        friend    bool editRecord(AuthBackend &backend,AuthData &rec,int type);
        friend    void delRecord(authdb::AuthBackend &backend,const uuid_t uid);
    };


    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);
    bool getRecord(authdb::AuthBackend &backend,AuthData &rec,int type);
    bool editRecord(AuthBackend &backend,AuthData &rec,int type);
    void delRecord(authdb::AuthBackend &backend,const uuid_t uid);

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

File changed.

Preview size limit exceeded, changes collapsed.

+5 −4
Changes for src/user.h: 5 added lines, 4 removed lines.
Original line number Diff line number Diff line
@@ -39,8 +39,8 @@
namespace authdb {
    class UserData {
    public:
        UserData();
        UserData(uuid_t id);

        ~UserData();

        void setUserName(const char* src);
@@ -62,6 +62,7 @@ namespace authdb {
        void getAvatar(std::vector<char> &dest);

        AuthData        *Data;
        uuid_t           uid;
    private:
        AuthData::Record  *username;
        AuthData::Record  *firstname;
@@ -70,7 +71,6 @@ namespace authdb {
        AuthData::Record  *pwhash;
        //optional
        AuthData::Record  *avatar;
        char               uid[255];
        friend class User;
    };

@@ -78,9 +78,10 @@ namespace authdb {
    public:
        void create(AuthBackend &backend,class UserData *dat);
        void remove(AuthBackend &backend,const uuid_t uid);
        bool exits(AuthBackend &backend,uuid_t *uid,const char *name, int &ret);

        void edit(AuthBackend &backend,uuid_t uid,class UserData &dat,size_t &pos);
        void info(AuthBackend &backend,uuid_t uid,class UserData &dat,size_t &pos);
        void edit(AuthBackend &backend,class UserData &dat,size_t &pos);
        void info(AuthBackend &backend,class UserData &dat,size_t &pos);
    };

    class UserAPi{