Commit 532b07cb authored by jan.koester's avatar jan.koester
Browse files

work work

parent c88bc4f9
Loading
Loading
Loading
Loading
Loading
+87 −1
Changes for src/client.cpp: 87 added lines, 1 removed line.
Original line number Diff line number Diff line
@@ -27,21 +27,107 @@

#include "client.h"

void authdb::ClientData::setClientKey(const Hash& key){
void authdb::ClientData::setKey(const char *key){
    setAuthData<char,char>(DataType::ClientData,StorageType::TextStorage,
                           this,&ClientKey,"clientkey",key,strlen(key)+1);
}

const char *authdb::ClientData::getKey(){
    return getAuthData<char>(DataType::ClientData,StorageType::TextStorage,
                             this,&ClientKey,"clientkey");
}

void authdb::ClientData::setName(const char* name){
    setAuthData<char,char>(DataType::ClientData,StorageType::TextStorage,
                           this,&ClientName,"clientname",name,strlen(name)+1);
}


const char *authdb::ClientData::getName(){
    return getAuthData<char>(DataType::ClientData,StorageType::TextStorage,
                             this,&ClientName,"clientname");
}

void authdb::Client::create(AuthBackend& backend, class ClientData* data){
    int exi=0;

    if(exits(backend,&data->Data->uuid,data->getName(),exi)){
        switch(exi){
            case 1:
                throw authdb::AuthBackendError("Create User: Username already Exists aborting!");
            default:
                throw authdb::AuthBackendError("Create User: UUID already Exists aborting!");
        }
    }

    size_t wd=backend.end();

    for(AuthData *curec=data; curec; curec=curec->next()){
        curec->Data->type=UserData;
        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();
    }
}

bool authdb::Client::exits(AuthBackend& backend, uuid_t* clid, 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,"clientname")==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(clid && uuid_compare(cur.uuid,*clid)==0){
                delete[] cur.data;
                ret=2;
                return true;
            }
            delete[] cur.data;
        }
    }
    ret=-1;
    return false;
}

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

    if(uuid_is_null(dat.Data->uuid))
        throw AuthBackendError("user info uid 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 == ClientData && uuid_compare(dat.Data->uuid,cur->uuid) == 0
            && strcmp(cur->fieldname,"clientname")==0
        ){

            if(!getRecord(backend,dat,DataType::UserData))
                continue;

            if(strcmp(dat.Data->fieldname,"clientname")==0){
                dat.ClientName=dat.Data;
            }else if(strcmp(dat.Data->fieldname,"clientkey")==0){
                dat.ClientKey=dat.Data;
            }
        }
        delete cur;
    }
}

void authdb::Client::remove(AuthBackend& backend, const uuid_t clid){
    delRecord(backend,clid,DataType::ClientData);
}
+2 −2
Changes for src/client.h: 2 added lines, 2 removed lines.
Original line number Diff line number Diff line
@@ -36,8 +36,8 @@ namespace authdb {
        void setName(const char* name);
        const char *getName();

        void setClientKey(const Hash &key);
        const Hash& getClientKey();
        void setKey(const char *key);
        const char *getKey();
    private:
        AuthData::Record *ClientName;
        AuthData::Record *ClientKey;