Commit f49d0125 authored by jan.koester's avatar jan.koester
Browse files

ups

parent 5c30874b
Loading
Loading
Loading
Loading
Loading
+105 −108
Changes for src/admin.cpp: 105 added lines, 108 removed lines.
Original line number Diff line number Diff line
@@ -957,7 +957,6 @@ namespace authdb {

            if (curform.getBoundary()) {
                size_t gcount=0;
                std::string gname;

                uuid_t gid;
                uuid_generate(gid);
@@ -968,8 +967,6 @@ namespace authdb {

                Group grp;

                grpdat.setName(gname.c_str());

                size_t git=0;

                for (libhttppp::HttpForm::MultipartForm::Data* curformdat = curform.MultipartFormData.getFormData();
@@ -980,9 +977,14 @@ namespace authdb {
                    ){
                        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(),"groupname")==0){
                             curformdat->Value.push_back('\0');
                             grpdat.setName(curformdat->Value.data());
                        }
                        if(tmp=="name" && strcmp(curdispo->getValue(),"groupmembers")==0){
                            curformdat->Value.push_back('\0');
                            members.emplace_back(curformdat->Value.data());
@@ -1104,8 +1106,7 @@ namespace authdb {

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

            uuid_t gid;
            uuid_parse(cgid,gid);
            uuid gid(cgid);

            class GroupData editrec(gid);

@@ -1225,41 +1226,38 @@ namespace authdb {
                  << "<table>";

            while(rd<end){
                authdb::AuthData::Record cur;
                std::shared_ptr<authdb::AuthData::Record>  cur= std::make_shared<authdb::AuthData::Record>();

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

                if(uuid_compare(cur.uuid,gid)==0 && cur.type==GroupData){
                if(gid == cur->uuid && cur->type==GroupData){

                    form  << "<tr><td><label for=\""<< cur.fieldname <<"\">" << cur.fieldname << "</label></td>";
                    form  << "<tr><td><label for=\""<< cur->fieldname <<"\">" << cur->fieldname << "</label></td>";

                    if(cur.storage==TextStorage && strcmp(cur.fieldname ,"groupname")==0){
                        cur.data = new char[cur.datasize];
                        backend->read((unsigned char*)cur.data,cur.datasize);
                    if(cur->storage==TextStorage && strcmp(cur->fieldname ,"groupname")==0){
                        cur->data = new char[cur->datasize];
                        backend->read((unsigned char*)cur->data,cur->datasize);
                        try {
                            form   << "<td><input type=\"text\" name=\"" << cur.fieldname << "\" value=\""
                                   << cur.data <<"\"></td>";
                            form   << "<td><input type=\"text\" name=\"" << cur->data << "\" value=\""
                                   << cur->data <<"\"></td>";
                        }catch(AuthBackendError &e){
                            std::cerr << e.what() << std::endl;
                        }
                        delete[] cur.data;
                    }else if(cur.storage==BinaryStorage && strcmp(cur.fieldname ,"groupmembers")==0){

                        form   << "<td><select name=\"" << cur.fieldname << "\" multiple>";

                        cur.data = new char[cur.datasize];
                        backend->read((unsigned char*)cur.data,cur.datasize);
                        delete[] cur->data;
                    }else if(cur->storage==BinaryStorage && strcmp(cur->fieldname ,"groupmembers")==0){

                        form   << "<td><select name=\"" << cur->fieldname << "\" multiple>";
                        std::cout << "test" << std::endl;
                        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);
                        class GroupData gdat(cur->uuid);

                        delete[] cur.data;
                        rd-=sizeof(AuthData::Record);

                        grp.info(*backend,gdat,rd);
                        gdat.getMembers(mrecs);

                        size_t urd=sizeof(AuthHeader),uend=backend->end();
                        while(urd<uend){
@@ -2390,85 +2388,85 @@ namespace authdb {

            uuid ssid;

            try{

                cookie.parse(curreq);

                for(libhttppp::HttpCookie::CookieData *cur=cookie.getfirstCookieData(); cur; cur=cur->nextCookieData()){
                    if(strcmp(cur->getKey(),"authdbid")==0){
                            if(ssid.parse(cur->getValue())==0){
                                sdat=AuthSession.getSession(ssid);
                            }
                        break;
                    }
                }

                if(curreq->getRequestURL().compare(0,15,"/settings/logout")==0){
                    AuthSession.remSession(ssid);
                    libhttppp::HttpResponse rep;
                    rep.setState(HTTP303);
                    rep.setVersion(HTTPVERSION(1.1));
                    rep.setHeaderData("Location")->push_back("/settings/index");
                    rep.setContentType("text/html");
                    rep.send(curreq,nullptr,0);
                    return;
                }

                if(!sdat){
                    throw AuthBackendError("No Session found!");
                }
            }catch(...){
                try {
                    login(curreq,tid,args);
                    return;
                }catch(...){
                    std::shared_ptr<libhtmlpp::HtmlString> out=std::make_shared<libhtmlpp::HtmlString>(),
                                                                                dform=std::make_shared<libhtmlpp::HtmlString>();

                    libhtmlpp::HtmlElement index=*_LoginElement,*domel=index.getElementbyID("domain");
                    Domain domain;

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

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

                        cur.type=EmptyData;

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

                        rd=_AdminBackend.getPos()+cur.datasize;

                        if(cur.type == DataType::DomainData && strcmp(cur.fieldname,"domainname")==0){
                            class DomainData ddat(cur.uuid);

                            try {
                                size_t dpos=sizeof(authdb::AuthHeader);
                                domain.info(_AdminBackend,ddat,dpos);

                                char crdid[255];
                                uuid_unparse(cur.uuid,crdid);

                                *dform << "<option value=\"" << crdid << "\" >"
                                << ddat.getDomainName()
                                << "</option>";

                                domel->appendChild(dform->parse());
                                dform->clear();
                            }catch(AuthBackendError &e){
                                std::cerr << e.what() << std::endl;
                            }
                        }
                    }

                    libhtmlpp::print(&index,*out,true);
                    libhttppp::HttpResponse rep;
                    rep.setContentType("text/html");
                    rep.send(curreq,out->c_str(),out->size());
                    return;
                }
            }
            // try{
            //
            //     cookie.parse(curreq);
            //
            //     for(libhttppp::HttpCookie::CookieData *cur=cookie.getfirstCookieData(); cur; cur=cur->nextCookieData()){
            //         if(strcmp(cur->getKey(),"authdbid")==0){
            //                 if(ssid.parse(cur->getValue())==0){
            //                     sdat=AuthSession.getSession(ssid);
            //                 }
            //             break;
            //         }
            //     }
            //
            //     if(curreq->getRequestURL().compare(0,15,"/settings/logout")==0){
            //         AuthSession.remSession(ssid);
            //         libhttppp::HttpResponse rep;
            //         rep.setState(HTTP303);
            //         rep.setVersion(HTTPVERSION(1.1));
            //         rep.setHeaderData("Location")->push_back("/settings/index");
            //         rep.setContentType("text/html");
            //         rep.send(curreq,nullptr,0);
            //         return;
            //     }
            //
            //     if(!sdat){
            //         throw AuthBackendError("No Session found!");
            //     }
            // }catch(...){
            //     try {
            //         login(curreq,tid,args);
            //         return;
            //     }catch(...){
            //         std::shared_ptr<libhtmlpp::HtmlString> out=std::make_shared<libhtmlpp::HtmlString>(),
            //                                                                     dform=std::make_shared<libhtmlpp::HtmlString>();
            //
            //         libhtmlpp::HtmlElement index=*_LoginElement,*domel=index.getElementbyID("domain");
            //         Domain domain;
            //
            //         size_t rd=sizeof(authdb::AuthHeader),end=_AdminBackend.end();
            //
            //         while(rd<end){
            //             authdb::AuthData::Record cur;
            //
            //             cur.type=EmptyData;
            //
            //             _AdminBackend.setPos(rd);
            //             _AdminBackend.read((unsigned char*)&cur,sizeof(AuthData::Record));
            //
            //             rd=_AdminBackend.getPos()+cur.datasize;
            //
            //             if(cur.type == DataType::DomainData && strcmp(cur.fieldname,"domainname")==0){
            //                 class DomainData ddat(cur.uuid);
            //
            //                 try {
            //                     size_t dpos=sizeof(authdb::AuthHeader);
            //                     domain.info(_AdminBackend,ddat,dpos);
            //
            //                     char crdid[255];
            //                     uuid_unparse(cur.uuid,crdid);
            //
            //                     *dform << "<option value=\"" << crdid << "\" >"
            //                     << ddat.getDomainName()
            //                     << "</option>";
            //
            //                     domel->appendChild(dform->parse());
            //                     dform->clear();
            //                 }catch(AuthBackendError &e){
            //                     std::cerr << e.what() << std::endl;
            //                 }
            //             }
            //         }
            //
            //         libhtmlpp::print(&index,*out,true);
            //         libhttppp::HttpResponse rep;
            //         rep.setContentType("text/html");
            //         rep.send(curreq,out->c_str(),out->size());
            //         return;
            //     }
            // }

            char domain[255]={},url[255]={};

@@ -2522,9 +2520,8 @@ namespace authdb {
            }else{
URLNOTFOUND:
                uuid did;
                uuid_clear(did.value);

                if(!sdat)
                if(sdat)
                    sdat->getDid(did);

                char url[255],cdid[128];
+17 −18
Changes for src/group.cpp: 17 added lines, 18 removed lines.
Original line number Diff line number Diff line
@@ -25,6 +25,7 @@
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *******************************************************************************/

#include <iostream>
#include <cstring>
#include <vector>
#include <memory>
@@ -57,26 +58,24 @@ const char* authdb::GroupData::getName(){
}

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;

    try{
       getAuthData<char>(DataType::GroupData,StorageType::BinaryStorage,
                                                                        this,&_Members,"groupmembers");
       std::copy(_Members->data,_Members->data+sizeof(size_t),&asize);
    }catch(AuthBackendError &e){
        std::cerr << e.what() << std::endl;
    }

    if(asize==0)
        return;
    std::vector<uuid> members;

    if(asize!=0){

        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]);
@@ -87,7 +86,7 @@ void authdb::GroupData::addMember(const uuid &uid){
            if(mem==uid)
                throw AuthBackendError("User is already member!");
        }

    }
    members.push_back(uid);

    size_t wsize=members.size();
@@ -109,7 +108,7 @@ void authdb::GroupData::addMember(const uuid &uid){
        wsize+=sizeof(uuid_t);
    }

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

    delete[] data;
}
@@ -117,7 +116,7 @@ void authdb::GroupData::addMember(const uuid &uid){
void authdb::GroupData::remMember(const uuid& uid){
        try{
        if(!getAuthData<char>(DataType::GroupData,StorageType::BinaryStorage,
                                                                        this,&_Members,"gpoallowed"))
                                                                        this,&_Members,"groupmembers"))
               return;
    }catch(...){
        return;
@@ -165,7 +164,7 @@ void authdb::GroupData::remMember(const uuid& uid){
        wsize+=sizeof(uuid_t);
    }

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

    delete[] data;
}
@@ -174,7 +173,7 @@ void authdb::GroupData::remMember(const uuid& uid){
bool authdb::GroupData::isMember(const uuid uid){
    try{
        if(!getAuthData<char>(DataType::GroupData,StorageType::BinaryStorage,
                                                                        this,&_Members,"gpoallowed"))
                                                                        this,&_Members,"groupmembers"))
               return false;
    }catch(...){
        return false;
@@ -195,7 +194,7 @@ bool authdb::GroupData::isMember(const uuid uid){
    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);
        members.emplace_back(tmp);
    }

    for(const uuid &mem : members){
@@ -209,7 +208,7 @@ bool authdb::GroupData::isMember(const uuid uid){
void authdb::GroupData::getMembers(std::vector<uuid>& members){
    try{
        if(!getAuthData<char>(DataType::GroupData,StorageType::BinaryStorage,
                                                                        this,&_Members,"gpoallowed"))
                                                                        this,&_Members,"groupmembers"))
               return;
    }catch(...){
        return;