/[pdpsoft]/trunk/grid-mw-security/ees/plugin_examples/plugin_transformer/src/transformer.c
ViewVC logotype

Diff of /trunk/grid-mw-security/ees/plugin_examples/plugin_transformer/src/transformer.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 2148 by okoeroo, Fri Jan 7 13:27:11 2011 UTC revision 2149 by okoeroo, Fri Jan 14 22:21:32 2011 UTC
# Line 1  Line 1 
1  #include "eef_plugin.h"  #include "eef_plugin.h"
 #include "gridmapfile.h"  
 #include "gridmapdir.h"  
2  #include <getopt.h>  #include <getopt.h>
3  #include <stdio.h>  #include <stdio.h>
4  #include <stdlib.h>  #include <stdlib.h>
5  #include <pwd.h>  #include <pwd.h>
6  #include <sys/stat.h>  #include <sys/stat.h>
7    
8    
9    #define SPECIAL_EES_OBLIGATION_LIST_ATTR_ID "http://authz-interop.org/xacml/attribute/trans-obligation"
10    #define SPECIAL_EES_OBLIGATION_LIST_DELIMITER "?attrId="
11    
12    
13  EES_PL_RC set_var_as_string(const char* name, char* value);  EES_PL_RC set_var_as_string(const char* name, char* value);
14  EES_PL_RC set_var_as_int(const char* name, int value);  EES_PL_RC set_var_as_int(const char* name, int value);
15  EES_PL_RC set_var_as_void_p(const char* name, void* value, size_t size);  EES_PL_RC set_var_as_void_p(const char* name, void* value, size_t size);
16  char* get_var_as_string(char* name);  char* get_var_as_string(char* name);
17  int get_var_as_int(char* name);  int get_var_as_int(char* name);
18  void* get_var_as_void_p(char* name);  void* get_var_as_void_p(char* name);
 char* dn_to_username(char* _dn);  
 char* find_in_mappings(const char* string, gridmap_list_t *_mappings);  
19    
 EES_PL_RC plugin_initialize(int argc, char* argv[]){  
   int               option_index, c;    /* getopt */  
20    
21    char*             _obligation_name   = NULL;   /* obligation name to create  */  EES_PL_RC plugin_initialize(int argc, char* argv[]){
22    char*             _attribute_user    = NULL;   /* attribute name for user */      aos_dump_argslist();
   char*             _attribute_group   = NULL;   /* attribute name for group */  
   
   char*             _gridmapfile       = NULL;   /* path to gridmapfile */  
   char*             _gridmapdir        = NULL;   /* path to gridmapdir */  
   
   struct stat       _gridmapfile_stat;           /* stat() structs to check existence of gridmapfile */  
   struct stat       _gridmapdir_stat;            /* stat() structs to check existence of gridmapdir */  
   
   char*             _mapping_attribute = NULL;   /* which field to retrieve DN from */  
   
   int               _use_usernames     = 0;      /* wheter to use username strings. uses uid strings otherwise */  
   int               _use_pool          = 0;      /* use pool accounts from gridmapdir */  
   
   int               _retval            = 0;  
   gridmap_list_t   *_mappings          = NULL;  
   
   static struct option long_options[] = /* options */  
   {  
     /*{"gridmap",       required_argument, 0, 'g'},*/  
     {"gridmapfile",   required_argument, 0, 'f'},  
     {"gridmapdir" ,   required_argument, 0, 'd'},  
     {"mapattrib",     required_argument, 0, 'm'},  
     {"obligation",    required_argument, 0, 'o'},  
     {"attribute_u",   required_argument, 0, 'u'},  
     {"attribute_g",   required_argument, 0, 'g'},  
     {"strings",       no_argument,       0, 'n'},  
     {"pool",          no_argument,       0, 'p'}  
   };  
   
   EEF_log(LOG_DEBUG, "%s: Initializing localaccount plugin!\n", EEF_getRunningPluginName());  
   
   opterr = 0;  
   optind = 0;  
   
   /* parse options */  
   while(1){  
     c = getopt_long_only(argc, argv, "", long_options, &option_index);  
     if(c == -1){  
       break;  
     }  
     switch(c){  
       case 'f':  
         if((_gridmapfile = strdup(optarg)) == NULL){  
           EEF_log(LOG_ERR, "%s: %s", EEF_getRunningPluginName(), strerror(errno));  
         }  
         break;  
       case 'd':  
         if((_gridmapdir = strdup(optarg)) == NULL){  
           EEF_log(LOG_ERR, "%s: %s", EEF_getRunningPluginName(), strerror(errno));  
         }  
         break;  
       case 'm':  
         if((_mapping_attribute = strdup(optarg)) == NULL){  
           EEF_log(LOG_ERR, "%s: %s", EEF_getRunningPluginName(), strerror(errno));  
         }  
         break;  
       case 'o':  
         if((_obligation_name = strdup(optarg)) == NULL){  
           EEF_log(LOG_ERR, "%s: %s", EEF_getRunningPluginName(), strerror(errno));  
         }  
         break;  
       case 'u':  
         if((_attribute_user = strdup(optarg)) == NULL){  
           EEF_log(LOG_ERR, "%s: %s", EEF_getRunningPluginName(), strerror(errno));  
         }  
         break;  
       case 'g':  
         if((_attribute_group = strdup(optarg)) == NULL){  
           EEF_log(LOG_ERR, "%s: %s", EEF_getRunningPluginName(), strerror(errno));  
         }  
         break;  
       case 'n':  
         _use_usernames = 1;  
         break;  
       case 'p':  
         _use_pool = 1;  
         break;  
       case '?':  
         EEF_log(LOG_ERR, "%s: unkown option %s", EEF_getRunningPluginName(), optarg);  
         break;  
       case ':':  
         EEF_log(LOG_ERR, "%s: missing argument for %s", EEF_getRunningPluginName(), optarg);  
         break;  
     }  
   }  
   
   if(_gridmapfile){  
     /* check if path to gridmapfile exists */  
     if(stat(_gridmapfile, &_gridmapfile_stat) != 0){  
       EEF_log(LOG_ERR, "Unable to stat gridmapfile (%s): %s\n", _gridmapfile, strerror(errno));  
       return EES_PL_FAILURE;  
     }  
   }  
   
   if(_gridmapdir){  
     /* check if path to gridmapdir exists */  
     if(stat(_gridmapdir, &_gridmapdir_stat) != 0){  
       EEF_log(LOG_ERR, "Unable to stat gridmapdir (%s): %s\n", _gridmapdir, strerror(errno));  
       return EES_PL_FAILURE;  
     }  
   }  
   
   _retval = parse_gridmapfile(_gridmapfile, &_mappings);  
   
   /* look up DN in gridmapfile */  
   if(_retval == 0){  
     set_var_as_void_p("gridmappings", &_mappings, sizeof(void*));  
   } else {  
     switch(_retval){  
       case -1:  
         EEF_log(LOG_ERR, "%s: Unable to parse gridmapfile: %s - I/O error (file may have changed during access)\n", EEF_getRunningPluginName(), _gridmapfile);  
         break;  
       case -2:  
         EEF_log(LOG_ERR, "%s: Unable to parse gridmapfile: %s - privilege-drop error\n", EEF_getRunningPluginName(), _gridmapfile);  
         break;  
       case -3:  
         EEF_log(LOG_ERR, "%s: Unable to parse gridmapfile: %s - permission error (untrusted path)\n", EEF_getRunningPluginName(), _gridmapfile);  
         break;  
       case -4:  
         EEF_log(LOG_ERR, "%s: Unable to parse gridmapfile: %s - memory error \n", EEF_getRunningPluginName(), _gridmapfile);  
         break;  
       case -5:  
         EEF_log(LOG_ERR, "%s: Unable to parse gridmapfile: %s - unknown or safefile error \n", EEF_getRunningPluginName(), _gridmapfile);  
         break;  
       default:  
         EEF_log(LOG_ERR, "%s: Unable to parse gridmapfile: %s - mysterious unknown error \n", EEF_getRunningPluginName(), _gridmapfile);  
         break;  
     }  
     return EES_PL_FAILURE;  
   }  
   
   /* save state to AOS */  
   set_var_as_string("user_attribute",  _attribute_user);  
   set_var_as_string("group_attribute", _attribute_group);  
   set_var_as_string("obligation_name", _obligation_name);  
   set_var_as_string("gridmapfile",     _gridmapfile);  
   set_var_as_string("gridmapdir",      _gridmapdir);  
   set_var_as_string("mappingattr",     _mapping_attribute);  
   set_var_as_int("use_pool",           _use_pool);  
   set_var_as_int("use_usernames",      _use_usernames);  
   aos_dump_argslist();  
23    
24    return EES_PL_SUCCESS;      return EES_PL_SUCCESS;
25  }  }
26    
 EES_PL_RC plugin_run(){  
   aos_context_t    *_context            = NULL;  
   aos_attribute_t  *_tmp_attr           = NULL;  
27    
28    aos_attribute_t  *_uid_attr           = NULL;  EES_PL_RC plugin_terminate(){
29    aos_attribute_t  *_gid_attr           = NULL;      return EES_PL_SUCCESS;
30    }
31    
   char             *_dn                 = NULL;  
32    
33    char             *_uid_str            = NULL;  EES_PL_RC plugin_run(){
34    char             *_gid_str            = NULL;      aos_context_t    *_context            = NULL;
35        aos_attribute_t  *_tmp_attr           = NULL;
36    char             *_user_name          = NULL;      aos_context_t    *_context_oblig      = NULL;
37    char             *_attribute_user     = NULL;      aos_attribute_t  *_tmp_attr_oblig     = NULL;
38    char             *_attribute_group    = NULL;  
39    char             *_obligation_name    = NULL;      char             *_tmp_attr_id        = NULL;
40        int               i                   = 0;
41    char             *_gridmapdir         = NULL;  
42        /* TODO: needs to change */
43    char             *_mapping_attribute  = NULL;      char ** list_of_obligations =  NULL;
44    int               _use_usernames      = 0;      int     list_of_obligations_cnt = 0;
45    int               _use_pool           = 0;      list_of_obligations = malloc (sizeof (char *) * 42);
46    char             *_cmp_attr_id        = NULL;  
47    struct passwd     _tmp_pwd_s;  
48        EEF_log(LOG_INFO, "Running %s\n", EEF_getRunningPluginName());
49    EEF_log(LOG_INFO, "Running %s\n", EEF_getRunningPluginName());  
50        /* Debug */
51    /* populate fields */      aos_dump_argslist();
52    _attribute_user    = get_var_as_string("user_attribute");  
53    _attribute_group   = get_var_as_string("group_attribute");      /* Search for a special Environment attributeId that lists the Obligation Id's to search for and transform */
54    _obligation_name   = get_var_as_string("obligation_name");      rewindContexts(NULL);
55    _mapping_attribute = get_var_as_string("mappingattr");      while((_context = getNextContext(ENVIRONMENT, NULL))){
56            rewindAttributes(_context);
57    _use_usernames     = get_var_as_int("use_usernames");          while((_tmp_attr = getNextAttribute(_context))){
58    _use_pool          = get_var_as_int("use_pool");              _tmp_attr_id = getAttributeId(_tmp_attr);
59                if(_tmp_attr_id){
60    /* fetch DN (subject-x509-id) */                  if(strncmp(_tmp_attr_id, SPECIAL_EES_OBLIGATION_LIST_ATTR_ID, strlen(SPECIAL_EES_OBLIGATION_LIST_ATTR_ID)) == 1){
61    rewindContexts(NULL);                      /* Get Obligation Name to fetch */
62    while((_context = getNextContext(SUBJECT, NULL))){                      list_of_obligations[list_of_obligations_cnt] = getAttributeValueAsString (_tmp_attr);
63      rewindAttributes(_context);                      list_of_obligations_cnt++;
64      while((_tmp_attr = getNextAttribute(_context))){  
65        _cmp_attr_id = getAttributeId(_tmp_attr);                      /* TODO: remove limitation */
66        if(_cmp_attr_id && _mapping_attribute){                      if(list_of_obligations_cnt == 42){
67          if(strcmp(_cmp_attr_id, _mapping_attribute) == 0){                          EEF_log(LOG_INFO, "Too many obligations to transform, sorry, going to fail. (hardcoded max is 42\n");
68            _dn = getAttributeValueAsString(_tmp_attr);                          return EES_PL_FAILURE;
69          }                      }
70        }                  }
71      }              }
72    }          }
   
   aos_dump_argslist();  
   
   /* check if a DN was found */  
   if(_dn == NULL){  
     EEF_log(LOG_ERR, "%s: No DN found!\n", EEF_getRunningPluginName());  
     return EES_PL_FAILURE;  
   } else {  
     _user_name = dn_to_username(_dn);  
   }  
   
   if(_user_name == NULL){  
     EEF_log(LOG_ERR, "%s: Unable to find local mapping for DN \"%s\"\n", EEF_getRunningPluginName(), _dn);  
     return EES_PL_FAILURE;  
   } else {  
     EEF_log(LOG_ERR, "%s: Found mapping for DN \"%s\": account \"%s\"\n", EEF_getRunningPluginName(), _dn, _user_name);  
   }  
   
   /* TODO add secondary GIDs */  
   
   if(_use_usernames){  
     /* username as string */  
     _uid_str = _user_name;  
   } else {  
     /* username as uid */  
     asprintf(&_uid_str, "%llu", (long long unsigned int) uid_from_user_name(_user_name));  
   }  
   
   EEF_log(LOG_INFO, "Adding obligations for uid %s and gid %s\n", _uid_str, _gid_str);  
   
   /* add obligation for new uid-gid */  
   
   if((_context = createContext(OBLIGATION)) != NULL){  
     setContextObligationId(_context, _obligation_name);  
     if((_uid_attr = createAttribute())){  
       setAttributeId(   _uid_attr, _attribute_user);  
       setAttributeValue(_uid_attr, _uid_str, strlen(_uid_str)+1);  
       addAttribute(_context, _uid_attr);  
       free(_uid_str);  
     }  
   
     if(_gid_str){  
       if((_gid_attr = createAttribute())){  
         setAttributeId(   _gid_attr, _attribute_group);  
         setAttributeValue(_gid_attr, _gid_str, strlen(_gid_str)+1);  
         addAttribute(_context, _gid_attr);  
       }  
       free(_gid_str);  
73      }      }
74    
     addContext(_context);  
     return EES_PL_SUCCESS;  
   }  
75    
76    return EES_PL_FAILURE;      /* Search the Environment attributes for attributes to transform to Obligations, when found, register the obligations. */
77        for (i = 0; i < list_of_obligations_cnt; i++){
78            rewindContexts(NULL);
79            while((_context = getNextContext(ENVIRONMENT, NULL))){
80                rewindAttributes(_context);
81                while((_tmp_attr = getNextAttribute(_context))){
82                    _tmp_attr_id = getAttributeId(_tmp_attr);
83                    if(_tmp_attr_id){
84                        if(strncmp(_tmp_attr_id, list_of_obligations[i], strlen(list_of_obligations[i])) == 0){
85                            /* TODO: Each attribute will have its own obligation context, this must be optimized */
86                            if((_context_oblig = createContext(OBLIGATION)) != NULL){
87                                setContextObligationId(_context_oblig, list_of_obligations[i]);
88                                if((_tmp_attr_oblig = createAttribute())){
89                                    /* TODO: Strip first part */
90                                    setAttributeId(_tmp_attr_oblig, getAttributeId(_tmp_attr));
91                                    setAttributeIssuer(_tmp_attr_oblig, getAttributeIssuer(_tmp_attr));
92                                    setAttributeType(_tmp_attr_oblig, getAttributeType(_tmp_attr));
93                                    setAttributeValue(_tmp_attr_oblig, getAttributeValueAsVoidPointer(_tmp_attr), 0);
94                                    addAttribute(_context, _tmp_attr_oblig);
95                                }
96                                addContext(_context);
97                            }
98                        }
99                    }
100                }
101            }
102        }
103        return EES_PL_SUCCESS;
104  }  }
105    
 char* dn_to_username(char* _dn){  
   char *_gridmapfile        = get_var_as_string("gridmapfile");  
   char *_gridmapdir         = get_var_as_string("gridmapdir");  
   int   _use_pool           = get_var_as_int("use_pool");  
   char *_single_user_name   = NULL;  
   char* _pool_user_name     = NULL;  
   gridmap_list_t  *_mappings       = NULL;  
   
   _mappings = get_var_as_void_p("gridmappings");  
   _gridmapfile = get_var_as_string("gridmapfile");  
   EEF_log(LOG_DEBUG, "Get gridmappings into AOS at %p\n", _mappings);  
   _single_user_name = find_in_mappings(_dn, _mappings);  
   
   if(_use_pool && _single_user_name){  
     /* get pool account from gridmapdir */  
     EEF_log(LOG_DEBUG, "Using gridmapdir. Looking for account in pool %s\n", _single_user_name);  
     if (gridmapdir_userid(_gridmapdir, _dn, _single_user_name, &_pool_user_name, OVERRIDE_INCONSISTANCY) == 0){  
       /* find_in_mapping */  
       free(_single_user_name);  
       _single_user_name = NULL;  
       return _pool_user_name;  
     }  
       
   } else {  
     EEF_log(LOG_DEBUG, "Unable to find local username in gridmapfile %s\n", _gridmapfile);  
     return _single_user_name;  
   }  
106    
   return NULL;  
107    
108  }  EES_PL_RC set_var_as_string(const char* name, char* value){
109        aos_context_t*   context;
110        aos_attribute_t* attribute;
111        char*            attribute_name;
112    
113        if(value == NULL){
114            /*EEF_log(LOG_ERR, "Value cannot be NULL\n");*/
115            return EES_PL_FAILURE;
116        }
117    
118        rewindContexts(NULL);
119        if((context = getNextContext(NONE, NULL)) == NULL){
120            if ((context = createContext (NONE)) != NULL){
121                addContext (context);
122            } else {
123                EEF_log(LOG_ERR, "Unable to get context\n");
124                return EES_PL_FAILURE;
125            }
126        }
127    
128  char* find_in_mappings(const char* _dn, gridmap_list_t *_mappings){      /* store attribute names in AOS for lookup during run */
129    gridmap_line_t   *_mapping_line  = find_mapping(_mappings, _dn, MATCH_WILD_CHARS);      if((attribute = createAttribute())){
130    gridmap_list_t   *_tmp_mapping   = NULL;          if(asprintf(&attribute_name, "%s_%s", name, EEF_getRunningPluginName())){
131    char             *_found_mapping = NULL;              setAttributeId(   attribute, attribute_name);
132    if(_mapping_line){              free(attribute_name);
     _tmp_mapping = _mappings;  
     while(_tmp_mapping){  
       if(_tmp_mapping->line != NULL){  
         if(_tmp_mapping->line->mappings != NULL){  
           _found_mapping = strdup(_tmp_mapping->line->mappings->value);  
133          }          }
134        }          setAttributeValue(attribute, (void*) value, strlen(value)+1);
135        _tmp_mapping= _tmp_mapping->next;          addAttribute(context, attribute);
136      }      }
   }  
137    
138    return _found_mapping;      return EES_PL_SUCCESS;
139  }  }
140    
141    
142  EES_PL_RC plugin_terminate(){  EES_PL_RC set_var_as_void_p(const char* name, void* value, size_t size){
143    gridmap_list_t *_mappings;      aos_context_t*   context;
144    _mappings = get_var_as_void_p("gridmappings");      aos_attribute_t* attribute;
145    gridmap_list_free(_mappings);      char*            attribute_name;
146    return EES_PL_SUCCESS;    
147  }      /* store attribute names in AOS for lookup during run */
148    
149        rewindContexts(NULL);
150        while((context = getNextContext(NONE, NULL))){
151            if(context){
152                break;
153            }
154        }  
155        if(context == NULL){
156            context = createContext (NONE);
157            addContext (context);
158        }
159    
160  EES_PL_RC set_var_as_string(const char* name, char* value){      if(context == NULL){
161    aos_context_t*   context;          EEF_log(LOG_ERR, "Unable to get context\n");
162    aos_attribute_t* attribute;          return EES_PL_FAILURE;
163    char*            attribute_name;      }
   
   if(value == NULL){  
     /*EEF_log(LOG_ERR, "Value cannot be NULL\n");*/  
     return EES_PL_FAILURE;  
   }  
   
   rewindContexts(NULL);  
   if((context = getNextContext(NONE, NULL)) == NULL){  
     if ((context = createContext (NONE)) != NULL){  
       addContext (context);  
     } else {  
       EEF_log(LOG_ERR, "Unable to get context\n");  
       return EES_PL_FAILURE;  
     }  
   }  
   
   /* store attribute names in AOS for lookup during run */  
   if((attribute = createAttribute())){  
     if(asprintf(&attribute_name, "%s_%s", name, EEF_getRunningPluginName())){  
       setAttributeId(   attribute, attribute_name);  
       free(attribute_name);  
     }  
     setAttributeValue(attribute, (void*) value, strlen(value)+1);  
     addAttribute(context, attribute);  
   }  
164    
165    return EES_PL_SUCCESS;      if((attribute = createAttribute())){
166            if(asprintf(&attribute_name, "%s_%s", name, EEF_getRunningPluginName())){
167                setAttributeId(   attribute, attribute_name);
168                free(attribute_name);
169            }
170            setAttributeValue(attribute, value, size);
171            addAttribute(context, attribute);
172        }
173        return EES_PL_SUCCESS;
174  }  }
175    
176    EES_PL_RC set_var_as_int(const char* name, int value){
177        aos_context_t*   context;
178        aos_attribute_t* attribute;
179        char*            attribute_name;
180    
181        /* store attribute names in AOS for lookup during run */
182    
183        rewindContexts(NULL);
184        while((context = getNextContext(NONE, NULL))){
185            if(context){
186                break;
187            }
188        }  
189        if(context == NULL){
190            context = createContext (NONE);
191            addContext (context);
192        }
193    
194  EES_PL_RC set_var_as_void_p(const char* name, void* value, size_t size){      if(context == NULL){
195    aos_context_t*   context;          EEF_log(LOG_ERR, "Unable to get context\n");
196    aos_attribute_t* attribute;          return EES_PL_FAILURE;
197    char*            attribute_name;      }
   
   /* store attribute names in AOS for lookup during run */  
   
   rewindContexts(NULL);  
   while((context = getNextContext(NONE, NULL))){  
     if(context){  
       break;  
     }  
   }    
   if(context == NULL){  
     context = createContext (NONE);  
     addContext (context);  
   }  
   
   if(context == NULL){  
     EEF_log(LOG_ERR, "Unable to get context\n");  
     return EES_PL_FAILURE;  
   }  
   
   if((attribute = createAttribute())){  
     if(asprintf(&attribute_name, "%s_%s", name, EEF_getRunningPluginName())){  
       setAttributeId(   attribute, attribute_name);  
       free(attribute_name);  
     }  
     setAttributeValue(attribute, value, size);  
     addAttribute(context, attribute);  
   }  
   return EES_PL_SUCCESS;  
 }  
198    
199  EES_PL_RC set_var_as_int(const char* name, int value){      if((attribute = createAttribute())){
200    aos_context_t*   context;          if(asprintf(&attribute_name, "%s_%s", name, EEF_getRunningPluginName())){
201    aos_attribute_t* attribute;              setAttributeId(   attribute, attribute_name);
202    char*            attribute_name;              free(attribute_name);
203            }
204    /* store attribute names in AOS for lookup during run */          setAttributeValue(attribute, &value, sizeof(int));
205            addAttribute(context, attribute);
206    rewindContexts(NULL);      }
207    while((context = getNextContext(NONE, NULL))){      return EES_PL_SUCCESS;
     if(context){  
       break;  
     }  
   }    
   if(context == NULL){  
     context = createContext (NONE);  
     addContext (context);  
   }  
   
   if(context == NULL){  
     EEF_log(LOG_ERR, "Unable to get context\n");  
     return EES_PL_FAILURE;  
   }  
   
   if((attribute = createAttribute())){  
     if(asprintf(&attribute_name, "%s_%s", name, EEF_getRunningPluginName())){  
       setAttributeId(   attribute, attribute_name);  
       free(attribute_name);  
     }  
     setAttributeValue(attribute, &value, sizeof(int));  
     addAttribute(context, attribute);  
   }  
   return EES_PL_SUCCESS;  
208  }  }
209    
210  char* get_var_as_string(char* name){  char* get_var_as_string(char* name){
211    char* localname;      char* localname;
212    aos_context_t  * context;      aos_context_t  * context;
213    aos_attribute_t* attribute;      aos_attribute_t* attribute;
214    
215    asprintf(&localname, "%s_%s", name, EEF_getRunningPluginName());      asprintf(&localname, "%s_%s", name, EEF_getRunningPluginName());
216    
217    rewindContexts(NULL);      rewindContexts(NULL);
218    while((context = getNextContext(NONE, NULL))){      while((context = getNextContext(NONE, NULL))){
219      rewindAttributes(context);          rewindAttributes(context);
220      while((attribute = getNextAttribute(context))){          while((attribute = getNextAttribute(context))){
221        if(strcmp(getAttributeId(attribute), localname) == 0){              if(strcmp(getAttributeId(attribute), localname) == 0){
222          free(localname);                  free(localname);
223          return getAttributeValueAsString(attribute);                  return getAttributeValueAsString(attribute);
224        }              }
225      }          }
226    }      }
227    free(localname);      free(localname);
228    return NULL;      return NULL;
229  }  }
230    
231  int get_var_as_int(char* name){  int get_var_as_int(char* name){
232    char* localname;      char* localname;
233    aos_context_t  * context;      aos_context_t  * context;
234    aos_attribute_t* attribute;      aos_attribute_t* attribute;
235    
236    /* Free this */      /* Free this */
237    asprintf(&localname, "%s_%s", name, EEF_getRunningPluginName());      asprintf(&localname, "%s_%s", name, EEF_getRunningPluginName());
238    
239    rewindContexts(NULL);      rewindContexts(NULL);
240    while((context = getNextContext(NONE, NULL))){      while((context = getNextContext(NONE, NULL))){
241      rewindAttributes(context);          rewindAttributes(context);
242      while((attribute = getNextAttribute(context))){          while((attribute = getNextAttribute(context))){
243        if(strcmp(getAttributeId(attribute), localname) == 0){              if(strcmp(getAttributeId(attribute), localname) == 0){
244          free(localname);                  free(localname);
245          return getAttributeValueAsInt(attribute);                  return getAttributeValueAsInt(attribute);
246        }              }
247      }          }
248    }      }
249    free(localname);      free(localname);
250    return -1;      return -1;
251  }  }
252    
253  void* get_var_as_void_p(char* name){  void* get_var_as_void_p(char* name){
254    char* localname;      char* localname;
255    aos_context_t  * context;      aos_context_t  * context;
256    aos_attribute_t* attribute;      aos_attribute_t* attribute;
257    
258    /* Free this */      /* Free this */
259    asprintf(&localname, "%s_%s", name, EEF_getRunningPluginName());      asprintf(&localname, "%s_%s", name, EEF_getRunningPluginName());
260    
261    rewindContexts(NULL);      rewindContexts(NULL);
262    while((context = getNextContext(NONE, NULL))){      while((context = getNextContext(NONE, NULL))){
263      rewindAttributes(context);          rewindAttributes(context);
264      while((attribute = getNextAttribute(context))){          while((attribute = getNextAttribute(context))){
265        if(strcmp(getAttributeId(attribute), localname) == 0){              if(strcmp(getAttributeId(attribute), localname) == 0){
266          free(localname);                  free(localname);
267          return *((void**) getAttributeValueAsVoidPointer(attribute));                  return *((void**) getAttributeValueAsVoidPointer(attribute));
268        }              }
269      }          }
270    }      }
271    free(localname);      free(localname);
272    return NULL;      return NULL;
273  }  }
274    

Legend:
Removed from v.2148  
changed lines
  Added in v.2149

grid.support@nikhef.nl
ViewVC Help
Powered by ViewVC 1.1.28