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

test

parent ad697dcb
Loading
Loading
Loading
Loading
Loading
+19 −72
Changes for src/admin.cpp: 19 added lines, 72 removed lines.
Original line number Diff line number Diff line
@@ -964,44 +964,12 @@ namespace authdb {

                class GroupData grpdat(gid);

                struct GroupData::MemberUids member;

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

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


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

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

                        if(tmp=="name" && strcmp(curdispo->getValue(),"groupmembers")==0){
                            ++gcount;
                        }

                        if(tmp=="name" && strcmp(curdispo->getValue(),"groupname")==0){
                            std::copy(curformdat->Value.begin(),curformdat->Value.end(),std::back_inserter(gname));
                        }

                    }
                }

                if(gname.empty())
                    throw AuthBackendError("createGroups: no doamin name given");
                std::vector <uuid> members;

                Group grp;

                grpdat.setName(gname.c_str());

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

                size_t git=0;

                for (libhttppp::HttpForm::MultipartForm::Data* curformdat = curform.MultipartFormData.getFormData();
@@ -1017,14 +985,15 @@ namespace authdb {

                        if(tmp=="name" && strcmp(curdispo->getValue(),"groupmembers")==0){
                            curformdat->Value.push_back('\0');
                            if(uuid_parse(curformdat->Value.data(),member.uid[git++])!=0)
                                throw AuthBackendError("Creategroup: cannot parse uuid!");
                            members.emplace_back(curformdat->Value.data());
                        }
                    }

                }

                for(auto member : members){
                    grpdat.addMember(member);
                }

                grp.create(*backend,&grpdat);

@@ -1140,6 +1109,8 @@ namespace authdb {

            class GroupData editrec(gid);

            std::vector<uuid> members;

            bool data = false;

            libhttppp::HttpForm curform;
@@ -1148,35 +1119,6 @@ namespace authdb {

            if(curform.MultipartFormData.getFormData()){

                GroupData::MemberUids members;
                members.count=0;
                members.uid = nullptr;

                size_t count = 0;

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

                        std::string key=curdispo->getKey();

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

                        if( key=="name" && strcmp(curdispo->getValue(),"groupmembers")==0){
                            ++members.count;
                        }
                    }
                }

                if(members.count>0)
                    members.uid = new uuid_t[members.count];

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

@@ -1225,10 +1167,8 @@ namespace authdb {

                     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++]);

                         members.emplace_back(curformdat->Value.data());
                     }else if(curec.Data.storage==TextStorage) {
                         curformdat->Value.push_back('\0');
                         curec.Data.datasize=curformdat->Value.size();
@@ -1261,7 +1201,9 @@ namespace authdb {
                }

                if(data){
                    editrec.addMember(members);
                    for(auto mem : members){
                        editrec.addMember(mem);
                    }
                    editRecord(*backend,editrec,GroupData);
                    libhttppp::HttpResponse rep;
                    rep.setState(HTTP307);
@@ -1310,7 +1252,12 @@ namespace authdb {
                        cur.data = new char[cur.datasize];
                        backend->read((unsigned char*)cur.data,cur.datasize);

                        GroupData::MemberUids mrec(cur.data,cur.datasize);
                        std::vector<uuid> mrecs;
                        class Group grp;
                        class GroupData gdat(cur.uuid);
                        size_t gdpos=sizeof(AuthHeader);
                        grp.info(*backend,gdat,gdpos);
                        gdat.getMembers(mrecs);

                        delete[] cur.data;

@@ -1330,8 +1277,8 @@ namespace authdb {
                                uuid_unparse(curu.uuid,cuuid);

                                form << "<option value=\"" << cuuid << "\" ";
                                for(size_t i=0; i<mrec.count; ++i ){
                                    if(mrec.uid && uuid_compare(mrec.uid[i],curu.uuid) == 0){
                                for(auto mrec : mrecs){
                                    if(mrec == curu.uuid ){
                                        form << " selected ";
                                        break;
                                    }
+1 −6
Changes for src/authdb.cpp: 1 added line, 6 removed lines.
Original line number Diff line number Diff line
@@ -130,12 +130,7 @@ namespace authdb {

                    gdat.setName("SuperAdmin");

                    authdb::GroupData::MemberUids muid;

                    muid.count=1;
                    muid.addUid(adminid);

                    gdat.addMember(muid);
                    gdat.addMember(adminid);

                    group.create(_AdminBackend,&gdat);

+149 −50
Changes for src/group.cpp: 149 added lines, 50 removed lines.
Original line number Diff line number Diff line
@@ -26,6 +26,7 @@
 *******************************************************************************/

#include <cstring>
#include <vector>
#include <memory>

#include "authdb.h"
@@ -46,93 +47,191 @@ authdb::GroupData::GroupData(const GroupData& src) : AuthData(src){
authdb::GroupData::~GroupData(){
}

authdb::GroupData::MemberUids::MemberUids(){
    count=0;
    uid=nullptr;
void authdb::GroupData::setName(const char* name){
    setAuthData<const char>(DataType::GroupData,StorageType::TextStorage, this,&_Name,"groupname",name,strlen(name)+1);
}

authdb::GroupData::MemberUids::MemberUids(const MemberUids& src){
    count=src.count;
    uid=new uuid_t[count];
    std::copy(
        reinterpret_cast<char*>(src.uid),
        reinterpret_cast<char*>(src.uid)+(count*sizeof(uuid_t)),
        reinterpret_cast<char*>(uid)
    );
const char* authdb::GroupData::getName(){
    return getAuthData<char>(DataType::GroupData,StorageType::TextStorage,
                             this,&_Name,"groupname");
}

authdb::GroupData::MemberUids::MemberUids(char* src,size_t srclen){
    std::copy(src,src+sizeof(size_t),&count);
    uid=new uuid_t[count];
    size_t ipos=0;
    for(size_t i =sizeof(size_t); i<srclen; i+=sizeof(uuid_t)){
        std::copy(src+i,src+(i+sizeof(uuid_t)),uid[ipos++]);
void authdb::GroupData::addMember(const uuid &uid){
    try{
        if(!getAuthData<char>(DataType::GroupData,StorageType::BinaryStorage,
                                                                        this,&_Members,"gpoallowed"))
               return;
    }catch(...){
        return;
    }
    size_t asize=0;

    std::copy(_Members->data,_Members->data+sizeof(size_t),&asize);

    if(asize==0)
        return;

    asize*=sizeof(uuid_t);

    char *start=_Members->data+sizeof(size_t);

    std::vector<uuid> members;

    for(size_t i =0; i<asize; i+=sizeof(uuid_t) ){
        uuid_t tmp;
        std::copy(start+i,start+i+sizeof(uuid_t),&tmp[0]);
        members.push_back(tmp);
    }

authdb::GroupData::MemberUids::~MemberUids(){
    delete[] uid;
    for(const uuid &mem : members){
        if(mem==uid)
            throw AuthBackendError("User is already member!");
    }

void authdb::GroupData::MemberUids::addUid(const uuid& src){
        uuid_t *tmp=new uuid_t[count+1];
        if(uid){
    members.push_back(uid);

    size_t wsize=members.size();

    char *data=new  char[(wsize*sizeof(uuid_t))+sizeof(size_t)];
    memset(data,0,(wsize*sizeof(uuid_t))+sizeof(size_t));

    std::copy(&wsize,&wsize+sizeof(size_t),data);

    wsize=sizeof(size_t);

    for(const uuid &mem : members){
        std::copy(
                reinterpret_cast<char*>(uid),
                reinterpret_cast<char*>(uid+sizeof(count*sizeof(uuid_t))),
                reinterpret_cast<char*>(tmp)
           &mem.value[0],
           &mem.value[0]+sizeof(uuid_t),
           data+wsize
        );
        char tmp[255];
        wsize+=sizeof(uuid_t);
    }
        uuid_copy(tmp[count],src.value);
        delete[] uid;
        uid=tmp;
        ++count;

    setAuthData<char>(DataType::PolicyData,StorageType::BinaryStorage,this,&_Members,"groupmembers",data,wsize);

    delete[] data;
}

void authdb::GroupData::remMember(const uuid& uid){
        try{
        if(!getAuthData<char>(DataType::GroupData,StorageType::BinaryStorage,
                                                                        this,&_Members,"gpoallowed"))
               return;
    }catch(...){
        return;
    }
    size_t asize=0;

void authdb::GroupData::setName(const char* name){
    setAuthData<const char>(DataType::GroupData,StorageType::TextStorage, this,&_Name,"groupname",name,strlen(name)+1);
    std::copy(_Members->data,_Members->data+sizeof(size_t),&asize);

    if(asize==0)
        return;

    asize*=sizeof(uuid_t);

    char *start=_Members->data+sizeof(size_t);

    std::vector<uuid> members;

    for(size_t i =0; i<asize; i+=sizeof(uuid_t) ){
        uuid_t tmp;
        std::copy(start+i,start+i+sizeof(uuid_t),&tmp[0]);
        members.push_back(tmp);
    }

const char* authdb::GroupData::getName(){
    return getAuthData<char>(DataType::GroupData,StorageType::TextStorage,
                             this,&_Name,"groupname");
    for(auto mem = members.begin(); mem!=members.end(); ++mem){
        if(*mem==uid)
            members.erase(mem);
    }

void authdb::GroupData::addMember(const MemberUids &uid){
    size_t uidsize=(sizeof(uuid_t)*uid.count);
    char *data=new char[uidsize+sizeof(size_t)];
    memset(data,0,uidsize+sizeof(size_t));
    std::copy(&uid.count,&uid.count+sizeof(size_t),data);
    if(uid.count>0){
    size_t wsize=members.size();

    char *data=new  char[(wsize*sizeof(uuid_t))+sizeof(size_t)];
    memset(data,0,(wsize*sizeof(uuid_t))+sizeof(size_t));

    std::copy(&wsize,&wsize+sizeof(size_t),data);

    wsize=sizeof(size_t);

    for(const uuid &mem : members){
        std::copy(
            reinterpret_cast<char*>(uid.uid),
            reinterpret_cast<char*>(uid.uid)+uidsize,
            data+sizeof(size_t)
           &mem.value[0],
           &mem.value[0]+sizeof(uuid_t),
           data+wsize
        );
        char tmp[255];
        wsize+=sizeof(uuid_t);
    }
    setAuthData<const char>(DataType::GroupData,StorageType::BinaryStorage,this,&_Members,"groupmembers",data,uidsize+sizeof(size_t));

    setAuthData<char>(DataType::PolicyData,StorageType::BinaryStorage,this,&_Members,"groupmembers",data,wsize);

    delete[] data;
}


bool authdb::GroupData::isMember(const uuid uid){
    if(!_Members){
    try{
        if(!getAuthData<char>(DataType::GroupData,StorageType::BinaryStorage,
                             this,&_Members,"groupmembers"))
                                                                        this,&_Members,"gpoallowed"))
               return false;
    }catch(...){
        return false;
    }
    size_t count =  *_Members->data;
    char *mem=_Members->data+sizeof(size_t);
    size_t asize=0;

    std::copy(_Members->data,_Members->data+sizeof(size_t),&asize);

    if(asize==0)
        return false;

    asize*=sizeof(uuid_t);

    for(size_t i=0; i< count; ++i){
        if(uid == *reinterpret_cast<uuid_t*>(mem+(i*sizeof(uuid_t))) )
    char *start=_Members->data+sizeof(size_t);

    std::vector<uuid> members;

    for(size_t i =0; i<asize; i+=sizeof(uuid_t) ){
        uuid_t tmp;
        std::copy(start+i,start+i+sizeof(uuid_t),&tmp[0]);
        members.push_back(tmp);
    }

    for(const uuid &mem : members){
        if(mem==uid)
            return true;
    }

    return false;
}

void authdb::GroupData::getMembers(std::vector<uuid>& members){
    try{
        if(!getAuthData<char>(DataType::GroupData,StorageType::BinaryStorage,
                                                                        this,&_Members,"gpoallowed"))
               return;
    }catch(...){
        return;
    }
    size_t asize=0;

    std::copy(_Members->data,_Members->data+sizeof(size_t),&asize);

    if(asize==0)
        return;

    asize*=sizeof(uuid_t);

    char *start=_Members->data+sizeof(size_t);

    for(size_t i =0; i<asize; i+=sizeof(uuid_t) ){
        uuid_t tmp;
        std::copy(start+i,start+i+sizeof(uuid_t),&tmp[0]);
        members.emplace_back(tmp);
    }
}


bool authdb::Group::exits(AuthBackend& backend, uuid_t* gid, const char* name, int& ret){
    std::shared_ptr<authdb::AuthData::Record> cur=std::make_shared<authdb::AuthData::Record>();
+3 −12
Changes for src/group.h: 3 added lines, 12 removed lines.
Original line number Diff line number Diff line
@@ -45,19 +45,10 @@ namespace authdb {
        void setName(const char *name);
        const char *getName();

        struct MemberUids {
            MemberUids();
            MemberUids(const MemberUids &src);
            MemberUids(char *src,size_t srclen);
            ~MemberUids();
            void addUid(const uuid &src);
            size_t  count;
            uuid_t *uid;
        };

        void addMember(const MemberUids &uid);
        void remMember(const MemberUids &uid);
        void addMember(const uuid &uid);
        void remMember(const uuid &uid);
        bool isMember(const uuid uid);
        void getMembers(std::vector<uuid> &members);

    private:
        AuthData::Record * _Name;