avrule_query.h File Reference

00037 {
00038         policydb_t *db;
00039         avtab_state_t *state;
00040 
00041         if (iter) {
00042                 *iter = NULL;
00043         }
00044         if (policy == NULL || iter == NULL) {
00045                 ERR(policy, "%s", strerror(EINVAL));
00046                 errno = EINVAL;
00047                 return STATUS_ERR;
00048         }
00049 
00050         if (!qpol_policy_has_capability(policy, QPOL_CAP_RULES_LOADED)) {
00051                 ERR(policy, "%s", "Cannot get avrules: Rules not loaded");
00052                 errno = ENOTSUP;
00053                 return STATUS_ERR;
00054         }
00055 
00056         if ((rule_type_mask & QPOL_RULE_NEVERALLOW) && !qpol_policy_has_capability(policy, QPOL_CAP_NEVERALLOW)) {
00057                 ERR(policy, "%s", "Cannot get avrules: Neverallow rules requested but not available");
00058                 errno = ENOTSUP;
00059                 return STATUS_ERR;
00060         }
00061 
00062         db = &policy->p->p;
00063 
00064         state = calloc(1, sizeof(avtab_state_t));
00065         if (state == NULL) {
00066                 ERR(policy, "%s", strerror(ENOMEM));
00067                 errno = ENOMEM;
00068                 return STATUS_ERR;
00069         }
00070         state->ucond_tab = &db->te_avtab;
00071         state->cond_tab = &db->te_cond_avtab;
00072         state->rule_type_mask = rule_type_mask;
00073         state->node = db->te_avtab.htable[0];
00074 
00075         if (qpol_iterator_create
00076             (policy, state, avtab_state_get_cur, avtab_state_next, avtab_state_end, avtab_state_size, free, iter)) {
00077                 free(state);
00078                 return STATUS_ERR;
00079         }
00080         if (state->node == NULL || !(state->node->key.specified & state->rule_type_mask)) {
00081                 avtab_state_next(*iter);
00082         }
00083         return STATUS_SUCCESS;
00084 }

00087 {
00088         policydb_t *db = NULL;
00089         avtab_ptr_t avrule = NULL;
00090 
00091         if (source) {
00092                 *source = NULL;
00093         }
00094 
00095         if (!policy || !rule || !source) {
00096                 ERR(policy, "%s", strerror(EINVAL));
00097                 errno = EINVAL;
00098                 return STATUS_ERR;
00099         }
00100 
00101         db = &policy->p->p;
00102         avrule = (avtab_ptr_t) rule;
00103 
00104         *source = (qpol_type_t *) db->type_val_to_struct[avrule->key.source_type - 1];
00105 
00106         return STATUS_SUCCESS;
00107 }

00110 {
00111         policydb_t *db = NULL;
00112         avtab_ptr_t avrule = NULL;
00113 
00114         if (target) {
00115                 *target = NULL;
00116         }
00117 
00118         if (!policy || !rule || !target) {
00119                 ERR(policy, "%s", strerror(EINVAL));
00120                 errno = EINVAL;
00121                 return STATUS_ERR;
00122         }
00123 
00124         db = &policy->p->p;
00125         avrule = (avtab_ptr_t) rule;
00126 
00127         *target = (qpol_type_t *) db->type_val_to_struct[avrule->key.target_type - 1];
00128 
00129         return STATUS_SUCCESS;
00130 }

00133 {
00134         policydb_t *db = NULL;
00135         avtab_ptr_t avrule = NULL;
00136 
00137         if (obj_class) {
00138                 *obj_class = NULL;
00139         }
00140 
00141         if (!policy || !rule || !obj_class) {
00142                 ERR(policy, "%s", strerror(EINVAL));
00143                 errno = EINVAL;
00144                 return STATUS_ERR;
00145         }
00146 
00147         db = &policy->p->p;
00148         avrule = (avtab_ptr_t) rule;
00149 
00150         *obj_class = (qpol_class_t *) db->class_val_to_struct[avrule->key.target_class - 1];
00151 
00152         return STATUS_SUCCESS;
00153 }

00156 {
00157         policydb_t *db = NULL;
00158         avtab_ptr_t avrule = NULL;
00159         perm_state_t *ps = NULL;
00160 
00161         if (perms) {
00162                 *perms = NULL;
00163         }
00164 
00165         if (!policy || !rule || !perms) {
00166                 ERR(policy, "%s", strerror(EINVAL));
00167                 errno = EINVAL;
00168                 return STATUS_ERR;
00169         }
00170 
00171         db = &policy->p->p;
00172         avrule = (avtab_ptr_t) rule;
00173         ps = calloc(1, sizeof(perm_state_t));
00174         if (!ps) {
00175                 return STATUS_ERR;
00176         }
00177         if (avrule->key.specified & QPOL_RULE_DONTAUDIT) {
00178                 ps->perm_set = ~(avrule->datum.data);   /* stored as auditdeny flip the bits */
00179         } else {
00180                 ps->perm_set = avrule->datum.data;
00181         }
00182         ps->obj_class_val = avrule->key.target_class;
00183 
00184         if (qpol_iterator_create(policy, (void *)ps, perm_state_get_cur,
00185                                  perm_state_next, perm_state_end, perm_state_size, free, perms)) {
00186                 return STATUS_ERR;
00187         }
00188 
00189         if (!(ps->perm_set & 1))       /* defaults to bit 0, if off: advance */
00190                 perm_state_next(*perms);
00191 
00192         return STATUS_SUCCESS;
00193 }

00196 {
00197         policydb_t *db = NULL;
00198         avtab_ptr_t avrule = NULL;
00199 
00200         if (rule_type) {
00201                 *rule_type = 0;
00202         }
00203 
00204         if (!policy || !rule || !rule_type) {
00205                 ERR(policy, "%s", strerror(EINVAL));
00206                 errno = EINVAL;
00207                 return STATUS_ERR;
00208         }
00209 
00210         db = &policy->p->p;
00211         avrule = (avtab_ptr_t) rule;
00212 
00213         *rule_type =
00214                 (avrule->key.specified & (QPOL_RULE_ALLOW | QPOL_RULE_NEVERALLOW | QPOL_RULE_AUDITALLOW | QPOL_RULE_DONTAUDIT));
00215 
00216         return STATUS_SUCCESS;
00217 }

00220 {
00221         avtab_ptr_t avrule = NULL;
00222 
00223         if (cond) {
00224                 *cond = NULL;
00225         }
00226 
00227         if (!policy || !rule || !cond) {
00228                 ERR(policy, "%s", strerror(EINVAL));
00229                 errno = EINVAL;
00230                 return STATUS_ERR;
00231         }
00232 
00233         avrule = (avtab_ptr_t) rule;
00234 
00235         *cond = (qpol_cond_t *) avrule->parse_context;
00236 
00237         return STATUS_SUCCESS;
00238 }

00241 {
00242         avtab_ptr_t avrule = NULL;
00243 
00244         if (is_enabled) {
00245                 *is_enabled = 0;
00246         }
00247 
00248         if (!policy || !rule || !is_enabled) {
00249                 ERR(policy, "%s", strerror(EINVAL));
00250                 errno = EINVAL;
00251                 return STATUS_ERR;
00252         }
00253 
00254         avrule = (avtab_ptr_t) rule;
00255 
00256         *is_enabled = ((avrule->merged & QPOL_COND_RULE_ENABLED) ? 1 : 0);
00257 
00258         return STATUS_SUCCESS;
00259 }

00262 {
00263         avtab_ptr_t avrule = NULL;
00264 
00265         if (which_list) {
00266                 *which_list = 0;
00267         }
00268 
00269         if (!policy || !rule || !which_list) {
00270                 ERR(policy, "%s", strerror(EINVAL));
00271                 errno = EINVAL;
00272                 return STATUS_ERR;
00273         }
00274 
00275         avrule = (avtab_ptr_t) rule;
00276 
00277         if (!avrule->parse_context) {
00278                 ERR(policy, "%s", strerror(EINVAL));
00279                 errno = EINVAL;
00280                 return STATUS_ERR;
00281         }
00282 
00283         *which_list = ((avrule->merged & QPOL_COND_RULE_LIST) ? 1 : 0);
00284 
00285         return STATUS_SUCCESS;
00286 }