Main Page | Alphabetical List | Data Structures | Directories | File List | Data Fields | Globals | Search for 
tmp / linux-rsbac-1.2 / rsbac / data_structures

pm_data_structures.c File Reference

#include <linux/types.h>
#include <linux/sched.h>
#include <linux/fs.h>
#include <asm/uaccess.h>
#include <linux/file.h>
#include <linux/vmalloc.h>
#include <linux/init.h>
#include <rsbac/types.h>
#include <rsbac/pm_types.h>
#include <rsbac/pm_data_structures.h>
#include <rsbac/getname.h>
#include <rsbac/pm_getname.h>
#include <rsbac/error.h>
#include <rsbac/helpers.h>
#include <rsbac/fs.h>
#include <rsbac/adf.h>
#include <rsbac/adf_main.h>
#include <rsbac/debug.h>
#include <rsbac/proc_fs.h>
#include <rsbac/rkmem.h>
#include <rsbac/lists.h>
#include <linux/string.h>

Go to the source code of this file.

Functions

int sys_write (u_int, char *, u_int)
static void __init registration_error (int err, char *listname)
int __init rsbac_init_pm (void)
int rsbac_stats_pm (void)
int rsbac_pm_add_to_set (rsbac_list_ta_number_t ta_number, enum rsbac_pm_set_t set, union rsbac_pm_set_id_t id, union rsbac_pm_set_member_t member)
int rsbac_pm_remove_from_set (rsbac_list_ta_number_t ta_number, enum rsbac_pm_set_t set, union rsbac_pm_set_id_t id, union rsbac_pm_set_member_t member)
int rsbac_pm_clear_set (rsbac_list_ta_number_t ta_number, enum rsbac_pm_set_t set, union rsbac_pm_set_id_t id)
rsbac_boolean_t rsbac_pm_set_member (rsbac_list_ta_number_t ta_number, enum rsbac_pm_set_t set, union rsbac_pm_set_id_t id, union rsbac_pm_set_member_t member)
rsbac_boolean_t rsbac_pm_pp_subset (rsbac_pm_pp_set_id_t pp_set, rsbac_pm_in_pp_set_id_t in_pp_set)
rsbac_boolean_t rsbac_pm_pp_superset (rsbac_pm_pp_set_id_t pp_set, rsbac_pm_out_pp_set_id_t out_pp_set)
rsbac_boolean_t rsbac_pm_pp_only (rsbac_pm_purpose_id_t purpose, rsbac_pm_out_pp_set_id_t out_pp_set)
int rsbac_pm_pp_intersec (rsbac_pm_pp_set_id_t pp_set, rsbac_pm_in_pp_set_id_t in_pp_set)
int rsbac_pm_pp_union (rsbac_pm_pp_set_id_t pp_set, rsbac_pm_out_pp_set_id_t out_pp_set)
int rsbac_pm_create_set (rsbac_list_ta_number_t ta_number, enum rsbac_pm_set_t set, union rsbac_pm_set_id_t id)
rsbac_boolean_t rsbac_pm_set_exist (rsbac_list_ta_number_t ta_number, enum rsbac_pm_set_t set, union rsbac_pm_set_id_t id)
int rsbac_pm_remove_set (rsbac_list_ta_number_t ta_number, enum rsbac_pm_set_t set, union rsbac_pm_set_id_t id)
int rsbac_pm_get_data (rsbac_list_ta_number_t ta_number, enum rsbac_pm_target_t target, union rsbac_pm_target_id_t tid, enum rsbac_pm_data_t data, union rsbac_pm_data_value_t *value)
int rsbac_pm_get_all_data (rsbac_list_ta_number_t ta_number, enum rsbac_pm_target_t target, union rsbac_pm_target_id_t tid, union rsbac_pm_all_data_value_t *value)
rsbac_boolean_t rsbac_pm_exists (rsbac_list_ta_number_t ta_number, enum rsbac_pm_target_t target, union rsbac_pm_target_id_t tid)
int rsbac_pm_set_data (rsbac_list_ta_number_t ta_number, enum rsbac_pm_target_t target, union rsbac_pm_target_id_t tid, enum rsbac_pm_data_t data, union rsbac_pm_data_value_t value)
int rsbac_pm_add_target (rsbac_list_ta_number_t ta_number, enum rsbac_pm_target_t target, union rsbac_pm_all_data_value_t data)
int rsbac_pm_remove_target (rsbac_list_ta_number_t ta_number, enum rsbac_pm_target_t target, union rsbac_pm_target_id_t tid)

Variables

static rsbac_list_handle_t task_set_handle = NULL
static rsbac_list_handle_t tp_set_handle = NULL
static rsbac_list_handle_t ru_set_handle = NULL
static rsbac_list_handle_t pp_set_handle = NULL
static rsbac_list_handle_t in_pp_set_handle = NULL
static rsbac_list_handle_t out_pp_set_handle = NULL
static rsbac_list_handle_t task_handle = NULL
static rsbac_list_handle_t class_handle = NULL
static rsbac_list_handle_t na_handle = NULL
static rsbac_list_handle_t cs_handle = NULL
static rsbac_list_handle_t tp_handle = NULL
static rsbac_list_handle_t pp_handle = NULL
static rsbac_list_handle_t tkt_handle = NULL

Function Documentation

static void __init registration_error (  int  err,
char *  listname
)  [static]
 

Definition at line 1121 of file pm_data_structures.c.

References get_error_name(), rsbac_kfree(), rsbac_kmalloc(), RSBAC_MAXNAMELEN, and rsbac_printk().

01123   {
01124     if(err)
01125       {
01126         char * tmp = rsbac_kmalloc(RSBAC_MAXNAMELEN);
01127 
01128         if(tmp)
01129           {
01130             rsbac_printk(KERN_WARNING
01131                    "rsbac_init_pm(): Registering PM %s list failed with error %s\n",
01132                    listname,
01133                    get_error_name(tmp, err));
01134             rsbac_kfree(tmp);
01135           }
01136       }
01137   }

int __init rsbac_init_pm (  void   ) 
 

Definition at line 1150 of file pm_data_structures.c.

References class_handle, cs_handle, rsbac_list_lol_info_t::data_size, rsbac_list_info_t::data_size, rsbac_list_lol_info_t::desc_size, rsbac_list_info_t::desc_size, in_pp_set_handle, rsbac_list_lol_info_t::key, rsbac_list_info_t::key, rsbac_list_lol_info_t::max_age, rsbac_list_info_t::max_age, na_handle, NULL, out_pp_set_handle, PA_class, PA_cs, PA_in_pp_set, PA_na, PA_out_pp_set, PA_pp, PA_pp_set, PA_ru_set, PA_task, PA_task_set, PA_tkt, PA_tp, PA_tp_set, pp_handle, pp_set_handle, proc_rsbac_root_p, registration_error(), RSBAC_EREINIT, rsbac_is_initialized(), RSBAC_LIST_BACKUP, rsbac_list_compare_u32(), rsbac_list_lol_register(), RSBAC_LIST_PERSIST, rsbac_list_register(), RSBAC_LIST_VERSION, RSBAC_PM_CLASS_LIST_NAME, RSBAC_PM_CLASS_LIST_PROC_NAME, RSBAC_PM_CLASS_LIST_VERSION, RSBAC_PM_CS_LIST_NAME, RSBAC_PM_CS_LIST_PROC_NAME, RSBAC_PM_CS_LIST_VERSION, RSBAC_PM_IN_PP_SET_LIST_NAME, RSBAC_PM_IN_PP_SET_LIST_PROC_NAME, RSBAC_PM_LIST_KEY, RSBAC_PM_NA_LIST_NAME, RSBAC_PM_NA_LIST_PROC_NAME, RSBAC_PM_NA_LIST_VERSION, RSBAC_PM_NO_VERSION, RSBAC_PM_OUT_PP_SET_LIST_NAME, RSBAC_PM_OUT_PP_SET_LIST_PROC_NAME, RSBAC_PM_PP_LIST_NAME, RSBAC_PM_PP_LIST_PROC_NAME, RSBAC_PM_PP_LIST_VERSION, RSBAC_PM_PP_SET_LIST_NAME, RSBAC_PM_PP_SET_LIST_PROC_NAME, RSBAC_PM_PP_SET_LIST_VERSION, RSBAC_PM_PROC_DIR_NAME, RSBAC_PM_PROC_STATS_NAME, RSBAC_PM_RU_SET_LIST_NAME, RSBAC_PM_RU_SET_LIST_PROC_NAME, RSBAC_PM_RU_SET_LIST_VERSION, RSBAC_PM_TASK_LIST_NAME, RSBAC_PM_TASK_LIST_PROC_NAME, RSBAC_PM_TASK_LIST_VERSION, RSBAC_PM_TASK_SET_LIST_NAME, RSBAC_PM_TASK_SET_LIST_PROC_NAME, RSBAC_PM_TASK_SET_LIST_VERSION, RSBAC_PM_TKT_LIST_NAME, RSBAC_PM_TKT_LIST_PROC_NAME, RSBAC_PM_TKT_LIST_VERSION, RSBAC_PM_TP_LIST_NAME, RSBAC_PM_TP_LIST_PROC_NAME, RSBAC_PM_TP_LIST_VERSION, RSBAC_PM_TP_SET_LIST_NAME, RSBAC_PM_TP_SET_LIST_PROC_NAME, RSBAC_PM_TP_SET_LIST_VERSION, rsbac_printk(), ru_set_handle, rsbac_list_lol_info_t::subdata_size, rsbac_list_lol_info_t::subdesc_size, task_handle, task_set_handle, tkt_handle, tp_handle, tp_set_handle, rsbac_list_lol_info_t::version, and rsbac_list_info_t::version.

Referenced by rsbac_do_init().

01152   {
01153     int  err = 0;
01154     struct proc_dir_entry * tmp_entry_p;
01155     struct proc_dir_entry * pm_entry_p;
01156     struct rsbac_list_lol_info_t lol_info;
01157     struct rsbac_list_info_t     list_info;
01158 
01159     if (rsbac_is_initialized())
01160       {
01161         rsbac_printk(KERN_WARNING "rsbac_init_pm(): RSBAC already initialized\n");
01162         return(-RSBAC_EREINIT);
01163       }
01164 
01165     rsbac_printk(KERN_INFO "rsbac_init_pm(): Initializing RSBAC: PM subsystem\n");
01166 
01167 /* Helper lists */
01168     lol_info.version = RSBAC_PM_TASK_SET_LIST_VERSION;
01169     lol_info.key = RSBAC_PM_LIST_KEY;
01170     lol_info.desc_size = sizeof(rsbac_pm_task_set_id_t);
01171     lol_info.data_size = 0;
01172     lol_info.subdesc_size = sizeof(rsbac_pm_task_id_t);
01173     lol_info.subdata_size = 0;
01174     lol_info.max_age = 0;
01175     err = rsbac_list_lol_register(RSBAC_LIST_VERSION,
01176                                   &task_set_handle,
01177                                   &lol_info,
01178                                   RSBAC_LIST_PERSIST | RSBAC_LIST_BACKUP,
01179                                   rsbac_list_compare_u32,
01180                                   rsbac_list_compare_u32,
01181                                   NULL,
01182                                   NULL,
01183                                   NULL,
01184                                   NULL,
01185                                   RSBAC_PM_TASK_SET_LIST_NAME,
01186                                   RSBAC_AUTO_DEV);
01187     if(err)
01188       {
01189         registration_error(err, "task set");
01190         return err;
01191       }
01192 
01193     lol_info.version = RSBAC_PM_TP_SET_LIST_VERSION;
01194     lol_info.key = RSBAC_PM_LIST_KEY;
01195     lol_info.desc_size = sizeof(rsbac_pm_tp_set_id_t);
01196     lol_info.data_size = 0;
01197     lol_info.subdesc_size = sizeof(rsbac_pm_tp_id_t);
01198     lol_info.subdata_size = 0;
01199     lol_info.max_age = 0;
01200     err = rsbac_list_lol_register(RSBAC_LIST_VERSION,
01201                                   &tp_set_handle,
01202                                   &lol_info,
01203                                   RSBAC_LIST_PERSIST | RSBAC_LIST_BACKUP,
01204                                   rsbac_list_compare_u32,
01205                                   rsbac_list_compare_u32,
01206                                   NULL,
01207                                   NULL,
01208                                   NULL,
01209                                   NULL,
01210                                   RSBAC_PM_TP_SET_LIST_NAME,
01211                                   RSBAC_AUTO_DEV);
01212     if(err)
01213       {
01214         registration_error(err, "tp set");
01215         return err;
01216       }
01217 
01218     lol_info.version = RSBAC_PM_RU_SET_LIST_VERSION;
01219     lol_info.key = RSBAC_PM_LIST_KEY;
01220     lol_info.desc_size = sizeof(rsbac_pm_ru_set_id_t);
01221     lol_info.data_size = 0;
01222     lol_info.subdesc_size = sizeof(rsbac_uid_t);
01223     lol_info.subdata_size = 0;
01224     lol_info.max_age = 0;
01225     err = rsbac_list_lol_register(RSBAC_LIST_VERSION,
01226                                   &ru_set_handle,
01227                                   &lol_info,
01228                                   RSBAC_LIST_PERSIST | RSBAC_LIST_BACKUP,
01229                                   rsbac_list_compare_u32,
01230                                   rsbac_list_compare_u32,
01231                                   NULL,
01232                                   NULL,
01233                                   NULL,
01234                                   NULL,
01235                                   RSBAC_PM_RU_SET_LIST_NAME,
01236                                   RSBAC_AUTO_DEV);
01237     if(err)
01238       {
01239         registration_error(err, "ru set");
01240         return err;
01241       }
01242 
01243     lol_info.version = RSBAC_PM_PP_SET_LIST_VERSION;
01244     lol_info.key = RSBAC_PM_LIST_KEY;
01245     lol_info.desc_size = sizeof(rsbac_pm_pp_set_id_t);
01246     lol_info.data_size = 0;
01247     lol_info.subdesc_size = sizeof(rsbac_pm_purpose_id_t);
01248     lol_info.subdata_size = 0;
01249     lol_info.max_age = 0;
01250     err = rsbac_list_lol_register(RSBAC_LIST_VERSION,
01251                                   &pp_set_handle,
01252                                   &lol_info,
01253                                   RSBAC_LIST_PERSIST | RSBAC_LIST_BACKUP,
01254                                   rsbac_list_compare_u32,
01255                                   rsbac_list_compare_u32,
01256                                   NULL,
01257                                   NULL,
01258                                   NULL,
01259                                   NULL,
01260                                   RSBAC_PM_PP_SET_LIST_NAME,
01261                                   RSBAC_AUTO_DEV);
01262     if(err)
01263       {
01264         registration_error(err, "pp set");
01265         return err;
01266       }
01267 
01268     lol_info.version = RSBAC_PM_NO_VERSION;
01269     lol_info.key = RSBAC_PM_LIST_KEY;
01270     lol_info.desc_size = sizeof(rsbac_pm_in_pp_set_id_t);
01271     lol_info.data_size = 0;
01272     lol_info.subdesc_size = sizeof(rsbac_pm_purpose_id_t);
01273     lol_info.subdata_size = 0;
01274     lol_info.max_age = 0;
01275     err = rsbac_list_lol_register(RSBAC_LIST_VERSION,
01276                                   &in_pp_set_handle,
01277                                   &lol_info,
01278                                   0,
01279                                   rsbac_list_compare_u32,
01280                                   rsbac_list_compare_u32,
01281                                   NULL,
01282                                   NULL,
01283                                   NULL,
01284                                   NULL,
01285                                   RSBAC_PM_IN_PP_SET_LIST_NAME,
01286                                   RSBAC_AUTO_DEV);
01287     if(err)
01288       {
01289         registration_error(err, "in_pp set");
01290         return err;
01291       }
01292 
01293     lol_info.version = RSBAC_PM_NO_VERSION;
01294     lol_info.key = RSBAC_PM_LIST_KEY;
01295     lol_info.desc_size = sizeof(rsbac_pm_out_pp_set_id_t);
01296     lol_info.data_size = 0;
01297     lol_info.subdesc_size = sizeof(rsbac_pm_purpose_id_t);
01298     lol_info.subdata_size = 0;
01299     lol_info.max_age = 0;
01300     err = rsbac_list_lol_register(RSBAC_LIST_VERSION,
01301                                   &out_pp_set_handle,
01302                                   &lol_info,
01303                                   0,
01304                                   rsbac_list_compare_u32,
01305                                   rsbac_list_compare_u32,
01306                                   NULL,
01307                                   NULL,
01308                                   NULL,
01309                                   NULL,
01310                                   RSBAC_PM_OUT_PP_SET_LIST_NAME,
01311                                   RSBAC_AUTO_DEV);
01312     if(err)
01313       {
01314         registration_error(err, "out_pp set");
01315         return err;
01316       }
01317 
01318 /* Main lists */
01319     list_info.version = RSBAC_PM_TASK_LIST_VERSION;
01320     list_info.key = RSBAC_PM_LIST_KEY;
01321     list_info.desc_size = sizeof(rsbac_pm_task_id_t);
01322     list_info.data_size = sizeof(struct rsbac_pm_task_data_t);
01323     list_info.max_age = 0;
01324     err = rsbac_list_register(RSBAC_LIST_VERSION,
01325                               &task_handle,
01326                               &list_info,
01327                               RSBAC_LIST_PERSIST | RSBAC_LIST_BACKUP,
01328                               rsbac_list_compare_u32,
01329                               NULL,
01330                               NULL,
01331                               RSBAC_PM_TASK_LIST_NAME,
01332                               RSBAC_AUTO_DEV);
01333     if(err)
01334       {
01335         registration_error(err, "task");
01336         return err;
01337       }
01338 
01339     list_info.version = RSBAC_PM_CLASS_LIST_VERSION;
01340     list_info.key = RSBAC_PM_LIST_KEY;
01341     list_info.desc_size = sizeof(rsbac_pm_object_class_id_t);
01342     list_info.data_size = sizeof(struct rsbac_pm_class_data_t);
01343     list_info.max_age = 0;
01344     err = rsbac_list_register(RSBAC_LIST_VERSION,
01345                               &class_handle,
01346                               &list_info,
01347                               RSBAC_LIST_PERSIST | RSBAC_LIST_BACKUP,
01348                               rsbac_list_compare_u32,
01349                               NULL,
01350                               NULL,
01351                               RSBAC_PM_CLASS_LIST_NAME,
01352                               RSBAC_AUTO_DEV);
01353     if(err)
01354       {
01355         registration_error(err, "class");
01356         return err;
01357       }
01358 
01359     list_info.version = RSBAC_PM_NA_LIST_VERSION;
01360     list_info.key = RSBAC_PM_LIST_KEY;
01361     list_info.desc_size = sizeof(struct rsbac_pm_na_id_t);
01362     list_info.data_size = sizeof(struct rsbac_pm_na_data_t);
01363     list_info.max_age = 0;
01364     err = rsbac_list_register(RSBAC_LIST_VERSION,
01365                               &na_handle,
01366                               &list_info,
01367                               RSBAC_LIST_PERSIST | RSBAC_LIST_BACKUP,
01368                               rsbac_list_compare_u32,
01369                               NULL,
01370                               NULL,
01371                               RSBAC_PM_NA_LIST_NAME,
01372                               RSBAC_AUTO_DEV);
01373     if(err)
01374       {
01375         registration_error(err, "na");
01376         return err;
01377       }
01378 
01379     list_info.version = RSBAC_PM_CS_LIST_VERSION;
01380     list_info.key = RSBAC_PM_LIST_KEY;
01381     list_info.desc_size = sizeof(struct rsbac_pm_cs_id_t);
01382     list_info.data_size = sizeof(struct rsbac_pm_cs_data_t);
01383     list_info.max_age = 0;
01384     err = rsbac_list_register(RSBAC_LIST_VERSION,
01385                               &cs_handle,
01386                               &list_info,
01387                               RSBAC_LIST_PERSIST | RSBAC_LIST_BACKUP,
01388                               rsbac_list_compare_u32,
01389                               NULL,
01390                               NULL,
01391                               RSBAC_PM_CS_LIST_NAME,
01392                               RSBAC_AUTO_DEV);
01393     if(err)
01394       {
01395         registration_error(err, "cs");
01396         return err;
01397       }
01398 
01399     list_info.version = RSBAC_PM_TP_LIST_VERSION;
01400     list_info.key = RSBAC_PM_LIST_KEY;
01401     list_info.desc_size = sizeof(rsbac_pm_tp_id_t);
01402     list_info.data_size = sizeof(struct rsbac_pm_tp_data_t);
01403     list_info.max_age = 0;
01404     err = rsbac_list_register(RSBAC_LIST_VERSION,
01405                               &tp_handle,
01406                               &list_info,
01407                               RSBAC_LIST_PERSIST | RSBAC_LIST_BACKUP,
01408                               rsbac_list_compare_u32,
01409                               NULL,
01410                               NULL,
01411                               RSBAC_PM_TP_LIST_NAME,
01412                               RSBAC_AUTO_DEV);
01413     if(err)
01414       {
01415         registration_error(err, "tp");
01416         return err;
01417       }
01418 
01419     list_info.version = RSBAC_PM_PP_LIST_VERSION;
01420     list_info.key = RSBAC_PM_LIST_KEY;
01421     list_info.desc_size = sizeof(rsbac_pm_purpose_id_t);
01422     list_info.data_size = sizeof(struct rsbac_pm_pp_data_t);
01423     list_info.max_age = 0;
01424     err = rsbac_list_register(RSBAC_LIST_VERSION,
01425                               &pp_handle,
01426                               &list_info,
01427                               RSBAC_LIST_PERSIST | RSBAC_LIST_BACKUP,
01428                               rsbac_list_compare_u32,
01429                               NULL,
01430                               NULL,
01431                               RSBAC_PM_PP_LIST_NAME,
01432                               RSBAC_AUTO_DEV);
01433     if(err)
01434       {
01435         registration_error(err, "pp");
01436         return err;
01437       }
01438 
01439     list_info.version = RSBAC_PM_TKT_LIST_VERSION;
01440     list_info.key = RSBAC_PM_LIST_KEY;
01441     list_info.desc_size = sizeof(rsbac_pm_tkt_id_t);
01442     list_info.data_size = sizeof(struct rsbac_pm_tkt_data_t);
01443     list_info.max_age = 0;
01444     err = rsbac_list_register(RSBAC_LIST_VERSION,
01445                               &tkt_handle,
01446                               &list_info,
01447                               RSBAC_LIST_PERSIST | RSBAC_LIST_BACKUP,
01448                               rsbac_list_compare_u32,
01449                               NULL,
01450                               NULL,
01451                               RSBAC_PM_TKT_LIST_NAME,
01452                               RSBAC_AUTO_DEV);
01453     if(err)
01454       {
01455         registration_error(err, "tkt");
01456         return err;
01457       }
01458 
01459     #if defined(CONFIG_RSBAC_PROC) && defined(CONFIG_PROC_FS)
01460     tmp_entry_p = create_proc_entry(RSBAC_PM_PROC_STATS_NAME,
01461                                     S_IFREG | S_IRUGO,
01462                                     proc_rsbac_root_p);
01463     if(tmp_entry_p)
01464       {
01465         tmp_entry_p->get_info = stats_pm_proc_info;
01466       }
01467 
01468     pm_entry_p = create_proc_entry(RSBAC_PM_PROC_DIR_NAME,
01469                                    S_IFDIR | S_IRUGO | S_IXUGO,
01470                                    proc_rsbac_root_p);
01471     if(pm_entry_p)
01472       {
01473         tmp_entry_p = create_proc_entry(RSBAC_PM_TASK_SET_LIST_PROC_NAME,
01474                                         S_IFREG | S_IRUGO,
01475                                         pm_entry_p);
01476         if(tmp_entry_p)
01477           {
01478             tmp_entry_p->read_proc = pm_list_proc_read;
01479             tmp_entry_p->data = (void *) PA_task_set;
01480           }
01481         tmp_entry_p = create_proc_entry(RSBAC_PM_TP_SET_LIST_PROC_NAME,
01482                                         S_IFREG | S_IRUGO,
01483                                         pm_entry_p);
01484         if(tmp_entry_p)
01485           {
01486             tmp_entry_p->read_proc = pm_list_proc_read;
01487             tmp_entry_p->data = (void *) PA_tp_set;
01488           }
01489         tmp_entry_p = create_proc_entry(RSBAC_PM_RU_SET_LIST_PROC_NAME,
01490                                         S_IFREG | S_IRUGO,
01491                                         pm_entry_p);
01492         if(tmp_entry_p)
01493           {
01494             tmp_entry_p->read_proc = pm_list_proc_read;
01495             tmp_entry_p->data = (void *) PA_ru_set;
01496           }
01497         tmp_entry_p = create_proc_entry(RSBAC_PM_PP_SET_LIST_PROC_NAME,
01498                                         S_IFREG | S_IRUGO,
01499                                         pm_entry_p);
01500         if(tmp_entry_p)
01501           {
01502             tmp_entry_p->read_proc = pm_list_proc_read;
01503             tmp_entry_p->data = (void *) PA_pp_set;
01504           }
01505         tmp_entry_p = create_proc_entry(RSBAC_PM_IN_PP_SET_LIST_PROC_NAME,
01506                                         S_IFREG | S_IRUGO,
01507                                         pm_entry_p);
01508         if(tmp_entry_p)
01509           {
01510             tmp_entry_p->read_proc = pm_list_proc_read;
01511             tmp_entry_p->data = (void *) PA_in_pp_set;
01512           }
01513         tmp_entry_p = create_proc_entry(RSBAC_PM_OUT_PP_SET_LIST_PROC_NAME,
01514                                         S_IFREG | S_IRUGO,
01515                                         pm_entry_p);
01516         if(tmp_entry_p)
01517           {
01518             tmp_entry_p->read_proc = pm_list_proc_read;
01519             tmp_entry_p->data = (void *) PA_out_pp_set;
01520           }
01521 
01522         tmp_entry_p = create_proc_entry(RSBAC_PM_TASK_LIST_PROC_NAME,
01523                                         S_IFREG | S_IRUGO,
01524                                         pm_entry_p);
01525         if(tmp_entry_p)
01526           {
01527             tmp_entry_p->read_proc = pm_list_proc_read;
01528             tmp_entry_p->data = (void *) PA_task;
01529           }
01530         tmp_entry_p = create_proc_entry(RSBAC_PM_CLASS_LIST_PROC_NAME,
01531                                         S_IFREG | S_IRUGO,
01532                                         pm_entry_p);
01533         if(tmp_entry_p)
01534           {
01535             tmp_entry_p->read_proc = pm_list_proc_read;
01536             tmp_entry_p->data = (void *) PA_class;
01537           }
01538         tmp_entry_p = create_proc_entry(RSBAC_PM_NA_LIST_PROC_NAME,
01539                                         S_IFREG | S_IRUGO,
01540                                         pm_entry_p);
01541         if(tmp_entry_p)
01542           {
01543             tmp_entry_p->read_proc = pm_list_proc_read;
01544             tmp_entry_p->data = (void *) PA_na;
01545           }
01546         tmp_entry_p = create_proc_entry(RSBAC_PM_CS_LIST_PROC_NAME,
01547                                         S_IFREG | S_IRUGO,
01548                                         pm_entry_p);
01549         if(tmp_entry_p)
01550           {
01551             tmp_entry_p->read_proc = pm_list_proc_read;
01552             tmp_entry_p->data = (void *) PA_cs;
01553           }
01554         tmp_entry_p = create_proc_entry(RSBAC_PM_TP_LIST_PROC_NAME,
01555                                         S_IFREG | S_IRUGO,
01556                                         pm_entry_p);
01557         if(tmp_entry_p)
01558           {
01559             tmp_entry_p->read_proc = pm_list_proc_read;
01560             tmp_entry_p->data = (void *) PA_tp;
01561           }
01562         tmp_entry_p = create_proc_entry(RSBAC_PM_PP_LIST_PROC_NAME,
01563                                         S_IFREG | S_IRUGO,
01564                                         pm_entry_p);
01565         if(tmp_entry_p)
01566           {
01567             tmp_entry_p->read_proc = pm_list_proc_read;
01568             tmp_entry_p->data = (void *) PA_pp;
01569           }
01570         tmp_entry_p = create_proc_entry(RSBAC_PM_TKT_LIST_PROC_NAME,
01571                                         S_IFREG | S_IRUGO,
01572                                         pm_entry_p);
01573         if(tmp_entry_p)
01574           {
01575             tmp_entry_p->read_proc = pm_list_proc_read;
01576             tmp_entry_p->data = (void *) PA_tkt;
01577           }
01578       }
01579     #endif
01580 
01581 #ifdef CONFIG_RSBAC_DEBUG
01582     if (rsbac_debug_ds_pm)
01583       {
01584         rsbac_printk(KERN_DEBUG "rsbac_init_pm(): Ready.\n");
01585       }
01586 #endif
01587     return(err);
01588   };

int rsbac_pm_add_target (  rsbac_list_ta_number_t  ta_number,
enum rsbac_pm_target_t  target,
union rsbac_pm_all_data_value_t  data
) 
 

Definition at line 2769 of file pm_data_structures.c.

References class_handle, cs_handle, na_handle, pp_handle, RSBAC_EINVALIDTARGET, rsbac_ta_list_add_ttl(), task_handle, tkt_handle, and tp_handle.

Referenced by rsbac_pm().

02773     { 
02774       switch (target)
02775         {
02776           case PMT_TASK:
02777 /*
02778 #ifdef CONFIG_RSBAC_DEBUG
02779             if (rsbac_debug_ds_pm)
02780               rsbac_printk(KERN_DEBUG
02781                      "rsbac_pm_add_target(): Adding task item\n");
02782 #endif
02783 */
02784             return rsbac_ta_list_add_ttl(ta_number, task_handle, 0, &data.task.id, &data.task);
02785             
02786           case PMT_CLASS:
02787 /*
02788 #ifdef CONFIG_RSBAC_DEBUG
02789             if (rsbac_debug_ds_pm)
02790               rsbac_printk(KERN_DEBUG
02791                      "rsbac_pm_add_target(): Adding class item\n");
02792 #endif
02793 */
02794             return rsbac_ta_list_add_ttl(ta_number, class_handle, 0, &data.object_class.id, &data.object_class);
02795 
02796           case PMT_NA:
02797             {
02798               struct rsbac_pm_na_id_t na_id;
02799 
02800 /*
02801 #ifdef CONFIG_RSBAC_DEBUG
02802               if (rsbac_debug_ds_pm)
02803                 rsbac_printk(KERN_DEBUG
02804                        "rsbac_pm_add_target(): Adding na item\n");
02805 #endif
02806 */
02807               na_id.task = data.na.task;
02808               na_id.object_class = data.na.object_class;
02809               na_id.tp = data.na.tp;
02810               return rsbac_ta_list_add_ttl(ta_number, na_handle, 0, &na_id, &data.na);
02811             }
02812 
02813           case PMT_CS:
02814             {
02815               struct rsbac_pm_cs_id_t cs_id;
02816 
02817 /*
02818 #ifdef CONFIG_RSBAC_DEBUG
02819               if (rsbac_debug_ds_pm)
02820                 rsbac_printk(KERN_DEBUG
02821                        "rsbac_pm_add_target(): Adding cs item\n");
02822 #endif
02823 */
02824               cs_id.purpose = data.cs.purpose;
02825               cs_id.file = data.cs.file;
02826               return rsbac_ta_list_add_ttl(ta_number, cs_handle, 0, &cs_id, &data.cs);
02827             }
02828 
02829           case PMT_TP:
02830 /*
02831 #ifdef CONFIG_RSBAC_DEBUG
02832             if (rsbac_debug_ds_pm)
02833               rsbac_printk(KERN_DEBUG
02834                      "rsbac_pm_add_target(): Adding tp item\n");
02835 #endif
02836 */
02837             return rsbac_ta_list_add_ttl(ta_number, tp_handle, 0, &data.tp.id, &data.tp);
02838 
02839           case PMT_PP:
02840 /*
02841 #ifdef CONFIG_RSBAC_DEBUG
02842             if (rsbac_debug_ds_pm)
02843               rsbac_printk(KERN_DEBUG
02844                      "rsbac_pm_add_target(): Adding pp item\n");
02845 #endif
02846 */
02847             return rsbac_ta_list_add_ttl(ta_number, pp_handle, 0, &data.pp.id, &data.pp);
02848 
02849           case PMT_TKT:
02850 /*
02851 #ifdef CONFIG_RSBAC_DEBUG
02852             if (rsbac_debug_ds_pm)
02853               rsbac_printk(KERN_DEBUG
02854                      "rsbac_pm_add_target(): Adding tkt item\n");
02855 #endif
02856 */
02857             return rsbac_ta_list_add_ttl(ta_number, tkt_handle, 0, &data.tkt.id, &data.tkt);
02858 
02859           /* switch target: no valid target */
02860           default:  
02861             return(-RSBAC_EINVALIDTARGET);
02862         }
02863     }      /* end of rsbac_pm_add_target() */

int rsbac_pm_add_to_set (  rsbac_list_ta_number_t  ta_number,
enum rsbac_pm_set_t  set,
union rsbac_pm_set_id_t  id,
union rsbac_pm_set_member_t  member
) 
 

Definition at line 1714 of file pm_data_structures.c.

References in_pp_set_handle, NULL, out_pp_set_handle, pp_set_handle, RSBAC_EINVALIDTARGET, rsbac_ta_list_lol_subadd_ttl(), ru_set_handle, task_set_handle, and tp_set_handle.

Referenced by adjust_in_out_pp_ipc(), and rsbac_pm().

01719   {
01720     switch(set)
01721       {
01722         case PS_TASK:
01723           return(rsbac_ta_list_lol_subadd_ttl(ta_number, task_set_handle, 0, &id.task_set, &member.task, NULL));
01724         case PS_TP:
01725           return(rsbac_ta_list_lol_subadd_ttl(ta_number, tp_set_handle, 0, &id.tp_set, &member.tp, NULL));
01726         case PS_RU:
01727           return(rsbac_ta_list_lol_subadd_ttl(ta_number, ru_set_handle, 0, &id.ru_set, &member.ru, NULL));
01728         case PS_PP:
01729           return(rsbac_ta_list_lol_subadd_ttl(ta_number, pp_set_handle, 0, &id.pp_set, &member.pp, NULL));
01730         case PS_IN_PP:
01731           return(rsbac_ta_list_lol_subadd_ttl(ta_number, in_pp_set_handle, 0, &id.in_pp_set, &member.pp, NULL));
01732         case PS_OUT_PP:
01733           return(rsbac_ta_list_lol_subadd_ttl(ta_number, out_pp_set_handle, 0, &id.out_pp_set, &member.pp, NULL));
01734         default:
01735           return(-RSBAC_EINVALIDTARGET);
01736       }
01737   }

int rsbac_pm_clear_set (  rsbac_list_ta_number_t  ta_number,
enum rsbac_pm_set_t  set,
union rsbac_pm_set_id_t  id
) 
 

Definition at line 1774 of file pm_data_structures.c.

References in_pp_set_handle, out_pp_set_handle, pp_set_handle, RSBAC_EINVALIDTARGET, rsbac_ta_list_lol_subremove_all(), ru_set_handle, task_set_handle, and tp_set_handle.

Referenced by adjust_in_out_pp_ipc(), and rsbac_pm().

01778   {
01779     switch(set)
01780       {
01781         case PS_TASK:
01782           return(rsbac_ta_list_lol_subremove_all(ta_number, task_set_handle, &id.task_set));
01783         case PS_TP:
01784           return(rsbac_ta_list_lol_subremove_all(ta_number, tp_set_handle, &id.tp_set));
01785         case PS_RU:
01786           return(rsbac_ta_list_lol_subremove_all(ta_number, ru_set_handle, &id.ru_set));
01787         case PS_PP:
01788           return(rsbac_ta_list_lol_subremove_all(ta_number, pp_set_handle, &id.pp_set));
01789         case PS_IN_PP:
01790           return(rsbac_ta_list_lol_subremove_all(ta_number, in_pp_set_handle, &id.in_pp_set));
01791         case PS_OUT_PP:
01792           return(rsbac_ta_list_lol_subremove_all(ta_number, out_pp_set_handle, &id.out_pp_set));
01793         default:
01794           return(-RSBAC_EINVALIDTARGET);
01795       }
01796   }

int rsbac_pm_create_set (  rsbac_list_ta_number_t  ta_number,
enum rsbac_pm_set_t  set,
union rsbac_pm_set_id_t  id
) 
 

Definition at line 2006 of file pm_data_structures.c.

References in_pp_set_handle, NULL, out_pp_set_handle, pp_set_handle, RSBAC_EEXISTS, RSBAC_EINVALIDTARGET, rsbac_ta_list_lol_add_ttl(), rsbac_ta_list_lol_exist(), ru_set_handle, task_set_handle, and tp_set_handle.

Referenced by adjust_in_out_pp_ipc(), and rsbac_pm().

02010   {
02011     switch (set)
02012       {
02013         case PS_TASK:
02014 /*
02015 #ifdef CONFIG_RSBAC_DEBUG
02016           if (rsbac_debug_ds_pm)
02017             rsbac_printk(KERN_DEBUG "rsbac_pm_create_set(): Creating task set\n");
02018 #endif
02019 */
02020           if(rsbac_ta_list_lol_exist(ta_number, task_set_handle, &id.task_set))
02021             return -RSBAC_EEXISTS;
02022           return rsbac_ta_list_lol_add_ttl(ta_number, task_set_handle, 0, &id.task_set, NULL);
02023         case PS_TP:
02024 /*
02025 #ifdef CONFIG_RSBAC_DEBUG
02026           if (rsbac_debug_ds_pm)
02027             rsbac_printk(KERN_DEBUG "rsbac_pm_create_set(): Creating tp set\n");
02028 #endif
02029 */
02030           if(rsbac_ta_list_lol_exist(ta_number, tp_set_handle, &id.tp_set))
02031             return -RSBAC_EEXISTS;
02032           return rsbac_ta_list_lol_add_ttl(ta_number, tp_set_handle, 0, &id.tp_set, NULL);
02033         case PS_RU:
02034 /*
02035 #ifdef CONFIG_RSBAC_DEBUG
02036           if (rsbac_debug_ds_pm)
02037             rsbac_printk(KERN_DEBUG "rsbac_pm_create_set(): Creating ru set\n");
02038 #endif
02039 */
02040           if(rsbac_ta_list_lol_exist(ta_number, ru_set_handle, &id.ru_set))
02041             return -RSBAC_EEXISTS;
02042           return rsbac_ta_list_lol_add_ttl(ta_number, ru_set_handle, 0, &id.ru_set, NULL);
02043         case PS_PP:
02044 /*
02045 #ifdef CONFIG_RSBAC_DEBUG
02046           if (rsbac_debug_ds_pm)
02047             rsbac_printk(KERN_DEBUG "rsbac_pm_create_set(): Creating pp set\n");
02048 #endif
02049 */
02050           if(rsbac_ta_list_lol_exist(ta_number, pp_set_handle, &id.pp_set))
02051             return -RSBAC_EEXISTS;
02052           return rsbac_ta_list_lol_add_ttl(ta_number, pp_set_handle, 0, &id.pp_set, NULL);
02053         case PS_IN_PP:
02054 /*
02055 #ifdef CONFIG_RSBAC_DEBUG
02056           if (rsbac_debug_ds_pm)
02057             rsbac_printk(KERN_DEBUG "rsbac_pm_create_set(): Creating in_pp set\n");
02058 #endif
02059 */
02060           if(rsbac_ta_list_lol_exist(ta_number, in_pp_set_handle, &id.in_pp_set))
02061             return -RSBAC_EEXISTS;
02062           return rsbac_ta_list_lol_add_ttl(ta_number, in_pp_set_handle, 0, &id.in_pp_set, NULL);
02063         case PS_OUT_PP:
02064 /*
02065 #ifdef CONFIG_RSBAC_DEBUG
02066           if (rsbac_debug_ds_pm)
02067             rsbac_printk(KERN_DEBUG "rsbac_pm_create_set(): Creating out_pp set\n");
02068 #endif
02069 */
02070           if(rsbac_ta_list_lol_exist(ta_number, out_pp_set_handle, &id.out_pp_set))
02071             return -RSBAC_EEXISTS;
02072           return rsbac_ta_list_lol_add_ttl(ta_number, out_pp_set_handle, 0, &id.out_pp_set, NULL);
02073 
02074         default:
02075           return(-RSBAC_EINVALIDTARGET);          
02076       }
02077   }

rsbac_boolean_t rsbac_pm_exists (  rsbac_list_ta_number_t  ta_number,
enum rsbac_pm_target_t  target,
union rsbac_pm_target_id_t  tid
) 
 

Definition at line 2486 of file pm_data_structures.c.

References class_handle, cs_handle, FALSE, na_handle, NULL, pp_handle, pp_set_handle, RSBAC_PM_DEV_OBJECT_CLASS_ID, RSBAC_PM_IPC_OBJECT_CLASS_ID, rsbac_printk(), rsbac_ta_list_exist(), rsbac_ta_list_get_data_ttl(), rsbac_ta_list_lol_exist(), rsbac_ta_list_lol_remove(), rsbac_ta_list_remove(), task_handle, tkt_handle, tp_handle, and TRUE.

Referenced by na_and_pp_or_cs(), rsbac_pm(), and rsbac_pm_create_file().

02490     { 
02491       switch (target)
02492         {
02493           case PMT_TASK:
02494             return rsbac_ta_list_exist(ta_number, task_handle, &tid.task);
02495 
02496           case PMT_CLASS:
02497             /* IPC and DEV classes always exist */
02498             if(   (tid.object_class == RSBAC_PM_IPC_OBJECT_CLASS_ID)
02499                || (tid.object_class == RSBAC_PM_DEV_OBJECT_CLASS_ID))
02500               return(TRUE);
02501             return rsbac_ta_list_exist(ta_number, class_handle, &tid.object_class);
02502 
02503           case PMT_NA:
02504             return rsbac_ta_list_exist(ta_number, na_handle, &tid.na);
02505 
02506           case PMT_CS:
02507             return rsbac_ta_list_exist(ta_number, cs_handle, &tid.cs);
02508 
02509           case PMT_TP:
02510             return rsbac_ta_list_exist(ta_number, tp_handle, &tid.tp);
02511 
02512           case PMT_PP:
02513             return rsbac_ta_list_exist(ta_number, pp_handle, &tid.pp);
02514 
02515           case PMT_TKT:
02516             {
02517               struct rsbac_pm_tkt_data_t all_data;
02518 
02519               if(rsbac_ta_list_get_data_ttl(ta_number, tkt_handle,
02520                                             NULL, &tid.tkt, &all_data))
02521                 return FALSE;
02522 
02523               /* ticket too old? -> remove it and return FALSE */
02524               {
02525                 if(all_data.valid_until < RSBAC_CURRENT_TIME)
02526                   {
02527                     rsbac_pm_pp_set_id_t pp_set = -tid.tkt;
02528 
02529                     if(rsbac_ta_list_lol_exist(ta_number, pp_set_handle, &pp_set))
02530                       rsbac_ta_list_lol_remove(ta_number, pp_set_handle, &pp_set);
02531                     rsbac_ta_list_remove(ta_number, tkt_handle, &tid.tkt);
02532                     return(FALSE);
02533                   }
02534                 else
02535                   return TRUE;
02536               }
02537             }
02538           /* switch target: no valid target */
02539           default:  
02540             rsbac_printk(KERN_WARNING
02541                    "rsbac_pm_exists(): Invalid target!\n");
02542             return FALSE;
02543         }
02544     }      /* end of rsbac_pm_exists() */

int rsbac_pm_get_all_data (  rsbac_list_ta_number_t  ta_number,
enum rsbac_pm_target_t  target,
union rsbac_pm_target_id_t  tid,
union rsbac_pm_all_data_value_t *  value
) 
 

Definition at line 2391 of file pm_data_structures.c.

References class_handle, cs_handle, na_handle, NULL, pp_handle, RSBAC_EINVALIDTARGET, RSBAC_EINVALIDVALUE, rsbac_ta_list_get_data_ttl(), task_handle, tkt_handle, and tp_handle.

Referenced by rsbac_pm().

02396     { 
02397       if (!value)
02398         return(-RSBAC_EINVALIDVALUE);
02399       switch (target)
02400         {
02401           case PMT_TASK:
02402 /*
02403 #ifdef CONFIG_RSBAC_DEBUG
02404             if (rsbac_debug_ds_pm)
02405               rsbac_printk(KERN_DEBUG
02406                      "rsbac_pm_get_data(): Getting task data\n");
02407 #endif
02408 */
02409             return rsbac_ta_list_get_data_ttl(ta_number, task_handle,
02410                                               NULL, &tid.task, &value->task);
02411 
02412           case PMT_CLASS:
02413 /*
02414 #ifdef CONFIG_RSBAC_DEBUG
02415             if (rsbac_debug_ds_pm)
02416               rsbac_printk(KERN_DEBUG
02417                      "rsbac_pm_get_data(): Getting class data\n");
02418 #endif
02419 */
02420             return rsbac_ta_list_get_data_ttl(ta_number, class_handle,
02421                                               NULL, &tid.object_class, &value->object_class);
02422 
02423           case PMT_NA:
02424 /*
02425 #ifdef CONFIG_RSBAC_DEBUG
02426             if (rsbac_debug_ds_pm) 
02427               rsbac_printk(KERN_DEBUG
02428                      "rsbac_pm_get_data(): Getting na data\n");
02429 #endif
02430 */
02431             return rsbac_ta_list_get_data_ttl(ta_number, na_handle,
02432                                               NULL, &tid.na, &value->na);
02433 
02434           case PMT_CS:
02435 /*
02436 #ifdef CONFIG_RSBAC_DEBUG
02437             if (rsbac_debug_ds_pm)
02438               rsbac_printk(KERN_DEBUG
02439                      "rsbac_pm_get_data(): Getting cs data\n");
02440 #endif
02441 */
02442             return rsbac_ta_list_get_data_ttl(ta_number, cs_handle,
02443                                               NULL, &tid.cs, &value->cs);
02444 
02445           case PMT_TP:
02446 /*
02447 #ifdef CONFIG_RSBAC_DEBUG
02448             if (rsbac_debug_ds_pm)
02449               rsbac_printk(KERN_DEBUG
02450                      "rsbac_pm_get_data(): Getting tp data\n");
02451 #endif
02452 */
02453             return rsbac_ta_list_get_data_ttl(ta_number, tp_handle,
02454                                               NULL, &tid.tp, &value->tp);
02455 
02456           case PMT_PP:
02457 /*
02458 #ifdef CONFIG_RSBAC_DEBUG
02459             if (rsbac_debug_ds_pm)
02460               rsbac_printk(KERN_DEBUG
02461                      "rsbac_pm_get_data(): Getting pp data\n");
02462 #endif
02463 */
02464             return rsbac_ta_list_get_data_ttl(ta_number, pp_handle,
02465                                               NULL, &tid.pp, &value->pp);
02466 
02467           case PMT_TKT:
02468 /*
02469 #ifdef CONFIG_RSBAC_DEBUG
02470             if (rsbac_debug_ds_pm)
02471               rsbac_printk(KERN_DEBUG
02472                      "rsbac_pm_get_data(): Getting tkt data\n");
02473 #endif
02474 */
02475             return rsbac_ta_list_get_data_ttl(ta_number, tkt_handle,
02476                                               NULL, &tid.tkt, &value->tkt);
02477 
02478           /* switch target: no valid target */
02479           default:  
02480             return(-RSBAC_EINVALIDTARGET);
02481         }
02482     }      /* end of rsbac_pm_get_all_data() */

int rsbac_pm_get_data (  rsbac_list_ta_number_t  ta_number,
enum rsbac_pm_target_t  target,
union rsbac_pm_target_id_t  tid,
enum rsbac_pm_data_t  data,
union rsbac_pm_data_value_t *  value
) 
 

Definition at line 2150 of file pm_data_structures.c.

References class_handle, cs_handle, na_handle, NULL, pp_handle, RSBAC_EINVALIDATTR, RSBAC_EINVALIDTARGET, RSBAC_EINVALIDVALUE, rsbac_ta_list_get_data_ttl(), task_handle, tkt_handle, and tp_handle.

Referenced by adjust_in_out_pp(), na_and_pp_ipc(), na_and_pp_or_cs(), na_dev(), na_ipc(), rsbac_adf_request_pm(), rsbac_adf_set_attr_pm(), rsbac_pm(), and rsbac_pm_create_file().

02156     { 
02157       int err = 0;
02158     
02159       if (!value)
02160         return(-RSBAC_EINVALIDVALUE);
02161 
02162       switch (target)
02163         {
02164           case PMT_TASK:
02165             {
02166               struct rsbac_pm_task_data_t all_data;
02167 
02168 /*
02169 #ifdef CONFIG_RSBAC_DEBUG
02170               if (rsbac_debug_ds_pm)
02171                 rsbac_printk(KERN_DEBUG
02172                        "rsbac_pm_get_data(): Getting task data\n");
02173 #endif
02174 */
02175               err = rsbac_ta_list_get_data_ttl(ta_number, task_handle,
02176                                                NULL, &tid.task, &all_data);
02177               if(err)
02178                 return err;
02179 
02180               switch (data)
02181                 {
02182                   case PD_purpose:
02183                     value->purpose = all_data.purpose;
02184                     break;
02185                   case PD_tp_set:
02186                     value->tp_set = all_data.tp_set;
02187                     break;
02188                   case PD_ru_set:
02189                     value->ru_set = all_data.ru_set;
02190                     break;
02191                   default:
02192                     return -RSBAC_EINVALIDATTR;
02193                 }
02194               return 0;
02195             }
02196 
02197           case PMT_CLASS:
02198             {
02199               struct rsbac_pm_class_data_t all_data;
02200 
02201 /*
02202 #ifdef CONFIG_RSBAC_DEBUG
02203               if (rsbac_debug_ds_pm)
02204                 rsbac_printk(KERN_DEBUG
02205                        "rsbac_pm_get_data(): Getting class data\n");
02206 #endif
02207 */
02208               err = rsbac_ta_list_get_data_ttl(ta_number, class_handle,
02209                                                NULL, &tid.object_class, &all_data);
02210               if(err)
02211                 return err;
02212 
02213               switch (data)
02214                 {
02215                   case PD_pp_set:
02216                     value->pp_set = all_data.pp_set;
02217                     break;
02218                   default:
02219                     return -RSBAC_EINVALIDATTR;
02220                 }
02221               return 0;
02222             }
02223             
02224           case PMT_NA:
02225             {
02226               struct rsbac_pm_na_data_t all_data;
02227 
02228 /*
02229 #ifdef CONFIG_RSBAC_DEBUG
02230               if (rsbac_debug_ds_pm)
02231                 rsbac_printk(KERN_DEBUG
02232                        "rsbac_pm_get_data(): Getting na data\n");
02233 #endif
02234 */
02235               err = rsbac_ta_list_get_data_ttl(ta_number, na_handle,
02236                                                NULL, &tid.na, &all_data);
02237               if(err)
02238                 return err;
02239 
02240               switch (data)
02241                 {
02242                   case PD_task:
02243                      value->task = all_data.task;
02244                     break;
02245                   case PD_class:
02246                     value->object_class = all_data.object_class;
02247                     break;
02248                   case PD_tp:
02249                     value->tp = all_data.tp;
02250                     break;
02251                   case PD_accesses:
02252                     value->accesses = all_data.accesses;
02253                     break;
02254                   default:
02255                     return -RSBAC_EINVALIDATTR;
02256                 }
02257               return 0;
02258             }
02259             
02260           case PMT_CS:
02261             {
02262               struct rsbac_pm_cs_data_t all_data;
02263 
02264 /*
02265 #ifdef CONFIG_RSBAC_DEBUG
02266               if (rsbac_debug_ds_pm)
02267                 rsbac_printk(KERN_DEBUG
02268                        "rsbac_pm_get_data(): Getting cs data\n");
02269 #endif
02270 */
02271               err = rsbac_ta_list_get_data_ttl(ta_number, cs_handle,
02272                                                NULL, &tid.cs, &all_data);
02273               if(err)
02274                 return err;
02275 
02276               switch (data)
02277                 {
02278                   case PD_purpose:
02279                     value->purpose = all_data.purpose;
02280                     break;
02281                   case PD_file:
02282                     value->file = all_data.file;
02283                     break;
02284                   default:
02285                     return -RSBAC_EINVALIDATTR;
02286                 }
02287               return 0;
02288             }
02289             
02290           case PMT_TP:
02291             {
02292               struct rsbac_pm_tp_data_t all_data;
02293 
02294 /*
02295 #ifdef CONFIG_RSBAC_DEBUG
02296               if (rsbac_debug_ds_pm)
02297                 rsbac_printk(KERN_DEBUG
02298                        "rsbac_pm_get_data(): Getting tp data\n");
02299 #endif
02300 */
02301               err = rsbac_ta_list_get_data_ttl(ta_number, tp_handle,
02302                                                NULL, &tid.tp, &all_data);
02303               if(err)
02304                 return err;
02305 
02306               switch (data)
02307                 {
02308                   case PD_tp:
02309                     value->tp = all_data.id;
02310                     break;
02311                   default:
02312                     return -RSBAC_EINVALIDATTR;
02313                 }
02314               return 0;
02315             }
02316             
02317           case PMT_PP:
02318             {
02319               struct rsbac_pm_pp_data_t all_data;
02320 
02321 /*
02322 #ifdef CONFIG_RSBAC_DEBUG
02323               if (rsbac_debug_ds_pm)
02324                 rsbac_printk(KERN_DEBUG
02325                        "rsbac_pm_get_data(): Getting pp data\n");
02326 #endif
02327 */
02328               err = rsbac_ta_list_get_data_ttl(ta_number, pp_handle,
02329                                                NULL, &tid.pp, &all_data);
02330               if(err)
02331                 return err;
02332 
02333               switch (data)
02334                 {
02335                   case PD_purpose:
02336                     value->purpose = all_data.id;
02337                     break;
02338                   case PD_def_class:
02339                     value->def_class = all_data.def_class;
02340                     break;
02341                   default:
02342                     return -RSBAC_EINVALIDATTR;
02343                 }
02344               return 0;
02345             }
02346             
02347           case PMT_TKT:
02348             {
02349               struct rsbac_pm_tkt_data_t all_data;
02350 
02351 /*
02352 #ifdef CONFIG_RSBAC_DEBUG
02353               if (rsbac_debug_ds_pm)
02354                 rsbac_printk(KERN_DEBUG
02355                        "rsbac_pm_get_data(): Getting tkt data\n");
02356 #endif
02357 */
02358               err = rsbac_ta_list_get_data_ttl(ta_number, tkt_handle,
02359                                                NULL, &tid.tkt, &all_data);
02360               if(err)
02361                 return err;
02362 
02363               switch (data)
02364                 {
02365                   case PD_issuer:
02366                     value->issuer = all_data.issuer;
02367                     break;
02368                   case PD_function_type:
02369                     value->function_type = all_data.function_type;
02370                     break;
02371                   case PD_function_param:
02372                     value->function_param = all_data.function_param;
02373                     break;
02374                   case PD_valid_until:
02375                     value->valid_until = all_data.valid_until;
02376                     break;
02377                   default:
02378                     return -RSBAC_EINVALIDATTR;
02379                 }
02380               return 0;
02381             }
02382 
02383           /* switch target: no valid target */
02384           default:  
02385             return(-RSBAC_EINVALIDTARGET);
02386         }
02387     };      /* end of rsbac_pm_get_data() */

int rsbac_pm_pp_intersec (  rsbac_pm_pp_set_id_t  pp_set,
rsbac_pm_in_pp_set_id_t  in_pp_set
) 
 

Definition at line 1925 of file pm_data_structures.c.

References in_pp_set_handle, NULL, pp_set_handle, RSBAC_EINVALIDVALUE, rsbac_list_lol_add(), rsbac_list_lol_exist(), rsbac_list_lol_get_all_subdesc(), rsbac_list_lol_subadd(), rsbac_list_lol_subexist(), rsbac_list_lol_subremove(), and rsbac_vfree.

Referenced by adjust_in_out_pp().

01927   {
01928     rsbac_pm_purpose_id_t          * pp_array;
01929     long                             count;
01930     u_long                           i;
01931 
01932     if(!rsbac_list_lol_exist(pp_set_handle, &pp_set))
01933       return -RSBAC_EINVALIDVALUE;
01934 
01935     if(!rsbac_list_lol_exist(in_pp_set_handle, &in_pp_set))
01936       { /* in_pp_set not found -> try to create and fill with pp_set */
01937         if((count = rsbac_list_lol_add(in_pp_set_handle, &in_pp_set, NULL)))
01938           return count;
01939         /* creation successful -> copy list */
01940         /* get all pp_set members */
01941         count = rsbac_list_lol_get_all_subdesc(pp_set_handle, &pp_set, (void **) &pp_array);
01942         if(count <= 0)
01943           return count;
01944         for(i=0; i < count; i++)
01945           {
01946             rsbac_list_lol_subadd(in_pp_set_handle, &in_pp_set, &pp_array[i], NULL);
01947           }
01948         rsbac_vfree(pp_array);
01949       }
01950     else
01951       { /* in_pp_set exists -> remove all members not in pp_set */
01952         /* get all in_pp_set members */
01953         count = rsbac_list_lol_get_all_subdesc(in_pp_set_handle, &in_pp_set, (void **) &pp_array);
01954         if(count <= 0)
01955           return count;
01956         for(i=0; i < count; i++)
01957           {
01958             if(!rsbac_list_lol_subexist(pp_set_handle, &pp_set, &pp_array[i]))
01959               rsbac_list_lol_subremove(in_pp_set_handle, &in_pp_set, &pp_array[i]);
01960           }
01961         rsbac_vfree(pp_array);
01962       }
01963     return 0;
01964   }

rsbac_boolean_t rsbac_pm_pp_only (  rsbac_pm_purpose_id_t  purpose,
rsbac_pm_out_pp_set_id_t  out_pp_set
) 
 

Definition at line 1902 of file pm_data_structures.c.

References FALSE, out_pp_set_handle, rsbac_list_lol_subcount(), rsbac_list_lol_subexist(), and TRUE.

Referenced by na_and_pp_ipc().

01904   {
01905            long                             count;
01906 
01907     if(!out_pp_set)
01908       return(TRUE);
01909 
01910     /* get number of pp_set members */
01911     count = rsbac_list_lol_subcount(out_pp_set_handle, &out_pp_set);
01912     if(count <= 0)
01913       return TRUE;
01914     if(count == 1)
01915       return rsbac_list_lol_subexist(out_pp_set_handle, &out_pp_set, &purpose);
01916     else
01917       return FALSE;
01918   }

rsbac_boolean_t rsbac_pm_pp_subset (  rsbac_pm_pp_set_id_t  pp_set,
rsbac_pm_in_pp_set_id_t  in_pp_set
) 
 

Definition at line 1829 of file pm_data_structures.c.

References FALSE, in_pp_set_handle, pp_set_handle, rsbac_list_lol_exist(), rsbac_list_lol_get_all_subdesc(), rsbac_list_lol_subexist(), rsbac_vfree, and TRUE.

Referenced by na_and_pp_or_cs().

01831   {
01832            rsbac_pm_purpose_id_t          * pp_array;
01833            long                             count;
01834            u_long                           i;
01835            rsbac_boolean_t                          result = TRUE;
01836 
01837     if(!pp_set || !in_pp_set)
01838       return(FALSE);
01839 
01840     /* get all pp_set members */
01841     count = rsbac_list_lol_get_all_subdesc(pp_set_handle, &pp_set, (void **) &pp_array);
01842     if(count < 0)
01843       return FALSE;
01844     if(!count)
01845       return TRUE;
01846     if(!rsbac_list_lol_exist(in_pp_set_handle, &in_pp_set))
01847       {
01848         rsbac_vfree(pp_array);
01849         return TRUE;
01850       }
01851     /* check all members in in_pp_set */
01852     for(i=0; i< count; i++)
01853       {
01854         if(!rsbac_list_lol_subexist(in_pp_set_handle, &in_pp_set, &pp_array[i]))
01855           {
01856             result = FALSE;
01857             break;
01858           }
01859       }
01860     rsbac_vfree(pp_array);
01861     return result;
01862   }

rsbac_boolean_t rsbac_pm_pp_superset (  rsbac_pm_pp_set_id_t  pp_set,
rsbac_pm_out_pp_set_id_t  out_pp_set
) 
 

Definition at line 1867 of file pm_data_structures.c.

References FALSE, out_pp_set_handle, pp_set_handle, rsbac_list_lol_exist(), rsbac_list_lol_get_all_subdesc(), rsbac_list_lol_subexist(), rsbac_vfree, and TRUE.

Referenced by na_and_pp_or_cs().

01869   {
01870            rsbac_pm_purpose_id_t          * pp_array;
01871            long                             count;
01872            u_long                           i;
01873            rsbac_boolean_t                          result = TRUE;
01874 
01875     if(!pp_set)
01876       return(FALSE);
01877     if(!out_pp_set)
01878       return(TRUE);
01879     if(!rsbac_list_lol_exist(pp_set_handle, &pp_set))
01880       return FALSE;
01881 
01882     /* get all pp_set members */
01883     count = rsbac_list_lol_get_all_subdesc(out_pp_set_handle, &out_pp_set, (void **) &pp_array);
01884     if(count <= 0)
01885       return TRUE;
01886     /* check all members in in_pp_set */
01887     for(i=0; i< count; i++)
01888       {
01889         if(!rsbac_list_lol_subexist(pp_set_handle, &pp_set, &pp_array[i]))
01890           {
01891             result = FALSE;
01892             break;
01893           }
01894       }
01895     rsbac_vfree(pp_array);
01896     return result;
01897   }

int rsbac_pm_pp_union (  rsbac_pm_pp_set_id_t  pp_set,
rsbac_pm_out_pp_set_id_t  out_pp_set
) 
 

Definition at line 1971 of file pm_data_structures.c.

References NULL, out_pp_set_handle, pp_set_handle, RSBAC_EINVALIDVALUE, rsbac_list_lol_add(), rsbac_list_lol_exist(), rsbac_list_lol_get_all_subdesc(), rsbac_list_lol_subadd(), and rsbac_vfree.

Referenced by adjust_in_out_pp().

01973   {
01974     rsbac_pm_purpose_id_t          * pp_array;
01975     long                             count;
01976     u_long                           i;
01977     
01978     /* check, whether set-id pp_set exists */
01979     if(!rsbac_list_lol_exist(pp_set_handle, &pp_set))
01980       return -RSBAC_EINVALIDVALUE;
01981 
01982     if(!rsbac_list_lol_exist(out_pp_set_handle, &out_pp_set))
01983       { /* out_pp_set not found -> try to create */
01984         count = rsbac_list_lol_add(out_pp_set_handle, &out_pp_set, NULL);
01985         if(count)
01986           return count;
01987       }
01988     /* out_pp_set exists -> add all members in pp_set */
01989     /* get all pp_set members */
01990     count = rsbac_list_lol_get_all_subdesc(pp_set_handle, &pp_set, (void **) &pp_array);
01991     if(count <= 0)
01992       return count;
01993     for(i=0; i < count; i++)
01994       {
01995         rsbac_list_lol_subadd(out_pp_set_handle, &out_pp_set, &pp_array[i], NULL);
01996       }
01997     rsbac_vfree(pp_array);
01998     return 0;
01999   }

int rsbac_pm_remove_from_set (  rsbac_list_ta_number_t  ta_number,
enum rsbac_pm_set_t  set,
union rsbac_pm_set_id_t  id,
union rsbac_pm_set_member_t  member
) 
 

Definition at line 1744 of file pm_data_structures.c.

References in_pp_set_handle, out_pp_set_handle, pp_set_handle, RSBAC_EINVALIDTARGET, rsbac_ta_list_lol_subremove(), ru_set_handle, task_set_handle, and tp_set_handle.

Referenced by rsbac_pm().

01749   {
01750     switch(set)
01751       {
01752         case PS_TASK:
01753           return(rsbac_ta_list_lol_subremove(ta_number, task_set_handle, &id.task_set, &member.task));
01754         case PS_TP:
01755           return(rsbac_ta_list_lol_subremove(ta_number, tp_set_handle, &id.tp_set, &member.tp));
01756         case PS_RU:
01757           return(rsbac_ta_list_lol_subremove(ta_number, ru_set_handle, &id.ru_set, &member.ru));
01758         case PS_PP:
01759           return(rsbac_ta_list_lol_subremove(ta_number, pp_set_handle, &id.pp_set, &member.pp));
01760         case PS_IN_PP:
01761           return(rsbac_ta_list_lol_subremove(ta_number, in_pp_set_handle, &id.in_pp_set, &member.pp));
01762         case PS_OUT_PP:
01763           return(rsbac_ta_list_lol_subremove(ta_number, out_pp_set_handle, &id.out_pp_set, &member.pp));
01764         default:
01765           return(-RSBAC_EINVALIDTARGET);
01766       }
01767   }

int rsbac_pm_remove_set (  rsbac_list_ta_number_t  ta_number,
enum rsbac_pm_set_t  set,
union rsbac_pm_set_id_t  id
) 
 

Definition at line 2113 of file pm_data_structures.c.

References in_pp_set_handle, out_pp_set_handle, pp_set_handle, RSBAC_EINVALIDTARGET, rsbac_ta_list_lol_remove(), ru_set_handle, task_set_handle, and tp_set_handle.

Referenced by rsbac_adf_request_pm(), and rsbac_pm().

02117   {
02118     switch (set)
02119       {
02120         case PS_TASK:
02121           return rsbac_ta_list_lol_remove(ta_number, task_set_handle, &id.task_set);
02122         case PS_TP:
02123           return rsbac_ta_list_lol_remove(ta_number, tp_set_handle, &id.tp_set);
02124         case PS_RU:
02125           return rsbac_ta_list_lol_remove(ta_number, ru_set_handle, &id.ru_set);
02126         case PS_PP:
02127           return rsbac_ta_list_lol_remove(ta_number, pp_set_handle, &id.pp_set);
02128         case PS_IN_PP:
02129           return rsbac_ta_list_lol_remove(ta_number, in_pp_set_handle, &id.in_pp_set);
02130         case PS_OUT_PP:
02131           return rsbac_ta_list_lol_remove(ta_number, out_pp_set_handle, &id.out_pp_set);
02132 
02133         default:
02134           return -RSBAC_EINVALIDTARGET;
02135       }
02136   }

int rsbac_pm_remove_target (  rsbac_list_ta_number_t  ta_number,
enum rsbac_pm_target_t  target,
union rsbac_pm_target_id_t  tid
) 
 

Definition at line 2867 of file pm_data_structures.c.

References class_handle, cs_handle, na_handle, pp_handle, pp_set_handle, RSBAC_EINVALIDTARGET, rsbac_ta_list_lol_exist(), rsbac_ta_list_lol_remove(), rsbac_ta_list_remove(), task_handle, tkt_handle, and tp_handle.

Referenced by rsbac_pm().

02871     { 
02872       switch (target)
02873         {
02874           case PMT_TASK:
02875 /*
02876 #ifdef CONFIG_RSBAC_DEBUG
02877             if (rsbac_debug_ds_pm)
02878               rsbac_printk(KERN_DEBUG
02879                      "rsbac_pm_remove_target(): Removing task data\n");
02880 #endif
02881 */
02882             return rsbac_ta_list_remove(ta_number, task_handle, &tid.task);
02883 
02884           case PMT_CLASS:
02885 /*
02886 #ifdef CONFIG_RSBAC_DEBUG
02887             if (rsbac_debug_ds_pm) rsbac_printk(KERN_DEBUG "%s\n",
02888                         "rsbac_pm_remove_target(): Removing class data");
02889 #endif
02890 */
02891             return rsbac_ta_list_remove(ta_number, class_handle, &tid.object_class);
02892 
02893           case PMT_NA:
02894 /*
02895 #ifdef CONFIG_RSBAC_DEBUG
02896             if (rsbac_debug_ds_pm) rsbac_printk(KERN_DEBUG "%s\n",
02897                         "rsbac_pm_remove_target(): Removing tp data");
02898 #endif
02899 */
02900             return rsbac_ta_list_remove(ta_number, na_handle, &tid.na);
02901 
02902           case PMT_CS:
02903 /*
02904 #ifdef CONFIG_RSBAC_DEBUG
02905             if (rsbac_debug_ds_pm) rsbac_printk(KERN_DEBUG "%s\n",
02906                         "rsbac_pm_remove_target(): Removing cs data");
02907 #endif
02908 */
02909             return rsbac_ta_list_remove(ta_number, cs_handle, &tid.cs);
02910 
02911           case PMT_TP:
02912 /*
02913 #ifdef CONFIG_RSBAC_DEBUG
02914             if (rsbac_debug_ds_pm) rsbac_printk(KERN_DEBUG "%s\n",
02915                         "rsbac_pm_remove_target(): Removing tp data");
02916 #endif
02917 */
02918             return rsbac_ta_list_remove(ta_number, tp_handle, &tid.tp);
02919 
02920           case PMT_PP:
02921 /*
02922 #ifdef CONFIG_RSBAC_DEBUG
02923             if (rsbac_debug_ds_pm) rsbac_printk(KERN_DEBUG "%s\n",
02924                         "rsbac_pm_remove_target(): Removing pp data");
02925 #endif
02926 */
02927             return rsbac_ta_list_remove(ta_number, pp_handle, &tid.pp);
02928 
02929           case PMT_TKT:
02930             {
02931               rsbac_pm_pp_set_id_t pp_set = -tid.tkt;
02932 
02933 /*
02934 #ifdef CONFIG_RSBAC_DEBUG
02935               if (rsbac_debug_ds_pm) rsbac_printk(KERN_DEBUG "%s\n",
02936                           "rsbac_pm_remove_target(): Removing tkt data");
02937 #endif
02938 */
02939               if(rsbac_ta_list_lol_exist(ta_number, pp_set_handle, &pp_set))
02940                 rsbac_ta_list_lol_remove(ta_number, pp_set_handle, &pp_set);
02941               return rsbac_ta_list_remove(ta_number, tkt_handle, &tid.tkt);
02942             }
02943 
02944           default:
02945             return(-RSBAC_EINVALIDTARGET);          
02946         }
02947     };      /* end of rsbac_remove_target() */

int rsbac_pm_set_data (  rsbac_list_ta_number_t  ta_number,
enum rsbac_pm_target_t  target,
union rsbac_pm_target_id_t  tid,
enum rsbac_pm_data_t  data,
union rsbac_pm_data_value_t  value
) 
 

Definition at line 2548 of file pm_data_structures.c.

References class_handle, cs_handle, na_handle, NULL, pp_handle, RSBAC_EINVALIDATTR, RSBAC_EINVALIDTARGET, rsbac_ta_list_add_ttl(), rsbac_ta_list_get_data_ttl(), task_handle, and tkt_handle.

Referenced by rsbac_pm().

02554     { 
02555       switch (target)
02556         {
02557           case PMT_TASK:
02558             {
02559               struct rsbac_pm_task_data_t all_data;
02560                      int                  err;
02561 
02562 /*
02563 #ifdef CONFIG_RSBAC_DEBUG
02564               if (rsbac_debug_ds_pm)
02565                 rsbac_printk(KERN_DEBUG
02566                        "rsbac_pm_set_data(): Setting task data\n");
02567 #endif
02568 */
02569               err = rsbac_ta_list_get_data_ttl(ta_number, task_handle,
02570                                                NULL, &tid.task, &all_data);
02571               if(err)
02572                 return err;
02573 
02574               switch (data)
02575                 {
02576                   case PD_purpose:
02577                     all_data.purpose = value.purpose;
02578                     break;
02579                   case PD_tp_set:
02580                     all_data.tp_set = value.tp_set;
02581                     break;
02582                   case PD_ru_set:
02583                     all_data.ru_set = value.ru_set;
02584                     break;
02585                   default:
02586                     return -RSBAC_EINVALIDATTR;
02587                 }
02588               err = rsbac_ta_list_add_ttl(ta_number, task_handle, 0, &tid.task, &all_data);
02589               return err;
02590             }
02591 
02592           case PMT_CLASS:
02593             {
02594               struct rsbac_pm_class_data_t all_data;
02595                      int                   err;
02596 
02597 /*
02598 #ifdef CONFIG_RSBAC_DEBUG
02599               if (rsbac_debug_ds_pm)
02600                 rsbac_printk(KERN_DEBUG
02601                        "rsbac_pm_set_data(): Setting class data\n");
02602 #endif
02603 */
02604               err = rsbac_ta_list_get_data_ttl(ta_number, class_handle,
02605                                                NULL, &tid.object_class, &all_data);
02606               if(err)
02607                 return err;
02608 
02609               switch (data)
02610                 {
02611                   case PD_pp_set:
02612                     all_data.pp_set = value.pp_set;
02613                     break;
02614                   default:
02615                     return -RSBAC_EINVALIDATTR;
02616                 }
02617               err = rsbac_ta_list_add_ttl(ta_number, class_handle, 0, &tid.object_class, &all_data);
02618               return err;
02619             }
02620 
02621           case PMT_NA:
02622             {
02623               struct rsbac_pm_na_data_t all_data;
02624                      int                err;
02625 
02626 /*
02627 #ifdef CONFIG_RSBAC_DEBUG
02628               if (rsbac_debug_ds_pm)
02629                 rsbac_printk(KERN_DEBUG
02630                        "rsbac_pm_set_data(): Setting na data\n");
02631 #endif
02632 */
02633               err = rsbac_ta_list_get_data_ttl(ta_number, na_handle,
02634                                                NULL, &tid.na, &all_data);
02635               if(err)
02636                 return err;
02637 
02638               switch (data)
02639                 {
02640                   case PD_task:
02641                     all_data.task = value.task;
02642                     break;
02643                   case PD_class:
02644                     all_data.object_class = value.object_class;
02645                     break;
02646                   case PD_tp:
02647                     all_data.tp = value.tp;
02648                     break;
02649                   case PD_accesses:
02650                     all_data.accesses = value.accesses;
02651                     break;
02652                   default:
02653                     return -RSBAC_EINVALIDATTR;
02654                 }
02655               err = rsbac_ta_list_add_ttl(ta_number, na_handle, 0, &tid.na, &all_data);
02656               return err;
02657             }
02658 
02659           case PMT_CS:
02660             {
02661               struct rsbac_pm_cs_data_t all_data;
02662                      int                err;
02663 
02664 /*
02665 #ifdef CONFIG_RSBAC_DEBUG
02666               if (rsbac_debug_ds_pm)
02667                 rsbac_printk(KERN_DEBUG
02668                        "rsbac_pm_set_data(): Setting cs data\n");
02669 #endif
02670 */
02671               err = rsbac_ta_list_get_data_ttl(ta_number, cs_handle,
02672                                                NULL, &tid.cs, &all_data);
02673               if(err)
02674                 return err;
02675 
02676               switch (data)
02677                 {
02678                   case PD_purpose:
02679                     all_data.purpose = value.purpose;
02680                     break;
02681                   case PD_file:
02682                     all_data.file = value.file;
02683                     break;
02684                   default:
02685                     return -RSBAC_EINVALIDATTR;
02686                 }
02687               err = rsbac_ta_list_add_ttl(ta_number, cs_handle, 0, &tid.cs, &all_data);
02688               return err;
02689             }
02690 
02691           case PMT_TP:
02692             return -RSBAC_EINVALIDATTR;
02693 
02694           case PMT_PP:
02695             {
02696               struct rsbac_pm_pp_data_t all_data;
02697                      int                err;
02698 
02699 /*
02700 #ifdef CONFIG_RSBAC_DEBUG
02701               if (rsbac_debug_ds_pm)
02702                 rsbac_printk(KERN_DEBUG
02703                        "rsbac_pm_set_data(): Setting pp data\n");
02704 #endif
02705 */
02706               err = rsbac_ta_list_get_data_ttl(ta_number, pp_handle,
02707                                                NULL, &tid.pp, &all_data);
02708               if(err)
02709                 return err;
02710 
02711               switch (data)
02712                 {
02713                   case PD_def_class:
02714                     all_data.def_class = value.def_class;
02715                     break;
02716                   default:
02717                     return -RSBAC_EINVALIDATTR;
02718                 }
02719               err = rsbac_ta_list_add_ttl(ta_number, pp_handle, 0, &tid.pp, &all_data);
02720               return err;
02721             }
02722 
02723           case PMT_TKT:
02724             {
02725               struct rsbac_pm_tkt_data_t all_data;
02726                      int                 err;
02727 
02728 /*
02729 #ifdef CONFIG_RSBAC_DEBUG
02730               if (rsbac_debug_ds_pm)
02731                 rsbac_printk(KERN_DEBUG
02732                        "rsbac_pm_set_data(): Setting tkt data\n");
02733 #endif
02734 */
02735               err = rsbac_ta_list_get_data_ttl(ta_number, tkt_handle,
02736                                                NULL, &tid.tkt, &all_data);
02737               if(err)
02738                 return err;
02739 
02740               switch (data)
02741                 {
02742                   case PD_issuer:
02743                     all_data.issuer = value.issuer;
02744                     break;
02745                   case PD_function_type:
02746                     all_data.function_type = value.function_type;
02747                     break;
02748                   case PD_function_param:
02749                     all_data.function_param = value.function_param;
02750                     break;
02751                   case PD_valid_until:
02752                     all_data.valid_until = value.valid_until;
02753                     break;
02754                   default:
02755                     return -RSBAC_EINVALIDATTR;
02756                 }
02757               err = rsbac_ta_list_add_ttl(ta_number, tkt_handle, 0, &tid.tkt, &all_data);
02758               return err;
02759             }
02760 
02761           /* switch target: no valid target */
02762           default:  
02763             return(-RSBAC_EINVALIDTARGET);
02764         }
02765     }      /* end of rsbac_pm_set_data() */

rsbac_boolean_t rsbac_pm_set_exist (  rsbac_list_ta_number_t  ta_number,
enum rsbac_pm_set_t  set,
union rsbac_pm_set_id_t  id
) 
 

Definition at line 2082 of file pm_data_structures.c.

References FALSE, in_pp_set_handle, out_pp_set_handle, pp_set_handle, rsbac_ta_list_lol_exist(), ru_set_handle, task_set_handle, and tp_set_handle.

Referenced by adjust_in_out_pp_ipc().

02086   {
02087     switch (set)
02088       {
02089         case PS_TASK:
02090           return rsbac_ta_list_lol_exist(ta_number, task_set_handle, &id.task_set);
02091         case PS_TP:
02092           return rsbac_ta_list_lol_exist(ta_number, tp_set_handle, &id.tp_set);
02093         case PS_RU:
02094           return rsbac_ta_list_lol_exist(ta_number, ru_set_handle, &id.ru_set);
02095         case PS_PP:
02096           return rsbac_ta_list_lol_exist(ta_number, pp_set_handle, &id.pp_set);
02097         case PS_IN_PP:
02098           return rsbac_ta_list_lol_exist(ta_number, in_pp_set_handle, &id.in_pp_set);
02099         case PS_OUT_PP:
02100           return rsbac_ta_list_lol_exist(ta_number, out_pp_set_handle, &id.out_pp_set);
02101 
02102         default:
02103           return FALSE;
02104       }
02105   }

rsbac_boolean_t rsbac_pm_set_member (  rsbac_list_ta_number_t  ta_number,
enum rsbac_pm_set_t  set,
union rsbac_pm_set_id_t  id,
union rsbac_pm_set_member_t  member
) 
 

Definition at line 1801 of file pm_data_structures.c.

References FALSE, in_pp_set_handle, out_pp_set_handle, pp_set_handle, rsbac_ta_list_lol_subexist(), ru_set_handle, task_set_handle, and tp_set_handle.

Referenced by na_and_pp_ipc(), na_and_pp_or_cs(), rsbac_adf_request_pm(), rsbac_pm(), rsbac_pm_change_current_task(), and rsbac_pm_create_file().

01806   {
01807     switch(set)
01808       {
01809         case PS_TASK:
01810           return(rsbac_ta_list_lol_subexist(ta_number, task_set_handle, &id.task_set, &member.task));
01811         case PS_TP:
01812           return(rsbac_ta_list_lol_subexist(ta_number, tp_set_handle, &id.tp_set, &member.tp));
01813         case PS_RU:
01814           return(rsbac_ta_list_lol_subexist(ta_number, ru_set_handle, &id.ru_set, &member.ru));
01815         case PS_PP:
01816           return(rsbac_ta_list_lol_subexist(ta_number, pp_set_handle, &id.pp_set, &member.pp));
01817         case PS_IN_PP:
01818           return(rsbac_ta_list_lol_subexist(ta_number, in_pp_set_handle, &id.in_pp_set, &member.pp));
01819         case PS_OUT_PP:
01820           return(rsbac_ta_list_lol_subexist(ta_number, out_pp_set_handle, &id.out_pp_set, &member.pp));
01821         default:
01822           return(FALSE);
01823       }
01824   }

int rsbac_stats_pm (  void   ) 
 

Definition at line 1593 of file pm_data_structures.c.

References class_handle, cs_handle, in_pp_set_handle, na_handle, out_pp_set_handle, pp_handle, pp_set_handle, RSBAC_ENOTINITIALIZED, rsbac_is_initialized(), rsbac_list_count(), rsbac_list_lol_all_subcount(), rsbac_list_lol_count(), rsbac_printk(), ru_set_handle, task_handle, task_set_handle, tkt_handle, tp_handle, and tp_set_handle.

Referenced by rsbac_stats(), and sys_rsbac_stats_pm().

01594   {
01595     u_long                                   tmp_count;
01596     u_long                                   tmp_member_count;
01597     u_long                                   all_set_count = 0;
01598     u_long                                   all_member_count = 0;
01599     u_long                               all_count = 0;
01600   
01601     if (!rsbac_is_initialized())
01602       {
01603         rsbac_printk(KERN_WARNING "rsbac_stats_pm(): RSBAC not initialized\n");
01604         return(-RSBAC_ENOTINITIALIZED);
01605       }
01606 
01607 /****************/
01608 /* Helper lists */
01609 /****************/
01610 
01611     tmp_count = rsbac_list_lol_count(task_set_handle);
01612     tmp_member_count = rsbac_list_lol_all_subcount(task_set_handle);
01613     rsbac_printk(KERN_INFO "rsbac_stats_pm(): %lu task-set-items, sum of %lu members\n",
01614                  tmp_count, tmp_member_count);
01615     all_set_count += tmp_count;
01616     all_member_count += tmp_member_count;
01617 
01618     tmp_count = rsbac_list_lol_count(tp_set_handle);
01619     tmp_member_count = rsbac_list_lol_all_subcount(tp_set_handle);
01620     rsbac_printk(KERN_INFO "rsbac_stats_pm(): %lu tp set items, sum of %lu members\n",
01621                  tmp_count, tmp_member_count);
01622     all_set_count += tmp_count;
01623     all_member_count += tmp_member_count;
01624 
01625     tmp_count = rsbac_list_lol_count(ru_set_handle);
01626     tmp_member_count = rsbac_list_lol_all_subcount(ru_set_handle);
01627     rsbac_printk(KERN_INFO "rsbac_stats_pm(): %lu ru set items, sum of %lu members\n",
01628                  tmp_count, tmp_member_count);
01629     all_set_count += tmp_count;
01630     all_member_count += tmp_member_count;
01631 
01632     tmp_count = rsbac_list_lol_count(pp_set_handle);
01633     tmp_member_count = rsbac_list_lol_all_subcount(pp_set_handle);
01634     rsbac_printk(KERN_INFO "rsbac_stats_pm(): %lu pp set items, sum of %lu members\n",
01635                  tmp_count, tmp_member_count);
01636     all_set_count += tmp_count;
01637     all_member_count += tmp_member_count;
01638 
01639     tmp_count = rsbac_list_lol_count(in_pp_set_handle);
01640     tmp_member_count = rsbac_list_lol_all_subcount(in_pp_set_handle);
01641     rsbac_printk(KERN_INFO "rsbac_stats_pm(): %lu input purpose set items, sum of %lu members\n",
01642                  tmp_count, tmp_member_count);
01643     all_set_count += tmp_count;
01644     all_member_count += tmp_member_count;
01645 
01646     tmp_count = rsbac_list_lol_count(out_pp_set_handle);
01647     tmp_member_count = rsbac_list_lol_all_subcount(out_pp_set_handle);
01648     rsbac_printk(KERN_INFO "rsbac_stats_pm(): %lu output purpose set items, sum of %lu members\n",
01649                  tmp_count, tmp_member_count);
01650     all_set_count += tmp_count;
01651     all_member_count += tmp_member_count;
01652 
01653     rsbac_printk(KERN_INFO "rsbac_stats_pm(): Total of %lu registered rsbac-pm-set-items, %lu members\n",
01654                  all_set_count, all_member_count);
01655 
01656 /**************/
01657 /* Main lists */
01658 /**************/
01659     tmp_count = rsbac_list_count(task_handle);
01660     rsbac_printk(KERN_INFO "rsbac_stats_pm(): %lu task items\n",
01661                  tmp_count);
01662     all_count += tmp_count;
01663 
01664     tmp_count = rsbac_list_count(class_handle);
01665     rsbac_printk(KERN_INFO "rsbac_stats_pm(): %lu class items\n",
01666                  tmp_count);
01667     all_count += tmp_count;
01668 
01669     tmp_count = rsbac_list_count(na_handle);
01670     rsbac_printk(KERN_INFO "rsbac_stats_pm(): %lu na items\n",
01671                  tmp_count);
01672     all_count += tmp_count;
01673 
01674     tmp_count = rsbac_list_count(cs_handle);
01675     rsbac_printk(KERN_INFO "rsbac_stats_pm(): %lu cs items\n",
01676                  tmp_count);
01677     all_count += tmp_count;
01678 
01679     tmp_count = rsbac_list_count(tp_handle);
01680     rsbac_printk(KERN_INFO "rsbac_stats_pm(): %lu tp items\n",
01681                  tmp_count);
01682     all_count += tmp_count;
01683 
01684     tmp_count = rsbac_list_count(pp_handle);
01685     rsbac_printk(KERN_INFO "rsbac_stats_pm(): %lu pp items\n",
01686                  tmp_count);
01687     all_count += tmp_count;
01688 
01689     tmp_count = rsbac_list_count(tkt_handle);
01690     rsbac_printk(KERN_INFO "rsbac_stats_pm(): %lu tkt items\n",
01691                  tmp_count);
01692     all_count += tmp_count;
01693 
01694     rsbac_printk(KERN_INFO "rsbac_stats_pm(): Total of %lu registered rsbac-pm-items\n",
01695                  all_count);
01696     return 0;
01697   }

int sys_write (  u_int  ,
char *  ,
u_int 
) 
 

Variable Documentation

rsbac_list_handle_t class_handle = NULL [static]
 

Definition at line 46 of file pm_data_structures.c.

Referenced by rsbac_init_pm(), rsbac_pm_add_target(), rsbac_pm_exists(), rsbac_pm_get_all_data(), rsbac_pm_get_data(), rsbac_pm_remove_target(), rsbac_pm_set_data(), and rsbac_stats_pm().

rsbac_list_handle_t cs_handle = NULL [static]
 

Definition at line 48 of file pm_data_structures.c.

Referenced by rsbac_init_pm(), rsbac_pm_add_target(), rsbac_pm_exists(), rsbac_pm_get_all_data(), rsbac_pm_get_data(), rsbac_pm_remove_target(), rsbac_pm_set_data(), and rsbac_stats_pm().

rsbac_list_handle_t in_pp_set_handle = NULL [static]
 

Definition at line 42 of file pm_data_structures.c.

Referenced by rsbac_init_pm(), rsbac_pm_add_to_set(), rsbac_pm_clear_set(), rsbac_pm_create_set(), rsbac_pm_pp_intersec(), rsbac_pm_pp_subset(), rsbac_pm_remove_from_set(), rsbac_pm_remove_set(), rsbac_pm_set_exist(), rsbac_pm_set_member(), and rsbac_stats_pm().

rsbac_list_handle_t na_handle = NULL [static]
 

Definition at line 47 of file pm_data_structures.c.

Referenced by rsbac_init_pm(), rsbac_pm_add_target(), rsbac_pm_exists(), rsbac_pm_get_all_data(), rsbac_pm_get_data(), rsbac_pm_remove_target(), rsbac_pm_set_data(), and rsbac_stats_pm().

rsbac_list_handle_t out_pp_set_handle = NULL [static]
 

Definition at line 43 of file pm_data_structures.c.

Referenced by rsbac_init_pm(), rsbac_pm_add_to_set(), rsbac_pm_clear_set(), rsbac_pm_create_set(), rsbac_pm_pp_only(), rsbac_pm_pp_superset(), rsbac_pm_pp_union(), rsbac_pm_remove_from_set(), rsbac_pm_remove_set(), rsbac_pm_set_exist(), rsbac_pm_set_member(), and rsbac_stats_pm().

rsbac_list_handle_t pp_handle = NULL [static]
 

Definition at line 50 of file pm_data_structures.c.

Referenced by rsbac_init_pm(), rsbac_pm_add_target(), rsbac_pm_exists(), rsbac_pm_get_all_data(), rsbac_pm_get_data(), rsbac_pm_remove_target(), rsbac_pm_set_data(), and rsbac_stats_pm().

rsbac_list_handle_t pp_set_handle = NULL [static]
 

Definition at line 41 of file pm_data_structures.c.

Referenced by rsbac_init_pm(), rsbac_pm_add_to_set(), rsbac_pm_clear_set(), rsbac_pm_create_set(), rsbac_pm_exists(), rsbac_pm_pp_intersec(), rsbac_pm_pp_subset(), rsbac_pm_pp_superset(), rsbac_pm_pp_union(), rsbac_pm_remove_from_set(), rsbac_pm_remove_set(), rsbac_pm_remove_target(), rsbac_pm_set_exist(), rsbac_pm_set_member(), and rsbac_stats_pm().

rsbac_list_handle_t ru_set_handle = NULL [static]
 

Definition at line 40 of file pm_data_structures.c.

Referenced by rsbac_init_pm(), rsbac_pm_add_to_set(), rsbac_pm_clear_set(), rsbac_pm_create_set(), rsbac_pm_remove_from_set(), rsbac_pm_remove_set(), rsbac_pm_set_exist(), rsbac_pm_set_member(), and rsbac_stats_pm().

rsbac_list_handle_t task_handle = NULL [static]
 

Definition at line 45 of file pm_data_structures.c.

Referenced by rsbac_init_pm(), rsbac_pm_add_target(), rsbac_pm_exists(), rsbac_pm_get_all_data(), rsbac_pm_get_data(), rsbac_pm_remove_target(), rsbac_pm_set_data(), and rsbac_stats_pm().

rsbac_list_handle_t task_set_handle = NULL [static]
 

Definition at line 38 of file pm_data_structures.c.

Referenced by rsbac_init_pm(), rsbac_pm_add_to_set(), rsbac_pm_clear_set(), rsbac_pm_create_set(), rsbac_pm_remove_from_set(), rsbac_pm_remove_set(), rsbac_pm_set_exist(), rsbac_pm_set_member(), and rsbac_stats_pm().

rsbac_list_handle_t tkt_handle = NULL [static]
 

Definition at line 51 of file pm_data_structures.c.

Referenced by rsbac_init_pm(), rsbac_pm_add_target(), rsbac_pm_exists(), rsbac_pm_get_all_data(), rsbac_pm_get_data(), rsbac_pm_remove_target(), rsbac_pm_set_data(), and rsbac_stats_pm().

rsbac_list_handle_t tp_handle = NULL [static]
 

Definition at line 49 of file pm_data_structures.c.

Referenced by rsbac_init_pm(), rsbac_pm_add_target(), rsbac_pm_exists(), rsbac_pm_get_all_data(), rsbac_pm_get_data(), rsbac_pm_remove_target(), and rsbac_stats_pm().

rsbac_list_handle_t tp_set_handle = NULL [static]
 

Definition at line 39 of file pm_data_structures.c.

Referenced by rsbac_init_pm(), rsbac_pm_add_to_set(), rsbac_pm_clear_set(), rsbac_pm_create_set(), rsbac_pm_remove_from_set(), rsbac_pm_remove_set(), rsbac_pm_set_exist(), rsbac_pm_set_member(), and rsbac_stats_pm().

Generated on Thu Sep 22 16:42:31 2005 for RSBAC by  doxygen 1.4.2