#include <rsbac/types.h>
Go to the source code of this file.
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 * | , | |
enum | rsbac_attribute_t | |||
) |
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 * | ) |
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 * | , | |
enum | rsbac_attribute_t | |||
) |
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 | |||
) |
int get_cap_nr | ( | const char * | name | ) |
char* get_error_name | ( | char * | , | |
int | ||||
) |
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 * | , | |
enum | rsbac_ipc_type_t | |||
) |
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 * | ) |
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 * | , | |
enum | rsbac_log_level_t | |||
) |
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 * | ) |
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 * | , | |
enum | rsbac_adf_request_t | |||
) |
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 * | ) |
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 * | , | |
enum | rsbac_adf_req_ret_t | |||
) |
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 * | ) |
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 * | , | |
enum | rsbac_scd_type_t | |||
) |
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 * | ) |
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 * | , | |
enum | rsbac_switch_target_t | |||
) |
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 * | ) |
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 * | , | |
enum | rsbac_target_t, | |||
char * | , | |||
union | rsbac_target_id_t | |||
) |
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_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().
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 * | ) |
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 }