Commit 2ac6cde6 authored by jan.koester's avatar jan.koester
Browse files

some changes

parent b91a030c
Loading
Loading
Loading
Loading
Loading
+20 −20
Changes for src/admin.cpp: 20 added lines, 20 removed lines.
Original line number Diff line number Diff line
@@ -46,7 +46,7 @@
namespace authdb {
    class AdminController {
    public:
        AdminController(authdb::AuthBackend &backend,netplus::socket *ssock) : _AdminBackend(backend){
        AdminController(authdb::AuthBackend &backend,netplus::socket *ssock) : _AdminBackend(backend) , _Session(backend){
            _Indexpage.loadFile(_IndexElement,GETDATA(index.html));
            _Loginpage.loadFile(_LoginElement,GETDATA(login.html));
        };
@@ -1404,20 +1404,20 @@ namespace authdb {
                    throw AuthBackendError("listSessions: wrong url!");
            }

            for(const SessionData *curdat=_Session.firstData(); curdat; curdat=curdat->next()){
                uuid_t sdid;
            for(std::shared_ptr<SessionData> curdat=std::make_shared<SessionData>(_Session.firstData()); curdat; curdat=curdat->next()){
                uuid sdid;
                curdat->getDid(sdid);
                if( ( strcmp(cdid,"admin")==0 && uuid_is_null(sdid)==1 ) ||
                    (uuid_is_null(did)==0 && uuid_compare(did,sdid)==0) ) {
                if( ( strcmp(cdid,"admin")==0 && uuid_is_null(sdid.value)==1 ) ||
                    (uuid_is_null(did)==0 && uuid_compare(did,sdid.value)==0) ) {

                    libhtmlpp::HtmlString listel;
                    uuid_t sid;
                    uuid sid;

                    curdat->getSid(sid);

                    char csid[255],cuid[255];

                    uuid_unparse(sid,csid);
                    uuid_unparse(sid.value,csid);

                    listel << "<li class=\"sessionel\">"
                           << "<span>" << curdat->getUsername() << ": " << csid << "</span>"
@@ -1485,7 +1485,7 @@ namespace authdb {
                throw AuthBackendError("login: could not parse uuid!");
            }

            _Session.relSession(*backend,sid);
            _Session.relSession(sid);

            char rurl[255];
            snprintf(rurl,255,"/settings/%s/listsessions",cdid);
@@ -2094,11 +2094,11 @@ namespace authdb {

                    if(username==udat.getUsername() && pwhash==udat.getPwHash() ){
                        libhttppp::HttpCookie cookie;
                        uuid_t sid;
                        const SessionData *cses=_Session.addSession(*backend,did,udat.uid);
                        cses->getSid(sid);
                        uuid sid;
                        const SessionData cses=_Session.addSession(did,udat.uid);
                        cses.getSid(sid);
                        char csid[255];
                        uuid_unparse(sid,csid);
                        uuid_unparse(sid.value,csid);

                        libhttppp::HttpResponse rep;
                        cookie.setcookie(&rep,"authdbid",csid,nullptr,nullptr,-1,"/");
@@ -2471,7 +2471,7 @@ namespace authdb {

            libhttppp::HttpCookie cookie;
            uuid_t ssid;
            const SessionData *sdat=nullptr;
            SessionData sdat;

            try{
                uuid_clear(ssid);
@@ -2497,7 +2497,7 @@ namespace authdb {
                    return;
                }

                if(!sdat){
                if(sdat.empty()){
                    libhttppp::HttpResponse rep;
                    cookie.setcookie(&rep,"authdbid",nullptr,nullptr,nullptr,-1,"/");
                    rep.setState(HTTP307);
@@ -2610,18 +2610,18 @@ namespace authdb {
                editClient(curreq,tid,args);
            }else{
URLNOTFOUND:
                uuid_t did;
                uuid_clear(did);
                uuid did;
                uuid_clear(did.value);

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

                char url[255],cdid[255];

                if(uuid_is_null(did)==1){
                if(uuid_is_null(did.value)==1){
                    snprintf(url,255,"/settings/admin/listusers");
                }else{
                    uuid_unparse(did,cdid);
                    uuid_unparse(did.value,cdid);
                    snprintf(url,255,"/settings/%s/listusers",cdid);
                }
                libhttppp::HttpResponse rep;
+3 −3
Changes for src/api.cpp: 3 added lines, 3 removed lines.
Original line number Diff line number Diff line
@@ -117,11 +117,11 @@ namespace authdb {

                                            if(name==udat.getUsername()){
                                                if(pwsalt==udat.getPwHash()){
                                                    Session session;
                                                    const SessionData *sdat=session.addSession(*_Backend,did.value,cur.uuid);
                                                    Session session(*_Backend);
                                                    const SessionData sdat=session.addSession(did.value,cur.uuid);
                                                    json_object *respid=json_object_new_object();
                                                    uuid sessid;
                                                    sdat->getSid(sessid.value);
                                                    sdat.getSid(sessid);
                                                    json_object_object_add(respid,"sessionid",json_object_new_string(sessid.c_str()));
                                                    json_object_array_add(response,respid);
                                                    return true;
+77 −50
Changes for src/session.cpp: 77 added lines, 50 removed lines.
Original line number Diff line number Diff line
@@ -25,6 +25,8 @@
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *******************************************************************************/

#include <mutex>

#include "session.h"
#include "authdb.h"
#include "backend.h"
@@ -33,36 +35,45 @@
#include "uuid.h"

namespace authdb {
        std::shared_ptr<SessionData>  _firstData;
        std::shared_ptr<SessionData>  _lastData;
        SessionData                   _empty;
}

authdb::SessionData::SessionData(uuid_t sessionid, uuid_t userid, uuid_t domainid,std::vector<uuid> &members) : _members(members){
    uuid_copy(_sid,sessionid);
    uuid_copy(_uid,userid);
    uuid_copy(_did,domainid);
authdb::SessionData::SessionData(){
    _next=nullptr;
}


authdb::SessionData::SessionData(uuid sessionid, uuid userid, uuid domainid,std::vector<uuid> &members) : _members(members){
    _sid=sessionid;
    _uid=userid;
    _did=domainid;
    _next=nullptr;
}

void authdb::SessionData::getUid(uuid_t& dest) const{
    uuid_copy(dest,_uid);
void authdb::SessionData::getUid(uuid& dest) const{
    dest=_uid;
}

void authdb::SessionData::getSid(uuid_t& dest) const{
    uuid_copy(dest,_sid);
void authdb::SessionData::getSid(uuid& dest) const{
    dest=_sid;
}

void authdb::SessionData::getDid(uuid_t& dest) const{
    uuid_copy(dest,_did);
void authdb::SessionData::getDid(uuid& dest) const{
    dest=_did;
}

const char * authdb::SessionData::getUsername() const{
    return _username.c_str();
}

bool authdb::SessionData::empty(){
    if(sizeof(*this)==sizeof(_empty))
        return true;
    return false;
}

bool authdb::SessionData::isMemberOf(const uuid_t& gid){

bool authdb::SessionData::isMemberOf(const uuid& gid){
    for(const auto &member : _members){
        if(member==gid)
            return true;
@@ -70,39 +81,37 @@ bool authdb::SessionData::isMemberOf(const uuid_t& gid){
    return false;
}

const authdb::SessionData * authdb::SessionData::next() const{
    return _next.get();
const std::shared_ptr<authdb::SessionData> authdb::SessionData::next(){
    return _next;
}



authdb::Session::Session(){
    _firstData=nullptr;
    _lastData=nullptr;
authdb::Session::Session(AuthBackend &backend) : _Backend(backend){
}

authdb::Session::~Session()=default;

const authdb::SessionData * authdb::Session::addSession(AuthBackend &backend,uuid_t domainid,uuid_t userid){
const authdb::SessionData &authdb::Session::addSession(uuid domainid,uuid userid){
    std::lock_guard<std::mutex> guard(_lockData);
    Group group;
    std::string username;

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

        cur.type=EmptyData;

        backend.setPos(rd);
        backend.read(reinterpret_cast<unsigned char*>(&cur),sizeof(AuthData::Record));
        _Backend.setPos(rd);
        _Backend.read(reinterpret_cast<unsigned char*>(&cur),sizeof(AuthData::Record));

        rd=backend.getPos()+cur.datasize;
        rd=_Backend.getPos()+cur.datasize;

        if(cur.type == UserData && strcmp(cur.fieldname,"username")==0
            && uuid_compare(cur.uuid,userid)==0){
            && uuid_compare(cur.uuid,userid.value)==0){

            const std::shared_ptr<unsigned char[]> tmp(new unsigned char[cur.datasize]);
            backend.read(tmp.get(),cur.datasize);
            _Backend.read(tmp.get(),cur.datasize);
            username=reinterpret_cast<char*>(tmp.get());
        }
    }
@@ -114,15 +123,15 @@ const authdb::SessionData * authdb::Session::addSession(AuthBackend &backend,uui

        cur.type=EmptyData;

        backend.setPos(rd);
        backend.read(reinterpret_cast<unsigned char*>(&cur),sizeof(AuthData::Record));
        _Backend.setPos(rd);
        _Backend.read(reinterpret_cast<unsigned char*>(&cur),sizeof(AuthData::Record));

        rd=backend.getPos()+cur.datasize;
        rd=_Backend.getPos()+cur.datasize;

        if(cur.type == GroupData && strcmp(cur.fieldname,"groupname")==0){
            class GroupData grpi(cur.uuid);
            size_t upos=sizeof(authdb::AuthHeader);
            group.info(backend,grpi,upos);
            group.info(_Backend,grpi,upos);
            if(grpi.isMember(cur.uuid)){
                mbs.emplace_back(cur.uuid);
            }
@@ -142,22 +151,24 @@ const authdb::SessionData * authdb::Session::addSession(AuthBackend &backend,uui

    _lastData->_username=username;

    return _lastData.get();
    return *_lastData;
}

const authdb::SessionData * authdb::Session::getSession(uuid_t sessionid) const{
    for(const SessionData *cur=firstData(); cur!=nullptr; cur=cur->next()){
        if(uuid_compare(cur->_sid,sessionid)==0)
            return cur;
const authdb::SessionData &authdb::Session::getSession(uuid sessionid){
    std::lock_guard<std::mutex> guard(_lockData);
    for(std::shared_ptr<SessionData> cur=_firstData; cur.get(); cur=cur->_next){
        if(cur->_sid==sessionid.value)
            return *cur;
    }
    return nullptr;
    return _empty;
}

void authdb::Session::remSession(uuid_t sessionid){
void authdb::Session::remSession(uuid sessionid){
    std::lock_guard<std::mutex> guard(_lockData);
    std::shared_ptr<SessionData> prev;

    for(std::shared_ptr<SessionData> cur=_firstData; cur; cur=cur->_next){
        if(uuid_compare(cur->_sid,sessionid)==0){
        if(cur->_sid==sessionid){
            if(prev)
                prev->_next=cur->_next;

@@ -174,7 +185,8 @@ void authdb::Session::remSession(uuid_t sessionid){
    }
}

void authdb::Session::relSession(AuthBackend &backend,uuid_t sessionid){
void authdb::Session::relSession(uuid sessionid){
    std::lock_guard<std::mutex> guard(_lockData);
    Group group;

    std::string username;
@@ -182,7 +194,7 @@ void authdb::Session::relSession(AuthBackend &backend,uuid_t sessionid){
    std::shared_ptr<SessionData> cursess=nullptr;

    for(std::shared_ptr<SessionData> cur=_firstData; cur; cur=cur->_next){
        if(uuid_compare(cur->_sid,sessionid)==0){
        if(cur->_sid==sessionid){
            cursess=cur;
            break;
        }
@@ -193,37 +205,52 @@ void authdb::Session::relSession(AuthBackend &backend,uuid_t sessionid){

    cursess->_members.clear();

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

        cur.type=EmptyData;

        backend.setPos(rd);
        backend.read(reinterpret_cast<unsigned char*>(&cur),sizeof(AuthData::Record));
        _Backend.setPos(rd);
        _Backend.read(reinterpret_cast<unsigned char*>(&cur),sizeof(AuthData::Record));

        rd=backend.getPos()+cur.datasize;
        rd=_Backend.getPos()+cur.datasize;

        if(cur.type == UserData && strcmp(cur.fieldname,"username")==0
            && uuid_compare(cur.uuid,cursess->_uid)==0){
            && uuid_compare(cur.uuid,cursess->_uid.value)==0){

            const std::shared_ptr<unsigned char[]>tmp(new unsigned char[cur.datasize]);
            backend.read(tmp.get(),cur.datasize);
            _Backend.read(tmp.get(),cur.datasize);
            username=reinterpret_cast<char*>(tmp.get());
        }

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

            if(grpi.isMember(cursess->_uid))
            if(grpi.isMember(cursess->_uid.value))
                cursess->_members.emplace_back(cursess->_uid);
        }
    }
}

const authdb::SessionData & authdb::Session::firstData() const{
    return *_firstData;
}


const authdb::SessionData * authdb::Session::firstData() const{
    return _firstData.get();
void authdb::Session::operator=(const Session& src){
    std::lock_guard<std::mutex> guard(_lockData);
    for(std::shared_ptr<SessionData> cur=std::make_shared<SessionData>(src.firstData()); cur.get(); cur=cur->_next){
        if(!_firstData){
            _firstData=std::make_shared<SessionData>(cur->_sid,cur->_uid,cur->_did,cur->_members);
            _lastData=_firstData;
        }else{
            _lastData->_next=std::make_shared<SessionData>(cur->_sid,cur->_uid,cur->_did,cur->_members);
            _lastData=_lastData->_next;
        }

        _lastData->_username=cur->_username;
    }
}
+25 −17
Changes for src/session.h: 25 added lines, 17 removed lines.
Original line number Diff line number Diff line
@@ -28,6 +28,7 @@
#include <vector>
#include <string>
#include <memory>
#include <mutex>

#include "uuid.h"

@@ -39,24 +40,26 @@
namespace authdb {
    class SessionData {
    public:
        bool isMemberOf(const uuid_t &gid);
        bool isMemberOf(const uuid &gid);

        void getSid(uuid_t &dest) const;
        void getUid(uuid_t &dest) const;
        void getDid(uuid_t &dest) const;
        void getSid(uuid &dest) const;
        void getUid(uuid &dest) const;
        void getDid(uuid &dest) const;

        const char *getUsername() const;

        const SessionData *next() const;
        bool empty();

        const std::shared_ptr<SessionData> next();

        SessionData();
        SessionData(uuid sessionid,uuid userid,uuid domainid,std::vector<uuid> &members);
        ~SessionData() =default;

    private:
        SessionData(uuid_t sessionid,uuid_t userid,uuid_t domainid,std::vector<uuid> &members);

        uuid_t                _uid;
        uuid_t                _sid;
        uuid_t                _did;
        uuid                _uid;
        uuid                _sid;
        uuid                _did;

        std::vector<uuid>            _members;

@@ -64,19 +67,24 @@ namespace authdb {

        std::shared_ptr<SessionData> _next;
        friend class Session;
        friend class std::shared_ptr<SessionData>;
    };

    class Session{
    public:
        Session();
        Session(AuthBackend &backend);
        ~Session();

        const SessionData *addSession(AuthBackend &backend,uuid_t domainid,uuid_t userid);
        const SessionData *getSession(uuid_t sessionid) const;
        void               remSession(uuid_t sessionid);
        void               relSession(AuthBackend &backend,uuid_t sessionid);
        const SessionData &addSession(uuid domainid,uuid userid);
        const SessionData &getSession(uuid sessionid);
        void               remSession(uuid sessionid);
        void               relSession(uuid sessionid);

        const SessionData *firstData() const;
        const SessionData &firstData() const;
        void operator=(const Session &src);
    private:
        std::shared_ptr<SessionData>  _firstData;
        std::shared_ptr<SessionData>  _lastData;
        std::mutex                    _lockData;
        AuthBackend &_Backend;
    };
};