source: libabac/abac_pl_yap.c @ 202a7f9

/* copied from abac_graph.c 
   implementation of the low level using
   yap prolog
*/

#include <err.h>
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <Yap/YapInterface.h>

#include "abac_pl.h"
#include "abac_pl_yap.h"

#include "abac_list.h"
#include "abac_util.h"

#include "uthash.h"

extern char *abac_cn_with_role(abac_role_t *);
extern abac_list_t *abac_credential_clauses(abac_credential_t *cred);
static int debug=0;

// pl
struct _abac_pl_t {
    FILE *fptr;
    char *fname;
    char *yap_certs;
};

static int _insert_clause(char *str)
{
    YAP_Term *eterm;
    YAP_Term goalArgs=YAP_ReadBuffer(str, eterm);
    char *tmp=YAP_CompileClause(goalArgs);
    if (tmp!=NULL) { /* something is wrong */
        printf("error: result of compile clause (%s)\n", tmp);
        printf("error: str used (%s)\n", str);
        return 1;
    }
    return 0;
}

static int _insert_cred_clause(char *cstr)
{
    int ret=ABAC_CERT_SUCCESS;
    int rc=_insert_clause(cstr);
    if (rc)
        return ABAC_CERT_BAD_YAP;
    return ABAC_CERT_SUCCESS;
}

static void _show_yap_db(char *msg)
{
    char lstr[]="listing";
    YAP_Term *eterm;

    printf("\n\n========= yap db (%s)\n",msg);
    YAP_Term goal=YAP_ReadBuffer(lstr, eterm);
    int rc =YAP_RunGoal( goal );
    if (rc) {
        printf("listing ok.. \n");
    } else {
        printf("listing's rc is bad.. \n");
        YAP_Exit(1);
    }
    printf("========= \n\n");
}

static void _set_dbg(abac_pl_t *pl)
{
    char *fname=strdup( "/tmp/abac_yap-XXXXXX.pl" );
    int fd = mkstemps( pl->fname, 3 );
    if ( fd == -1) {
        printf("Couldn't get a valid temp name %s\n", fname);
        free((void*)fname);
        YAP_Exit(1);
    }
    FILE *fptr = fdopen(fd, "w");
    if (fptr == NULL) {
        printf("Couldn't open %s for writing\n", fname);
        free((void*)fname);
        YAP_Exit(1);
    }
    pl->fptr=fptr;
    pl->fname=fname;
}

/**
 * Include some utility routines
 */
abac_pl_t *abac_pl_utility(void) {
/*
append([],L,L).
append([X|L1],L2,[X|L3]):-append(L1,L2,L3).

appendL([],[]).
appendL([H|T], L) :-
   appendL(T,L2), append(H,L2,L).
*/
    if(_insert_clause("append([],L,L)"))
        YAP_Exit(1);
    if(_insert_clause("append([X|L1],L2,[X|L3]):-append(L1,L2,L3)"))
        YAP_Exit(1);
    if(_insert_clause("appendL([],[])"))
        YAP_Exit(1);
    if(_insert_clause("appendL([H|T], L) :- appendL(T,L2), append(H,L2,L)"))
        YAP_Exit(1);
}

/**
 * Create a new yap structure.
 */
abac_pl_t *abac_pl_new(void) {

    if (YAP_FastInit(NULL) == YAP_BOOT_ERROR)
        YAP_Exit(1);

    if (YAP_RunGoal(YAP_MkAtomTerm(YAP_LookupAtom("source")))) {
        if(debug) printf("calling source..\n");
        } else {
            if(debug) printf("calling source failed..\n");
            YAP_Exit(1);
    }

    abac_pl_utility();
  
    abac_pl_t *pl = abac_xmalloc(sizeof(abac_pl_t));
    pl->fptr=NULL;
    pl->fname=NULL;
    pl->yap_certs=NULL;
    return pl;
}

/**
 * Add a credential to the db
 */
int abac_pl_add_credential(abac_pl_t *pl, abac_credential_t *cred)
{
    int rc=0;
    abac_list_t *clauses=abac_credential_clauses(cred);
    if (clauses != NULL) {
        char *cur;
        abac_list_foreach(clauses, cur,
            if(cur) {
                if(debug) printf("inserting =>%s\n",cur);
                rc=_insert_cred_clause(cur);
            }
        );
    }
    return rc;
}

int abac_pl_add_type_credential(abac_pl_t *pl, abac_id_cert_t *id_cert)
{
    char *clause=abac_id_clause(id_cert);
    if (clause != NULL) {
        int rc=_insert_cred_clause(clause);
        return rc;
    }
    return 0;
}

/* cases,
     ['str']
     ['str1','str2']
     ([] is not possible, and don't care)
*/
static void _credentials_from_string(abac_stack_t *credentials,char *slist) {
    char *cptr=slist; /* current ptr */
    char *sptr; /* string ptr */
    char *ptr;
    int len=0;
    char *string;
    abac_credential_t *cred=NULL;
    int cnt=0;

    if(debug)
        printf("DEBUG:responds from yap(%s)\n",slist);

    /* find first [' */  
    ptr=strstr(cptr,"['");
    if(ptr == NULL) 
         return;
    cptr=ptr+2;
    sptr=cptr;
    while (1) {
        /* find next ',' or '] */
        ptr=strstr(cptr,"','");
        if(ptr!=NULL) {
             cptr=ptr+3;
             len=(ptr-sptr);
             string=strndup(sptr,len);
             cred=abac_credential_lookup(string);
             free(string); 
             if(cred) {
                 abac_stack_push(credentials, cred);
                 cnt++;
                 } else {
                 printf("BAD BAD BAD\n");
             }
             sptr=cptr;
             } else {
             ptr=strstr(cptr,"']");
             if(ptr!=NULL) {
                 len=(ptr-sptr);
                 string=strndup(sptr,len);
                 cred=abac_credential_lookup(string);
                 free(string);
                 if(cred) {
                     abac_stack_push(credentials, cred);
                     cnt++;
                     } else {
                     printf("BAD BAD BAD\n");
                 }
                 break;
             }
        }
    }
    if(debug)
        printf("DEBUG:total %d credentials\n", cnt);
}

/* 2 types 
      acme.buys_rocket <- coyote (coyote=prin, acme.buys_rocket=role)
      acme.buys_rocket <- acme.preferred_customer  -- NOT DONE YET */
static abac_stack_t *_query(abac_pl_t *pl, abac_role_t* role, abac_role_t* role_prin )
{
    YAP_Term *eterm;
    YAP_Term arg[3];
    char tmp[2000];
    abac_stack_t *cred_list = abac_stack_new();

    if(debug)
        _show_yap_db("DEBUG:calling within _query");

    char *cn_prin=abac_cn_with_role(role_prin);
    char *cn_role=abac_cn_with_role(role);

    if(abac_role_role_name(role_prin)!=NULL) {
        printf("fail, a.r <- b.r query is not implemented yet !!!\n");
        YAP_Exit(1);
    }

    if (cn_prin == NULL || cn_role == NULL) {
        printf("fail, query's call got bad roles.. \n");
        YAP_Exit(1);
    }
    sprintf(tmp,"role(%s,%s)", cn_role, abac_role_role_name(role));
    arg[0]=YAP_MkAtomTerm(YAP_LookupAtom(cn_prin));
    arg[1]=YAP_ReadBuffer(tmp,eterm);
    arg[2]=YAP_MkVarTerm();
    YAP_Atom f = YAP_LookupAtom("isMember");
    YAP_Functor func = YAP_MkFunctor(f, 3);
    YAP_Term goal=YAP_MkApplTerm(func, 3, arg);
    int rc =YAP_RunGoal( goal );
    if (rc) {
        printf("success, query call ok.. \n");
        YAP_WriteBuffer(arg[2], tmp, 2000,YAP_WRITE_HANDLE_VARS);
        /* printf("    answer : %s(%d)\n", tmp, strlen(tmp)); */
        /* this is returned as ['string1','string2'] */
        _credentials_from_string(cred_list,tmp); 
        while (YAP_RestartGoal()) {
            printf("another success\n");
            YAP_WriteBuffer(arg[2], tmp, 2000,YAP_WRITE_HANDLE_VARS);
            /* printf("    answer : %s\n", tmp); */
            _credentials_from_string(cred_list,tmp); 
        }
    } else {
        printf("fail, query's call is bad.. \n");
        YAP_Exit(1);
    }
    return cred_list;
}

/**
 * Make a query into prolog db
--role acme.preferred_customer --principal coyote
--role acme.prefer_customer.buy_rockets --principlal coyote
 */
abac_stack_t *abac_pl_query(abac_pl_t *pl, char *role_name, char *principal)
{
    abac_role_t *role = abac_role_from_string(role_name);
    abac_role_t *prin_role = abac_role_from_string(principal);
    abac_stack_t *ret=NULL;

    // give up on bogus roles
    if (role == NULL || prin_role == NULL) {
        return NULL;
    }

    ret=_query(pl,role,prin_role);

    return ret;
}

/**
 * Get all the credentials (attribute/issuer cert pairs) from prolog
 * (which returns in string form)
 */
abac_stack_t *abac_pl_credentials(abac_pl_t *pl) {
    abac_stack_t *credentials = abac_stack_new();
    /* fix up a stream to stream the credentials from prolog engine */
    return credentials;
}

void abac_pl_free(abac_pl_t *pl) {
    if(pl->fptr) {
        fflush(pl->fptr);
        free(pl->fptr);
    }
    if(pl->fname) {
        unlink(pl->fname);
        free(pl->fname);
    }
    free(pl);
}