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

test

parent 05081796
Loading
Loading
Loading
Loading
+140 −8
Changes for src/authdb.cpp: 140 added lines, 8 removed lines.
Original line number Diff line number Diff line
@@ -42,6 +42,7 @@
#include "backend.h"
#include "authdb.h"
#include "user.h"
#include "domain.h"
#include "types.h"
#include "hash.h"

@@ -450,12 +451,54 @@ namespace authdb {
        }

        void listDomains(libhttppp::HttpRequest *curreq, const int tid, ULONG_PTR args){
            size_t rd=sizeof(authdb::AuthHeader),end=_Backend.end();

            libhtmlpp::HtmlString list,out;

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

            list  << "<div><ul class=\"usertoolbar\" >"
            Domain domain;

            list <<"<div><p>DomainList:</p><table class=\"domainlist\">";

            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 == DataType::DomainData && strcmp(cur.fieldname,"domainName")==0){
                    class DomainData ddat(cur.uuid);

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

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

                        list << "<tr><td>"
                        <<  ddat.getDomainName()
                        << "</td><td><ul><li>"
                        << "Domainid: " << crdid
                        << "</li>"
                        << "<li><span>Storagetype: </span><span>" << ddat.getStorageType() << "</span></li>"
                        << "<li><span>Storageoptions: </span><span>" << ddat.getStorageOptions() << "</span></li>"
                        << "</ul></td><td><ul class=\"usertoolbar\" >"
                        << "<li><a class=\"button\" href=\"/admin/removeuser/" << crdid << "\">RemoveDomain</a></li>"
                        << "</ul></td></tr>";
                    }catch(AuthBackendError &e){
                        std::cerr << e.what() << std::endl;
                    }
                }
            }

            list  << "<div><ul class=\"domaintoolbar\" >"
                  << "<li><a class=\"button\" href=\"/admin/createdomain\">CreateDomain</a>"
                  << "</li></ul></div>";

@@ -470,6 +513,94 @@ namespace authdb {
        }

        void createDomain(libhttppp::HttpRequest *curreq, const int tid, ULONG_PTR args){
            libhttppp::HttpForm curform;
            curform.parse(curreq);

            if (curform.getBoundary()) {
                uuid_t uid;
                uuid_generate(uid);
                class DomainData ddat(uid);

                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()
                    ){

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

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

                        if(tmp=="name")
                            name=curdispo->getValue();

                        if(tmp=="filename"){
                            stortype=BinaryStorage;
                        }

                        bool numeric=true;

                        for(auto t=tmp.begin(); t!=tmp.end(); ++t){
                            if(!std::isdigit(*t)){
                                numeric=false;
                                break;
                            }
                        }

                        if(numeric){
                            stortype=StorageType::IntStorage;
                        }

                    }

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

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

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

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

                    if(dodat.storage==TextStorage){

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

                    ddat.Data->append(dodat);
                    delete[] dodat.data;
                }
                Domain domain;
                domain.create(_Backend,&ddat);
                std::cout << "domain created!" << std::endl;
            }

            libhtmlpp::HtmlString form,out;

            libhtmlpp::HtmlElement root=_IndexElement;
@@ -478,16 +609,16 @@ namespace authdb {
            form  << "<form method=\"post\" enctype=\"multipart/form-data\">"
                  << "<table>"

                  << "<tr><td><label for=\"domainname\">Domain Name:</label></td>"
                  << "<td><input class=\"domaintext\" type=\"text\" name=\"domainname\" value=\"tuxist.de\"></td></tr>"
                  << "<tr><td><label for=\"domainName\">Domain Name:</label></td>"
                  << "<td><input class=\"domaintext\" type=\"text\" name=\"domainName\" value=\"tuxist.de\"></td></tr>"

                  << "<tr><td><label for=\"domainstorage\">Domain Storage:</label></td>"
                  << "<td><select name=\"domainstorage\">"
                  << "<option value=\"file\">File</option>"
                  << "<tr><td><label for=\"domainStorage\">Domain Storage:</label></td>"
                  << "<td><select name=\"domainStorage\">"
                  << "<option value=\"file\">1</option>"
                  << "</select></td></tr>"

                  << "<tr><td><label for=\"domainname\">Domain Options:</label></td>"
                  << "<td><input class=\"domaintext\" type=\"text\" name=\"options\" value=\"/var/lib/authdb/tuxist.de.db\"></td></tr>"
                  << "<tr><td><label for=\"domainOptions\">Domain Options:</label></td>"
                  << "<td><input class=\"domaintext\" type=\"text\" name=\"domainOptions\" value=\"/var/lib/authdb/tuxist.de.db\"></td></tr>"

                  << "<tr><td></td><td><input type=\"submit\" value=\"save\" ></td></tr>"
                  << "</table>";
@@ -679,6 +810,7 @@ VALUEFOUND:
                backend.read((unsigned char*)cur.data,cur.datasize);
                rec.append(cur);
                delete[] cur.data;
                found=true;
            }
        }

+32 −4
Changes for src/domain.cpp: 32 added lines, 4 removed lines.
Original line number Diff line number Diff line
@@ -133,7 +133,7 @@ namespace authdb {
            return *(*varclass)->data;
        }else{
            for(const AuthData *curdat=dat; curdat; curdat=curdat->next()){
                if(curdat->Data && curdat->Data->storage == StorageType::TextStorage &&
                if(curdat->Data && curdat->Data->storage == StorageType::IntStorage &&
                    curdat->Data->type==DataType::DomainData
                    && strcmp(curdat->Data->fieldname,varname)==0){
                    *varclass=curdat->Data;
@@ -148,8 +148,8 @@ namespace authdb {
    }
};

authdb::DomainData::DomainData(){
    uuid_generate(did);
authdb::DomainData::DomainData(uuid_t uuid){
    uuid_copy(did,uuid);
    Data=new AuthData(did);
}

@@ -215,7 +215,7 @@ bool authdb::Domain::exits(AuthBackend& backend, uuid_t* did, const char* name,i
        backend.setPos(rd);
        backend.read((unsigned char*)&cur,sizeof(AuthData::Record));
        rd=backend.getPos()+cur.datasize;
        if(strcmp(cur.fieldname,"domainname")==0 ){
        if(cur.type==DataType::DomainData && strcmp(cur.fieldname,"domainName")==0){
            cur.data=new char[cur.datasize];
            backend.read((unsigned char*)cur.data,cur.datasize);
            if(name && strcmp(cur.data,name) == 0){
@@ -234,3 +234,31 @@ bool authdb::Domain::exits(AuthBackend& backend, uuid_t* did, const char* name,i
    ret=-1;
    return false;
}
#include<iostream>
void authdb::Domain::info(AuthBackend& backend, class DomainData& dat, size_t& pos){
  size_t end=backend.end();

    if(uuid_is_null(dat.did))
        throw AuthBackendError("Domain info domainid 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 == DataType::DomainData && uuid_compare(dat.did,cur->uuid) == 0){

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

            if(strcmp(dat.Data->Data->fieldname,"domainName")==0){
                dat._name=dat.Data->Data;
            }else if(strcmp(dat.Data->Data->fieldname,"domainStorage")==0){
                dat._storageType =dat.Data->Data;
            }else if(strcmp(dat.Data->Data->fieldname,"domainOptions")==0){
                dat._storageOptions=dat.Data->Data;
            }
        }
        delete cur;
    }
}
+3 −1
Changes for src/domain.h: 3 added lines, 1 removed line.
Original line number Diff line number Diff line
@@ -35,7 +35,7 @@
namespace authdb {
    class DomainData{
    public:
        DomainData();
        DomainData(uuid_t uuid);
        ~DomainData();

        uuid_t      did;
@@ -60,7 +60,9 @@ namespace authdb {
    };

    class Domain {
    public:
        void create(authdb::AuthBackend &backend,class DomainData *data);
        bool exits(AuthBackend& backend, uuid_t* uid, const char* name,int &ret);
        void info(AuthBackend &backend,class DomainData &dat,size_t &pos);
    };
};