Main Page | Alphabetical List | Data Structures | Directories | File List | Data Fields | Globals | Search for 
linux-2.6.16-rsbac-1.2.6 / 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 667 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().

00668   {
00669     if(attr > A_none)
00670       return SW_NONE;
00671     else
00672       return attr_mod_list[attr];
00673   }

char* get_attribute_name (  char *  ,
enum  rsbac_attribute_t
) 
 

Definition at line 681 of file getname.c.

References A_none, attribute_list, and NULL.

Referenced by rsbac_adf_request_int(), and rsbac_adf_set_attr().

00683   {
00684     if(!attr_name)
00685       return(NULL);
00686     if(attr > A_none)
00687       strcpy(attr_name, "ERROR!");
00688     else
00689       strcpy(attr_name, attribute_list[attr]);
00690     return(attr_name);
00691   }

enum rsbac_attribute_t get_attribute_nr (  const char *   ) 
 

Definition at line 693 of file getname.c.

References A_none, and attribute_list.

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

char* get_attribute_param (  char *  ,
enum  rsbac_attribute_t
) 
 

Definition at line 1381 of file getname.c.

References A_none, attribute_param_list, and NULL.

01383   {
01384     if(!attr_name)
01385       return(NULL);
01386     if(attr > A_none)
01387       strcpy(attr_name, "ERROR!");
01388     else
01389       strcpy(attr_name, attribute_param_list[attr]);
01390     return(attr_name);
01391   }

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 715 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().

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

char* get_cap_name (  char *  name,
u_int  value
) 
 

Definition at line 1422 of file getname.c.

References cap_list, CAP_NONE, and NULL.

01424   {
01425     if(!name)
01426       return(NULL);
01427     if(value > CAP_NONE)
01428       strcpy(name, "ERROR!");
01429     else
01430       strcpy(name, cap_list[value]);
01431     return(name);
01432   }

int get_cap_nr (  const char *  name  ) 
 

Definition at line 1434 of file getname.c.

References cap_list, CAP_NONE, and RT_NONE.

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

char* get_error_name (  char *  ,
int 
) 
 

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

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

char* get_ipc_target_name (  char *  ,
enum  rsbac_ipc_type_t
) 
 

Definition at line 1290 of file getname.c.

References I_none, ipc_target_list, and NULL.

01292   {
01293     if(!ipc_name)
01294       return(NULL);
01295     if(target > I_none)
01296       strcpy(ipc_name, "ERROR!");
01297     else
01298       strcpy(ipc_name, ipc_target_list[target]);
01299     return(ipc_name);
01300   }

enum rsbac_ipc_type_t get_ipc_target_nr (  const char *   ) 
 

Definition at line 1302 of file getname.c.

References I_none, and ipc_target_list.

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

char* get_log_level_name (  char *  ,
enum  rsbac_log_level_t
) 
 

Definition at line 1394 of file getname.c.

References LL_invalid, log_level_list, and NULL.

01396   {
01397     if(!ll_name)
01398       return(NULL);
01399     if(target > LL_invalid)
01400       strcpy(ll_name, "ERROR!");
01401     else
01402       strcpy(ll_name, log_level_list[target]);
01403     return(ll_name);
01404   }

enum rsbac_log_level_t get_log_level_nr (  const char *   ) 
 

Definition at line 1406 of file getname.c.

References LL_invalid, and log_level_list.

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

char* get_request_name (  char *  ,
enum  rsbac_adf_request_t
) 
 

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

00611   {
00612     if(!request_name)
00613       return(NULL);
00614     if(request >= R_NONE)
00615       strcpy(request_name, "ERROR!");
00616     else
00617       strcpy(request_name, request_list[request]);
00618     return(request_name);
00619   }

enum rsbac_adf_request_t get_request_nr (  const char *   ) 
 

Definition at line 621 of file getname.c.

References R_NONE, and request_list.

Referenced by get_acl_special_right_nr(), and get_rc_special_right_nr().

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

char* get_result_name (  char *  ,
enum  rsbac_adf_req_ret_t
) 
 

Definition at line 638 of file getname.c.

References NULL, result_list, and UNDEFINED.

Referenced by rsbac_adf_request_int().

00640   {
00641     if(!res_name)
00642       return(NULL);
00643     if(res > UNDEFINED)
00644       strcpy(res_name, "ERROR!");
00645     else
00646       strcpy(res_name, result_list[res]);
00647     return(res_name);
00648   }

enum rsbac_adf_req_ret_t get_result_nr (  const char *   ) 
 

Definition at line 650 of file getname.c.

References result_list, and UNDEFINED.

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

char* get_scd_type_name (  char *  ,
enum  rsbac_scd_type_t
) 
 

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

00797   {
00798     if(!res_name)
00799       return(NULL);
00800     if(res > ST_none)
00801       strcpy(res_name, "ERROR!");
00802     else
00803       strcpy(res_name, scd_type_list[res]);
00804     return(res_name);
00805   }

enum rsbac_scd_type_t get_scd_type_nr (  const char *   ) 
 

Definition at line 807 of file getname.c.

References scd_type_list, and ST_none.

Referenced by get_acl_scd_type_nr(), and get_rc_scd_type_nr().

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

char* get_switch_target_name (  char *  ,
enum  rsbac_switch_target_t
) 
 

Definition at line 1325 of file getname.c.

References NULL, SW_NONE, and switch_target_list.

Referenced by get_attribute_value_name(), and sys_rsbac_switch().

01327   {
01328     if(!switch_name)
01329       return(NULL);
01330     if(target > SW_NONE)
01331       strcpy(switch_name, "ERROR!");
01332     else
01333       strcpy(switch_name, switch_target_list[target]);
01334     return(switch_name);
01335   }

enum rsbac_switch_target_t get_switch_target_nr (  const char *   ) 
 

Definition at line 1337 of file getname.c.

References SW_NONE, and switch_target_list.

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

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

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

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

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

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

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

enum rsbac_target_t get_target_nr (  const char *   ) 
 

Definition at line 1274 of file getname.c.

References T_NONE, and target_list.

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

Generated on Sun May 21 14:30:58 2006 for RSBAC by  doxygen 1.4.2