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

getname.h File Reference

#include <rsbac/types.h>

Go to the source code of this file.

Functions

char * get_request_name (char *, enum rsbac_adf_request_t)
enum rsbac_adf_request_t get_request_nr (const char *)
char * get_result_name (char *, enum rsbac_adf_req_ret_t)
enum rsbac_adf_req_ret_t get_result_nr (const char *)
enum rsbac_switch_target_t get_attr_module (enum rsbac_attribute_t attr)
char * get_attribute_name (char *, enum rsbac_attribute_t)
char * get_attribute_value_name (char *attr_val_name, enum rsbac_attribute_t attr, union rsbac_attribute_value_t *attr_val_p)
enum rsbac_attribute_t get_attribute_nr (const char *)
char * get_target_name (char *, enum rsbac_target_t, char *, union rsbac_target_id_t)
char * get_target_name_only (char *target_type_name, enum rsbac_target_t target)
enum rsbac_target_t get_target_nr (const char *)
char * get_ipc_target_name (char *, enum rsbac_ipc_type_t)
enum rsbac_ipc_type_t get_ipc_target_nr (const char *)
char * get_scd_type_name (char *, enum rsbac_scd_type_t)
enum rsbac_scd_type_t get_scd_type_nr (const char *)
char * get_switch_target_name (char *, enum rsbac_switch_target_t)
enum rsbac_switch_target_t get_switch_target_nr (const char *)
char * get_error_name (char *, int)
char * get_attribute_param (char *, enum rsbac_attribute_t)
char * get_log_level_name (char *, enum rsbac_log_level_t)
enum rsbac_log_level_t get_log_level_nr (const char *)
char * get_cap_name (char *name, u_int value)
int get_cap_nr (const char *name)

Function Documentation

enum rsbac_switch_target_t get_attr_module (  enum rsbac_attribute_t  attr  ) 
 

Definition at line 663 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().

00664   {
00665     if(attr > A_none)
00666       return SW_NONE;
00667     else
00668       return attr_mod_list[attr];
00669   }

char* get_attribute_name (  char *  ,
enum  rsbac_attribute_t
) 
 

Definition at line 677 of file getname.c.

References A_none, attribute_list, and NULL.

Referenced by rsbac_adf_request_int(), and rsbac_adf_set_attr().

00679   {
00680     if(!attr_name)
00681       return(NULL);
00682     if(attr > A_none)
00683       strcpy(attr_name, "ERROR!");
00684     else
00685       strcpy(attr_name, attribute_list[attr]);
00686     return(attr_name);
00687   }

enum rsbac_attribute_t get_attribute_nr (  const char *   ) 
 

Definition at line 689 of file getname.c.

References A_none, and attribute_list.

00690   {
00691      enum  rsbac_attribute_t i;
00692     
00693     if(!attr_name)
00694       return(A_none);
00695     for (i = 0; i < A_none; i++)
00696       {
00697         if (!strcmp(attr_name,attribute_list[i]))
00698           {
00699             return(i);
00700           }
00701       }
00702     return(A_none);
00703   }

char* get_attribute_param (  char *  ,
enum  rsbac_attribute_t
) 
 

Definition at line 1377 of file getname.c.

References A_none, attribute_param_list, and NULL.

01379   {
01380     if(!attr_name)
01381       return(NULL);
01382     if(attr > A_none)
01383       strcpy(attr_name, "ERROR!");
01384     else
01385       strcpy(attr_name, attribute_param_list[attr]);
01386     return(attr_name);
01387   }

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 711 of file getname.c.

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

Referenced by rsbac_adf_request_int().

00714   {
00715     if(!attr_val_name)
00716       return(NULL);
00717     if(attr > A_none)
00718       strcpy(attr_val_name, "ERROR!");
00719     else
00720       switch(attr)
00721         {
00722           case A_none:
00723             strcpy(attr_val_name, "none");
00724             break;
00725 #ifdef __KERNEL__
00726           case A_create_data:
00727             {
00728               char * tmp = rsbac_kmalloc(RSBAC_MAXNAMELEN);
00729 
00730               if(tmp)
00731                 {
00732                   if(attr_val_p->create_data.dentry_p)
00733                     snprintf(attr_val_name, RSBAC_MAXNAMELEN - 1,
00734                              "%s %s, mode %o",
00735                              get_target_name_only(tmp, attr_val_p->create_data.target),
00736                              attr_val_p->create_data.dentry_p->d_name.name,
00737                              attr_val_p->create_data.mode & S_IALLUGO);
00738                   else
00739                     snprintf(attr_val_name, RSBAC_MAXNAMELEN - 1,
00740                              "%s, mode %o",
00741                              get_target_name_only(tmp, attr_val_p->create_data.target),
00742                              attr_val_p->create_data.mode & S_IALLUGO);
00743                   rsbac_kfree(tmp);
00744                 }
00745             }
00746             break;
00747           case A_mode:
00748             sprintf(attr_val_name, "%o", attr_val_p->mode);
00749             break;
00750           case A_priority:
00751             sprintf(attr_val_name, "%i", attr_val_p->priority);
00752             break;
00753           case A_mod_name:
00754             if(attr_val_p->mod_name)
00755               strncpy(attr_val_name, attr_val_p->mod_name, RSBAC_MAXNAMELEN - 1);
00756             else
00757               strcpy(attr_val_name, "unknown");
00758             attr_val_name[RSBAC_MAXNAMELEN - 1] = 0;
00759             break;
00760           case A_auth_add_f_cap:
00761           case A_auth_remove_f_cap:
00762             sprintf(attr_val_name, "%u:%u",
00763                     attr_val_p->auth_cap_range.first,
00764                     attr_val_p->auth_cap_range.last);
00765             break;
00766           case A_switch_target:
00767             get_switch_target_name(attr_val_name, attr_val_p->switch_target);
00768             break;
00769           case A_request:
00770             get_request_name(attr_val_name, attr_val_p->request);
00771             break;
00772 #endif
00773 #if defined(CONFIG_RSBAC_PAX) || !defined(__KERNEL__)
00774           case A_pax_flags:
00775             pax_print_flags(attr_val_name, attr_val_p->pax_flags);
00776             break;
00777 #endif
00778           default:
00779             snprintf(attr_val_name, RSBAC_MAXNAMELEN - 1, "%u", attr_val_p->u_dummy);
00780         }
00781     return(attr_val_name);
00782   }

char* get_cap_name (  char *  name,
u_int  value
) 
 

Definition at line 1418 of file getname.c.

References cap_list, CAP_NONE, and NULL.

01420   {
01421     if(!name)
01422       return(NULL);
01423     if(value > CAP_NONE)
01424       strcpy(name, "ERROR!");
01425     else
01426       strcpy(name, cap_list[value]);
01427     return(name);
01428   }

int get_cap_nr (  const char *  name  ) 
 

Definition at line 1430 of file getname.c.

References cap_list, CAP_NONE, and RT_NONE.

01431   {
01432     int i;
01433     
01434     if(!name)
01435       return(RT_NONE);
01436     for (i = 0; i < CAP_NONE; i++)
01437       {
01438         if (!strcmp(name, cap_list[i]))
01439           {
01440             return(i);
01441           }
01442       }
01443     return(CAP_NONE);
01444   }

char* get_error_name (  char *  ,
int 
) 
 

Definition at line 1360 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(), rsbac_list_register(), rsbac_mount(), rsbac_mount_acl(), rsbac_mount_auth(), rsbac_mount_mac(), and show_error().

01362   {
01363     if(!error_name)
01364       return(NULL);
01365     if(RSBAC_ERROR(error))
01366       strcpy(error_name, error_list[(-error)-RSBAC_EPERM]);
01367     else
01368       #ifdef __KERNEL__ 
01369       inttostr(error_name, error);
01370       #else
01371       strcpy(error_name, strerror(errno));
01372       #endif
01373     return(error_name);
01374   }

char* get_ipc_target_name (  char *  ,
enum  rsbac_ipc_type_t
) 
 

Definition at line 1286 of file getname.c.

References I_none, ipc_target_list, and NULL.

01288   {
01289     if(!ipc_name)
01290       return(NULL);
01291     if(target > I_none)
01292       strcpy(ipc_name, "ERROR!");
01293     else
01294       strcpy(ipc_name, ipc_target_list[target]);
01295     return(ipc_name);
01296   }

enum rsbac_ipc_type_t get_ipc_target_nr (  const char *   ) 
 

Definition at line 1298 of file getname.c.

References I_none, and ipc_target_list.

01299   {
01300      enum  rsbac_ipc_type_t i;
01301     
01302     if(!ipc_name)
01303       return(I_none);
01304     for (i = 0; i < I_none; i++)
01305       {
01306         if (!strcmp(ipc_name,ipc_target_list[i]))
01307           {
01308             return(i);
01309           }
01310       }
01311     return(I_none);
01312   }

char* get_log_level_name (  char *  ,
enum  rsbac_log_level_t
) 
 

Definition at line 1390 of file getname.c.

References LL_invalid, log_level_list, and NULL.

01392   {
01393     if(!ll_name)
01394       return(NULL);
01395     if(target > LL_invalid)
01396       strcpy(ll_name, "ERROR!");
01397     else
01398       strcpy(ll_name, log_level_list[target]);
01399     return(ll_name);
01400   }

enum rsbac_log_level_t get_log_level_nr (  const char *   ) 
 

Definition at line 1402 of file getname.c.

References LL_invalid, and log_level_list.

01403   {
01404      enum  rsbac_log_level_t i;
01405     
01406     if(!ll_name)
01407       return(LL_invalid);
01408     for (i = 0; i < LL_invalid; i++)
01409       {
01410         if (!strcmp(ll_name,log_level_list[i]))
01411           {
01412             return(i);
01413           }
01414       }
01415     return(LL_invalid);
01416   }

char* get_request_name (  char *  ,
enum  rsbac_adf_request_t
) 
 

Definition at line 605 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().

00607   {
00608     if(!request_name)
00609       return(NULL);
00610     if(request >= R_NONE)
00611       strcpy(request_name, "ERROR!");
00612     else
00613       strcpy(request_name, request_list[request]);
00614     return(request_name);
00615   }

enum rsbac_adf_request_t get_request_nr (  const char *   ) 
 

Definition at line 617 of file getname.c.

References R_NONE, and request_list.

Referenced by get_acl_special_right_nr(), and get_rc_special_right_nr().

00618   {
00619      enum  rsbac_adf_request_t i;
00620     
00621     if(!request_name)
00622       return(R_NONE);
00623     for (i = 0; i < R_NONE; i++)
00624       {
00625         if (!strcmp(request_name,request_list[i]))
00626           {
00627             return(i);
00628           }
00629       }
00630     return(R_NONE);
00631   }

char* get_result_name (  char *  ,
enum  rsbac_adf_req_ret_t
) 
 

Definition at line 634 of file getname.c.

References NULL, result_list, and UNDEFINED.

Referenced by rsbac_adf_request_int().

00636   {
00637     if(!res_name)
00638       return(NULL);
00639     if(res > UNDEFINED)
00640       strcpy(res_name, "ERROR!");
00641     else
00642       strcpy(res_name, result_list[res]);
00643     return(res_name);
00644   }

enum rsbac_adf_req_ret_t get_result_nr (  const char *   ) 
 

Definition at line 646 of file getname.c.

References result_list, and UNDEFINED.

00647   {
00648      enum  rsbac_adf_req_ret_t i;
00649     
00650     if(!res_name)
00651       return(UNDEFINED);
00652     for (i = 0; i < UNDEFINED; i++)
00653       {
00654         if (!strcmp(res_name,result_list[i]))
00655           {
00656             return(i);
00657           }
00658       }
00659     return(UNDEFINED);
00660   }

char* get_scd_type_name (  char *  ,
enum  rsbac_scd_type_t
) 
 

Definition at line 791 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().

00793   {
00794     if(!res_name)
00795       return(NULL);
00796     if(res > ST_none)
00797       strcpy(res_name, "ERROR!");
00798     else
00799       strcpy(res_name, scd_type_list[res]);
00800     return(res_name);
00801   }

enum rsbac_scd_type_t get_scd_type_nr (  const char *   ) 
 

Definition at line 803 of file getname.c.

References scd_type_list, and ST_none.

Referenced by get_acl_scd_type_nr(), and get_rc_scd_type_nr().

00804   {
00805      enum  rsbac_scd_type_t i;
00806     
00807     if(!res_name)
00808       return(ST_none);
00809     for (i = 0; i < ST_none; i++)
00810       {
00811         if (!strcmp(res_name, scd_type_list[i]))
00812           {
00813             return(i);
00814           }
00815       }
00816     return(ST_none);
00817   }

char* get_switch_target_name (  char *  ,
enum  rsbac_switch_target_t
) 
 

Definition at line 1321 of file getname.c.

References NULL, SW_NONE, and switch_target_list.

Referenced by get_attribute_value_name(), and sys_rsbac_switch().

01323   {
01324     if(!switch_name)
01325       return(NULL);
01326     if(target > SW_NONE)
01327       strcpy(switch_name, "ERROR!");
01328     else
01329       strcpy(switch_name, switch_target_list[target]);
01330     return(switch_name);
01331   }

enum rsbac_switch_target_t get_switch_target_nr (  const char *   ) 
 

Definition at line 1333 of file getname.c.

References SW_NONE, and switch_target_list.

01334   {
01335      enum  rsbac_switch_target_t i;
01336     
01337     if(!switch_name)
01338       return(SW_NONE);
01339     for (i = 0; i < SW_NONE; i++)
01340       {
01341 #ifdef __KERNEL__
01342         if (!strncmp(switch_name,switch_target_list[i],strlen(switch_target_list[i])))
01343 #else
01344         if (!strcmp(switch_name,switch_target_list[i]))
01345 #endif
01346           {
01347             return(i);
01348           }
01349       }
01350     return(SW_NONE);
01351   }

char* get_target_name (  char *  ,
enum  rsbac_target_t,
char *  ,
union  rsbac_target_id_t
) 
 

Definition at line 826 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_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, 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_USER, rsbac_ipc_t::type, rsbac_dev_desc_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().

00830   {
00831 #ifdef __KERNEL__
00832     char * help_name;
00833 #else
00834     char help_name[RSBAC_MAXNAMELEN+4];
00835 #endif
00836 
00837     if(!target_type_name)
00838       return(NULL);
00839 
00840 #ifdef __KERNEL__
00841     #ifdef CONFIG_RSBAC_LOG_FULL_PATH
00842     help_name = rsbac_kmalloc(CONFIG_RSBAC_MAX_PATH_LEN + 4);
00843     #else
00844     help_name = rsbac_kmalloc(RSBAC_MAXNAMELEN + 4);
00845     #endif
00846     if(!help_name)
00847       return NULL;
00848 #endif
00849 
00850     switch(target)
00851       {
00852 #ifdef __KERNEL__
00853         case T_FD:      strcpy (target_type_name, "FD");
00854                         if(!target_id_name)
00855                           break;
00856                         sprintf(target_id_name, "Device %02u:%02u Inode %u",
00857                                 RSBAC_MAJOR(tid.file.device), RSBAC_MINOR(tid.file.device),
00858                                 tid.file.inode);
00859                         if(   tid.file.dentry_p
00860                            && tid.file.dentry_p->d_name.name
00861                            && tid.file.dentry_p->d_name.len
00862                           )
00863                           {
00864                             #ifdef CONFIG_RSBAC_LOG_FULL_PATH
00865                               if(rsbac_get_full_path(tid.file.dentry_p, help_name,
00866                                                CONFIG_RSBAC_MAX_PATH_LEN) > 0)
00867                                 {
00868                                   strcat(target_id_name, " Path ");
00869                                   strcat(target_id_name, help_name);
00870                                 }
00871                             #else
00872                               int namelen = rsbac_min(tid.file.dentry_p->d_name.len, RSBAC_MAXNAMELEN);
00873 
00874                               strcat(target_id_name, " Name ");
00875                               strncpy(help_name, tid.file.dentry_p->d_name.name, namelen);
00876                               help_name[namelen]=0;
00877                               strcat(target_id_name, help_name);
00878                             #endif
00879                           }
00880                         break;
00881         case T_FILE:    strcpy (target_type_name, "FILE");
00882                         if(!target_id_name)
00883                           break;
00884                         sprintf(target_id_name, "Device %02u:%02u Inode %u",
00885                                 RSBAC_MAJOR(tid.file.device), RSBAC_MINOR(tid.file.device),
00886                                 tid.file.inode);
00887                         if(   tid.file.dentry_p
00888                            && tid.file.dentry_p->d_name.name
00889                            && tid.file.dentry_p->d_name.len
00890                           )
00891                           {
00892                             #ifdef CONFIG_RSBAC_LOG_FULL_PATH
00893                               if(rsbac_get_full_path(tid.file.dentry_p, help_name,
00894                                                CONFIG_RSBAC_MAX_PATH_LEN) > 0)
00895                                 {
00896                                   strcat(target_id_name, " Path ");
00897                                   strcat(target_id_name, help_name);
00898                                 }
00899                             #else
00900                               int namelen = rsbac_min(tid.file.dentry_p->d_name.len, RSBAC_MAXNAMELEN);
00901 
00902                               strcat(target_id_name, " Name ");
00903                               strncpy(help_name, tid.file.dentry_p->d_name.name, namelen);
00904                               help_name[namelen]=0;
00905                               strcat(target_id_name, help_name);
00906                             #endif
00907                           }
00908                         break;
00909         case T_DIR:     strcpy (target_type_name, "DIR");
00910                         if(!target_id_name)
00911                           break;
00912                         sprintf(target_id_name, "Device %02u:%02u Inode %u",
00913                                 RSBAC_MAJOR(tid.file.device), RSBAC_MINOR(tid.file.device),
00914                                 tid.dir.inode);
00915                         if(   tid.dir.dentry_p
00916                            && tid.dir.dentry_p->d_name.name
00917                            && tid.dir.dentry_p->d_name.len
00918                           )
00919                           {
00920                             #ifdef CONFIG_RSBAC_LOG_FULL_PATH
00921                               if(rsbac_get_full_path(tid.dir.dentry_p, help_name,
00922                                                CONFIG_RSBAC_MAX_PATH_LEN) > 0)
00923                                 {
00924                                   strcat(target_id_name, " Path ");
00925                                   strcat(target_id_name, help_name);
00926                                 }
00927                             #else
00928                               int namelen = rsbac_min(tid.dir.dentry_p->d_name.len, RSBAC_MAXNAMELEN);
00929 
00930                               strcat(target_id_name, " Name ");
00931                               strncpy(help_name, tid.dir.dentry_p->d_name.name, namelen);
00932                               help_name[namelen]=0;
00933                               strcat(target_id_name, help_name);
00934                             #endif
00935                           }
00936                         break;
00937         case T_FIFO:    strcpy (target_type_name, "FIFO");
00938                         if(!target_id_name)
00939                           break;
00940                         sprintf(target_id_name, "Device %02u:%02u Inode %u",
00941                                 RSBAC_MAJOR(tid.file.device), RSBAC_MINOR(tid.file.device),
00942                                 tid.fifo.inode);
00943                         if(   tid.fifo.dentry_p
00944                            && tid.fifo.dentry_p->d_name.name
00945                            && tid.fifo.dentry_p->d_name.len
00946                           )
00947                           {
00948                             #ifdef CONFIG_RSBAC_LOG_FULL_PATH
00949                               if(rsbac_get_full_path(tid.fifo.dentry_p, help_name,
00950                                                CONFIG_RSBAC_MAX_PATH_LEN) > 0)
00951                                 {
00952                                   strcat(target_id_name, " Path ");
00953                                   strcat(target_id_name, help_name);
00954                                 }
00955                             #else
00956                               int namelen = rsbac_min(tid.fifo.dentry_p->d_name.len, RSBAC_MAXNAMELEN);
00957 
00958                               strcat(target_id_name, " Name ");
00959                               strncpy(help_name, tid.fifo.dentry_p->d_name.name, namelen);
00960                               help_name[namelen]=0;
00961                               strcat(target_id_name, help_name);
00962                             #endif
00963                           }
00964                         break;
00965         case T_SYMLINK: strcpy (target_type_name, "SYMLINK");
00966                         if(!target_id_name)
00967                           break;
00968                         sprintf(target_id_name, "Device %02u:%02u Inode %u",
00969                                 RSBAC_MAJOR(tid.file.device), RSBAC_MINOR(tid.file.device),
00970                                 tid.symlink.inode);
00971                         if(   tid.symlink.dentry_p
00972                            && tid.symlink.dentry_p->d_name.name
00973                            && tid.symlink.dentry_p->d_name.len
00974                           )
00975                           {
00976                             #ifdef CONFIG_RSBAC_LOG_FULL_PATH
00977                               if(rsbac_get_full_path(tid.symlink.dentry_p, help_name,
00978                                                CONFIG_RSBAC_MAX_PATH_LEN) > 0)
00979                                 {
00980                                   strcat(target_id_name, " Path ");
00981                                   strcat(target_id_name, help_name);
00982                                 }
00983                             #else
00984                               int namelen = rsbac_min(tid.symlink.dentry_p->d_name.len, RSBAC_MAXNAMELEN);
00985 
00986                               strcat(target_id_name, " Name ");
00987                               strncpy(help_name, tid.symlink.dentry_p->d_name.name, namelen);
00988                               help_name[namelen]=0;
00989                               strcat(target_id_name, help_name);
00990                             #endif
00991                           }
00992                         break;
00993         case T_DEV:     strcpy (target_type_name, "DEV");
00994                         if(!target_id_name)
00995                           break;
00996                         switch(tid.dev.type)
00997                           {
00998                             case D_block:
00999                               sprintf(target_id_name, "block %02u:%02u",
01000                                       tid.dev.major, tid.dev.minor);
01001                               break;
01002                             case D_char:
01003                               sprintf(target_id_name, "char %02u:%02u",
01004                                       tid.dev.major, tid.dev.minor);
01005                               break;
01006                             case D_block_major:
01007                               sprintf(target_id_name, "block major %02u",
01008                                       tid.dev.major);
01009                               break;
01010                             case D_char_major:
01011                               sprintf(target_id_name, "char major %02u",
01012                                       tid.dev.major);
01013                               break;
01014                             default:
01015                               sprintf(target_id_name, "*unknown* %02u:%02u",
01016                                       tid.dev.major, tid.dev.minor);
01017                           }
01018                         break;
01019         case T_NETOBJ:  strcpy (target_type_name, "NETOBJ");
01020                         if(!target_id_name)
01021                           break;
01022 #ifdef CONFIG_NET
01023                         if(   tid.netobj.sock_p
01024                            && tid.netobj.sock_p->ops
01025                            && tid.netobj.sock_p->sk
01026                           )
01027                           {
01028                             char type_name[RSBAC_MAXNAMELEN];
01029 
01030                             switch(tid.netobj.sock_p->ops->family)
01031                               {
01032                                 case AF_INET:
01033                                   {
01034                                     __u32 saddr;
01035                                     __u16 sport;
01036                                     __u32 daddr;
01037                                     __u16 dport;
01038                                     struct net_device *dev;
01039                                     char ldevname[RSBAC_IFNAMSIZ+10];
01040                                     char rdevname[RSBAC_IFNAMSIZ+10];
01041 
01042                                     if(tid.netobj.local_addr)
01043                                       {
01044                                         struct sockaddr_in * addr = tid.netobj.local_addr;
01045 
01046                                         saddr = addr->sin_addr.s_addr;
01047                                         sport = ntohs(addr->sin_port);
01048                                       }
01049                                     else
01050                                       {
01051 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
01052                                         saddr = inet_sk(tid.netobj.sock_p->sk)->saddr;
01053                                         sport = inet_sk(tid.netobj.sock_p->sk)->num;
01054 #else
01055                                         saddr = tid.netobj.sock_p->sk->saddr;
01056                                         sport = tid.netobj.sock_p->sk->num;
01057 #endif
01058                                       }
01059                                     if(tid.netobj.remote_addr)
01060                                       {
01061                                         struct sockaddr_in * addr = tid.netobj.remote_addr;
01062 
01063                                         daddr = addr->sin_addr.s_addr;
01064                                         dport = ntohs(addr->sin_port);
01065                                       }
01066                                     else
01067                                       {
01068 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
01069                                         daddr = inet_sk(tid.netobj.sock_p->sk)->daddr;
01070                                         dport = ntohs(inet_sk(tid.netobj.sock_p->sk)->dport);
01071 #else
01072                                         daddr = tid.netobj.sock_p->sk->daddr;
01073                                         dport = ntohs(tid.netobj.sock_p->sk->dport);
01074 #endif
01075                                       }
01076                                     dev = ip_dev_find(saddr);
01077                                     if(dev)
01078                                       {
01079                                         sprintf(ldevname, "%s:", dev->name);
01080                                         dev_put(dev);
01081                                       }
01082                                     else
01083                                       ldevname[0] = 0;
01084                                     dev = ip_dev_find(daddr);
01085                                     if(dev)
01086                                       {
01087                                         sprintf(rdevname, "%s:", dev->name);
01088                                         dev_put(dev);
01089                                       }
01090                                     else
01091                                       rdevname[0] = 0;
01092                                     sprintf(target_id_name, "%p INET %s proto %s local %s%u.%u.%u.%u:%u remote %s%u.%u.%u.%u:%u",
01093                                             tid.netobj.sock_p,
01094                                             rsbac_get_net_type_name(type_name,
01095                                                                     tid.netobj.sock_p->type),
01096 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
01097                                             rsbac_get_net_protocol_name(help_name,
01098                                                                         tid.netobj.sock_p->sk->sk_protocol),
01099 #else
01100                                             rsbac_get_net_protocol_name(help_name,
01101                                                                         tid.netobj.sock_p->sk->protocol),
01102 #endif
01103                                             ldevname,
01104                                             NIPQUAD(saddr),
01105                                             sport,
01106                                             rdevname,
01107                                             NIPQUAD(daddr),
01108                                             dport);
01109                                   }
01110                                   break;
01111                                 case AF_UNIX:
01112 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
01113                                   if(unix_sk(tid.netobj.sock_p->sk)->addr)
01114                                     sprintf(target_id_name, "%p UNIX %s %s",
01115                                             tid.netobj.sock_p,
01116                                             rsbac_get_net_type_name(type_name,
01117                                                                     tid.netobj.sock_p->type),
01118                                             unix_sk(tid.netobj.sock_p->sk)->addr->name[0].sun_path);
01119 #else
01120                                   if(tid.netobj.sock_p->sk->protinfo.af_unix.addr)
01121                                     sprintf(target_id_name, "%p UNIX %s %s",
01122                                             tid.netobj.sock_p,
01123                                             rsbac_get_net_type_name(type_name,
01124                                                                     tid.netobj.sock_p->type),
01125                                             tid.netobj.sock_p->sk->protinfo.af_unix.addr->name[0].sun_path);
01126 #endif
01127                                   else
01128                                   if(tid.netobj.local_addr)
01129                                     {
01130                                       struct sockaddr_un * addr = tid.netobj.local_addr;
01131 
01132                                       sprintf(target_id_name, "%p UNIX %s %s",
01133                                               tid.netobj.sock_p,
01134                                               rsbac_get_net_type_name(type_name,
01135                                                                       tid.netobj.sock_p->type),
01136                                               addr->sun_path);
01137                                     }
01138                                   else
01139                                     sprintf(target_id_name, "%p UNIX %s",
01140                                             tid.netobj.sock_p,
01141                                             rsbac_get_net_type_name(type_name,
01142                                                                     tid.netobj.sock_p->type));
01143                                   break;
01144                                 default:
01145                                   sprintf(target_id_name, "%p %s %s",
01146                                           tid.netobj.sock_p,
01147                                           rsbac_get_net_family_name(help_name,
01148                                                                     tid.netobj.sock_p->ops->family),
01149                                           rsbac_get_net_type_name(type_name,
01150                                                                   tid.netobj.sock_p->type));
01151                               }
01152                           }
01153                         else
01154 #endif /* CONFIG_NET */
01155                           {
01156                             sprintf(target_id_name, "%p", tid.netobj.sock_p);
01157                           }
01158                         break;
01159 #endif /* __KERNEL__ */
01160         case T_IPC:     strcpy (target_type_name, "IPC");
01161                         if(!target_id_name)
01162                           break;
01163                         switch (tid.ipc.type)
01164                           {
01165                             case I_sem: strcpy(target_id_name, "Sem-ID ");
01166                                         break;
01167                             case I_msg: strcpy(target_id_name, "Msg-ID ");
01168                                         break;
01169                             case I_shm: strcpy(target_id_name, "Shm-ID ");
01170                                         break;
01171                             case I_anonpipe: strcpy(target_id_name, "AnonPipe-ID ");
01172                                         break;
01173                             case I_mqueue: strcpy(target_id_name, "Mqueue-ID ");
01174                                         break;
01175                             default:    strcpy(target_id_name, "???-ID ");
01176                                         break;
01177                           };
01178                         sprintf(help_name, "%lu", tid.ipc.id.id_nr);
01179                         strcat(target_id_name, help_name);
01180                         break;
01181         case T_SCD:     strcpy (target_type_name, "SCD");
01182                         if(target_id_name)
01183                           get_scd_type_name(target_id_name, tid.scd);
01184                         break;
01185         case T_USER:    strcpy (target_type_name, "USER");
01186                         if(target_id_name)
01187                           sprintf(target_id_name, "%u", tid.user);
01188                         break;
01189         case T_PROCESS: strcpy (target_type_name, "PROCESS");
01190                         if(target_id_name)
01191                           sprintf(target_id_name, "%u", tid.process);
01192                         break;
01193         case T_GROUP:   strcpy (target_type_name, "GROUP");
01194                         if(target_id_name)
01195                           sprintf(target_id_name, "%u", tid.group);
01196                         break;
01197         case T_NETDEV:  strcpy (target_type_name, "NETDEV");
01198                         if(!target_id_name)
01199                           break;
01200                         strncpy(target_id_name, tid.netdev, RSBAC_IFNAMSIZ);
01201                         target_id_name[RSBAC_IFNAMSIZ] = 0;
01202                         break;
01203         case T_NETTEMP: strcpy (target_type_name, "NETTEMP");
01204                         if(target_id_name)
01205                           sprintf(target_id_name, "%u", tid.nettemp);
01206                         break;
01207         case T_NETTEMP_NT: strcpy (target_type_name, "NETTEMP_NT");
01208                         if(target_id_name)
01209                           sprintf(target_id_name, "%u", tid.nettemp);
01210                         break;
01211         case T_NONE:    strcpy (target_type_name, "NONE");
01212                         if(target_id_name)
01213                           strcpy (target_id_name, "NONE");
01214                         break;
01215         default:        strcpy (target_type_name, "ERROR!!!");
01216                         if(target_id_name)
01217                           sprintf(target_id_name, "%u", target);
01218       }
01219 #ifdef __KERNEL__
01220     rsbac_kfree(help_name);
01221 #endif
01222     return(target_type_name);
01223   }

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

Definition at line 1225 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, and T_USER.

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

01227   {
01228     if(!target_type_name)
01229       return(NULL);
01230 
01231     switch(target)
01232       {
01233         case T_FILE:    strcpy (target_type_name, "FILE");
01234                         break;
01235         case T_DIR:     strcpy (target_type_name, "DIR");
01236                         break;
01237         case T_FIFO:    strcpy (target_type_name, "FIFO");
01238                         break;
01239         case T_SYMLINK: strcpy (target_type_name, "SYMLINK");
01240                         break;
01241         case T_FD:      strcpy (target_type_name, "FD");
01242                         break;
01243         case T_DEV:     strcpy (target_type_name, "DEV");
01244                         break;
01245         case T_NETOBJ:  strcpy (target_type_name, "NETOBJ");
01246                         break;
01247         case T_IPC:     strcpy (target_type_name, "IPC");
01248                         break;
01249         case T_SCD:     strcpy (target_type_name, "SCD");
01250                         break;
01251         case T_USER:    strcpy (target_type_name, "USER");
01252                         break;
01253         case T_PROCESS: strcpy (target_type_name, "PROCESS");
01254                         break;
01255         case T_GROUP:   strcpy (target_type_name, "GROUP");
01256                         break;
01257         case T_NETDEV:  strcpy (target_type_name, "NETDEV");
01258                         break;
01259         case T_NETTEMP: strcpy (target_type_name, "NETTEMP");
01260                         break;
01261         case T_NETTEMP_NT: strcpy (target_type_name, "NETTEMP_NT");
01262                         break;
01263         case T_NONE:    strcpy (target_type_name, "NONE");
01264                         break;
01265         default:        strcpy (target_type_name, "ERROR!!!");
01266       };
01267     return(target_type_name);
01268   }

enum rsbac_target_t get_target_nr (  const char *   ) 
 

Definition at line 1270 of file getname.c.

References T_NONE, and target_list.

01271   {
01272      enum  rsbac_target_t i;
01273     
01274     if(!target_name)
01275       return(T_NONE);
01276     for (i = 0; i < T_NONE; i++)
01277       {
01278         if (!strcmp(target_name,target_list[i]))
01279           {
01280             return(i);
01281           }
01282       }
01283     return(T_NONE);
01284   }

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