Commit 6a5dad6f authored by jan.koester's avatar jan.koester
Browse files

remove unessary

parent 5d2298b7
Loading
Loading
Loading
Loading
Loading

modules/facebook.cpp

deleted100644 → 0
+0 −0

Empty file deleted.

modules/google.cpp

deleted100644 → 0
+0 −0

Empty file deleted.

+94 −12
Changes for src/authdb.cpp: 94 added lines, 12 removed lines.
Original line number Diff line number Diff line
@@ -967,11 +967,43 @@ namespace authdb {
                throw AuthBackendError("listGroups: could not parse uuid!");
            }

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

            size_t rd=sizeof(authdb::AuthHeader),end=backend->end();
            while(rd<end){
                authdb::AuthData::Record cur;

                cur.type=EmptyData;

                backend->setPos(rd);
                backend->read((unsigned char*)&cur,sizeof(AuthData::Record));

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

                if(cur.type == GroupData && strcmp(cur.fieldname,"groupname")==0){
                    class GroupData gdat(cur.uuid);
                    try {
                        size_t upos=sizeof(authdb::AuthHeader);
                        group.info(*backend,gdat,upos);

                        char cruid[20];
                        uuid_unparse(cur.uuid,cruid);
                        grouplist << "<tr><td class=\"list_groupname\">" << gdat.getName()
                        << "</td><td>"
                        << "<ul><li>"
                        << "uid: " << cruid
                        << "</li>"
                        << "</ul></td><td><a class=\"button\" href=\"/settings/"
                        << cdid
                        << "/removegroup/" << cruid << "\">Remove group</a></td></tr>";
                    }catch(AuthBackendError &e){
                        std::cerr << e.what() << std::endl;
                    }
                }
            }
            content->appendChild(domel);

            grouplist << "<div><ul class=\"grouptoolbar\" ><li><a class=\"button\" href=\"/settings/"<< cdid << "/creategroup\">CreateGroup</a></li></ul></div>";
            grouplist << "</table></div><div><ul class=\"grouptoolbar\" ><li><a class=\"button\" href=\"/settings/"<< cdid << "/creategroup\">CreateGroup</a></li></ul></div>";

            content->appendChild(grouplist.parse());

@@ -1021,7 +1053,9 @@ namespace authdb {
                uuid_t gid;
                uuid_generate(gid);

                class GroupData grp(gid);
                class GroupData grpdat(gid);

                struct GroupData::MemberUids member;

                for (libhttppp::HttpForm::MultipartForm::Data* curformdat = curform.MultipartFormData.getFormData();
                     curformdat; curformdat = curformdat->nextData()) {
@@ -1052,8 +1086,12 @@ namespace authdb {
                if(gname.empty())
                    throw AuthBackendError("createGroups: no doamin name given");

                grp.Members->count=gcount;
                grp.Members->uid = new uuid_t[gcount];
                Group grp;

                grpdat.setName(gname.c_str());

                member.count=gcount;
                member.uid = new uuid_t[gcount];

                size_t git=0;

@@ -1069,14 +1107,18 @@ namespace authdb {
                                       [](unsigned char c){ return std::tolower(c); });

                        if(tmp=="name" && strcmp(curdispo->getValue(),"members")==0){
                            uuid_parse(curformdat->Value.data(),grp.Members->uid[git]);
                            uuid_parse(curformdat->Value.data(),member.uid[git]);
                            ++git;
                        }
                    }

                }

                delete[] grp.Members->uid;
                grpdat.addMember(member);

                grp.create(*backend,&grpdat);

                delete[] member.uid;
            }

            size_t rd=sizeof(authdb::AuthHeader),end=backend->end();
@@ -1123,6 +1165,44 @@ namespace authdb {
            rep.send(curreq,out.c_str(),out.size());
        }

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

            if(sscanf(curreq->getRequestURL(),"/settings/%[^/]/removegroup/%s",cdid,gid)<0){
                throw AuthBackendError("removeGroup: 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("removeGroup: could not parse uuid!");
            }

            Group group;

            uuid_t uuid;

            uuid_parse(gid,uuid);

            group.remove(*backend,uuid);

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

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

@@ -1134,22 +1214,24 @@ namespace authdb {
            try {
                if(strncmp(url,"listusers",9)==0){
                    listUsers(curreq,tid,args,"listusers");
                }else if(strncmp(url,"createuser",9)==0){
                }else if(strncmp(url,"createuser",10)==0){
                    createUser(curreq,tid,args,"createuser");
                }else if(strncmp(url,"removeuser",9)==0){
                }else if(strncmp(url,"removeuser",10)==0){
                    removeuser(curreq,tid,args);
                }else if(strncmp(url,"edituser",8)==0){
                    editUser(curreq,tid,args);
                }else if(strncmp(url,"listdomains",9)==0){
                }else if(strncmp(url,"listdomains",11)==0){
                    listDomains(curreq,tid,args);
                }else if(strncmp(url,"createdomain",12)==0){
                }else if(strncmp(url,"createdomain",11)==0){
                    createDomain(curreq,tid,args);
                }else if(strncmp(url,"removedomain",12)==0){
                }else if(strncmp(url,"removedomain",11)==0){
                    removeDomain(curreq,tid,args);
                }else if(strncmp(url,"listgroups",10)==0){
                    listGroups(curreq,tid,args,"listgroups");
                }else if(strncmp(url,"creategroup",11)==0){
                }else if(strncmp(url,"creategroup",10)==0){
                    createGroup(curreq,tid,args,"creategroup");
                }else if(strncmp(url,"removegroup",10)==0){
                    removeGroup(curreq,tid,args,"removegroup");
                }else{
                    libhtmlpp::HtmlElement root=_IndexElement;
                    libhtmlpp::HtmlString out;
+204 −2
Changes for src/group.cpp: 204 added lines, 2 removed lines.
Original line number Diff line number Diff line
@@ -25,12 +25,214 @@
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *******************************************************************************/

#include <cstring>

#include "authdb.h"
#include "types.h"
#include "group.h"

namespace authdb{
    inline void setGroupData(AuthData *dat,AuthData::Record **varclass,const char *varname,const char *value){
        AuthData::Record *target=*varclass;

        AuthData *curec=dat;

        if(!target){
            while(curec){
                if(curec->Data->type == authdb::GroupData &&
                    uuid_compare(curec->Data->uuid,dat->Data->uuid)==0 &&
                    strcmp(curec->Data->fieldname,varname)==0
                ){

                    target=curec->Data;
                    target->datasize=0;
                    delete[] target->data;
                    target->data=nullptr;
                    break;
                }
                curec=curec->next();
            }
        }

        if(!target){
            target=new AuthData::Record;
        }

        memset(target,0,sizeof(AuthData::Record));

        target->start=0xFE;
        uuid_copy(target->uuid,dat->Data->uuid);
        target->type=DataType::GroupData;
        target->storage=StorageType::TextStorage;

        snprintf(target->fieldname,255,"%s",varname);
        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){
        if(*varclass && (*varclass)->data ){
            return (*varclass)->data;
        }else{
            for(const AuthData *curdat=dat; curdat; curdat=curdat->next()){
                if(curdat->Data && curdat->Data->storage == StorageType::TextStorage &&
                    curdat->Data->type==DataType::GroupData
                    && strcmp(curdat->Data->fieldname,varname)==0){
                    *varclass=curdat->Data;
                    return curdat->Data->data;
                }
            }
        }
        std::string err;
        err=varname;
        err+=" data not found !";
        throw(authdb::AuthBackendError(err.c_str()));
    }
};

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

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

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

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

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

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

                    _Members=curec->Data;
                    _Members->datasize=0;
                    delete[] _Members->data;
                    _Members->data=nullptr;
                    break;
                }
                curec=curec->next();
            }
        }

        if(!_Members){
            _Members=new AuthData::Record;
        }

        size_t mtsize=sizeof(GroupData::MemberUids)+(sizeof(uuid_t)*uid.count);

        memset(_Members,0,sizeof(AuthData::Record));

        _Members->start=0xFE;
        uuid_copy(_Members->uuid,_Gid);
        _Members->type=DataType::GroupData;
        _Members->storage=StorageType::BinaryStorage;

        snprintf(_Members->fieldname,255,"%s","groupmembers");
        _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));

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


bool authdb::Group::exits(AuthBackend& backend, uuid_t* gid, const char* name, int& ret){
    authdb::AuthData::Record cur;

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

    while(rd<end){
        backend.setPos(rd);
        backend.read((unsigned char*)&cur,sizeof(AuthData::Record));
        rd=backend.getPos()+cur.datasize;
        if(strcmp(cur.fieldname,"groupname")==0 ){
            cur.data=new char[cur.datasize];
            backend.read((unsigned char*)cur.data,cur.datasize);
            if(name && strcmp(cur.data,name) == 0){
                delete[] cur.data;
                ret=1;
                return true;

            }else if(gid && uuid_compare(cur.uuid,*gid)==0){
                delete[] cur.data;
                ret=2;
                return true;
            }
            delete[] cur.data;
        }
    }
    ret=-1;
    return false;
}

void authdb::Group::create(AuthBackend& backend, class GroupData* dat){
    int exi=0;

    if(exits(backend,&dat->_Gid,dat->getName(),exi)){
       switch(exi){
           case 1:
                throw authdb::AuthBackendError("Create Group: Groupname already Exists aborting!");
           default:
                throw authdb::AuthBackendError("Create Group: GUID already Exists aborting!");
       }
    }

    size_t wd=backend.end();

    for(AuthData *curec=dat->Data; curec; curec=curec->next()){
         curec->Data->type=GroupData;
         backend.setPos(wd);
         backend.write((unsigned char*)curec->Data,sizeof(struct AuthData::Record));
         backend.write((unsigned char*)curec->Data->data,curec->Data->datasize);
         wd=backend.end();
    }
}

void authdb::Group::info(AuthBackend &backend, class GroupData& dat, size_t &pos){
    size_t end=backend.end();

    if(uuid_is_null(dat._Gid))
        throw AuthBackendError("group info gid required!");

    while(pos<end){
        authdb::AuthData::Record *cur=new AuthData::Record;
        backend.setPos(pos);
        backend.read((unsigned char*)cur,sizeof(AuthData::Record));
        pos=backend.getPos()+cur->datasize;
        if(cur->type == GroupData && uuid_compare(dat._Gid,cur->uuid) == 0){

            if(!getRecord(backend,*dat.Data,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;
            }
        }
        delete cur;
    }
}

void authdb::Group::remove(AuthBackend& backend, const uuid_t gid){
    delRecord(backend,gid,DataType::GroupData);
}
+7 −6
Changes for src/group.h: 7 added lines, 6 removed lines.
Original line number Diff line number Diff line
@@ -43,20 +43,21 @@ namespace authdb {
        ~GroupData();

        void setName(const char *name);
        const char *getName() const;

        void addMember(uuid_t uid);
        void remMember(uuid_t uid);
        bool isMember(uuid_t uid) const;
        const char *getName();

        struct MemberUids {
            size_t  count;
            uuid_t *uid;
        } *Members;
        };

        void addMember(const MemberUids &uid);
        void remMember(const MemberUids &uid);
        bool isMember(const MemberUids &uid);

        AuthData *Data;

    private:
        uuid_t            _Gid;
        AuthData::Record *_Name;
        AuthData::Record *_Members;
        friend class Group;