00001
00002
00003
00004
00005
00006
00007
00008
00009 #include <linux/types.h>
00010 #include <linux/sched.h>
00011 #include <linux/fs.h>
00012 #include <asm/uaccess.h>
00013 #include <linux/file.h>
00014 #include <linux/vmalloc.h>
00015 #include <linux/init.h>
00016 #include <rsbac/types.h>
00017 #include <rsbac/pm_types.h>
00018 #include <rsbac/pm_data_structures.h>
00019 #include <rsbac/getname.h>
00020 #include <rsbac/pm_getname.h>
00021 #include <rsbac/error.h>
00022 #include <rsbac/helpers.h>
00023 #include <rsbac/fs.h>
00024 #include <rsbac/adf.h>
00025 #include <rsbac/adf_main.h>
00026 #include <rsbac/debug.h>
00027 #include <rsbac/proc_fs.h>
00028 #include <rsbac/rkmem.h>
00029 #include <rsbac/lists.h>
00030 #include <linux/string.h>
00031
00032
00033
00034
00035
00036
00037
00038 static rsbac_list_handle_t task_set_handle = NULL;
00039 static rsbac_list_handle_t tp_set_handle = NULL;
00040 static rsbac_list_handle_t ru_set_handle = NULL;
00041 static rsbac_list_handle_t pp_set_handle = NULL;
00042 static rsbac_list_handle_t in_pp_set_handle = NULL;
00043 static rsbac_list_handle_t out_pp_set_handle = NULL;
00044
00045 static rsbac_list_handle_t task_handle = NULL;
00046 static rsbac_list_handle_t class_handle = NULL;
00047 static rsbac_list_handle_t na_handle = NULL;
00048 static rsbac_list_handle_t cs_handle = NULL;
00049 static rsbac_list_handle_t tp_handle = NULL;
00050 static rsbac_list_handle_t pp_handle = NULL;
00051 static rsbac_list_handle_t tkt_handle = NULL;
00052
00053
00054
00055
00056
00057 int sys_write(u_int, char *, u_int);
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074 #if defined(CONFIG_RSBAC_PROC)
00075 static int
00076 stats_pm_proc_info(char *buffer, char **start, off_t offset, int length)
00077 {
00078 u_int len = 0;
00079 off_t pos = 0;
00080 off_t begin = 0;
00081
00082 u_long tmp_count;
00083 u_long tmp_member_count;
00084 u_long all_set_count = 0;
00085 u_long all_member_count = 0;
00086 u_long all_count = 0;
00087
00088 #if !defined(CONFIG_RSBAC_MAINT)
00089 union rsbac_target_id_t rsbac_target_id;
00090 union rsbac_attribute_value_t rsbac_attribute_value;
00091 #endif
00092
00093 if (!rsbac_is_initialized()) {
00094 rsbac_printk(KERN_WARNING "stats_pm_proc_info(): RSBAC not initialized\n");
00095 return (-RSBAC_ENOTINITIALIZED);
00096 }
00097 #if !defined(CONFIG_RSBAC_MAINT)
00098 rsbac_pr_debug(aef_pm, "calling ADF\n");
00099 rsbac_target_id.scd = ST_rsbac;
00100 rsbac_attribute_value.dummy = 0;
00101 if (!rsbac_adf_request(R_GET_STATUS_DATA,
00102 current->pid,
00103 T_SCD,
00104 rsbac_target_id,
00105 A_none, rsbac_attribute_value)) {
00106 #if defined(CONFIG_RSBAC_SOFTMODE)
00107 if (!rsbac_softmode)
00108 #endif
00109 return -EPERM;
00110 }
00111 #endif
00112
00113 len += sprintf(buffer, "PM Status\n---------\n");
00114
00115
00116
00117
00118
00119 tmp_count = rsbac_list_lol_count(task_set_handle);
00120 tmp_member_count = rsbac_list_lol_all_subcount(task_set_handle);
00121 len +=
00122 sprintf(buffer + len,
00123 "%lu task-set-items, sum of %lu members\n", tmp_count,
00124 tmp_member_count);
00125 pos = begin + len;
00126 if (pos < offset) {
00127 len = 0;
00128 begin = pos;
00129 }
00130 if (pos > offset + length)
00131 goto out;
00132 all_set_count += tmp_count;
00133 all_member_count += tmp_member_count;
00134
00135 tmp_count = rsbac_list_lol_count(tp_set_handle);
00136 tmp_member_count = rsbac_list_lol_all_subcount(tp_set_handle);
00137 len +=
00138 sprintf(buffer + len, "%lu tp-set-items, sum of %lu members\n",
00139 tmp_count, tmp_member_count);
00140 pos = begin + len;
00141 if (pos < offset) {
00142 len = 0;
00143 begin = pos;
00144 }
00145 if (pos > offset + length)
00146 goto out;
00147 all_set_count += tmp_count;
00148 all_member_count += tmp_member_count;
00149
00150 tmp_count = rsbac_list_lol_count(ru_set_handle);
00151 tmp_member_count = rsbac_list_lol_all_subcount(ru_set_handle);
00152 len +=
00153 sprintf(buffer + len, "%lu ru-set-items, sum of %lu members\n",
00154 tmp_count, tmp_member_count);
00155 pos = begin + len;
00156 if (pos < offset) {
00157 len = 0;
00158 begin = pos;
00159 }
00160 if (pos > offset + length)
00161 goto out;
00162 all_set_count += tmp_count;
00163 all_member_count += tmp_member_count;
00164
00165 tmp_count = rsbac_list_lol_count(pp_set_handle);
00166 tmp_member_count = rsbac_list_lol_all_subcount(pp_set_handle);
00167 len +=
00168 sprintf(buffer + len, "%lu pp-set-items, sum of %lu members\n",
00169 tmp_count, tmp_member_count);
00170 pos = begin + len;
00171 if (pos < offset) {
00172 len = 0;
00173 begin = pos;
00174 }
00175 if (pos > offset + length)
00176 goto out;
00177 all_set_count += tmp_count;
00178 all_member_count += tmp_member_count;
00179
00180 tmp_count = rsbac_list_lol_count(in_pp_set_handle);
00181 tmp_member_count = rsbac_list_lol_all_subcount(in_pp_set_handle);
00182 len +=
00183 sprintf(buffer + len,
00184 "%lu in_pp-set-items, sum of %lu members\n", tmp_count,
00185 tmp_member_count);
00186 pos = begin + len;
00187 if (pos < offset) {
00188 len = 0;
00189 begin = pos;
00190 }
00191 if (pos > offset + length)
00192 goto out;
00193 all_set_count += tmp_count;
00194 all_member_count += tmp_member_count;
00195
00196 tmp_count = rsbac_list_lol_count(out_pp_set_handle);
00197 tmp_member_count = rsbac_list_lol_all_subcount(out_pp_set_handle);
00198 len +=
00199 sprintf(buffer + len,
00200 "%lu out_pp-set-items, sum of %lu members\n",
00201 tmp_count, tmp_member_count);
00202 pos = begin + len;
00203 if (pos < offset) {
00204 len = 0;
00205 begin = pos;
00206 }
00207 if (pos > offset + length)
00208 goto out;
00209 all_set_count += tmp_count;
00210 all_member_count += tmp_member_count;
00211
00212 len +=
00213 sprintf(buffer + len,
00214 "Total of %lu registered rsbac-pm-set-items, %lu members\n",
00215 all_set_count, all_member_count);
00216
00217
00218
00219
00220
00221 tmp_count = rsbac_list_count(task_handle);
00222 len += sprintf(buffer + len, "%lu task-items\n", tmp_count);
00223 pos = begin + len;
00224 if (pos < offset) {
00225 len = 0;
00226 begin = pos;
00227 }
00228 if (pos > offset + length)
00229 goto out;
00230 all_count += tmp_count;
00231
00232 tmp_count = rsbac_list_count(class_handle);
00233 len += sprintf(buffer + len, "%lu class-items\n", tmp_count);
00234 pos = begin + len;
00235 if (pos < offset) {
00236 len = 0;
00237 begin = pos;
00238 }
00239 if (pos > offset + length)
00240 goto out;
00241 all_count += tmp_count;
00242
00243 tmp_count = rsbac_list_count(na_handle);
00244 len += sprintf(buffer + len, "%lu necessary access items\n",
00245 tmp_count);
00246 pos = begin + len;
00247 if (pos < offset) {
00248 len = 0;
00249 begin = pos;
00250 }
00251 if (pos > offset + length)
00252 goto out;
00253 all_count += tmp_count;
00254
00255 tmp_count = rsbac_list_count(cs_handle);
00256 len += sprintf(buffer + len, "%lu consent items\n", tmp_count);
00257 pos = begin + len;
00258 if (pos < offset) {
00259 len = 0;
00260 begin = pos;
00261 }
00262 if (pos > offset + length)
00263 goto out;
00264 all_count += tmp_count;
00265
00266 tmp_count = rsbac_list_count(tp_handle);
00267 len += sprintf(buffer + len, "%lu tp items\n", tmp_count);
00268 pos = begin + len;
00269 if (pos < offset) {
00270 len = 0;
00271 begin = pos;
00272 }
00273 if (pos > offset + length)
00274 goto out;
00275 all_count += tmp_count;
00276
00277 tmp_count = rsbac_list_count(pp_handle);
00278 len += sprintf(buffer + len, "%lu purpose items\n", tmp_count);
00279 pos = begin + len;
00280 if (pos < offset) {
00281 len = 0;
00282 begin = pos;
00283 }
00284 if (pos > offset + length)
00285 goto out;
00286 all_count += tmp_count;
00287
00288 tmp_count = rsbac_list_count(tkt_handle);
00289 len += sprintf(buffer + len, "%lu tkt items\n", tmp_count);
00290 pos = begin + len;
00291 if (pos < offset) {
00292 len = 0;
00293 begin = pos;
00294 }
00295 if (pos > offset + length)
00296 goto out;
00297 all_count += tmp_count;
00298
00299 len +=
00300 sprintf(buffer + len,
00301 "Total of %lu registered rsbac-pm-items\n", all_count);
00302 pos = begin + len;
00303 if (pos < offset) {
00304 len = 0;
00305 begin = pos;
00306 }
00307
00308 out:
00309 *start = buffer + (offset - begin);
00310 len -= (offset - begin);
00311
00312 if (len > length)
00313 len = length;
00314 return len;
00315 }
00316
00317
00318
00319 static int pm_list_proc_read(char *buffer, char **start, off_t offset,
00320 int length, int *eof, void *data)
00321 {
00322 int len = 0;
00323 off_t pos = 0;
00324 off_t begin = 0;
00325 long count;
00326 long subcount;
00327 u_long i, j;
00328 enum rsbac_pm_list_t list;
00329
00330 if (!rsbac_is_initialized())
00331 return (-ENOSYS);
00332 list = (enum rsbac_pm_all_list_t) data;
00333
00334 #if !defined(CONFIG_RSBAC_MAINT)
00335
00336 #if defined(CONFIG_RSBAC_SWITCH_PM)
00337 if (rsbac_switch_pm)
00338 #endif
00339 {
00340 int error;
00341 union rsbac_target_id_t tid;
00342 union rsbac_attribute_value_t attr_val;
00343
00344 rsbac_get_owner(&tid.user);
00345 error =
00346 rsbac_get_attr(SW_PM, T_USER, tid, A_pm_role, &attr_val,
00347 TRUE);
00348 if (error) {
00349 char *tmp = rsbac_kmalloc(RSBAC_MAXNAMELEN);
00350
00351 if (tmp) {
00352 get_error_name(tmp, error);
00353 rsbac_printk(KERN_WARNING "pm_list_proc_read(): rsbac_get_attr() for pm_role returned error %s",
00354 tmp);
00355 rsbac_kfree(tmp);
00356 }
00357 return (error);
00358 }
00359 if ((attr_val.pm_role != PR_security_officer)
00360 && (attr_val.pm_role != PR_data_protection_officer)
00361 && (attr_val.pm_role != PR_tp_manager)) {
00362 char *tmp = rsbac_kmalloc(RSBAC_MAXNAMELEN);
00363
00364 if (tmp) {
00365 get_pm_all_list_name(tmp, list);
00366 rsbac_printk(KERN_WARNING "pm_list_proc_read(): access to list %s denied\n",
00367 tmp);
00368 rsbac_kfree(tmp);
00369 }
00370 #if defined(CONFIG_RSBAC_SOFTMODE)
00371 if (!rsbac_softmode)
00372 #endif
00373 return (-EPERM);
00374 }
00375 if ((attr_val.pm_role == PR_tp_manager)
00376 && (list != PA_tp)) {
00377 rsbac_printk(KERN_WARNING "pm_list_proc_read(): access to list tp denied\n");
00378 #if defined(CONFIG_RSBAC_SOFTMODE)
00379 if (!rsbac_softmode)
00380 #endif
00381 return (-EPERM);
00382 }
00383 }
00384 #endif
00385
00386 switch (list) {
00387 case PA_task_set:
00388 {
00389 rsbac_pm_task_set_id_t *set_array;
00390 rsbac_pm_task_id_t *member_array;
00391
00392 count =
00393 rsbac_list_lol_get_all_desc(task_set_handle,
00394 (void **)
00395 &set_array);
00396 if (count < 0) {
00397 return count;
00398 }
00399 len +=
00400 sprintf(buffer + len, "task-set\tmembers\n");
00401 for (i = 0; i < count; i++) {
00402 len += sprintf(buffer + len, "%u\t\t",
00403 set_array[i]);
00404 pos = begin + len;
00405 if (pos < offset) {
00406 len = 0;
00407 begin = pos;
00408 }
00409 if (pos > offset + length) {
00410 rsbac_vfree(set_array);
00411 goto out;
00412 }
00413
00414 subcount =
00415 rsbac_list_lol_get_all_subdesc
00416 (task_set_handle, &set_array[i],
00417 (void **) &member_array);
00418 if (subcount < 0) {
00419 rsbac_vfree(set_array);
00420 goto out;
00421 }
00422 for (j = 0; j < subcount; j++) {
00423 len += sprintf(buffer + len, "%u ",
00424 member_array[j]);
00425 pos = begin + len;
00426 if (pos < offset) {
00427 len = 0;
00428 begin = pos;
00429 }
00430 if (pos > offset + length) {
00431 rsbac_vfree(set_array);
00432 rsbac_vfree(member_array);
00433 goto out;
00434 }
00435 };
00436 if (subcount > 0)
00437 rsbac_vfree(member_array);
00438 len += sprintf(buffer + len, "\n");
00439 pos = begin + len;
00440 if (pos < offset) {
00441 len = 0;
00442 begin = pos;
00443 }
00444 if (pos > offset + length) {
00445 rsbac_vfree(set_array);
00446 goto out;
00447 }
00448 };
00449 if (count > 0)
00450 rsbac_vfree(set_array);
00451 break;
00452 }
00453
00454 case PA_tp_set:
00455 {
00456 rsbac_pm_tp_set_id_t *set_array;
00457 rsbac_pm_tp_id_t *member_array;
00458
00459 count =
00460 rsbac_list_lol_get_all_desc(tp_set_handle,
00461 (void **)
00462 &set_array);
00463 if (count < 0) {
00464 return count;
00465 }
00466 len +=
00467 sprintf(buffer + len, "tp-set\t\tmembers\n");
00468 for (i = 0; i < count; i++) {
00469 len += sprintf(buffer + len, "%u\t\t",
00470 set_array[i]);
00471 pos = begin + len;
00472 if (pos < offset) {
00473 len = 0;
00474 begin = pos;
00475 }
00476 if (pos > offset + length) {
00477 rsbac_vfree(set_array);
00478 goto out;
00479 }
00480
00481 subcount =
00482 rsbac_list_lol_get_all_subdesc
00483 (tp_set_handle, &set_array[i],
00484 (void **) &member_array);
00485 if (subcount < 0) {
00486 rsbac_vfree(set_array);
00487 goto out;
00488 }
00489 for (j = 0; j < subcount; j++) {
00490 len += sprintf(buffer + len, "%u ",
00491 member_array[j]);
00492 pos = begin + len;
00493 if (pos < offset) {
00494 len = 0;
00495 begin = pos;
00496 }
00497 if (pos > offset + length) {
00498 rsbac_vfree(set_array);
00499 rsbac_vfree(member_array);
00500 goto out;
00501 }
00502 };
00503 if (subcount > 0)
00504 rsbac_vfree(member_array);
00505 len += sprintf(buffer + len, "\n");
00506 pos = begin + len;
00507 if (pos < offset) {
00508 len = 0;
00509 begin = pos;
00510 }
00511 if (pos > offset + length) {
00512 rsbac_vfree(set_array);
00513 goto out;
00514 }
00515 };
00516 if (count > 0)
00517 rsbac_vfree(set_array);
00518 break;
00519 }
00520
00521 case PA_ru_set:
00522 {
00523 rsbac_pm_ru_set_id_t *set_array;
00524 rsbac_uid_t *member_array;
00525
00526 count =
00527 rsbac_list_lol_get_all_desc(ru_set_handle,
00528 (void **)
00529 &set_array);
00530 if (count < 0) {
00531 return count;
00532 }
00533 len +=
00534 sprintf(buffer + len, "ru-set\t\tmembers\n");
00535 for (i = 0; i < count; i++) {
00536 len += sprintf(buffer + len, "%u\t\t",
00537 set_array[i]);
00538 pos = begin + len;
00539 if (pos < offset) {
00540 len = 0;
00541 begin = pos;
00542 }
00543 if (pos > offset + length) {
00544 rsbac_vfree(set_array);
00545 goto out;
00546 }
00547
00548 subcount =
00549 rsbac_list_lol_get_all_subdesc
00550 (ru_set_handle, &set_array[i],
00551 (void **) &member_array);
00552 if (subcount < 0) {
00553 rsbac_vfree(set_array);
00554 goto out;
00555 }
00556 for (j = 0; j < subcount; j++) {
00557 len += sprintf(buffer + len, "%u ",
00558 member_array[j]);
00559 pos = begin + len;
00560 if (pos < offset) {
00561 len = 0;
00562 begin = pos;
00563 }
00564 if (pos > offset + length) {
00565 rsbac_vfree(set_array);
00566 rsbac_vfree(member_array);
00567 goto out;
00568 }
00569 };
00570 if (subcount > 0)
00571 rsbac_vfree(member_array);
00572 len += sprintf(buffer + len, "\n");
00573 pos = begin + len;
00574 if (pos < offset) {
00575 len = 0;
00576 begin = pos;
00577 }
00578 if (pos > offset + length) {
00579 rsbac_vfree(set_array);
00580 goto out;
00581 }
00582 };
00583 if (count > 0)
00584 rsbac_vfree(set_array);
00585 break;
00586 }
00587
00588 case PA_pp_set:
00589 {
00590 rsbac_pm_pp_set_id_t *set_array;
00591 rsbac_pm_purpose_id_t *member_array;
00592
00593 count =
00594 rsbac_list_lol_get_all_desc(pp_set_handle,
00595 (void **)
00596 &set_array);
00597 if (count < 0) {
00598 return count;
00599 }
00600 len +=
00601 sprintf(buffer + len, "pp-set\t\tmembers\n");
00602 for (i = 0; i < count; i++) {
00603 len += sprintf(buffer + len, "%u\t\t",
00604 set_array[i]);
00605 pos = begin + len;
00606 if (pos < offset) {
00607 len = 0;
00608 begin = pos;
00609 }
00610 if (pos > offset + length) {
00611 rsbac_vfree(set_array);
00612 goto out;
00613 }
00614
00615 subcount =
00616 rsbac_list_lol_get_all_subdesc
00617 (pp_set_handle, &set_array[i],
00618 (void **) &member_array);
00619 if (subcount < 0) {
00620 rsbac_vfree(set_array);
00621 goto out;
00622 }
00623 for (j = 0; j < subcount; j++) {
00624 len += sprintf(buffer + len, "%u ",
00625 member_array[j]);
00626 pos = begin + len;
00627 if (pos < offset) {
00628 len = 0;
00629 begin = pos;
00630 }
00631 if (pos > offset + length) {
00632 rsbac_vfree(set_array);
00633 rsbac_vfree(member_array);
00634 goto out;
00635 }
00636 };
00637 if (subcount > 0)
00638 rsbac_vfree(member_array);
00639 len += sprintf(buffer + len, "\n");
00640 pos = begin + len;
00641 if (pos < offset) {
00642 len = 0;
00643 begin = pos;
00644 }
00645 if (pos > offset + length) {
00646 rsbac_vfree(set_array);
00647 goto out;
00648 }
00649 };
00650 if (count > 0)
00651 rsbac_vfree(set_array);
00652 break;
00653 }
00654
00655 case PA_in_pp_set:
00656 {
00657 rsbac_pm_in_pp_set_id_t *set_array;
00658 rsbac_pm_purpose_id_t *member_array;
00659
00660 count =
00661 rsbac_list_lol_get_all_desc(in_pp_set_handle,
00662 (void **)
00663 &set_array);
00664 if (count < 0) {
00665 return count;
00666 }
00667
00668 len +=
00669 sprintf(buffer + len, "in-pp-set\tmembers\n");
00670 for (i = 0; i < count; i++) {
00671 len += sprintf(buffer + len, "%u\t\t",
00672 set_array[i]);
00673 pos = begin + len;
00674 if (pos < offset) {
00675 len = 0;
00676 begin = pos;
00677 }
00678 if (pos > offset + length) {
00679 rsbac_vfree(set_array);
00680 goto out;
00681 }
00682
00683 subcount =
00684 rsbac_list_lol_get_all_subdesc
00685 (in_pp_set_handle, &set_array[i],
00686 (void **) &member_array);
00687 if (subcount < 0) {
00688 rsbac_vfree(set_array);
00689 goto out;
00690 }
00691 for (j = 0; j < subcount; j++) {
00692 len += sprintf(buffer + len, "%u ",
00693 member_array[j]);
00694 pos = begin + len;
00695 if (pos < offset) {
00696 len = 0;
00697 begin = pos;
00698 }
00699 if (pos > offset + length) {
00700 rsbac_vfree(set_array);
00701 rsbac_vfree(member_array);
00702 goto out;
00703 }
00704 };
00705 if (subcount > 0)
00706 rsbac_vfree(member_array);
00707 len += sprintf(buffer + len, "\n");
00708 pos = begin + len;
00709 if (pos < offset) {
00710 len = 0;
00711 begin = pos;
00712 }
00713 if (pos > offset + length) {
00714 rsbac_vfree(set_array);
00715 goto out;
00716 }
00717 };
00718 if (count > 0)
00719 rsbac_vfree(set_array);
00720 break;
00721 }
00722
00723 case PA_out_pp_set:
00724 {
00725 rsbac_pm_out_pp_set_id_t *set_array;
00726 rsbac_pm_purpose_id_t *member_array;
00727
00728 count =
00729 rsbac_list_lol_get_all_desc(out_pp_set_handle,
00730 (void **)
00731 &set_array);
00732 if (count < 0) {
00733 return count;
00734 }
00735
00736 len +=
00737 sprintf(buffer + len, "out-pp-set\tmembers\n");
00738 for (i = 0; i < count; i++) {
00739 len += sprintf(buffer + len, "%u\t\t",
00740 set_array[i]);
00741 pos = begin + len;
00742 if (pos < offset) {
00743 len = 0;
00744 begin = pos;
00745 }
00746 if (pos > offset + length) {
00747 rsbac_vfree(set_array);
00748 goto out;
00749 }
00750
00751 subcount =
00752 rsbac_list_lol_get_all_subdesc
00753 (out_pp_set_handle, &set_array[i],
00754 (void **) &member_array);
00755 if (subcount < 0) {
00756 rsbac_vfree(set_array);
00757 goto out;
00758 }
00759 for (j = 0; j < subcount; j++) {
00760 len += sprintf(buffer + len, "%u ",
00761 member_array[j]);
00762 pos = begin + len;
00763 if (pos < offset) {
00764 len = 0;
00765 begin = pos;
00766 }
00767 if (pos > offset + length) {
00768 rsbac_vfree(set_array);
00769 rsbac_vfree(member_array);
00770 goto out;
00771 }
00772 };
00773 if (subcount > 0)
00774 rsbac_vfree(member_array);
00775 len += sprintf(buffer + len, "\n");
00776 pos = begin + len;
00777 if (pos < offset) {
00778 len = 0;
00779 begin = pos;
00780 }
00781 if (pos > offset + length) {
00782 rsbac_vfree(set_array);
00783 goto out;
00784 }
00785 };
00786 if (count > 0)
00787 rsbac_vfree(set_array);
00788 break;
00789 }
00790
00791
00792
00793 case PA_task:
00794 {
00795 rsbac_pm_task_id_t *desc_array;
00796
00797 count =
00798 rsbac_list_get_all_desc(task_handle,
00799 (void **) &desc_array);
00800 if (count < 0) {
00801 return count;
00802 }
00803
00804 len += sprintf(buffer + len, "task-id\n");
00805 for (i = 0; i < count; i++) {
00806 len += sprintf(buffer + len, "%u\n",
00807 desc_array[i]);
00808 pos = begin + len;
00809 if (pos < offset) {
00810 len = 0;
00811 begin = pos;
00812 }
00813 if (pos > offset + length) {
00814 rsbac_vfree(desc_array);
00815 goto out;
00816 }
00817 };
00818 if (count > 0)
00819 rsbac_vfree(desc_array);
00820 break;
00821 }
00822
00823 case PA_class:
00824 {
00825 rsbac_pm_object_class_id_t *desc_array;
00826
00827 count =
00828 rsbac_list_get_all_desc(class_handle,
00829 (void **) &desc_array);
00830 if (count < 0) {
00831 return count;
00832 }
00833
00834 len += sprintf(buffer + len, "class-id\n");
00835 for (i = 0; i < count; i++) {
00836 len += sprintf(buffer + len, "%u\n",
00837 desc_array[i]);
00838 pos = begin + len;
00839 if (pos < offset) {
00840 len = 0;
00841 begin = pos;
00842 }
00843 if (pos > offset + length) {
00844 rsbac_vfree(desc_array);
00845 goto out;
00846 }
00847 };
00848 if (count > 0)
00849 rsbac_vfree(desc_array);
00850 break;
00851 }
00852
00853 case PA_na:
00854 {
00855 struct rsbac_pm_na_data_t *data_array;
00856
00857 count =
00858 rsbac_list_get_all_data(na_handle,
00859 (void **) &data_array);
00860 if (count < 0) {
00861 return count;
00862 }
00863 len +=
00864 sprintf(buffer + len,
00865 "task\tclass\ttp\taccesses\n");
00866 for (i = 0; i < count; i++) {
00867 len +=
00868 sprintf(buffer + len,
00869 "%u\t%u\t%u\t%u\n",
00870 data_array[i].task,
00871 data_array[i].object_class,
00872 data_array[i].tp,
00873 data_array[i].accesses);
00874 pos = begin + len;
00875 if (pos < offset) {
00876 len = 0;
00877 begin = pos;
00878 }
00879 if (pos > offset + length) {
00880 rsbac_vfree(data_array);
00881 goto out;
00882 }
00883 };
00884 if (count > 0)
00885 rsbac_vfree(data_array);
00886 break;
00887 }
00888
00889 case PA_cs:
00890 {
00891 struct rsbac_pm_cs_id_t *desc_array;
00892
00893 count =
00894 rsbac_list_get_all_desc(cs_handle,
00895 (void **) &desc_array);
00896 if (count < 0) {
00897 return count;
00898 }
00899 len +=
00900 sprintf(buffer + len,
00901 "purpose\tdevice\tinode\n");
00902 for (i = 0; i < count; i++) {
00903 len +=
00904 sprintf(buffer + len,
00905 "%u\t%02u:02%u\t%u\n",
00906 desc_array[i].purpose,
00907 RSBAC_MAJOR(desc_array[i].file.
00908 device),
00909 RSBAC_MINOR(desc_array[i].file.
00910 device),
00911 desc_array[i].file.inode);
00912 pos = begin + len;
00913 if (pos < offset) {
00914 len = 0;
00915 begin = pos;
00916 }
00917 if (pos > offset + length) {
00918 rsbac_vfree(desc_array);
00919 goto out;
00920 }
00921 };
00922 if (count > 0)
00923 rsbac_vfree(desc_array);
00924 break;
00925 }
00926
00927 case PA_tp:
00928 {
00929 rsbac_pm_tp_id_t *desc_array;
00930
00931 count =
00932 rsbac_list_get_all_desc(tp_handle,
00933 (void **) &desc_array);
00934 if (count < 0) {
00935 return count;
00936 }
00937
00938 len += sprintf(buffer + len, "tp-id\n");
00939 for (i = 0; i < count; i++) {
00940 len += sprintf(buffer + len, "%u\n",
00941 desc_array[i]);
00942 pos = begin + len;
00943 if (pos < offset) {
00944 len = 0;
00945 begin = pos;
00946 }
00947 if (pos > offset + length) {
00948 rsbac_vfree(desc_array);
00949 goto out;
00950 }
00951 };
00952 if (count > 0)
00953 rsbac_vfree(desc_array);
00954 break;
00955 }
00956
00957 case PA_pp:
00958 {
00959 struct rsbac_pm_pp_data_t *data_array;
00960
00961 count =
00962 rsbac_list_get_all_data(pp_handle,
00963 (void **) &data_array);
00964 if (count < 0) {
00965 return count;
00966 }
00967 len +=
00968 sprintf(buffer + len, "purpose\tdef-class\n");
00969 for (i = 0; i < count; i++) {
00970 len += sprintf(buffer + len, "%u\t%u\n",
00971 data_array[i].id,
00972 data_array[i].def_class);
00973 pos = begin + len;
00974 if (pos < offset) {
00975 len = 0;
00976 begin = pos;
00977 }
00978 if (pos > offset + length) {
00979 rsbac_vfree(data_array);
00980 goto out;
00981 }
00982 };
00983 if (count > 0)
00984 rsbac_vfree(data_array);
00985 break;
00986 }
00987
00988 case PA_tkt:
00989 {
00990 struct rsbac_pm_tkt_data_t *data_array;
00991
00992 count =
00993 rsbac_list_get_all_data(tkt_handle,
00994 (void **) &data_array);
00995 if (count < 0) {
00996 return count;
00997 }
00998 len +=
00999 sprintf(buffer + len,
01000 "tkt-id\tvalid-for\tfunction-type\n");
01001 for (i = 0; i < count; i++) {
01002 char tmp1[RSBAC_MAXNAMELEN];
01003 char tmp2[RSBAC_MAXNAMELEN];
01004 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
01005 struct timespec now = CURRENT_TIME;
01006 #endif
01007
01008 tmp2[0] = 0;
01009 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
01010 if (data_array[i].valid_until < now.tv_sec)
01011 #else
01012 if (data_array[i].valid_until <
01013 CURRENT_TIME)
01014 #endif
01015 {
01016 strcpy(tmp2,
01017 "\t(removed on cleanup)");
01018 }
01019 len +=
01020 sprintf(buffer + len,
01021 "%u\t%li\t\t%s%s\n",
01022 data_array[i].id,
01023 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
01024 data_array[i].valid_until -
01025 now.tv_sec,
01026 #else
01027 data_array[i].valid_until -
01028 CURRENT_TIME,
01029 #endif
01030 get_pm_function_type_name(tmp1,
01031 data_array
01032 [i].
01033 function_type),
01034 tmp2);
01035 pos = begin + len;
01036 if (pos < offset) {
01037 len = 0;
01038 begin = pos;
01039 }
01040 if (pos > offset + length) {
01041 rsbac_vfree(data_array);
01042 goto out;
01043 }
01044 };
01045 if (count > 0)
01046 rsbac_vfree(data_array);
01047 break;
01048 }
01049
01050 default:
01051 rsbac_printk(KERN_WARNING "pm_list_proc_read(): access to unknown list %i\n",
01052 list);
01053 return (-RSBAC_EINVALIDTARGET);
01054 }
01055
01056 out:
01057 if (len <= offset + length)
01058 *eof = 1;
01059 *start = buffer + (offset - begin);
01060 len -= (offset - begin);
01061
01062 if (len > length)
01063 len = length;
01064 return len;
01065 };
01066
01067 #endif
01068
01069
01070
01071
01072
01073 #ifdef CONFIG_RSBAC_INIT_DELAY
01074 static void registration_error(int err, char *listname)
01075 #else
01076 static void __init registration_error(int err, char *listname)
01077 #endif
01078 {
01079 if (err) {
01080 char *tmp = rsbac_kmalloc(RSBAC_MAXNAMELEN);
01081
01082 if (tmp) {
01083 rsbac_printk(KERN_WARNING "rsbac_init_pm(): Registering PM %s list failed with error %s\n",
01084 listname, get_error_name(tmp, err));
01085 rsbac_kfree(tmp);
01086 }
01087 }
01088 }
01089
01090
01091
01092
01093
01094
01095
01096
01097
01098 #ifdef CONFIG_RSBAC_INIT_DELAY
01099 int rsbac_init_pm(void)
01100 #else
01101 int __init rsbac_init_pm(void)
01102 #endif
01103 {
01104 int err = 0;
01105 struct proc_dir_entry *tmp_entry_p;
01106 struct proc_dir_entry *pm_entry_p;
01107 struct rsbac_list_lol_info_t lol_info;
01108 struct rsbac_list_info_t list_info;
01109
01110 if (rsbac_is_initialized()) {
01111 rsbac_printk(KERN_WARNING "rsbac_init_pm(): RSBAC already initialized\n");
01112 return (-RSBAC_EREINIT);
01113 }
01114
01115 rsbac_printk(KERN_INFO "rsbac_init_pm(): Initializing RSBAC: PM subsystem\n");
01116
01117
01118 lol_info.version = RSBAC_PM_TASK_SET_LIST_VERSION;
01119 lol_info.key = RSBAC_PM_LIST_KEY;
01120 lol_info.desc_size = sizeof(rsbac_pm_task_set_id_t);
01121 lol_info.data_size = 0;
01122 lol_info.subdesc_size = sizeof(rsbac_pm_task_id_t);
01123 lol_info.subdata_size = 0;
01124 lol_info.max_age = 0;
01125 err = rsbac_list_lol_register(RSBAC_LIST_VERSION,
01126 &task_set_handle,
01127 &lol_info,
01128 RSBAC_LIST_PERSIST |
01129 RSBAC_LIST_BACKUP,
01130 NULL,
01131 NULL, NULL, NULL,
01132 NULL, NULL,
01133 RSBAC_PM_TASK_SET_LIST_NAME,
01134 RSBAC_AUTO_DEV);
01135 if (err) {
01136 registration_error(err, "task set");
01137 return err;
01138 }
01139
01140 lol_info.version = RSBAC_PM_TP_SET_LIST_VERSION;
01141 lol_info.key = RSBAC_PM_LIST_KEY;
01142 lol_info.desc_size = sizeof(rsbac_pm_tp_set_id_t);
01143 lol_info.data_size = 0;
01144 lol_info.subdesc_size = sizeof(rsbac_pm_tp_id_t);
01145 lol_info.subdata_size = 0;
01146 lol_info.max_age = 0;
01147 err = rsbac_list_lol_register(RSBAC_LIST_VERSION,
01148 &tp_set_handle,
01149 &lol_info,
01150 RSBAC_LIST_PERSIST |
01151 RSBAC_LIST_BACKUP,
01152 NULL,
01153 NULL, NULL, NULL,
01154 NULL, NULL,
01155 RSBAC_PM_TP_SET_LIST_NAME,
01156 RSBAC_AUTO_DEV);
01157 if (err) {
01158 registration_error(err, "tp set");
01159 return err;
01160 }
01161
01162 lol_info.version = RSBAC_PM_RU_SET_LIST_VERSION;
01163 lol_info.key = RSBAC_PM_LIST_KEY;
01164 lol_info.desc_size = sizeof(rsbac_pm_ru_set_id_t);
01165 lol_info.data_size = 0;
01166 lol_info.subdesc_size = sizeof(rsbac_uid_t);
01167 lol_info.subdata_size = 0;
01168 lol_info.max_age = 0;
01169 err = rsbac_list_lol_register(RSBAC_LIST_VERSION,
01170 &ru_set_handle,
01171 &lol_info,
01172 RSBAC_LIST_PERSIST |
01173 RSBAC_LIST_BACKUP,
01174 NULL,
01175 NULL, NULL, NULL,
01176 NULL, NULL,
01177 RSBAC_PM_RU_SET_LIST_NAME,
01178 RSBAC_AUTO_DEV);
01179 if (err) {
01180 registration_error(err, "ru set");
01181 return err;
01182 }
01183
01184 lol_info.version = RSBAC_PM_PP_SET_LIST_VERSION;
01185 lol_info.key = RSBAC_PM_LIST_KEY;
01186 lol_info.desc_size = sizeof(rsbac_pm_pp_set_id_t);
01187 lol_info.data_size = 0;
01188 lol_info.subdesc_size = sizeof(rsbac_pm_purpose_id_t);
01189 lol_info.subdata_size = 0;
01190 lol_info.max_age = 0;
01191 err = rsbac_list_lol_register(RSBAC_LIST_VERSION,
01192 &pp_set_handle,
01193 &lol_info,
01194 RSBAC_LIST_PERSIST |
01195 RSBAC_LIST_BACKUP,
01196 NULL,
01197 NULL, NULL, NULL,
01198 NULL, NULL,
01199 RSBAC_PM_PP_SET_LIST_NAME,
01200 RSBAC_AUTO_DEV);
01201 if (err) {
01202 registration_error(err, "pp set");
01203 return err;
01204 }
01205
01206 lol_info.version = RSBAC_PM_NO_VERSION;
01207 lol_info.key = RSBAC_PM_LIST_KEY;
01208 lol_info.desc_size = sizeof(rsbac_pm_in_pp_set_id_t);
01209 lol_info.data_size = 0;
01210 lol_info.subdesc_size = sizeof(rsbac_pm_purpose_id_t);
01211 lol_info.subdata_size = 0;
01212 lol_info.max_age = 0;
01213 err = rsbac_list_lol_register(RSBAC_LIST_VERSION,
01214 &in_pp_set_handle,
01215 &lol_info,
01216 0,
01217 NULL,
01218 NULL,
01219 NULL,
01220 NULL,
01221 NULL,
01222 NULL,
01223 RSBAC_PM_IN_PP_SET_LIST_NAME,
01224 RSBAC_AUTO_DEV);
01225 if (err) {
01226 registration_error(err, "in_pp set");
01227 return err;
01228 }
01229
01230 lol_info.version = RSBAC_PM_NO_VERSION;
01231 lol_info.key = RSBAC_PM_LIST_KEY;
01232 lol_info.desc_size = sizeof(rsbac_pm_out_pp_set_id_t);
01233 lol_info.data_size = 0;
01234 lol_info.subdesc_size = sizeof(rsbac_pm_purpose_id_t);
01235 lol_info.subdata_size = 0;
01236 lol_info.max_age = 0;
01237 err = rsbac_list_lol_register(RSBAC_LIST_VERSION,
01238 &out_pp_set_handle,
01239 &lol_info,
01240 0,
01241 NULL,
01242 NULL,
01243 NULL,
01244 NULL,
01245 NULL,
01246 NULL,
01247 RSBAC_PM_OUT_PP_SET_LIST_NAME,
01248 RSBAC_AUTO_DEV);
01249 if (err) {
01250 registration_error(err, "out_pp set");
01251 return err;
01252 }
01253
01254
01255 list_info.version = RSBAC_PM_TASK_LIST_VERSION;
01256 list_info.key = RSBAC_PM_LIST_KEY;
01257 list_info.desc_size = sizeof(rsbac_pm_task_id_t);
01258 list_info.data_size = sizeof(struct rsbac_pm_task_data_t);
01259 list_info.max_age = 0;
01260 err = rsbac_list_register(RSBAC_LIST_VERSION,
01261 &task_handle,
01262 &list_info,
01263 RSBAC_LIST_PERSIST | RSBAC_LIST_BACKUP,
01264 NULL,
01265 NULL,
01266 NULL,
01267 RSBAC_PM_TASK_LIST_NAME, RSBAC_AUTO_DEV);
01268 if (err) {
01269 registration_error(err, "task");
01270 return err;
01271 }
01272
01273 list_info.version = RSBAC_PM_CLASS_LIST_VERSION;
01274 list_info.key = RSBAC_PM_LIST_KEY;
01275 list_info.desc_size = sizeof(rsbac_pm_object_class_id_t);
01276 list_info.data_size = sizeof(struct rsbac_pm_class_data_t);
01277 list_info.max_age = 0;
01278 err = rsbac_list_register(RSBAC_LIST_VERSION,
01279 &class_handle,
01280 &list_info,
01281 RSBAC_LIST_PERSIST | RSBAC_LIST_BACKUP,
01282 NULL,
01283 NULL,
01284 NULL,
01285 RSBAC_PM_CLASS_LIST_NAME,
01286 RSBAC_AUTO_DEV);
01287 if (err) {
01288 registration_error(err, "class");
01289 return err;
01290 }
01291
01292 list_info.version = RSBAC_PM_NA_LIST_VERSION;
01293 list_info.key = RSBAC_PM_LIST_KEY;
01294 list_info.desc_size = sizeof(struct rsbac_pm_na_id_t);
01295 list_info.data_size = sizeof(struct rsbac_pm_na_data_t);
01296 list_info.max_age = 0;
01297 err = rsbac_list_register(RSBAC_LIST_VERSION,
01298 &na_handle,
01299 &list_info,
01300 RSBAC_LIST_PERSIST | RSBAC_LIST_BACKUP,
01301 NULL,
01302 NULL,
01303 NULL,
01304 RSBAC_PM_NA_LIST_NAME, RSBAC_AUTO_DEV);
01305 if (err) {
01306 registration_error(err, "na");
01307 return err;
01308 }
01309
01310 list_info.version = RSBAC_PM_CS_LIST_VERSION;
01311 list_info.key = RSBAC_PM_LIST_KEY;
01312 list_info.desc_size = sizeof(struct rsbac_pm_cs_id_t);
01313 list_info.data_size = sizeof(struct rsbac_pm_cs_data_t);
01314 list_info.max_age = 0;
01315 err = rsbac_list_register(RSBAC_LIST_VERSION,
01316 &cs_handle,
01317 &list_info,
01318 RSBAC_LIST_PERSIST | RSBAC_LIST_BACKUP,
01319 NULL,
01320 NULL,
01321 NULL,
01322 RSBAC_PM_CS_LIST_NAME, RSBAC_AUTO_DEV);
01323 if (err) {
01324 registration_error(err, "cs");
01325 return err;
01326 }
01327
01328 list_info.version = RSBAC_PM_TP_LIST_VERSION;
01329 list_info.key = RSBAC_PM_LIST_KEY;
01330 list_info.desc_size = sizeof(rsbac_pm_tp_id_t);
01331 list_info.data_size = sizeof(struct rsbac_pm_tp_data_t);
01332 list_info.max_age = 0;
01333 err = rsbac_list_register(RSBAC_LIST_VERSION,
01334 &tp_handle,
01335 &list_info,
01336 RSBAC_LIST_PERSIST | RSBAC_LIST_BACKUP,
01337 NULL,
01338 NULL,
01339 NULL,
01340 RSBAC_PM_TP_LIST_NAME, RSBAC_AUTO_DEV);
01341 if (err) {
01342 registration_error(err, "tp");
01343 return err;
01344 }
01345
01346 list_info.version = RSBAC_PM_PP_LIST_VERSION;
01347 list_info.key = RSBAC_PM_LIST_KEY;
01348 list_info.desc_size = sizeof(rsbac_pm_purpose_id_t);
01349 list_info.data_size = sizeof(struct rsbac_pm_pp_data_t);
01350 list_info.max_age = 0;
01351 err = rsbac_list_register(RSBAC_LIST_VERSION,
01352 &pp_handle,
01353 &list_info,
01354 RSBAC_LIST_PERSIST | RSBAC_LIST_BACKUP,
01355 NULL,
01356 NULL,
01357 NULL,
01358 RSBAC_PM_PP_LIST_NAME, RSBAC_AUTO_DEV);
01359 if (err) {
01360 registration_error(err, "pp");
01361 return err;
01362 }
01363
01364 list_info.version = RSBAC_PM_TKT_LIST_VERSION;
01365 list_info.key = RSBAC_PM_LIST_KEY;
01366 list_info.desc_size = sizeof(rsbac_pm_tkt_id_t);
01367 list_info.data_size = sizeof(struct rsbac_pm_tkt_data_t);
01368 list_info.max_age = 0;
01369 err = rsbac_list_register(RSBAC_LIST_VERSION,
01370 &tkt_handle,
01371 &list_info,
01372 RSBAC_LIST_PERSIST | RSBAC_LIST_BACKUP,
01373 NULL,
01374 NULL,
01375 NULL,
01376 RSBAC_PM_TKT_LIST_NAME, RSBAC_AUTO_DEV);
01377 if (err) {
01378 registration_error(err, "tkt");
01379 return err;
01380 }
01381 #if defined(CONFIG_RSBAC_PROC)
01382 tmp_entry_p = create_proc_entry(RSBAC_PM_PROC_STATS_NAME,
01383 S_IFREG | S_IRUGO,
01384 proc_rsbac_root_p);
01385 if (tmp_entry_p) {
01386 tmp_entry_p->get_info = stats_pm_proc_info;
01387 }
01388
01389 pm_entry_p = create_proc_entry(RSBAC_PM_PROC_DIR_NAME,
01390 S_IFDIR | S_IRUGO | S_IXUGO,
01391 proc_rsbac_root_p);
01392 if (pm_entry_p) {
01393 tmp_entry_p =
01394 create_proc_entry(RSBAC_PM_TASK_SET_LIST_PROC_NAME,
01395 S_IFREG | S_IRUGO, pm_entry_p);
01396 if (tmp_entry_p) {
01397 tmp_entry_p->read_proc = pm_list_proc_read;
01398 tmp_entry_p->data = (void *) PA_task_set;
01399 }
01400 tmp_entry_p =
01401 create_proc_entry(RSBAC_PM_TP_SET_LIST_PROC_NAME,
01402 S_IFREG | S_IRUGO, pm_entry_p);
01403 if (tmp_entry_p) {
01404 tmp_entry_p->read_proc = pm_list_proc_read;
01405 tmp_entry_p->data = (void *) PA_tp_set;
01406 }
01407 tmp_entry_p =
01408 create_proc_entry(RSBAC_PM_RU_SET_LIST_PROC_NAME,
01409 S_IFREG | S_IRUGO, pm_entry_p);
01410 if (tmp_entry_p) {
01411 tmp_entry_p->read_proc = pm_list_proc_read;
01412 tmp_entry_p->data = (void *) PA_ru_set;
01413 }
01414 tmp_entry_p =
01415 create_proc_entry(RSBAC_PM_PP_SET_LIST_PROC_NAME,
01416 S_IFREG | S_IRUGO, pm_entry_p);
01417 if (tmp_entry_p) {
01418 tmp_entry_p->read_proc = pm_list_proc_read;
01419 tmp_entry_p->data = (void *) PA_pp_set;
01420 }
01421 tmp_entry_p =
01422 create_proc_entry(RSBAC_PM_IN_PP_SET_LIST_PROC_NAME,
01423 S_IFREG | S_IRUGO, pm_entry_p);
01424 if (tmp_entry_p) {
01425 tmp_entry_p->read_proc = pm_list_proc_read;
01426 tmp_entry_p->data = (void *) PA_in_pp_set;
01427 }
01428 tmp_entry_p =
01429 create_proc_entry(RSBAC_PM_OUT_PP_SET_LIST_PROC_NAME,
01430 S_IFREG | S_IRUGO, pm_entry_p);
01431 if (tmp_entry_p) {
01432 tmp_entry_p->read_proc = pm_list_proc_read;
01433 tmp_entry_p->data = (void *) PA_out_pp_set;
01434 }
01435
01436 tmp_entry_p =
01437 create_proc_entry(RSBAC_PM_TASK_LIST_PROC_NAME,
01438 S_IFREG | S_IRUGO, pm_entry_p);
01439 if (tmp_entry_p) {
01440 tmp_entry_p->read_proc = pm_list_proc_read;
01441 tmp_entry_p->data = (void *) PA_task;
01442 }
01443 tmp_entry_p =
01444 create_proc_entry(RSBAC_PM_CLASS_LIST_PROC_NAME,
01445 S_IFREG | S_IRUGO, pm_entry_p);
01446 if (tmp_entry_p) {
01447 tmp_entry_p->read_proc = pm_list_proc_read;
01448 tmp_entry_p->data = (void *) PA_class;
01449 }
01450 tmp_entry_p = create_proc_entry(RSBAC_PM_NA_LIST_PROC_NAME,
01451 S_IFREG | S_IRUGO,
01452 pm_entry_p);
01453 if (tmp_entry_p) {
01454 tmp_entry_p->read_proc = pm_list_proc_read;
01455 tmp_entry_p->data = (void *) PA_na;
01456 }
01457 tmp_entry_p = create_proc_entry(RSBAC_PM_CS_LIST_PROC_NAME,
01458 S_IFREG | S_IRUGO,
01459 pm_entry_p);
01460 if (tmp_entry_p) {
01461 tmp_entry_p->read_proc = pm_list_proc_read;
01462 tmp_entry_p->data = (void *) PA_cs;
01463 }
01464 tmp_entry_p = create_proc_entry(RSBAC_PM_TP_LIST_PROC_NAME,
01465 S_IFREG | S_IRUGO,
01466 pm_entry_p);
01467 if (tmp_entry_p) {
01468 tmp_entry_p->read_proc = pm_list_proc_read;
01469 tmp_entry_p->data = (void *) PA_tp;
01470 }
01471 tmp_entry_p = create_proc_entry(RSBAC_PM_PP_LIST_PROC_NAME,
01472 S_IFREG | S_IRUGO,
01473 pm_entry_p);
01474 if (tmp_entry_p) {
01475 tmp_entry_p->read_proc = pm_list_proc_read;
01476 tmp_entry_p->data = (void *) PA_pp;
01477 }
01478 tmp_entry_p =
01479 create_proc_entry(RSBAC_PM_TKT_LIST_PROC_NAME,
01480 S_IFREG | S_IRUGO, pm_entry_p);
01481 if (tmp_entry_p) {
01482 tmp_entry_p->read_proc = pm_list_proc_read;
01483 tmp_entry_p->data = (void *) PA_tkt;
01484 }
01485 }
01486 #endif
01487 rsbac_pr_debug(ds_pm, "Ready.\n");
01488 return (err);
01489 };
01490
01491
01492
01493
01494 int rsbac_stats_pm(void)
01495 {
01496 u_long tmp_count;
01497 u_long tmp_member_count;
01498 u_long all_set_count = 0;
01499 u_long all_member_count = 0;
01500 u_long all_count = 0;
01501
01502 if (!rsbac_is_initialized()) {
01503 rsbac_printk(KERN_WARNING "rsbac_stats_pm(): RSBAC not initialized\n");
01504 return (-RSBAC_ENOTINITIALIZED);
01505 }
01506
01507
01508
01509
01510
01511 tmp_count = rsbac_list_lol_count(task_set_handle);
01512 tmp_member_count = rsbac_list_lol_all_subcount(task_set_handle);
01513 rsbac_printk(KERN_INFO "rsbac_stats_pm(): %lu task-set-items, sum of %lu members\n",
01514 tmp_count, tmp_member_count);
01515 all_set_count += tmp_count;
01516 all_member_count += tmp_member_count;
01517
01518 tmp_count = rsbac_list_lol_count(tp_set_handle);
01519 tmp_member_count = rsbac_list_lol_all_subcount(tp_set_handle);
01520 rsbac_printk(KERN_INFO "rsbac_stats_pm(): %lu tp set items, sum of %lu members\n",
01521 tmp_count, tmp_member_count);
01522 all_set_count += tmp_count;
01523 all_member_count += tmp_member_count;
01524
01525 tmp_count = rsbac_list_lol_count(ru_set_handle);
01526 tmp_member_count = rsbac_list_lol_all_subcount(ru_set_handle);
01527 rsbac_printk(KERN_INFO "rsbac_stats_pm(): %lu ru set items, sum of %lu members\n",
01528 tmp_count, tmp_member_count);
01529 all_set_count += tmp_count;
01530 all_member_count += tmp_member_count;
01531
01532 tmp_count = rsbac_list_lol_count(pp_set_handle);
01533 tmp_member_count = rsbac_list_lol_all_subcount(pp_set_handle);
01534 rsbac_printk(KERN_INFO "rsbac_stats_pm(): %lu pp set items, sum of %lu members\n",
01535 tmp_count, tmp_member_count);
01536 all_set_count += tmp_count;
01537 all_member_count += tmp_member_count;
01538
01539 tmp_count = rsbac_list_lol_count(in_pp_set_handle);
01540 tmp_member_count = rsbac_list_lol_all_subcount(in_pp_set_handle);
01541 rsbac_printk(KERN_INFO "rsbac_stats_pm(): %lu input purpose set items, sum of %lu members\n",
01542 tmp_count, tmp_member_count);
01543 all_set_count += tmp_count;
01544 all_member_count += tmp_member_count;
01545
01546 tmp_count = rsbac_list_lol_count(out_pp_set_handle);
01547 tmp_member_count = rsbac_list_lol_all_subcount(out_pp_set_handle);
01548 rsbac_printk(KERN_INFO "rsbac_stats_pm(): %lu output purpose set items, sum of %lu members\n",
01549 tmp_count, tmp_member_count);
01550 all_set_count += tmp_count;
01551 all_member_count += tmp_member_count;
01552
01553 rsbac_printk(KERN_INFO "rsbac_stats_pm(): Total of %lu registered rsbac-pm-set-items, %lu members\n",
01554 all_set_count, all_member_count);
01555
01556
01557
01558
01559 tmp_count = rsbac_list_count(task_handle);
01560 rsbac_printk(KERN_INFO "rsbac_stats_pm(): %lu task items\n",
01561 tmp_count);
01562 all_count += tmp_count;
01563
01564 tmp_count = rsbac_list_count(class_handle);
01565 rsbac_printk(KERN_INFO "rsbac_stats_pm(): %lu class items\n",
01566 tmp_count);
01567 all_count += tmp_count;
01568
01569 tmp_count = rsbac_list_count(na_handle);
01570 rsbac_printk(KERN_INFO "rsbac_stats_pm(): %lu na items\n",
01571 tmp_count);
01572 all_count += tmp_count;
01573
01574 tmp_count = rsbac_list_count(cs_handle);
01575 rsbac_printk(KERN_INFO "rsbac_stats_pm(): %lu cs items\n",
01576 tmp_count);
01577 all_count += tmp_count;
01578
01579 tmp_count = rsbac_list_count(tp_handle);
01580 rsbac_printk(KERN_INFO "rsbac_stats_pm(): %lu tp items\n",
01581 tmp_count);
01582 all_count += tmp_count;
01583
01584 tmp_count = rsbac_list_count(pp_handle);
01585 rsbac_printk(KERN_INFO "rsbac_stats_pm(): %lu pp items\n",
01586 tmp_count);
01587 all_count += tmp_count;
01588
01589 tmp_count = rsbac_list_count(tkt_handle);
01590 rsbac_printk(KERN_INFO "rsbac_stats_pm(): %lu tkt items\n",
01591 tmp_count);
01592 all_count += tmp_count;
01593
01594 rsbac_printk(KERN_INFO "rsbac_stats_pm(): Total of %lu registered rsbac-pm-items\n",
01595 all_count);
01596 return 0;
01597 }
01598
01599
01600
01601
01602
01603
01604
01605
01606
01607
01608
01609
01610
01611
01612
01613
01614 int rsbac_pm_add_to_set(rsbac_list_ta_number_t ta_number,
01615 enum rsbac_pm_set_t set,
01616 union rsbac_pm_set_id_t id,
01617 union rsbac_pm_set_member_t member)
01618 {
01619 switch (set) {
01620 case PS_TASK:
01621 return (rsbac_ta_list_lol_subadd_ttl
01622 (ta_number, task_set_handle, 0, &id.task_set,
01623 &member.task, NULL));
01624 case PS_TP:
01625 return (rsbac_ta_list_lol_subadd_ttl
01626 (ta_number, tp_set_handle, 0, &id.tp_set,
01627 &member.tp, NULL));
01628 case PS_RU:
01629 return (rsbac_ta_list_lol_subadd_ttl
01630 (ta_number, ru_set_handle, 0, &id.ru_set,
01631 &member.ru, NULL));
01632 case PS_PP:
01633 return (rsbac_ta_list_lol_subadd_ttl
01634 (ta_number, pp_set_handle, 0, &id.pp_set,
01635 &member.pp, NULL));
01636 case PS_IN_PP:
01637 return (rsbac_ta_list_lol_subadd_ttl
01638 (ta_number, in_pp_set_handle, 0, &id.in_pp_set,
01639 &member.pp, NULL));
01640 case PS_OUT_PP:
01641 return (rsbac_ta_list_lol_subadd_ttl
01642 (ta_number, out_pp_set_handle, 0, &id.out_pp_set,
01643 &member.pp, NULL));
01644 default:
01645 return (-RSBAC_EINVALIDTARGET);
01646 }
01647 }
01648
01649
01650
01651
01652
01653
01654 int rsbac_pm_remove_from_set(rsbac_list_ta_number_t ta_number,
01655 enum rsbac_pm_set_t set,
01656 union rsbac_pm_set_id_t id,
01657 union rsbac_pm_set_member_t member)
01658 {
01659 switch (set) {
01660 case PS_TASK:
01661 return (rsbac_ta_list_lol_subremove
01662 (ta_number, task_set_handle, &id.task_set,
01663 &member.task));
01664 case PS_TP:
01665 return (rsbac_ta_list_lol_subremove
01666 (ta_number, tp_set_handle, &id.tp_set,
01667 &member.tp));
01668 case PS_RU:
01669 return (rsbac_ta_list_lol_subremove
01670 (ta_number, ru_set_handle, &id.ru_set,
01671 &member.ru));
01672 case PS_PP:
01673 return (rsbac_ta_list_lol_subremove
01674 (ta_number, pp_set_handle, &id.pp_set,
01675 &member.pp));
01676 case PS_IN_PP:
01677 return (rsbac_ta_list_lol_subremove
01678 (ta_number, in_pp_set_handle, &id.in_pp_set,
01679 &member.pp));
01680 case PS_OUT_PP:
01681 return (rsbac_ta_list_lol_subremove
01682 (ta_number, out_pp_set_handle, &id.out_pp_set,
01683 &member.pp));
01684 default:
01685 return (-RSBAC_EINVALIDTARGET);
01686 }
01687 }
01688
01689
01690
01691
01692
01693
01694 int rsbac_pm_clear_set(rsbac_list_ta_number_t ta_number,
01695 enum rsbac_pm_set_t set, union rsbac_pm_set_id_t id)
01696 {
01697 switch (set) {
01698 case PS_TASK:
01699 return (rsbac_ta_list_lol_subremove_all
01700 (ta_number, task_set_handle, &id.task_set));
01701 case PS_TP:
01702 return (rsbac_ta_list_lol_subremove_all
01703 (ta_number, tp_set_handle, &id.tp_set));
01704 case PS_RU:
01705 return (rsbac_ta_list_lol_subremove_all
01706 (ta_number, ru_set_handle, &id.ru_set));
01707 case PS_PP:
01708 return (rsbac_ta_list_lol_subremove_all
01709 (ta_number, pp_set_handle, &id.pp_set));
01710 case PS_IN_PP:
01711 return (rsbac_ta_list_lol_subremove_all
01712 (ta_number, in_pp_set_handle, &id.in_pp_set));
01713 case PS_OUT_PP:
01714 return (rsbac_ta_list_lol_subremove_all
01715 (ta_number, out_pp_set_handle, &id.out_pp_set));
01716 default:
01717 return (-RSBAC_EINVALIDTARGET);
01718 }
01719 }
01720
01721
01722
01723
01724 rsbac_boolean_t rsbac_pm_set_member(rsbac_list_ta_number_t ta_number,
01725 enum rsbac_pm_set_t set,
01726 union rsbac_pm_set_id_t id,
01727 union rsbac_pm_set_member_t member)
01728 {
01729 switch (set) {
01730 case PS_TASK:
01731 return (rsbac_ta_list_lol_subexist
01732 (ta_number, task_set_handle, &id.task_set,
01733 &member.task));
01734 case PS_TP:
01735 return (rsbac_ta_list_lol_subexist
01736 (ta_number, tp_set_handle, &id.tp_set,
01737 &member.tp));
01738 case PS_RU:
01739 return (rsbac_ta_list_lol_subexist
01740 (ta_number, ru_set_handle, &id.ru_set,
01741 &member.ru));
01742 case PS_PP:
01743 return (rsbac_ta_list_lol_subexist
01744 (ta_number, pp_set_handle, &id.pp_set,
01745 &member.pp));
01746 case PS_IN_PP:
01747 return (rsbac_ta_list_lol_subexist
01748 (ta_number, in_pp_set_handle, &id.in_pp_set,
01749 &member.pp));
01750 case PS_OUT_PP:
01751 return (rsbac_ta_list_lol_subexist
01752 (ta_number, out_pp_set_handle, &id.out_pp_set,
01753 &member.pp));
01754 default:
01755 return (FALSE);
01756 }
01757 }
01758
01759
01760
01761
01762 rsbac_boolean_t rsbac_pm_pp_subset(rsbac_pm_pp_set_id_t pp_set,
01763 rsbac_pm_in_pp_set_id_t in_pp_set)
01764 {
01765 rsbac_pm_purpose_id_t *pp_array;
01766 long count;
01767 u_long i;
01768 rsbac_boolean_t result = TRUE;
01769
01770 if (!pp_set || !in_pp_set)
01771 return (FALSE);
01772
01773
01774 count =
01775 rsbac_list_lol_get_all_subdesc(pp_set_handle, &pp_set,
01776 (void **) &pp_array);
01777 if (count < 0)
01778 return FALSE;
01779 if (!count)
01780 return TRUE;
01781 if (!rsbac_list_lol_exist(in_pp_set_handle, &in_pp_set)) {
01782 rsbac_vfree(pp_array);
01783 return TRUE;
01784 }
01785
01786 for (i = 0; i < count; i++) {
01787 if (!rsbac_list_lol_subexist
01788 (in_pp_set_handle, &in_pp_set, &pp_array[i])) {
01789 result = FALSE;
01790 break;
01791 }
01792 }
01793 rsbac_vfree(pp_array);
01794 return result;
01795 }
01796
01797
01798
01799
01800 rsbac_boolean_t rsbac_pm_pp_superset(rsbac_pm_pp_set_id_t pp_set,
01801 rsbac_pm_out_pp_set_id_t out_pp_set)
01802 {
01803 rsbac_pm_purpose_id_t *pp_array;
01804 long count;
01805 u_long i;
01806 rsbac_boolean_t result = TRUE;
01807
01808 if (!pp_set)
01809 return (FALSE);
01810 if (!out_pp_set)
01811 return (TRUE);
01812 if (!rsbac_list_lol_exist(pp_set_handle, &pp_set))
01813 return FALSE;
01814
01815
01816 count =
01817 rsbac_list_lol_get_all_subdesc(out_pp_set_handle, &out_pp_set,
01818 (void **) &pp_array);
01819 if (count <= 0)
01820 return TRUE;
01821
01822 for (i = 0; i < count; i++) {
01823 if (!rsbac_list_lol_subexist
01824 (pp_set_handle, &pp_set, &pp_array[i])) {
01825 result = FALSE;
01826 break;
01827 }
01828 }
01829 rsbac_vfree(pp_array);
01830 return result;
01831 }
01832
01833
01834
01835
01836 rsbac_boolean_t rsbac_pm_pp_only(rsbac_pm_purpose_id_t purpose,
01837 rsbac_pm_out_pp_set_id_t out_pp_set)
01838 {
01839 long count;
01840
01841 if (!out_pp_set)
01842 return (TRUE);
01843
01844
01845 count = rsbac_list_lol_subcount(out_pp_set_handle, &out_pp_set);
01846 if (count <= 0)
01847 return TRUE;
01848 if (count == 1)
01849 return rsbac_list_lol_subexist(out_pp_set_handle,
01850 &out_pp_set, &purpose);
01851 else
01852 return FALSE;
01853 }
01854
01855
01856
01857
01858
01859
01860 int rsbac_pm_pp_intersec(rsbac_pm_pp_set_id_t pp_set,
01861 rsbac_pm_in_pp_set_id_t in_pp_set)
01862 {
01863 rsbac_pm_purpose_id_t *pp_array;
01864 long count;
01865 u_long i;
01866
01867 if (!rsbac_list_lol_exist(pp_set_handle, &pp_set))
01868 return -RSBAC_EINVALIDVALUE;
01869
01870 if (!rsbac_list_lol_exist(in_pp_set_handle, &in_pp_set)) {
01871 if ((count =
01872 rsbac_list_lol_add(in_pp_set_handle, &in_pp_set,
01873 NULL)))
01874 return count;
01875
01876
01877 count =
01878 rsbac_list_lol_get_all_subdesc(pp_set_handle, &pp_set,
01879 (void **) &pp_array);
01880 if (count <= 0)
01881 return count;
01882 for (i = 0; i < count; i++) {
01883 rsbac_list_lol_subadd(in_pp_set_handle, &in_pp_set,
01884 &pp_array[i], NULL);
01885 }
01886 rsbac_vfree(pp_array);
01887 } else {
01888
01889 count =
01890 rsbac_list_lol_get_all_subdesc(in_pp_set_handle,
01891 &in_pp_set,
01892 (void **) &pp_array);
01893 if (count <= 0)
01894 return count;
01895 for (i = 0; i < count; i++) {
01896 if (!rsbac_list_lol_subexist
01897 (pp_set_handle, &pp_set, &pp_array[i]))
01898 rsbac_list_lol_subremove(in_pp_set_handle,
01899 &in_pp_set,
01900 &pp_array[i]);
01901 }
01902 rsbac_vfree(pp_array);
01903 }
01904 return 0;
01905 }
01906
01907
01908
01909
01910
01911
01912 int rsbac_pm_pp_union(rsbac_pm_pp_set_id_t pp_set,
01913 rsbac_pm_out_pp_set_id_t out_pp_set)
01914 {
01915 rsbac_pm_purpose_id_t *pp_array;
01916 long count;
01917 u_long i;
01918
01919
01920 if (!rsbac_list_lol_exist(pp_set_handle, &pp_set))
01921 return -RSBAC_EINVALIDVALUE;
01922
01923 if (!rsbac_list_lol_exist(out_pp_set_handle, &out_pp_set)) {
01924 count =
01925 rsbac_list_lol_add(out_pp_set_handle, &out_pp_set,
01926 NULL);
01927 if (count)
01928 return count;
01929 }
01930
01931
01932 count =
01933 rsbac_list_lol_get_all_subdesc(pp_set_handle, &pp_set,
01934 (void **) &pp_array);
01935 if (count <= 0)
01936 return count;
01937 for (i = 0; i < count; i++) {
01938 rsbac_list_lol_subadd(out_pp_set_handle, &out_pp_set,
01939 &pp_array[i], NULL);
01940 }
01941 rsbac_vfree(pp_array);
01942 return 0;
01943 }
01944
01945
01946
01947
01948
01949
01950 int rsbac_pm_create_set(rsbac_list_ta_number_t ta_number,
01951 enum rsbac_pm_set_t set,
01952 union rsbac_pm_set_id_t id)
01953 {
01954 switch (set) {
01955 case PS_TASK:
01956
01957
01958
01959 if (rsbac_ta_list_lol_exist
01960 (ta_number, task_set_handle, &id.task_set))
01961 return -RSBAC_EEXISTS;
01962 return rsbac_ta_list_lol_add_ttl(ta_number,
01963 task_set_handle, 0,
01964 &id.task_set, NULL);
01965 case PS_TP:
01966
01967
01968
01969 if (rsbac_ta_list_lol_exist
01970 (ta_number, tp_set_handle, &id.tp_set))
01971 return -RSBAC_EEXISTS;
01972 return rsbac_ta_list_lol_add_ttl(ta_number, tp_set_handle,
01973 0, &id.tp_set, NULL);
01974 case PS_RU:
01975
01976
01977
01978 if (rsbac_ta_list_lol_exist
01979 (ta_number, ru_set_handle, &id.ru_set))
01980 return -RSBAC_EEXISTS;
01981 return rsbac_ta_list_lol_add_ttl(ta_number, ru_set_handle,
01982 0, &id.ru_set, NULL);
01983 case PS_PP:
01984
01985
01986
01987 if (rsbac_ta_list_lol_exist
01988 (ta_number, pp_set_handle, &id.pp_set))
01989 return -RSBAC_EEXISTS;
01990 return rsbac_ta_list_lol_add_ttl(ta_number, pp_set_handle,
01991 0, &id.pp_set, NULL);
01992 case PS_IN_PP:
01993
01994
01995
01996 if (rsbac_ta_list_lol_exist
01997 (ta_number, in_pp_set_handle, &id.in_pp_set))
01998 return -RSBAC_EEXISTS;
01999 return rsbac_ta_list_lol_add_ttl(ta_number,
02000 in_pp_set_handle, 0,
02001 &id.in_pp_set, NULL);
02002 case PS_OUT_PP:
02003
02004
02005
02006 if (rsbac_ta_list_lol_exist
02007 (ta_number, out_pp_set_handle, &id.out_pp_set))
02008 return -RSBAC_EEXISTS;
02009 return rsbac_ta_list_lol_add_ttl(ta_number,
02010 out_pp_set_handle, 0,
02011 &id.out_pp_set, NULL);
02012
02013 default:
02014 return (-RSBAC_EINVALIDTARGET);
02015 }
02016 }
02017
02018
02019
02020
02021 rsbac_boolean_t rsbac_pm_set_exist(rsbac_list_ta_number_t ta_number,
02022 enum rsbac_pm_set_t set,
02023 union rsbac_pm_set_id_t id)
02024 {
02025 switch (set) {
02026 case PS_TASK:
02027 return rsbac_ta_list_lol_exist(ta_number, task_set_handle,
02028 &id.task_set);
02029 case PS_TP:
02030 return rsbac_ta_list_lol_exist(ta_number, tp_set_handle,
02031 &id.tp_set);
02032 case PS_RU:
02033 return rsbac_ta_list_lol_exist(ta_number, ru_set_handle,
02034 &id.ru_set);
02035 case PS_PP:
02036 return rsbac_ta_list_lol_exist(ta_number, pp_set_handle,
02037 &id.pp_set);
02038 case PS_IN_PP:
02039 return rsbac_ta_list_lol_exist(ta_number, in_pp_set_handle,
02040 &id.in_pp_set);
02041 case PS_OUT_PP:
02042 return rsbac_ta_list_lol_exist(ta_number,
02043 out_pp_set_handle,
02044 &id.out_pp_set);
02045
02046 default:
02047 return FALSE;
02048 }
02049 }
02050
02051
02052
02053
02054
02055
02056
02057 int rsbac_pm_remove_set(rsbac_list_ta_number_t ta_number,
02058 enum rsbac_pm_set_t set,
02059 union rsbac_pm_set_id_t id)
02060 {
02061 switch (set) {
02062 case PS_TASK:
02063 return rsbac_ta_list_lol_remove(ta_number, task_set_handle,
02064 &id.task_set);
02065 case PS_TP:
02066 return rsbac_ta_list_lol_remove(ta_number, tp_set_handle,
02067 &id.tp_set);
02068 case PS_RU:
02069 return rsbac_ta_list_lol_remove(ta_number, ru_set_handle,
02070 &id.ru_set);
02071 case PS_PP:
02072 return rsbac_ta_list_lol_remove(ta_number, pp_set_handle,
02073 &id.pp_set);
02074 case PS_IN_PP:
02075 return rsbac_ta_list_lol_remove(ta_number,
02076 in_pp_set_handle,
02077 &id.in_pp_set);
02078 case PS_OUT_PP:
02079 return rsbac_ta_list_lol_remove(ta_number,
02080 out_pp_set_handle,
02081 &id.out_pp_set);
02082
02083 default:
02084 return -RSBAC_EINVALIDTARGET;
02085 }
02086 }
02087
02088
02089
02090
02091
02092
02093
02094
02095
02096
02097
02098
02099
02100 int rsbac_pm_get_data(rsbac_list_ta_number_t ta_number,
02101 enum rsbac_pm_target_t target,
02102 union rsbac_pm_target_id_t tid,
02103 enum rsbac_pm_data_t data,
02104 union rsbac_pm_data_value_t *value)
02105 {
02106 int err = 0;
02107
02108 if (!value)
02109 return (-RSBAC_EINVALIDVALUE);
02110
02111 switch (target) {
02112 case PMT_TASK:
02113 {
02114 struct rsbac_pm_task_data_t all_data;
02115
02116
02117
02118
02119 err =
02120 rsbac_ta_list_get_data_ttl(ta_number,
02121 task_handle, NULL,
02122 &tid.task,
02123 &all_data);
02124 if (err)
02125 return err;
02126
02127 switch (data) {
02128 case PD_purpose:
02129 value->purpose = all_data.purpose;
02130 break;
02131 case PD_tp_set:
02132 value->tp_set = all_data.tp_set;
02133 break;
02134 case PD_ru_set:
02135 value->ru_set = all_data.ru_set;
02136 break;
02137 default:
02138 return -RSBAC_EINVALIDATTR;
02139 }
02140 return 0;
02141 }
02142
02143 case PMT_CLASS:
02144 {
02145 struct rsbac_pm_class_data_t all_data;
02146
02147
02148
02149
02150 err =
02151 rsbac_ta_list_get_data_ttl(ta_number,
02152 class_handle, NULL,
02153 &tid.object_class,
02154 &all_data);
02155 if (err)
02156 return err;
02157
02158 switch (data) {
02159 case PD_pp_set:
02160 value->pp_set = all_data.pp_set;
02161 break;
02162 default:
02163 return -RSBAC_EINVALIDATTR;
02164 }
02165 return 0;
02166 }
02167
02168 case PMT_NA:
02169 {
02170 struct rsbac_pm_na_data_t all_data;
02171
02172
02173
02174
02175 err =
02176 rsbac_ta_list_get_data_ttl(ta_number,
02177 na_handle, NULL,
02178 &tid.na, &all_data);
02179 if (err)
02180 return err;
02181
02182 switch (data) {
02183 case PD_task:
02184 value->task = all_data.task;
02185 break;
02186 case PD_class:
02187 value->object_class =
02188 all_data.object_class;
02189 break;
02190 case PD_tp:
02191 value->tp = all_data.tp;
02192 break;
02193 case PD_accesses:
02194 value->accesses = all_data.accesses;
02195 break;
02196 default:
02197 return -RSBAC_EINVALIDATTR;
02198 }
02199 return 0;
02200 }
02201
02202 case PMT_CS:
02203 {
02204 struct rsbac_pm_cs_data_t all_data;
02205
02206
02207
02208
02209 err =
02210 rsbac_ta_list_get_data_ttl(ta_number,
02211 cs_handle, NULL,
02212 &tid.cs, &all_data);
02213 if (err)
02214 return err;
02215
02216 switch (data) {
02217 case PD_purpose:
02218 value->purpose = all_data.purpose;
02219 break;
02220 case PD_file:
02221 value->file = all_data.file;
02222 break;
02223 default:
02224 return -RSBAC_EINVALIDATTR;
02225 }
02226 return 0;
02227 }
02228
02229 case PMT_TP:
02230 {
02231 struct rsbac_pm_tp_data_t all_data;
02232
02233
02234
02235
02236 err =
02237 rsbac_ta_list_get_data_ttl(ta_number,
02238 tp_handle, NULL,
02239 &tid.tp, &all_data);
02240 if (err)
02241 return err;
02242
02243 switch (data) {
02244 case PD_tp:
02245 value->tp = all_data.id;
02246 break;
02247 default:
02248 return -RSBAC_EINVALIDATTR;
02249 }
02250 return 0;
02251 }
02252
02253 case PMT_PP:
02254 {
02255 struct rsbac_pm_pp_data_t all_data;
02256
02257
02258
02259
02260 err =
02261 rsbac_ta_list_get_data_ttl(ta_number,
02262 pp_handle, NULL,
02263 &tid.pp, &all_data);
02264 if (err)
02265 return err;
02266
02267 switch (data) {
02268 case PD_purpose:
02269 value->purpose = all_data.id;
02270 break;
02271 case PD_def_class:
02272 value->def_class = all_data.def_class;
02273 break;
02274 default:
02275 return -RSBAC_EINVALIDATTR;
02276 }
02277 return 0;
02278 }
02279
02280 case PMT_TKT:
02281 {
02282 struct rsbac_pm_tkt_data_t all_data;
02283
02284
02285
02286
02287 err =
02288 rsbac_ta_list_get_data_ttl(ta_number,
02289 tkt_handle, NULL,
02290 &tid.tkt,
02291 &all_data);
02292 if (err)
02293 return err;
02294
02295 switch (data) {
02296 case PD_issuer:
02297 value->issuer = all_data.issuer;
02298 break;
02299 case PD_function_type:
02300 value->function_type =
02301 all_data.function_type;
02302 break;
02303 case PD_function_param:
02304 value->function_param =
02305 all_data.function_param;
02306 break;
02307 case PD_valid_until:
02308 value->valid_until = all_data.valid_until;
02309 break;
02310 default:
02311 return -RSBAC_EINVALIDATTR;
02312 }
02313 return 0;
02314 }
02315
02316
02317 default:
02318 return (-RSBAC_EINVALIDTARGET);
02319 }
02320 };
02321
02322
02323
02324 int rsbac_pm_get_all_data(rsbac_list_ta_number_t ta_number,
02325 enum rsbac_pm_target_t target,
02326 union rsbac_pm_target_id_t tid,
02327 union rsbac_pm_all_data_value_t *value)
02328 {
02329 if (!value)
02330 return (-RSBAC_EINVALIDVALUE);
02331 switch (target) {
02332 case PMT_TASK:
02333
02334
02335
02336 return rsbac_ta_list_get_data_ttl(ta_number, task_handle,
02337 NULL, &tid.task,
02338 &value->task);
02339
02340 case PMT_CLASS:
02341
02342
02343
02344 return rsbac_ta_list_get_data_ttl(ta_number, class_handle,
02345 NULL, &tid.object_class,
02346 &value->object_class);
02347
02348 case PMT_NA:
02349
02350
02351
02352 return rsbac_ta_list_get_data_ttl(ta_number, na_handle,
02353 NULL, &tid.na,
02354 &value->na);
02355
02356 case PMT_CS:
02357
02358
02359
02360 return rsbac_ta_list_get_data_ttl(ta_number, cs_handle,
02361 NULL, &tid.cs,
02362 &value->cs);
02363
02364 case PMT_TP:
02365
02366
02367
02368 return rsbac_ta_list_get_data_ttl(ta_number, tp_handle,
02369 NULL, &tid.tp,
02370 &value->tp);
02371
02372 case PMT_PP:
02373
02374
02375
02376 return rsbac_ta_list_get_data_ttl(ta_number, pp_handle,
02377 NULL, &tid.pp,
02378 &value->pp);
02379
02380 case PMT_TKT:
02381
02382
02383
02384 return rsbac_ta_list_get_data_ttl(ta_number, tkt_handle,
02385 NULL, &tid.tkt,
02386 &value->tkt);
02387
02388
02389 default:
02390 return (-RSBAC_EINVALIDTARGET);
02391 }
02392 }
02393
02394
02395
02396 rsbac_boolean_t rsbac_pm_exists(rsbac_list_ta_number_t ta_number,
02397 enum rsbac_pm_target_t target,
02398 union rsbac_pm_target_id_t tid)
02399 {
02400 switch (target) {
02401 case PMT_TASK:
02402 return rsbac_ta_list_exist(ta_number, task_handle,
02403 &tid.task);
02404
02405 case PMT_CLASS:
02406
02407 if ((tid.object_class == RSBAC_PM_IPC_OBJECT_CLASS_ID)
02408 || (tid.object_class == RSBAC_PM_DEV_OBJECT_CLASS_ID))
02409 return (TRUE);
02410 return rsbac_ta_list_exist(ta_number, class_handle,
02411 &tid.object_class);
02412
02413 case PMT_NA:
02414 return rsbac_ta_list_exist(ta_number, na_handle, &tid.na);
02415
02416 case PMT_CS:
02417 return rsbac_ta_list_exist(ta_number, cs_handle, &tid.cs);
02418
02419 case PMT_TP:
02420 return rsbac_ta_list_exist(ta_number, tp_handle, &tid.tp);
02421
02422 case PMT_PP:
02423 return rsbac_ta_list_exist(ta_number, pp_handle, &tid.pp);
02424
02425 case PMT_TKT:
02426 {
02427 struct rsbac_pm_tkt_data_t all_data;
02428
02429 if (rsbac_ta_list_get_data_ttl
02430 (ta_number, tkt_handle, NULL, &tid.tkt,
02431 &all_data))
02432 return FALSE;
02433
02434
02435 {
02436 if (all_data.valid_until <
02437 RSBAC_CURRENT_TIME) {
02438 rsbac_pm_pp_set_id_t pp_set =
02439 -tid.tkt;
02440
02441 if (rsbac_ta_list_lol_exist
02442 (ta_number, pp_set_handle,
02443 &pp_set))
02444 rsbac_ta_list_lol_remove
02445 (ta_number,
02446 pp_set_handle,
02447 &pp_set);
02448 rsbac_ta_list_remove(ta_number,
02449 tkt_handle,
02450 &tid.tkt);
02451 return (FALSE);
02452 } else
02453 return TRUE;
02454 }
02455 }
02456
02457 default:
02458 rsbac_printk(KERN_WARNING "rsbac_pm_exists(): Invalid target!\n");
02459 return FALSE;
02460 }
02461 }
02462
02463
02464
02465 int rsbac_pm_set_data(rsbac_list_ta_number_t ta_number,
02466 enum rsbac_pm_target_t target,
02467 union rsbac_pm_target_id_t tid,
02468 enum rsbac_pm_data_t data,
02469 union rsbac_pm_data_value_t value)
02470 {
02471 switch (target) {
02472 case PMT_TASK:
02473 {
02474 struct rsbac_pm_task_data_t all_data;
02475 int err;
02476
02477
02478
02479
02480 err =
02481 rsbac_ta_list_get_data_ttl(ta_number,
02482 task_handle, NULL,
02483 &tid.task,
02484 &all_data);
02485 if (err)
02486 return err;
02487
02488 switch (data) {
02489 case PD_purpose:
02490 all_data.purpose = value.purpose;
02491 break;
02492 case PD_tp_set:
02493 all_data.tp_set = value.tp_set;
02494 break;
02495 case PD_ru_set:
02496 all_data.ru_set = value.ru_set;
02497 break;
02498 default:
02499 return -RSBAC_EINVALIDATTR;
02500 }
02501 err =
02502 rsbac_ta_list_add_ttl(ta_number, task_handle,
02503 0, &tid.task, &all_data);
02504 return err;
02505 }
02506
02507 case PMT_CLASS:
02508 {
02509 struct rsbac_pm_class_data_t all_data;
02510 int err;
02511
02512
02513
02514
02515 err =
02516 rsbac_ta_list_get_data_ttl(ta_number,
02517 class_handle, NULL,
02518 &tid.object_class,
02519 &all_data);
02520 if (err)
02521 return err;
02522
02523 switch (data) {
02524 case PD_pp_set:
02525 all_data.pp_set = value.pp_set;
02526 break;
02527 default:
02528 return -RSBAC_EINVALIDATTR;
02529 }
02530 err =
02531 rsbac_ta_list_add_ttl(ta_number, class_handle,
02532 0, &tid.object_class,
02533 &all_data);
02534 return err;
02535 }
02536
02537 case PMT_NA:
02538 {
02539 struct rsbac_pm_na_data_t all_data;
02540 int err;
02541
02542
02543
02544
02545 err =
02546 rsbac_ta_list_get_data_ttl(ta_number,
02547 na_handle, NULL,
02548 &tid.na, &all_data);
02549 if (err)
02550 return err;
02551
02552 switch (data) {
02553 case PD_task:
02554 all_data.task = value.task;
02555 break;
02556 case PD_class:
02557 all_data.object_class = value.object_class;
02558 break;
02559 case PD_tp:
02560 all_data.tp = value.tp;
02561 break;
02562 case PD_accesses:
02563 all_data.accesses = value.accesses;
02564 break;
02565 default:
02566 return -RSBAC_EINVALIDATTR;
02567 }
02568 err =
02569 rsbac_ta_list_add_ttl(ta_number, na_handle, 0,
02570 &tid.na, &all_data);
02571 return err;
02572 }
02573
02574 case PMT_CS:
02575 {
02576 struct rsbac_pm_cs_data_t all_data;
02577 int err;
02578
02579
02580
02581
02582 err =
02583 rsbac_ta_list_get_data_ttl(ta_number,
02584 cs_handle, NULL,
02585 &tid.cs, &all_data);
02586 if (err)
02587 return err;
02588
02589 switch (data) {
02590 case PD_purpose:
02591 all_data.purpose = value.purpose;
02592 break;
02593 case PD_file:
02594 all_data.file = value.file;
02595 break;
02596 default:
02597 return -RSBAC_EINVALIDATTR;
02598 }
02599 err =
02600 rsbac_ta_list_add_ttl(ta_number, cs_handle, 0,
02601 &tid.cs, &all_data);
02602 return err;
02603 }
02604
02605 case PMT_TP:
02606 return -RSBAC_EINVALIDATTR;
02607
02608 case PMT_PP:
02609 {
02610 struct rsbac_pm_pp_data_t all_data;
02611 int err;
02612
02613
02614
02615
02616 err =
02617 rsbac_ta_list_get_data_ttl(ta_number,
02618 pp_handle, NULL,
02619 &tid.pp, &all_data);
02620 if (err)
02621 return err;
02622
02623 switch (data) {
02624 case PD_def_class:
02625 all_data.def_class = value.def_class;
02626 break;
02627 default:
02628 return -RSBAC_EINVALIDATTR;
02629 }
02630 err =
02631 rsbac_ta_list_add_ttl(ta_number, pp_handle, 0,
02632 &tid.pp, &all_data);
02633 return err;
02634 }
02635
02636 case PMT_TKT:
02637 {
02638 struct rsbac_pm_tkt_data_t all_data;
02639 int err;
02640
02641
02642
02643
02644 err =
02645 rsbac_ta_list_get_data_ttl(ta_number,
02646 tkt_handle, NULL,
02647 &tid.tkt,
02648 &all_data);
02649 if (err)
02650 return err;
02651
02652 switch (data) {
02653 case PD_issuer:
02654 all_data.issuer = value.issuer;
02655 break;
02656 case PD_function_type:
02657 all_data.function_type =
02658 value.function_type;
02659 break;
02660 case PD_function_param:
02661 all_data.function_param =
02662 value.function_param;
02663 break;
02664 case PD_valid_until:
02665 all_data.valid_until = value.valid_until;
02666 break;
02667 default:
02668 return -RSBAC_EINVALIDATTR;
02669 }
02670 err =
02671 rsbac_ta_list_add_ttl(ta_number, tkt_handle, 0,
02672 &tid.tkt, &all_data);
02673 return err;
02674 }
02675
02676
02677 default:
02678 return (-RSBAC_EINVALIDTARGET);
02679 }
02680 }
02681
02682
02683
02684 int rsbac_pm_add_target(rsbac_list_ta_number_t ta_number,
02685 enum rsbac_pm_target_t target,
02686 union rsbac_pm_all_data_value_t data)
02687 {
02688 switch (target) {
02689 case PMT_TASK:
02690
02691
02692
02693 return rsbac_ta_list_add_ttl(ta_number, task_handle, 0,
02694 &data.task.id, &data.task);
02695
02696 case PMT_CLASS:
02697
02698
02699
02700 return rsbac_ta_list_add_ttl(ta_number, class_handle, 0,
02701 &data.object_class.id,
02702 &data.object_class);
02703
02704 case PMT_NA:
02705 {
02706 struct rsbac_pm_na_id_t na_id;
02707
02708
02709
02710
02711 na_id.task = data.na.task;
02712 na_id.object_class = data.na.object_class;
02713 na_id.tp = data.na.tp;
02714 return rsbac_ta_list_add_ttl(ta_number, na_handle,
02715 0, &na_id, &data.na);
02716 }
02717
02718 case PMT_CS:
02719 {
02720 struct rsbac_pm_cs_id_t cs_id;
02721
02722
02723
02724
02725 cs_id.purpose = data.cs.purpose;
02726 cs_id.file = data.cs.file;
02727 return rsbac_ta_list_add_ttl(ta_number, cs_handle,
02728 0, &cs_id, &data.cs);
02729 }
02730
02731 case PMT_TP:
02732
02733
02734
02735 return rsbac_ta_list_add_ttl(ta_number, tp_handle, 0,
02736 &data.tp.id, &data.tp);
02737
02738 case PMT_PP:
02739
02740
02741
02742 return rsbac_ta_list_add_ttl(ta_number, pp_handle, 0,
02743 &data.pp.id, &data.pp);
02744
02745 case PMT_TKT:
02746
02747
02748
02749 return rsbac_ta_list_add_ttl(ta_number, tkt_handle, 0,
02750 &data.tkt.id, &data.tkt);
02751
02752
02753 default:
02754 return (-RSBAC_EINVALIDTARGET);
02755 }
02756 }
02757
02758
02759
02760 int rsbac_pm_remove_target(rsbac_list_ta_number_t ta_number,
02761 enum rsbac_pm_target_t target,
02762 union rsbac_pm_target_id_t tid)
02763 {
02764 switch (target) {
02765 case PMT_TASK:
02766
02767
02768
02769 return rsbac_ta_list_remove(ta_number, task_handle,
02770 &tid.task);
02771
02772 case PMT_CLASS:
02773
02774
02775
02776 return rsbac_ta_list_remove(ta_number, class_handle,
02777 &tid.object_class);
02778
02779 case PMT_NA:
02780
02781
02782
02783 return rsbac_ta_list_remove(ta_number, na_handle, &tid.na);
02784
02785 case PMT_CS:
02786
02787
02788
02789 return rsbac_ta_list_remove(ta_number, cs_handle, &tid.cs);
02790
02791 case PMT_TP:
02792
02793
02794
02795 return rsbac_ta_list_remove(ta_number, tp_handle, &tid.tp);
02796
02797 case PMT_PP:
02798
02799
02800
02801 return rsbac_ta_list_remove(ta_number, pp_handle, &tid.pp);
02802
02803 case PMT_TKT:
02804 {
02805 rsbac_pm_pp_set_id_t pp_set = -tid.tkt;
02806
02807
02808
02809
02810 if (rsbac_ta_list_lol_exist
02811 (ta_number, pp_set_handle, &pp_set))
02812 rsbac_ta_list_lol_remove(ta_number,
02813 pp_set_handle,
02814 &pp_set);
02815 return rsbac_ta_list_remove(ta_number, tkt_handle,
02816 &tid.tkt);
02817 }
02818
02819 default:
02820 return (-RSBAC_EINVALIDTARGET);
02821 }
02822 };
02823