test (18cdeb9c) · Commits · tuxist / authdb

src/client.cpp

+9 −33

Original line number	Diff line number	Diff line
		@@ -138,32 +138,15 @@ bool authdb::Client::exits(AuthBackend& backend,const uuid::uuid &clid, const ch

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

		if(uuid::uuid(dat.Data.ruid).empty())
		throw AuthBackendError("user info uid required!");

		while(pos+sizeof(AuthData::Record)<=end){
		authdb::AuthData::Record *cur=new AuthData::Record;
		backend.setPos(pos);
		backend.read((unsigned char*)cur,sizeof(AuthData::Record));
		size_t next=backend.getPos()+cur->datasize;
		if(next<backend.getPos() \|\| next>end){ delete cur; break; }
		pos=next;
		if(cur->type == ClientData && uuid::uuid(dat.Data.ruid)==cur->ruid
		&& strcmp(cur->fieldname,"clientname")==0
		){

		if(!getRecord(backend,dat,DataType::ClientData)){
		delete cur;
		continue;
		}
		throw AuthBackendError("client info uid required!");

		if(!getRecord(backend,dat,DataType::ClientData))
		return;

		dat.ClientName=&dat.Data;
		}
		delete cur;
		}
		}

		authdb::ClientConnections::ClientConnections(uuid::uuid sid, AuthBackend& bck, const class ClientData& clt) : _backend(bck) , _Data(clt){
		_sessionId=sid;
		@@ -321,15 +304,8 @@ authdb::ClientConnections * authdb::Client::ConnectionData(){

		void authdb::Client::list(AuthBackend &backend,std::vector<uuid::uuid> &uuids){
		AuthBackend::Guard guard(backend, AuthBackend::Shared);
		size_t rd=sizeof(authdb::AuthHeader),end=backend.end();
		while(rd+sizeof(AuthData::Record)<=end){
		authdb::AuthData::Record cur;
		backend.setPos(rd);
		backend.read((unsigned char*)&cur,sizeof(AuthData::Record));
		size_t next=backend.getPos()+cur.datasize;
		if(next<backend.getPos() \|\| next>end) break;
		rd=next;
		if(cur.type==ClientData && strcmp(cur.fieldname,"clientname")==0)
		uuids.emplace_back(cur.ruid);
		}
		RecordIndex &idx = getIndex(backend.getOptions());
		if(!idx.valid() \|\| idx.revision()!=backend.getRevesion())
		idx.build(backend);
		idx.listByType(DataType::ClientData, uuids);
		}

src/domain.cpp

+9 −34

Original line number	Diff line number	Diff line
		@@ -145,48 +145,23 @@ bool authdb::Domain::exits(AuthBackend& backend,const uuid::uuid& did, const std

		void authdb::Domain::info(AuthBackend& backend, class DomainData& dat, size_t& pos){
		AuthBackend::Guard guard(backend, AuthBackend::Shared);
		size_t end=backend.end();

		if(uuid::uuid(dat.Data.ruid).empty())
		throw AuthBackendError("Domain info domainid required!");

		while(pos+sizeof(AuthData::Record)<=end){
		authdb::AuthData::Record *cur=new AuthData::Record;
		backend.setPos(pos);
		backend.read((unsigned char*)cur,sizeof(AuthData::Record));
		size_t next=backend.getPos()+cur->datasize;
		if(next<backend.getPos() \|\| next>end){ delete cur; break; }
		pos=next;
		if(cur->type == DataType::DomainData && uuid::uuid(dat.Data.ruid) ==cur->ruid &&
		strcmp(cur->fieldname,"domainname")==0
		){
		if(!getRecord(backend,dat,DataType::DomainData))
		return;

		if(!getRecord(backend,dat,DataType::DomainData)){
		delete cur;
		continue;
		}

		if(strcmp(dat.Data.fieldname,"domainname")==0){
		if(strcmp(dat.Data.fieldname,"domainname")==0)
		dat._name=&dat.Data;
		}
		}
		delete cur;
		}
		}

		void authdb::Domain::list(AuthBackend &backend,std::vector<uuid::uuid> &uuids){
		AuthBackend::Guard guard(backend, AuthBackend::Shared);
		size_t rd=sizeof(authdb::AuthHeader),end=backend.end();
		while(rd+sizeof(AuthData::Record)<=end){
		authdb::AuthData::Record cur;
		backend.setPos(rd);
		backend.read((unsigned char*)&cur,sizeof(AuthData::Record));
		size_t next=backend.getPos()+cur.datasize;
		if(next<backend.getPos() \|\| next>end) break;
		rd=next;
		if(cur.type==DataType::DomainData && strcmp(cur.fieldname,"domainname")==0)
		uuids.emplace_back(cur.ruid);
		}
		RecordIndex &idx = getIndex(backend.getOptions());
		if(!idx.valid() \|\| idx.revision()!=backend.getRevesion())
		idx.build(backend);
		idx.listByType(DataType::DomainData, uuids);
		}

		namespace authdb {

src/gpo.cpp

+8 −28

Original line number	Diff line number	Diff line
		@@ -176,40 +176,20 @@ void authdb::Gpo::remove(AuthBackend &backend,const uuid::uuid &gpid){

		void authdb::Gpo::info(AuthBackend &backend, class GpoData& dat, size_t &pos){
		AuthBackend::Guard guard(backend, AuthBackend::Shared);
		size_t end=backend.end();

		if(uuid::uuid(dat.Data.ruid).empty())
		throw AuthBackendError("gpo info gpoid required!");

		while(pos+sizeof(AuthData::Record)<=end){
		std::shared_ptr<authdb::AuthData::Record> cur=std::make_shared<AuthData::Record>();
		backend.setPos(pos);
		backend.read((unsigned char*)cur.get(),sizeof(AuthData::Record));
		size_t next=backend.getPos()+cur->datasize;
		if(next<backend.getPos() \|\| next>end) break;
		pos=next;
		if(cur->type == PolicyData && uuid::uuid(dat.Data.ruid)==cur->ruid &&
		strcmp(cur->fieldname,"gponame")==0
		){
		if(!getRecord(backend,dat,DataType::PolicyData))
		continue;
		return;

		dat._Name=&dat.Data;
		}
		}
		}

		void authdb::Gpo::list(AuthBackend &backend,std::vector<uuid::uuid> &uuids){
		AuthBackend::Guard guard(backend, AuthBackend::Shared);
		size_t rd=sizeof(authdb::AuthHeader),end=backend.end();
		while(rd+sizeof(AuthData::Record)<=end){
		authdb::AuthData::Record cur;
		backend.setPos(rd);
		backend.read((unsigned char*)&cur,sizeof(AuthData::Record));
		size_t next=backend.getPos()+cur.datasize;
		if(next<backend.getPos() \|\| next>end) break;
		rd=next;
		if(cur.type==PolicyData && strcmp(cur.fieldname,"gponame")==0)
		uuids.emplace_back(cur.ruid);
		}
		RecordIndex &idx = getIndex(backend.getOptions());
		if(!idx.valid() \|\| idx.revision()!=backend.getRevesion())
		idx.build(backend);
		idx.listByType(DataType::PolicyData, uuids);
		}

src/group.cpp

+6 −27

Original line number	Diff line number	Diff line
		@@ -220,26 +220,12 @@ void authdb::Group::create(AuthBackend& backend, class GroupData* dat){

		void authdb::Group::info(AuthBackend &backend, class GroupData& dat, size_t &pos){
		AuthBackend::Guard guard(backend, AuthBackend::Shared);
		size_t end=backend.end();

		if(uuid::uuid(dat.Data.ruid).empty())
		throw AuthBackendError("group info gid required!");

		while(pos+sizeof(AuthData::Record)<=end){
		std::shared_ptr<authdb::AuthData::Record> cur=std::make_shared<authdb::AuthData::Record>();
		backend.setPos(pos);
		backend.read((unsigned char*)cur.get(),sizeof(AuthData::Record));
		size_t next=backend.getPos()+cur->datasize;
		if(next<backend.getPos() \|\| next>end) break;
		pos=next;
		if(cur->type == GroupData && uuid::uuid(dat.Data.ruid)==cur->ruid
		&& strcmp(cur->fieldname,"groupname")==0
		){
		if(!getRecord(backend,dat,DataType::GroupData))
		continue;

		}
		}
		return;
		}

		void authdb::Group::remove(AuthBackend& backend, const uuid::uuid &gid){
		@@ -249,15 +235,8 @@ void authdb::Group::remove(AuthBackend& backend, const uuid::uuid &gid){

		void authdb::Group::list(AuthBackend &backend,std::vector<uuid::uuid> &uuids){
		AuthBackend::Guard guard(backend, AuthBackend::Shared);
		size_t rd=sizeof(authdb::AuthHeader),end=backend.end();
		while(rd+sizeof(AuthData::Record)<=end){
		authdb::AuthData::Record cur;
		backend.setPos(rd);
		backend.read((unsigned char*)&cur,sizeof(AuthData::Record));
		size_t next=backend.getPos()+cur.datasize;
		if(next<backend.getPos() \|\| next>end) break;
		rd=next;
		if(cur.type==GroupData && strcmp(cur.fieldname,"groupname")==0)
		uuids.emplace_back(cur.ruid);
		}
		RecordIndex &idx = getIndex(backend.getOptions());
		if(!idx.valid() \|\| idx.revision()!=backend.getRevesion())
		idx.build(backend);
		idx.listByType(DataType::GroupData, uuids);
		}

src/index.cpp

+7 −0

Original line number	Diff line number	Diff line
		@@ -142,6 +142,13 @@ namespace authdb {
		return 0;
		}

		void RecordIndex::listByType(int type, std::vector<uuid::uuid> &out) const {
		for (auto &[key, offset] : _offsetIndex) {
		if (key.type == type)
		out.emplace_back(key.uid);
		}
		}

		void RecordIndex::invalidate() {
		_valid = false;
		}