Commit 1084a553 authored by jan.koester's avatar jan.koester
Browse files

logical error fixed

parent 6a5dad6f
Loading
Loading
Loading
Loading
Loading
+227 −7
Changes for src/authdb.cpp: 227 added lines, 7 removed lines.
Original line number Diff line number Diff line
@@ -964,7 +964,7 @@ namespace authdb {
            }else if(uuid_parse(cdid,did) == 0 ){
                backend=dbackend.data(did);
            }else{
                throw AuthBackendError("listGroups: could not parse uuid!");
                throw AuthBackendError("removeGroup: could not parse uuid!");
            }

            grouplist << "<div><p>GroupList:</p><table class=\"userlist\">";
@@ -993,9 +993,13 @@ namespace authdb {
                        << "<ul><li>"
                        << "uid: " << cruid
                        << "</li>"
                        << "</ul></td><td><a class=\"button\" href=\"/settings/"
                        << "</ul></td><td><ul><li><a class=\"button\" href=\"/settings/"
                        << cdid
                        << "/removegroup/" << cruid << "\">Remove group</a></li>"
                        << "<li><a class=\"button\" href=\"/settings/"
                        << cdid
                        << "/removegroup/" << cruid << "\">Remove group</a></td></tr>";
                        << "/editgroup/" << cruid << "\">Edit group</a></li>"
                        << "</ul></td></tr>";
                    }catch(AuthBackendError &e){
                        std::cerr << e.what() << std::endl;
                    }
@@ -1032,12 +1036,12 @@ namespace authdb {

            AuthBackend *backend=nullptr;

            if(strcmp(cdid,"admin")!=0){
                if(uuid_parse(cdid,did)<0)
                    throw AuthBackendError("createGroups: wrong domain id !");
            if(strcmp(cdid,"admin") == 0 ){
                backend=&_AdminBackend;
            }else if(uuid_parse(cdid,did) == 0 ){
                backend=dbackend.data(did);
            }else{
                backend=&_AdminBackend;
                throw AuthBackendError("createGroups: could not parse uuid!");
            }

            if(!backend)
@@ -1203,6 +1207,220 @@ namespace authdb {
            rep.send(curreq,nullptr,0);
        }

        void editGroup(libhttppp::HttpRequest *curreq, const int tid, ULONG_PTR args){
            char cdid[255],cgid[255];
            uuid_t did;

            if(sscanf(curreq->getRequestURL(),"/settings/%[^/]/editgroup/%s",cdid,cgid)<0){
                throw AuthBackendError("listUsers: wrong url!");
            }

            DomainBackend dbackend(_AdminBackend);

            AuthBackend *backend=nullptr;

            if(strcmp(cdid,"admin") == 0 ){
                backend=&_AdminBackend;
            }else if(uuid_parse(cdid,did) == 0 ){
                backend=dbackend.data(did);
            }else{
                throw AuthBackendError("listUsers: could not parse uuid!");
            }


            size_t rd=sizeof(authdb::AuthHeader),end=backend->end();

            uuid_t gid;
            uuid_parse(cgid,gid);

            AuthData editrec(gid);

            bool data = false;

            libhttppp::HttpForm curform;

            curform.parse(curreq);


            for (libhttppp::HttpForm::MultipartForm::Data* curformdat = curform.MultipartFormData.getFormData();
                    curformdat; curformdat = curformdat->nextData()) {

                    AuthData curec(gid);

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

                    for(libhttppp::HttpForm::MultipartForm::Data::ContentDisposition *curdispo=curformdat->getDisposition();
                        curdispo; curdispo=curdispo->nextContentDisposition()
                    ){


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

                        data = true;

                        std::string key;

                        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());
                        }

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

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

                        for(auto t : curformdat->Value){
                            if(!std::isdigit(t)){
                                numeric=false;
                                break;
                            }
                        }

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



                    if(curec.Data->storage==TextStorage) {
                        curformdat->Value.push_back('\0');
                        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);

                        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(),
                               curformdat->Value.size());

                        editrec.append(curec);
                        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;
                        int val=atoi(curformdat->Value.data());
                        memcpy(curec.Data->data,&val,
                               curec.Data->datasize);

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

            }

            if(data){
                editRecord(*backend,editrec,GroupData);
                libhttppp::HttpResponse rep;
                rep.setState(HTTP307);
                rep.setVersion(HTTPVERSION(1.1));
                char rurl[255];
                snprintf(rurl,255,"/settings/%s/listgroups",cdid);
                rep.setHeaderData("Location")->push_back(rurl);
                rep.setContentType("text/html");
                rep.send(curreq,nullptr,0);
                return;
            }
            libhtmlpp::HtmlPage page;

            libhtmlpp::HtmlString form,out;

            form  << "<form method=\"post\" enctype=\"multipart/form-data\">"
                  << "<table>";

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

                backend->setPos(rd);
                backend->read((unsigned char*)&cur,sizeof(AuthData::Record));
                rd=backend->getPos()+cur.datasize;

                if(uuid_compare(cur.uuid,gid)==0 && cur.type==GroupData && cur.storage==TextStorage){
                    cur.data = new char[cur.datasize];
                    backend->read((unsigned char*)cur.data,cur.datasize);
                    try {
                        form  << "<tr><td><label for=\""<< cur.fieldname <<"\">" << 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;
                } else if(uuid_compare(cur.uuid,gid)==0 && cur.type==GroupData && cur.storage==BinaryStorage
                    && strcmp(cur.fieldname ,"groupmembers")==0
                ){
                    cur.data = new char[cur.datasize];
                    backend->read((unsigned char*)cur.data,cur.datasize);

                    GroupData::MemberUids mrec;
                    memcpy(&mrec,cur.data,sizeof(GroupData::MemberUids));

                    mrec.uid=new uuid_t[mrec.count];
                    memcpy(mrec.uid,cur.data+sizeof(GroupData::MemberUids),
                           (sizeof(uuid_t)*mrec.count));

                    for(size_t i=0; i<mrec.count; ++i ){
                        size_t urd=sizeof(AuthHeader),uend=backend->end();
                        while(urd<uend){
                            authdb::AuthData::Record curu;
                            backend->setPos(urd);
                            backend->read((unsigned char*)&curu,sizeof(AuthData::Record));
                            urd=backend->getPos()+curu.datasize;

                            if(curu.type == UserData && uuid_compare(mrec.uid[i],curu.uuid) == 0 &&
                                curu.storage==TextStorage && strcmp(curu.fieldname,"username")==0){

                                curu.data = new char[curu.datasize];
                                backend->read((unsigned char*)curu.data,curu.datasize);
                                std::cout << curu.data << std::endl;
                                delete[] curu.data;
                                break;
                            }
                        }
                    }

                    delete[] mrec.uid;
                }

            }

            form  << "<tr><td></td><td><input type=\"submit\"></td></tr>"
                  << "</table>"
                  << "</form";

            libhtmlpp::HtmlElement root=_IndexElement;
            libhtmlpp::HtmlElement *content=root.getElementbyID("content");

            content->insertChild(form.parse());

            libhtmlpp::print(&root,out,true);

            libhttppp::HttpResponse rep;
            rep.setContentType("text/html");
            rep.setContentLength(out.size());
            rep.send(curreq,out.c_str(),out.size());
        }

        void SettingsController(libhttppp::HttpRequest *curreq, const int tid, ULONG_PTR args){
            _AdminBackend.lock();

@@ -1232,6 +1450,8 @@ namespace authdb {
                    createGroup(curreq,tid,args,"creategroup");
                }else if(strncmp(url,"removegroup",10)==0){
                    removeGroup(curreq,tid,args,"removegroup");
                }else if(strncmp(url,"editgroup",9)==0){
                    editGroup(curreq,tid,args);
                }else{
                    libhtmlpp::HtmlElement root=_IndexElement;
                    libhtmlpp::HtmlString out;
+2 −1
Changes for src/authdb.h: 2 added lines, 1 removed line.
Original line number Diff line number Diff line
@@ -65,9 +65,10 @@ namespace authdb {

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

    protected:
        AuthData *_next;
    private:

        friend    int searchValue(authdb::AuthBackend &backend,const char*fieldname,const char *value);
        friend    bool getRecord(authdb::AuthBackend &backend,AuthData &rec,int type);
+3 −3
Changes for src/domain.cpp: 3 added lines, 3 removed lines.
Original line number Diff line number Diff line
@@ -57,6 +57,7 @@ namespace authdb {

        if(!target){
            target=new AuthData::Record;
            *varclass=dat->append(*target)->Data;
        }

        target->start=0xFE;
@@ -69,7 +70,7 @@ namespace authdb {
        target->data= new char[target->datasize];
        strcpy(target->data,value);

        *varclass=dat->append(*target)->Data;

    }

    inline const char *getDomainData(const AuthData *dat,AuthData::Record **varclass,const char *varname){
@@ -115,6 +116,7 @@ namespace authdb {

        if(!target){
            target=new AuthData::Record;
            *varclass=dat->append(*target)->Data;
        }

        target->start=0xFE;
@@ -126,8 +128,6 @@ namespace authdb {
        target->datasize=sizeof(int);
        target->data= new char[target->datasize];
        memcpy(target->data,&value,target->datasize);

        *varclass=dat->append(*target)->Data;
    }

    inline int getIntDomainData(const AuthData *dat,AuthData::Record **varclass,const char *varname){
+15 −18
Changes for src/group.cpp: 15 added lines, 18 removed lines.
Original line number Diff line number Diff line
@@ -56,6 +56,7 @@ namespace authdb{

        if(!target){
            target=new AuthData::Record;
            *varclass=dat->append(*target)->Data;
        }

        memset(target,0,sizeof(AuthData::Record));
@@ -69,8 +70,6 @@ namespace authdb{
        target->datasize=strlen(value)+1;
        target->data= new char[target->datasize];
        strcpy(target->data,value);

        *varclass=dat->append(*target)->Data;
    }

    inline const char *getGroupData(const AuthData *dat,AuthData::Record **varclass,const char *varname){
@@ -93,35 +92,32 @@ namespace authdb{
    }
};

authdb::GroupData::GroupData(uuid_t gid){
    Data=new AuthData(gid);
authdb::GroupData::GroupData(uuid_t gid) : AuthData(gid){
    uuid_copy(_Gid,gid);
    _Name=nullptr;
    _Members=nullptr;
}

authdb::GroupData::~GroupData(){
    delete Data;
}

void authdb::GroupData::setName(const char* name){
    setGroupData(Data,&_Name,"groupname",name);
    setGroupData(this,&_Name,"groupname",name);
}

const char* authdb::GroupData::getName(){
    return getGroupData(this->Data,&_Name,"groupname");
    return getGroupData(this,&_Name,"groupname");
}

void authdb::GroupData::addMember(const MemberUids &uid){
        AuthData *curec=Data;
        AuthData *curec=this;

        if(!_Members){
            while(curec){
                if(curec->Data->type == authdb::GroupData &&
                    uuid_compare(curec->Data->uuid,Data->Data->uuid)==0 &&
                    uuid_compare(curec->Data->uuid,Data->uuid)==0 &&
                    strcmp(curec->Data->fieldname,"groupmembers")==0
                ){

                    _Members=curec->Data;
                    _Members->datasize=0;
                    delete[] _Members->data;
@@ -134,6 +130,7 @@ void authdb::GroupData::addMember(const MemberUids &uid){

        if(!_Members){
            _Members=new AuthData::Record;
            _Members=append(*_Members)->Data;
        }

        size_t mtsize=sizeof(GroupData::MemberUids)+(sizeof(uuid_t)*uid.count);
@@ -149,9 +146,9 @@ void authdb::GroupData::addMember(const MemberUids &uid){
        _Members->datasize = sizeof(GroupData::MemberUids)+mtsize;
        _Members->data=new char[_Members->datasize];
        memcpy(_Members->data,&uid,sizeof(GroupData::MemberUids));
        memcpy(_Members->data+sizeof(GroupData::MemberUids),&uid.uid,(sizeof(uuid_t)*uid.count));
        memcpy(_Members->data+sizeof(GroupData::MemberUids),uid.uid,(sizeof(uuid_t)*uid.count));


        _Members=Data->append(*_Members)->Data;
}


@@ -198,7 +195,7 @@ void authdb::Group::create(AuthBackend& backend, class GroupData* dat){

    size_t wd=backend.end();

    for(AuthData *curec=dat->Data; curec; curec=curec->next()){
    for(AuthData *curec=dat; curec; curec=curec->next()){
         curec->Data->type=GroupData;
         backend.setPos(wd);
         backend.write((unsigned char*)curec->Data,sizeof(struct AuthData::Record));
@@ -220,13 +217,13 @@ void authdb::Group::info(AuthBackend &backend, class GroupData& dat, size_t &pos
        pos=backend.getPos()+cur->datasize;
        if(cur->type == GroupData && uuid_compare(dat._Gid,cur->uuid) == 0){

            if(!getRecord(backend,*dat.Data,DataType::GroupData))
            if(!getRecord(backend,dat,DataType::GroupData))
                continue;

            if(strcmp(dat.Data->Data->fieldname,"groupname")==0){
                dat._Name=dat.Data->Data;
            }else if(strcmp(dat.Data->Data->fieldname,"groupmembers")==0){
                dat._Members=dat.Data->Data;
            if(strcmp(dat.Data->fieldname,"groupname")==0){
                dat._Name=dat.Data;
            }else if(strcmp(dat.Data->fieldname,"groupmembers")==0){
                dat._Members=dat.Data;
            }
        }
        delete cur;
+1 −3
Changes for src/group.h: 1 added line, 3 removed lines.
Original line number Diff line number Diff line
@@ -34,7 +34,7 @@
#pragma once

namespace authdb {
    class GroupData {
    class GroupData : public AuthData{
    public:

        GroupData(uuid_t gid);
@@ -54,8 +54,6 @@ namespace authdb {
        void remMember(const MemberUids &uid);
        bool isMember(const MemberUids &uid);

        AuthData *Data;

    private:
        uuid_t            _Gid;
        AuthData::Record *_Name;
Loading