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