/linux-2.6.21.1-rsbac-1.3.4/rsbac/help/getname.c File Reference

#include <rsbac/types.h>
#include <rsbac/getname.h>
#include <rsbac/helpers.h>
#include <rsbac/error.h>
#include <rsbac/pax_getname.h>
#include <string.h>
#include <stdio.h>
#include <errno.h>

Go to the source code of this file.

Functions

char * get_request_name (char *request_name, enum rsbac_adf_request_t request)
enum rsbac_adf_request_t get_request_nr (const char *request_name)
char * get_result_name (char *res_name, enum rsbac_adf_req_ret_t res)
enum rsbac_adf_req_ret_t get_result_nr (const char *res_name)
enum rsbac_switch_target_t get_attr_module (enum rsbac_attribute_t attr)
char * get_attribute_name (char *attr_name, enum rsbac_attribute_t attr)
enum rsbac_attribute_t get_attribute_nr (const char *attr_name)
char * get_attribute_value_name (char *attr_val_name, enum rsbac_attribute_t attr, union rsbac_attribute_value_t *attr_val_p)
char * get_scd_type_name (char *res_name, enum rsbac_scd_type_t res)
enum rsbac_scd_type_t get_scd_type_nr (const char *res_name)
char * get_target_name (char *target_type_name, enum rsbac_target_t target, char *target_id_name, union rsbac_target_id_t tid)
char * get_target_name_only (char *target_type_name, enum rsbac_target_t target)
enum rsbac_target_t get_target_nr (const char *target_name)
char * get_ipc_target_name (char *ipc_name, enum rsbac_ipc_type_t target)
enum rsbac_ipc_type_t get_ipc_target_nr (const char *ipc_name)
char * get_switch_target_name (char *switch_name, enum rsbac_switch_target_t target)
enum rsbac_switch_target_t get_switch_target_nr (const char *switch_name)
char * get_error_name (char *error_name, int error)
char * get_attribute_param (char *attr_name, enum rsbac_attribute_t attr)
char * get_log_level_name (char *ll_name, enum rsbac_log_level_t target)
enum rsbac_log_level_t get_log_level_nr (const char *ll_name)
char * get_cap_name (char *name, u_int value)
int get_cap_nr (const char *name)

Variables

static char request_list [R_NONE+1][24]
static char result_list [UNDEFINED+1][12]
static rsbac_switch_target_int_t attr_mod_list [A_none+1]
static char attribute_list [A_none+1][23]
static char target_list [T_NONE+1][11]
static char ipc_target_list [I_none+1][9]
static char switch_target_list [SW_NONE+1][12]
static char error_list [RSBAC_EMAX][26]
static char scd_type_list [ST_none+1][17]
static char attribute_param_list [A_none+1][194]
static char log_level_list [LL_invalid+1][9]
static char cap_list [RSBAC_CAP_MAX+1][17]


Function Documentation

enum rsbac_switch_target_t get_attr_module ( enum rsbac_attribute_t  attr  ) 

Definition at line 693 of file getname.c.

References A_none, attr_mod_list, and SW_NONE.

Referenced by sys_rsbac_get_attr(), sys_rsbac_get_attr_n(), sys_rsbac_set_attr(), and sys_rsbac_set_attr_n().

00694 {
00695         if (attr > A_none)
00696                 return SW_NONE;
00697         else
00698                 return attr_mod_list[attr];
00699 }

char* get_attribute_name ( char *  attr_name,
enum rsbac_attribute_t  attr 
)

Definition at line 707 of file getname.c.

References A_none, attribute_list, and NULL.

Referenced by rsbac_adf_request_int(), and rsbac_adf_set_attr().

00708 {
00709         if (!attr_name)
00710                 return (NULL);
00711         if (attr > A_none)
00712                 strcpy(attr_name, "ERROR!");
00713         else
00714                 strcpy(attr_name, attribute_list[attr]);
00715         return (attr_name);
00716 }

enum rsbac_attribute_t get_attribute_nr ( const char *  attr_name  ) 

Definition at line 718 of file getname.c.

References A_none, and attribute_list.

00719 {
00720         enum rsbac_attribute_t i;
00721 
00722         if (!attr_name)
00723                 return (A_none);
00724         for (i = 0; i < A_none; i++) {
00725                 if (!strcmp(attr_name, attribute_list[i])) {
00726                         return (i);
00727                 }
00728         }
00729         return (A_none);
00730 }

char* get_attribute_param ( char *  attr_name,
enum rsbac_attribute_t  attr 
)

Definition at line 1555 of file getname.c.

References A_none, attribute_param_list, and NULL.

01556 {
01557         if (!attr_name)
01558                 return (NULL);
01559         if (attr > A_none)
01560                 strcpy(attr_name, "ERROR!");
01561         else
01562                 strcpy(attr_name, attribute_param_list[attr]);
01563         return (attr_name);
01564 }

char* get_attribute_value_name ( char *  attr_val_name,
enum rsbac_attribute_t  attr,
union rsbac_attribute_value_t attr_val_p 
)

Definition at line 738 of file getname.c.

References A_auth_last_auth, A_none, A_pax_flags, rsbac_attribute_value_t::auth_last_auth, get_request_name(), get_switch_target_name(), get_target_name_only(), name, NULL, rsbac_attribute_value_t::pax_flags, pax_print_flags(), rsbac_get_net_type_name(), rsbac_kfree(), rsbac_kmalloc(), RSBAC_MAXNAMELEN, and rsbac_attribute_value_t::u_dummy.

Referenced by rsbac_adf_request_int().

00741 {
00742         if (!attr_val_name)
00743                 return (NULL);
00744         if (attr > A_none)
00745                 strcpy(attr_val_name, "ERROR!");
00746         else
00747                 switch (attr) {
00748                 case A_none:
00749                         strcpy(attr_val_name, "none");
00750                         break;
00751 #ifdef __KERNEL__
00752                 case A_create_data:
00753                         {
00754                                 char *tmp =
00755                                     rsbac_kmalloc(RSBAC_MAXNAMELEN);
00756 
00757                                 if (tmp) {
00758                                         if (attr_val_p->create_data.
00759                                             dentry_p)
00760                                                 snprintf(attr_val_name,
00761                                                          RSBAC_MAXNAMELEN -
00762                                                          1,
00763                                                          "%s %s, mode %o",
00764                                                          get_target_name_only
00765                                                          (tmp,
00766                                                           attr_val_p->
00767                                                           create_data.
00768                                                           target),
00769                                                          attr_val_p->
00770                                                          create_data.
00771                                                          dentry_p->d_name.
00772                                                          name,
00773                                                          attr_val_p->
00774                                                          create_data.
00775                                                          mode & S_IALLUGO);
00776                                         else
00777                                                 snprintf(attr_val_name,
00778                                                          RSBAC_MAXNAMELEN -
00779                                                          1, "%s, mode %o",
00780                                                          get_target_name_only
00781                                                          (tmp,
00782                                                           attr_val_p->
00783                                                           create_data.
00784                                                           target),
00785                                                          attr_val_p->
00786                                                          create_data.
00787                                                          mode & S_IALLUGO);
00788                                         rsbac_kfree(tmp);
00789                                 }
00790                         }
00791                         break;
00792                 case A_mode:
00793                         sprintf(attr_val_name, "%o", attr_val_p->mode);
00794                         break;
00795                 case A_priority:
00796                         sprintf(attr_val_name, "%i", attr_val_p->priority);
00797                         break;
00798                 case A_mod_name:
00799                         if (attr_val_p->mod_name)
00800                                 strncpy(attr_val_name,
00801                                         attr_val_p->mod_name,
00802                                         RSBAC_MAXNAMELEN - 1);
00803                         else
00804                                 strcpy(attr_val_name, "unknown");
00805                         attr_val_name[RSBAC_MAXNAMELEN - 1] = 0;
00806                         break;
00807                 case A_auth_add_f_cap:
00808                 case A_auth_remove_f_cap:
00809                         sprintf(attr_val_name, "%u:%u",
00810                                 attr_val_p->auth_cap_range.first,
00811                                 attr_val_p->auth_cap_range.last);
00812                         break;
00813                 case A_switch_target:
00814                         get_switch_target_name(attr_val_name,
00815                                                attr_val_p->switch_target);
00816                         break;
00817                 case A_request:
00818                         get_request_name(attr_val_name,
00819                                          attr_val_p->request);
00820                         break;
00821                 case A_sock_type:
00822                         rsbac_get_net_type_name(attr_val_name,
00823                                         attr_val_p->sock_type);
00824                         break;
00825 #endif
00826 #if defined(CONFIG_RSBAC_PAX) || !defined(__KERNEL__)
00827                 case A_pax_flags:
00828                         pax_print_flags(attr_val_name,
00829                                         attr_val_p->pax_flags);
00830                         break;
00831 #endif
00832 #if defined(CONFIG_RSBAC_AUTH) || !defined(__KERNEL__)
00833                 case A_auth_last_auth:
00834 #if defined(CONFIG_RSBAC_AUTH_LEARN) && defined(__KERNEL__)
00835                 case A_auth_start_uid:
00836                 case A_auth_start_euid:
00837 #endif
00838                         sprintf(attr_val_name, "%u",
00839                                 attr_val_p->auth_last_auth);
00840                         break;
00841 #endif
00842 #ifdef CONFIG_RSBAC_AUTH_GROUP
00843                 case A_auth_start_gid:
00844 #ifdef CONFIG_RSBAC_AUTH_DAC_GROUP
00845                 case A_auth_start_egid:
00846 #endif
00847                         sprintf(attr_val_name, "%u",
00848                                 attr_val_p->auth_start_gid);
00849                         break;
00850 #endif
00851                 default:
00852                         snprintf(attr_val_name, RSBAC_MAXNAMELEN - 1, "%u",
00853                                  attr_val_p->u_dummy);
00854                 }
00855         return (attr_val_name);
00856 }

char* get_cap_name ( char *  name,
u_int  value 
)

Definition at line 1592 of file getname.c.

References cap_list, CAP_NONE, and NULL.

01593 {
01594         if (!name)
01595                 return (NULL);
01596         if (value > CAP_NONE)
01597                 strcpy(name, "ERROR!");
01598         else
01599                 strcpy(name, cap_list[value]);
01600         return (name);
01601 }

int get_cap_nr ( const char *  name  ) 

Definition at line 1603 of file getname.c.

References cap_list, CAP_NONE, and RT_NONE.

01604 {
01605         int i;
01606 
01607         if (!name)
01608                 return (RT_NONE);
01609         for (i = 0; i < CAP_NONE; i++) {
01610                 if (!strcmp(name, cap_list[i])) {
01611                         return (i);
01612                 }
01613         }
01614         return (CAP_NONE);
01615 }

char* get_error_name ( char *  error_name,
int  error 
)

Definition at line 1535 of file getname.c.

References error_list, inttostr(), NULL, RSBAC_EPERM, and RSBAC_ERROR.

Referenced by aci_detach_fd_lists(), acl_detach_fd_lists(), acl_register_fd_lists(), auth_detach_fd_lists(), auth_register_fd_lists(), error_exit(), mac_detach_fd_lists(), mac_register_fd_lists(), register_fd_lists(), registration_error(), rsbac_acl_check_forward(), rsbac_acl_check_right(), rsbac_acl_check_super(), rsbac_acl_sys_add_to_acl_entry(), rsbac_acl_sys_get_mask(), rsbac_acl_sys_get_rights(), rsbac_acl_sys_get_tlist(), rsbac_acl_sys_remove_acl(), rsbac_acl_sys_remove_acl_entry(), rsbac_acl_sys_remove_from_acl_entry(), rsbac_acl_sys_remove_user(), rsbac_acl_sys_set_acl_entry(), rsbac_acl_sys_set_mask(), rsbac_do_init(), rsbac_init_acl(), rsbac_init_auth(), rsbac_init_debug(), rsbac_init_mac(), rsbac_init_um(), rsbac_list_init(), rsbac_list_lol_register_hashed(), rsbac_list_register_hashed(), rsbac_mount(), rsbac_mount_acl(), rsbac_mount_auth(), rsbac_mount_mac(), and show_error().

01536 {
01537         if (!error_name)
01538                 return (NULL);
01539 #ifndef __KERNEL__
01540         if((error == -1) && RSBAC_ERROR(-errno))
01541                 error = -errno;
01542 #endif
01543         if (RSBAC_ERROR(error))
01544                 strcpy(error_name, error_list[(-error) - RSBAC_EPERM]);
01545         else
01546 #ifdef __KERNEL__
01547                 inttostr(error_name, error);
01548 #else
01549                 strcpy(error_name, strerror(errno));
01550 #endif
01551         return (error_name);
01552 }

char* get_ipc_target_name ( char *  ipc_name,
enum rsbac_ipc_type_t  target 
)

Definition at line 1463 of file getname.c.

References I_none, ipc_target_list, and NULL.

01464 {
01465         if (!ipc_name)
01466                 return (NULL);
01467         if (target > I_none)
01468                 strcpy(ipc_name, "ERROR!");
01469         else
01470                 strcpy(ipc_name, ipc_target_list[target]);
01471         return (ipc_name);
01472 }

enum rsbac_ipc_type_t get_ipc_target_nr ( const char *  ipc_name  ) 

Definition at line 1474 of file getname.c.

References I_none, and ipc_target_list.

01475 {
01476         enum rsbac_ipc_type_t i;
01477 
01478         if (!ipc_name)
01479                 return (I_none);
01480         for (i = 0; i < I_none; i++) {
01481                 if (!strcmp(ipc_name, ipc_target_list[i])) {
01482                         return (i);
01483                 }
01484         }
01485         return (I_none);
01486 }

char* get_log_level_name ( char *  ll_name,
enum rsbac_log_level_t  target 
)

Definition at line 1567 of file getname.c.

References LL_invalid, log_level_list, and NULL.

01568 {
01569         if (!ll_name)
01570                 return (NULL);
01571         if (target > LL_invalid)
01572                 strcpy(ll_name, "ERROR!");
01573         else
01574                 strcpy(ll_name, log_level_list[target]);
01575         return (ll_name);
01576 }

enum rsbac_log_level_t get_log_level_nr ( const char *  ll_name  ) 

Definition at line 1578 of file getname.c.

References LL_invalid, and log_level_list.

01579 {
01580         enum rsbac_log_level_t i;
01581 
01582         if (!ll_name)
01583                 return (LL_invalid);
01584         for (i = 0; i < LL_invalid; i++) {
01585                 if (!strcmp(ll_name, log_level_list[i])) {
01586                         return (i);
01587                 }
01588         }
01589         return (LL_invalid);
01590 }

char* get_request_name ( char *  request_name,
enum rsbac_adf_request_t  request 
)

Definition at line 640 of file getname.c.

References NULL, R_NONE, and request_list.

Referenced by check_comp_rc_scd(), get_acl_special_right_name(), get_attribute_value_name(), get_rc_special_right_name(), rsbac_acl_check_right(), rsbac_adf_request_int(), rsbac_adf_set_attr(), sys_rsbac_adf_log_switch(), and sys_rsbac_get_adf_log().

00642 {
00643         if (!request_name)
00644                 return (NULL);
00645         if (request >= R_NONE)
00646                 strcpy(request_name, "ERROR!");
00647         else
00648                 strcpy(request_name, request_list[request]);
00649         return (request_name);
00650 }

enum rsbac_adf_request_t get_request_nr ( const char *  request_name  ) 

Definition at line 652 of file getname.c.

References R_NONE, and request_list.

Referenced by get_acl_special_right_nr(), and get_rc_special_right_nr().

00653 {
00654         enum rsbac_adf_request_t i;
00655 
00656         if (!request_name)
00657                 return (R_NONE);
00658         for (i = 0; i < R_NONE; i++) {
00659                 if (!strcmp(request_name, request_list[i])) {
00660                         return (i);
00661                 }
00662         }
00663         return (R_NONE);
00664 }

char* get_result_name ( char *  res_name,
enum rsbac_adf_req_ret_t  res 
)

Definition at line 667 of file getname.c.

References NULL, result_list, and UNDEFINED.

Referenced by rsbac_adf_request_int().

00668 {
00669         if (!res_name)
00670                 return (NULL);
00671         if (res > UNDEFINED)
00672                 strcpy(res_name, "ERROR!");
00673         else
00674                 strcpy(res_name, result_list[res]);
00675         return (res_name);
00676 }

enum rsbac_adf_req_ret_t get_result_nr ( const char *  res_name  ) 

Definition at line 678 of file getname.c.

References result_list, and UNDEFINED.

00679 {
00680         enum rsbac_adf_req_ret_t i;
00681 
00682         if (!res_name)
00683                 return (UNDEFINED);
00684         for (i = 0; i < UNDEFINED; i++) {
00685                 if (!strcmp(res_name, result_list[i])) {
00686                         return (i);
00687                 }
00688         }
00689         return (UNDEFINED);
00690 }

char* get_scd_type_name ( char *  res_name,
enum rsbac_scd_type_t  res 
)

Definition at line 865 of file getname.c.

References NULL, scd_type_list, and ST_none.

Referenced by get_acl_scd_type_name(), get_rc_scd_type_name(), and get_target_name().

00866 {
00867         if (!res_name)
00868                 return (NULL);
00869         if (res > ST_none)
00870                 strcpy(res_name, "ERROR!");
00871         else
00872                 strcpy(res_name, scd_type_list[res]);
00873         return (res_name);
00874 }

enum rsbac_scd_type_t get_scd_type_nr ( const char *  res_name  ) 

Definition at line 876 of file getname.c.

References scd_type_list, and ST_none.

Referenced by get_acl_scd_type_nr(), and get_rc_scd_type_nr().

00877 {
00878         enum rsbac_scd_type_t i;
00879 
00880         if (!res_name)
00881                 return (ST_none);
00882         for (i = 0; i < ST_none; i++) {
00883                 if (!strcmp(res_name, scd_type_list[i])) {
00884                         return (i);
00885                 }
00886         }
00887         return (ST_none);
00888 }

char* get_switch_target_name ( char *  switch_name,
enum rsbac_switch_target_t  target 
)

Definition at line 1495 of file getname.c.

References NULL, SW_NONE, and switch_target_list.

Referenced by get_attribute_value_name(), and sys_rsbac_switch().

01497 {
01498         if (!switch_name)
01499                 return (NULL);
01500         if (target > SW_NONE)
01501                 strcpy(switch_name, "ERROR!");
01502         else
01503                 strcpy(switch_name, switch_target_list[target]);
01504         return (switch_name);
01505 }

enum rsbac_switch_target_t get_switch_target_nr ( const char *  switch_name  ) 

Definition at line 1507 of file getname.c.

References SW_NONE, and switch_target_list.

01508 {
01509         enum rsbac_switch_target_t i;
01510 
01511         if (!switch_name)
01512                 return (SW_NONE);
01513         for (i = 0; i < SW_NONE; i++) {
01514 #ifdef __KERNEL__
01515                 if (!strncmp
01516                     (switch_name, switch_target_list[i],
01517                      strlen(switch_target_list[i])))
01518 #else
01519                 if (!strcmp(switch_name, switch_target_list[i]))
01520 #endif
01521                 {
01522                         return (i);
01523                 }
01524         }
01525         return (SW_NONE);
01526 }

char* get_target_name ( char *  target_type_name,
enum rsbac_target_t  target,
char *  target_id_name,
union rsbac_target_id_t  tid 
)

Definition at line 897 of file getname.c.

References D_block, D_block_major, D_char, D_char_major, rsbac_target_id_t::dev, get_scd_type_name(), rsbac_target_id_t::group, I_anonpipe, I_anonunix, I_mqueue, I_msg, I_sem, I_shm, rsbac_ipc_t::id, rsbac_ipc_id_t::id_nr, rsbac_target_id_t::ipc, KERNEL_VERSION, rsbac_net_obj_desc_t::local_addr, rsbac_dev_desc_t::major, rsbac_dev_desc_t::minor, name, rsbac_target_id_t::netdev, rsbac_target_id_t::netobj, rsbac_target_id_t::nettemp, NIPQUAD, NULL, rsbac_target_id_t::process, rsbac_net_obj_desc_t::remote_addr, rsbac_get_full_path(), rsbac_get_net_family_name(), rsbac_get_net_protocol_name(), rsbac_get_net_type_name(), RSBAC_IFNAMSIZ, rsbac_kfree(), rsbac_kmalloc(), RSBAC_MAXNAMELEN, rsbac_min, rsbac_target_id_t::scd, rsbac_net_obj_desc_t::sock_p, T_DEV, T_DIR, T_FD, T_FIFO, T_FILE, T_GROUP, T_IPC, T_NETDEV, T_NETOBJ, T_NETTEMP, T_NETTEMP_NT, T_NONE, T_PROCESS, T_SCD, T_SYMLINK, T_UNIXSOCK, T_USER, rsbac_dev_desc_t::type, rsbac_ipc_t::type, and rsbac_target_id_t::user.

Referenced by auto_read_attr(), auto_read_write_attr(), auto_write_attr(), rsbac_acl_check_right(), rsbac_acl_sys_add_to_acl_entry(), rsbac_acl_sys_remove_acl(), rsbac_acl_sys_remove_acl_entry(), rsbac_acl_sys_remove_from_acl_entry(), rsbac_acl_sys_set_acl_entry(), rsbac_acl_sys_set_mask(), rsbac_adf_request_int(), and rsbac_adf_set_attr().

00900 {
00901 #ifdef __KERNEL__
00902         char *help_name;
00903 #else
00904         char help_name[RSBAC_MAXNAMELEN + 4];
00905 #endif
00906 
00907         if (!target_type_name)
00908                 return (NULL);
00909 
00910 #ifdef __KERNEL__
00911 #ifdef CONFIG_RSBAC_LOG_FULL_PATH
00912         help_name = rsbac_kmalloc(CONFIG_RSBAC_MAX_PATH_LEN + 4);
00913 #else
00914         help_name = rsbac_kmalloc(RSBAC_MAXNAMELEN + 4);
00915 #endif
00916         if (!help_name)
00917                 return NULL;
00918 #endif
00919 
00920         switch (target) {
00921 #ifdef __KERNEL__
00922         case T_FD:
00923                 strcpy(target_type_name, "FD");
00924                 if (!target_id_name)
00925                         break;
00926                 sprintf(target_id_name, "Device %02u:%02u Inode %u",
00927                         RSBAC_MAJOR(tid.file.device),
00928                         RSBAC_MINOR(tid.file.device), tid.file.inode);
00929                 if (tid.file.dentry_p && tid.file.dentry_p->d_name.name
00930                     && tid.file.dentry_p->d_name.len) {
00931 #ifdef CONFIG_RSBAC_LOG_FULL_PATH
00932                         if (rsbac_get_full_path
00933                             (tid.file.dentry_p, help_name,
00934                              CONFIG_RSBAC_MAX_PATH_LEN) > 0) {
00935                                 strcat(target_id_name, " Path ");
00936                                 strcat(target_id_name, help_name);
00937                         }
00938 #else
00939                         int namelen =
00940                             rsbac_min(tid.file.dentry_p->d_name.len,
00941                                       RSBAC_MAXNAMELEN);
00942 
00943                         strcat(target_id_name, " Name ");
00944                         strncpy(help_name, tid.file.dentry_p->d_name.name,
00945                                 namelen);
00946                         help_name[namelen] = 0;
00947                         strcat(target_id_name, help_name);
00948 #endif
00949                 }
00950                 break;
00951         case T_FILE:
00952                 strcpy(target_type_name, "FILE");
00953                 if (!target_id_name)
00954                         break;
00955                 sprintf(target_id_name, "Device %02u:%02u Inode %u",
00956                         RSBAC_MAJOR(tid.file.device),
00957                         RSBAC_MINOR(tid.file.device), tid.file.inode);
00958                 if (tid.file.dentry_p && tid.file.dentry_p->d_name.name
00959                     && tid.file.dentry_p->d_name.len) {
00960 #ifdef CONFIG_RSBAC_LOG_FULL_PATH
00961                         if (rsbac_get_full_path
00962                             (tid.file.dentry_p, help_name,
00963                              CONFIG_RSBAC_MAX_PATH_LEN) > 0) {
00964                                 strcat(target_id_name, " Path ");
00965                                 strcat(target_id_name, help_name);
00966                         }
00967 #else
00968                         int namelen =
00969                             rsbac_min(tid.file.dentry_p->d_name.len,
00970                                       RSBAC_MAXNAMELEN);
00971 
00972                         strcat(target_id_name, " Name ");
00973                         strncpy(help_name, tid.file.dentry_p->d_name.name,
00974                                 namelen);
00975                         help_name[namelen] = 0;
00976                         strcat(target_id_name, help_name);
00977 #endif
00978                 }
00979                 break;
00980         case T_DIR:
00981                 strcpy(target_type_name, "DIR");
00982                 if (!target_id_name)
00983                         break;
00984                 sprintf(target_id_name, "Device %02u:%02u Inode %u",
00985                         RSBAC_MAJOR(tid.file.device),
00986                         RSBAC_MINOR(tid.file.device), tid.dir.inode);
00987                 if (tid.dir.dentry_p && tid.dir.dentry_p->d_name.name
00988                     && tid.dir.dentry_p->d_name.len) {
00989 #ifdef CONFIG_RSBAC_LOG_FULL_PATH
00990                         if (rsbac_get_full_path
00991                             (tid.dir.dentry_p, help_name,
00992                              CONFIG_RSBAC_MAX_PATH_LEN) > 0) {
00993                                 strcat(target_id_name, " Path ");
00994                                 strcat(target_id_name, help_name);
00995                         }
00996 #else
00997                         int namelen =
00998                             rsbac_min(tid.dir.dentry_p->d_name.len,
00999                                       RSBAC_MAXNAMELEN);
01000 
01001                         strcat(target_id_name, " Name ");
01002                         strncpy(help_name, tid.dir.dentry_p->d_name.name,
01003                                 namelen);
01004                         help_name[namelen] = 0;
01005                         strcat(target_id_name, help_name);
01006 #endif
01007                 }
01008                 break;
01009         case T_FIFO:
01010                 strcpy(target_type_name, "FIFO");
01011                 if (!target_id_name)
01012                         break;
01013                 sprintf(target_id_name, "Device %02u:%02u Inode %u",
01014                         RSBAC_MAJOR(tid.file.device),
01015                         RSBAC_MINOR(tid.file.device), tid.fifo.inode);
01016                 if (tid.fifo.dentry_p && tid.fifo.dentry_p->d_name.name
01017                     && tid.fifo.dentry_p->d_name.len) {
01018 #ifdef CONFIG_RSBAC_LOG_FULL_PATH
01019                         if (rsbac_get_full_path
01020                             (tid.fifo.dentry_p, help_name,
01021                              CONFIG_RSBAC_MAX_PATH_LEN) > 0) {
01022                                 strcat(target_id_name, " Path ");
01023                                 strcat(target_id_name, help_name);
01024                         }
01025 #else
01026                         int namelen =
01027                             rsbac_min(tid.fifo.dentry_p->d_name.len,
01028                                       RSBAC_MAXNAMELEN);
01029 
01030                         strcat(target_id_name, " Name ");
01031                         strncpy(help_name, tid.fifo.dentry_p->d_name.name,
01032                                 namelen);
01033                         help_name[namelen] = 0;
01034                         strcat(target_id_name, help_name);
01035 #endif
01036                 }
01037                 break;
01038         case T_SYMLINK:
01039                 strcpy(target_type_name, "SYMLINK");
01040                 if (!target_id_name)
01041                         break;
01042                 sprintf(target_id_name, "Device %02u:%02u Inode %u",
01043                         RSBAC_MAJOR(tid.symlink.device),
01044                         RSBAC_MINOR(tid.symlink.device), tid.symlink.inode);
01045                 if (tid.symlink.dentry_p
01046                     && tid.symlink.dentry_p->d_name.name
01047                     && tid.symlink.dentry_p->d_name.len) {
01048 #ifdef CONFIG_RSBAC_LOG_FULL_PATH
01049                         if (rsbac_get_full_path
01050                             (tid.symlink.dentry_p, help_name,
01051                              CONFIG_RSBAC_MAX_PATH_LEN) > 0) {
01052                                 strcat(target_id_name, " Path ");
01053                                 strcat(target_id_name, help_name);
01054                         }
01055 #else
01056                         int namelen =
01057                             rsbac_min(tid.symlink.dentry_p->d_name.len,
01058                                       RSBAC_MAXNAMELEN);
01059 
01060                         strcat(target_id_name, " Name ");
01061                         strncpy(help_name,
01062                                 tid.symlink.dentry_p->d_name.name,
01063                                 namelen);
01064                         help_name[namelen] = 0;
01065                         strcat(target_id_name, help_name);
01066 #endif
01067                 }
01068                 break;
01069         case T_UNIXSOCK:
01070                 strcpy(target_type_name, "UNIXSOCK");
01071                 if (!target_id_name)
01072                         break;
01073                 sprintf(target_id_name, "Device %02u:%02u Inode %u",
01074                         RSBAC_MAJOR(tid.unixsock.device),
01075                         RSBAC_MINOR(tid.unixsock.device), tid.unixsock.inode);
01076                 if (tid.symlink.dentry_p
01077                     && tid.unixsock.dentry_p->d_name.name
01078                     && tid.unixsock.dentry_p->d_name.len) {
01079 #ifdef CONFIG_RSBAC_LOG_FULL_PATH
01080                         if (rsbac_get_full_path
01081                             (tid.unixsock.dentry_p, help_name,
01082                              CONFIG_RSBAC_MAX_PATH_LEN) > 0) {
01083                                 strcat(target_id_name, " Path ");
01084                                 strcat(target_id_name, help_name);
01085                         }
01086 #else
01087                         int namelen =
01088                             rsbac_min(tid.unixsock.dentry_p->d_name.len,
01089                                       RSBAC_MAXNAMELEN);
01090 
01091                         strcat(target_id_name, " Name ");
01092                         strncpy(help_name,
01093                                 tid.unixsock.dentry_p->d_name.name,
01094                                 namelen);
01095                         help_name[namelen] = 0;
01096                         strcat(target_id_name, help_name);
01097 #endif
01098                 }
01099                 break;
01100         case T_DEV:
01101                 strcpy(target_type_name, "DEV");
01102                 if (!target_id_name)
01103                         break;
01104                 switch (tid.dev.type) {
01105                 case D_block:
01106                         sprintf(target_id_name, "block %02u:%02u",
01107                                 tid.dev.major, tid.dev.minor);
01108                         break;
01109                 case D_char:
01110                         sprintf(target_id_name, "char %02u:%02u",
01111                                 tid.dev.major, tid.dev.minor);
01112                         break;
01113                 case D_block_major:
01114                         sprintf(target_id_name, "block major %02u",
01115                                 tid.dev.major);
01116                         break;
01117                 case D_char_major:
01118                         sprintf(target_id_name, "char major %02u",
01119                                 tid.dev.major);
01120                         break;
01121                 default:
01122                         sprintf(target_id_name, "*unknown* %02u:%02u",
01123                                 tid.dev.major, tid.dev.minor);
01124                 }
01125                 break;
01126         case T_NETOBJ:
01127                 strcpy(target_type_name, "NETOBJ");
01128                 if (!target_id_name)
01129                         break;
01130 #ifdef CONFIG_NET
01131                 if (tid.netobj.sock_p
01132                     && tid.netobj.sock_p->ops && tid.netobj.sock_p->sk) {
01133                         char type_name[RSBAC_MAXNAMELEN];
01134 
01135                         switch (tid.netobj.sock_p->ops->family) {
01136                         case AF_INET:
01137                                 {
01138                                         __u32 saddr;
01139                                         __u16 sport;
01140                                         __u32 daddr;
01141                                         __u16 dport;
01142                                         struct net_device *dev;
01143                                         char ldevname[RSBAC_IFNAMSIZ + 10];
01144                                         char rdevname[RSBAC_IFNAMSIZ + 10];
01145 
01146                                         if (tid.netobj.local_addr) {
01147                                                 struct sockaddr_in *addr =
01148                                                     tid.netobj.local_addr;
01149 
01150                                                 saddr =
01151                                                     addr->sin_addr.s_addr;
01152                                                 sport =
01153                                                     ntohs(addr->sin_port);
01154                                         } else {
01155 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
01156                                                 saddr =
01157                                                     inet_sk(tid.netobj.
01158                                                             sock_p->sk)->
01159                                                     saddr;
01160                                                 sport =
01161                                                     inet_sk(tid.netobj.
01162                                                             sock_p->sk)->
01163                                                     num;
01164 #else
01165                                                 saddr =
01166                                                     tid.netobj.sock_p->sk->
01167                                                     saddr;
01168                                                 sport =
01169                                                     tid.netobj.sock_p->sk->
01170                                                     num;
01171 #endif
01172                                         }
01173                                         if (tid.netobj.remote_addr) {
01174                                                 struct sockaddr_in *addr =
01175                                                     tid.netobj.remote_addr;
01176 
01177                                                 daddr =
01178                                                     addr->sin_addr.s_addr;
01179                                                 dport =
01180                                                     ntohs(addr->sin_port);
01181                                         } else {
01182 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
01183                                                 daddr =
01184                                                     inet_sk(tid.netobj.
01185                                                             sock_p->sk)->
01186                                                     daddr;
01187                                                 dport =
01188                                                     ntohs(inet_sk
01189                                                           (tid.netobj.
01190                                                            sock_p->sk)->
01191                                                           dport);
01192 #else
01193                                                 daddr =
01194                                                     tid.netobj.sock_p->sk->
01195                                                     daddr;
01196                                                 dport =
01197                                                     ntohs(tid.netobj.
01198                                                           sock_p->sk->
01199                                                           dport);
01200 #endif
01201                                         }
01202                                         dev = ip_dev_find(saddr);
01203                                         if (dev) {
01204                                                 sprintf(ldevname, "%s:",
01205                                                         dev->name);
01206                                                 dev_put(dev);
01207                                         } else
01208                                                 ldevname[0] = 0;
01209                                         dev = ip_dev_find(daddr);
01210                                         if (dev) {
01211                                                 sprintf(rdevname, "%s:",
01212                                                         dev->name);
01213                                                 dev_put(dev);
01214                                         } else
01215                                                 rdevname[0] = 0;
01216                                         sprintf(target_id_name,
01217                                                 "%p INET %s proto %s local %s%u.%u.%u.%u:%u remote %s%u.%u.%u.%u:%u",
01218                                                 tid.netobj.sock_p,
01219                                                 rsbac_get_net_type_name
01220                                                 (type_name,
01221                                                  tid.netobj.sock_p->type),
01222 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
01223                                                 rsbac_get_net_protocol_name
01224                                                 (help_name,
01225                                                  tid.netobj.sock_p->sk->
01226                                                  sk_protocol),
01227 #else
01228                                                 rsbac_get_net_protocol_name
01229                                                 (help_name,
01230                                                  tid.netobj.sock_p->sk->
01231                                                  protocol),
01232 #endif
01233                                                 ldevname,
01234                                                 NIPQUAD(saddr),
01235                                                 sport,
01236                                                 rdevname,
01237                                                 NIPQUAD(daddr), dport);
01238                                 }
01239                                 break;
01240                         case AF_UNIX:
01241 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
01242                                 if (unix_sk(tid.netobj.sock_p->sk)->addr)
01243                                         sprintf(target_id_name,
01244                                                 "%p UNIX %s %s",
01245                                                 tid.netobj.sock_p,
01246                                                 rsbac_get_net_type_name
01247                                                 (type_name,
01248                                                  tid.netobj.sock_p->type),
01249                                                 unix_sk(tid.netobj.sock_p->
01250                                                         sk)->addr->name[0].
01251                                                 sun_path);
01252 #else
01253                                 if (tid.netobj.sock_p->sk->protinfo.
01254                                     af_unix.addr)
01255                                         sprintf(target_id_name,
01256                                                 "%p UNIX %s %s",
01257                                                 tid.netobj.sock_p,
01258                                                 rsbac_get_net_type_name
01259                                                 (type_name,
01260                                                  tid.netobj.sock_p->type),
01261                                                 tid.netobj.sock_p->sk->
01262                                                 protinfo.af_unix.addr->
01263                                                 name[0].sun_path);
01264 #endif
01265                                 else if (tid.netobj.local_addr) {
01266                                         struct sockaddr_un *addr =
01267                                             tid.netobj.local_addr;
01268 
01269                                         sprintf(target_id_name,
01270                                                 "%p UNIX %s %s",
01271                                                 tid.netobj.sock_p,
01272                                                 rsbac_get_net_type_name
01273                                                 (type_name,
01274                                                  tid.netobj.sock_p->type),
01275                                                 addr->sun_path);
01276                                 } else
01277                                         sprintf(target_id_name,
01278                                                 "%p UNIX %s",
01279                                                 tid.netobj.sock_p,
01280                                                 rsbac_get_net_type_name
01281                                                 (type_name,
01282                                                  tid.netobj.sock_p->type));
01283                                 break;
01284                         default:
01285                                 sprintf(target_id_name, "%p %s %s",
01286                                         tid.netobj.sock_p,
01287                                         rsbac_get_net_family_name
01288                                         (help_name,
01289                                          tid.netobj.sock_p->ops->family),
01290                                         rsbac_get_net_type_name(type_name,
01291                                                                 tid.netobj.
01292                                                                 sock_p->
01293                                                                 type));
01294                         }
01295                 } else
01296 #endif                          /* CONFIG_NET */
01297                 {
01298                         sprintf(target_id_name, "%p", tid.netobj.sock_p);
01299                 }
01300                 break;
01301 #endif                          /* __KERNEL__ */
01302         case T_IPC:
01303                 strcpy(target_type_name, "IPC");
01304                 if (!target_id_name)
01305                         break;
01306                 switch (tid.ipc.type) {
01307                 case I_sem:
01308                         strcpy(target_id_name, "Sem-ID ");
01309                         break;
01310                 case I_msg:
01311                         strcpy(target_id_name, "Msg-ID ");
01312                         break;
01313                 case I_shm:
01314                         strcpy(target_id_name, "Shm-ID ");
01315                         break;
01316                 case I_anonpipe:
01317                         strcpy(target_id_name, "AnonPipe-ID ");
01318                         break;
01319                 case I_mqueue:
01320                         strcpy(target_id_name, "Mqueue-ID ");
01321                         break;
01322                 case I_anonunix:
01323                         strcpy(target_id_name, "AnonUnix-ID ");
01324                         break;
01325                 default:
01326                         strcpy(target_id_name, "ID ");
01327                         break;
01328                 };
01329                 sprintf(help_name, "%lu", tid.ipc.id.id_nr);
01330                 strcat(target_id_name, help_name);
01331                 break;
01332         case T_SCD:
01333                 strcpy(target_type_name, "SCD");
01334                 if (target_id_name)
01335                         get_scd_type_name(target_id_name, tid.scd);
01336                 break;
01337         case T_USER:
01338                 strcpy(target_type_name, "USER");
01339                 if (target_id_name)
01340                         sprintf(target_id_name, "%u", tid.user);
01341                 break;
01342         case T_PROCESS:
01343                 strcpy(target_type_name, "PROCESS");
01344                 if (target_id_name)
01345                         sprintf(target_id_name, "%u", tid.process);
01346                 break;
01347         case T_GROUP:
01348                 strcpy(target_type_name, "GROUP");
01349                 if (target_id_name)
01350                         sprintf(target_id_name, "%u", tid.group);
01351                 break;
01352         case T_NETDEV:
01353                 strcpy(target_type_name, "NETDEV");
01354                 if (!target_id_name)
01355                         break;
01356                 strncpy(target_id_name, tid.netdev, RSBAC_IFNAMSIZ);
01357                 target_id_name[RSBAC_IFNAMSIZ] = 0;
01358                 break;
01359         case T_NETTEMP:
01360                 strcpy(target_type_name, "NETTEMP");
01361                 if (target_id_name)
01362                         sprintf(target_id_name, "%u", tid.nettemp);
01363                 break;
01364         case T_NETTEMP_NT:
01365                 strcpy(target_type_name, "NETTEMP_NT");
01366                 if (target_id_name)
01367                         sprintf(target_id_name, "%u", tid.nettemp);
01368                 break;
01369         case T_NONE:
01370                 strcpy(target_type_name, "NONE");
01371                 if (target_id_name)
01372                         strcpy(target_id_name, "NONE");
01373                 break;
01374         default:
01375                 strcpy(target_type_name, "ERROR!!!");
01376                 if (target_id_name)
01377                         sprintf(target_id_name, "%u", target);
01378         }
01379 #ifdef __KERNEL__
01380         rsbac_kfree(help_name);
01381 #endif
01382         return (target_type_name);
01383 }

char* get_target_name_only ( char *  target_type_name,
enum rsbac_target_t  target 
)

Definition at line 1385 of file getname.c.

References NULL, T_DEV, T_DIR, T_FD, T_FIFO, T_FILE, T_GROUP, T_IPC, T_NETDEV, T_NETOBJ, T_NETTEMP, T_NETTEMP_NT, T_NONE, T_PROCESS, T_SCD, T_SYMLINK, T_UNIXSOCK, and T_USER.

Referenced by check_comp_rc(), get_attribute_value_name(), and rsbac_rc_sys_copy_type().

01387 {
01388         if (!target_type_name)
01389                 return (NULL);
01390 
01391         switch (target) {
01392         case T_FILE:
01393                 strcpy(target_type_name, "FILE");
01394                 break;
01395         case T_DIR:
01396                 strcpy(target_type_name, "DIR");
01397                 break;
01398         case T_FIFO:
01399                 strcpy(target_type_name, "FIFO");
01400                 break;
01401         case T_SYMLINK:
01402                 strcpy(target_type_name, "SYMLINK");
01403                 break;
01404         case T_UNIXSOCK:
01405                 strcpy(target_type_name, "UNIXSOCK");
01406                 break;
01407         case T_FD:
01408                 strcpy(target_type_name, "FD");
01409                 break;
01410         case T_DEV:
01411                 strcpy(target_type_name, "DEV");
01412                 break;
01413         case T_NETOBJ:
01414                 strcpy(target_type_name, "NETOBJ");
01415                 break;
01416         case T_IPC:
01417                 strcpy(target_type_name, "IPC");
01418                 break;
01419         case T_SCD:
01420                 strcpy(target_type_name, "SCD");
01421                 break;
01422         case T_USER:
01423                 strcpy(target_type_name, "USER");
01424                 break;
01425         case T_PROCESS:
01426                 strcpy(target_type_name, "PROCESS");
01427                 break;
01428         case T_GROUP:
01429                 strcpy(target_type_name, "GROUP");
01430                 break;
01431         case T_NETDEV:
01432                 strcpy(target_type_name, "NETDEV");
01433                 break;
01434         case T_NETTEMP:
01435                 strcpy(target_type_name, "NETTEMP");
01436                 break;
01437         case T_NETTEMP_NT:
01438                 strcpy(target_type_name, "NETTEMP_NT");
01439                 break;
01440         case T_NONE:
01441                 strcpy(target_type_name, "NONE");
01442                 break;
01443         default:
01444                 strcpy(target_type_name, "ERROR!!!");
01445         };
01446         return (target_type_name);
01447 }

enum rsbac_target_t get_target_nr ( const char *  target_name  ) 

Definition at line 1449 of file getname.c.

References T_NONE, and target_list.

01450 {
01451         enum rsbac_target_t i;
01452 
01453         if (!target_name)
01454                 return (T_NONE);
01455         for (i = 0; i < T_NONE; i++) {
01456                 if (!strcmp(target_name, target_list[i])) {
01457                         return (i);
01458                 }
01459         }
01460         return (T_NONE);
01461 }


Variable Documentation

rsbac_switch_target_int_t attr_mod_list[A_none+1] [static]

Definition at line 93 of file getname.c.

Referenced by get_attr_module().

char attribute_list[A_none+1][23] [static]

Definition at line 231 of file getname.c.

Referenced by get_attribute_name(), and get_attribute_nr().

char attribute_param_list[A_none+1][194] [static]

Definition at line 488 of file getname.c.

Referenced by get_attribute_param().

char cap_list[RSBAC_CAP_MAX+1][17] [static]

Definition at line 599 of file getname.c.

Referenced by get_cap_name(), and get_cap_nr().

char error_list[RSBAC_EMAX][26] [static]

Definition at line 421 of file getname.c.

Referenced by get_error_name().

char ipc_target_list[I_none+1][9] [static]

Initial value:

 {
        "sem",
        "msg",
        "shm",
        "anonpipe",
        "mqueue",
        "anonunix",
        "none"
}

Definition at line 390 of file getname.c.

Referenced by get_ipc_target_name(), and get_ipc_target_nr().

char log_level_list[LL_invalid+1][9] [static]

Initial value:

 {
        "none",
        "denied",
        "full",
        "request",
        "invalid!"
}

Definition at line 591 of file getname.c.

Referenced by get_log_level_name(), and get_log_level_nr().

char request_list[R_NONE+1][24] [static]

Definition at line 31 of file getname.c.

Referenced by get_request_name(), and get_request_nr().

char result_list[UNDEFINED+1][12] [static]

Initial value:

 {
        "NOT_GRANTED",
        "GRANTED",
        "DO_NOT_CARE",
        "UNDEFINED"
}

Definition at line 86 of file getname.c.

Referenced by get_result_name(), and get_result_nr().

char scd_type_list[ST_none+1][17] [static]

Initial value:

 {
        "time_strucs",
        "clock",
        "host_id",
        "net_id",
        "ioports",
        "rlimit",
        "swap",
        "syslog",
        "rsbac",
        "rsbac_log",
        "other",
        "kmem",
        "network",
        "firewall",
        "priority",
        "sysfs",
        "rsbac_remote_log",
        "quota",
        "sysctl",
        "nfsd",
        "ksyms",
        "mlock",
        "capability",
        "kexec",
        "none"
}

Definition at line 457 of file getname.c.

Referenced by get_scd_type_name(), and get_scd_type_nr().

char switch_target_list[SW_NONE+1][12] [static]

Initial value:

 {
        "GEN",
        "MAC",
        "PM",
        "DAZ",
        "FF",
        "RC",
        "AUTH",
        "REG",
        "ACL",
        "CAP",
        "JAIL",
        "RES",
        "PAX",
        "SOFTMODE",
        "DAC_DISABLE",
        "UM",
        "FREEZE",
        "NONE"
}

Definition at line 400 of file getname.c.

Referenced by get_switch_target_name(), and get_switch_target_nr().

char target_list[T_NONE+1][11] [static]

Initial value:

 {
        "FILE",
        "DIR",
        "FIFO",
        "SYMLINK",
        "DEV",
        "IPC",
        "SCD",
        "USER",
        "PROCESS",
        "NETDEV",
        "NETTEMP",
        "NETOBJ",
        "NETTEMP_NT",
        "GROUP",
        "FD",
        "UNIXSOCK",
        "NONE"
}

Definition at line 370 of file getname.c.

Referenced by get_target_nr().


Generated on Wed May 16 11:54:31 2007 for RSBAC by  doxygen 1.5.1