Skip to content

Built in helper processing to make the API less awkward #20

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
PolBreachIty wants to merge 4 commits into
base: main
Choose a base branch
from
Open

Built in helper processing to make the API less awkward #20

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
3aef154
wip: POC built in helper processing
PolBreachIty Apr 5, 2022
1a15840
feat: add more error handling. fix typo
PolBreachIty Apr 6, 2022
08cabc9
Merge branch 'main' of github.com:breachintelligence/casbinex into ea…
PolBreachIty Apr 6, 2022
46111c9
feat: simplified the code further and return ok tuples
PolBreachIty Apr 6, 2022
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
118 changes: 73 additions & 45 deletions c_src/casbin_nif.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -33,11 +33,32 @@ string ListToString(ErlNifEnv* env, ERL_NIF_TERM term) {
return string(stringData, res);
}

string BinToString(ErlNifEnv* env, ERL_NIF_TERM term) {
ERL_NIF_TERM maybeBin = term;

unsigned int listLength = 0;
ErlNifBinary term_bin;
if (!enif_inspect_iolist_as_binary(env, term, &term_bin))
{
// we blame the user if address isn't a string
return string();
}

return string(reinterpret_cast<char*>(term_bin.data), term_bin.size);
}

ERL_NIF_TERM VectorToList(ErlNifEnv* env, const vector<string> &input) {
ERL_NIF_TERM enifList[input.size()];

for(int ii = 0; ii < input.size(); ++ii) {
enifList[ii] = enif_make_string(env, input.at(ii).c_str(), ERL_NIF_LATIN1);
ERL_NIF_TERM component_term;

const char* inputCharArray = (const char*)input.at(ii).c_str();
const int inputLength = strlen(inputCharArray);
char *component_term_bin = reinterpret_cast<char*>(enif_make_new_binary(env, inputLength, &component_term));
strncpy(component_term_bin, inputCharArray, inputLength);

enifList[ii] = component_term;
}

return enif_make_list_from_array(env, enifList, input.size());
Expand Down Expand Up @@ -65,14 +86,14 @@ vector<string> ListToVector(ErlNifEnv* env, ERL_NIF_TERM term) {
items = term;

while(enif_get_list_cell(env, items, &item, &items))
resultVector.push_back(ListToString(env, item));
resultVector.push_back(BinToString(env, item));

return resultVector;
}

ERL_NIF_TERM CreateEnforcer(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
string modelPath = ListToString(env, argv[0]);
string policyPath = ListToString(env, argv[1]);
string modelPath = BinToString(env, argv[0]);
string policyPath = BinToString(env, argv[1]);

try{

Expand Down Expand Up @@ -110,12 +131,12 @@ ERL_NIF_TERM DestroyEnforcer(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]

ERL_NIF_TERM Enforce(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
if(!enforcer) {
return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create and enforcer first."));
return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create an enforcer first."));
}

string sub = ListToString(env, argv[0]);
string obj = ListToString(env, argv[1]);
string act = ListToString(env, argv[2]);
string sub = BinToString(env, argv[0]);
string obj = BinToString(env, argv[1]);
string act = BinToString(env, argv[2]);

try{
return enforcer->Enforce({sub.c_str(), obj.c_str(), act.c_str()})
Expand All @@ -128,12 +149,12 @@ ERL_NIF_TERM Enforce(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {

ERL_NIF_TERM AddPolicy(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
if(!enforcer) {
return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create and enforcer first."));
return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create an enforcer first."));
}

string sub = ListToString(env, argv[0]);
string obj = ListToString(env, argv[1]);
string act = ListToString(env, argv[2]);
string sub = BinToString(env, argv[0]);
string obj = BinToString(env, argv[1]);
string act = BinToString(env, argv[2]);

try{
enforcer->InvalidateCache();
Expand All @@ -147,12 +168,12 @@ ERL_NIF_TERM AddPolicy(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {

ERL_NIF_TERM RemovePolicy(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
if(!enforcer) {
return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create and enforcer first."));
return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create an enforcer first."));
}

string sub = ListToString(env, argv[0]);
string obj = ListToString(env, argv[1]);
string act = ListToString(env, argv[2]);
string sub = BinToString(env, argv[0]);
string obj = BinToString(env, argv[1]);
string act = BinToString(env, argv[2]);

try{
enforcer->InvalidateCache();
Expand All @@ -166,11 +187,11 @@ ERL_NIF_TERM RemovePolicy(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {

ERL_NIF_TERM AddGroupingPolicy(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
if(!enforcer) {
return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create and enforcer first."));
return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create an enforcer first."));
}

string user = ListToString(env, argv[0]);
string group = ListToString(env, argv[1]);
string user = BinToString(env, argv[0]);
string group = BinToString(env, argv[1]);

try{
enforcer->InvalidateCache();
Expand All @@ -184,12 +205,13 @@ ERL_NIF_TERM AddGroupingPolicy(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv

ERL_NIF_TERM GetUsersForRole(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
if(!enforcer) {
return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create and enforcer first."));
return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create an enforcer first."));
}

string role = ListToString(env, argv[0]);
string role = BinToString(env, argv[0]);
try{
return VectorToList(env, enforcer->GetUsersForRole(role));
ERL_NIF_TERM list = VectorToList(env, enforcer->GetUsersForRole(role));
return make_result_tuple( PF_ATOM_OK, list );
} catch(const casbin::CasbinRBACException &e) {
return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("RBAC exception"));
} catch(...) {
Expand All @@ -199,23 +221,24 @@ ERL_NIF_TERM GetUsersForRole(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]

ERL_NIF_TERM GetRolesForUser(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
if(!enforcer) {
return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create and enforcer first."));
return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create an enforcer first."));
}

string user = ListToString(env, argv[0]);
string user = BinToString(env, argv[0]);
try{
return VectorToList(env, enforcer->GetRolesForUser(user));
ERL_NIF_TERM list = VectorToList(env, enforcer->GetRolesForUser(user));
return make_result_tuple( PF_ATOM_OK, list );
} catch(...) {
return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Unexpected exception"));
}
}

ERL_NIF_TERM DeleteRole(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
if(!enforcer) {
return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create and enforcer first."));
return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create an enforcer first."));
}

string role = ListToString(env, argv[0]);
string role = BinToString(env, argv[0]);
try{
enforcer->InvalidateCache();
return enforcer->DeleteRole({role})
Expand All @@ -230,11 +253,11 @@ ERL_NIF_TERM DeleteRole(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {

ERL_NIF_TERM AddRoleForUser(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
if(!enforcer) {
return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create and enforcer first."));
return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create an enforcer first."));
}

string user = ListToString(env, argv[0]);
string role = ListToString(env, argv[1]);
string user = BinToString(env, argv[0]);
string role = BinToString(env, argv[1]);
try{
enforcer->InvalidateCache();
return enforcer->AddRoleForUser(user, role)
Expand All @@ -249,10 +272,10 @@ ERL_NIF_TERM AddRoleForUser(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])

ERL_NIF_TERM AddRolesForUser(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
if(!enforcer) {
return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create and enforcer first."));
return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create an enforcer first."));
}

string user = ListToString(env, argv[0]);
string user = BinToString(env, argv[0]);
vector<string> roles = ListToVector(env, argv[1]);
try{
enforcer->InvalidateCache();
Expand All @@ -268,10 +291,10 @@ ERL_NIF_TERM AddRolesForUser(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]

ERL_NIF_TERM DeleteRolesForUser(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
if(!enforcer) {
return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create and enforcer first."));
return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create an enforcer first."));
}

string user = ListToString(env, argv[0]);
string user = BinToString(env, argv[0]);
try{
enforcer->InvalidateCache();
return enforcer->DeleteRolesForUser(user)
Expand All @@ -287,11 +310,11 @@ ERL_NIF_TERM DeleteRolesForUser(ErlNifEnv* env, int argc, const ERL_NIF_TERM arg

ERL_NIF_TERM DeleteRoleForUser(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
if(!enforcer) {
return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create and enforcer first."));
return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create an enforcer first."));
}

string user = ListToString(env, argv[0]);
string role = ListToString(env, argv[1]);
string user = BinToString(env, argv[0]);
string role = BinToString(env, argv[1]);
try{
enforcer->InvalidateCache();
return enforcer->DeleteRoleForUser(user, role)
Expand All @@ -306,7 +329,7 @@ ERL_NIF_TERM DeleteRoleForUser(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv

ERL_NIF_TERM RemoveFilteredPolicy(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
if(!enforcer) {
return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create and enforcer first."));
return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create an enforcer first."));
}

int fieldIndex = 0;
Expand All @@ -320,15 +343,17 @@ ERL_NIF_TERM RemoveFilteredPolicy(ErlNifEnv* env, int argc, const ERL_NIF_TERM a
return enforcer->RemoveFilteredPolicy(fieldIndex, resourceId)
?PF_ATOM_TRUE
:PF_ATOM_FALSE;
} catch(...) {
return PF_ATOM_FALSE;
} catch(const casbin::CasbinRBACException &e) {
return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("RBAC exception"));
} catch(std::exception e2) {
return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING(e2.what()));
}
}


ERL_NIF_TERM GetFilteredPolicy(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
if(!enforcer) {
return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create and enforcer first."));
return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("Must create an enforcer first."));
}

int fieldIndex = 0;
Expand All @@ -338,9 +363,12 @@ ERL_NIF_TERM GetFilteredPolicy(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv
vector<string> resourceId = ListToVector(env, argv[1]);

try{
return VectorToList(env, enforcer->GetFilteredPolicy(fieldIndex, resourceId));
} catch(...) {
return PF_ATOM_FALSE;
ERL_NIF_TERM list = VectorToList(env, enforcer->GetFilteredPolicy(fieldIndex, resourceId));
return make_result_tuple( PF_ATOM_OK, list );
} catch(const casbin::CasbinRBACException &e) {
return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING("RBAC exception") );
} catch(std::exception e2) {
return make_result_tuple( PF_ATOM_ERROR, PF_MAKE_STRING(e2.what()) );
}
}

Expand All @@ -363,4 +391,4 @@ ErlNifFunc casbinex_nif_funcs[] =
{"getFilteredPolicy", 2, GetFilteredPolicy},
};

ERL_NIF_INIT(Elixir.Casbinex, casbinex_nif_funcs, 0, 0, 0, 0);
ERL_NIF_INIT(Elixir.Casbinex.Base, casbinex_nif_funcs, 0, 0, 0, 0);
4 changes: 2 additions & 2 deletions config/test.exs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,5 +1,5 @@
use Mix.Config

config :casbinex,
model_path: 'test/data/rbac_model.conf',
pg_connection: 'test/data/rbac_policy.csv' #postgresql://<user>:<pass>@<host>/<db>
model_path: "test/data/rbac_model.conf",
pg_connection: "test/data/rbac_policy.csv" #postgresql://<user>:<pass>@<host>/<db>
76 changes: 41 additions & 35 deletions lib/casbinex.ex
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -3,71 +3,77 @@ defmodule Casbinex do
Documentation for `Casbinex`.
"""

@on_load :load_nifs
alias Casbinex.Base

app = Mix.Project.config[:app]
def load_nifs do
path = :filename.join(:code.priv_dir(unquote(app)), 'casbinex_nif')
:ok = :erlang.load_nif(path, 0)
def createEnforcer(modelpath, policypath) do
Base.createEnforcer(modelpath, policypath)
end

def createEnforcer(_modelpath, _policypath) do
raise "NIF createEnforcerdd/2 not implemented"
def destroyEnforcer() do
Base.destroyEnforcer()
end

def destroyEnforcer() do
raise "NIF destroyEnforcer/0 not implemented"
def enforce(sub, obj, act) do
Base.enforce(sub, obj, act)
end

def addPolicy(sub, obj, act) do
Base.addPolicy(sub, obj, act)
end

def removePolicy(sub, obj, act) do
Base.removePolicy(sub, obj, act)
end

def enforce(_sub, _obj, _act) do
raise "NIF enforce/3 not implemented"
def addGroupingPolicy(user, group) do
Base.addGroupingPolicy(user, group)
end

def addPolicy(_sub, _obj, _act) do
raise "NIF addPolicy/3 not implemented"
def getUsersForRole(role) do
Base.getUsersForRole(role)
end

def removePolicy(_sub, _obj, _act) do
raise "NIF removePolicy/3 not implemented"
def getRolesForUser(user) do
Base.getRolesForUser(user)
end

def addGroupingPolicy(_user, _group) do
raise "NIF addGroupingPolicy/2 not implemented"
def deleteRole(role) do
Base.deleteRole(role)
end

def getUsersForRole(_role) do
raise "NIF getUsersForRole/1 not implemented"
def deleteRoleForUser(user, role) do
Base.deleteRoleForUser(user, role)
end

def getRolesForUser(_user) do
raise "NIF getRolesForUser/1 not implemented"
def deleteRolesForUser(user) do
Base.deleteRolesForUser(user)
end

def deleteRole(_role) do
raise "NIF deleteRole/1 not implemented"
def addRoleForUser(user, role) do
Base.addRoleForUser(user, role)
end

def deleteRoleForUser(_user, _role) do
raise "NIF deleteRoleForUser/2 not implemented"
def addRolesForUser(user, roles) when is_list(roles) do
Base.addRolesForUser(user, roles)
end

def deleteRolesForUser(_user) do
raise "NIF deleteRolesForUser/1 not implemented"
def addRolesForUser(user, roles) do
Base.addRoleForUser(user, roles)
end

def addRoleForUser(_user, _role) do
raise "NIF addRoleForUser/2 not implemented"
def getFilteredPolicy(fieldindex, fields) when is_list(fields) do
Base.getFilteredPolicy(fieldindex, fields)
end

def addRolesForUser(_user, _role) do
raise "NIF addRolesForUser/2 not implemented"
def getFilteredPolicy(fieldindex, field) do
Base.getFilteredPolicy(fieldindex, [field])
end

def getFilteredPolicy(_field_index, _fields) do
raise "NIF getFilteredPolicy/2 not implemented"
def removeFilteredPolicy(fieldindex, fields) when is_list(fields) do
Base.removeFilteredPolicy(fieldindex, fields)
end

def removeFilteredPolicy(_field_index, _fields) do
raise "NIF removeFilteredPolicy/2 not implemented"
def removeFilteredPolicy(fieldindex, field) do
Base.removeFilteredPolicy(fieldindex, [field])
end
end
Loading