source: libabac/abac_pl_gen.c @ 8c45663

mei_rt2mei_rt2_fix_1meiyap-rt1rt2
Last change on this file since 8c45663 was 8c45663, checked in by Mei <mei@…>, 12 years ago

1) fix a typo in abac_pl_gen.c
  • Property mode set to 100644
File size: 23.4 KB
Line 
1
2
3/***********************************************************************/
4/* clause generation called from parser to generate credential clauses */
5/***********************************************************************/
6#include <stdio.h>
7#include <assert.h>
8#include <stdlib.h>
9
10#include "abac_set.h"
11#include "abac_util.h"
12#include "abac_pl.h"
13
14#include "uthash.h"
15
16// index to generate C1,C2..
17static int cred_count=0;
18
19extern char* abac_yyfptr_encoded;
20extern int abac_yy_cnt_yy_id_certs();
21extern void abac_yy_free_yy_id_certs();
22extern char *abac_yy_string_yy_id_certs();
23extern void abac_yy_free_yy_constraints();
24extern char *abac_yy_string_yy_constraints();
25
26/***********************************************************************/
27static int _get_next_cred_idx()
28{
29    cred_count++;
30    return cred_count;
31}
32
33/* remember to free the returned string */
34static char *_compose_cred_list()
35{
36    int i=cred_count;
37    if(cred_count==0) return "";
38
39    char *clist=(char *)abac_xmalloc(sizeof(char)*(cred_count)*3);
40    strcpy(clist,"C1");
41    if (cred_count==1) return clist;
42
43    i=1;
44    while(i!=cred_count) {
45        i++;
46        sprintf(clist,"%s,C%d",clist,i);
47    }
48    return clist;
49}
50
51/* generate role(p_name, r_name, param..) */
52static char* generate_pl_head_role_string(abac_role_t *role)
53{
54     char *tmp=NULL;
55     char *principalname=abac_role_principal_cn(role);
56     char *rolename=abac_role_role_name(role);
57     char *param_string=NULL;
58     int cnt=0;
59
60     /* can not be a linked role */
61     abac_param_list_t *role_params=abac_role_role_params(role);
62     if(role_params) {
63        param_string=abac_param_list_string(role_params);
64     }
65
66     if (param_string != NULL) {
67         cnt=asprintf(&tmp,"role(%s,%s,%s)", principalname, rolename, param_string);
68         free(param_string);
69         } else {
70             cnt=asprintf(&tmp,"role(%s,%s)", principalname, rolename);
71     }
72     if(cnt>0)
73        return tmp;
74        else
75           return NULL;
76}
77
78/* generate role(p_name, r_name, param..) with isMember call ?? */
79static char* generate_pl_tail_role_string(abac_role_t *role)
80{
81     char *tmp;
82     char *principalname=abac_role_principal_cn(role);
83     char *rolename=abac_role_role_name(role);
84     char *linkedname=abac_role_linked_role(role);
85
86     char *param_string=NULL;
87     char *linked_param_string=NULL;
88     int cnt=0;
89
90     abac_param_list_t *role_params=abac_role_role_params(role);
91     if(role_params) {
92        param_string=abac_param_list_string(role_params);
93     }
94
95     abac_param_list_t *linked_role_params=abac_role_linked_role_params(role);
96     if(linked_role_params) {
97        linked_param_string=abac_param_list_string(linked_role_params);
98     }
99
100     /* b.r.r */
101     if(linkedname!=NULL && rolename!=NULL && principalname!=NULL ) {
102         int fst=_get_next_cred_idx();
103         int snd=_get_next_cred_idx();
104         if(linked_param_string !=NULL) {
105             if (param_string != NULL) {
106                 cnt=asprintf(&tmp,"isMember(Y,role(%s,%s,%s),C%d),isMember(X,role(Y,%s,%s),C%d)",
107                            principalname,
108                            linkedname,linked_param_string,fst,
109                            rolename,param_string,snd);
110                 free(param_string);
111                 } else {
112                     cnt=asprintf(&tmp,"isMember(Y,role(%s,%s,%s),C%d),isMember(X,role(Y,%s),C%d)",
113                            principalname,
114                            linkedname,linked_param_string,fst,
115                            rolename,snd);
116             }
117             free(linked_param_string);
118             } else {
119                 if (role_params != NULL) {
120                     cnt=asprintf(&tmp,"isMember(Y,role(%s,%s),C%d),isMember(X,role(Y,%s,%s),C%d)",
121                            principalname,
122                            linkedname,fst,
123                            rolename,param_string,snd);
124                     free(param_string);
125                     } else {
126                         cnt=asprintf(&tmp,"isMember(Y,role(%s,%s),C%d),isMember(X,role(Y,%s),C%d)",
127                            principalname,
128                            linkedname,fst,
129                            rolename,snd);
130               }
131         }
132         if(cnt>0)
133             return tmp;
134             else
135                 return NULL;
136     } 
137     /* b.r */
138     if(linkedname==NULL && rolename!=NULL && principalname!=NULL ) {
139         int fst=_get_next_cred_idx();
140         if(param_string != NULL) {
141             cnt=asprintf(&tmp,"isMember(X,role(%s,%s,%s),C%d)",
142                          principalname, rolename, param_string, fst);
143             free(param_string);
144             } else {
145                 cnt=asprintf(&tmp,"isMember(X,role(%s,%s),C%d)",
146                          principalname, rolename, fst);
147         }
148         if(cnt>0)
149             return tmp;
150             else
151                 return NULL;
152     } 
153     /* b */
154     if(linkedname==NULL && rolename==NULL && principalname!=NULL ) {
155         tmp=abac_xstrdup(principalname);
156         return tmp;
157     } 
158
159     return tmp;
160}
161
162
163/* generate oset(p_name, r_name, param..) */
164static char* generate_pl_head_oset_string(abac_oset_t *oset)
165{
166     char *tmp=NULL;
167     char *principalname=abac_oset_principal_cn(oset);
168     char *osetname=abac_oset_oset_name(oset);
169     char *param_string=NULL;
170     int cnt=0;
171
172     /* can not be a linked role */
173     abac_param_list_t *oset_params=abac_oset_oset_params(oset);
174     if(oset_params) {
175        param_string=abac_param_list_string(oset_params);
176     }
177
178     if (param_string != NULL) {
179         cnt=asprintf(&tmp,"oset(%s,%s,%s)", principalname, osetname, param_string);
180         free(param_string);
181         } else {
182             cnt=asprintf(&tmp,"oset(%s,%s)", principalname, osetname);
183     }
184     if(cnt>0)
185        return tmp;
186        else
187           return NULL;
188}
189
190/* generate oset(p_name, r_name, param..) with isMember call ?? */
191static char* generate_pl_tail_oset_string(abac_oset_t *oset)
192{
193     char *tmp;
194/*
195   A.oset <- B
196   A.oset <- Obj
197   A.oset <- B.oset
198   A.oset <- B.role.oset
199*/
200     /* o */
201     if(abac_oset_is_object(oset)) {
202         char *objectname=abac_oset_object_cn(oset);
203         tmp=abac_xstrdup(objectname);
204         return tmp;
205     } else {
206         char *principalname=abac_oset_principal_cn(oset);
207         char *osetname=abac_oset_oset_name(oset);
208         char *linkedname=abac_oset_linked_role(oset);
209
210         char *param_string=NULL;
211         char *linked_param_string=NULL;
212         int cnt=0;
213
214         abac_param_list_t *oset_params=abac_oset_oset_params(oset);
215         if(oset_params) {
216             param_string=abac_param_list_string(oset_params);
217         }
218
219         abac_param_list_t *linked_role_params=abac_oset_linked_role_params(oset);
220         if(linked_role_params) {
221             linked_param_string=abac_param_list_string(linked_role_params);
222         }
223
224         /* b.r.r */
225         if(linkedname!=NULL && osetname!=NULL && principalname!=NULL ) {
226             int fst=_get_next_cred_idx();
227             int snd=_get_next_cred_idx();
228             if(linked_param_string !=NULL) {
229                 if (param_string != NULL) {
230                     cnt=asprintf(&tmp,"isMember(Y,role(%s,%s,%s),C%d),isMember(X,oset(Y,%s,%s),C%d)",
231                                principalname,
232                                linkedname,linked_param_string,fst,
233                                osetname,param_string,snd);
234                     free(param_string);
235                     } else {
236                         cnt=asprintf(&tmp,"isMember(Y,role(%s,%s,%s),C%d),isMember(X,oset(Y,%s),C%d)",
237                                principalname,
238                                linkedname,linked_param_string,fst,
239                                osetname,snd);
240                 }
241                 free(linked_param_string);
242                 } else {
243                     if (oset_params != NULL) {
244                         cnt=asprintf(&tmp,"isMember(Y,role(%s,%s),C%d),isMember(X,oset(Y,%s,%s),C%d)",
245                                principalname,
246                                linkedname,fst,
247                                osetname,param_string,snd);
248                         free(param_string);
249                         } else {
250                             cnt=asprintf(&tmp,"isMember(Y,role(%s,%s),C%d),isMember(X,oset(Y,%s),C%d)",
251                                principalname,
252                                linkedname,fst,
253                                osetname,snd);
254                   }
255             }
256             if(cnt>0)
257                 return tmp;
258                 else
259                     return NULL;
260         } 
261         /* b.r */
262         if(linkedname==NULL && osetname!=NULL && principalname!=NULL ) {
263             int fst=_get_next_cred_idx();
264             if(param_string != NULL) {
265                 cnt=asprintf(&tmp,"isMember(X,oset(%s,%s,%s),C%d)",
266                              principalname, osetname, param_string, fst);
267                 free(param_string);
268                 } else {
269                     cnt=asprintf(&tmp,"isMember(X,oset(%s,%s),C%d)",
270                              principalname, osetname, fst);
271             }
272             if(cnt>0)
273                 return tmp;
274                 else
275                     return NULL;
276         } 
277         /* b */
278         if(linkedname==NULL && osetname==NULL && principalname!=NULL ) {
279             tmp=abac_xstrdup(principalname);
280             return tmp;
281         } 
282
283    }
284    return tmp;
285}
286
287
288/********************************************************************************/
289
290static char *_build_constraint_rule_clause(char *head_string, char *tail_string)
291{
292    /*only,  A.R <- B */
293    char *tmp;
294    int idx=_get_next_cred_idx();
295    asprintf(&tmp, "isMember(%s,%s,C%d)", tail_string,head_string,idx);
296    return tmp;
297}
298
299static char *_build_rule_clause(char *rolename, char *head_string,
300char *tail_string, char *id_string, char *constraint_string)
301{
302    char *tmp=NULL;
303
304    if(rolename == NULL) {
305        /* A.R <- B */
306        if(id_string == NULL && constraint_string == NULL) {
307            asprintf(&tmp, "isMember(%s,%s,['%s'])",
308                     tail_string,head_string,abac_yyfptr_encoded);
309            } else {
310                if(id_string == NULL) {
311                    asprintf(&tmp, "isMember(%s,%s,['%s']) :- %s",
312                         tail_string,head_string,abac_yyfptr_encoded,
313                         constraint_string);
314                } else if(constraint_string == NULL) {
315                    asprintf(&tmp, "isMember(%s,%s,['%s']) :- %s",
316                         tail_string,head_string,abac_yyfptr_encoded,
317                         id_string);
318                } else { asprintf(&tmp, "isMember(%s,%s,['%s']) :- %s,%s",
319                         tail_string,head_string,abac_yyfptr_encoded,
320                         id_string, constraint_string);
321                }
322        }
323        } else {
324             /* A.R <- B.R */
325             /* A.R <- B.R.R */
326             if (cred_count==0) {
327                 if(id_string == NULL && constraint_string == NULL) {
328                     asprintf(&tmp,"isMember(X,%s,['%s']):-%s",
329                           head_string, abac_yyfptr_encoded, tail_string);
330                     } else {
331                         if(id_string == NULL) {
332                             asprintf(&tmp,"isMember(X,%s,['%s']):-%s,%s",
333                                 head_string, abac_yyfptr_encoded, tail_string,
334                                 constraint_string);
335                         } else if(constraint_string == NULL) {
336                             asprintf(&tmp,"isMember(X,%s,['%s']):-%s,%s",
337                                 head_string, abac_yyfptr_encoded, id_string,
338                                 tail_string);
339                         } else { 
340                             asprintf(&tmp,"isMember(X,%s,['%s']):-%s,%s,%s",
341                                 head_string, abac_yyfptr_encoded, id_string,
342                                 tail_string, constraint_string);
343                         }
344                 }
345                 } else {
346                     char *tmp_cred_list=_compose_cred_list();
347                     if(id_string == NULL && constraint_string == NULL) {
348                         asprintf(&tmp,"isMember(X,%s,L):-%s, appendL([['%s'],%s],L)",
349                                  head_string, tail_string,
350                                  abac_yyfptr_encoded, tmp_cred_list);
351                         } else {
352                            if(id_string == NULL) {
353                               asprintf(&tmp,"isMember(X,%s,L):-%s, %s, appendL([['%s'],%s],L)",
354                                  head_string, tail_string, constraint_string,
355                                  abac_yyfptr_encoded, tmp_cred_list);
356                            } else if(constraint_string == NULL) {
357                               asprintf(&tmp,"isMember(X,%s,L):-%s, %s, appendL([['%s'],%s],L)",
358                                  head_string, id_string, tail_string,
359                                  abac_yyfptr_encoded, tmp_cred_list);
360                            } else { 
361                               asprintf(&tmp,"isMember(X,%s,L):-%s, %s, %s, appendL([['%s'],%s],L)",
362                                  head_string, id_string, tail_string,
363                                  constraint_string,
364                                  abac_yyfptr_encoded, tmp_cred_list);
365                            }
366                     }
367                     free(tmp_cred_list);
368                     cred_count=0;
369             }
370    }
371    return tmp;
372}
373
374
375static char *generate_pl_rule_role_clause(char *head_role_string,
376abac_role_t *tail_role, char *id_string, char *constraint_string)
377{
378    char *rolename=abac_role_role_name(tail_role);
379    char *tail_role_string=generate_pl_tail_role_string(tail_role);
380    if(rolename == NULL && tail_role_string == NULL) 
381        goto error;
382    char *tmp=_build_rule_clause(rolename,head_role_string, tail_role_string,
383                                          id_string, constraint_string);
384    if(tail_role_string) free(tail_role_string);
385    return tmp;
386
387error:
388    if(tail_role_string) free(tail_role_string);
389    return NULL;
390}
391
392static char *generate_pl_rule_oset_clause(char *head_oset_string, abac_oset_t *tail_oset, char *id_string, char *constraint_string)
393{
394    char *osetname=abac_oset_oset_name(tail_oset);
395    char *tail_oset_string=generate_pl_tail_oset_string(tail_oset);
396    if(osetname == NULL && tail_oset_string == NULL) 
397        goto error;
398    char *tmp=_build_rule_clause(osetname,head_oset_string, tail_oset_string, id_string, constraint_string);
399    if(tail_oset_string) free(tail_oset_string);
400    return tmp;
401
402error:
403    if(tail_oset_string) free(tail_oset_string);
404    return NULL;
405}
406
407
408static char *_add_string(char *dstr, char *nstr)
409{
410    if(strlen(dstr)==0) {
411        dstr=abac_xstrdup(nstr);
412        return dstr;
413        } else { 
414            int len = strlen(dstr)+strlen(nstr)+2;
415            char *tmp=abac_xmalloc(len*sizeof(char));
416            sprintf(tmp,"%s,%s", dstr,nstr);
417            free(dstr);
418            return tmp;
419    }
420    return NULL;
421}
422
423static char *_build_intersecting_clause(char *head_role_string,
424char *tail_role_string, char* id_string, char* constraint_string)
425{
426    char *tmp;
427
428    if (cred_count==0) {
429        if(id_string == NULL && constraint_string == NULL) {
430            asprintf(&tmp,"isMember(X,%s,['%s']):-%s",
431                   head_role_string, abac_yyfptr_encoded, tail_role_string);
432            } else {
433             if(id_string == NULL) {
434                asprintf(&tmp,"isMember(X,%s,['%s']):-%s, %s",
435                       head_role_string, abac_yyfptr_encoded, 
436                       tail_role_string, constraint_string);
437             } else if(constraint_string == NULL) {
438                asprintf(&tmp,"isMember(X,%s,['%s']):-%s, %s",
439                       head_role_string, abac_yyfptr_encoded, 
440                       id_string, tail_role_string);
441             } else {   
442                asprintf(&tmp,"isMember(X,%s,['%s']):-%s, %s, %s",
443                       head_role_string, abac_yyfptr_encoded, 
444                       id_string, tail_role_string, constraint_string);
445             }           
446        }
447        } else {
448            char *tmp_cred_list=_compose_cred_list();
449            if(id_string == NULL && constraint_string == NULL) {
450                asprintf(&tmp,"isMember(X,%s,L):-%s, appendL([['%s'],%s],L)",
451                                head_role_string, tail_role_string,
452                                abac_yyfptr_encoded, tmp_cred_list);
453                } else {
454                    if(id_string == NULL) {
455                        asprintf(&tmp,"isMember(X,%s,L):-%s, %s, appendL([['%s'],%s],L)",
456                            head_role_string, tail_role_string, constraint_string,
457                            abac_yyfptr_encoded, tmp_cred_list);
458                    } else if(constraint_string == NULL) {
459                        asprintf(&tmp,"isMember(X,%s,L):-%s, %s, appendL([['%s'],%s],L)",
460                            head_role_string, id_string, tail_role_string,
461                            abac_yyfptr_encoded, tmp_cred_list);
462                    } else {   
463                        asprintf(&tmp,"isMember(X,%s,L):-%s, %s, %s, appendL([['%s'],%s],L)",
464                            head_role_string, id_string, tail_role_string, constraint_string,
465                            abac_yyfptr_encoded, tmp_cred_list);
466                    }           
467            }
468            free(tmp_cred_list);
469            cred_count=0;
470    }
471    return tmp;
472}
473
474static char *generate_pl_intersecting_role_clause(char *head_role_string,
475abac_role_t *tail_role, char* id_string, char* constraint_string)
476{
477    char *tmp=NULL;
478    char* tail_role_string=NULL;
479    abac_list_t *list=abac_role_prereqs(tail_role);
480    /* A.R <- B.R & C.R.R */
481
482    if (list != NULL) {
483        abac_role_t *cur;
484        abac_list_foreach(list, cur,
485            char *ntmp=generate_pl_tail_role_string(cur);
486            if(tail_role_string==NULL)
487                 asprintf(&tail_role_string,"%s",ntmp);
488                 else
489                    asprintf(&tail_role_string,"%s, %s",tail_role_string,ntmp);
490            free(ntmp);
491        );
492    }
493
494    tmp=_build_intersecting_clause(head_role_string, tail_role_string, id_string,constraint_string);
495    if(tail_role_string) free(tail_role_string);
496    return tmp;
497}
498
499static char *generate_pl_intersecting_oset_clause(char *head_oset_string, abac_oset_t *tail_oset, char* id_string, char* constraint_string)
500{
501    char *tmp=NULL;
502    char* tail_oset_string=NULL;
503    abac_list_t *list=abac_oset_prereqs(tail_oset);
504    /* A.O <- B.O & C.R.O */
505
506    if (list != NULL) {
507        abac_oset_t *cur;
508        abac_list_foreach(list, cur,
509            char *ntmp=generate_pl_tail_oset_string(cur);
510            if(tail_oset_string==NULL)
511                 asprintf(&tail_oset_string,"%s",ntmp);
512                 else
513                    asprintf(&tail_oset_string,"%s, %s",tail_oset_string,ntmp);
514            free(ntmp);
515        );
516    }
517
518    tmp=_build_intersecting_clause(head_oset_string, tail_oset_string,
519                                            id_string, constraint_string);
520    if(tail_oset_string) free(tail_oset_string);
521    return tmp;
522}
523
524/* generate the yap isMember rule clause for the credential stmt */
525abac_list_t *generate_pl_role_clauses(abac_role_t *head_role, abac_role_t *tail_role)
526{
527   char *tmp=NULL;
528   char *id_clauses_string=NULL;
529   char *constraint_clauses_string=NULL;
530   abac_list_t *clauses=abac_list_new();
531 
532   int cnt=abac_yy_cnt_yy_id_certs();
533   if(cnt > 0) { /* string it up */
534       id_clauses_string=abac_yy_string_yy_id_certs();
535       abac_yy_free_yy_id_certs();
536   }
537
538   /* XXX make a loop here */
539   cnt=abac_yy_cnt_yy_constraints();
540   if(cnt > 0) {
541      constraint_clauses_string=abac_yy_string_yy_constraints();
542      abac_yy_free_yy_constraints();
543   }
544
545/* generate head's role string */
546    char *head_role_string=generate_pl_head_role_string(head_role);
547    if(head_role_string == NULL)
548        goto error;
549
550/* tail side */
551    if(abac_role_is_intersection(tail_role)) {
552       tmp=generate_pl_intersecting_role_clause(head_role_string, tail_role,
553                    id_clauses_string, constraint_clauses_string);
554       } else {
555           tmp=generate_pl_rule_role_clause(head_role_string, tail_role,
556                    id_clauses_string, constraint_clauses_string);
557    }
558    if(tmp==NULL)
559        goto error;
560 
561    abac_list_add(clauses,tmp);
562    return clauses;
563
564error:
565    if(head_role_string) free(head_role_string);
566    if(id_clauses_string) free(id_clauses_string);
567    if(constraint_clauses_string) free(constraint_clauses_string);
568    return clauses;
569}
570
571abac_list_t *generate_pl_oset_clauses(abac_oset_t *head_oset, abac_oset_t *tail_oset)
572{
573   char *tmp=NULL;
574   char *id_clauses_string=NULL;
575   char *constraint_clauses_string=NULL;
576   abac_list_t *clauses=abac_list_new();
577
578   int cnt=abac_yy_cnt_yy_id_certs();
579   if(cnt > 0) { /* string it up */
580       id_clauses_string=abac_yy_string_yy_id_certs();
581       abac_yy_free_yy_id_certs();
582   }
583
584   /* XXX */
585   cnt=abac_yy_cnt_yy_constraints();
586   if(cnt > 0) {
587      constraint_clauses_string=abac_yy_string_yy_constraints();
588      abac_yy_free_yy_constraints();
589   }
590
591/* generate head's oset string */
592    char *head_oset_string=generate_pl_head_oset_string(head_oset);
593    if(head_oset_string == NULL)
594        goto error;
595   
596/* tail side */
597    if(abac_oset_is_intersection(tail_oset)) {
598       tmp=generate_pl_intersecting_oset_clause(head_oset_string, tail_oset,
599                            id_clauses_string, constraint_clauses_string);
600       } else {
601           tmp=generate_pl_rule_oset_clause(head_oset_string, tail_oset,
602                             id_clauses_string, constraint_clauses_string);
603    }
604    if(tmp==NULL)
605        goto error;
606
607    abac_list_add(clauses,tmp);
608    return clauses;
609
610error:
611    if(head_oset_string) free(head_oset_string);
612    if(id_clauses_string) free(id_clauses_string);
613    if(constraint_clauses_string) free(constraint_clauses_string);
614    return clauses;
615}
616
617/* should be just 1 */
618char *generate_pl_role_constraint_clause(abac_role_t *head_role, char *tail_string)
619{
620/* generate head's role string */
621    char *head_role_string=generate_pl_head_role_string(head_role);
622    if(head_role_string == NULL)
623        goto error;
624
625/* tail side */
626    char *tmp=_build_constraint_rule_clause(head_role_string, tail_string);
627    if(tmp==NULL)
628        goto error;
629
630    return tmp;
631
632error:
633    if(head_role_string) free(head_role_string);
634    return NULL;
635}
636
637
638
639/* integer(X)<10 */
640/* X='abc' */
641char *generate_pl_range_constraint(char *typestr,char *var,char *val,char *op)
642{
643   char *tmp=NULL;
644   if(typestr)
645      asprintf(&tmp,"%s(%s)%s%s",typestr,var,op,val);
646      else
647          asprintf(&tmp,"%s%s%s",var,op,val);
648   return tmp;
649}
650
651/* should just be 1 clause */
652char *generate_pl_oset_constraint_clause(abac_oset_t *head_oset,
653char *tail_string)
654{
655/* generate head's oset string */
656    char *head_oset_string=generate_pl_head_oset_string(head_oset);
657    if(head_oset_string == NULL)
658        goto error;
659
660/* tail side */
661    char *tmp=_build_constraint_rule_clause(head_oset_string, tail_string);
662    if(tmp==NULL)
663        goto error;
664
665    return tmp;
666error:
667    if(head_oset_string) free(head_oset_string);
668    return NULL;
669}
670
671
672/* generate the yap isType rule clause for the type,
673   isType(Acme, keyid); */
674char *generate_pl_type_clause(char *principalname, int type)
675{
676    char *tmp=NULL;
677    char *typeid= abac_keyid_type(type);
678    if(strcmp(typeid,"NULL")==0)
679        panic("generate_pl_type_clause: can not have null typeid");
680    int cnt=asprintf(&tmp,"isType(%s,%s)",
681                                principalname, typeid);
682    return tmp;
683}
684
Note: See TracBrowser for help on using the repository browser.