/daten/src/linux-2.4.27-rsbac-v1.2.3/rsbac/data_structures/pm_data_structures.c

Go to the documentation of this file.
00001 /*************************************************** */ 00002 /* Rule Set Based Access Control */ 00003 /* Implementation of PM data structures */ 00004 /* Author and (c) 1999-2004: Amon Ott <ao@rsbac.org> */ 00005 /* */ 00006 /* Last modified: 16/Jun/2004 */ 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 /* Global Variables */ 00034 /************************************************************************** */ 00035 00036 /* The following global variables are needed for access to PM data. */ 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 /* Declarations of external functions */ 00055 /**************************************************/ 00056 00057 int sys_write(u_int,char *, u_int); 00058 00059 /**************************************************/ 00060 /* Declarations of internal functions */ 00061 /**************************************************/ 00062 00063 /* As some function use later defined functions, we declare those here. */ 00064 00065 /************************************************* */ 00066 /* Internal Help functions */ 00067 /************************************************* */ 00068 00069 00070 /************************************************* */ 00071 /* proc functions */ 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 /* Helper lists */ 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 /* Main lists */ 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 /* list_proc_read() */ 00346 /* Generic readable list generation function */ 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 /* access control */ 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); /* something weird happened */ 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 /* !MAINT */ 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 }; /* end of list_proc_read */ 01153 01154 #endif /* CONFIG_PROC_FS && CONFIG_RSBAC_PROC */ 01155 01156 /************************************************* */ 01157 /* Init functions */ 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 /* All functions return 0, if no error occurred, and a negative error code */ 01191 /* otherwise. The error codes are defined in rsbac/error.h. */ 01192 01193 /************************************************************************** */ 01194 /* Initialization of all PM data structures. After this call, all PM data */ 01195 /* is kept in memory for performance reasons, but is written to disk on */ 01196 /* every change. */ 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 /* Helper lists */ 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 /* Main lists */ 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 /* We also need some status information... */ 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 /* Helper lists */ 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 /* Main lists */ 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 /* Access functions */ 01770 /************************************************* */ 01771 01772 /***********************/ 01773 /* Helper lists / sets */ 01774 /***********************/ 01775 01776 /* Trying to access a never created or removed set returns an error! */ 01777 01778 01779 /* rsbac_pm_add_to_set */ 01780 /* Add a set member to a set sublist. Set behaviour: also returns success, */ 01781 /* if member was already in set! */ 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 /* rsbac_pm_remove_from_set */ 01807 /* Remove a set member from a sublist. Set behaviour: Returns no error, if */ 01808 /* member is not in list. */ 01809 /* Caution: Writing to disk is not done in the remove functions! */ 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 /* rsbac_pm_clear_set */ 01835 /* Remove all set members from a sublist. Set behaviour: Returns no error, */ 01836 /* if list is empty. */ 01837 /* Caution: Writing to disk is not done in the remove functions! */ 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 /* rsbac_pm_set_member */ 01862 /* Return truth value, whether member is in set */ 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 /* rsbac_pm_pp_subset */ 01888 /* Return truth value, whether pp_set is subset of in_pp_set */ 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 /* get all pp_set members */ 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 /* check all members in in_pp_set */ 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 /* rsbac_pm_pp_superset */ 01926 /* Return truth value, whether pp_set is superset of out_pp_set */ 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 /* get all pp_set members */ 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 /* check all members in in_pp_set */ 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 /* rsbac_pm_pp_only */ 01961 /* Return truth value, if there is no other item in out_pp_set than purpose */ 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 /* get number of pp_set members */ 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 /* rsbac_pm_pp_intersec */ 01982 /* Create intersection of pp_set and in_pp_set in in_pp_set */ 01983 /* If in_pp_set does not exist, it is created with all members of pp_set */ 01984 /* If pp_set does not exist or one of them is invalid, an error is returned */ 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 { /* in_pp_set not found -> try to create and fill with pp_set */ 01998 if((count = rsbac_list_lol_add(in_pp_set_handle, &in_pp_set, NULL))) 01999 return count; 02000 /* creation successful -> copy list */ 02001 /* get all pp_set members */ 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 { /* in_pp_set exists -> remove all members not in pp_set */ 02013 /* get all in_pp_set members */ 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 /* rsbac_pm_pp_union */ 02028 /* Create union of pp_set and out_pp_set in out_pp_set 02029 * If out_pp_set does not exist, it is created with all members of pp_set 02030 * If pp_set does not exist or one of them is invalid, an error is returned */ 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 /* check, whether set-id pp_set exists */ 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 { /* out_pp_set not found -> try to create */ 02045 count = rsbac_list_lol_add(out_pp_set_handle, &out_pp_set, NULL); 02046 if(count) 02047 return count; 02048 } 02049 /* out_pp_set exists -> add all members in pp_set */ 02050 /* get all pp_set members */ 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 /* rsbac_pm_create_set */ 02063 /* Create a new set of given type set, using id id. Using any other set */ 02064 /* function for a set id without creating this set returns an error. */ 02065 /* To empty an existing set use rsbac_pm_clear_set. */ 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 #ifdef CONFIG_RSBAC_DEBUG 02075 if (rsbac_debug_ds_pm) 02076 printk(KERN_DEBUG "rsbac_pm_create_set(): Creating task set\n"); 02077 #endif 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 #ifdef CONFIG_RSBAC_DEBUG 02085 if (rsbac_debug_ds_pm) 02086 printk(KERN_DEBUG "rsbac_pm_create_set(): Creating tp set\n"); 02087 #endif 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 #ifdef CONFIG_RSBAC_DEBUG 02095 if (rsbac_debug_ds_pm) 02096 printk(KERN_DEBUG "rsbac_pm_create_set(): Creating ru set\n"); 02097 #endif 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 #ifdef CONFIG_RSBAC_DEBUG 02105 if (rsbac_debug_ds_pm) 02106 printk(KERN_DEBUG "rsbac_pm_create_set(): Creating pp set\n"); 02107 #endif 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 #ifdef CONFIG_RSBAC_DEBUG 02115 if (rsbac_debug_ds_pm) 02116 printk(KERN_DEBUG "rsbac_pm_create_set(): Creating in_pp set\n"); 02117 #endif 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 #ifdef CONFIG_RSBAC_DEBUG 02125 if (rsbac_debug_ds_pm) 02126 printk(KERN_DEBUG "rsbac_pm_create_set(): Creating out_pp set\n"); 02127 #endif 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 /* rsbac_pm_set_exist */ 02139 /* Return boolean value whether set exists */ 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 /* rsbac_pm_remove_set */ 02165 /* Remove a full set. After this call the given id can only be used for */ 02166 /* creating a new set, anything else returns an error. */ 02167 /* To empty an existing set use rsbac_pm_clear_set. */ 02168 /* Caution: Writing to disk is done in the remove_item functions! */ 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 /* Main lists */ 02195 /**************/ 02196 02197 /* rsbac_pm_get_data() and rsbac_pm_set_data() change single data values. */ 02198 /* rsbac_pm_add_target() adds a new list item and sets all data values as */ 02199 /* given. rsbac_pm_remove_target() removes an item. */ 02200 02201 /* A rsbac_pm_[sg]et_data() call for a non-existing target will return an */ 02202 /* error.*/ 02203 /* Invalid parameter combinations return an error. */ 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 #ifdef CONFIG_RSBAC_DEBUG 02223 if (rsbac_debug_ds_pm) 02224 printk(KERN_DEBUG 02225 "rsbac_pm_get_data(): Getting task data\n"); 02226 #endif 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 #ifdef CONFIG_RSBAC_DEBUG 02255 if (rsbac_debug_ds_pm) 02256 printk(KERN_DEBUG 02257 "rsbac_pm_get_data(): Getting class data\n"); 02258 #endif 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 #ifdef CONFIG_RSBAC_DEBUG 02281 if (rsbac_debug_ds_pm) 02282 printk(KERN_DEBUG 02283 "rsbac_pm_get_data(): Getting na data\n"); 02284 #endif 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 #ifdef CONFIG_RSBAC_DEBUG 02316 if (rsbac_debug_ds_pm) 02317 printk(KERN_DEBUG 02318 "rsbac_pm_get_data(): Getting cs data\n"); 02319 #endif 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 #ifdef CONFIG_RSBAC_DEBUG 02345 if (rsbac_debug_ds_pm) 02346 printk(KERN_DEBUG 02347 "rsbac_pm_get_data(): Getting tp data\n"); 02348 #endif 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 #ifdef CONFIG_RSBAC_DEBUG 02371 if (rsbac_debug_ds_pm) 02372 printk(KERN_DEBUG 02373 "rsbac_pm_get_data(): Getting pp data\n"); 02374 #endif 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 #ifdef CONFIG_RSBAC_DEBUG 02400 if (rsbac_debug_ds_pm) 02401 printk(KERN_DEBUG 02402 "rsbac_pm_get_data(): Getting tkt data\n"); 02403 #endif 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 /* switch target: no valid target */ 02430 default: 02431 return(-RSBAC_EINVALIDTARGET); 02432 } 02433 }; /* end of rsbac_pm_get_data() */ 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 #ifdef CONFIG_RSBAC_DEBUG 02448 if (rsbac_debug_ds_pm) 02449 printk(KERN_DEBUG 02450 "rsbac_pm_get_data(): Getting task data\n"); 02451 #endif 02452 */ 02453 return rsbac_list_get_data(task_handle, &tid.task, &value->task); 02454 02455 case PMT_CLASS: 02456 /* 02457 #ifdef CONFIG_RSBAC_DEBUG 02458 if (rsbac_debug_ds_pm) 02459 printk(KERN_DEBUG 02460 "rsbac_pm_get_data(): Getting class data\n"); 02461 #endif 02462 */ 02463 return rsbac_list_get_data(class_handle, &tid.object_class, &value->object_class); 02464 02465 case PMT_NA: 02466 /* 02467 #ifdef CONFIG_RSBAC_DEBUG 02468 if (rsbac_debug_ds_pm) 02469 printk(KERN_DEBUG 02470 "rsbac_pm_get_data(): Getting na data\n"); 02471 #endif 02472 */ 02473 return rsbac_list_get_data(na_handle, &tid.na, &value->na); 02474 02475 case PMT_CS: 02476 /* 02477 #ifdef CONFIG_RSBAC_DEBUG 02478 if (rsbac_debug_ds_pm) 02479 printk(KERN_DEBUG 02480 "rsbac_pm_get_data(): Getting cs data\n"); 02481 #endif 02482 */ 02483 return rsbac_list_get_data(cs_handle, &tid.cs, &value->cs); 02484 02485 case PMT_TP: 02486 /* 02487 #ifdef CONFIG_RSBAC_DEBUG 02488 if (rsbac_debug_ds_pm) 02489 printk(KERN_DEBUG 02490 "rsbac_pm_get_data(): Getting tp data\n"); 02491 #endif 02492 */ 02493 return rsbac_list_get_data(tp_handle, &tid.tp, &value->tp); 02494 02495 case PMT_PP: 02496 /* 02497 #ifdef CONFIG_RSBAC_DEBUG 02498 if (rsbac_debug_ds_pm) 02499 printk(KERN_DEBUG 02500 "rsbac_pm_get_data(): Getting pp data\n"); 02501 #endif 02502 */ 02503 return rsbac_list_get_data(pp_handle, &tid.pp, &value->pp); 02504 02505 case PMT_TKT: 02506 /* 02507 #ifdef CONFIG_RSBAC_DEBUG 02508 if (rsbac_debug_ds_pm) 02509 printk(KERN_DEBUG 02510 "rsbac_pm_get_data(): Getting tkt data\n"); 02511 #endif 02512 */ 02513 return rsbac_list_get_data(tkt_handle, &tid.tkt, &value->tkt); 02514 02515 /* switch target: no valid target */ 02516 default: 02517 return(-RSBAC_EINVALIDTARGET); 02518 } 02519 }; /* end of rsbac_pm_get_all_data() */ 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 /* IPC and DEV classes always exist */ 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 /* ticket too old? -> remove it and return FALSE */ 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 /* switch target: no valid target */ 02579 default: 02580 printk(KERN_WARNING 02581 "rsbac_pm_exists(): Invalid target!\n"); 02582 return FALSE; 02583 } 02584 }; /* end of rsbac_pm_exists() */ 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 #ifdef CONFIG_RSBAC_DEBUG 02602 if (rsbac_debug_ds_pm) 02603 printk(KERN_DEBUG 02604 "rsbac_pm_set_data(): Setting task data\n"); 02605 #endif 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 #ifdef CONFIG_RSBAC_DEBUG 02636 if (rsbac_debug_ds_pm) 02637 printk(KERN_DEBUG 02638 "rsbac_pm_set_data(): Setting class data\n"); 02639 #endif 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 #ifdef CONFIG_RSBAC_DEBUG 02664 if (rsbac_debug_ds_pm) 02665 printk(KERN_DEBUG 02666 "rsbac_pm_set_data(): Setting na data\n"); 02667 #endif 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 #ifdef CONFIG_RSBAC_DEBUG 02701 if (rsbac_debug_ds_pm) 02702 printk(KERN_DEBUG 02703 "rsbac_pm_set_data(): Setting cs data\n"); 02704 #endif 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 #ifdef CONFIG_RSBAC_DEBUG 02735 if (rsbac_debug_ds_pm) 02736 printk(KERN_DEBUG 02737 "rsbac_pm_set_data(): Setting pp data\n"); 02738 #endif 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 #ifdef CONFIG_RSBAC_DEBUG 02763 if (rsbac_debug_ds_pm) 02764 printk(KERN_DEBUG 02765 "rsbac_pm_set_data(): Setting tkt data\n"); 02766 #endif 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 /* switch target: no valid target */ 02794 default: 02795 return(-RSBAC_EINVALIDTARGET); 02796 } 02797 }; /* end of rsbac_pm_set_data() */ 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 #ifdef CONFIG_RSBAC_DEBUG 02809 if (rsbac_debug_ds_pm) 02810 printk(KERN_DEBUG 02811 "rsbac_pm_add_target(): Adding task item\n"); 02812 #endif 02813 */ 02814 return rsbac_list_add(task_handle, &data.task.id, &data.task); 02815 02816 case PMT_CLASS: 02817 /* 02818 #ifdef CONFIG_RSBAC_DEBUG 02819 if (rsbac_debug_ds_pm) 02820 printk(KERN_DEBUG 02821 "rsbac_pm_add_target(): Adding class item\n"); 02822 #endif 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 #ifdef CONFIG_RSBAC_DEBUG 02832 if (rsbac_debug_ds_pm) 02833 printk(KERN_DEBUG 02834 "rsbac_pm_add_target(): Adding na item\n"); 02835 #endif 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 #ifdef CONFIG_RSBAC_DEBUG 02849 if (rsbac_debug_ds_pm) 02850 printk(KERN_DEBUG 02851 "rsbac_pm_add_target(): Adding cs item\n"); 02852 #endif 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 #ifdef CONFIG_RSBAC_DEBUG 02862 if (rsbac_debug_ds_pm) 02863 printk(KERN_DEBUG 02864 "rsbac_pm_add_target(): Adding tp item\n"); 02865 #endif 02866 */ 02867 return rsbac_list_add(tp_handle, &data.tp.id, &data.tp); 02868 02869 case PMT_PP: 02870 /* 02871 #ifdef CONFIG_RSBAC_DEBUG 02872 if (rsbac_debug_ds_pm) 02873 printk(KERN_DEBUG 02874 "rsbac_pm_add_target(): Adding pp item\n"); 02875 #endif 02876 */ 02877 return rsbac_list_add(pp_handle, &data.pp.id, &data.pp); 02878 02879 case PMT_TKT: 02880 /* 02881 #ifdef CONFIG_RSBAC_DEBUG 02882 if (rsbac_debug_ds_pm) 02883 printk(KERN_DEBUG 02884 "rsbac_pm_add_target(): Adding tkt item\n"); 02885 #endif 02886 */ 02887 return rsbac_list_add(tkt_handle, &data.tkt.id, &data.tkt); 02888 02889 /* switch target: no valid target */ 02890 default: 02891 return(-RSBAC_EINVALIDTARGET); 02892 } 02893 }; /* end of rsbac_pm_add_target() */ 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 #ifdef CONFIG_RSBAC_DEBUG 02905 if (rsbac_debug_ds_pm) 02906 printk(KERN_DEBUG 02907 "rsbac_pm_remove_target(): Removing task data\n"); 02908 #endif 02909 */ 02910 return rsbac_list_remove(task_handle, &tid.task); 02911 02912 case PMT_CLASS: 02913 /* 02914 #ifdef CONFIG_RSBAC_DEBUG 02915 if (rsbac_debug_ds_pm) printk(KERN_DEBUG "%s\n", 02916 "rsbac_pm_remove_target(): Removing class data"); 02917 #endif 02918 */ 02919 return rsbac_list_remove(class_handle, &tid.object_class); 02920 02921 case PMT_NA: 02922 /* 02923 #ifdef CONFIG_RSBAC_DEBUG 02924 if (rsbac_debug_ds_pm) printk(KERN_DEBUG "%s\n", 02925 "rsbac_pm_remove_target(): Removing tp data"); 02926 #endif 02927 */ 02928 return rsbac_list_remove(na_handle, &tid.na); 02929 02930 case PMT_CS: 02931 /* 02932 #ifdef CONFIG_RSBAC_DEBUG 02933 if (rsbac_debug_ds_pm) printk(KERN_DEBUG "%s\n", 02934 "rsbac_pm_remove_target(): Removing cs data"); 02935 #endif 02936 */ 02937 return rsbac_list_remove(cs_handle, &tid.cs); 02938 02939 case PMT_TP: 02940 /* 02941 #ifdef CONFIG_RSBAC_DEBUG 02942 if (rsbac_debug_ds_pm) printk(KERN_DEBUG "%s\n", 02943 "rsbac_pm_remove_target(): Removing tp data"); 02944 #endif 02945 */ 02946 return rsbac_list_remove(tp_handle, &tid.tp); 02947 02948 case PMT_PP: 02949 /* 02950 #ifdef CONFIG_RSBAC_DEBUG 02951 if (rsbac_debug_ds_pm) printk(KERN_DEBUG "%s\n", 02952 "rsbac_pm_remove_target(): Removing pp data"); 02953 #endif 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 #ifdef CONFIG_RSBAC_DEBUG 02963 if (rsbac_debug_ds_pm) printk(KERN_DEBUG "%s\n", 02964 "rsbac_pm_remove_target(): Removing tkt data"); 02965 #endif 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 }; /* end of rsbac_remove_target() */ 02976 02977 /* end of pm_data_structures.c */

Generated on Tue Aug 31 10:05:26 2004 for RSBAC by doxygen 1.3.8