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

Generated on Wed May 16 11:53:45 2007 for RSBAC by  doxygen 1.5.1