Home | History | Annotate | Download | only in src 
      1 /* Copyright (C) 2005 Red Hat, Inc. */
      2 
      3 /* Object: semanage_node_t (Network Port)
      4  * Object: semanage_node_key_t (Network Port Key)
      5  * Implements: record_t (Database Record)
      6  * Implements: record_key_t (Database Record Key)
      7  */
      8 
      9 #include <sepol/context_record.h>
     10 #include <sepol/node_record.h>
     11 #include <stddef.h>
     12 
     13 typedef sepol_context_t semanage_context_t;
     14 typedef sepol_node_t semanage_node_t;
     15 typedef sepol_node_key_t semanage_node_key_t;
     16 #define _SEMANAGE_NODE_DEFINED_
     17 #define _SEMANAGE_CONTEXT_DEFINED_
     18 
     19 typedef semanage_node_t record_t;
     20 typedef semanage_node_key_t record_key_t;
     21 #define DBASE_RECORD_DEFINED
     22 
     23 #include "node_internal.h"
     24 #include "handle.h"
     25 #include "database.h"
     26 
     27 /* Key */
     28 int semanage_node_compare(const semanage_node_t * node,
     29 			  const semanage_node_key_t * key)
     30 {
     31 
     32 	return sepol_node_compare(node, key);
     33 }
     34 
     35 hidden_def(semanage_node_compare)
     36 
     37 int semanage_node_compare2(const semanage_node_t * node,
     38 			   const semanage_node_t * node2)
     39 {
     40 
     41 	return sepol_node_compare2(node, node2);
     42 }
     43 
     44 hidden_def(semanage_node_compare2)
     45 
     46 hidden int semanage_node_compare2_qsort(const semanage_node_t ** node,
     47 					const semanage_node_t ** node2)
     48 {
     49 
     50 	return sepol_node_compare2(*node, *node2);
     51 }
     52 
     53 int semanage_node_key_create(semanage_handle_t * handle,
     54 			     const char *addr,
     55 			     const char *mask,
     56 			     int proto, semanage_node_key_t ** key_ptr)
     57 {
     58 
     59 	return sepol_node_key_create(handle->sepolh, addr, mask, proto,
     60 				     key_ptr);
     61 }
     62 
     63 int semanage_node_key_extract(semanage_handle_t * handle,
     64 			      const semanage_node_t * node,
     65 			      semanage_node_key_t ** key_ptr)
     66 {
     67 
     68 	return sepol_node_key_extract(handle->sepolh, node, key_ptr);
     69 }
     70 
     71 hidden_def(semanage_node_key_extract)
     72 
     73 void semanage_node_key_free(semanage_node_key_t * key)
     74 {
     75 
     76 	sepol_node_key_free(key);
     77 }
     78 
     79 hidden_def(semanage_node_key_free)
     80 
     81 /* Address */
     82 int semanage_node_get_addr(semanage_handle_t * handle,
     83 			   const semanage_node_t * node, char **addr_ptr)
     84 {
     85 
     86 	return sepol_node_get_addr(handle->sepolh, node, addr_ptr);
     87 }
     88 
     89 hidden_def(semanage_node_get_addr)
     90 
     91 int semanage_node_get_addr_bytes(semanage_handle_t * handle,
     92 				 const semanage_node_t * node,
     93 				 char **addr, size_t * addr_sz)
     94 {
     95 
     96 	return sepol_node_get_addr_bytes(handle->sepolh, node, addr, addr_sz);
     97 }
     98 
     99 hidden_def(semanage_node_get_addr_bytes)
    100 
    101 int semanage_node_set_addr(semanage_handle_t * handle,
    102 			   semanage_node_t * node, int proto, const char *addr)
    103 {
    104 
    105 	return sepol_node_set_addr(handle->sepolh, node, proto, addr);
    106 }
    107 
    108 hidden_def(semanage_node_set_addr)
    109 
    110 int semanage_node_set_addr_bytes(semanage_handle_t * handle,
    111 				 semanage_node_t * node,
    112 				 const char *addr, size_t addr_sz)
    113 {
    114 
    115 	return sepol_node_set_addr_bytes(handle->sepolh, node, addr, addr_sz);
    116 }
    117 
    118 hidden_def(semanage_node_set_addr_bytes)
    119 
    120 /* Netmask */
    121 int semanage_node_get_mask(semanage_handle_t * handle,
    122 			   const semanage_node_t * node, char **mask_ptr)
    123 {
    124 
    125 	return sepol_node_get_mask(handle->sepolh, node, mask_ptr);
    126 }
    127 
    128 hidden_def(semanage_node_get_mask)
    129 
    130 int semanage_node_get_mask_bytes(semanage_handle_t * handle,
    131 				 const semanage_node_t * node,
    132 				 char **mask, size_t * mask_sz)
    133 {
    134 
    135 	return sepol_node_get_mask_bytes(handle->sepolh, node, mask, mask_sz);
    136 }
    137 
    138 hidden_def(semanage_node_get_mask_bytes)
    139 
    140 int semanage_node_set_mask(semanage_handle_t * handle,
    141 			   semanage_node_t * node, int proto, const char *mask)
    142 {
    143 
    144 	return sepol_node_set_mask(handle->sepolh, node, proto, mask);
    145 }
    146 
    147 hidden_def(semanage_node_set_mask)
    148 
    149 int semanage_node_set_mask_bytes(semanage_handle_t * handle,
    150 				 semanage_node_t * node,
    151 				 const char *mask, size_t mask_sz)
    152 {
    153 
    154 	return sepol_node_set_mask_bytes(handle->sepolh, node, mask, mask_sz);
    155 }
    156 
    157 hidden_def(semanage_node_set_mask_bytes)
    158 
    159 /* Protocol */
    160 int semanage_node_get_proto(const semanage_node_t * node)
    161 {
    162 
    163 	return sepol_node_get_proto(node);
    164 }
    165 
    166 hidden_def(semanage_node_get_proto)
    167 
    168 void semanage_node_set_proto(semanage_node_t * node, int proto)
    169 {
    170 
    171 	sepol_node_set_proto(node, proto);
    172 }
    173 
    174 hidden_def(semanage_node_set_proto)
    175 
    176 const char *semanage_node_get_proto_str(int proto)
    177 {
    178 
    179 	return sepol_node_get_proto_str(proto);
    180 }
    181 
    182 hidden_def(semanage_node_get_proto_str)
    183 
    184 /* Context */
    185 semanage_context_t *semanage_node_get_con(const semanage_node_t * node)
    186 {
    187 
    188 	return sepol_node_get_con(node);
    189 }
    190 
    191 hidden_def(semanage_node_get_con)
    192 
    193 int semanage_node_set_con(semanage_handle_t * handle,
    194 			  semanage_node_t * node, semanage_context_t * con)
    195 {
    196 
    197 	return sepol_node_set_con(handle->sepolh, node, con);
    198 }
    199 
    200 hidden_def(semanage_node_set_con)
    201 
    202 /* Create/Clone/Destroy */
    203 int semanage_node_create(semanage_handle_t * handle,
    204 			 semanage_node_t ** node_ptr)
    205 {
    206 
    207 	return sepol_node_create(handle->sepolh, node_ptr);
    208 }
    209 
    210 hidden_def(semanage_node_create)
    211 
    212 int semanage_node_clone(semanage_handle_t * handle,
    213 			const semanage_node_t * node,
    214 			semanage_node_t ** node_ptr)
    215 {
    216 
    217 	return sepol_node_clone(handle->sepolh, node, node_ptr);
    218 }
    219 
    220 hidden_def(semanage_node_clone)
    221 
    222 void semanage_node_free(semanage_node_t * node)
    223 {
    224 
    225 	sepol_node_free(node);
    226 }
    227 
    228 hidden_def(semanage_node_free)
    229 
    230 /* Port base functions */
    231 record_table_t SEMANAGE_NODE_RTABLE = {
    232 	.create = semanage_node_create,
    233 	.key_extract = semanage_node_key_extract,
    234 	.key_free = semanage_node_key_free,
    235 	.clone = semanage_node_clone,
    236 	.compare = semanage_node_compare,
    237 	.compare2 = semanage_node_compare2,
    238 	.compare2_qsort = semanage_node_compare2_qsort,
    239 	.free = semanage_node_free,
    240 };
    241