#include <linux/sched.h>#include <linux/smp_lock.h>#include <linux/module.h>#include <asm/uaccess.h>#include <rsbac/types.h>#include <rsbac/error.h>#include <rsbac/helpers.h>#include <rsbac/getname.h>#include <rsbac/debug.h>#include <rsbac/adf.h>#include <rsbac/aci_data_structures.h>#include <rsbac/proc_fs.h>#include <rsbac/rkmem.h>#include <rsbac/lists.h>#include <rsbac/gen_lists.h>Go to the source code of this file.
|
|
Definition at line 3062 of file gen_lists.c. Referenced by rsbac_ta_list_lol_add_ttl(), rsbac_ta_list_lol_remove(), rsbac_ta_list_lol_remove_all(), rsbac_ta_list_lol_subadd_ttl(), rsbac_ta_list_lol_subremove(), rsbac_ta_list_lol_subremove_all(), and rsbac_ta_list_lol_subremove_from_all(). |
|
|
Definition at line 3053 of file gen_lists.c. Referenced by rsbac_ta_list_add_ttl(), rsbac_ta_list_remove(), and rsbac_ta_list_remove_all(). |
|
||||||||||||||||||||
|
Definition at line 1246 of file gen_lists.c. References insert_item_compare(), insert_item_memcmp(), NULL, and rsbac_kmalloc(). 01251 {
01252 struct rsbac_list_item_t * new_item_p = NULL;
01253
01254 if(!list || !desc)
01255 return NULL;
01256
01257 if(!list || !desc)
01258 return NULL;
01259 if(list->info.data_size && !data)
01260 return NULL;
01261 /* item desc and data are behind official struct */
01262 if ( !(new_item_p = rsbac_kmalloc(sizeof(*new_item_p) + list->info.desc_size + list->info.data_size)) )
01263 return(NULL);
01264 new_item_p->max_age = max_age;
01265 /* item desc is behind official struct */
01266 memcpy(&new_item_p[1],
01267 desc, list->info.desc_size);
01268 /* item data is behind official struct and desc */
01269 /* data might be empty! */
01270 if(data && list->info.data_size)
01271 memcpy(((__u8 *) new_item_p) + sizeof(*new_item_p) + list->info.desc_size,
01272 data,
01273 list->info.data_size);
01274
01275 if (!list->head)
01276 {
01277 list->head=new_item_p;
01278 list->tail=new_item_p;
01279 list->curr=new_item_p;
01280 list->count = 1;
01281 new_item_p->prev=NULL;
01282 new_item_p->next=NULL;
01283 return new_item_p;
01284 }
01285 if(list->compare)
01286 return insert_item_compare(list, desc, new_item_p);
01287 else
01288 return insert_item_memcmp(list, desc, new_item_p);
01289 }
|
|
||||||||||||||||||||
|
Definition at line 1949 of file gen_lists.c. References insert_lol_item_compare(), insert_lol_item_memcmp(), NULL, and rsbac_kmalloc(). Referenced by read_lol_list(), rsbac_ta_list_lol_add_ttl(), and rsbac_ta_list_lol_subadd_ttl(). 01954 {
01955 struct rsbac_list_lol_item_t * new_item_p = NULL;
01956
01957 if(!list || !desc)
01958 return NULL;
01959 if(list->info.data_size && !data)
01960 return NULL;
01961 /* item desc and data are behind official struct */
01962 if ( !(new_item_p = rsbac_kmalloc(sizeof(*new_item_p) + list->info.desc_size + list->info.data_size)) )
01963 return(NULL);
01964 /* Init sublist */
01965 new_item_p->head = NULL;
01966 new_item_p->tail = NULL;
01967 new_item_p->curr = NULL;
01968 new_item_p->count = 0;
01969 new_item_p->max_age = max_age;
01970 /* item desc is behind official struct */
01971 memcpy(&new_item_p[1],
01972 desc,
01973 list->info.desc_size);
01974 /* item data is behind official struct and desc */
01975 /* data might be empty! */
01976 if(data && list->info.data_size)
01977 memcpy(((__u8 *) new_item_p) + sizeof(*new_item_p) + list->info.desc_size,
01978 data,
01979 list->info.data_size);
01980
01981 if (!list->head)
01982 {
01983 list->head=new_item_p;
01984 list->tail=new_item_p;
01985 list->curr=new_item_p;
01986 list->count = 1;
01987 new_item_p->prev=NULL;
01988 new_item_p->next=NULL;
01989 return(new_item_p);
01990 }
01991 if(list->compare)
01992 return insert_lol_item_compare(list, desc, new_item_p);
01993 else
01994 return insert_lol_item_memcmp(list, desc, new_item_p);
01995 }
|
|
|
Definition at line 2386 of file gen_lists.c. References rsbac_list_lol_reg_head_t::count, rsbac_list_lol_reg_head_t::curr, rsbac_list_lol_reg_head_t::head, rsbac_list_lol_reg_item_t::next, NULL, rsbac_list_lol_reg_item_t::prev, and rsbac_list_lol_reg_head_t::tail. Referenced by rsbac_list_lol_register(). 02387 {
02388 if (!lol_reg_head.head)
02389 {
02390 lol_reg_head.head=new_item_p;
02391 lol_reg_head.tail=new_item_p;
02392 lol_reg_head.curr=new_item_p;
02393 lol_reg_head.count = 1;
02394 new_item_p->prev=NULL;
02395 new_item_p->next=NULL;
02396 }
02397 else
02398 {
02399 new_item_p->prev=lol_reg_head.tail;
02400 new_item_p->next=NULL;
02401 lol_reg_head.tail->next=new_item_p;
02402 lol_reg_head.tail=new_item_p;
02403 lol_reg_head.curr=new_item_p;
02404 lol_reg_head.count++;
02405 };
02406 return(new_item_p);
02407 }
|
|
||||||||||||||||||||||||
|
Definition at line 1770 of file gen_lists.c. References rsbac_list_lol_item_t::count, rsbac_list_lol_item_t::curr, rsbac_list_lol_item_t::head, insert_lol_subitem_compare(), insert_lol_subitem_memcmp(), NULL, rsbac_kmalloc(), and rsbac_list_lol_item_t::tail. Referenced by read_lol_list(), and rsbac_ta_list_lol_subadd_ttl(). 01776 {
01777 struct rsbac_list_item_t * new_item_p = NULL;
01778
01779 if(!list || !sublist || !subdesc)
01780 return NULL;
01781 if(list->info.subdata_size && !subdata)
01782 return NULL;
01783 /* item desc and data are behind official struct */
01784 if ( !(new_item_p = rsbac_kmalloc(sizeof(*new_item_p) + list->info.subdesc_size + list->info.subdata_size)) )
01785 return(NULL);
01786 new_item_p->max_age = max_age;
01787 /* item desc is behind official struct */
01788 memcpy(&new_item_p[1],
01789 subdesc,
01790 list->info.subdesc_size);
01791 /* item data is behind official struct and desc */
01792 /* subdata might be empty! */
01793 if(subdata && list->info.subdata_size)
01794 memcpy(((__u8 *) new_item_p) + sizeof(*new_item_p) + list->info.subdesc_size,
01795 subdata,
01796 list->info.subdata_size);
01797
01798 /* Sublist was empty */
01799 if (!sublist->head)
01800 {
01801 sublist->head=new_item_p;
01802 sublist->tail=new_item_p;
01803 sublist->curr=new_item_p;
01804 sublist->count = 1;
01805 new_item_p->prev=NULL;
01806 new_item_p->next=NULL;
01807 return(new_item_p);
01808 }
01809 if(list->subcompare)
01810 return insert_lol_subitem_compare(list, sublist, subdesc, new_item_p);
01811 else
01812 return insert_lol_subitem_memcmp(list, sublist, subdesc, new_item_p);
01813 }
|
|
|
Definition at line 2271 of file gen_lists.c. References rsbac_list_reg_head_t::count, rsbac_list_reg_head_t::curr, rsbac_list_reg_head_t::head, rsbac_list_reg_item_t::next, NULL, rsbac_list_reg_item_t::prev, and rsbac_list_reg_head_t::tail. Referenced by rsbac_list_register(). 02272 {
02273 if (!reg_head.head)
02274 {
02275 reg_head.head=new_item_p;
02276 reg_head.tail=new_item_p;
02277 reg_head.curr=new_item_p;
02278 reg_head.count = 1;
02279 new_item_p->prev=NULL;
02280 new_item_p->next=NULL;
02281 }
02282 else
02283 {
02284 new_item_p->prev=reg_head.tail;
02285 new_item_p->next=NULL;
02286 reg_head.tail->next=new_item_p;
02287 reg_head.tail=new_item_p;
02288 reg_head.curr=new_item_p;
02289 reg_head.count++;
02290 };
02291 return(new_item_p);
02292 }
|
|
|
Definition at line 2987 of file gen_lists.c. References rsbac_list_lol_reg_item_t::def_data, rsbac_list_lol_reg_item_t::def_subdata, remove_all_lol_items(), and rsbac_kfree(). Referenced by remove_lol_reg(), and rsbac_list_lol_register(). 02988 {
02989 if(item_p)
02990 {
02991 /* now we can remove the item from memory */
02992 remove_all_lol_items(item_p);
02993 if(item_p->def_data)
02994 rsbac_kfree(item_p->def_data);
02995 if(item_p->def_subdata)
02996 rsbac_kfree(item_p->def_subdata);
02997 rsbac_kfree(item_p);
02998 }
02999 }
|
|
|
Definition at line 2928 of file gen_lists.c. References rsbac_list_reg_item_t::def_data, remove_all_items(), and rsbac_kfree(). Referenced by remove_reg(), and rsbac_list_register(). 02929 {
02930 if(item_p)
02931 {
02932 /* now we can remove the item from memory */
02933 remove_all_items(item_p);
02934 if(item_p->def_data)
02935 rsbac_kfree(item_p->def_data);
02936 rsbac_kfree(item_p);
02937 }
02938 }
|
|
||||||||||||||||||||||||||||||||||||||||||||
|
Definition at line 2296 of file gen_lists.c. References rsbac_list_lol_info_t::data_size, FALSE, NULL, rsbac_kfree(), rsbac_kmalloc(), RSBAC_LIST_DEF_DATA, RSBAC_LIST_DEF_SUBDATA, RSBAC_LIST_MAX_FILENAME, RSBAC_LIST_NO_WRITE, RSBAC_LIST_NONAME, rsbac_list_lol_info_t::subdata_size, and TRUE. Referenced by rsbac_list_lol_register(). 02306 {
02307 struct rsbac_list_lol_reg_item_t * new_item_p = NULL;
02308
02309 if ( !(new_item_p = rsbac_kmalloc(sizeof(*new_item_p))) )
02310 return(NULL);
02311 new_item_p->info = *info_p;
02312 if(info_p->data_size && !def_data)
02313 flags &= ~RSBAC_LIST_DEF_DATA;
02314 if(!def_subdata)
02315 flags &= ~RSBAC_LIST_DEF_SUBDATA;
02316 new_item_p->flags = flags;
02317 new_item_p->compare = compare;
02318 new_item_p->subcompare = subcompare;
02319 new_item_p->get_conv = get_conv;
02320 new_item_p->get_subconv = get_subconv;
02321 if( (flags & RSBAC_LIST_DEF_DATA)
02322 && (info_p->data_size)
02323 )
02324 {
02325 new_item_p->def_data = rsbac_kmalloc(info_p->data_size);
02326 if(new_item_p->def_data)
02327 memcpy(new_item_p->def_data, def_data, info_p->data_size);
02328 else
02329 {
02330 rsbac_kfree(new_item_p);
02331 return NULL;
02332 }
02333 }
02334 else
02335 new_item_p->def_data = NULL;
02336 if(flags & RSBAC_LIST_DEF_SUBDATA)
02337 {
02338 new_item_p->def_subdata = rsbac_kmalloc(info_p->subdata_size);
02339 if(new_item_p->def_subdata)
02340 memcpy(new_item_p->def_subdata, def_subdata, info_p->subdata_size);
02341 else
02342 {
02343 if(new_item_p->def_data)
02344 rsbac_kfree(new_item_p->def_data);
02345 rsbac_kfree(new_item_p);
02346 return NULL;
02347 }
02348 }
02349 else
02350 new_item_p->def_subdata = NULL;
02351 if(name)
02352 {
02353 strncpy(new_item_p->name, name, RSBAC_LIST_MAX_FILENAME);
02354 new_item_p->name[RSBAC_LIST_MAX_FILENAME] = 0;
02355 }
02356 else
02357 {
02358 strcpy(new_item_p->name, RSBAC_LIST_NONAME);
02359 }
02360 new_item_p->device = device;
02361 new_item_p->head = NULL;
02362 new_item_p->tail = NULL;
02363 new_item_p->curr = NULL;
02364 new_item_p->lock = RW_LOCK_UNLOCKED;
02365 new_item_p->count = 0;
02366 new_item_p->dirty = FALSE;
02367 if(flags & RSBAC_LIST_NO_WRITE)
02368 new_item_p->no_write = TRUE;
02369 else
02370 new_item_p->no_write = FALSE;
02371 new_item_p->lastchange.sec = 0;
02372 new_item_p->lastchange.nsec = 0;
02373 #ifdef CONFIG_RSBAC_LIST_TRANS
02374 new_item_p->ta_copied = FALSE;
02375 new_item_p->ta_head = NULL;
02376 new_item_p->ta_tail = NULL;
02377 new_item_p->ta_curr = NULL;
02378 new_item_p->ta_count = 0;
02379 #endif
02380 new_item_p->self = new_item_p;
02381 return(new_item_p);
02382 }
|
|
||||||||||||||||||||||||||||||||
|
Definition at line 2205 of file gen_lists.c. References rsbac_list_info_t::data_size, FALSE, NULL, rsbac_kfree(), rsbac_kmalloc(), RSBAC_LIST_DEF_DATA, RSBAC_LIST_MAX_FILENAME, RSBAC_LIST_NO_WRITE, RSBAC_LIST_NONAME, and TRUE. Referenced by rsbac_list_register(). 02212 {
02213 struct rsbac_list_reg_item_t * new_item_p = NULL;
02214
02215 if ( !(new_item_p = rsbac_kmalloc(sizeof(*new_item_p))) )
02216 return(NULL);
02217 new_item_p->info = *info_p;
02218 if(!def_data)
02219 flags &= ~RSBAC_LIST_DEF_DATA;
02220 new_item_p->flags = flags;
02221 new_item_p->compare = compare;
02222 new_item_p->get_conv = get_conv;
02223 if(flags & RSBAC_LIST_DEF_DATA)
02224 {
02225 new_item_p->def_data = rsbac_kmalloc(info_p->data_size);
02226 if(new_item_p->def_data)
02227 memcpy(new_item_p->def_data, def_data, info_p->data_size);
02228 else
02229 {
02230 rsbac_kfree(new_item_p);
02231 return NULL;
02232 }
02233 }
02234 else
02235 new_item_p->def_data = NULL;
02236 if(name)
02237 {
02238 strncpy(new_item_p->name, name, RSBAC_LIST_MAX_FILENAME);
02239 new_item_p->name[RSBAC_LIST_MAX_FILENAME] = 0;
02240 }
02241 else
02242 {
02243 strcpy(new_item_p->name, RSBAC_LIST_NONAME);
02244 }
02245 new_item_p->device = device;
02246 new_item_p->head = NULL;
02247 new_item_p->tail = NULL;
02248 new_item_p->curr = NULL;
02249 new_item_p->lock = RW_LOCK_UNLOCKED;
02250 new_item_p->count = 0;
02251 new_item_p->dirty = FALSE;
02252 if(flags & RSBAC_LIST_NO_WRITE)
02253 new_item_p->no_write = TRUE;
02254 else
02255 new_item_p->no_write = FALSE;
02256 new_item_p->lastchange.sec = 0;
02257 new_item_p->lastchange.nsec = 0;
02258 #ifdef CONFIG_RSBAC_LIST_TRANS
02259 new_item_p->ta_copied = FALSE;
02260 new_item_p->ta_head = NULL;
02261 new_item_p->ta_tail = NULL;
02262 new_item_p->ta_curr = NULL;
02263 new_item_p->ta_count = 0;
02264 #endif
02265 new_item_p->self = new_item_p;
02266 return new_item_p;
02267 }
|
|
||||||||||||
|
Definition at line 2411 of file gen_lists.c. References rsbac_list_reg_item_t::count, rsbac_list_reg_item_t::curr, rsbac_list_reg_item_t::head, rsbac_list_item_t::next, NULL, rsbac_list_item_t::prev, rsbac_kfree(), and rsbac_list_reg_item_t::tail. Referenced by remove_item(), rsbac_check_lists(), rsbac_list_check(), and rsbac_ta_list_add_ttl(). 02414 {
02415 if(!list || !item_p)
02416 return;
02417
02418 if ( (list->head == item_p) )
02419 { /* item is head */
02420 if ( (list->tail == item_p) )
02421 { /* item is head and tail = only item -> list will be empty*/
02422 list->head = NULL;
02423 list->tail = NULL;
02424 }
02425 else
02426 { /* item is head, but not tail -> next item becomes head */
02427 item_p->next->prev = NULL;
02428 list->head = item_p->next;
02429 };
02430 }
02431 else
02432 { /* item is not head */
02433 if ( (list->tail == item_p) )
02434 { /*item is not head, but tail -> previous item becomes tail*/
02435 item_p->prev->next = NULL;
02436 list->tail = item_p->prev;
02437 }
02438 else
02439 { /* item is neither head nor tail -> item is cut out */
02440 item_p->prev->next = item_p->next;
02441 item_p->next->prev = item_p->prev;
02442 }
02443 }
02444 /* curr is no longer valid -> reset */
02445 list->curr=NULL;
02446 /* adjust counter */
02447 list->count--;
02448 /* now we can remove the item from memory */
02449 rsbac_kfree(item_p);
02450 } /* end of do_remove_item() */
|
|
||||||||||||
|
Definition at line 2625 of file gen_lists.c. References rsbac_list_lol_reg_item_t::count, rsbac_list_lol_reg_item_t::curr, rsbac_list_lol_item_t::head, rsbac_list_lol_reg_item_t::head, rsbac_list_lol_reg_item_t::name, rsbac_list_item_t::next, rsbac_list_lol_item_t::next, NULL, rsbac_list_lol_item_t::prev, rsbac_kfree(), rsbac_printk(), and rsbac_list_lol_reg_item_t::tail. Referenced by remove_lol_item(), rsbac_check_lists(), rsbac_list_lol_check(), rsbac_ta_list_lol_add_ttl(), and rsbac_ta_list_lol_subremove(). 02628 {
02629 struct rsbac_list_item_t * subitem_p;
02630 struct rsbac_list_item_t * next_subitem_p;
02631
02632 if(!list || !item_p)
02633 return;
02634
02635 if ( (list->head == item_p) )
02636 { /* item is head */
02637 if ( (list->tail == item_p) )
02638 { /* item is head and tail = only item -> list will be empty*/
02639 list->head = NULL;
02640 list->tail = NULL;
02641 }
02642 else
02643 { /* item is head, but not tail -> next item becomes head */
02644 #ifdef CONFIG_RSBAC_DEBUG
02645 if(!item_p->next)
02646 { /* list corrupted! */
02647 rsbac_printk(KERN_WARNING
02648 "do_remove_lol_item(): list %s corrupted: invalid next!\n",
02649 list->name);
02650 }
02651 else
02652 #endif
02653 {
02654 item_p->next->prev = NULL;
02655 list->head = item_p->next;
02656 }
02657 }
02658 }
02659 else
02660 { /* item is not head */
02661 if ( (list->tail == item_p) )
02662 { /*item is not head, but tail -> previous item becomes tail*/
02663 #ifdef CONFIG_RSBAC_DEBUG
02664 if(!item_p->prev)
02665 { /* list corrupted! */
02666 rsbac_printk(KERN_WARNING
02667 "do_remove_lol_item(): list %s corrupted: invalid prev!\n",
02668 list->name);
02669 }
02670 else
02671 #endif
02672 {
02673 item_p->prev->next = NULL;
02674 list->tail = item_p->prev;
02675 }
02676 }
02677 else
02678 { /* item is neither head nor tail -> item is cut out */
02679 #ifdef CONFIG_RSBAC_DEBUG
02680 if(!item_p->prev)
02681 { /* list corrupted! */
02682 rsbac_printk(KERN_WARNING
02683 "do_remove_lol_item(): list %s corrupted: invalid prev!\n",
02684 list->name);
02685 }
02686 else
02687 if(!item_p->next)
02688 { /* list corrupted! */
02689 rsbac_printk(KERN_WARNING
02690 "do_remove_lol_item(): list %s corrupted: invalid next!\n",
02691 list->name);
02692 }
02693 else
02694 #endif
02695 {
02696 item_p->prev->next = item_p->next;
02697 item_p->next->prev = item_p->prev;
02698 }
02699 }
02700 }
02701 /* curr is no longer valid -> reset */
02702 list->curr=NULL;
02703 /* adjust counter */
02704 list->count--;
02705 /* first remove subitems */
02706 subitem_p = item_p->head;
02707 while(subitem_p)
02708 {
02709 next_subitem_p = subitem_p->next;
02710 rsbac_kfree(subitem_p);
02711 subitem_p = next_subitem_p;
02712 }
02713 /* now we can remove the item from memory */
02714 rsbac_kfree(item_p);
02715 }
|
|
||||||||||||
|
Definition at line 2566 of file gen_lists.c. References rsbac_list_lol_item_t::count, rsbac_list_lol_item_t::curr, rsbac_list_lol_item_t::head, rsbac_list_item_t::next, NULL, rsbac_list_item_t::prev, rsbac_kfree(), and rsbac_list_lol_item_t::tail. Referenced by remove_lol_subitem(), rsbac_check_lists(), rsbac_list_lol_check(), and rsbac_ta_list_lol_subadd_ttl(). 02569 {
02570 if(!sublist || !item_p)
02571 return;
02572
02573 if ( (sublist->head == item_p) )
02574 { /* item is head */
02575 if ( (sublist->tail == item_p) )
02576 { /* item is head and tail = only item -> list will be empty*/
02577 sublist->head = NULL;
02578 sublist->tail = NULL;
02579 }
02580 else
02581 { /* item is head, but not tail -> next item becomes head */
02582 item_p->next->prev = NULL;
02583 sublist->head = item_p->next;
02584 }
02585 }
02586 else
02587 { /* item is not head */
02588 if ( (sublist->tail == item_p) )
02589 { /*item is not head, but tail -> previous item becomes tail*/
02590 item_p->prev->next = NULL;
02591 sublist->tail = item_p->prev;
02592 }
02593 else
02594 { /* item is neither head nor tail -> item is cut out */
02595 item_p->prev->next = item_p->next;
02596 item_p->next->prev = item_p->prev;
02597 }
02598 }
02599 /* curr is no longer valid -> reset */
02600 sublist->curr=NULL;
02601 /* adjust counter */
02602 sublist->count--;
02603 /* now we can remove the item from memory */
02604 rsbac_kfree(item_p);
02605 }
|
|
||||||||||||
|
Definition at line 3923 of file gen_lists.c. References rsbac_list_reg_item_t::count, rsbac_list_info_t::data_size, rsbac_list_info_t::desc_size, rsbac_list_reg_item_t::device, FALSE, rsbac_list_reg_item_t::head, rsbac_list_reg_item_t::info, rsbac_list_reg_item_t::lastchange, rsbac_list_reg_item_t::lock, rsbac_list_item_t::max_age, rsbac_list_reg_item_t::name, NULL, RSBAC_ENOMEM, rsbac_kfree(), rsbac_kmalloc(), RSBAC_LIST_DISK_VERSION, RSBAC_LIST_MAX_FILENAME, and rsbac_vkmalloc(). Referenced by rsbac_list_detach(). 03925 {
03926 struct rsbac_list_write_item_t * write_item_p;
03927 struct rsbac_list_item_t * current_p;
03928 u_long flags;
03929 char * buffer = NULL;
03930 u_long buflen;
03931 u_long write_count = 0;
03932 rsbac_boolean_t vmalloc_used = FALSE;
03933 rsbac_version_t list_version = RSBAC_LIST_DISK_VERSION;
03934 rsbac_time_t timestamp = RSBAC_CURRENT_TIME;
03935
03936 write_item_p = rsbac_kmalloc(sizeof(*write_item_p));
03937 if(!write_item_p)
03938 {
03939 *write_item_pp = NULL;
03940 return(-RSBAC_ENOMEM);
03941 }
03942
03943 /* protect this list */
03944 rsbac_read_lock(&list->lock, &flags);
03945 /* allocate mem */
03946 buflen = sizeof(list_version)
03947 + sizeof(timestamp)
03948 + sizeof(list->info)
03949 + sizeof(list->lastchange)
03950 + sizeof(list->count)
03951 + list->count * (sizeof(current_p->max_age) + list->info.desc_size + list->info.data_size);
03952 /* try to rsbac_vkmalloc */
03953 buffer = (char *) rsbac_vkmalloc(buflen, &vmalloc_used);
03954 if(!buffer)
03955 {
03956 /* unprotect this list */
03957 rsbac_read_unlock(&list->lock, &flags);
03958 rsbac_kfree(write_item_p);
03959 *write_item_pp = NULL;
03960 return(-RSBAC_ENOMEM);
03961 }
03962 /* copy version */
03963 memcpy(buffer,
03964 (char *) &list_version,
03965 sizeof(list_version));
03966 write_count = sizeof(list_version);
03967 /* copy timestamp */
03968 memcpy(buffer+write_count,
03969 (char *) ×tamp,
03970 sizeof(timestamp));
03971 write_count += sizeof(timestamp);
03972 /* copy info */
03973 memcpy(buffer+write_count,
03974 (char *) &list->info,
03975 sizeof(list->info));
03976 write_count += sizeof(list->info);
03977 /* copy lastchange */
03978 memcpy(buffer+write_count,
03979 (char *) &list->lastchange,
03980 sizeof(list->lastchange));
03981 write_count += sizeof(list->lastchange);
03982 /* copy count */
03983 memcpy(buffer+write_count,
03984 (char *) &list->count,
03985 sizeof(list->count));
03986 write_count += sizeof(list->count);
03987 /* copy list */
03988 current_p = list->head;
03989 while (current_p)
03990 {
03991 memcpy(buffer+write_count,
03992 ¤t_p->max_age,
03993 sizeof(current_p->max_age));
03994 write_count += sizeof(current_p->max_age);
03995 memcpy(buffer+write_count,
03996 ((char *) current_p) + sizeof(*current_p),
03997 list->info.desc_size + list->info.data_size);
03998 write_count += list->info.desc_size + list->info.data_size;
03999 current_p = current_p->next;
04000 }
04001
04002 /* fill write_item */
04003 write_item_p->prev = NULL;
04004 write_item_p->next = NULL;
04005 write_item_p->list = list;
04006 write_item_p->buflen = write_count;
04007 write_item_p->buf = buffer;
04008 write_item_p->vmalloc_used = vmalloc_used;
04009 strncpy(write_item_p->name, list->name, RSBAC_LIST_MAX_FILENAME);
04010 write_item_p->name[RSBAC_LIST_MAX_FILENAME] = 0;
04011 write_item_p->device = list->device;
04012
04013 *write_item_pp = write_item_p;
04014
04015 /* unprotect this list */
04016 rsbac_read_unlock(&list->lock, &flags);
04017
04018 return 0;
04019 }
|
|
||||||||||||
|
Definition at line 4131 of file gen_lists.c. References rsbac_list_lol_item_t::count, rsbac_list_lol_reg_item_t::count, rsbac_list_lol_info_t::data_size, rsbac_list_lol_info_t::desc_size, rsbac_list_lol_reg_item_t::device, FALSE, rsbac_list_lol_reg_item_t::head, rsbac_list_lol_reg_item_t::info, rsbac_list_lol_reg_item_t::lastchange, rsbac_list_lol_reg_item_t::lock, rsbac_list_item_t::max_age, rsbac_list_lol_item_t::max_age, rsbac_list_lol_reg_item_t::name, rsbac_list_lol_item_t::next, NULL, RSBAC_ENOMEM, rsbac_kfree(), rsbac_kmalloc(), RSBAC_LIST_DISK_VERSION, RSBAC_LIST_MAX_FILENAME, rsbac_vkmalloc(), rsbac_list_lol_info_t::subdata_size, and rsbac_list_lol_info_t::subdesc_size. Referenced by rsbac_list_lol_detach(). 04133 {
04134 struct rsbac_list_lol_write_item_t * write_item_p;
04135 struct rsbac_list_lol_item_t * current_p;
04136 struct rsbac_list_item_t * sub_p;
04137 u_long flags;
04138 char * buffer = NULL;
04139 u_long buflen;
04140 u_long write_count = 0;
04141 rsbac_boolean_t vmalloc_used = FALSE;
04142 rsbac_version_t list_version = RSBAC_LIST_DISK_VERSION;
04143 rsbac_time_t timestamp = RSBAC_CURRENT_TIME;
04144
04145 write_item_p = rsbac_kmalloc(sizeof(*write_item_p));
04146 if(!write_item_p)
04147 {
04148 *write_item_pp = NULL;
04149 return(-RSBAC_ENOMEM);
04150 }
04151
04152 /* protect this list */
04153 rsbac_read_lock(&list->lock, &flags);
04154
04155 /* allocate mem */
04156 buflen = sizeof(list_version)
04157 + sizeof(timestamp)
04158 + sizeof(list->info)
04159 + sizeof(list->lastchange)
04160 + sizeof(list->count)
04161 + list->count * (sizeof(current_p->max_age) + list->info.desc_size + list->info.data_size);
04162 current_p = list->head;
04163 while(current_p)
04164 {
04165 buflen += sizeof(current_p->count);
04166 buflen += current_p->count * (sizeof(current_p->max_age) + list->info.subdesc_size + list->info.subdata_size);
04167 current_p = current_p->next;
04168 }
04169 /* try to rsbac_vkmalloc */
04170 buffer = (char *) rsbac_vkmalloc(buflen, &vmalloc_used);
04171 if(!buffer)
04172 {
04173 /* unprotect this list */
04174 rsbac_read_unlock(&list->lock, &flags);
04175 rsbac_kfree(write_item_p);
04176 *write_item_pp = NULL;
04177 return(-RSBAC_ENOMEM);
04178 }
04179 /* copy version */
04180 memcpy(buffer,
04181 (char *) &list_version,
04182 sizeof(list_version));
04183 write_count = sizeof(list_version);
04184 /* copy timestamp */
04185 memcpy(buffer+write_count,
04186 (char *) ×tamp,
04187 sizeof(timestamp));
04188 write_count += sizeof(timestamp);
04189 /* copy info */
04190 memcpy(buffer+write_count,
04191 (char *) &list->info,
04192 sizeof(list->info));
04193 write_count += sizeof(list->info);
04194 /* copy lastchange */
04195 memcpy(buffer+write_count,
04196 (char *) &list->lastchange,
04197 sizeof(list->lastchange));
04198 write_count += sizeof(list->lastchange);
04199 /* copy count */
04200 memcpy(buffer+write_count,
04201 (char *) &list->count,
04202 sizeof(list->count));
04203 write_count += sizeof(list->count);
04204 /* copy list */
04205 current_p = list->head;
04206 while (current_p)
04207 {
04208 memcpy(buffer+write_count,
04209 ¤t_p->max_age,
04210 sizeof(current_p->max_age));
04211 write_count += sizeof(current_p->max_age);
04212 memcpy(buffer+write_count,
04213 ((char *) current_p) + sizeof(*current_p),
04214 list->info.desc_size + list->info.data_size);
04215 write_count += list->info.desc_size + list->info.data_size;
04216 memcpy(buffer+write_count,
04217 ¤t_p->count,
04218 sizeof(current_p->count));
04219 write_count += sizeof(current_p->count);
04220 /* copy subitems */
04221 sub_p = current_p->head;
04222 while (sub_p)
04223 {
04224 memcpy(buffer+write_count,
04225 &sub_p->max_age,
04226 sizeof(sub_p->max_age));
04227 write_count += sizeof(sub_p->max_age);
04228 memcpy(buffer+write_count,
04229 ((char *) sub_p) + sizeof(*sub_p),
04230 list->info.subdesc_size + list->info.subdata_size);
04231 write_count += list->info.subdesc_size + list->info.subdata_size;
04232 sub_p = sub_p->next;
04233 }
04234 current_p = current_p->next;
04235 }
04236
04237 /* fill write_item */
04238 write_item_p->prev = NULL;
04239 write_item_p->next = NULL;
04240 write_item_p->list = list;
04241 write_item_p->buflen = write_count;
04242 write_item_p->buf = buffer;
04243 write_item_p->vmalloc_used = vmalloc_used;
04244 strncpy(write_item_p->name, list->name, RSBAC_LIST_MAX_FILENAME);
04245 write_item_p->name[RSBAC_LIST_MAX_FILENAME] = 0;
04246 write_item_p->device = list->device;
04247 *write_item_pp = write_item_p;
04248
04249 /* unprotect this list */
04250 rsbac_read_unlock(&list->lock, &flags);
04251
04252 return 0;
04253 }
|
|
||||||||||||||||
|
Definition at line 1112 of file gen_lists.c. References rsbac_list_reg_item_t::compare, rsbac_list_reg_item_t::count, rsbac_list_reg_item_t::curr, rsbac_list_reg_item_t::head, rsbac_list_item_t::next, NULL, rsbac_list_item_t::prev, and rsbac_list_reg_item_t::tail. Referenced by add_item(). 01116 {
01117 struct rsbac_list_item_t * curr;
01118
01119 curr = list->curr;
01120 if(!curr)
01121 curr = list->head;
01122 if((list->compare(desc, &curr[1]) > 0))
01123 {
01124 curr = curr->next;
01125 while ( curr
01126 && (list->compare(desc, &curr[1]) > 0)
01127 )
01128 curr = curr->next;
01129 if (curr)
01130 {
01131 /* insert before curr */
01132 new_item_p->prev=curr->prev;
01133 new_item_p->next=curr;
01134 curr->prev->next=new_item_p;
01135 curr->prev=new_item_p;
01136 }
01137 else
01138 {
01139 /* insert as last item */
01140 new_item_p->prev=list->tail;
01141 new_item_p->next=NULL;
01142 list->tail->next=new_item_p;
01143 list->tail=new_item_p;
01144 }
01145 }
01146 else
01147 {
01148 curr = curr->prev;
01149 while ( curr
01150 && (list->compare(desc, &curr[1]) < 0)
01151 )
01152 curr = curr->prev;
01153 if (curr)
01154 {
01155 /* insert after curr */
01156 new_item_p->prev=curr;
01157 new_item_p->next=curr->next;
01158 curr->next->prev=new_item_p;
01159 curr->next=new_item_p;
01160 }
01161 else
01162 {
01163 /* insert as first item */
01164 new_item_p->prev=NULL;
01165 new_item_p->next=list->head;
01166 list->head->prev=new_item_p;
01167 list->head=new_item_p;
01168 }
01169 }
01170 list->count++;
01171 list->curr=new_item_p;
01172 return new_item_p;
01173 }
|
|
||||||||||||||||
|
Definition at line 1175 of file gen_lists.c. References rsbac_list_item_t::next, NULL, and rsbac_list_item_t::prev. Referenced by add_item(). 01179 {
01180 struct rsbac_list_item_t * curr;
01181
01182 curr = list->curr;
01183 if(!curr)
01184 curr = list->head;
01185 if(memcmp(desc,
01186 &curr[1],
01187 list->info.desc_size) > 0)
01188 {
01189 curr = curr->next;
01190 while ( curr
01191 && (memcmp(desc,
01192 &curr[1],
01193 list->info.desc_size) > 0
01194 )
01195 )
01196 curr = curr->next;
01197 if (curr)
01198 {
01199 /* insert before curr */
01200 new_item_p->prev=curr->prev;
01201 new_item_p->next=curr;
01202 curr->prev->next=new_item_p;
01203 curr->prev=new_item_p;
01204 }
01205 else
01206 {
01207 /* insert as last item */
01208 new_item_p->prev=list->tail;
01209 new_item_p->next=NULL;
01210 list->tail->next=new_item_p;
01211 list->tail=new_item_p;
01212 }
01213 }
01214 else
01215 {
01216 curr = curr->prev;
01217 while ( curr
01218 && (memcmp(desc,
01219 &curr[1],
01220 list->info.desc_size) < 0
01221 )
01222 )
01223 curr = curr->prev;
01224 if (curr)
01225 {
01226 /* insert after curr */
01227 new_item_p->prev=curr;
01228 new_item_p->next=curr->next;
01229 curr->next->prev=new_item_p;
01230 curr->next=new_item_p;
01231 }
01232 else
01233 {
01234 /* insert as first item */
01235 new_item_p->prev=NULL;
01236 new_item_p->next=list->head;
01237 list->head->prev=new_item_p;
01238 list->head=new_item_p;
01239 }
01240 }
01241 list->count++;
01242 list->curr=new_item_p;
01243 return new_item_p;
01244 }
|
|
||||||||||||||||
|
Definition at line 1815 of file gen_lists.c. References rsbac_list_lol_reg_item_t::compare, rsbac_list_lol_reg_item_t::count, rsbac_list_lol_reg_item_t::curr, rsbac_list_lol_reg_item_t::head, rsbac_list_lol_item_t::next, NULL, rsbac_list_lol_item_t::prev, and rsbac_list_lol_reg_item_t::tail. Referenced by add_lol_item(). 01819 {
01820 struct rsbac_list_lol_item_t * curr;
01821
01822 curr = list->curr;
01823 if(!curr)
01824 curr = list->head;
01825 if((list->compare(desc, &curr[1]) > 0))
01826 {
01827 curr = curr->next;
01828 while ( curr
01829 && (list->compare(desc, &curr[1]) > 0)
01830 )
01831 curr = curr->next;
01832 if (curr)
01833 {
01834 /* insert before curr */
01835 new_item_p->prev=curr->prev;
01836 new_item_p->next=curr;
01837 curr->prev->next=new_item_p;
01838 curr->prev=new_item_p;
01839 }
01840 else
01841 {
01842 /* insert as last item */
01843 new_item_p->prev=list->tail;
01844 new_item_p->next=NULL;
01845 list->tail->next=new_item_p;
01846 list->tail=new_item_p;
01847 }
01848 }
01849 else
01850 {
01851 curr = curr->prev;
01852 while ( curr
01853 && (list->compare(desc, &curr[1]) < 0)
01854 )
01855 curr = curr->prev;
01856 if (curr)
01857 {
01858 /* insert after curr */
01859 new_item_p->prev=curr;
01860 new_item_p->next=curr->next;
01861 curr->next->prev=new_item_p;
01862 curr->next=new_item_p;
01863 }
01864 else
01865 {
01866 /* insert as first item */
01867 new_item_p->prev=NULL;
01868 new_item_p->next=list->head;
01869 list->head->prev=new_item_p;
01870 list->head=new_item_p;
01871 }
01872 }
01873 list->count++;
01874 list->curr=new_item_p;
01875 return new_item_p;
01876 }
|
|
||||||||||||||||
|
Definition at line 1878 of file gen_lists.c. References rsbac_list_lol_item_t::count, rsbac_list_lol_item_t::curr, rsbac_list_lol_item_t::head, rsbac_list_lol_item_t::next, NULL, rsbac_list_item_t::prev, rsbac_list_lol_item_t::prev, and rsbac_list_lol_item_t::tail. Referenced by add_lol_item(). 01882 {
01883 struct rsbac_list_lol_item_t * curr;
01884
01885 curr = list->curr;
01886 if(!curr)
01887 curr = list->head;
01888 if(memcmp(desc,
01889 &curr[1],
01890 list->info.desc_size) > 0)
01891 {
01892 curr = curr->next;
01893 while ( curr
01894 && (memcmp(desc,
01895 &curr[1],
01896 list->info.desc_size) > 0
01897 )
01898 )
01899 curr = curr->next;
01900 if (curr)
01901 {
01902 /* insert before curr */
01903 new_item_p->prev=curr->prev;
01904 new_item_p->next=curr;
01905 curr->prev->next=new_item_p;
01906 curr->prev=new_item_p;
01907 }
01908 else
01909 {
01910 /* insert as last item */
01911 new_item_p->prev=list->tail;
01912 new_item_p->next=NULL;
01913 list->tail->next=new_item_p;
01914 list->tail=new_item_p;
01915 }
01916 }
01917 else
01918 {
01919 curr = curr->prev;
01920 while ( curr
01921 && (memcmp(desc,
01922 &curr[1],
01923 list->info.desc_size) < 0
01924 )
01925 )
01926 curr = curr->prev;
01927 if (curr)
01928 {
01929 /* insert after curr */
01930 new_item_p->prev=curr;
01931 new_item_p->next=curr->next;
01932 curr->next->prev=new_item_p;
01933 curr->next=new_item_p;
01934 }
01935 else
01936 {
01937 /* insert as first item */
01938 new_item_p->prev=NULL;
01939 new_item_p->next=list->head;
01940 list->head->prev=new_item_p;
01941 list->head=new_item_p;
01942 }
01943 }
01944 list->count++;
01945 list->curr=new_item_p;
01946 return new_item_p;
01947 }
|
|
||||||||||||||||||||
|
Definition at line 1634 of file gen_lists.c. References rsbac_list_lol_item_t::count, rsbac_list_lol_item_t::curr, rsbac_list_lol_item_t::head, rsbac_list_item_t::next, NULL, rsbac_list_item_t::prev, rsbac_list_lol_reg_item_t::subcompare, and rsbac_list_lol_item_t::tail. Referenced by add_lol_subitem(). 01639 {
01640 struct rsbac_list_item_t * curr;
01641
01642 curr = sublist->curr;
01643 if(!curr)
01644 curr = sublist->head;
01645 if((list->subcompare(subdesc, &curr[1]) > 0))
01646 {
01647 curr = curr->next;
01648 while ( curr
01649 && (list->subcompare(subdesc, &curr[1]) > 0)
01650 )
01651 curr = curr->next;
01652 if (curr)
01653 {
01654 /* insert before curr */
01655 new_item_p->prev=curr->prev;
01656 new_item_p->next=curr;
01657 curr->prev->next=new_item_p;
01658 curr->prev=new_item_p;
01659 }
01660 else
01661 {
01662 /* insert as last item */
01663 new_item_p->prev=sublist->tail;
01664 new_item_p->next=NULL;
01665 sublist->tail->next=new_item_p;
01666 sublist->tail=new_item_p;
01667 }
01668 }
01669 else
01670 {
01671 curr = curr->prev;
01672 while ( curr
01673 && (list->subcompare(subdesc, &curr[1]) < 0)
01674 )
01675 curr = curr->prev;
01676 if (curr)
01677 {
01678 /* insert after curr */
01679 new_item_p->prev=curr;
01680 new_item_p->next=curr->next;
01681 curr->next->prev=new_item_p;
01682 curr->next=new_item_p;
01683 }
01684 else
01685 {
01686 /* insert as first item */
01687 new_item_p->prev=NULL;
01688 new_item_p->next=sublist->head;
01689 sublist->head->prev=new_item_p;
01690 sublist->head=new_item_p;
01691 }
01692 }
01693 sublist->count++;
01694 sublist->curr=new_item_p;
01695 return new_item_p;
01696 }
|
|
||||||||||||||||||||
|
Definition at line 1698 of file gen_lists.c. References rsbac_list_lol_item_t::count, rsbac_list_lol_item_t::curr, rsbac_list_lol_item_t::head, rsbac_list_item_t::next, NULL, rsbac_list_item_t::prev, and rsbac_list_lol_item_t::tail. Referenced by add_lol_subitem(). 01703 {
01704 struct rsbac_list_item_t * curr;
01705
01706 curr = sublist->curr;
01707 if(!curr)
01708 curr = sublist->head;
01709 if(memcmp(subdesc,
01710 &curr[1],
01711 list->info.subdesc_size) > 0)
01712 {
01713 curr = curr->next;
01714 while ( curr
01715 && (memcmp(subdesc,
01716 &curr[1],
01717 list->info.subdesc_size) > 0
01718 )
01719 )
01720 curr = curr->next;
01721 if (curr)
01722 {
01723 /* insert before curr */
01724 new_item_p->prev=curr->prev;
01725 new_item_p->next=curr;
01726 curr->prev->next=new_item_p;
01727 curr->prev=new_item_p;
01728 }
01729 else
01730 {
01731 /* insert as last item */
01732 new_item_p->prev=sublist->tail;
01733 new_item_p->next=NULL;
01734 sublist->tail->next=new_item_p;
01735 sublist->tail=new_item_p;
01736 }
01737 }
01738 else
01739 {
01740 curr = curr->prev;
01741 while ( curr
01742 && (memcmp(subdesc,
01743 &curr[1],
01744 list->info.subdesc_size) < 0
01745 )
01746 )
01747 curr = curr->prev;
01748 if (curr)
01749 {
01750 /* insert after curr */
01751 new_item_p->prev=curr;
01752 new_item_p->next=curr->next;
01753 curr->next->prev=new_item_p;
01754 curr->next=new_item_p;
01755 }
01756 else
01757 {
01758 /* insert as first item */
01759 new_item_p->prev=NULL;
01760 new_item_p->next=sublist->head;
01761 sublist->head->prev=new_item_p;
01762 sublist->head=new_item_p;
01763 }
01764 }
01765 sublist->count++;
01766 sublist->curr=new_item_p;
01767 return new_item_p;
01768 }
|
|
||||||||||||
|
Definition at line 170 of file gen_lists.c. References rsbac_list_reg_item_t::compare, lookup_item_compare(), lookup_item_memcmp(), and NULL. 00173 {
00174 if(!list || !desc)
00175 return NULL;
00176
00177 if(list->compare)
00178 return lookup_item_compare(list, desc);
00179 else
00180 return lookup_item_memcmp(list, desc);
00181 }
|
|
||||||||||||
|
Definition at line 60 of file gen_lists.c. References rsbac_list_reg_item_t::compare, rsbac_list_reg_item_t::curr, rsbac_list_reg_item_t::head, rsbac_list_item_t::next, NULL, and rsbac_list_item_t::prev. Referenced by lookup_item(). 00063 {
00064 struct rsbac_list_item_t * curr;
00065
00066 if(!list || !desc || !list->compare)
00067 return NULL;
00068
00069 curr = list->curr;
00070 if(!curr)
00071 {
00072 curr = list->head;
00073 if(!curr)
00074 return NULL;
00075 }
00076 /* if current item is not the right one, search... */
00077 /* note: item desc is behind official struct */
00078 if(list->compare(desc, &curr[1]))
00079 {
00080 if((list->compare(desc, &curr[1]) > 0))
00081 {
00082 curr = curr->next;
00083 while ( curr
00084 && (list->compare(desc, &curr[1]) > 0)
00085 )
00086 curr = curr->next;
00087 }
00088 else
00089 {
00090 curr = curr->prev;
00091 while ( curr
00092 && (list->compare(desc, &curr[1]) < 0)
00093 )
00094 curr = curr->prev;
00095 }
00096 if (curr)
00097 {
00098 /* keep for speedup */
00099 list->curr = curr;
00100 if(!list->compare(desc, &curr[1]))
00101 return curr;
00102 }
00103 /* NULL or not found */
00104 return NULL;
00105 }
00106 /* it is the current item -> return it */
00107 return curr;
00108 }
|
|
||||||||||||||||
|
Definition at line 361 of file gen_lists.c. References lookup_item_data_compare(), lookup_item_data_memcmp(), and NULL. Referenced by rsbac_ta_list_get_desc(). 00365 {
00366 if(!list || !data)
00367 return NULL;
00368
00369 if(compare)
00370 return lookup_item_data_compare(list, data, compare);
00371 else
00372 return lookup_item_data_memcmp(list, data);
00373 }
|
|
||||||||||||||||
|
Definition at line 314 of file gen_lists.c. References rsbac_list_info_t::desc_size, rsbac_list_reg_item_t::head, rsbac_list_reg_item_t::info, rsbac_list_item_t::max_age, and NULL. Referenced by lookup_item_data(). 00318 {
00319 struct rsbac_list_item_t * curr;
00320
00321 if(!list || !data || !compare)
00322 return NULL;
00323
00324 curr = list->head;
00325
00326 /* note: item desc is behind official struct */
00327 while ( curr
00328 && ( (curr->max_age && (curr->max_age <= RSBAC_CURRENT_TIME))
00329 || compare((char *)curr + sizeof(*curr) + list->info.desc_size, data)
00330 )
00331 )
00332 curr = curr->next;
00333 /* it is the current item -> return it */
00334 return curr;
00335 }
|
|
||||||||||||
|
Definition at line 337 of file gen_lists.c. References rsbac_list_item_t::max_age, rsbac_list_item_t::next, and NULL. Referenced by lookup_item_data(). 00340 {
00341 struct rsbac_list_item_t * curr;
00342
00343 if(!list || !data)
00344 return NULL;
00345
00346 curr = list->head;
00347
00348 /* note: item desc is behind official struct */
00349 while ( curr
00350 && ( (curr->max_age && (curr->max_age <= RSBAC_CURRENT_TIME))
00351 || memcmp(data,
00352 &curr[1] + list->info.desc_size,
00353 list->info.data_size)
00354 )
00355 )
00356 curr = curr->next;
00357 /* it is the current item -> return it */
00358 return curr;
00359 }
|
|
||||||||||||
|
Definition at line 110 of file gen_lists.c. References rsbac_list_item_t::next, NULL, and rsbac_list_item_t::prev. Referenced by lookup_item(). 00113 {
00114 struct rsbac_list_item_t * curr;
00115
00116 if(!list || !desc)
00117 return NULL;
00118
00119 curr = list->curr;
00120 if(!curr)
00121 {
00122 curr = list->head;
00123 if(!curr)
00124 return NULL;
00125 }
00126 /* if current item is not the right one, search... */
00127 /* note: item desc is behind official struct */
00128 if(memcmp(desc,
00129 &curr[1],
00130 list->info.desc_size))
00131 {
00132 if(memcmp(desc,
00133 &curr[1],
00134 list->info.desc_size) > 0)
00135 {
00136 curr = curr->next;
00137 while ( curr
00138 && (memcmp(desc,
00139 &curr[1],
00140 list->info.desc_size) > 0)
00141 )
00142 curr = curr->next;
00143 }
00144 else
00145 {
00146 curr = curr->prev;
00147 while ( curr
00148 && (memcmp(desc,
00149 &curr[1],
00150 list->info.desc_size) < 0)
00151 )
00152 curr = curr->prev;
00153 }
00154 if (curr)
00155 {
00156 /* keep for speedup */
00157 list->curr = curr;
00158 if(!memcmp(desc,
00159 &curr[1],
00160 list->info.desc_size))
00161 return curr;
00162 }
00163 /* not found */
00164 return NULL;
00165 }
00166 /* it is the current item -> return it */
00167 return curr;
00168 }
|
|
||||||||||||
|
Definition at line 705 of file gen_lists.c. References rsbac_list_lol_reg_item_t::compare, lookup_lol_item_compare(), lookup_lol_item_memcmp(), and NULL. Referenced by remove_lol_item(), rsbac_ta_list_lol_add_ttl(), rsbac_ta_list_lol_exist(), rsbac_ta_list_lol_get_all_subdata(), rsbac_ta_list_lol_get_all_subdesc_ttl(), rsbac_ta_list_lol_get_all_subitems_ttl(), rsbac_ta_list_lol_get_data_ttl(), rsbac_ta_list_lol_get_next_desc(), rsbac_ta_list_lol_get_subdata_ttl(), rsbac_ta_list_lol_remove(), rsbac_ta_list_lol_subadd_ttl(), rsbac_ta_list_lol_subcount(), rsbac_ta_list_lol_subexist(), rsbac_ta_list_lol_subexist_compare(), rsbac_ta_list_lol_subremove(), and rsbac_ta_list_lol_subremove_all(). 00708 {
00709 if(!list || !desc)
00710 return NULL;
00711
00712 if(list->compare)
00713 return lookup_lol_item_compare(list, desc);
00714 else
00715 return lookup_lol_item_memcmp(list, desc);
00716 }
|
|
||||||||||||
|
Definition at line 595 of file gen_lists.c. References rsbac_list_lol_reg_item_t::compare, rsbac_list_lol_reg_item_t::curr, rsbac_list_lol_reg_item_t::head, rsbac_list_lol_item_t::next, NULL, and rsbac_list_lol_item_t::prev. Referenced by lookup_lol_item(). 00598 {
00599 struct rsbac_list_lol_item_t * curr;
00600
00601 if(!list || !desc || !list->compare)
00602 return NULL;
00603
00604 curr = list->curr;
00605 if(!curr)
00606 {
00607 curr = list->head;
00608 if(!curr)
00609 return NULL;
00610 }
00611 /* if current item is not the right one, search... */
00612 /* note: item desc is behind official struct */
00613 if(list->compare(desc, &curr[1]))
00614 {
00615 if((list->compare(desc, &curr[1]) > 0))
00616 {
00617 curr = curr->next;
00618 while ( curr
00619 && (list->compare(desc, &curr[1]) > 0)
00620 )
00621 curr = curr->next;
00622 }
00623 else
00624 {
00625 curr = curr->prev;
00626 while ( curr
00627 && (list->compare(desc, &curr[1]) < 0)
00628 )
00629 curr = curr->prev;
00630 }
00631 if (curr)
00632 {
00633 /* keep for speedup */
00634 list->curr = curr;
00635 if(!list->compare(desc, &curr[1]))
00636 return curr;
00637 }
00638 /* not found */
00639 return NULL;
00640 }
00641 /* it is the current item -> return it */
00642 return curr;
00643 }
|
|
||||||||||||||||
|
Definition at line 896 of file gen_lists.c. References lookup_lol_item_data_compare(), lookup_lol_item_data_memcmp(), and NULL. Referenced by rsbac_ta_list_lol_get_desc(). 00900 {
00901 if(!list || !data)
00902 return NULL;
00903
00904 if(compare)
00905 return lookup_lol_item_data_compare(list, data, compare);
00906 else
00907 return lookup_lol_item_data_memcmp(list, data);
00908 }
|
|
||||||||||||||||
|
Definition at line 849 of file gen_lists.c. References rsbac_list_lol_info_t::desc_size, rsbac_list_lol_reg_item_t::head, rsbac_list_lol_reg_item_t::info, rsbac_list_lol_item_t::max_age, and NULL. Referenced by lookup_lol_item_data(). 00853 {
00854 struct rsbac_list_lol_item_t * curr;
00855
00856 if(!list || !data || !compare)
00857 return NULL;
00858
00859 curr = list->head;
00860
00861 /* note: item desc is behind official struct */
00862 while ( curr
00863 && ( (curr->max_age && (curr->max_age <= RSBAC_CURRENT_TIME))
00864 || compare((char *)curr + sizeof(*curr) + list->info.desc_size, data)
00865 )
00866 )
00867 curr = curr->next;
00868 /* it is the current item -> return it */
00869 return curr;
00870 }
|
|
||||||||||||
|
Definition at line 872 of file gen_lists.c. References rsbac_list_lol_item_t::head, rsbac_list_lol_item_t::max_age, rsbac_list_lol_item_t::next, and NULL. Referenced by lookup_lol_item_data(). 00875 {
00876 struct rsbac_list_lol_item_t * curr;
00877
00878 if(!list || !data)
00879 return NULL;
00880
00881 curr = list->head;
00882
00883 /* note: item desc is behind official struct */
00884 while ( curr
00885 && ( (curr->max_age && (curr->max_age <= RSBAC_CURRENT_TIME))
00886 || memcmp(data,
00887 &curr[1] + list->info.desc_size,
00888 list->info.data_size)
00889 )
00890 )
00891 curr = curr->next;
00892 /* it is the current item -> return it */
00893 return curr;
00894 }
|
|
||||||||||||
|
Definition at line 645 of file gen_lists.c. References rsbac_list_lol_item_t::curr, rsbac_list_lol_item_t::head, rsbac_list_lol_item_t::next, NULL, and rsbac_list_lol_item_t::prev. Referenced by lookup_lol_item(). 00648 {
00649 struct rsbac_list_lol_item_t * curr;
00650
00651 if(!list || !desc)
00652 return NULL;
00653
00654 curr = list->curr;
00655 if(!curr)
00656 {
00657 curr = list->head;
00658 if(!curr)
00659 return NULL;
00660 }
00661 /* if current item is not the right one, search... */
00662 /* note: item desc is behind official struct */
00663 if(memcmp(desc,
00664 &curr[1],
00665 list->info.desc_size))
00666 {
00667 if(memcmp(desc,
00668 &curr[1],
00669 list->info.desc_size) > 0)
00670 {
00671 curr = curr->next;
00672 while ( curr
00673 && (memcmp(desc,
00674 &curr[1],
00675 list->info.desc_size) > 0)
00676 )
00677 curr = curr->next;
00678 }
00679 else
00680 {
00681 curr = curr->prev;
00682 while ( curr
00683 && (memcmp(desc,
00684 &curr[1],
00685 list->info.desc_size) < 0)
00686 )
00687 curr = curr->prev;
00688 }
00689 if (curr)
00690 {
00691 /* keep for speedup */
00692 list->curr = curr;
00693 if(!memcmp(desc,
00694 &curr[1],
00695 list->info.desc_size))
00696 return curr;
00697 }
00698 /* not found */
00699 return NULL;
00700 }
00701 /* it is the current item -> return it */
00702 return curr;
00703 }
|
|
|
Definition at line 1045 of file gen_lists.c. References rsbac_list_lol_reg_head_t::curr, rsbac_list_lol_reg_head_t::head, rsbac_list_lol_reg_item_t::next, NULL, and rsbac_printk(). Referenced by remove_lol_reg(), rsbac_list_lol_destroy(), rsbac_list_lol_detach(), and rsbac_list_lol_no_write(). 01046 {
01047 struct rsbac_list_lol_reg_item_t * curr = lol_reg_head.curr;
01048
01049 if(!handle)
01050 return NULL;
01051 /* if there is no current item or it is not the right one, search... */
01052 if(curr != handle)
01053 {
01054 curr = lol_reg_head.head;
01055 while (curr && curr != handle)
01056 curr = curr->next;
01057 if (curr)
01058 lol_reg_head.curr=curr;
01059 #ifdef CONFIG_RSBAC_DEBUG
01060 else
01061 if(rsbac_debug_lists)
01062 {
01063 rsbac_printk(KERN_DEBUG "lookup_lol_reg(): Lookup of unknown list handle %p\n",
01064 handle);
01065 }
01066 #endif
01067 }
01068 /* it is the current item -> return it */
01069 return curr;
01070 }
|
|
||||||||||||
|
Definition at line 1072 of file gen_lists.c. References rsbac_list_lol_reg_head_t::curr, rsbac_list_lol_reg_item_t::device, rsbac_list_lol_reg_head_t::head, rsbac_list_lol_reg_item_t::name, rsbac_list_lol_reg_item_t::next, NULL, RSBAC_LIST_MAX_FILENAME, and rsbac_printk(). Referenced by rsbac_list_lol_register(), and rsbac_list_register(). 01073 {
01074 struct rsbac_list_lol_reg_item_t * curr = lol_reg_head.curr;
01075
01076 if(!name)
01077 return NULL;
01078 /* if there is no current item or it is not the right one, search... */
01079 if( !curr
01080 || ( strncmp(curr->name, name, RSBAC_LIST_MAX_FILENAME)
01081 || (RSBAC_MAJOR(curr->device) != RSBAC_MAJOR(device))
01082 || (RSBAC_MINOR(curr->device) != RSBAC_MINOR(device))
01083 )
01084 )
01085 {
01086 curr = lol_reg_head.head;
01087 while ( curr
01088 && ( strncmp(curr->name, name, RSBAC_LIST_MAX_FILENAME)
01089 || (RSBAC_MAJOR(curr->device) != RSBAC_MAJOR(device))
01090 || (RSBAC_MINOR(curr->device) != RSBAC_MINOR(device))
01091 )
01092 )
01093 curr = curr->next;
01094 if (curr)
01095 lol_reg_head.curr=curr;
01096 #ifdef CONFIG_RSBAC_DEBUG
01097 else
01098 if(rsbac_debug_lists)
01099 {
01100 rsbac_printk(KERN_DEBUG "lookup_lol_reg_name(): Lookup of unknown list name %s on device %02u:%02u\n",
01101 name, RSBAC_MAJOR(device), RSBAC_MINOR(device));
01102 }
01103 #endif
01104 }
01105 /* it is the current item -> return it */
01106 return curr;
01107 }
|
|
||||||||||||||||
|
Definition at line 557 of file gen_lists.c. References lookup_lol_subitem_compare(), lookup_lol_subitem_memcmp(), NULL, and rsbac_list_lol_reg_item_t::subcompare. Referenced by remove_lol_subitem(), rsbac_ta_list_lol_get_subdata_ttl(), rsbac_ta_list_lol_subadd_ttl(), rsbac_ta_list_lol_subexist(), rsbac_ta_list_lol_subremove(), and rsbac_ta_list_lol_subremove_from_all(). 00561 {
00562 if(!list || !sublist || !subdesc)
00563 return NULL;
00564
00565 if(list->subcompare)
00566 return lookup_lol_subitem_compare(list, sublist, subdesc, list->subcompare);
00567 else
00568 return lookup_lol_subitem_memcmp(list, sublist, subdesc);
00569 }
|
|
||||||||||||||||||||
|
Definition at line 444 of file gen_lists.c. References compare(), rsbac_list_lol_item_t::curr, rsbac_list_lol_item_t::head, rsbac_list_item_t::next, NULL, and rsbac_list_item_t::prev. Referenced by lookup_lol_subitem(). 00449 {
00450 struct rsbac_list_item_t * curr;
00451
00452 if(!list || !sublist || !subdesc || !compare)
00453 return NULL;
00454
00455 curr = sublist->curr;
00456 if(!curr)
00457 {
00458 curr = sublist->head;
00459 if(!curr)
00460 return NULL;
00461 }
00462 /* if current item is not the right one, search... */
00463 /* note: item desc is behind official struct */
00464 if(compare(&curr[1],subdesc))
00465 {
00466 if((compare(&curr[1], subdesc) < 0))
00467 {
00468 curr = curr->next;
00469 while ( curr
00470 && (compare(&curr[1], subdesc) < 0)
00471 )
00472 curr = curr->next;
00473 }
00474 else
00475 {
00476 curr = curr->prev;
00477 while ( curr
00478 && (compare(&curr[1], subdesc) > 0)
00479 )
00480 curr = curr->prev;
00481 }
00482 if (curr)
00483 {
00484 /* keep for speedup */
00485 sublist->curr = curr;
00486 if(!compare(&curr[1], subdesc))
00487 return curr;
00488 }
00489 /* not found */
00490 return NULL;
00491 }
00492 /* it is the current item -> return it */
00493 return curr;
00494 }
|
|
||||||||||||||||
|
Definition at line 496 of file gen_lists.c. References rsbac_list_lol_item_t::curr, rsbac_list_lol_item_t::head, rsbac_list_lol_reg_item_t::info, rsbac_list_item_t::next, NULL, rsbac_list_item_t::prev, and rsbac_list_lol_info_t::subdesc_size. Referenced by lookup_lol_subitem(). 00500 {
00501 struct rsbac_list_item_t * curr;
00502
00503 if(!list || !sublist || !subdesc)
00504 return NULL;
00505
00506 curr = sublist->curr;
00507 if(!curr)
00508 {
00509 curr = sublist->head;
00510 if(!curr)
00511 return NULL;
00512 }
00513 /* if current item is not the right one, search... */
00514 /* note: item desc is behind official struct */
00515 if(memcmp(subdesc,
00516 &curr[1],
00517 list->info.subdesc_size))
00518 {
00519 if(memcmp(subdesc,
00520 &curr[1],
00521 list->info.subdesc_size) > 0)
00522 {
00523 curr = curr->next;
00524 while ( curr
00525 && (memcmp(subdesc,
00526 &curr[1],
00527 list->info.subdesc_size) > 0)
00528 )
00529 curr = curr->next;
00530 }
00531 else
00532 {
00533 curr = curr->prev;
00534 while ( curr
00535 && (memcmp(subdesc,
00536 &curr[1],
00537 list->info.subdesc_size) < 0)
00538 )
00539 curr = curr->prev;
00540 }
00541 if (curr)
00542 {
00543 /* keep for speedup */
00544 sublist->curr = curr;
00545 if(!memcmp(subdesc,
00546 &curr[1],
00547 list->info.subdesc_size))
00548 return curr;
00549 }
00550 /* not found */
00551 return NULL;
00552 }
00553 /* it is the current item -> return it */
00554 return curr;
00555 }
|
|
||||||||||||||||||||
|
Definition at line 571 of file gen_lists.c. References compare(), rsbac_list_lol_item_t::head, rsbac_list_item_t::next, and NULL. Referenced by rsbac_ta_list_lol_subexist_compare(). 00576 {
00577 struct rsbac_list_item_t * curr;
00578
00579 if(!list || !sublist || !subdesc || !compare)
00580 return NULL;
00581
00582 curr = sublist->head;
00583 /* note: item desc is behind official struct */
00584 while(curr)
00585 {
00586 if(!compare(&curr[1],subdesc))
00587 return curr;
00588 curr = curr->next;
00589 }
00590 return curr;
00591 }
|
|
|
Definition at line 979 of file gen_lists.c. References rsbac_list_reg_head_t::curr, rsbac_list_reg_head_t::head, rsbac_list_reg_item_t::next, NULL, and rsbac_printk(). Referenced by remove_reg(), rsbac_list_destroy(), rsbac_list_detach(), and rsbac_list_no_write(). 00980 {
00981 struct rsbac_list_reg_item_t * curr = reg_head.curr;
00982
00983 if(!handle)
00984 return NULL;
00985 /* if there is no current item or it is not the right one, search... */
00986 if(curr != handle)
00987 {
00988 curr = reg_head.head;
00989 while (curr && curr != handle)
00990 curr = curr->next;
00991 if (curr)
00992 reg_head.curr=curr;
00993 #ifdef CONFIG_RSBAC_DEBUG
00994 else
00995 if(rsbac_debug_lists)
00996 {
00997 rsbac_printk(KERN_DEBUG "lookup_reg(): Lookup of unknown list handle %p\n",
00998 handle);
00999 }
01000 #endif
01001 }
01002 /* it is the current item -> return it */
01003 return curr;
01004 }
|
|
||||||||||||
|
Definition at line 1006 of file gen_lists.c. References rsbac_list_reg_head_t::curr, rsbac_list_reg_item_t::device, rsbac_list_reg_head_t::head, rsbac_list_reg_item_t::name, rsbac_list_reg_item_t::next, NULL, RSBAC_LIST_MAX_FILENAME, and rsbac_printk(). Referenced by rsbac_list_lol_register(), and rsbac_list_register(). 01007 {
01008 struct rsbac_list_reg_item_t * curr = reg_head.curr;
01009
01010 if(!name)
01011 return NULL;
01012 /* if there is no current item or it is not the right one, search... */
01013 if( !curr
01014 || ( strncmp(curr->name, name, RSBAC_LIST_MAX_FILENAME)
01015 || (RSBAC_MAJOR(curr->device) != RSBAC_MAJOR(device))
01016 || (RSBAC_MINOR(curr->device) != RSBAC_MINOR(device))
01017 )
01018 )
01019 {
01020 curr = reg_head.head;
01021 while ( curr
01022 && ( strncmp(curr->name, name, RSBAC_LIST_MAX_FILENAME)
01023 || (RSBAC_MAJOR(curr->device) != RSBAC_MAJOR(device))
01024 || (RSBAC_MINOR(curr->device) != RSBAC_MINOR(device))
01025 )
01026 )
01027 curr = curr->next;
01028 if (curr)
01029 reg_head.curr=curr;
01030 #ifdef CONFIG_RSBAC_DEBUG
01031 else
01032 if(rsbac_debug_lists)
01033 {
01034 rsbac_printk(KERN_DEBUG "lookup_reg_name(): Lookup of unknown list name %s on device %02u:%02u\n",
01035 name, RSBAC_MAJOR(device), RSBAC_MINOR(device));
01036 }
01037 #endif
01038 }
01039 /* it is the current item -> return it */
01040 return curr;
01041 }
|
|
|
Definition at line 3069 of file gen_lists.c. References add_item(), rsbac_list_info_t::data_size, rsbac_list_info_t::desc_size, rsbac_list_reg_item_t::device, FALSE, rsbac_list_reg_item_t::flags, rsbac_list_reg_item_t::get_conv, rsbac_list_reg_item_t::info, rsbac_list_info_t::key, rsbac_list_reg_item_t::lastchange, rsbac_list_reg_item_t::lock, rsbac_list_reg_item_t::name, NULL, RSBAC_EINVALIDVALUE, RSBAC_EINVALIDVERSION, RSBAC_ENOMEM, RSBAC_EREADFAILED, rsbac_kfree(), rsbac_kmalloc(), RSBAC_LIST_DISK_OLD_VERSION, RSBAC_LIST_DISK_VERSION, RSBAC_LIST_IGNORE_OLD, RSBAC_LIST_IGNORE_UNSUPP_VERSION, rsbac_printk(), rsbac_read_close(), rsbac_read_open(), TRUE, and rsbac_list_info_t::version. Referenced by rsbac_list_register(). 03070 {
03071 struct file * file_p;
03072 int err = 0;
03073 int tmperr;
03074 int converr;
03075 rsbac_version_t list_version;
03076 u_long read_count = 0;
03077 u_long flags;
03078 char * old_buf;
03079 char * new_buf;
03080 char * old_data;
03081 char * new_data;
03082 struct rsbac_list_info_t * list_info_p;
03083 rsbac_list_count_t list_count;
03084 rsbac_time_t timestamp;
03085 struct rsbac_nanotime_t lastchange;
03086 rsbac_time_t max_age = 0;
03087 rsbac_list_conv_function_t * conv = NULL;
03088 rsbac_boolean_t timeout = FALSE;
03089 mm_segment_t oldfs;
03090
03091 list_info_p = rsbac_kmalloc(sizeof(*list_info_p));
03092 if(!list_info_p)
03093 return -RSBAC_ENOMEM;
03094 file_p = rsbac_kmalloc(sizeof(*file_p));
03095 if(!file_p)
03096 {
03097 rsbac_kfree(list_info_p);
03098 return -RSBAC_ENOMEM;
03099 }
03100 /* open file */
03101 if ((err = rsbac_read_open(list->name,
03102 file_p,
03103 list->device) ))
03104 {
03105 rsbac_kfree(list_info_p);
03106 rsbac_kfree(file_p);
03107 return(err);
03108 }
03109
03110 /* OK, now we can start reading */
03111 /* There is a read function for this file, so check info and read as
03112 * many items as possible. A positive return value means a read success,
03113 * 0 end of file and a negative value an error. */
03114
03115 /* Set current user space to kernel space, because read() writes */
03116 /* to user space */
03117 oldfs = get_fs();
03118 set_fs(KERNEL_DS);
03119
03120 /* check gen-list on-disk version */
03121 tmperr = file_p->f_op->read(file_p,
03122 (__u8 *) &list_version,
03123 sizeof(list_version),
03124 &file_p->f_pos);
03125 set_fs(oldfs);
03126 /* error? */
03127 if (tmperr < sizeof(list_version))
03128 {
03129 rsbac_printk(KERN_WARNING
03130 "read_list(): read error from file!\n");
03131 err = -RSBAC_EREADFAILED;
03132 goto end_read;
03133 }
03134 /* if wrong list on-disk version, fail */
03135 switch(list_version)
03136 {
03137 case RSBAC_LIST_DISK_VERSION:
03138 case RSBAC_LIST_DISK_OLD_VERSION:
03139 break;
03140 default:
03141 rsbac_printk(KERN_WARNING
03142 "read_list(): wrong on-disk list version %u in file %s, expected %u - error!\n",
03143 list_version,
03144 list->name,
03145 RSBAC_LIST_DISK_VERSION);
03146 err = -RSBAC_EREADFAILED;
03147 goto end_read;
03148 }
03149
03150 /* get timestamp */
03151 set_fs(KERNEL_DS);
03152 tmperr = file_p->f_op->read(file_p,
03153 (__u8 *) ×tamp,
03154 sizeof(timestamp),
03155 &file_p->f_pos);
03156 set_fs(oldfs);
03157 /* error? */
03158 if (tmperr < sizeof(timestamp))
03159 {
03160 rsbac_printk(KERN_WARNING
03161 "read_list(): timestamp read error from file %s!\n",
03162 list->name);
03163 err = -RSBAC_EREADFAILED;
03164 goto end_read;
03165 }
03166
03167 /* get list info */
03168 set_fs(KERNEL_DS);
03169 tmperr = file_p->f_op->read(file_p,
03170 (__u8 *) list_info_p,
03171 sizeof(*list_info_p),
03172 &file_p->f_pos);
03173 set_fs(oldfs);
03174 /* error? */
03175 if (tmperr < sizeof(*list_info_p))
03176 {
03177 rsbac_printk(KERN_WARNING
03178 "read_list(): list info read error from file %s!\n",
03179 list->name);
03180 err = -RSBAC_EREADFAILED;
03181 goto end_read;
03182 }
03183
03184 /* list timed out? System time is measured in seconds. */
03185 if( list_info_p->max_age
03186 && (timestamp + list_info_p->max_age) <= RSBAC_CURRENT_TIME)
03187 timeout = TRUE;
03188
03189 /* Valid key? */
03190 if (list_info_p->key != list->info.key)
03191 {
03192 if(timeout)
03193 {
03194 rsbac_printk(KERN_WARNING
03195 "read_list(): accessing timed out list %s with wrong key, ignoring old contents!\n",
03196 list->name);
03197 goto end_read;
03198 }
03199 else
03200 {
03201 rsbac_printk(KERN_WARNING
03202 "read_list(): try to access list %s with wrong key!\n",
03203 list->name);
03204 err = -EPERM;
03205 goto end_read;
03206 }
03207 }
03208
03209 /* skip the rest, if ignore is requested */
03210 if(list->flags & RSBAC_LIST_IGNORE_OLD)
03211 goto end_read;
03212
03213 switch(list_version)
03214 {
03215 case RSBAC_LIST_DISK_VERSION:
03216 set_fs(KERNEL_DS);
03217 tmperr = file_p->f_op->read(file_p,
03218 (char *) &lastchange,
03219 sizeof(lastchange),
03220 &file_p->f_pos);
03221 set_fs(oldfs);
03222 /* error? */
03223 if (tmperr < sizeof(lastchange))
03224 {
03225 rsbac_printk(KERN_WARNING
03226 "read_list(): lastchange read error from file %s!\n",
03227 list->name);
03228 err = -RSBAC_EREADFAILED;
03229 goto end_read;
03230 }
03231 #if defined(CONFIG_RSBAC_LIST_REPL)
03232 else
03233 list->lastchange = lastchange;
03234 #endif
03235 break;
03236 case RSBAC_LIST_DISK_OLD_VERSION:
03237 break;
03238 default:
03239 break;
03240 }
03241 /* if wrong list version, try to get_conv */
03242 if(list_info_p->version != list->info.version)
03243 {
03244 if(list->get_conv)
03245 conv = list->get_conv(list_info_p->version);
03246 if(!conv)
03247 {
03248 if(timeout)
03249 {
03250 rsbac_printk(KERN_WARNING
03251 "read_list(): accessing timed out list %s without conversion function, ignoring old contents!\n",
03252 list->name);
03253 goto end_read;
03254 }
03255 else
03256 {
03257 /* complain and set error, if ignore is not requested */
03258 if(!(list->flags & RSBAC_LIST_IGNORE_UNSUPP_VERSION))
03259 {
03260 rsbac_printk(KERN_WARNING
03261 "read_list(): cannot convert list version %u of file %s to version %u!\n",
03262 list_info_p->version,
03263 list->name,
03264 list->info.version);
03265 err = -RSBAC_EINVALIDVERSION;
03266 }
03267 goto end_read;
03268 }
03269 }
03270 else
03271 {
03272 rsbac_printk(KERN_WARNING
03273 "read_list(): converting list version %u of file %s on device %02u:%02u to version %u!\n",
03274 list_info_p->version,
03275 list->name,
03276 RSBAC_MAJOR(list->device), RSBAC_MINOR(list->device),
03277 list->info.version);
03278 }
03279 }
03280 else /* same version needs same sizes */
03281 {
03282 if( (list_info_p->desc_size != list->info.desc_size)
03283 || (list_info_p->data_size != list->info.data_size)
03284 )
03285 {
03286 if(timeout)
03287 {
03288 rsbac_printk(KERN_WARNING
03289 "read_list(): accessing timed out list %s with wrong desc or data size, ignoring old contents!\n",
03290 list->name);
03291 goto end_read;
03292 }
03293 else
03294 {
03295 rsbac_printk(KERN_WARNING
03296 "read_list(): desc or data size mismatch on list %s!\n",
03297 list->name);
03298 err = -RSBAC_EINVALIDVALUE;
03299 goto end_read;
03300 }
03301 }
03302 }
03303
03304 /* get list count */
03305 set_fs(KERNEL_DS);
03306 tmperr = file_p->f_op->read(file_p,
03307 (__u8 *) &list_count,
03308 sizeof(list_count),
03309 &file_p->f_pos);
03310 set_fs(oldfs);
03311 /* error? */
03312 if (tmperr < sizeof(list_count))
03313 {
03314 rsbac_printk(KERN_WARNING
03315 "read_list(): list count read error from file %s!\n",
03316 list->name);
03317 err = -RSBAC_EREADFAILED;
03318 goto end_read;
03319 }
03320
03321 /* alloc mem for old and converted item */
03322 old_buf = rsbac_kmalloc(list_info_p->desc_size + list_info_p->data_size);
03323 if(!old_buf)
03324 {
03325 rsbac_printk(KERN_WARNING
03326 "read_list(): cannot allocate memory!\n");
03327 err = -RSBAC_ENOMEM;
03328 goto end_read;
03329 }
03330 new_buf = rsbac_kmalloc(list->info.desc_size + list->info.data_size);
03331 if(!new_buf)
03332 {
03333 rsbac_printk(KERN_WARNING
03334 "read_list(): cannot allocate memory!\n");
03335 rsbac_kfree(old_buf);
03336 err = -RSBAC_ENOMEM;
03337 goto end_read;
03338 }
03339 /* calculate data pointers */
03340 if(list_info_p->data_size)
03341 old_data = old_buf + list_info_p->desc_size;
03342 else
03343 old_data = NULL;
03344 if(list->info.data_size)
03345 new_data = new_buf + list->info.desc_size;
03346 else
03347 new_data = NULL;
03348
03349 /* actual reading */
03350 do
03351 {
03352 set_fs(KERNEL_DS);
03353 tmperr = file_p->f_op->read(file_p,
03354 (char *) &max_age,
03355 sizeof(max_age),
03356 &file_p->f_pos);
03357 set_fs(oldfs);
03358 if(conv)
03359 {
03360 set_fs(KERNEL_DS);
03361 tmperr = file_p->f_op->read(file_p,
03362 old_buf,
03363 list_info_p->desc_size + list_info_p->data_size,
03364 &file_p->f_pos);
03365 set_fs(oldfs);
03366 if(tmperr > 0)
03367 { /* convert */
03368 converr = conv(old_buf, old_data,
03369 new_buf, new_data);
03370 if(converr)
03371 tmperr = converr;
03372 }
03373 }
03374 else
03375 {
03376 set_fs(KERNEL_DS);
03377 tmperr = file_p->f_op->read(file_p,
03378 new_buf,
03379 list->info.desc_size + list->info.data_size,
03380 &file_p->f_pos);
03381 set_fs(oldfs);
03382 }
03383 /* if successful, add item */
03384 if (tmperr > 0)
03385 {
03386 /* wait for write access to list */
03387 rsbac_write_lock(&list->lock, &flags);
03388 add_item(list, max_age, new_buf, new_data);
03389 /* allow access */
03390 rsbac_write_unlock(&list->lock, &flags);
03391 read_count++;
03392 /*
03393 #ifdef CONFIG_RSBAC_DEBUG
03394 if (rsbac_debug_lists) rsbac_printk(KERN_DEBUG "read_list(): read item %i\n",
03395 user_aci.id);
03396 #endif
03397 */
03398 }
03399 }
03400 while (tmperr > 0); /* end of do */
03401
03402 if (tmperr < 0)
03403 {
03404 rsbac_printk(KERN_WARNING "read_list(): read error from file %s!\n",
03405 list->name);
03406 err = -RSBAC_EREADFAILED;
03407 }
03408 rsbac_kfree(old_buf);
03409 rsbac_kfree(new_buf);
03410
03411 if (read_count != list_count)
03412 {
03413 rsbac_printk(KERN_WARNING "read_list(): read %lu, expected %u items from file %s!\n",
03414 read_count,
03415 list_count,
03416 list->name);
03417 err = -RSBAC_EREADFAILED;
03418 }
03419
03420 end_read:
03421
03422 #ifdef CONFIG_RSBAC_DEBUG
03423 if (rsbac_debug_lists)
03424 {
03425 rsbac_printk(KERN_DEBUG "read_list(): %lu entries read.\n",
03426 read_count);
03427 }
03428 #endif
03429 /* We do not need this file any more */
03430 rsbac_read_close(file_p);
03431 rsbac_kfree(list_info_p);
03432 rsbac_kfree(file_p);
03433 return(err);
03434 }
|
|
|
Definition at line 3437 of file gen_lists.c. References add_lol_item(), add_lol_subitem(), rsbac_list_lol_info_t::data_size, rsbac_list_lol_info_t::desc_size, rsbac_list_lol_reg_item_t::device, FALSE, rsbac_list_lol_reg_item_t::flags, rsbac_list_lol_reg_item_t::get_conv, rsbac_list_lol_reg_item_t::get_subconv, rsbac_list_lol_reg_item_t::info, rsbac_list_lol_info_t::key, rsbac_list_lol_reg_item_t::lastchange, rsbac_list_lol_reg_item_t::lock, rsbac_list_lol_reg_item_t::name, NULL, RSBAC_EINVALIDVALUE, RSBAC_EINVALIDVERSION, RSBAC_ENOMEM, RSBAC_EREADFAILED, rsbac_kfree(), rsbac_kmalloc(), RSBAC_LIST_DISK_OLD_VERSION, RSBAC_LIST_DISK_VERSION, RSBAC_LIST_IGNORE_OLD, RSBAC_LIST_IGNORE_UNSUPP_VERSION, rsbac_printk(), rsbac_read_close(), rsbac_read_open(), rsbac_list_lol_info_t::subdata_size, rsbac_list_lol_info_t::subdesc_size, TRUE, and rsbac_list_lol_info_t::version. Referenced by rsbac_list_lol_register(). 03438 {
03439 struct file * file_p;
03440 int err = 0;
03441 int tmperr;
03442 int converr;
03443 rsbac_version_t list_version;
03444 u_long read_count = 0;
03445 u_long flags;
03446 u_long sublen;
03447 u_long i;
03448 char * old_buf;
03449 char * new_buf;
03450 char * old_data;
03451 char * new_data;
03452 char * old_subbuf;
03453 char * new_subbuf;
03454 char * old_subdata;
03455 char * new_subdata;
03456 struct rsbac_list_lol_info_t * list_info_p;
03457 rsbac_list_count_t list_count;
03458 rsbac_time_t timestamp;
03459 struct rsbac_nanotime_t lastchange;
03460 rsbac_time_t max_age = 0;
03461 rsbac_list_conv_function_t * conv = NULL;
03462 rsbac_list_conv_function_t * subconv = NULL;
03463 rsbac_boolean_t timeout = FALSE;
03464 struct rsbac_list_lol_item_t * item_p;
03465 mm_segment_t oldfs;
03466
03467 list_info_p = rsbac_kmalloc(sizeof(*list_info_p));
03468 if(!list_info_p)
03469 return -RSBAC_ENOMEM;
03470 file_p = rsbac_kmalloc(sizeof(*file_p));
03471 if(!file_p)
03472 {
03473 rsbac_kfree(list_info_p);
03474 return -RSBAC_ENOMEM;
03475 }
03476 /* open file */
03477 if ((err = rsbac_read_open(list->name,
03478 file_p,
03479 list->device) ))
03480 {
03481 rsbac_kfree(list_info_p);
03482 rsbac_kfree(file_p);
03483 return(err);
03484 }
03485
03486 /* OK, now we can start reading */
03487 /* There is a read function for this file, so check info and read as
03488 * many items as possible. A positive return value means a read success,
03489 * 0 end of file and a negative value an error. */
03490
03491 /* Set current user space to kernel space, because read() writes */
03492 /* to user space */
03493 oldfs = get_fs();
03494 set_fs(KERNEL_DS);
03495
03496 /* check gen-list on-disk version */
03497 tmperr = file_p->f_op->read(file_p,
03498 (__u8 *) &list_version,
03499 sizeof(list_version),
03500 &file_p->f_pos);
03501 set_fs(oldfs);
03502 /* error? */
03503 if (tmperr < sizeof(list_version))
03504 {
03505 printk(KERN_WARNING
03506 "read_lol_list(): read error from file!\n");
03507 err = -RSBAC_EREADFAILED;
03508 goto end_read;
03509 }
03510 /* if wrong list on-disk version, fail */
03511 switch(list_version)
03512 {
03513 case RSBAC_LIST_DISK_VERSION:
03514 case RSBAC_LIST_DISK_OLD_VERSION:
03515 break;
03516 default:
03517 rsbac_printk(KERN_WARNING
03518 "read_lol_list(): wrong on-disk list version %u in file %s, expected %u - error!\n",
03519 list_version,
03520 list->name,
03521 RSBAC_LIST_DISK_VERSION);
03522 err = -RSBAC_EREADFAILED;
03523 goto end_read;
03524 }
03525
03526 /* get timestamp */
03527 set_fs(KERNEL_DS);
03528 tmperr = file_p->f_op->read(file_p,
03529 (__u8 *) ×tamp,
03530 sizeof(timestamp),
03531 &file_p->f_pos);
03532 set_fs(oldfs);
03533 /* error? */
03534 if (tmperr < sizeof(timestamp))
03535 {
03536 rsbac_printk(KERN_WARNING
03537 "read_lol_list(): timestamp read error from file %s!\n",
03538 list->name);
03539 err = -RSBAC_EREADFAILED;
03540 goto end_read;
03541 }
03542
03543 /* get list info */
03544 set_fs(KERNEL_DS);
03545 tmperr = file_p->f_op->read(file_p,
03546 (__u8 *) list_info_p,
03547 sizeof(*list_info_p),
03548 &file_p->f_pos);
03549 set_fs(oldfs);
03550 /* error? */
03551 if (tmperr < sizeof(*list_info_p))
03552 {
03553 rsbac_printk(KERN_WARNING
03554 "read_lol_list(): list info read error from file %s!\n",
03555 list->name);
03556 err = -RSBAC_EREADFAILED;
03557 goto end_read;
03558 }
03559
03560 /* list timed out? System time is measured in seconds. */
03561 if( list_info_p->max_age
03562 && (timestamp + list_info_p->max_age) <= RSBAC_CURRENT_TIME)
03563 timeout = TRUE;
03564
03565 /* Valid key? */
03566 if (list_info_p->key != list->info.key)
03567 {
03568 if(timeout)
03569 {
03570 rsbac_printk(KERN_WARNING
03571 "read_lol_list(): accessing timed out list %s with wrong key, ignoring old contents!\n",
03572 list->name);
03573 goto end_read;
03574 }
03575 else
03576 {
03577 rsbac_printk(KERN_WARNING
03578 "read_lol_list(): try to access list %s with wrong key!\n",
03579 list->name);
03580 err = -EPERM;
03581 goto end_read;
03582 }
03583 }
03584
03585 /* skip the rest, if ignore is requested */
03586 if(list->flags & RSBAC_LIST_IGNORE_OLD)
03587 goto end_read;
03588
03589 switch(list_version)
03590 {
03591 case RSBAC_LIST_DISK_VERSION:
03592 set_fs(KERNEL_DS);
03593 tmperr = file_p->f_op->read(file_p,
03594 (char *) &lastchange,
03595 sizeof(lastchange),
03596 &file_p->f_pos);
03597 set_fs(oldfs);
03598 /* error? */
03599 if (tmperr < sizeof(lastchange))
03600 {
03601 rsbac_printk(KERN_WARNING
03602 "read_list(): lastchange read error from file %s!\n",
03603 list->name);
03604 err = -RSBAC_EREADFAILED;
03605 goto end_read;
03606 }
03607 #if defined(CONFIG_RSBAC_LIST_REPL)
03608 else
03609 list->lastchange = lastchange;
03610 #endif
03611 break;
03612 case RSBAC_LIST_DISK_OLD_VERSION:
03613 break;
03614 default:
03615 break;
03616 }
03617 /* if wrong list version, try to get_conv */
03618 if(list_info_p->version != list->info.version)
03619 {
03620 if(list->get_conv)
03621 conv = list->get_conv(list_info_p->version);
03622 if(list->get_subconv)
03623 subconv = list->get_subconv(list_info_p->version);
03624 if(!conv || !subconv)
03625 {
03626 if(timeout)
03627 {
03628 rsbac_printk(KERN_WARNING
03629 "read_lol_list(): accessing timed out list %s without both conversion functions, ignoring old contents!\n",
03630 list->name);
03631 goto end_read;
03632 }
03633 else
03634 {
03635 /* complain and set error, if ignore is not requested */
03636 if(!(list->flags & RSBAC_LIST_IGNORE_UNSUPP_VERSION))
03637 {
03638 rsbac_printk(KERN_WARNING
03639 "read_lol_list(): cannot convert list version %u of file %s to version %u!\n",
03640 list_info_p->version,
03641 list->name,
03642 list->info.version);
03643 err = -RSBAC_EINVALIDVERSION;
03644 }
03645 goto end_read;
03646 }
03647 }
03648 else
03649 {
03650 rsbac_printk(KERN_WARNING
03651 "read_lol_list(): converting list version %u of file %s on device %02u:%02u to version %u!\n",
03652 list_info_p->version,
03653 list->name,
03654 RSBAC_MAJOR(list->device), RSBAC_MINOR(list->device),
03655 list->info.version);
03656 }
03657 }
03658 else /* same version needs same sizes */
03659 {
03660 if( (list_info_p->desc_size != list->info.desc_size)
03661 || (list_info_p->data_size != list->info.data_size)
03662 || (list_info_p->subdesc_size != list->info.subdesc_size)
03663 || (list_info_p->subdata_size != list->info.subdata_size)
03664 )
03665 {
03666 if(timeout)
03667 {
03668 rsbac_printk(KERN_WARNING
03669 "read_lol_list(): accessing timed out list %s with wrong desc or data size(s), ignoring old contents!\n",
03670 list->name);
03671 goto end_read;
03672 }
03673 else
03674 {
03675 rsbac_printk(KERN_WARNING
03676 "read_lol_list(): desc or data size mismatch on list %s!\n",
03677 list->name);
03678 err = -RSBAC_EINVALIDVALUE;
03679 goto end_read;
03680 }
03681 }
03682 }
03683
03684 /* get list count */
03685 set_fs(KERNEL_DS);
03686 tmperr = file_p->f_op->read(file_p,
03687 (__u8 *) &list_count,
03688 sizeof(list_count),
03689 &file_p->f_pos);
03690 set_fs(oldfs);
03691 /* error? */
03692 if (tmperr < sizeof(list_count))
03693 {
03694 rsbac_printk(KERN_WARNING
03695 "read_lol_list(): list count read error from file %s!\n",
03696 list->name);
03697 err = -RSBAC_EREADFAILED;
03698 goto end_read;
03699 }
03700
03701 /* alloc mem for old and converted items */
03702 old_buf = rsbac_kmalloc(list_info_p->desc_size + list_info_p->data_size);
03703 if(!old_buf)
03704 {
03705 rsbac_printk(KERN_WARNING
03706 "read_lol_list(): cannot allocate memory!\n");
03707 err = -RSBAC_ENOMEM;
03708 goto end_read;
03709 }
03710 new_buf = rsbac_kmalloc(list->info.desc_size + list->info.data_size);
03711 if(!new_buf)
03712 {
03713 rsbac_printk(KERN_WARNING
03714 "read_lol_list(): cannot allocate memory!\n");
03715 rsbac_kfree(old_buf);
03716 err = -RSBAC_ENOMEM;
03717 goto end_read;
03718 }
03719 old_subbuf = rsbac_kmalloc(list_info_p->subdesc_size + list_info_p->subdata_size);
03720 if(!old_subbuf)
03721 {
03722 rsbac_printk(KERN_WARNING
03723 "read_lol_list(): cannot allocate memory!\n");
03724 rsbac_kfree(old_buf);
03725 rsbac_kfree(new_buf);
03726 err = -RSBAC_ENOMEM;
03727 goto end_read;
03728 }
03729 new_subbuf = rsbac_kmalloc(list->info.subdesc_size + list->info.subdata_size);
03730 if(!new_subbuf)
03731 {
03732 rsbac_printk(KERN_WARNING
03733 "read_lol_list(): cannot allocate memory!\n");
03734 rsbac_kfree(old_buf);
03735 rsbac_kfree(new_buf);
03736 rsbac_kfree(old_subbuf);
03737 err = -RSBAC_ENOMEM;
03738 goto end_read;
03739 }
03740 /* calculate data pointers */
03741 if(list_info_p->data_size)
03742 old_data = old_buf + list_info_p->desc_size;
03743 else
03744 old_data = NULL;
03745 if(list->info.data_size)
03746 new_data = new_buf + list->info.desc_size;
03747 else
03748 new_data = NULL;
03749 if(list_info_p->subdata_size)
03750 old_subdata = old_subbuf + list_info_p->subdesc_size;
03751 else
03752 old_subdata = NULL;
03753 if(list->info.subdata_size)
03754 new_subdata = new_subbuf + list->info.subdesc_size;
03755 else
03756 new_subdata = NULL;
03757
03758 /* actual reading */
03759 do
03760 {
03761 set_fs(KERNEL_DS);
03762 tmperr = file_p->f_op->read(file_p,
03763 (char *) &max_age,
03764 sizeof(max_age),
03765 &file_p->f_pos);
03766 set_fs(oldfs);
03767 if(conv)
03768 {
03769 set_fs(KERNEL_DS);
03770 tmperr = file_p->f_op->read(file_p,
03771 old_buf,
03772 list_info_p->desc_size + list_info_p->data_size,
03773 &file_p->f_pos);
03774 set_fs(oldfs);
03775 if(tmperr > 0)
03776 { /* convert */
03777 converr = conv(old_buf, old_data,
03778 new_buf, new_data);
03779 if(converr)
03780 tmperr = converr;
03781 }
03782 }
03783 else
03784 {
03785 set_fs(KERNEL_DS);
03786 tmperr = file_p->f_op->read(file_p,
03787 new_buf,
03788 list->info.desc_size + list->info.data_size,
03789 &file_p->f_pos);
03790 set_fs(oldfs);
03791 }
03792 /* if successful, add item */
03793 if (tmperr > 0)
03794 {
03795 /* wait for write access to list */
03796 rsbac_write_lock(&list->lock, &flags);
03797 item_p = add_lol_item(list, max_age, new_buf, new_data);
03798 /* allow access */
03799 rsbac_write_unlock(&list->lock, &flags);
03800 if(!item_p)
03801 {
03802 err = -RSBAC_ENOMEM;
03803 goto end_read_free;
03804 }
03805 read_count++;
03806 /*
03807 #ifdef CONFIG_RSBAC_DEBUG
03808 if (rsbac_debug_lists) rsbac_printk(KERN_DEBUG "read_lol_list(): read item %i\n",
03809 user_aci.id);
03810 #endif
03811 */
03812 set_fs(KERNEL_DS);
03813 tmperr = file_p->f_op->read(file_p,
03814 (__u8 *) &sublen,
03815 sizeof(sublen),
03816 &file_p->f_pos);
03817 set_fs(oldfs);
03818 /* if successful, read and add sublen subitems */
03819 if (tmperr > 0)
03820 {
03821 for(i=0;i<sublen;i++)
03822 {
03823 set_fs(KERNEL_DS);
03824 tmperr = file_p->f_op->read(file_p,
03825 (char *) &max_age,
03826 sizeof(max_age),
03827 &file_p->f_pos);
03828 set_fs(oldfs);
03829 if(subconv)
03830 {
03831 set_fs(KERNEL_DS);
03832 tmperr = file_p->f_op->read(file_p,
03833 old_subbuf,
03834 list_info_p->subdesc_size + list_info_p->subdata_size,
03835 &file_p->f_pos);
03836 set_fs(oldfs);
03837 if(tmperr > 0)
03838 { /* convert */
03839 converr = subconv(old_subbuf, old_subdata,
03840 new_subbuf, new_subdata);
03841 if(converr)
03842 tmperr = converr;
03843 }
03844 }
03845 else
03846 {
03847 set_fs(KERNEL_DS);
03848 tmperr = file_p->f_op->read(file_p,
03849 new_subbuf,
03850 list->info.subdesc_size + list->info.subdata_size,
03851 &file_p->f_pos);
03852 set_fs(oldfs);
03853 }
03854 if(tmperr > 0)
03855 {
03856 /* wait for write access to list */
03857 rsbac_write_lock(&list->lock, &flags);
03858 if (!add_lol_subitem(list,
03859 item_p,
03860 max_age,
03861 new_subbuf,
03862 new_subdata))
03863 {
03864 rsbac_printk(KERN_WARNING
03865 "read_lol_list(): could not add subitem!\n");
03866 i = sublen;
03867 tmperr = -1;
03868 }
03869 /* allow access */
03870 rsbac_write_unlock(&list->lock, &flags);
03871 }
03872 else
03873 {
03874 i = sublen;
03875 tmperr = -1;
03876 }
03877 }
03878 }
03879 }
03880 }
03881 while (tmperr > 0); /* end of do */
03882
03883 if (tmperr < 0)
03884 {
03885 rsbac_printk(KERN_WARNING "read_lol_list(): read error from file %s!\n",
03886 list->name);
03887 err = -RSBAC_EREADFAILED;
03888 }
03889
03890 if (read_count != list_count)
03891 {
03892 rsbac_printk(KERN_WARNING "read_lol_list(): read %lu, expected %u items from file %s!\n",
03893 read_count,
03894 list_count,
03895 list->name);
03896 err = -RSBAC_EREADFAILED;
03897 }
03898
03899 end_read_free:
03900 rsbac_kfree(old_buf);
03901 rsbac_kfree(new_buf);
03902 rsbac_kfree(old_subbuf);
03903 rsbac_kfree(new_subbuf);
03904
03905 end_read:
03906
03907 #ifdef CONFIG_RSBAC_DEBUG
03908 if (rsbac_debug_lists)
03909 {
03910 rsbac_printk(KERN_DEBUG "read_lol_list(): %lu entries read.\n",
03911 read_count);
03912 }
03913 #endif
03914 /* We do not need this file any more */
03915 rsbac_read_close(file_p);
03916 rsbac_kfree(list_info_p);
03917 rsbac_kfree(file_p);
03918 return(err);
03919 } /* end of read_lol_list() */
|
|
|
Definition at line 2467 of file gen_lists.c. References rsbac_list_reg_item_t::count, rsbac_list_reg_item_t::curr, rsbac_list_reg_item_t::head, rsbac_list_item_t::next, NULL, rsbac_kfree(), and rsbac_list_reg_item_t::tail. Referenced by clear_reg(), and rsbac_ta_list_remove_all(). 02468 {
02469 struct rsbac_list_item_t * item_p;
02470 struct rsbac_list_item_t * next_item_p;
02471
02472 /* cleanup all items */
02473 item_p = list->head;
02474 while(item_p)
02475 {
02476 next_item_p = item_p->next;
02477 rsbac_kfree(item_p);
02478 item_p = next_item_p;
02479 }
02480 list->head = NULL;
02481 list->tail = NULL;
02482 list->curr = NULL;
02483 list->count = 0;
02484 }
|
|
|
Definition at line 2865 of file gen_lists.c. References rsbac_list_lol_reg_item_t::count, rsbac_list_lol_reg_item_t::curr, rsbac_list_lol_item_t::head, rsbac_list_lol_reg_item_t::head, rsbac_list_lol_item_t::next, rsbac_list_item_t::next, NULL, rsbac_kfree(), and rsbac_list_lol_reg_item_t::tail. Referenced by clear_lol_reg(), and rsbac_ta_list_lol_remove_all(). 02866 {
02867 struct rsbac_list_lol_item_t * item_p;
02868 struct rsbac_list_lol_item_t * next_item_p;
02869 struct rsbac_list_item_t * subitem_p;
02870 struct rsbac_list_item_t * next_subitem_p;
02871
02872 /* cleanup all items */
02873 item_p = list->head;
02874 while(item_p)
02875 {
02876 /* first remove subitems */
02877 subitem_p = item_p->head;
02878 while(subitem_p)
02879 {
02880 next_subitem_p = subitem_p->next;
02881 rsbac_kfree(subitem_p);
02882 subitem_p = next_subitem_p;
02883 }
02884 next_item_p = item_p->next;
02885 rsbac_kfree(item_p);
02886 item_p = next_item_p;
02887 }
02888 list->head = NULL;
02889 list->tail = NULL;
02890 list->curr = NULL;
02891 list->count = 0;
02892 }
|
|
|
Definition at line 2845 of file gen_lists.c. References rsbac_list_lol_item_t::count, rsbac_list_lol_item_t::curr, rsbac_list_lol_item_t::head, rsbac_list_item_t::next, NULL, rsbac_kfree(), and rsbac_list_lol_item_t::tail. Referenced by rsbac_ta_list_lol_subremove_all(). 02847 {
02848 struct rsbac_list_item_t * subitem_p;
02849 struct rsbac_list_item_t * next_subitem_p;
02850
02851 /* cleanup all items */
02852 subitem_p = sublist->head;
02853 while(subitem_p)
02854 {
02855 next_subitem_p = subitem_p->next;
02856 rsbac_kfree(subitem_p);
02857 subitem_p = next_subitem_p;
02858 }
02859 sublist->head = NULL;
02860 sublist->tail = NULL;
02861 sublist->curr = NULL;
02862 sublist->count = 0;
02863 }
|
|
||||||||||||
|
Definition at line 2452 of file gen_lists.c. References do_remove_item(), and lookup_item(). 02455 {
02456 struct rsbac_list_item_t * item_p;
02457
02458 if(!list || !desc)
02459 return;
02460 /* first we must locate the item. */
02461 if ( (item_p = lookup_item(list, desc)) )
02462 {
02463 do_remove_item(list, item_p);
02464 }
02465 }
|
|
||||||||||||
|
Definition at line 2717 of file gen_lists.c. References do_remove_lol_item(), and lookup_lol_item(). Referenced by rsbac_ta_list_lol_remove(), and rsbac_ta_list_lol_subadd_ttl(). 02720 {
02721 struct rsbac_list_lol_item_t * item_p;
02722
02723 if(!list || !desc)
02724 return;
02725
02726 /* first we must locate the item. */
02727 if ( (item_p = lookup_lol_item(list, desc)) )
02728 {
02729 do_remove_lol_item(list, item_p);
02730 }
02731 }
|
|
|
Definition at line 3002 of file gen_lists.c. References clear_lol_reg(), rsbac_list_lol_reg_head_t::count, rsbac_list_lol_reg_head_t::curr, rsbac_list_lol_reg_head_t::head, lookup_lol_reg(), rsbac_list_lol_reg_item_t::next, NULL, rsbac_list_lol_reg_item_t::prev, rsbac_list_lol_reg_item_t::self, and rsbac_list_lol_reg_head_t::tail. Referenced by rsbac_list_lol_destroy(), and rsbac_list_lol_detach(). 03003 {
03004 struct rsbac_list_lol_reg_item_t * item_p;
03005
03006 /* first we must locate the item. */
03007 if ( (item_p = lookup_lol_reg(handle)) )
03008 { /* ok, item was found */
03009 /* protect against reuse */
03010 item_p->self = NULL;
03011 if ( (lol_reg_head.head == item_p) )
03012 { /* item is head */
03013 if ( (lol_reg_head.tail == item_p) )
03014 { /* item is head and tail = only item -> list will be empty*/
03015 lol_reg_head.head = NULL;
03016 lol_reg_head.tail = NULL;
03017 }
03018 else
03019 { /* item is head, but not tail -> next item becomes head */
03020 item_p->next->prev = NULL;
03021 lol_reg_head.head = item_p->next;
03022 };
03023 }
03024 else
03025 { /* item is not head */
03026 if ( (lol_reg_head.tail == item_p) )
03027 { /*item is not head, but tail -> previous item becomes tail*/
03028 item_p->prev->next = NULL;
03029 lol_reg_head.tail = item_p->prev;
03030 }
03031 else
03032 { /* item is neither head nor tail -> item is cut out */
03033 item_p->prev->next = item_p->next;
03034 item_p->next->prev = item_p->prev;
03035 }
03036 }
03037
03038 /* curr is no longer valid -> reset */
03039 lol_reg_head.curr=NULL;
03040 /* adjust counter */
03041 lol_reg_head.count--;
03042 /* now we can remove the item from memory */
03043 clear_lol_reg(item_p);
03044 } /* end of if: item was found */
03045 }
|
|
||||||||||||||||
|
Definition at line 2607 of file gen_lists.c. References do_remove_lol_subitem(), and lookup_lol_subitem(). Referenced by rsbac_ta_list_lol_subremove(), and rsbac_ta_list_lol_subremove_from_all(). 02611 {
02612 struct rsbac_list_item_t * item_p;
02613
02614 if(!list || !sublist || !subdesc)
02615 return;
02616
02617 /* first we must locate the item. */
02618 if ( (item_p = lookup_lol_subitem(list, sublist, subdesc)) )
02619 {
02620 do_remove_lol_subitem(sublist, item_p);
02621 }
02622 }
|
|
|
Definition at line 2941 of file gen_lists.c. References clear_reg(), rsbac_list_reg_head_t::count, rsbac_list_reg_head_t::curr, rsbac_list_reg_head_t::head, lookup_reg(), rsbac_list_reg_item_t::next, NULL, rsbac_list_reg_item_t::prev, rsbac_list_reg_item_t::self, and rsbac_list_reg_head_t::tail. Referenced by rsbac_list_destroy(), and rsbac_list_detach(). 02942 {
02943 struct rsbac_list_reg_item_t * item_p;
02944
02945 /* first we must locate the item. */
02946 if ( (item_p = lookup_reg(handle)) )
02947 { /* ok, item was found */
02948 /* protect against reuse */
02949 item_p->self = NULL;
02950 if ( (reg_head.head == item_p) )
02951 { /* item is head */
02952 if ( (reg_head.tail == item_p) )
02953 { /* item is head and tail = only item -> list will be empty*/
02954 reg_head.head = NULL;
02955 reg_head.tail = NULL;
02956 }
02957 else
02958 { /* item is head, but not tail -> next item becomes head */
02959 item_p->next->prev = NULL;
02960 reg_head.head = item_p->next;
02961 }
02962 }
02963 else
02964 { /* item is not head */
02965 if ( (reg_head.tail == item_p) )
02966 { /*item is not head, but tail -> previous item becomes tail*/
02967 item_p->prev->next = NULL;
02968 reg_head.tail = item_p->prev;
02969 }
02970 else
02971 { /* item is neither head nor tail -> item is cut out */
02972 item_p->prev->next = item_p->next;
02973 item_p->next->prev = item_p->prev;
02974 }
02975 }
02976
02977 /* curr is no longer valid -> reset */
02978 reg_head.curr=NULL;
02979 /* adjust counter */
02980 reg_head.count--;
02981 /* now we can remove the item from memory */
02982 clear_reg(item_p);
02983 } /* end of if: item was found */
02984 }
|
|
|
Definition at line 5429 of file gen_lists.c. References rsbac_list_reg_item_t::count, rsbac_list_lol_item_t::count, rsbac_list_lol_reg_item_t::count, rsbac_list_info_t::data_size, rsbac_list_lol_info_t::data_size, rsbac_list_reg_item_t::def_data, rsbac_list_lol_reg_item_t::def_data, rsbac_list_lol_reg_item_t::def_subdata, rsbac_list_info_t::desc_size, rsbac_list_lol_info_t::desc_size, rsbac_list_reg_item_t::device, rsbac_list_lol_reg_item_t::device, rsbac_list_reg_item_t::dirty, rsbac_list_lol_reg_item_t::dirty, do_remove_item(), do_remove_lol_item(), do_remove_lol_subitem(), rsbac_list_reg_item_t::flags, rsbac_list_lol_reg_item_t::flags, rsbac_list_reg_head_t::head, rsbac_list_reg_item_t::head, rsbac_list_lol_reg_head_t::head, rsbac_list_lol_reg_item_t::head, rsbac_list_reg_item_t::info, rsbac_list_lol_reg_item_t::info, list_initialized, rsbac_list_reg_head_t::lock, rsbac_list_reg_item_t::lock, rsbac_list_lol_reg_head_t::lock, rsbac_list_lol_reg_item_t::lock, rsbac_list_item_t::max_age, rsbac_list_lol_item_t::max_age, rsbac_list_reg_item_t::name, rsbac_list_lol_reg_item_t::name, rsbac_list_item_t::next, rsbac_list_reg_item_t::next, rsbac_list_lol_item_t::next, rsbac_list_lol_reg_item_t::next, RSBAC_ENOTINITIALIZED, RSBAC_LIST_DEF_DATA, RSBAC_LIST_PERSIST, rsbac_printk(), rsbac_list_lol_info_t::subdata_size, and rsbac_list_lol_info_t::subdesc_size. Referenced by rsbac_do_init(), and sys_rsbac_check(). 05430 {
05431 struct rsbac_list_reg_item_t * list;
05432 struct rsbac_list_lol_reg_item_t * lol_list;
05433 struct rsbac_list_item_t * item_p;
05434 struct rsbac_list_item_t * next_item_p;
05435 struct rsbac_list_lol_item_t * lol_item_p;
05436 struct rsbac_list_lol_item_t * next_lol_item_p;
05437 struct rsbac_list_item_t * lol_subitem_p;
05438 struct rsbac_list_item_t * next_lol_subitem_p;
05439 u_long lock_flags, rlock_flags;
05440 u_long tmp_count;
05441 u_long tmp_subcount;
05442 u_long subitem_count;
05443 u_long dirty = 0;
05444
05445 #ifdef CONFIG_RSBAC_DEBUG
05446 if(rsbac_debug_lists)
05447 {
05448 rsbac_printk(KERN_DEBUG "rsbac_check_lists() called.\n");
05449 }
05450 #endif
05451 if(!list_initialized)
05452 return -RSBAC_ENOTINITIALIZED;
05453 rsbac_read_lock(®_head.lock, &rlock_flags);
05454 list = reg_head.head;
05455 while(list)
05456 {
05457 /* check list */
05458 rsbac_write_lock(&list->lock, &lock_flags);
05459 tmp_count = 0;
05460 item_p = list->head;
05461 while(item_p)
05462 {
05463 if( ( item_p->max_age
05464 && (item_p->max_age <= RSBAC_CURRENT_TIME)
05465 )
05466 || ( list->def_data
05467 && !memcmp(((char *) item_p) + sizeof(*item_p) + list->info.desc_size,
05468 list->def_data,
05469 list->info.data_size)
05470 )
05471 )
05472 {
05473 next_item_p = item_p->next;
05474 do_remove_item(list, item_p);
05475 item_p = next_item_p;
05476 }
05477 else
05478 {
05479 tmp_count++;
05480 item_p = item_p->next;
05481 }
05482 }
05483 if(tmp_count != list->count)
05484 {
05485 if(correct)
05486 {
05487 rsbac_printk(KERN_WARNING
05488 "rsbac_check_lists(): correcting count mismatch for list %s on device %02u:%02u - was %u, counted %lu!\n",
05489 list->name, RSBAC_MAJOR(list->device), RSBAC_MINOR(list->device), list->count, tmp_count);
05490 list->count = tmp_count;
05491 }
05492 else
05493 {
05494 rsbac_printk(KERN_WARNING
05495 "rsbac_check_lists(): count mismatch for list %s on device %02u:%02u - is %u, counted %lu!\n",
05496 list->name, RSBAC_MAJOR(list->device), RSBAC_MINOR(list->device), list->count, tmp_count);
05497 }
05498 }
05499 rsbac_write_unlock(&list->lock, &lock_flags);
05500 if(list->dirty && (list->flags & RSBAC_LIST_PERSIST))
05501 {
05502 dirty++;
05503 #ifdef CONFIG_RSBAC_DEBUG
05504 if(rsbac_debug_lists)
05505 {
05506 rsbac_printk(KERN_DEBUG
05507 "rsbac_check_lists(): %s on %02u:%02u has %u items (list is dirty)\n",
05508 list->name, RSBAC_MAJOR(list->device), RSBAC_MINOR(list->device), list->count);
05509 }
05510 #endif
05511 }
05512 #ifdef CONFIG_RSBAC_DEBUG
05513 else
05514 {
05515 if(rsbac_debug_lists)
05516 {
05517 rsbac_printk(KERN_DEBUG
05518 "rsbac_check_lists(): %s on %02u:%02u has %u items\n",
05519 list->name, RSBAC_MAJOR(list->device), RSBAC_MINOR(list->device), list->count);
05520 }
05521 }
05522 #endif
05523 list = list->next;
05524 }
05525 rsbac_read_unlock(®_head.lock, &rlock_flags);
05526
05527 rsbac_read_lock(&lol_reg_head.lock, &rlock_flags);
05528 lol_list = lol_reg_head.head;
05529 while(lol_list)
05530 {
05531 /* check list */
05532 rsbac_write_lock(&lol_list->lock, &lock_flags);
05533 tmp_count = 0;
05534 subitem_count = 0;
05535 lol_item_p = lol_list->head;
05536 while(lol_item_p)
05537 {
05538 if( ( lol_item_p->max_age
05539 && (lol_item_p->max_age <= RSBAC_CURRENT_TIME)
05540 )
05541 || ( lol_list->def_data
05542 && !lol_item_p->count
05543 && !memcmp(((char *) lol_item_p) + sizeof(*lol_item_p) + lol_list->info.desc_size,
05544 lol_list->def_data,
05545 lol_list->info.data_size)
05546 )
05547 || ( !lol_list->info.data_size
05548 && (lol_list->flags & RSBAC_LIST_DEF_DATA)
05549 && !lol_item_p->count
05550 )
05551 )
05552 {
05553 next_lol_item_p = lol_item_p->next;
05554 do_remove_lol_item(lol_list, lol_item_p);
05555 lol_item_p = next_lol_item_p;
05556 }
05557 else
05558 {
05559 tmp_count++;
05560 tmp_subcount = 0;
05561 lol_subitem_p = lol_item_p->head;
05562 while(lol_subitem_p)
05563 {
05564 if( ( lol_subitem_p->max_age
05565 && (lol_subitem_p->max_age <= RSBAC_CURRENT_TIME)
05566 )
05567 || ( lol_list->def_subdata
05568 && !memcmp(((char *) lol_subitem_p) + sizeof(*lol_subitem_p) + lol_list->info.subdesc_size,
05569 lol_list->def_subdata,
05570 lol_list->info.subdata_size)
05571 )
05572 )
05573 {
05574 next_lol_subitem_p = lol_subitem_p->next;
05575 do_remove_lol_subitem(lol_item_p, lol_subitem_p);
05576 lol_subitem_p = next_lol_subitem_p;
05577 }
05578 else
05579 {
05580 tmp_subcount++;
05581 lol_subitem_p = lol_subitem_p->next;
05582 }
05583 }
05584 if(tmp_subcount != lol_item_p->count)
05585 {
05586 if(correct)
05587 {
05588 rsbac_printk(KERN_WARNING
05589 "rsbac_check_lists(): correcting count mismatch for list of lists %s sublist on %02u:%02u - was %lu, counted %lu!\n",
05590 lol_list->name, RSBAC_MAJOR(lol_list->device), RSBAC_MINOR(lol_list->device), lol_item_p->count, tmp_subcount);
05591 lol_item_p->count = tmp_subcount;
05592 }
05593 else
05594 {
05595 rsbac_printk(KERN_WARNING
05596 "rsbac_check_lists(): count mismatch for list of lists %s sublist on %02u:%02u - is %lu, counted %lu!\n",
05597 lol_list->name, RSBAC_MAJOR(lol_list->device), RSBAC_MINOR(lol_list->device), lol_item_p->count, tmp_subcount);
05598 }
05599 }
05600 subitem_count += lol_item_p->count;
05601 lol_item_p = lol_item_p->next;
05602 }
05603 }
05604 if(tmp_count != lol_list->count)
05605 {
05606 if(correct)
05607 {
05608 rsbac_printk(KERN_WARNING
05609 "rsbac_check_lists(): correcting count mismatch for list of lists %s on %02u:%02u - was %u, counted %lu!\n",
05610 lol_list->name, RSBAC_MAJOR(lol_list->device), RSBAC_MINOR(lol_list->device), lol_list->count, tmp_count);
05611 lol_list->count = tmp_count;
05612 }
05613 else
05614 {
05615 rsbac_printk(KERN_WARNING
05616 "rsbac_check_lists(): count mismatch for list of lists %s on %02u:%02u - is %u, counted %lu!\n",
05617 lol_list->name, RSBAC_MAJOR(lol_list->device), RSBAC_MINOR(lol_list->device), lol_list->count, tmp_count);
05618 }
05619 }
05620 rsbac_write_unlock(&lol_list->lock, &lock_flags);
05621 if(lol_list->dirty && (lol_list->flags & RSBAC_LIST_PERSIST))
05622 {
05623 dirty++;
05624 #ifdef CONFIG_RSBAC_DEBUG
05625 if(rsbac_debug_lists)
05626 {
05627 rsbac_printk(KERN_DEBUG
05628 "rsbac_check_lists(): %s on %02u:%02u has %u items and %lu subitems (list is dirty)\n",
05629 lol_list->name, RSBAC_MAJOR(lol_list->device), RSBAC_MINOR(lol_list->device), lol_list->count, subitem_count);
05630 }
05631 #endif
05632 }
05633 #ifdef CONFIG_RSBAC_DEBUG
05634 else
05635 {
05636 if(rsbac_debug_lists)
05637 {
05638 rsbac_printk(KERN_DEBUG
05639 "rsbac_check_lists(): %s on %02u:%02u has %u items and %lu subitems\n",
05640 lol_list->name, RSBAC_MAJOR(lol_list->device), RSBAC_MINOR(lol_list->device), lol_list->count, subitem_count);
05641 }
05642 }
05643 #endif
05644 lol_list = lol_list->next;
05645 }
05646 rsbac_read_unlock(&lol_reg_head.lock, &rlock_flags);
05647 return 0;
05648 }
|
|
||||||||||||||||
|
Definition at line 7101 of file gen_lists.c. References RSBAC_LIST_TTL_KEEP, and rsbac_ta_list_add_ttl(). Referenced by need_overwrite_func(), register_user_lists(), request_func(), rsbac_adf_log_switch(), rsbac_do_init(), rsbac_init(), rsbac_init_acl(), rsbac_init_rc(), rsbac_kthread_notify(), set_attr_func(), syscall_func(), and write_func(). 07105 {
07106 return rsbac_ta_list_add_ttl(0, handle, RSBAC_LIST_TTL_KEEP, desc, data);
07107 }
|
|
||||||||||||||||||||
|
Definition at line 7089 of file gen_lists.c. References rsbac_ta_list_add_ttl(). Referenced by set_attr_fd(). 07094 {
07095 return rsbac_ta_list_add_ttl(0, handle, ttl, desc, data);
07096 }
|
|
||||||||||||
|
Definition at line 5653 of file gen_lists.c. References rsbac_list_reg_item_t::count, rsbac_list_info_t::data_size, rsbac_list_reg_item_t::def_data, rsbac_list_info_t::desc_size, rsbac_list_reg_item_t::device, rsbac_list_reg_item_t::dirty, do_remove_item(), rsbac_list_reg_item_t::head, rsbac_list_reg_item_t::info, list_initialized, rsbac_list_reg_head_t::lock, rsbac_list_reg_item_t::lock, rsbac_list_item_t::max_age, rsbac_list_reg_item_t::name, rsbac_list_item_t::next, RSBAC_EINVALIDVALUE, RSBAC_ENOTINITIALIZED, rsbac_printk(), rsbac_list_reg_item_t::self, and TRUE. 05656 {
05657 struct rsbac_list_reg_item_t * list;
05658 struct rsbac_list_item_t * item_p;
05659 struct rsbac_list_item_t * next_item_p;
05660 u_long lock_flags;
05661 u_long rlock_flags;
05662 u_long tmp_count;
05663
05664 if(!handle)
05665 return -RSBAC_EINVALIDVALUE;
05666 if(!list_initialized)
05667 return -RSBAC_ENOTINITIALIZED;
05668
05669 list = (struct rsbac_list_reg_item_t *) handle;
05670 if(!list || (list->self != list))
05671 return -RSBAC_EINVALIDVALUE;
05672
05673 rsbac_read_lock(®_head.lock, &rlock_flags);
05674 #ifdef CONFIG_RSBAC_DEBUG
05675 if(rsbac_debug_lists)
05676 rsbac_printk(KERN_DEBUG "rsbac_list_check: checking list %s.\n",
05677 list->name);
05678 #endif
05679 rsbac_write_lock(&list->lock, &lock_flags);
05680 tmp_count = 0;
05681 item_p = list->head;
05682 while(item_p)
05683 {
05684 if( ( item_p->max_age
05685 && (item_p->max_age <= RSBAC_CURRENT_TIME)
05686 )
05687 || ( list->def_data
05688 && !memcmp(((char *) item_p) + sizeof(*item_p) + list->info.desc_size,
05689 list->def_data,
05690 list->info.data_size)
05691 )
05692 )
05693 {
05694 next_item_p = item_p->next;
05695 do_remove_item(list, item_p);
05696 item_p = next_item_p;
05697 list->dirty = TRUE;
05698 }
05699 else
05700 {
05701 tmp_count++;
05702 item_p = item_p->next;
05703 }
05704 }
05705 if(tmp_count != list->count)
05706 {
05707 if(correct)
05708 {
05709 rsbac_printk(KERN_WARNING
05710 "rsbac_list_check(): correcting count mismatch for list %s on device %02u:%02u - was %u, counted %lu!\n",
05711 list->name, RSBAC_MAJOR(list->device), RSBAC_MINOR(list->device), list->count, tmp_count);
05712 list->count = tmp_count;
05713 list->dirty = TRUE;
05714 }
05715 else
05716 {
05717 rsbac_printk(KERN_WARNING
05718 "rsbac_list_check(): count mismatch for list %s on device %02u:%02u - is %u, counted %lu!\n",
05719 list->name, RSBAC_MAJOR(list->device), RSBAC_MINOR(list->device), list->count, tmp_count);
05720 }
05721 }
05722 rsbac_write_unlock(&list->lock, &lock_flags);
05723 rsbac_read_unlock(®_head.lock, &rlock_flags);
05724 return 0;
05725 }
|
|
||||||||||||
|
Definition at line 5055 of file gen_lists.c. Referenced by acl_register_fd_lists(), auth_register_fd_lists(), mac_register_fd_lists(), register_fd_lists(), register_process_lists(), register_user_lists(), rsbac_init_acl(), rsbac_init_pm(), rsbac_init_rc(), and rsbac_list_init(). 05056 {
05057 if( *((__u32*) desc1) < *((__u32*) desc2))
05058 return -1;
05059 return( *((__u32*) desc1) != *((__u32*) desc2));
05060 }
|
|
|
Definition at line 9535 of file gen_lists.c. References rsbac_ta_list_count(). Referenced by register_user_lists(), rsbac_check_acl(), rsbac_init_acl(), rsbac_init_rc(), rsbac_stats(), rsbac_stats_acl(), rsbac_stats_pm(), rsbac_stats_rc(), and rsbac_stats_um(). 09536 {
09537 return rsbac_ta_list_count(0, handle);
09538 }
|
|
||||||||||||
|
Definition at line 6299 of file gen_lists.c. References rsbac_list_reg_item_t::flags, rsbac_list_reg_item_t::info, rsbac_list_info_t::key, list_initialized, rsbac_list_reg_head_t::lock, lookup_reg(), rsbac_list_reg_item_t::name, NULL, proc_rsbac_backup_p, remove_reg(), RSBAC_EINVALIDPOINTER, RSBAC_EINVALIDVALUE, RSBAC_ENOTINITIALIZED, RSBAC_LIST_BACKUP, RSBAC_LIST_PERSIST, and rsbac_printk(). 06300 {
06301 struct rsbac_list_reg_item_t * reg_item_p;
06302 u_long lock_flags;
06303 int err = 0;
06304
06305 if(!handle_p)
06306 return -RSBAC_EINVALIDPOINTER;
06307 if(!*handle_p)
06308 return -RSBAC_EINVALIDVALUE;
06309 if(!list_initialized)
06310 return -RSBAC_ENOTINITIALIZED;
06311
06312 rsbac_write_lock(®_head.lock, &lock_flags);
06313 reg_item_p = lookup_reg((struct rsbac_list_reg_item_t *) *handle_p);
06314 if(!reg_item_p)
06315 {
06316 rsbac_write_unlock(®_head.lock, &lock_flags);
06317 rsbac_printk(KERN_WARNING "rsbac_list_destroy: destroying list failed due to invalid handle!\n");
06318 return -RSBAC_EINVALIDVALUE;
06319 }
06320 if(reg_item_p->info.key != key)
06321 {
06322 rsbac_write_unlock(®_head.lock, &lock_flags);
06323 rsbac_printk(KERN_WARNING "rsbac_list_destroy: destroying list %s denied due to invalid key!\n",
06324 reg_item_p->name);
06325 return -EPERM;
06326 }
06327 #ifdef CONFIG_RSBAC_DEBUG
06328 if(rsbac_debug_lists)
06329 {
06330 rsbac_printk(KERN_DEBUG "rsbac_list_destroy: destroying list %s.\n",
06331 reg_item_p->name);
06332 }
06333 #endif
06334 #if defined(CONFIG_RSBAC_PROC) && defined(CONFIG_PROC_FS)
06335 /* delete proc entry, if it exists */
06336 if( (reg_item_p->flags & RSBAC_LIST_BACKUP)
06337 && reg_item_p->proc_entry_p
06338 )
06339 {
06340 remove_proc_entry(reg_item_p->name, proc_rsbac_backup_p);
06341 reg_item_p->proc_entry_p = NULL;
06342 }
06343 #endif
06344
06345 #if 0
06346 if(reg_item_p->flags & RSBAC_LIST_PERSIST)
06347 err = unlink_list(reg_item_p);
06348 #endif
06349
06350 remove_reg(reg_item_p);
06351 *handle_p = NULL;
06352 rsbac_write_unlock(®_head.lock, &lock_flags);
06353 return err;
06354 }
|
|
||||||||||||
|
Definition at line 6421 of file gen_lists.c. References rsbac_list_write_item_t::buflen, rsbac_list_write_head_t::count, rsbac_list_reg_item_t::dirty, FALSE, fill_buffer(), rsbac_list_reg_item_t::flags, rsbac_list_write_head_t::head, rsbac_list_reg_item_t::info, rsbac_list_info_t::key, list_initialized, rsbac_list_reg_head_t::lock, lookup_reg(), rsbac_list_reg_item_t::name, rsbac_list_reg_item_t::no_write, NULL, proc_rsbac_backup_p, remove_reg(), RSBAC_EINVALIDPOINTER, RSBAC_EINVALIDVALUE, RSBAC_ENOTINITIALIZED, RSBAC_ENOTWRITABLE, RSBAC_LIST_BACKUP, RSBAC_LIST_PERSIST, rsbac_list_write_buffers(), rsbac_printk(), rsbac_list_write_head_t::tail, rsbac_list_write_head_t::total, and TRUE. Referenced by aci_detach_fd_lists(), cleanup_module(), and init_module(). 06422 {
06423 struct rsbac_list_reg_item_t * reg_item_p;
06424 u_long lock_flags;
06425 int err = 0;
06426
06427 if(!handle_p)
06428 return -RSBAC_EINVALIDPOINTER;
06429 if(!*handle_p)
06430 return -RSBAC_EINVALIDVALUE;
06431 if(!list_initialized)
06432 return -RSBAC_ENOTINITIALIZED;
06433
06434 rsbac_read_lock(®_head.lock, &lock_flags);
06435 reg_item_p = lookup_reg((struct rsbac_list_reg_item_t *) *handle_p);
06436 if(!reg_item_p)
06437 {
06438 rsbac_read_unlock(®_head.lock, &lock_flags);
06439 rsbac_printk(KERN_WARNING "rsbac_list_detach: detaching list failed due to invalid handle!\n");
06440 return -RSBAC_EINVALIDVALUE;
06441 }
06442 if(reg_item_p->info.key != key)
06443 {
06444 rsbac_read_unlock(®_head.lock, &lock_flags);
06445 rsbac_printk(KERN_WARNING "rsbac_list_detach: detaching list %s denied due to invalid key %u!\n",
06446 reg_item_p->name,
06447 key);
06448 return -EPERM;
06449 }
06450 #if defined(CONFIG_RSBAC_PROC) && defined(CONFIG_PROC_FS)
06451 /* delete proc entry, if it exists */
06452 if( (reg_item_p->flags & RSBAC_LIST_BACKUP)
06453 && reg_item_p->proc_entry_p
06454 )
06455 {
06456 remove_proc_entry(reg_item_p->name, proc_rsbac_backup_p);
06457 reg_item_p->proc_entry_p = NULL;
06458 }
06459 #endif
06460 #ifndef CONFIG_RSBAC_NO_WRITE
06461 /* final write, if dirty etc. */
06462 if( (reg_item_p->flags & RSBAC_LIST_PERSIST)
06463 && reg_item_p->dirty
06464 && !reg_item_p->no_write
06465 )
06466 {
06467 struct rsbac_list_write_head_t write_head;
06468 struct rsbac_list_write_item_t * write_item_p;
06469
06470 reg_item_p->dirty = FALSE;
06471 err = fill_buffer(reg_item_p, &write_item_p);
06472 if(!err)
06473 {
06474 write_head.head = write_item_p;
06475 write_head.tail = write_item_p;
06476 write_head.total = write_item_p->buflen;
06477 write_head.count = 1;
06478 rsbac_read_unlock(®_head.lock, &lock_flags);
06479 rsbac_list_write_buffers(write_head, TRUE);
06480 }
06481 else
06482 {
06483 rsbac_read_unlock(®_head.lock, &lock_flags);
06484 if(err != -RSBAC_ENOTWRITABLE)
06485 {
06486 rsbac_printk(KERN_WARNING
06487 "rsbac_list_detach(): fill_buffer() for list %s returned error %i\n",
06488 reg_item_p->name, err);
06489 }
06490 }
06491 }
06492 else
06493 rsbac_read_unlock(®_head.lock, &lock_flags);
06494 #else
06495 rsbac_read_unlock(®_head.lock, &lock_flags);
06496 #endif
06497 /* disable handle */
06498 *handle_p = NULL;
06499 /* too bad that the list might have been changed again - we do not care anymore */
06500 rsbac_write_lock(®_head.lock, &lock_flags);
06501 remove_reg(reg_item_p);
06502 rsbac_write_unlock(®_head.lock, &lock_flags);
06503 return err;
06504 }
|
|
||||||||||||
|
Definition at line 9060 of file gen_lists.c. References rsbac_ta_list_exist(). Referenced by init_module(), rsbac_check_acl(), and rsbac_init_rc(). 09063 {
09064 return rsbac_ta_list_exist(0, handle, desc);
09065 }
|
|
||||||||||||
|
Definition at line 10041 of file gen_lists.c. References rsbac_ta_list_get_all_data(). 10044 {
10045 return rsbac_ta_list_get_all_data(0, handle, array_p);
10046 }
|
|
||||||||||||
|
Definition at line 9661 of file gen_lists.c. References rsbac_ta_list_get_all_desc(). 09664 {
09665 return rsbac_ta_list_get_all_desc(0, handle, array_p);
09666 }
|
|
||||||||||||
|
Definition at line 10496 of file gen_lists.c. References NULL, and rsbac_ta_list_get_all_items_ttl(). 10497 {
10498 return rsbac_ta_list_get_all_items_ttl(0, handle, array_p, NULL);
10499 }
|
|
||||||||||||||||
|
Definition at line 10485 of file gen_lists.c. References rsbac_ta_list_get_all_items_ttl(). 10489 {
10490 return rsbac_ta_list_get_all_items_ttl(0, handle, array_p, ttl_array_p);
10491 }
|
|
||||||||||||||||
|
Definition at line 8322 of file gen_lists.c. References NULL, and rsbac_ta_list_get_data_ttl(). Referenced by init_module(), rsbac_do_init(), rsbac_init(), and rsbac_init_debug(). 08323 {
08324 return rsbac_ta_list_get_data_ttl(0, handle, NULL, desc, data);
08325 }
|
|
||||||||||||||||||||
|
Definition at line 8311 of file gen_lists.c. References rsbac_ta_list_get_data_ttl(). 08315 {
08316 return rsbac_ta_list_get_data_ttl(0, handle, ttl_p, desc, data);
08317 }
|
|
||||||||||||||||||||
|
Definition at line 8903 of file gen_lists.c. References rsbac_ta_list_get_desc(). Referenced by rsbac_rc_get_boot_role(). 08908 {
08909 return rsbac_ta_list_get_desc(0, handle, desc, data, compare);
08910 }
|
|
|
Definition at line 10289 of file gen_lists.c. References rsbac_list_info_t::data_size, rsbac_list_info_t::desc_size, rsbac_list_reg_item_t::info, list_initialized, RSBAC_EINVALIDVALUE, RSBAC_ENOTINITIALIZED, and rsbac_list_reg_item_t::self. 10290 {
10291 struct rsbac_list_reg_item_t * list;
10292
10293 if(!handle)
10294 return -RSBAC_EINVALIDVALUE;
10295 if(!list_initialized)
10296 return -RSBAC_ENOTINITIALIZED;
10297
10298 list = (struct rsbac_list_reg_item_t *) handle;
10299 if(list->self != list)
10300 return -RSBAC_EINVALIDVALUE;
10301 return list->info.desc_size + list->info.data_size;
10302 }
|
|
||||||||||||
|
Definition at line 8645 of file gen_lists.c. References rsbac_ta_list_get_max_desc(). Referenced by rsbac_init_acl(). 08646 {
08647 return rsbac_ta_list_get_max_desc(0, handle, desc);
08648 }
|
|
||||||||||||||||
|
Definition at line 8730 of file gen_lists.c. References rsbac_ta_list_get_next_desc(). 08731 {
08732 return rsbac_ta_list_get_next_desc(0, handle, old_desc, next_desc);
08733 }
|
|
|
Definition at line 5065 of file gen_lists.c. References rsbac_list_reg_head_t::count, rsbac_list_lol_reg_head_t::count, rsbac_list_reg_head_t::curr, rsbac_list_lol_reg_head_t::curr, get_error_name(), rsbac_list_reg_head_t::head, rsbac_list_lol_reg_head_t::head, list_initialized, rsbac_list_reg_head_t::lock, rsbac_list_lol_reg_head_t::lock, rsbac_nanotime_t::nsec, NULL, proc_rsbac_root_p, rsbac_list_compare_u32(), RSBAC_LIST_PERSIST, RSBAC_LIST_PROC_NAME, rsbac_list_register(), RSBAC_LIST_REPL_PARTNER_FILENAME, RSBAC_LIST_REPL_PARTNER_KEY, RSBAC_LIST_REPL_PARTNER_VERSION, RSBAC_LIST_REPL_PROC_NAME, RSBAC_LIST_TA_KEY, RSBAC_LIST_VERSION, RSBAC_MAXNAMELEN, rsbac_printk(), rsbac_nanotime_t::sec, rsbac_list_reg_head_t::tail, rsbac_list_lol_reg_head_t::tail, and TRUE. Referenced by rsbac_do_init(). 05067 {
05068 #ifdef CONFIG_RSBAC_LIST_TRANS
05069 int err;
05070 struct rsbac_list_info_t * list_info_p;
05071 #endif
05072
05073 reg_head.head = NULL;
05074 reg_head.tail = NULL;
05075 reg_head.curr = NULL;
05076 reg_head.lock = RW_LOCK_UNLOCKED;
05077 reg_head.count = 0;
05078
05079 lol_reg_head.head = NULL;
05080 lol_reg_head.tail = NULL;
05081 lol_reg_head.curr = NULL;
05082 lol_reg_head.lock = RW_LOCK_UNLOCKED;
05083 lol_reg_head.count = 0;
05084
05085 list_initialized = TRUE;
05086
05087 #ifdef CONFIG_RSBAC_LIST_REPL
05088 repl_last.sec = 0;
05089 repl_last.nsec = 0;
05090 #endif
05091
05092 /* init proc entry */
05093 #if defined(CONFIG_RSBAC_PROC) && defined(CONFIG_PROC_FS)
05094 {
05095 struct proc_dir_entry * tmp_entry_p;
05096
05097 tmp_entry_p = create_proc_entry(RSBAC_LIST_PROC_NAME,
05098 S_IFREG | S_IRUGO,
05099 proc_rsbac_root_p);
05100 if(tmp_entry_p)
05101 {
05102 tmp_entry_p->get_info = lists_proc_info;
05103 }
05104 #if defined(CONFIG_RSBAC_LIST_REPL)
05105 tmp_entry_p = create_proc_entry(RSBAC_LIST_REPL_PROC_NAME,
05106 S_IFREG | S_IRUGO,
05107 proc_rsbac_root_p);
05108 if(tmp_entry_p)
05109 {
05110 tmp_entry_p->get_info = repl_lists_proc_info;
05111 }
05112 #endif
05113 }
05114 #endif
05115
05116 #ifdef CONFIG_RSBAC_LIST_TRANS
05117 rsbac_printk(KERN_INFO
05118 "rsbac_list_init(): Registering transaction list.\n");
05119 list_info_p = kmalloc(sizeof(*list_info_p), GFP_KERNEL);
05120 if(!list_info_p)
05121 {
05122 return -ENOMEM;
05123 }
05124 list_info_p->version = 1;
05125 list_info_p->key = RSBAC_LIST_TA_KEY;
05126 list_info_p->desc_size = sizeof(rsbac_list_ta_number_t);
05127 list_info_p->data_size = sizeof(struct rsbac_list_ta_data_t);
05128 list_info_p->max_age = 0;
05129 err = rsbac_list_register(RSBAC_LIST_VERSION,
05130 (void **) &ta_handle,
05131 list_info_p,
05132 0,
05133 rsbac_list_compare_u32,
05134 NULL,
05135 NULL,
05136 "transactions",
05137 RSBAC_AUTO_DEV);
05138 if(err)
05139 {
05140 char * tmp = kmalloc(RSBAC_MAXNAMELEN, GFP_KERNEL);
05141
05142 if(tmp)
05143 {
05144 rsbac_printk(KERN_WARNING
05145 "rsbac_list_init(): Registering transaction list failed with error %s\n",
05146 get_error_name(tmp, err));
05147 kfree(tmp);
05148 }
05149 }
05150 kfree(list_info_p);
05151 #endif
05152
05153 #ifdef CONFIG_RSBAC_LIST_REPL
05154 rsbac_printk(KERN_INFO
05155 "rsbac_list_init(): Registering replication partner list.\n");
05156 list_info_p = kmalloc(sizeof(*list_info_p), GFP_KERNEL);
05157 if(!list_info_p)
05158 {
05159 return -ENOMEM;
05160 }
05161 list_info_p->version = RSBAC_LIST_REPL_PARTNER_VERSION;
05162 list_info_p->key = RSBAC_LIST_REPL_PARTNER_KEY;
05163 list_info_p->desc_size = sizeof(rsbac_list_repl_partner_number_t);
05164 list_info_p->data_size = sizeof(struct rsbac_list_repl_partner_entry_t);
05165 list_info_p->max_age = 0;
05166 err = rsbac_list_register(RSBAC_LIST_VERSION,
05167 (void **) &repl_partner_handle,
05168 list_info_p,
05169 RSBAC_LIST_PERSIST,
05170 NULL,
05171 NULL,
05172 NULL,
05173 RSBAC_LIST_REPL_PARTNER_FILENAME,
05174 RSBAC_AUTO_DEV);
05175 if(err)
05176 {
05177 char * tmp = kmalloc(RSBAC_MAXNAMELEN, GFP_KERNEL);
05178
05179 if(tmp)
05180 {
05181 rsbac_printk(KERN_WARNING
05182 "rsbac_list_init(): Registering replication partner list failed with error %s\n",
05183 get_error_name(tmp, err));
05184 kfree(tmp);
05185 }
05186 }
05187 kfree(list_info_p);
05188 #endif
05189
05190 return 0;
05191 }
|
|
||||||||||||||||
|
Definition at line 7484 of file gen_lists.c. References RSBAC_LIST_TTL_KEEP, and rsbac_ta_list_lol_add_ttl(). Referenced by rsbac_init_acl(), rsbac_init_rc(), rsbac_pm_pp_intersec(), and rsbac_pm_pp_union(). 07488 {
07489 return rsbac_ta_list_lol_add_ttl(0, handle, RSBAC_LIST_TTL_KEEP, desc, data);
07490 }
|
|
||||||||||||||||||||
|
Definition at line 7472 of file gen_lists.c. References rsbac_ta_list_lol_add_ttl(). 07477 {
07478 return rsbac_ta_list_lol_add_ttl(0, handle, ttl, desc, data);
07479 }
|
|
|
Definition at line 9444 of file gen_lists.c. References rsbac_ta_list_lol_all_subcount(). Referenced by rsbac_stats_acl(), rsbac_stats_auth(), rsbac_stats_mac(), rsbac_stats_pm(), and rsbac_stats_um(). 09445 {
09446 return rsbac_ta_list_lol_all_subcount(0, handle);
09447 }
|
|
||||||||||||
|
Definition at line 5730 of file gen_lists.c. References rsbac_list_lol_item_t::count, rsbac_list_lol_reg_item_t::count, rsbac_list_lol_info_t::data_size, rsbac_list_lol_reg_item_t::def_data, rsbac_list_lol_reg_item_t::def_subdata, rsbac_list_lol_info_t::desc_size, rsbac_list_lol_reg_item_t::device, do_remove_lol_item(), do_remove_lol_subitem(), rsbac_list_lol_reg_item_t::flags, rsbac_list_lol_reg_item_t::head, rsbac_list_lol_reg_item_t::info, list_initialized, rsbac_list_lol_reg_head_t::lock, rsbac_list_lol_reg_item_t::lock, rsbac_list_lol_item_t::max_age, rsbac_list_item_t::max_age, rsbac_list_lol_reg_item_t::name, rsbac_list_lol_item_t::next, rsbac_list_item_t::next, RSBAC_EINVALIDVALUE, RSBAC_ENOTINITIALIZED, RSBAC_LIST_DEF_DATA, rsbac_printk(), rsbac_list_lol_reg_item_t::self, rsbac_list_lol_info_t::subdata_size, and rsbac_list_lol_info_t::subdesc_size. 05733 {
05734 struct rsbac_list_lol_reg_item_t * lol_list;
05735 struct rsbac_list_lol_item_t * lol_item_p;
05736 struct rsbac_list_lol_item_t * next_lol_item_p;
05737 struct rsbac_list_item_t * lol_subitem_p;
05738 struct rsbac_list_item_t * next_lol_subitem_p;
05739 u_long lock_flags;
05740 u_long rlock_flags;
05741 u_long tmp_count;
05742 u_long tmp_subcount;
05743
05744 if(!handle)
05745 return -RSBAC_EINVALIDVALUE;
05746 if(!list_initialized)
05747 return -RSBAC_ENOTINITIALIZED;
05748
05749 lol_list = (struct rsbac_list_lol_reg_item_t *) handle;
05750 if(!lol_list || (lol_list->self != lol_list))
05751 return -RSBAC_EINVALIDVALUE;
05752
05753 rsbac_read_lock(&lol_reg_head.lock, &rlock_flags);
05754 #ifdef CONFIG_RSBAC_DEBUG
05755 if(rsbac_debug_lists)
05756 rsbac_printk(KERN_DEBUG "rsbac_list_lol_check: checking list %s.\n",
05757 lol_list->name);
05758 #endif
05759 rsbac_write_lock(&lol_list->lock, &lock_flags);
05760 tmp_count = 0;
05761 lol_item_p = lol_list->head;
05762 while(lol_item_p)
05763 {
05764 if( ( lol_item_p->max_age
05765 && (lol_item_p->max_age <= RSBAC_CURRENT_TIME)
05766 )
05767 || ( lol_list->def_data
05768 && !lol_item_p->count
05769 && !memcmp(((char *) lol_item_p) + sizeof(*lol_item_p) + lol_list->info.desc_size,
05770 lol_list->def_data,
05771 lol_list->info.data_size)
05772 )
05773 || ( !lol_list->info.data_size
05774 && (lol_list->flags & RSBAC_LIST_DEF_DATA)
05775 && !lol_item_p->count
05776 )
05777 )
05778 {
05779 next_lol_item_p = lol_item_p->next;
05780 do_remove_lol_item(lol_list, lol_item_p);
05781 lol_item_p = next_lol_item_p;
05782 }
05783 else
05784 {
05785 tmp_count++;
05786 tmp_subcount = 0;
05787 lol_subitem_p = lol_item_p->head;
05788 while(lol_subitem_p)
05789 {
05790 if( ( lol_subitem_p->max_age
05791 && (lol_subitem_p->max_age <= RSBAC_CURRENT_TIME)
05792 )
05793 || ( lol_list->def_subdata
05794 && !memcmp(((char *) lol_subitem_p) + sizeof(*lol_subitem_p) + lol_list->info.subdesc_size,
05795 lol_list->def_subdata,
05796 lol_list->info.subdata_size)
05797 )
05798 )
05799 {
05800 next_lol_subitem_p = lol_subitem_p->next;
05801 do_remove_lol_subitem(lol_item_p, lol_subitem_p);
05802 lol_subitem_p = next_lol_subitem_p;
05803 }
05804 else
05805 {
05806 tmp_subcount++;
05807 lol_subitem_p = lol_subitem_p->next;
05808 }
05809 }
05810 if(tmp_subcount != lol_item_p->count)
05811 {
05812 if(correct)
05813 {
05814 rsbac_printk(KERN_WARNING
05815 "rsbac_list_lol_check(): correcting count mismatch for list of lists %s sublist on %02u:%02u - was %lu, counted %lu!\n",
05816 lol_list->name, RSBAC_MAJOR(lol_list->device), RSBAC_MINOR(lol_list->device), lol_item_p->count, tmp_subcount);
05817 lol_item_p->count = tmp_subcount;
05818 }
05819 else
05820 {
05821 rsbac_printk(KERN_WARNING
05822 "rsbac_list_lol_check(): count mismatch for list of lists %s sublist on %02u:%02u - is %lu, counted %lu!\n",
05823 lol_list->name, RSBAC_MAJOR(lol_list->device), RSBAC_MINOR(lol_list->device), lol_item_p->count, tmp_subcount);
05824 }
05825 }
05826 lol_item_p = lol_item_p->next;
05827 }
05828 }
05829 if(tmp_count != lol_list->count)
05830 {
05831 if(correct)
05832 {
05833 rsbac_printk(KERN_WARNING
05834 "rsbac_list_lol_check(): correcting count mismatch for list of lists %s on %02u:%02u - was %u, counted %lu!\n",
05835 lol_list->name, RSBAC_MAJOR(lol_list->device), RSBAC_MINOR(lol_list->device), lol_list->count, tmp_count);
05836 lol_list->count = tmp_count;
05837 }
05838 else
05839 {
05840 rsbac_printk(KERN_WARNING
05841 "rsbac_list_lol_check(): count mismatch for list of lists %s on %02u:%02u - is %u, counted %lu!\n",
05842 lol_list->name, RSBAC_MAJOR(lol_list->device), RSBAC_MINOR(lol_list->device), lol_list->count, tmp_count);
05843 }
05844 }
05845 rsbac_write_unlock(&lol_list->lock, &lock_flags);
05846 rsbac_read_unlock(&lol_reg_head.lock, &rlock_flags);
05847 return 0;
05848 }
|
|
|
Definition at line 9493 of file gen_lists.c. References rsbac_ta_list_lol_count(). Referenced by rsbac_check_acl(), rsbac_init_acl(), rsbac_stats_acl(), rsbac_stats_auth(), rsbac_stats_mac(), rsbac_stats_pm(), and rsbac_stats_um(). 09494 {
09495 return rsbac_ta_list_lol_count(0, handle);
09496 }
|
|
||||||||||||
|
Definition at line 6359 of file gen_lists.c. References rsbac_list_lol_reg_item_t::flags, rsbac_list_lol_reg_item_t::info, rsbac_list_lol_info_t::key, list_initialized, rsbac_list_lol_reg_head_t::lock, lookup_lol_reg(), rsbac_list_lol_reg_item_t::name, NULL, proc_rsbac_backup_p, remove_lol_reg(), RSBAC_EINVALIDPOINTER, RSBAC_EINVALIDVALUE, RSBAC_ENOTINITIALIZED, RSBAC_LIST_BACKUP, RSBAC_LIST_PERSIST, and rsbac_printk(). 06360 {
06361 struct rsbac_list_lol_reg_item_t * reg_item_p;
06362 u_long lock_flags;
06363 int err = 0;
06364
06365 if(!handle_p)
06366 return -RSBAC_EINVALIDPOINTER;
06367 if(!*handle_p)
06368 return -RSBAC_EINVALIDVALUE;
06369 if(!list_initialized)
06370 return -RSBAC_ENOTINITIALIZED;
06371
06372 rsbac_write_lock(&lol_reg_head.lock, &lock_flags);
06373 reg_item_p = lookup_lol_reg((struct rsbac_list_lol_reg_item_t *) *handle_p);
06374 if(!reg_item_p)
06375 {
06376 rsbac_write_unlock(&lol_reg_head.lock, &lock_flags);
06377 rsbac_printk(KERN_WARNING "rsbac_list_lol_destroy: destroying list failed due to invalid handle!\n");
06378 return -RSBAC_EINVALIDVALUE;
06379 }
06380 if(reg_item_p->info.key != key)
06381 {
06382 rsbac_write_unlock(&lol_reg_head.lock, &lock_flags);
06383 rsbac_printk(KERN_WARNING "rsbac_list_lol_destroy: destroying list %s denied due to invalid key %u!\n",
06384 reg_item_p->name,
06385 key);
06386 return -EPERM;
06387 }
06388 #ifdef CONFIG_RSBAC_DEBUG
06389 if(rsbac_debug_lists)
06390 {
06391 rsbac_printk(KERN_DEBUG "rsbac_list_lol_destroy: destroying list %s.\n",
06392 reg_item_p->name);
06393 }
06394 #endif
06395 #if defined(CONFIG_RSBAC_PROC) && defined(CONFIG_PROC_FS)
06396 /* delete proc entry, if it exists */
06397 if( (reg_item_p->flags & RSBAC_LIST_BACKUP)
06398 && reg_item_p->proc_entry_p
06399 )
06400 {
06401 remove_proc_entry(reg_item_p->name, proc_rsbac_backup_p);
06402 reg_item_p->proc_entry_p = NULL;
06403 }
06404 #endif
06405 #if 0
06406 if(reg_item_p->flags & RSBAC_LIST_PERSIST)
06407 err = unlink_lol_list(reg_item_p);
06408 #endif
06409
06410 remove_lol_reg(reg_item_p);
06411 *handle_p = NULL;
06412 rsbac_write_unlock(&lol_reg_head.lock, &lock_flags);
06413 return err;
06414 }
|
|
||||||||||||
|
Definition at line 6509 of file gen_lists.c. References rsbac_list_lol_write_item_t::buflen, rsbac_list_lol_write_head_t::count, rsbac_list_lol_reg_item_t::dirty, FALSE, fill_lol_buffer(), rsbac_list_lol_reg_item_t::flags, rsbac_list_lol_write_head_t::head, rsbac_list_lol_reg_item_t::info, rsbac_list_lol_info_t::key, list_initialized, rsbac_list_lol_reg_head_t::lock, lookup_lol_reg(), rsbac_list_lol_reg_item_t::name, rsbac_list_lol_reg_item_t::no_write, NULL, proc_rsbac_backup_p, remove_lol_reg(), RSBAC_EINVALIDPOINTER, RSBAC_EINVALIDVALUE, RSBAC_ENOTINITIALIZED, RSBAC_ENOTWRITABLE, RSBAC_LIST_BACKUP, RSBAC_LIST_PERSIST, rsbac_list_write_lol_buffers(), rsbac_printk(), rsbac_list_lol_write_head_t::tail, rsbac_list_lol_write_head_t::total, and TRUE. Referenced by acl_detach_fd_lists(), auth_detach_fd_lists(), and mac_detach_fd_lists(). 06510 {
06511 struct rsbac_list_lol_reg_item_t * reg_item_p;
06512 u_long lock_flags;
06513 int err = 0;
06514
06515 if(!handle_p)
06516 return -RSBAC_EINVALIDPOINTER;
06517 if(!*handle_p)
06518 return -RSBAC_EINVALIDVALUE;
06519 if(!list_initialized)
06520 return -RSBAC_ENOTINITIALIZED;
06521
06522 rsbac_read_lock(&lol_reg_head.lock, &lock_flags);
06523 reg_item_p = lookup_lol_reg((struct rsbac_list_lol_reg_item_t *) *handle_p);
06524 if(!reg_item_p)
06525 {
06526 rsbac_read_unlock(&lol_reg_head.lock, &lock_flags);
06527 rsbac_printk(KERN_WARNING "rsbac_list_lol_detach: detaching list failed due to invalid handle!\n");
06528 return -RSBAC_EINVALIDVALUE;
06529 }
06530 if(reg_item_p->info.key != key)
06531 {
06532 rsbac_read_unlock(&lol_reg_head.lock, &lock_flags);
06533 rsbac_printk(KERN_WARNING "rsbac_list_lol_detach: detaching list %s denied due to invalid key %u!\n",
06534 reg_item_p->name,
06535 key);
06536 return -EPERM;
06537 }
06538 #if defined(CONFIG_RSBAC_PROC) && defined(CONFIG_PROC_FS)
06539 /* delete proc entry, if it exists */
06540 if( (reg_item_p->flags & RSBAC_LIST_BACKUP)
06541 && reg_item_p->proc_entry_p
06542 )
06543 {
06544 remove_proc_entry(reg_item_p->name, proc_rsbac_backup_p);
06545 reg_item_p->proc_entry_p = NULL;
06546 }
06547 #endif
06548 #ifndef CONFIG_RSBAC_NO_WRITE
06549 /* final write, if dirty etc. */
06550 if( (reg_item_p->flags & RSBAC_LIST_PERSIST)
06551 && reg_item_p->dirty
06552 && !reg_item_p->no_write
06553 )
06554 {
06555 struct rsbac_list_lol_write_head_t write_head;
06556 struct rsbac_list_lol_write_item_t * write_item_p;
06557
06558 reg_item_p->dirty = FALSE;
06559 err = fill_lol_buffer(reg_item_p, &write_item_p);
06560 if(!err)
06561 {
06562 write_head.head = write_item_p;
06563 write_head.tail = write_item_p;
06564 write_head.total = write_item_p->buflen;
06565 write_head.count = 1;
06566 rsbac_read_unlock(&lol_reg_head.lock, &lock_flags);
06567 rsbac_list_write_lol_buffers(write_head, TRUE);
06568 }
06569 else
06570 {
06571 rsbac_read_unlock(&lol_reg_head.lock, &lock_flags);
06572 if(err != -RSBAC_ENOTWRITABLE)
06573 {
06574 rsbac_printk(KERN_WARNING
06575 "rsbac_list_lol_detach(): fill_buffer() for list %s returned error %i\n",
06576 reg_item_p->name, err);
06577 }
06578 }
06579 }
06580 else
06581 rsbac_read_unlock(&lol_reg_head.lock, &lock_flags);
06582 #else
06583 rsbac_read_unlock(&lol_reg_head.lock, &lock_flags);
06584 #endif
06585 /* disable handle */
06586 *handle_p = NULL;
06587 /* too bad that the list might have been changed again - we do not care anymore */
06588 rsbac_write_lock(&lol_reg_head.lock, &lock_flags);
06589 remove_lol_reg(reg_item_p);
06590 rsbac_write_unlock(&lol_reg_head.lock, &lock_flags);
06591 return err;
06592 }
|
|
||||||||||||
|
Definition at line 9308 of file gen_lists.c. References rsbac_ta_list_lol_exist(). Referenced by rsbac_pm_pp_intersec(), rsbac_pm_pp_subset(), rsbac_pm_pp_superset(), and rsbac_pm_pp_union(). 09311 {
09312 return rsbac_ta_list_lol_exist(0, handle, desc);
09313 }
|
|
||||||||||||
|
Definition at line 10277 of file gen_lists.c. References rsbac_ta_list_lol_get_all_data(). 10280 {
10281 return rsbac_ta_list_lol_get_all_data(0, handle, array_p);
10282 }
|
|
||||||||||||
|
Definition at line 9907 of file gen_lists.c. References rsbac_ta_list_lol_get_all_desc(). Referenced by rsbac_check_acl(), and rsbac_init_rc(). 09908 {
09909 return rsbac_ta_list_lol_get_all_desc(0, handle, array_p);
09910 }
|
|
||||||||||||
|
Definition at line 10737 of file gen_lists.c. References rsbac_ta_list_lol_get_all_items(). 10740 {
10741 return rsbac_ta_list_lol_get_all_items(0, handle, array_p);
10742 }
|
|
||||||||||||||||
|
Definition at line 10145 of file gen_lists.c. References rsbac_ta_list_lol_get_all_subdata(). 10149 {
10150 return rsbac_ta_list_lol_get_all_subdata(0, handle, desc, array_p);
10151 }
|
|
||||||||||||||||
|
Definition at line 9786 of file gen_lists.c. References NULL, and rsbac_ta_list_lol_get_all_subdesc_ttl(). Referenced by rsbac_check_acl(), rsbac_pm_pp_intersec(), rsbac_pm_pp_subset(), rsbac_pm_pp_superset(), and rsbac_pm_pp_union(). 09787 {
09788 return rsbac_ta_list_lol_get_all_subdesc_ttl(0, handle,
09789 desc, array_p, NULL);
09790 }
|
|
||||||||||||||||||||
|
Definition at line 9770 of file gen_lists.c. References rsbac_ta_list_lol_get_all_subdesc_ttl(). Referenced by copy_fp_cap_set_item(), copy_fp_tru_set_item(), copy_pp_cap_set_item_handle(), and copy_pp_tru_set_item_handle(). 09775 {
09776 return rsbac_ta_list_lol_get_all_subdesc_ttl(0,
09777 handle,
09778 desc,
09779 array_p,
09780 ttl_array_p);
09781 }
|
|
||||||||||||||||
|
Definition at line 10616 of file gen_lists.c. References NULL, and rsbac_ta_list_lol_get_all_subitems_ttl(). 10617 {
10618 return rsbac_ta_list_lol_get_all_subitems_ttl(0, handle, desc,
10619 array_p, NULL);
10620 }
|
|
||||||||||||||||||||
|
Definition at line 10603 of file gen_lists.c. References rsbac_ta_list_lol_get_all_subitems_ttl(). 10608 {
10609 return rsbac_ta_list_lol_get_all_subitems_ttl(0, handle, desc,
10610 array_p, ttl_array_p);
10611 }
|
|
||||||||||||||||
|
Definition at line 8573 of file gen_lists.c. References NULL, and rsbac_ta_list_lol_get_data_ttl(). 08576 {
08577 return rsbac_ta_list_lol_get_data_ttl(0, handle, NULL, desc, data);
08578 }
|
|
||||||||||||||||||||
|
Definition at line 8562 of file gen_lists.c. References rsbac_ta_list_lol_get_data_ttl(). 08566 {
08567 return rsbac_ta_list_lol_get_data_ttl(0, handle, ttl_p, desc, data);
08568 }
|
|
||||||||||||||||||||
|
Definition at line 8984 of file gen_lists.c. References rsbac_ta_list_lol_get_desc(). 08989 {
08990 return rsbac_ta_list_lol_get_desc(0, handle, desc, data, compare);
08991 }
|
|
|
Definition at line 10325 of file gen_lists.c. References rsbac_list_lol_info_t::data_size, rsbac_list_lol_info_t::desc_size, rsbac_list_lol_reg_item_t::info, list_initialized, RSBAC_EINVALIDVALUE, RSBAC_ENOTINITIALIZED, and rsbac_list_lol_reg_item_t::self. 10326 {
10327 struct rsbac_list_lol_reg_item_t * list;
10328
10329 if(!handle)
10330 return -RSBAC_EINVALIDVALUE;
10331 if(!list_initialized)
10332 return -RSBAC_ENOTINITIALIZED;
10333
10334 list = (struct rsbac_list_lol_reg_item_t *) handle;
10335 if(list->self != list)
10336 return -RSBAC_EINVALIDVALUE;
10337 return list->info.desc_size + list->info.data_size;
10338 }
|
|
||||||||||||||||
|
Definition at line 8815 of file gen_lists.c. References rsbac_ta_list_lol_get_next_desc(). 08819 {
08820 return rsbac_ta_list_lol_get_next_desc(0, handle, old_desc, next_desc);
08821 }
|
|
||||||||||||||||||||
|
Definition at line 8457 of file gen_lists.c. References NULL, and rsbac_ta_list_lol_get_subdata_ttl(). Referenced by rsbac_rc_check_comp(). 08462 {
08463 return rsbac_ta_list_lol_get_subdata_ttl(0, handle, NULL, desc, subdesc, subdata);
08464 }
|
|
||||||||||||||||||||||||
|
Definition at line 8443 of file gen_lists.c. References rsbac_ta_list_lol_get_subdata_ttl(). 08449 {
08450 return rsbac_ta_list_lol_get_subdata_ttl(0, handle,
08451 ttl_p, desc, subdesc, subdata);
08452 }
|
|
|
Definition at line 10307 of file gen_lists.c. References rsbac_list_lol_reg_item_t::info, list_initialized, RSBAC_EINVALIDVALUE, RSBAC_ENOTINITIALIZED, rsbac_list_lol_reg_item_t::self, rsbac_list_lol_info_t::subdata_size, and rsbac_list_lol_info_t::subdesc_size. Referenced by rsbac_rc_copy_role(). 10308 {
10309 struct rsbac_list_lol_reg_item_t * list;
10310
10311 if(!handle)
10312 return -RSBAC_EINVALIDVALUE;
10313 if(!list_initialized)
10314 return -RSBAC_ENOTINITIALIZED;
10315
10316 list = (struct rsbac_list_lol_reg_item_t *) handle;
10317 if(list->self != list)
10318 return -RSBAC_EINVALIDVALUE;
10319 return list->info.subdesc_size + list->info.subdata_size;
10320 }
|
|
||||||||||||||||
|
Definition at line 6637 of file gen_lists.c. References FALSE, rsbac_list_lol_reg_item_t::info, rsbac_list_lol_info_t::key, list_initialized, rsbac_list_lol_reg_head_t::lock, lookup_lol_reg(), rsbac_list_lol_reg_item_t::name, rsbac_list_lol_reg_item_t::no_write, RSBAC_EINVALIDVALUE, RSBAC_ENOTINITIALIZED, rsbac_printk(), and TRUE. 06638 {
06639 struct rsbac_list_lol_reg_item_t * reg_item_p;
06640 u_long lock_flags;
06641
06642 if( !handle
06643 || ( (no_write != FALSE )
06644 && (no_write != TRUE )
06645 )
06646 )
06647 return -RSBAC_EINVALIDVALUE;
06648 if(!list_initialized)
06649 return -RSBAC_ENOTINITIALIZED;
06650
06651 rsbac_read_lock(&lol_reg_head.lock, &lock_flags);
06652 reg_item_p = lookup_lol_reg((struct rsbac_list_lol_reg_item_t *) handle);
06653 if(!reg_item_p)
06654 {
06655 rsbac_read_unlock(&lol_reg_head.lock, &lock_flags);
06656 rsbac_printk(KERN_WARNING "rsbac_list_lol_no_write: setting no_write for list denied due to invalid handle!\n");
06657 return -RSBAC_EINVALIDVALUE;
06658 }
06659 if(reg_item_p->info.key != key)
06660 {
06661 rsbac_read_unlock(&lol_reg_head.lock, &lock_flags);
06662 rsbac_printk(KERN_WARNING "rsbac_list_lol_no_write: setting no_write for list %s denied due to invalid key %u!\n",
06663 reg_item_p->name,
06664 key);
06665 return -EPERM;
06666 }
06667 reg_item_p->no_write = no_write;
06668 rsbac_read_unlock(&lol_reg_head.lock, &lock_flags);
06669 return 0;
06670 }
|
|
||||||||||||||||||||||||||||||||||||||||||||||||||||
|
Definition at line 6110 of file gen_lists.c. References add_lol_reg(), clear_lol_reg(), create_lol_reg(), rsbac_list_lol_info_t::data_size, rsbac_list_lol_info_t::desc_size, get_error_name(), rsbac_list_lol_info_t::key, list_initialized, rsbac_list_lol_reg_head_t::lock, rsbac_list_reg_head_t::lock, lookup_lol_reg_name(), lookup_reg_name(), rsbac_list_lol_info_t::max_age, rsbac_list_lol_reg_item_t::name, NULL, proc_rsbac_backup_p, read_lol_list(), RSBAC_ECOULDNOTADDITEM, RSBAC_EEXISTS, RSBAC_EINVALIDPOINTER, RSBAC_EINVALIDVALUE, RSBAC_EINVALIDVERSION, RSBAC_ENOTFOUND, RSBAC_ENOTINITIALIZED, rsbac_kfree(), rsbac_kmalloc(), RSBAC_LIST_BACKUP, RSBAC_LIST_MAX_AGE_LIMIT, RSBAC_LIST_MAX_ITEM_SIZE, RSBAC_LIST_PERSIST, RSBAC_LIST_VERSION, RSBAC_MAXNAMELEN, rsbac_printk(), rsbac_root_dev, rsbac_list_lol_info_t::subdata_size, rsbac_list_lol_info_t::subdesc_size, and rsbac_list_lol_info_t::version. Referenced by acl_register_fd_lists(), auth_register_fd_lists(), mac_register_fd_lists(), rsbac_init_acl(), rsbac_init_auth(), rsbac_init_mac(), rsbac_init_pm(), rsbac_init_rc(), and rsbac_init_um(). 06123 {
06124 struct rsbac_list_lol_reg_item_t * reg_item_p;
06125 struct rsbac_list_lol_reg_item_t * new_reg_item_p;
06126 u_long lock_flags;
06127 int err = 0;
06128
06129 if(ds_version != RSBAC_LIST_VERSION)
06130 return -RSBAC_EINVALIDVERSION;
06131 if(!handle_p)
06132 return -RSBAC_EINVALIDPOINTER;
06133 *handle_p = NULL;
06134 if(!info_p->key || !info_p->version || !info_p->desc_size)
06135 return -RSBAC_EINVALIDVALUE;
06136 if(info_p->max_age > RSBAC_LIST_MAX_AGE_LIMIT)
06137 return -RSBAC_EINVALIDVALUE;
06138 if(info_p->desc_size + info_p->data_size > RSBAC_LIST_MAX_ITEM_SIZE)
06139 return -RSBAC_EINVALIDVALUE;
06140 if(info_p->subdesc_size + info_p->subdata_size > RSBAC_LIST_MAX_ITEM_SIZE)
06141 return -RSBAC_EINVALIDVALUE;
06142 if(!list_initialized)
06143 return -RSBAC_ENOTINITIALIZED;
06144 if(name)
06145 {
06146 struct rsbac_list_reg_item_t * std_reg_item_p;
06147
06148 rsbac_read_lock(&lol_reg_head.lock, &lock_flags);
06149 reg_item_p = lookup_lol_reg_name(name, device);
06150 rsbac_read_unlock(&lol_reg_head.lock, &lock_flags);
06151 if(reg_item_p)
06152 {
06153 #ifdef CONFIG_RSBAC_DEBUG
06154 if(rsbac_debug_lists)
06155 {
06156 rsbac_printk(KERN_DEBUG "rsbac_list_lol_register: list name %s already exists on device %02u:%02u!\n",
06157 name, RSBAC_MAJOR(device), RSBAC_MINOR(device));
06158 }
06159 #endif
06160 return -RSBAC_EEXISTS;
06161 }
06162 rsbac_read_lock(®_head.lock, &lock_flags);
06163 std_reg_item_p = lookup_reg_name(name, device);
06164 rsbac_read_unlock(®_head.lock, &lock_flags);
06165 if(std_reg_item_p)
06166 {
06167 #ifdef CONFIG_RSBAC_DEBUG
06168 if(rsbac_debug_lists)
06169 {
06170 rsbac_printk(KERN_DEBUG "rsbac_list_register: list name %s already exists on device %02u:%02u!\n",
06171 name, RSBAC_MAJOR(device), RSBAC_MINOR(device));
06172 }
06173 #endif
06174 return -RSBAC_EEXISTS;
06175 }
06176 }
06177 else
06178 if(flags & RSBAC_LIST_PERSIST)
06179 {
06180 rsbac_printk(KERN_WARNING
06181 "rsbac_list_lol_register: trial to register persistent list of lists without name.\n");
06182 return -RSBAC_EINVALIDVALUE;
06183 }
06184
06185 if(flags & RSBAC_LIST_PERSIST)
06186 {
06187 if(RSBAC_IS_AUTO_DEV(device))
06188 device = rsbac_root_dev;
06189 if(!RSBAC_MAJOR(device))
06190 flags &= ~RSBAC_LIST_PERSIST;
06191 }
06192
06193 #ifdef CONFIG_RSBAC_DEBUG
06194 if(rsbac_debug_lists)
06195 {
06196 rsbac_printk(KERN_DEBUG "rsbac_list_lol_register: registering list of lists %s.\n",
06197 name);
06198 }
06199 #endif
06200 new_reg_item_p = create_lol_reg(info_p, flags, compare, subcompare,
06201 get_conv, get_subconv,
06202 def_data, def_subdata,
06203 name, device);
06204 if(!new_reg_item_p)
06205 {
06206 return -RSBAC_ECOULDNOTADDITEM;
06207 }
06208 /* Restore from disk */
06209 if(flags & RSBAC_LIST_PERSIST)
06210 {
06211 #ifdef CONFIG_RSBAC_DEBUG
06212 if(rsbac_debug_lists)
06213 {
06214 rsbac_printk(KERN_DEBUG "rsbac_list_lol_register: restoring list %s from device %02u:%02u.\n",
06215 name, RSBAC_MAJOR(device), RSBAC_MINOR(device));
06216 }
06217 #endif
06218 err = read_lol_list(new_reg_item_p);
06219 /* not found is no error */
06220 if(err == -RSBAC_ENOTFOUND)
06221 err = 0;
06222 else
06223 if(err)
06224 {
06225 #ifdef CONFIG_RSBAC_DEBUG
06226 if(rsbac_debug_lists)
06227 {
06228 char * tmp = rsbac_kmalloc(RSBAC_MAXNAMELEN);
06229
06230 if(tmp)
06231 {
06232 get_error_name(tmp, err);
06233 rsbac_printk(KERN_DEBUG "rsbac_list_lol_register: restoring list %s from device %02u:%02u failed with error %s, unregistering list.\n",
06234 name,
06235 RSBAC_MAJOR(device),RSBAC_MINOR(device),
06236 tmp);
06237 rsbac_kfree(tmp);
06238 }
06239 }
06240 #endif
06241 clear_lol_reg(new_reg_item_p);
06242 return err;
06243 }
06244 #ifdef CONFIG_RSBAC_DEBUG
06245 else
06246 {
06247 if(rsbac_debug_lists)
06248 {
06249 rsbac_printk(KERN_DEBUG "rsbac_list_lol_register: restoring list %s from device %02u:%02u was successful.\n",
06250 name,
06251 RSBAC_MAJOR(device),RSBAC_MINOR(device));
06252 }
06253 }
06254 #endif
06255 }
06256
06257 rsbac_write_lock(&lol_reg_head.lock, &lock_flags);
06258 reg_item_p = add_lol_reg(new_reg_item_p);
06259 rsbac_write_unlock(&lol_reg_head.lock, &lock_flags);
06260 if(!reg_item_p)
06261 {
06262 rsbac_printk(KERN_WARNING
06263 "rsbac_list_lol_register: inserting list %s failed!\n",
06264 name);
06265 /* cleanup */
06266 clear_lol_reg(new_reg_item_p);
06267 return -RSBAC_ECOULDNOTADDITEM;
06268 }
06269
06270 /* finish */
06271 #if defined(CONFIG_RSBAC_PROC) && defined(CONFIG_PROC_FS)
06272 /* create proc entry, if requested */
06273 if(flags & RSBAC_LIST_BACKUP)
06274 {
06275 reg_item_p->proc_entry_p = create_proc_entry(reg_item_p->name,
06276 S_IFREG | S_IRUGO,
06277 proc_rsbac_backup_p);
06278 if(reg_item_p->proc_entry_p)
06279 {
06280 reg_item_p->proc_entry_p->read_proc = lol_backup_proc_read;
06281 reg_item_p->proc_entry_p->data = reg_item_p;
06282 }
06283 }
06284 else
06285 {
06286 reg_item_p->proc_entry_p = NULL;
06287 }
06288 #endif
06289 *handle_p = reg_item_p;
06290 return err;
06291 }
|
|
||||||||||||
|
Definition at line 8112 of file gen_lists.c. References rsbac_ta_list_lol_remove(). Referenced by copy_fp_cap_set_item(), copy_fp_tru_set_item(), copy_pp_cap_set_item_handle(), copy_pp_tru_set_item_handle(), and rsbac_check_acl(). 08115 {
08116 return rsbac_ta_list_lol_remove(0, handle, desc);
08117 }
|
|
|
Definition at line 8208 of file gen_lists.c. References rsbac_ta_list_lol_remove_all(). 08209 {
08210 return rsbac_ta_list_lol_remove_all(0, handle);
08211 }
|
|
||||||||||||||||||||
|
Definition at line 7322 of file gen_lists.c. References RSBAC_LIST_TTL_KEEP, and rsbac_ta_list_lol_subadd_ttl(). Referenced by rsbac_auth_p_capset_member(), rsbac_init_acl(), rsbac_init_rc(), rsbac_pm_pp_intersec(), and rsbac_pm_pp_union(). 07327 {
07328 return rsbac_ta_list_lol_subadd_ttl(0, handle, RSBAC_LIST_TTL_KEEP, desc, subdesc, subdata);
07329 }
|
|
||||||||||||||||||||||||
|
Definition at line 7309 of file gen_lists.c. References rsbac_ta_list_lol_subadd_ttl(). Referenced by copy_fp_cap_set_item(), copy_fp_tru_set_item(), copy_pp_cap_set_item_handle(), and copy_pp_tru_set_item_handle(). 07315 {
07316 return rsbac_ta_list_lol_subadd_ttl(0, handle, ttl, desc, subdesc, subdata);
07317 }
|
|
||||||||||||
|
Definition at line 9379 of file gen_lists.c. References rsbac_ta_list_lol_subcount(). Referenced by rsbac_pm_pp_only(). 09382 {
09383 return rsbac_ta_list_lol_subcount(0, handle, desc);
09384 }
|
|
||||||||||||||||
|
Definition at line 9144 of file gen_lists.c. References rsbac_ta_list_lol_subexist(). Referenced by rsbac_init_rc(), rsbac_mac_p_truset_member(), rsbac_pm_pp_intersec(), rsbac_pm_pp_only(), rsbac_pm_pp_subset(), rsbac_pm_pp_superset(), rsbac_rc_check_comp(), and rsbac_ta_list_lol_subexist_compare(). 09148 {
09149 return rsbac_ta_list_lol_subexist(0, handle, desc, subdesc);
09150 }
|
|
||||||||||||||||||||
|
Definition at line 9232 of file gen_lists.c. References rsbac_ta_list_lol_subexist_compare(). Referenced by rsbac_auth_p_capset_member(). 09237 {
09238 return rsbac_ta_list_lol_subexist_compare(0, handle,
09239 desc, subdesc, compare);
09240 }
|
|
||||||||||||||||
|
Definition at line 7813 of file gen_lists.c. References rsbac_ta_list_lol_subremove(). Referenced by rsbac_check_acl(), and rsbac_pm_pp_intersec(). 07817 {
07818 return rsbac_ta_list_lol_subremove(0, handle, desc, subdesc);
07819 }
|
|
||||||||||||
|
Definition at line 8024 of file gen_lists.c. References rsbac_ta_list_lol_subremove_all(). 08025 {
08026 return rsbac_ta_list_lol_subremove_all(0, handle, desc);
08027 }
|
|
||||||||||||
|
Definition at line 7912 of file gen_lists.c. References rsbac_ta_list_lol_subremove_from_all(). 07915 {
07916 return rsbac_ta_list_lol_subremove_from_all(0, handle, subdesc);
07917 }
|
|
|
Definition at line 5193 of file gen_lists.c. Referenced by rsbac_mount(). 05194 {
05195 return 0;
05196 }
|
|
||||||||||||||||
|
Definition at line 6599 of file gen_lists.c. References FALSE, rsbac_list_reg_item_t::info, rsbac_list_info_t::key, list_initialized, rsbac_list_reg_head_t::lock, lookup_reg(), rsbac_list_reg_item_t::name, rsbac_list_reg_item_t::no_write, RSBAC_EINVALIDVALUE, RSBAC_ENOTINITIALIZED, rsbac_printk(), and TRUE. 06600 {
06601 struct rsbac_list_reg_item_t * reg_item_p;
06602 u_long lock_flags;
06603
06604 if( !handle
06605 || ( (no_write != FALSE )
06606 && (no_write != TRUE )
06607 )
06608 )
06609 return -RSBAC_EINVALIDVALUE;
06610 if(!list_initialized)
06611 return -RSBAC_ENOTINITIALIZED;
06612
06613 rsbac_read_lock(®_head.lock, &lock_flags);
06614 reg_item_p = lookup_reg((struct rsbac_list_reg_item_t *) handle);
06615 if(!reg_item_p)
06616 {
06617 rsbac_read_unlock(®_head.lock, &lock_flags);
06618 rsbac_printk(KERN_WARNING "rsbac_list_no_write: setting no_write for list denied due to invalid handle!\n");
06619 return -RSBAC_EINVALIDVALUE;
06620 }
06621 if(reg_item_p->info.key != key)
06622 {
06623 rsbac_read_unlock(®_head.lock, &lock_flags);
06624 rsbac_printk(KERN_WARNING "rsbac_list_no_write: setting no_write for list %s denied due to invalid key %u!\n",
06625 reg_item_p->name,
06626 key);
06627 return -EPERM;
06628 }
06629 reg_item_p->no_write = no_write;
06630 rsbac_read_unlock(®_head.lock, &lock_flags);
06631 return 0;
06632 }
|
|
||||||||||||||||||||||||||||||||||||||||
|
Definition at line 5888 of file gen_lists.c. References add_reg(), clear_reg(), create_reg(), rsbac_list_info_t::data_size, rsbac_list_info_t::desc_size, get_error_name(), rsbac_list_info_t::key, list_initialized, rsbac_list_reg_head_t::lock, rsbac_list_lol_reg_head_t::lock, lookup_lol_reg_name(), lookup_reg_name(), rsbac_list_info_t::max_age, rsbac_list_reg_item_t::name, NULL, proc_rsbac_backup_p, read_list(), RSBAC_ECOULDNOTADDITEM, RSBAC_EEXISTS, RSBAC_EINVALIDPOINTER, RSBAC_EINVALIDVALUE, RSBAC_EINVALIDVERSION, RSBAC_ENOTFOUND, RSBAC_ENOTINITIALIZED, rsbac_kfree(), rsbac_kmalloc(), RSBAC_LIST_BACKUP, RSBAC_LIST_MAX_AGE_LIMIT, RSBAC_LIST_MAX_ITEM_SIZE, RSBAC_LIST_PERSIST, RSBAC_LIST_VERSION, RSBAC_MAXNAMELEN, rsbac_printk(), rsbac_root_dev, and rsbac_list_info_t::version. Referenced by init_module(), register_dev_lists(), register_fd_lists(), register_ipc_lists(), register_process_lists(), register_user_lists(), rsbac_init_acl(), rsbac_init_debug(), rsbac_init_pm(), rsbac_init_rc(), rsbac_init_um(), and rsbac_list_init(). 05898 {
05899 struct rsbac_list_reg_item_t * reg_item_p;
05900 struct rsbac_list_reg_item_t * new_reg_item_p;
05901 u_long lock_flags;
05902 int err = 0;
05903
05904 if(ds_version != RSBAC_LIST_VERSION)
05905 {
05906 if(name)
05907 {
05908 rsbac_printk(KERN_WARNING
05909 "rsbac_list_register: wrong ds_version %u for list %s, expected %u!\n",
05910 ds_version,
05911 name,
05912 RSBAC_LIST_VERSION);
05913 }
05914 return -RSBAC_EINVALIDVERSION;
05915 }
05916 if(!handle_p || !info_p)
05917 return -RSBAC_EINVALIDPOINTER;
05918 *handle_p = NULL;
05919 if(!info_p->key || !info_p->version || !info_p->desc_size)
05920 return -RSBAC_EINVALIDVALUE;
05921 if(info_p->max_age > RSBAC_LIST_MAX_AGE_LIMIT)
05922 return -RSBAC_EINVALIDVALUE;
05923 if(info_p->desc_size + info_p->data_size > RSBAC_LIST_MAX_ITEM_SIZE)
05924 return -RSBAC_EINVALIDVALUE;
05925 if(!list_initialized)
05926 return -RSBAC_ENOTINITIALIZED;
05927 if(name)
05928 {
05929 struct rsbac_list_lol_reg_item_t * lol_reg_item_p;
05930
05931 rsbac_read_lock(®_head.lock, &lock_flags);
05932 reg_item_p = lookup_reg_name(name, device);
05933 rsbac_read_unlock(®_head.lock, &lock_flags);
05934 if(reg_item_p)
05935 {
05936 #ifdef CONFIG_RSBAC_DEBUG
05937 if(rsbac_debug_lists)
05938 {
05939 rsbac_printk(KERN_DEBUG "rsbac_list_register: list name %s already exists on device %02u:%02u!\n",
05940 name, RSBAC_MAJOR(device), RSBAC_MINOR(device));
05941 }
05942 #endif
05943 return -RSBAC_EEXISTS;
05944 }
05945 rsbac_read_lock(&lol_reg_head.lock, &lock_flags);
05946 lol_reg_item_p = lookup_lol_reg_name(name, device);
05947 rsbac_read_unlock(&lol_reg_head.lock, &lock_flags);
05948 if(lol_reg_item_p)
05949 {
05950 #ifdef CONFIG_RSBAC_DEBUG
05951 if(rsbac_debug_lists)
05952 {
05953 rsbac_printk(KERN_DEBUG "rsbac_list_register: list name %s already exists on device %02u:%02u!\n",
05954 name, RSBAC_MAJOR(device), RSBAC_MINOR(device));
05955 }
05956 #endif
05957 return -RSBAC_EEXISTS;
05958 }
05959 }
05960 else
05961 if(flags & RSBAC_LIST_PERSIST)
05962 {
05963 rsbac_printk(KERN_WARNING
05964 "rsbac_list_register: trial to register persistent list without name.\n");
05965 return -RSBAC_EINVALIDVALUE;
05966 }
05967
05968 if(flags & RSBAC_LIST_PERSIST)
05969 {
05970 if(RSBAC_IS_AUTO_DEV(device))
05971 device = rsbac_root_dev;
05972 if(!RSBAC_MAJOR(device))
05973 flags &= ~RSBAC_LIST_PERSIST;
05974 }
05975
05976 #ifdef CONFIG_RSBAC_DEBUG
05977 if(rsbac_debug_lists)
05978 {
05979 rsbac_printk(KERN_DEBUG "rsbac_list_register: registering list %s for device %02u:%02u.\n",
05980 name, RSBAC_MAJOR(device),RSBAC_MINOR(device));
05981 }
05982 #endif
05983 new_reg_item_p = create_reg(info_p, flags, compare, get_conv, def_data, name, device);
05984 if(!new_reg_item_p)
05985 {
05986 return -RSBAC_ECOULDNOTADDITEM;
05987 }
05988 /* Restore from disk, but only for real device mounts */
05989 if( (flags & RSBAC_LIST_PERSIST)
05990 && RSBAC_MAJOR(device)
05991 )
05992 {
05993 #ifdef CONFIG_RSBAC_DEBUG
05994 if(rsbac_debug_lists)
05995 {
05996 rsbac_printk(KERN_DEBUG "rsbac_list_register: restoring list %s from device %02u:%02u.\n",
05997 name, RSBAC_MAJOR(device), RSBAC_MINOR(device));
05998 }
05999 #endif
06000 err = read_list(new_reg_item_p);
06001 /* not found is no error */
06002 if(err == -RSBAC_ENOTFOUND)
06003 err = 0;
06004 else
06005 if(err)
06006 {
06007 #ifdef CONFIG_RSBAC_DEBUG
06008 if(rsbac_debug_lists)
06009 {
06010 char * tmp = rsbac_kmalloc(RSBAC_MAXNAMELEN);
06011
06012 if(tmp)
06013 {
06014 get_error_name(tmp, err);
06015 rsbac_printk(KERN_DEBUG "rsbac_list_register: restoring list %s from device %02u:%02u failed with error %s, unregistering list.\n",
06016 name,
06017 RSBAC_MAJOR(device),RSBAC_MINOR(device),
06018 tmp);
06019 rsbac_kfree(tmp);
06020 }
06021 }
06022 #endif
06023 clear_reg(new_reg_item_p);
06024 return err;
06025 }
06026 #ifdef CONFIG_RSBAC_DEBUG
06027 else
06028 {
06029 if(rsbac_debug_lists)
06030 {
06031 rsbac_printk(KERN_DEBUG "rsbac_list_register: restoring list %s from device %02u:%02u was successful.\n",
06032 name,
06033 RSBAC_MAJOR(device),RSBAC_MINOR(device));
06034 }
06035 }
06036 #endif
06037 }
06038
06039 rsbac_write_lock(®_head.lock, &lock_flags);
06040 reg_item_p = add_reg(new_reg_item_p);
06041 rsbac_write_unlock(®_head.lock, &lock_flags);
06042 if(!reg_item_p)
06043 {
06044 rsbac_printk(KERN_WARNING
06045 "rsbac_list_register: inserting list %s failed!\n",
06046 name);
06047 /* cleanup */
06048 clear_reg(new_reg_item_p);
06049 return -RSBAC_ECOULDNOTADDITEM;
06050 }
06051
06052 /* finish */
06053 #if defined(CONFIG_RSBAC_PROC) && defined(CONFIG_PROC_FS)
06054 /* create proc entry, if requested */
06055 if(flags & RSBAC_LIST_BACKUP)
06056 {
06057 reg_item_p->proc_entry_p = create_proc_entry(reg_item_p->name,
06058 S_IFREG | S_IRUGO,
06059 proc_rsbac_backup_p);
06060 if(reg_item_p->proc_entry_p)
06061 {
06062 reg_item_p->proc_entry_p->read_proc = backup_proc_read;
06063 reg_item_p->proc_entry_p->data = reg_item_p;
06064 }
06065 }
06066 else
06067 {
06068 reg_item_p->proc_entry_p = NULL;
06069 }
06070 #endif
06071 *handle_p = reg_item_p;
06072 return err;
06073 }
|
|
||||||||||||
|
Definition at line 7576 of file gen_lists.c. References rsbac_ta_list_remove(). 07579 {
07580 return rsbac_ta_list_remove(0, handle, desc);
07581 }
|
|
|
Definition at line 7672 of file gen_lists.c. References rsbac_ta_list_remove_all(). 07673 {
07674 return rsbac_ta_list_remove_all(0, handle);
07675 }
|
|
|
Definition at line 5198 of file gen_lists.c. Referenced by rsbac_umount(). 05199 {
05200 return 0;
05201 }
|
|
|
Definition at line 5856 of file gen_lists.c. References RSBAC_LIST_VERSION. 05857 {
05858 return RSBAC_LIST_VERSION;
05859 }
|
|
||||||||||||
|
Definition at line 4021 of file gen_lists.c. References rsbac_list_write_item_t::buf, rsbac_list_write_item_t::buflen, rsbac_list_write_item_t::device, rsbac_list_reg_item_t::dirty, rsbac_list_write_head_t::head, rsbac_list_write_item_t::list, rsbac_list_write_item_t::name, rsbac_list_write_item_t::next, RSBAC_ENOMEM, RSBAC_ENOTWRITABLE, rsbac_kfree(), rsbac_kmalloc(), rsbac_min, rsbac_printk(), rsbac_vkfree(), rsbac_write_close(), rsbac_write_open(), rsbac_list_reg_item_t::self, TRUE, and rsbac_list_write_item_t::vmalloc_used. Referenced by rsbac_list_detach(). 04023 {
04024 struct file * file_p;
04025 int count = 0;
04026 mm_segment_t oldfs;
04027 u_long written;
04028 u_long bytes;
04029 int tmperr = 0;
04030 struct rsbac_list_write_item_t * write_item_p;
04031 struct rsbac_list_write_item_t * next_item_p;
04032
04033 file_p = rsbac_kmalloc(sizeof(*file_p));
04034 if(!file_p)
04035 {
04036 return -RSBAC_ENOMEM;
04037 }
04038 write_item_p = write_head.head;
04039 while(write_item_p)
04040 {
04041 #ifdef CONFIG_RSBAC_DEBUG
04042 if (rsbac_debug_write)
04043 {
04044 rsbac_printk(KERN_DEBUG "rsbac_list_write_buffers(): write list %s on device %02u:%02u.\n",
04045 write_item_p->name,
04046 RSBAC_MAJOR(write_item_p->device),
04047 RSBAC_MINOR(write_item_p->device));
04048 }
04049 #endif
04050 if(need_lock)
04051 lock_kernel();
04052 /* open file */
04053 if ((tmperr = rsbac_write_open(write_item_p->name,
04054 file_p,
04055 write_item_p->device) ))
04056 {
04057 if(tmperr != -RSBAC_ENOTWRITABLE)
04058 {
04059 rsbac_printk(KERN_WARNING
04060 "rsbac_list_write_buffers(): opening file %s on device %02u:%02u failed with error %i!\n",
04061 write_item_p->name,
04062 RSBAC_MAJOR(write_item_p->device),
04063 RSBAC_MINOR(write_item_p->device),
04064 tmperr);
04065 }
04066 count = tmperr;
04067 goto free_item;
04068 }
04069
04070 /* OK, now we can start writing the buffer. */
04071 /* Set current user space to kernel space, because write() reads */
04072 /* from user space */
04073 oldfs = get_fs();
04074 set_fs(KERNEL_DS);
04075
04076 written = 0;
04077 while ((written < write_item_p->buflen) && (tmperr >= 0))
04078 {
04079 bytes = rsbac_min(write_item_p->buflen - written, RSBAC_MAX_WRITE_CHUNK);
04080 tmperr = file_p->f_op->write(file_p,
04081 write_item_p->buf + written,
04082 bytes,
04083 &file_p->f_pos);
04084 if(tmperr > 0)
04085 {
04086 written += tmperr;
04087 }
04088 }
04089 if (tmperr < 0)
04090 {
04091 rsbac_printk(KERN_WARNING
04092 "rsbac_list_write_buffers(): write error %i on device %02u:%02u file %s!\n",
04093 tmperr,
04094 RSBAC_MAJOR(write_item_p->device),
04095 RSBAC_MINOR(write_item_p->device),
04096 write_item_p->name);
04097 if(write_item_p->list->self == write_item_p->list)
04098 write_item_p->list->dirty = TRUE;
04099 }
04100 else
04101 count++;
04102
04103 /* Set current user space back to user space, because write() reads */
04104 /* from user space */
04105 set_fs(oldfs);
04106
04107 #ifdef CONFIG_RSBAC_DEBUG
04108 if (rsbac_debug_write)
04109 {
04110 rsbac_printk(KERN_DEBUG "rsbac_list_write_buffers(): %lu bytes written.\n",
04111 written);
04112 }
04113 #endif
04114 /* End of write access */
04115 rsbac_write_close(file_p);
04116
04117 free_item:
04118 if(need_lock)
04119 unlock_kernel();
04120 /* free buffer */
04121 rsbac_vkfree(write_item_p->buf, write_item_p->vmalloc_used);
04122 next_item_p = write_item_p->next;
04123 rsbac_kfree(write_item_p);
04124 write_item_p = next_item_p;
04125 }
04126 /* Ready. */
04127 rsbac_kfree(file_p);
04128 return count;
04129 }
|
|
||||||||||||
|
Definition at line 4255 of file gen_lists.c. References rsbac_list_lol_write_item_t::buf, rsbac_list_lol_write_item_t::buflen, rsbac_list_lol_write_item_t::device, rsbac_list_lol_reg_item_t::dirty, rsbac_list_lol_write_head_t::head, rsbac_list_lol_write_item_t::list, rsbac_list_lol_write_item_t::name, rsbac_list_lol_write_item_t::next, RSBAC_ENOMEM, RSBAC_ENOTWRITABLE, rsbac_kfree(), rsbac_kmalloc(), rsbac_min, rsbac_printk(), rsbac_vkfree(), rsbac_write_close(), rsbac_write_open(), rsbac_list_lol_reg_item_t::self, TRUE, and rsbac_list_lol_write_item_t::vmalloc_used. Referenced by rsbac_list_lol_detach(). 04257 {
04258 struct file * file_p;
04259 int count = 0;
04260 mm_segment_t oldfs;
04261 u_long written;
04262 u_long bytes;
04263 int tmperr = 0;
04264 struct rsbac_list_lol_write_item_t * write_item_p;
04265 struct rsbac_list_lol_write_item_t * next_item_p;
04266
04267 file_p = rsbac_kmalloc(sizeof(*file_p));
04268 if(!file_p)
04269 {
04270 return -RSBAC_ENOMEM;
04271 }
04272 write_item_p = write_head.head;
04273 while(write_item_p)
04274 {
04275 #ifdef CONFIG_RSBAC_DEBUG
04276 if (rsbac_debug_write)
04277 {
04278 rsbac_printk(KERN_DEBUG "rsbac_list_write_lol_buffers(): write list %s on device %02u:%02u.\n",
04279 write_item_p->name,
04280 RSBAC_MAJOR(write_item_p->device),
04281 RSBAC_MINOR(write_item_p->device));
04282 }
04283 #endif
04284 if(need_lock)
04285 lock_kernel();
04286 /* open file */
04287 if ((tmperr = rsbac_write_open(write_item_p->name,
04288 file_p,
04289 write_item_p->device) ))
04290 {
04291 if(tmperr != -RSBAC_ENOTWRITABLE)
04292 {
04293 rsbac_printk(KERN_WARNING
04294 "rsbac_list_write_lol_buffers(): opening file %s on device %02u:%02u failed with error %i!\n",
04295 write_item_p->name,
04296 RSBAC_MAJOR(write_item_p->device),
04297 RSBAC_MINOR(write_item_p->device),
04298 tmperr);
04299 }
04300 goto free_item;
04301 }
04302
04303 /* OK, now we can start writing the buffer. */
04304 /* Set current user space to kernel space, because write() reads */
04305 /* from user space */
04306 oldfs = get_fs();
04307 set_fs(KERNEL_DS);
04308
04309 written = 0;
04310 while ((written < write_item_p->buflen) && (tmperr >= 0))
04311 {
04312 bytes = rsbac_min(write_item_p->buflen - written, RSBAC_MAX_WRITE_CHUNK);
04313 tmperr = file_p->f_op->write(file_p,
04314 write_item_p->buf + written,
04315 bytes,
04316 &file_p->f_pos);
04317 if(tmperr > 0)
04318 {
04319 written += tmperr;
04320 }
04321 }
04322 if (tmperr < 0)
04323 {
04324 rsbac_printk(KERN_WARNING
04325 "rsbac_list_write_lol_buffers(): write error %i on device %02u:%02u file %s!\n",
04326 tmperr,
04327 RSBAC_MAJOR(write_item_p->device),
04328 RSBAC_MINOR(write_item_p->device),
04329 write_item_p->name);
04330 if(write_item_p->list->self == write_item_p->list)
04331 write_item_p->list->dirty = TRUE;
04332 }
04333 else
04334 count++;
04335
04336 /* Set current user space back to user space, because write() reads */
04337 /* from user space */
04338 set_fs(oldfs);
04339
04340 #ifdef CONFIG_RSBAC_DEBUG
04341 if (rsbac_debug_write)
04342 {
04343 rsbac_printk(KERN_DEBUG "rsbac_list_write_lol_buffers(): %lu bytes written.\n",
04344 written);
04345 }
04346 #endif
04347 /* End of write access */
04348 rsbac_write_close(file_p);
04349
04350 free_item:
04351 if(need_lock)
04352 unlock_kernel();
04353 /* free buffer */
04354 rsbac_vkfree(write_item_p->buf, write_item_p->vmalloc_used);
04355 next_item_p = write_item_p->next;
04356 rsbac_kfree(write_item_p);
04357 write_item_p = next_item_p;
04358 }
04359 /* Ready. */
04360 rsbac_kfree(file_p);
04361 return count;
04362 }
|
|
||||||||||||||||||||||||
|
Definition at line 6954 of file gen_lists.c. References add_item(), rsbac_list_info_t::data_size, rsbac_list_reg_item_t::def_data, rsbac_list_info_t::desc_size, rsbac_list_reg_item_t::dirty, do_remove_item(), rsbac_list_reg_item_t::info, list_initialized, rsbac_list_reg_head_t::lock, rsbac_list_reg_item_t::lock, lookup_item(), rsbac_list_item_t::max_age, RSBAC_EBUSY, RSBAC_EINVALIDTRANSACTION, RSBAC_EINVALIDVALUE, RSBAC_ENOTINITIALIZED, RSBAC_LIST_MAX_AGE_LIMIT, RSBAC_LIST_TTL_KEEP, rsbac_ta_list_exist(), rsbac_list_reg_item_t::self, touch, and TRUE. Referenced by rsbac_acl_add_group(), rsbac_acl_add_to_acl_entry(), rsbac_acl_change_group(), rsbac_acl_remove_from_acl_entry(), rsbac_acl_set_acl_entry(), rsbac_list_add(), rsbac_list_add_ttl(), rsbac_pm_add_target(), rsbac_pm_set_data(), rsbac_rc_copy_role(), rsbac_rc_copy_type(), rsbac_rc_set_item(), rsbac_um_add_group(), rsbac_um_mod_group(), rsbac_um_set_group_pass(), set_attr_dev(), set_attr_fd(), set_attr_ipc(), set_attr_process(), and set_attr_user(). 06960 {
06961 struct rsbac_list_reg_item_t * list;
06962 struct rsbac_list_item_t * item_p;
06963 u_long lock_flags, rlock_flags;
06964
06965 if(!handle || !desc)
06966 return -RSBAC_EINVALIDVALUE;
06967 if(!list_initialized)
06968 return -RSBAC_ENOTINITIALIZED;
06969
06970 list = (struct rsbac_list_reg_item_t *) handle;
06971 if(!list || (list->self != list))
06972 return -RSBAC_EINVALIDVALUE;
06973
06974 #ifdef CONFIG_RSBAC_LIST_TRANS
06975 if(ta_number && !rsbac_ta_list_exist(0, ta_handle, &ta_number))
06976 return -RSBAC_EINVALIDTRANSACTION;
06977 #endif
06978
06979 rsbac_read_lock(®_head.lock, &rlock_flags);
06980 if(list->info.data_size && !data)
06981 {
06982 rsbac_read_unlock(®_head.lock, &rlock_flags);
06983 return -RSBAC_EINVALIDVALUE;
06984 }
06985
06986 /*
06987 #ifdef CONFIG_RSBAC_DEBUG
06988 if(rsbac_debug_lists)
06989 rsbac_printk(KERN_DEBUG "rsbac_ta_list_add_ttl: adding to list %s.\n",
06990 list->name);
06991 #endif
06992 */
06993 if(ttl && (ttl != RSBAC_LIST_TTL_KEEP))
06994 {
06995 if(ttl > RSBAC_LIST_MAX_AGE_LIMIT)
06996 ttl = RSBAC_LIST_MAX_AGE_LIMIT;
06997 ttl += RSBAC_CURRENT_TIME;
06998 }
06999 rsbac_write_lock(&list->lock, &lock_flags);
07000
07001 #ifdef CONFIG_RSBAC_LIST_TRANS
07002 if(!ta_number)
07003 #endif
07004 {
07005 item_p = lookup_item(list, desc);
07006 if(item_p)
07007 { /* exists -> update data, if any */
07008 if(ttl != RSBAC_LIST_TTL_KEEP)
07009 item_p->max_age = ttl;
07010 if(data && list->info.data_size)
07011 {
07012 if( list->def_data
07013 && !item_p->max_age
07014 && !memcmp(list->def_data, data, list->info.data_size)
07015 )
07016 do_remove_item(list, item_p);
07017 else
07018 memcpy(((char *) item_p) + sizeof(*item_p) + list->info.desc_size,
07019 data, list->info.data_size);
07020 }
07021 }
07022 else
07023 {
07024 if(ttl == RSBAC_LIST_TTL_KEEP)
07025 ttl = 0;
07026 if( !list->def_data
07027 || memcmp(list->def_data, data, list->info.data_size)
07028 )
07029 add_item(list, ttl, desc, data);
07030 }
07031 touch(list);
07032 list->dirty = TRUE;
07033 }
07034 #ifdef CONFIG_RSBAC_LIST_TRANS
07035 if( list->ta_copied
07036 || ta_number
07037 )
07038 {
07039 if(!list->ta_copied)
07040 ta_copy(ta_number, list);
07041 else
07042 if(ta_number)
07043 {
07044 if(list->ta_copied != ta_number)
07045 {
07046 rsbac_write_unlock(&list->lock, &lock_flags);
07047 rsbac_read_unlock(®_head.lock, &rlock_flags);
07048 return -RSBAC_EBUSY;
07049 }
07050 }
07051 else
07052 ta_number = list->ta_copied;
07053 item_p = ta_lookup_item(ta_number, list, desc);
07054 if(item_p)
07055 { /* exists -> update data, if any */
07056 if(ttl != RSBAC_LIST_TTL_KEEP)
07057 item_p->max_age = ttl;
07058 if(data && list->info.data_size)
07059 {
07060 if( list->def_data
07061 && !item_p->max_age
07062 && !memcmp(list->def_data, data, list->info.data_size)
07063 )
07064 ta_do_remove_item(list, item_p);
07065 else
07066 memcpy(((char *) item_p) + sizeof(*item_p) + list->info.desc_size,
07067 data, list->info.data_size);
07068 }
07069 }
07070 else
07071 {
07072 if(ttl == RSBAC_LIST_TTL_KEEP)
07073 ttl = 0;
07074 if( !list->def_data
07075 || memcmp(list->def_data, data, list->info.data_size)
07076 )
07077 ta_add_item(ta_number, list, ttl, desc, data);
07078 }
07079 }
07080 #endif
07081 rsbac_write_unlock(&list->lock, &lock_flags);
07082 rsbac_read_unlock(®_head.lock, &rlock_flags);
07083 return 0;
07084 }
|
|
||||||||||||
|
Definition at line 9501 of file gen_lists.c. References rsbac_list_reg_item_t::count, list_initialized, RSBAC_EINVALIDTRANSACTION, RSBAC_EINVALIDVALUE, RSBAC_ENOTINITIALIZED, rsbac_ta_list_exist(), and rsbac_list_reg_item_t::self. Referenced by rsbac_list_count(), rsbac_rc_get_list(), rsbac_ta_list_all_dev(), rsbac_ta_list_all_group(), rsbac_ta_list_all_user(), and rsbac_um_get_group_list(). 09504 {
09505 struct rsbac_list_reg_item_t * list;
09506
09507 if(!handle)
09508 return -RSBAC_EINVALIDVALUE;
09509 if(!list_initialized)
09510 return -RSBAC_ENOTINITIALIZED;
09511
09512 list = (struct rsbac_list_reg_item_t *) handle;
09513 if(list->self != list)
09514 return -RSBAC_EINVALIDVALUE;
09515
09516 #ifdef CONFIG_RSBAC_LIST_TRANS
09517 if(ta_number)
09518 {
09519 if(!rsbac_ta_list_exist(0, ta_handle, &ta_number))
09520 return -RSBAC_EINVALIDTRANSACTION;
09521 }
09522 #endif
09523
09524 #ifdef CONFIG_RSBAC_LIST_TRANS
09525 if(ta_number && (list->ta_copied == ta_number))
09526 return list->ta_count;
09527 else
09528 #endif
09529 return list->count;
09530 }
|
|
||||||||||||||||
|
||||||||||||||||
|
Definition at line 9920 of file gen_lists.c. References rsbac_list_reg_item_t::count, rsbac_list_info_t::data_size, rsbac_list_info_t::desc_size, rsbac_list_reg_item_t::head, rsbac_list_reg_item_t::info, list_initialized, rsbac_list_reg_head_t::lock, rsbac_list_reg_item_t::lock, rsbac_list_item_t::max_age, rsbac_list_item_t::next, NULL, RSBAC_EINVALIDREQUEST, RSBAC_EINVALIDTRANSACTION, RSBAC_EINVALIDVALUE, RSBAC_ENOMEM, RSBAC_ENOTINITIALIZED, rsbac_ta_list_exist(), rsbac_vmalloc, and rsbac_list_reg_item_t::self. Referenced by rsbac_acl_list_groups(), rsbac_acl_remove_user(), and rsbac_list_get_all_data(). 09924 {
09925 struct rsbac_list_reg_item_t * list;
09926 struct rsbac_list_item_t * item_p;
09927 char * buffer;
09928 u_long lock_flags, rlock_flags;
09929 u_long offset = 0;
09930 long result = 0;
09931 u_int item_size;
09932 u_int item_offset;
09933
09934 if(!handle)
09935 return -RSBAC_EINVALIDVALUE;
09936 if(!array_p)
09937 return -RSBAC_EINVALIDVALUE;
09938 if(!list_initialized)
09939 return -RSBAC_ENOTINITIALIZED;
09940
09941 list = (struct rsbac_list_reg_item_t *) handle;
09942 if(list->self != list)
09943 return -RSBAC_EINVALIDVALUE;
09944 *array_p = NULL;
09945
09946 #ifdef CONFIG_RSBAC_LIST_TRANS
09947 if(ta_number)
09948 {
09949 if(!rsbac_ta_list_exist(0, ta_handle, &ta_number))
09950 return -RSBAC_EINVALIDTRANSACTION;
09951 }
09952 #endif
09953
09954 rsbac_read_lock(®_head.lock, &rlock_flags);
09955 /*
09956 #ifdef CONFIG_RSBAC_DEBUG
09957 if(rsbac_debug_lists)
09958 rsbac_printk(KERN_DEBUG "rsbac_list_get_all_data: list %s.\n",
09959 list->name);
09960 #endif
09961 */
09962 rsbac_read_lock(&list->lock, &lock_flags);
09963 if(!list->info.data_size)
09964 {
09965 rsbac_read_unlock(&list->lock, &lock_flags);
09966 rsbac_read_unlock(®_head.lock, &rlock_flags);
09967 return -RSBAC_EINVALIDREQUEST;
09968 }
09969 #ifdef CONFIG_RSBAC_LIST_TRANS
09970 if(ta_number && (list->ta_copied == ta_number))
09971 {
09972 if(list->ta_count)
09973 {
09974 item_size = list->info.data_size;
09975 item_offset = list->info.desc_size;
09976 buffer = rsbac_vmalloc(item_size * list->ta_count);
09977 if(buffer)
09978 {
09979 item_p = list->ta_head;
09980 while(item_p)
09981 {
09982 if( !item_p->max_age
09983 || (item_p->max_age > RSBAC_CURRENT_TIME)
09984 )
09985 {
09986 memcpy(buffer + offset,
09987 ((char *) item_p) + sizeof(*item_p) + item_offset,
09988 item_size);
09989 offset += item_size;
09990 result++;
09991 }
09992 item_p = item_p->next;
09993 }
09994 *array_p = buffer;
09995 }
09996 else
09997 {
09998 result = -RSBAC_ENOMEM;
09999 }
10000 }
10001 }
10002 else
10003 #endif
10004 if(list->count)
10005 {
10006 item_size = list->info.data_size;
10007 item_offset = list->info.desc_size;
10008 buffer = rsbac_vmalloc(item_size * list->count);
10009 if(buffer)
10010 {
10011 item_p = list->head;
10012 while(item_p)
10013 {
10014 if( !item_p->max_age
10015 || (item_p->max_age > RSBAC_CURRENT_TIME)
10016 )
10017 {
10018 memcpy(buffer + offset,
10019 ((char *) item_p) + sizeof(*item_p) + item_offset,
10020 item_size);
10021 offset += item_size;
10022 result++;
10023 }
10024 item_p = item_p->next;
10025 }
10026 *array_p = buffer;
10027 }
10028 else
10029 {
10030 result = -RSBAC_ENOMEM;
10031 }
10032 }
10033 rsbac_read_unlock(&list->lock, &lock_flags);
10034 rsbac_read_unlock(®_head.lock, &rlock_flags);
10035 return result;
10036 }
|
|
||||||||||||||||
|
Definition at line 9549 of file gen_lists.c. References rsbac_list_reg_item_t::count, rsbac_list_info_t::desc_size, rsbac_list_reg_item_t::head, rsbac_list_reg_item_t::info, list_initialized, rsbac_list_reg_head_t::lock, rsbac_list_reg_item_t::lock, rsbac_list_item_t::max_age, rsbac_list_item_t::next, NULL, RSBAC_EINVALIDTRANSACTION, RSBAC_EINVALIDVALUE, RSBAC_ENOMEM, RSBAC_ENOTINITIALIZED, rsbac_ta_list_exist(), rsbac_vmalloc, and rsbac_list_reg_item_t::self. Referenced by copy_new_uids(), rsbac_list_get_all_desc(), rsbac_rc_copy_type(), rsbac_rc_get_list(), rsbac_ta_list_all_dev(), rsbac_ta_list_all_group(), rsbac_ta_list_all_user(), and rsbac_um_get_group_list(). 09553 {
09554 struct rsbac_list_reg_item_t * list;
09555 struct rsbac_list_item_t * item_p;
09556 char * buffer;
09557 u_long lock_flags, rlock_flags;
09558 u_long offset = 0;
09559 long result = 0;
09560 u_int item_size;
09561
09562 if(!handle)
09563 return -RSBAC_EINVALIDVALUE;
09564 if(!array_p)
09565 return -RSBAC_EINVALIDVALUE;
09566 if(!list_initialized)
09567 return -RSBAC_ENOTINITIALIZED;
09568
09569 list = (struct rsbac_list_reg_item_t *) handle;
09570 if(list->self != list)
09571 return -RSBAC_EINVALIDVALUE;
09572 *array_p = NULL;
09573
09574 #ifdef CONFIG_RSBAC_LIST_TRANS
09575 if(ta_number)
09576 {
09577 if(!rsbac_ta_list_exist(0, ta_handle, &ta_number))
09578 return -RSBAC_EINVALIDTRANSACTION;
09579 }
09580 #endif
09581
09582 rsbac_read_lock(®_head.lock, &rlock_flags);
09583 /*
09584 #ifdef CONFIG_RSBAC_DEBUG
09585 if(rsbac_debug_lists)
09586 rsbac_printk(KERN_DEBUG "rsbac_list_get_all_desc: list %s.\n",
09587 list->name);
09588 #endif
09589 */
09590 rsbac_read_lock(&list->lock, &lock_flags);
09591 #ifdef CONFIG_RSBAC_LIST_TRANS
09592 if(ta_number && (list->ta_copied == ta_number))
09593 {
09594 if(list->ta_count)
09595 {
09596 item_size = list->info.desc_size;
09597 buffer = rsbac_vmalloc(item_size * list->ta_count);
09598 if(buffer)
09599 {
09600 item_p = list->ta_head;
09601 while(item_p)
09602 {
09603 if( !item_p->max_age
09604 || (item_p->max_age > RSBAC_CURRENT_TIME)
09605 )
09606 {
09607 memcpy(buffer + offset,
09608 ((char *) item_p) + sizeof(*item_p),
09609 item_size);
09610 offset += item_size;
09611 result++;
09612 }
09613 item_p = item_p->next;
09614 }
09615 *array_p = buffer;
09616 }
09617 else
09618 {
09619 result = -RSBAC_ENOMEM;
09620 }
09621 }
09622 }
09623 else
09624 #endif
09625 if(list->count)
09626 {
09627 item_size = list->info.desc_size;
09628 buffer = rsbac_vmalloc(item_size * list->count);
09629 if(buffer)
09630 {
09631 item_p = list->head;
09632 while(item_p)
09633 {
09634 if( !item_p->max_age
09635 || (item_p->max_age > RSBAC_CURRENT_TIME)
09636 )
09637 {
09638 memcpy(buffer + offset,
09639 ((char *) item_p) + sizeof(*item_p),
09640 item_size);
09641 offset += item_size;
09642 result++;
09643 }
09644 item_p = item_p->next;
09645 }
09646 *array_p = buffer;
09647 }
09648 else
09649 {
09650 result = -RSBAC_ENOMEM;
09651 }
09652 }
09653 rsbac_read_unlock(&list->lock, &lock_flags);
09654 rsbac_read_unlock(®_head.lock, &rlock_flags);
09655 return result;
09656 }
|
|
||||||||||||||||||||
|
Definition at line 10349 of file gen_lists.c. References rsbac_list_reg_item_t::count, rsbac_list_info_t::data_size, rsbac_list_info_t::desc_size, rsbac_list_reg_item_t::head, rsbac_list_reg_item_t::info, list_initialized, rsbac_list_reg_head_t::lock, rsbac_list_reg_item_t::lock, rsbac_list_item_t::max_age, rsbac_list_item_t::next, NULL, RSBAC_EINVALIDPOINTER, RSBAC_EINVALIDTRANSACTION, RSBAC_EINVALIDVALUE, RSBAC_ENOMEM, RSBAC_ENOTINITIALIZED, rsbac_ta_list_exist(), rsbac_vmalloc, and rsbac_list_reg_item_t::self. Referenced by rsbac_acl_get_tlist(), rsbac_list_get_all_items(), and rsbac_list_get_all_items_ttl(). 10354 {
10355 struct rsbac_list_reg_item_t * list;
10356 struct rsbac_list_item_t * item_p;
10357 char * buffer;
10358 rsbac_time_t * ttl_p = NULL;
10359 u_long lock_flags, rlock_flags;
10360 u_long offset = 0;
10361 long result = 0;
10362 u_int item_size;
10363
10364 if(!handle)
10365 return -RSBAC_EINVALIDVALUE;
10366 if(!array_p)
10367 return -RSBAC_EINVALIDPOINTER;
10368 if(!list_initialized)
10369 return -RSBAC_ENOTINITIALIZED;
10370
10371 list = (struct rsbac_list_reg_item_t *) handle;
10372 if(list->self != list)
10373 return -RSBAC_EINVALIDVALUE;
10374 *array_p = NULL;
10375
10376 #ifdef CONFIG_RSBAC_LIST_TRANS
10377 if(ta_number)
10378 {
10379 if(!rsbac_ta_list_exist(0, ta_handle, &ta_number))
10380 return -RSBAC_EINVALIDTRANSACTION;
10381 }
10382 #endif
10383
10384 rsbac_read_lock(®_head.lock, &rlock_flags);
10385 /*
10386 #ifdef CONFIG_RSBAC_DEBUG
10387 if(rsbac_debug_lists)
10388 rsbac_printk(KERN_DEBUG "rsbac_list_get_all_items: list %s.\n",
10389 list->name);
10390 #endif
10391 */
10392 rsbac_read_lock(&list->lock, &lock_flags);
10393 #ifdef CONFIG_RSBAC_LIST_TRANS
10394 if(ta_number && (list->ta_copied == ta_number))
10395 {
10396 if(list->ta_count)
10397 {
10398 item_size = list->info.desc_size + list->info.data_size;
10399 buffer = rsbac_vmalloc(item_size * list->ta_count);
10400 if(buffer)
10401 {
10402 if(ttl_array_p)
10403 ttl_p = rsbac_vmalloc(sizeof(**ttl_array_p) * list->ta_count);
10404 item_p = list->ta_head;
10405 while(item_p)
10406 {
10407 if( !item_p->max_age
10408 || (item_p->max_age > RSBAC_CURRENT_TIME)
10409 )
10410 {
10411 memcpy(buffer + offset,
10412 ((char *) item_p) + sizeof(*item_p),
10413 item_size);
10414 if(ttl_p)
10415 {
10416 if(item_p->max_age)
10417 ttl_p[result] = item_p->max_age - RSBAC_CURRENT_TIME;
10418 else
10419 ttl_p[result] = 0;
10420 }
10421 offset += item_size;
10422 result++;
10423 }
10424 item_p = item_p->next;
10425 }
10426 *array_p = buffer;
10427 if(ttl_array_p)
10428 *ttl_array_p = ttl_p;
10429 }
10430 else
10431 {
10432 result = -RSBAC_ENOMEM;
10433 }
10434 }
10435 }
10436 else
10437 #endif
10438 if(list->count)
10439 {
10440 item_size = list->info.desc_size + list->info.data_size;
10441 buffer = rsbac_vmalloc(item_size * list->count);
10442 if(buffer)
10443 {
10444 if(ttl_array_p)
10445 ttl_p = rsbac_vmalloc(sizeof(**ttl_array_p) * list->count);
10446 item_p = list->head;
10447 while(item_p)
10448 {
10449 if( !item_p->max_age
10450 || (item_p->max_age > RSBAC_CURRENT_TIME)
10451 )
10452 {
10453 memcpy(buffer + offset,
10454 ((char *) item_p) + sizeof(*item_p),
10455 item_size);
10456 if(ttl_p)
10457 {
10458 if(item_p->max_age)
10459 ttl_p[result] = item_p->max_age - RSBAC_CURRENT_TIME;
10460 else
10461 ttl_p[result] = 0;
10462 }
10463 offset += item_size;
10464 result++;
10465 }
10466 item_p = item_p->next;
10467 }
10468 *array_p = buffer;
10469 if(ttl_array_p)
10470 *ttl_array_p = ttl_p;
10471 }
10472 else
10473 {
10474 result = -RSBAC_ENOMEM;
10475 }
10476 }
10477 rsbac_read_unlock(&list->lock, &lock_flags);
10478 rsbac_read_unlock(®_head.lock, &rlock_flags);
10479 return result;
10480 }
|
|
||||||||||||||||||||||||
|
Definition at line 8219 of file gen_lists.c. References rsbac_list_info_t::data_size, rsbac_list_reg_item_t::def_data, rsbac_list_info_t::desc_size, rsbac_list_reg_item_t::info, list_initialized, rsbac_list_reg_head_t::lock, rsbac_list_reg_item_t::lock, lookup_item(), rsbac_list_item_t::max_age, RSBAC_EINVALIDREQUEST, RSBAC_EINVALIDTRANSACTION, RSBAC_EINVALIDVALUE, RSBAC_ENOTFOUND, RSBAC_ENOTINITIALIZED, rsbac_ta_list_exist(), and rsbac_list_reg_item_t::self. Referenced by get_attr_dev(), get_attr_fd(), get_attr_ipc(), get_attr_process(), get_attr_user(), rsbac_acl_add_to_acl_entry(), rsbac_acl_get_group_entry(), rsbac_acl_get_rights(), rsbac_acl_get_single_right(), rsbac_acl_remove_from_acl_entry(), rsbac_list_get_data(), rsbac_list_get_data_ttl(), rsbac_pm_exists(), rsbac_pm_get_all_data(), rsbac_pm_get_data(), rsbac_pm_set_data(), rsbac_rc_copy_role(), rsbac_rc_copy_type(), rsbac_rc_get_item(), rsbac_rc_set_item(), rsbac_um_get_group_item(), rsbac_um_mod_group(), rsbac_um_set_group_pass(), set_attr_dev(), set_attr_fd(), set_attr_ipc(), set_attr_process(), and set_attr_user(). 08225 {
08226 struct rsbac_list_reg_item_t * list;
08227 struct rsbac_list_item_t * item_p;
08228 u_long lock_flags, rlock_flags;
08229 int err = 0;
08230
08231 if(!handle || !desc)
08232 return -RSBAC_EINVALIDVALUE;
08233 if(!list_initialized)
08234 return -RSBAC_ENOTINITIALIZED;
08235
08236 list = (struct rsbac_list_reg_item_t *) handle;
08237 if(list->self != list)
08238 return -RSBAC_EINVALIDVALUE;
08239
08240 #ifdef CONFIG_RSBAC_LIST_TRANS
08241 if(ta_number)
08242 {
08243 if(!rsbac_ta_list_exist(0, ta_handle, &ta_number))
08244 return -RSBAC_EINVALIDTRANSACTION;
08245 }
08246 #endif
08247
08248 rsbac_read_lock(®_head.lock, &rlock_flags);
08249 /*
08250 #ifdef CONFIG_RSBAC_DEBUG
08251 if(rsbac_debug_lists)
08252 rsbac_printk(KERN_DEBUG "rsbac_list_get_data: getting data from list %s.\n",
08253 list->name);
08254 #endif
08255 */
08256 if(data && !list->info.data_size)
08257 {
08258 rsbac_read_unlock(®_head.lock, &rlock_flags);
08259 return -RSBAC_EINVALIDREQUEST;
08260 }
08261
08262 rsbac_read_lock(&list->lock, &lock_flags);
08263 #ifdef CONFIG_RSBAC_LIST_TRANS
08264 if(ta_number && (list->ta_copied == ta_number))
08265 item_p = ta_lookup_item(ta_number, list, desc);
08266 else
08267 #endif
08268 item_p = lookup_item(list, desc);
08269 if( item_p
08270 && ( !item_p->max_age
08271 || (item_p->max_age > RSBAC_CURRENT_TIME)
08272 )
08273 )
08274 { /* exists -> copy data, if any */
08275 if(ttl_p)
08276 {
08277 if(item_p->max_age)
08278 *ttl_p = item_p->max_age - RSBAC_CURRENT_TIME;
08279 else
08280 *ttl_p = 0;
08281 }
08282 if(data)
08283 {
08284 memcpy(data,
08285 ((char *) item_p) + sizeof(*item_p) + list->info.desc_size,
08286 list->info.data_size);
08287 }
08288 }
08289 else
08290 {
08291 if(!list->def_data)
08292 err = -RSBAC_ENOTFOUND;
08293 else
08294 {
08295 if(ttl_p)
08296 *ttl_p = 0;
08297 if(data)
08298 memcpy(data,
08299 list->def_data,
08300 list->info.data_size);
08301 }
08302 }
08303 rsbac_read_unlock(&list->lock, &lock_flags);
08304 rsbac_read_unlock(®_head.lock, &rlock_flags);
08305 return err;
08306 }
|
|
||||||||||||||||||||||||
|
Definition at line 8834 of file gen_lists.c. References rsbac_list_info_t::data_size, rsbac_list_info_t::desc_size, rsbac_list_reg_item_t::info, list_initialized, rsbac_list_reg_head_t::lock, rsbac_list_reg_item_t::lock, lookup_item_data(), RSBAC_EINVALIDREQUEST, RSBAC_EINVALIDTRANSACTION, RSBAC_EINVALIDVALUE, RSBAC_ENOTFOUND, RSBAC_ENOTINITIALIZED, rsbac_ta_list_exist(), and rsbac_list_reg_item_t::self. Referenced by rsbac_list_get_desc(), and rsbac_um_get_gid(). 08840 {
08841 struct rsbac_list_reg_item_t * list;
08842 struct rsbac_list_item_t * item_p;
08843 u_long lock_flags, rlock_flags;
08844 int err = 0;
08845
08846 if(!handle || !desc || !data)
08847 return -RSBAC_EINVALIDVALUE;
08848 if(!list_initialized)
08849 return -RSBAC_ENOTINITIALIZED;
08850
08851 list = (struct rsbac_list_reg_item_t *) handle;
08852 if(list->self != list)
08853 return -RSBAC_EINVALIDVALUE;
08854
08855 #ifdef CONFIG_RSBAC_LIST_TRANS
08856 if(ta_number)
08857 {
08858 if(!rsbac_ta_list_exist(0, ta_handle, &ta_number))
08859 return -RSBAC_EINVALIDTRANSACTION;
08860 }
08861 #endif
08862
08863 rsbac_read_lock(®_head.lock, &rlock_flags);
08864 /*
08865 #ifdef CONFIG_RSBAC_DEBUG
08866 if(rsbac_debug_lists)
08867 rsbac_printk(KERN_DEBUG "rsbac_list_get_desc: getting desc from list %s.\n",
08868 list->name);
08869 #endif
08870 */
08871 if(!list->info.data_size)
08872 {
08873 rsbac_read_unlock(®_head.lock, &rlock_flags);
08874 return -RSBAC_EINVALIDREQUEST;
08875 }
08876
08877 rsbac_read_lock(&list->lock, &lock_flags);
08878
08879 #ifdef CONFIG_RSBAC_LIST_TRANS
08880 if(ta_number && (list->ta_copied == ta_number))
08881 item_p = ta_lookup_item_data(ta_number, list, data, compare);
08882 else
08883 #endif
08884 item_p = lookup_item_data(list, data, compare);
08885 if(item_p)
08886 { /* exists -> copy desc */
08887 memcpy(desc,
08888 ((char *) item_p) + sizeof(*item_p),
08889 list->info.desc_size);
08890 }
08891 else
08892 {
08893 err = -RSBAC_ENOTFOUND;
08894 }
08895 rsbac_read_unlock(&list->lock, &lock_flags);
08896 rsbac_read_unlock(®_head.lock, &rlock_flags);
08897 return err;
08898 }
|
|
||||||||||||||||
|
Definition at line 8583 of file gen_lists.c. References rsbac_list_info_t::desc_size, rsbac_list_reg_item_t::info, list_initialized, rsbac_list_reg_head_t::lock, rsbac_list_reg_item_t::lock, rsbac_list_item_t::max_age, rsbac_list_item_t::prev, RSBAC_EINVALIDTRANSACTION, RSBAC_EINVALIDVALUE, RSBAC_ENOTFOUND, RSBAC_ENOTINITIALIZED, rsbac_ta_list_exist(), rsbac_list_reg_item_t::self, and rsbac_list_reg_item_t::tail. Referenced by rsbac_list_get_max_desc(). 08587 {
08588 struct rsbac_list_reg_item_t * list;
08589 struct rsbac_list_item_t * item_p;
08590 u_long lock_flags, rlock_flags;
08591 int err = 0;
08592
08593 if(!handle)
08594 return -RSBAC_EINVALIDVALUE;
08595 if(!list_initialized)
08596 return -RSBAC_ENOTINITIALIZED;
08597
08598 list = (struct rsbac_list_reg_item_t *) handle;
08599 if(list->self != list)
08600 return -RSBAC_EINVALIDVALUE;
08601
08602 #ifdef CONFIG_RSBAC_LIST_TRANS
08603 if(ta_number)
08604 {
08605 if(!rsbac_ta_list_exist(0, ta_handle, &ta_number))
08606 return -RSBAC_EINVALIDTRANSACTION;
08607 }
08608 #endif
08609
08610 rsbac_read_lock(®_head.lock, &rlock_flags);
08611 /*
08612 #ifdef CONFIG_RSBAC_DEBUG
08613 if(rsbac_debug_lists)
08614 rsbac_printk(KERN_DEBUG "rsbac_list_get_max_desc: list %s.\n",
08615 list->name);
08616 #endif
08617 */
08618 rsbac_read_lock(&list->lock, &lock_flags);
08619 #ifdef CONFIG_RSBAC_LIST_TRANS
08620 if(ta_number && (list->ta_copied == ta_number))
08621 item_p = list->ta_tail;
08622 else
08623 #endif
08624 item_p = list->tail;
08625 while( item_p
08626 && item_p->max_age
08627 && (item_p->max_age > RSBAC_CURRENT_TIME)
08628 )
08629 item_p = item_p->prev;
08630 if(item_p)
08631 memcpy(desc, (char *)item_p + sizeof(*item_p), list->info.desc_size);
08632 else
08633 {
08634 memset(desc, 0, list->info.desc_size);
08635 err = -RSBAC_ENOTFOUND;
08636 }
08637 rsbac_read_unlock(&list->lock, &lock_flags);
08638 rsbac_read_unlock(®_head.lock, &rlock_flags);
08639 return err;
08640 }
|
|
||||||||||||||||||||
|
Definition at line 8653 of file gen_lists.c. References rsbac_list_reg_item_t::curr, rsbac_list_info_t::desc_size, rsbac_list_reg_item_t::head, rsbac_list_reg_item_t::info, list_initialized, rsbac_list_reg_head_t::lock, rsbac_list_reg_item_t::lock, lookup_item(), rsbac_list_item_t::max_age, rsbac_list_item_t::next, RSBAC_EINVALIDPOINTER, RSBAC_EINVALIDTRANSACTION, RSBAC_EINVALIDVALUE, RSBAC_ENOTFOUND, RSBAC_ENOTINITIALIZED, rsbac_ta_list_exist(), and rsbac_list_reg_item_t::self. Referenced by rsbac_list_get_next_desc(). 08658 {
08659 struct rsbac_list_reg_item_t * list;
08660 struct rsbac_list_item_t * item_p;
08661 u_long lock_flags, rlock_flags;
08662
08663 if(!handle)
08664 return -RSBAC_EINVALIDVALUE;
08665 if(!list_initialized)
08666 return -RSBAC_ENOTINITIALIZED;
08667 if(!next_desc)
08668 return -RSBAC_EINVALIDPOINTER;
08669
08670 list = (struct rsbac_list_reg_item_t *) handle;
08671 if(list->self != list)
08672 return -RSBAC_EINVALIDVALUE;
08673
08674 #ifdef CONFIG_RSBAC_LIST_TRANS
08675 if(ta_number)
08676 {
08677 if(!rsbac_ta_list_exist(0, ta_handle, &ta_number))
08678 return -RSBAC_EINVALIDTRANSACTION;
08679 }
08680 #endif
08681
08682 rsbac_read_lock(®_head.lock, &rlock_flags);
08683 /*
08684 #ifdef CONFIG_RSBAC_DEBUG
08685 if(rsbac_debug_lists)
08686 rsbac_printk(KERN_DEBUG "rsbac_list_get_next_desc: list %s.\n",
08687 list->name);
08688 #endif
08689 */
08690 rsbac_read_lock(&list->lock, &lock_flags);
08691 if(old_desc)
08692 {
08693 #ifdef CONFIG_RSBAC_LIST_TRANS
08694 if(ta_number && (list->ta_copied == ta_number))
08695 item_p = ta_lookup_item(ta_number, list, old_desc);
08696 else
08697 #endif
08698 item_p = lookup_item(list, old_desc);
08699 if(item_p)
08700 item_p = item_p->next;
08701 }
08702 else
08703 #ifdef CONFIG_RSBAC_LIST_TRANS
08704 if(ta_number && (list->ta_copied == ta_number))
08705 item_p = list->ta_head;
08706 else
08707 #endif
08708 item_p = list->head;
08709 while( item_p
08710 && item_p->max_age
08711 && (item_p->max_age > RSBAC_CURRENT_TIME)
08712 )
08713 item_p = item_p->next;
08714 if(item_p)
08715 {
08716 memcpy(next_desc, (char *)item_p + sizeof(*item_p), list->info.desc_size);
08717 list->curr = item_p;
08718 }
08719 rsbac_read_unlock(&list->lock, &lock_flags);
08720 rsbac_read_unlock(®_head.lock, &rlock_flags);
08721 if(item_p)
08722 return 0;
08723 else
08724 return -RSBAC_ENOTFOUND;
08725 }
|
|
||||||||||||||||||||||||
|
Definition at line 7336 of file gen_lists.c. References add_lol_item(), rsbac_list_lol_item_t::count, rsbac_list_lol_info_t::data_size, rsbac_list_lol_reg_item_t::def_data, rsbac_list_lol_info_t::desc_size, rsbac_list_lol_reg_item_t::dirty, do_remove_lol_item(), rsbac_list_lol_reg_item_t::info, list_initialized, rsbac_list_lol_reg_head_t::lock, rsbac_list_lol_reg_item_t::lock, lol_touch, lookup_lol_item(), rsbac_list_lol_item_t::max_age, RSBAC_EBUSY, RSBAC_EINVALIDTRANSACTION, RSBAC_EINVALIDVALUE, RSBAC_ENOTINITIALIZED, RSBAC_LIST_MAX_AGE_LIMIT, RSBAC_LIST_TTL_KEEP, rsbac_ta_list_exist(), rsbac_list_lol_reg_item_t::self, and TRUE. Referenced by rsbac_acl_add_group_member(), rsbac_acl_add_to_acl_entry(), rsbac_acl_set_acl_entry(), rsbac_acl_set_mask(), rsbac_list_lol_add(), rsbac_list_lol_add_ttl(), rsbac_pm_create_set(), rsbac_um_add_user(), rsbac_um_mod_user(), and rsbac_um_set_pass(). 07342 {
07343 struct rsbac_list_lol_reg_item_t * list;
07344 struct rsbac_list_lol_item_t * item_p;
07345 u_long lock_flags, rlock_flags;
07346
07347 if(!handle || !desc)
07348 return -RSBAC_EINVALIDVALUE;
07349 if(!list_initialized)
07350 return -RSBAC_ENOTINITIALIZED;
07351
07352 list = (struct rsbac_list_lol_reg_item_t *) handle;
07353 if(!list || (list->self != list))
07354 return -RSBAC_EINVALIDVALUE;
07355
07356 #ifdef CONFIG_RSBAC_LIST_TRANS
07357 if(ta_number && !rsbac_ta_list_exist(0, ta_handle, &ta_number))
07358 return -RSBAC_EINVALIDTRANSACTION;
07359 #endif
07360
07361 if(ttl && (ttl != RSBAC_LIST_TTL_KEEP))
07362 {
07363 if(ttl > RSBAC_LIST_MAX_AGE_LIMIT)
07364 ttl = RSBAC_LIST_MAX_AGE_LIMIT;
07365 ttl += RSBAC_CURRENT_TIME;
07366 }
07367
07368 rsbac_read_lock(&lol_reg_head.lock, &rlock_flags);
07369 if(list->info.data_size && !data)
07370 {
07371 rsbac_read_unlock(&lol_reg_head.lock, &rlock_flags);
07372 return -RSBAC_EINVALIDVALUE;
07373 }
07374
07375 /*
07376 #ifdef CONFIG_RSBAC_DEBUG
07377 if(rsbac_debug_lists)
07378 rsbac_printk(KERN_DEBUG "rsbac_list_lol_add: adding to list %s.\n",
07379 list->name);
07380 #endif
07381 */
07382 rsbac_write_lock(&list->lock, &lock_flags);
07383
07384 #ifdef CONFIG_RSBAC_LIST_TRANS
07385 if(!ta_number)
07386 #endif
07387 {
07388 item_p = lookup_lol_item(list, desc);
07389 if(item_p)
07390 { /* exists -> update data, if any */
07391 if(ttl != RSBAC_LIST_TTL_KEEP)
07392 item_p->max_age = ttl;
07393 if(data && list->info.data_size)
07394 {
07395 if( list->def_data
07396 && !item_p->max_age
07397 && !memcmp(list->def_data, data, list->info.data_size)
07398 && !item_p->count
07399 )
07400 do_remove_lol_item(list, item_p);
07401 else
07402 memcpy(((char *) item_p) + sizeof(*item_p) + list->info.desc_size,
07403 data, list->info.data_size);
07404 }
07405 }
07406 else
07407 {
07408 if(ttl == RSBAC_LIST_TTL_KEEP)
07409 ttl = 0;
07410 if( !list->def_data
07411 || memcmp(list->def_data, data, list->info.data_size)
07412 )
07413 add_lol_item(list, ttl, desc, data);
07414 }
07415 lol_touch(list);
07416 list->dirty = TRUE;
07417 }
07418 #ifdef CONFIG_RSBAC_LIST_TRANS
07419 if(list->ta_copied || ta_number)
07420 {
07421 if(!list->ta_copied)
07422 ta_lol_copy(ta_number, list);
07423 else
07424 if(ta_number)
07425 {
07426 if(list->ta_copied != ta_number)
07427 {
07428 rsbac_write_unlock(&list->lock, &lock_flags);
07429 rsbac_read_unlock(&lol_reg_head.lock, &rlock_flags);
07430 return -RSBAC_EBUSY;
07431 }
07432 }
07433 else
07434 ta_number = list->ta_copied;
07435 item_p = ta_lookup_lol_item(ta_number, list, desc);
07436 if(item_p)
07437 { /* exists -> update data, if any */
07438 if(ttl != RSBAC_LIST_TTL_KEEP)
07439 item_p->max_age = ttl;
07440 if(data && list->info.data_size)
07441 {
07442 if( list->def_data
07443 && !item_p->max_age
07444 && !memcmp(list->def_data, data, list->info.data_size)
07445 && !item_p->count
07446 )
07447 ta_do_remove_lol_item(list, item_p);
07448 else
07449 memcpy(((char *) item_p) + sizeof(*item_p) + list->info.desc_size,
07450 data, list->info.data_size);
07451 }
07452 }
07453 else
07454 {
07455 if(ttl == RSBAC_LIST_TTL_KEEP)
07456 ttl = 0;
07457 if( !list->def_data
07458 || memcmp(list->def_data, data, list->info.data_size)
07459 )
07460 ta_add_lol_item(ta_number, list, ttl, desc, data);
07461 }
07462 }
07463 #endif
07464 rsbac_write_unlock(&list->lock, &lock_flags);
07465 rsbac_read_unlock(&lol_reg_head.lock, &rlock_flags);
07466 return 0;
07467 }
|
|
||||||||||||
|
Definition at line 9389 of file gen_lists.c. References rsbac_list_lol_item_t::count, rsbac_list_lol_reg_item_t::head, list_initialized, rsbac_list_lol_reg_head_t::lock, rsbac_list_lol_reg_item_t::lock, rsbac_list_lol_item_t::next, RSBAC_EINVALIDTRANSACTION, RSBAC_EINVALIDVALUE, RSBAC_ENOTINITIALIZED, rsbac_ta_list_exist(), and rsbac_list_lol_reg_item_t::self. Referenced by rsbac_list_lol_all_subcount(). 09392 {
09393 struct rsbac_list_lol_reg_item_t * list;
09394 struct rsbac_list_lol_item_t * sublist;
09395 u_long lock_flags, rlock_flags;
09396 long result = 0;
09397
09398 if(!handle)
09399 return -RSBAC_EINVALIDVALUE;
09400 if(!list_initialized)
09401 return -RSBAC_ENOTINITIALIZED;
09402
09403 list = (struct rsbac_list_lol_reg_item_t *) handle;
09404 if(list->self != list)
09405 return -RSBAC_EINVALIDVALUE;
09406
09407 #ifdef CONFIG_RSBAC_LIST_TRANS
09408 if(ta_number)
09409 {
09410 if(!rsbac_ta_list_exist(0, ta_handle, &ta_number))
09411 return -RSBAC_EINVALIDTRANSACTION;
09412 }
09413 #endif
09414
09415 rsbac_read_lock(&lol_reg_head.lock, &rlock_flags);
09416 /*
09417 #ifdef CONFIG_RSBAC_DEBUG
09418 if(rsbac_debug_lists)
09419 rsbac_printk(KERN_DEBUG "rsbac_list_lol_subcount: list %s.\n",
09420 list->name);
09421 #endif
09422 */
09423 rsbac_read_lock(&list->lock, &lock_flags);
09424
09425 #ifdef CONFIG_RSBAC_LIST_TRANS
09426 if(ta_number && (list->ta_copied == ta_number))
09427 sublist = list->ta_head;
09428 else
09429 #endif
09430 sublist = list->head;
09431 while(sublist)
09432 {
09433 result += sublist->count;
09434 sublist = sublist->next;
09435 }
09436 rsbac_read_unlock(&list->lock, &lock_flags);
09437 rsbac_read_unlock(&lol_reg_head.lock, &rlock_flags);
09438 return result;
09439 }
|
|
||||||||||||
|
Definition at line 9452 of file gen_lists.c. References rsbac_list_lol_reg_item_t::count, list_initialized, RSBAC_EINVALIDTRANSACTION, RSBAC_EINVALIDVALUE, RSBAC_ENOTINITIALIZED, rsbac_ta_list_exist(), and rsbac_list_lol_reg_item_t::self. Referenced by rsbac_acl_list_all_dev(), rsbac_acl_list_all_major_dev(), rsbac_acl_list_all_user(), rsbac_list_lol_count(), rsbac_um_get_gm_user_list(), and rsbac_um_get_user_list(). 09455 {
09456 struct rsbac_list_lol_reg_item_t * list;
09457
09458 if(!handle)
09459 return -RSBAC_EINVALIDVALUE;
09460 if(!list_initialized)
09461 return -RSBAC_ENOTINITIALIZED;
09462
09463 list = (struct rsbac_list_lol_reg_item_t *) handle;
09464 if(list->self != list)
09465 return -RSBAC_EINVALIDVALUE;
09466
09467 #ifdef CONFIG_RSBAC_LIST_TRANS
09468 if(ta_number)
09469 {
09470 if(!rsbac_ta_list_exist(0, ta_handle, &ta_number))
09471 return -RSBAC_EINVALIDTRANSACTION;
09472 }
09473 #endif
09474
09475 /*
09476 #ifdef CONFIG_RSBAC_DEBUG
09477 if(rsbac_debug_lists)
09478 rsbac_printk(KERN_DEBUG "rsbac_list_lol_count: list %s.\n",
09479 list->name);
09480 #endif
09481 */
09482 #ifdef CONFIG_RSBAC_LIST_TRANS
09483 if(ta_number && (list->ta_copied == ta_number))
09484 return list->ta_count;
09485 else
09486 #endif
09487 return list->count;
09488 }
|
|
||||||||||||||||
|
Definition at line 9245 of file gen_lists.c. References FALSE, list_initialized, rsbac_list_lol_reg_head_t::lock, rsbac_list_lol_reg_item_t::lock, lookup_lol_item(), rsbac_list_lol_item_t::max_age, RSBAC_EINVALIDTRANSACTION, RSBAC_EINVALIDVALUE, rsbac_ta_list_exist(), rsbac_list_lol_reg_item_t::self, and TRUE. Referenced by rsbac_acl_add_group_member(), rsbac_acl_add_to_acl_entry(), rsbac_acl_set_acl_entry(), rsbac_list_lol_exist(), rsbac_pm_create_set(), rsbac_pm_exists(), rsbac_pm_remove_target(), rsbac_pm_set_exist(), rsbac_um_add_user(), rsbac_um_get_user_item(), rsbac_um_mod_user(), rsbac_um_remove_user(), and rsbac_um_user_exists(). 09249 {
09250 struct rsbac_list_lol_reg_item_t * list;
09251 u_long lock_flags, rlock_flags;
09252 struct rsbac_list_lol_item_t * item_p;
09253 int result;
09254
09255 if(!handle || !desc)
09256 return FALSE;
09257 if(!list_initialized)
09258 return FALSE;
09259
09260 list = (struct rsbac_list_lol_reg_item_t *) handle;
09261 if(list->self != list)
09262 return -RSBAC_EINVALIDVALUE;
09263
09264 #ifdef CONFIG_RSBAC_LIST_TRANS
09265 if(ta_number)
09266 {
09267 if(!rsbac_ta_list_exist(0, ta_handle, &ta_number))
09268 return -RSBAC_EINVALIDTRANSACTION;
09269 }
09270 #endif
09271
09272 rsbac_read_lock(&lol_reg_head.lock, &rlock_flags);
09273 /*
09274 #ifdef CONFIG_RSBAC_DEBUG
09275 if(rsbac_debug_lists)
09276 rsbac_printk(KERN_DEBUG "rsbac_list_lol_exist: testing on list %s.\n",
09277 list->name);
09278 #endif
09279 */
09280 rsbac_read_lock(&list->lock, &lock_flags);
09281
09282 #ifdef CONFIG_RSBAC_LIST_TRANS
09283 if(ta_number && (list->ta_copied == ta_number))
09284 item_p = ta_lookup_lol_item(ta_number, list, desc);
09285 else
09286 #endif
09287 item_p = lookup_lol_item(list, desc);
09288 if( item_p
09289 && ( !item_p->max_age
09290 || (item_p->max_age > RSBAC_CURRENT_TIME)
09291 )
09292 )
09293 { /* exists -> TRUE */
09294 result = TRUE;
09295 }
09296 else
09297 {
09298 result = FALSE;
09299 }
09300 rsbac_read_unlock(&list->lock, &lock_flags);
09301 rsbac_read_unlock(&lol_reg_head.lock, &rlock_flags);
09302 return result;
09303 }
|
|
||||||||||||||||
|
Definition at line 10156 of file gen_lists.c. References rsbac_list_lol_reg_item_t::count, rsbac_list_lol_info_t::data_size, rsbac_list_lol_info_t::desc_size, rsbac_list_lol_reg_item_t::head, rsbac_list_lol_reg_item_t::info, list_initialized, rsbac_list_lol_reg_head_t::lock, rsbac_list_lol_reg_item_t::lock, rsbac_list_lol_item_t::max_age, rsbac_list_lol_item_t::next, NULL, RSBAC_EINVALIDREQUEST, RSBAC_EINVALIDTRANSACTION, RSBAC_EINVALIDVALUE, RSBAC_ENOMEM, RSBAC_ENOTINITIALIZED, rsbac_ta_list_exist(), rsbac_vmalloc, and rsbac_list_lol_reg_item_t::self. Referenced by rsbac_list_lol_get_all_data(). 10160 {
10161 struct rsbac_list_lol_reg_item_t * list;
10162 struct rsbac_list_lol_item_t * item_p;
10163 char * buffer;
10164 u_long lock_flags, rlock_flags;
10165 u_long offset = 0;
10166 long result = 0;
10167 u_int item_size;
10168 u_int item_offset;
10169
10170 if(!handle)
10171 return -RSBAC_EINVALIDVALUE;
10172 if(!array_p)
10173 return -RSBAC_EINVALIDVALUE;
10174 if(!list_initialized)
10175 return -RSBAC_ENOTINITIALIZED;
10176
10177 list = (struct rsbac_list_lol_reg_item_t *) handle;
10178 if(list->self != list)
10179 return -RSBAC_EINVALIDVALUE;
10180 *array_p = NULL;
10181
10182 #ifdef CONFIG_RSBAC_LIST_TRANS
10183 if(ta_number)
10184 {
10185 if(!rsbac_ta_list_exist(0, ta_handle, &ta_number))
10186 return -RSBAC_EINVALIDTRANSACTION;
10187 }
10188 #endif
10189
10190 rsbac_read_lock(&lol_reg_head.lock, &rlock_flags);
10191 /*
10192 #ifdef CONFIG_RSBAC_DEBUG
10193 if(rsbac_debug_lists)
10194 rsbac_printk(KERN_DEBUG "rsbac_list_lol_get_all_desc: list %s.\n",
10195 list->name);
10196 #endif
10197 */
10198 rsbac_read_lock(&list->lock, &lock_flags);
10199 if(!list->info.data_size)
10200 {
10201 rsbac_read_unlock(&list->lock, &lock_flags);
10202 rsbac_read_unlock(&lol_reg_head.lock, &rlock_flags);
10203 return -RSBAC_EINVALIDREQUEST;
10204 }
10205 #ifdef CONFIG_RSBAC_LIST_TRANS
10206 if(ta_number && (list->ta_copied == ta_number))
10207 {
10208 if(list->ta_count)
10209 {
10210 item_size = list->info.data_size;
10211 item_offset = list->info.desc_size;
10212 buffer = rsbac_vmalloc(item_size * list->ta_count);
10213 if(buffer)
10214 {
10215 item_p = list->ta_head;
10216 while(item_p)
10217 {
10218 if( !item_p->max_age
10219 || (item_p->max_age > RSBAC_CURRENT_TIME)
10220 )
10221 {
10222 memcpy(buffer + offset,
10223 ((char *) item_p) + sizeof(*item_p) + item_offset,
10224 item_size);
10225 offset += item_size;
10226 result++;
10227 }
10228 item_p = item_p->next;
10229 }
10230 *array_p = buffer;
10231 }
10232 else
10233 {
10234 result = -RSBAC_ENOMEM;
10235 }
10236 }
10237 }
10238 else
10239 #endif
10240 if(list->count)
10241 {
10242 item_size = list->info.data_size;
10243 item_offset = list->info.desc_size;
10244 buffer = rsbac_vmalloc(item_size * list->count);
10245 if(buffer)
10246 {
10247 item_p = list->head;
10248 while(item_p)
10249 {
10250 if( !item_p->max_age
10251 || (item_p->max_age > RSBAC_CURRENT_TIME)
10252 )
10253 {
10254 memcpy(buffer + offset,
10255 ((char *) item_p) + sizeof(*item_p) + item_offset,
10256 item_size);
10257 offset += item_size;
10258 result++;
10259 }
10260 item_p = item_p->next;
10261 }
10262 *array_p = buffer;
10263 }
10264 else
10265 {
10266 result = -RSBAC_ENOMEM;
10267 }
10268 }
10269 rsbac_read_unlock(&list->lock, &lock_flags);
10270 rsbac_read_unlock(&lol_reg_head.lock, &rlock_flags);
10271 return result;
10272 }
|
|
||||||||||||||||
|
Definition at line 9795 of file gen_lists.c. References rsbac_list_lol_reg_item_t::count, rsbac_list_lol_info_t::desc_size, rsbac_list_lol_reg_item_t::head, rsbac_list_lol_reg_item_t::info, list_initialized, rsbac_list_lol_reg_head_t::lock, rsbac_list_lol_reg_item_t::lock, rsbac_list_lol_item_t::max_age, rsbac_list_lol_item_t::next, NULL, RSBAC_EINVALIDTRANSACTION, RSBAC_EINVALIDVALUE, RSBAC_ENOMEM, RSBAC_ENOTINITIALIZED, rsbac_ta_list_exist(), rsbac_vmalloc, and rsbac_list_lol_reg_item_t::self. Referenced by rsbac_acl_get_group_members(), rsbac_acl_list_all_dev(), rsbac_acl_list_all_major_dev(), rsbac_acl_list_all_user(), rsbac_list_lol_get_all_desc(), rsbac_um_get_gm_user_list(), and rsbac_um_get_user_list(). 09799 {
09800 struct rsbac_list_lol_reg_item_t * list;
09801 struct rsbac_list_lol_item_t * item_p;
09802 char * buffer;
09803 u_long lock_flags, rlock_flags;
09804 u_long offset = 0;
09805 long result = 0;
09806 u_int item_size;
09807
09808 if(!handle)
09809 return -RSBAC_EINVALIDVALUE;
09810 if(!array_p)
09811 return -RSBAC_EINVALIDVALUE;
09812 if(!list_initialized)
09813 return -RSBAC_ENOTINITIALIZED;
09814
09815 list = (struct rsbac_list_lol_reg_item_t *) handle;
09816 if(list->self != list)
09817 return -RSBAC_EINVALIDVALUE;
09818 *array_p = NULL;
09819
09820 #ifdef CONFIG_RSBAC_LIST_TRANS
09821 if(ta_number)
09822 {
09823 if(!rsbac_ta_list_exist(0, ta_handle, &ta_number))
09824 return -RSBAC_EINVALIDTRANSACTION;
09825 }
09826 #endif
09827
09828 rsbac_read_lock(&lol_reg_head.lock, &rlock_flags);
09829 /*
09830 #ifdef CONFIG_RSBAC_DEBUG
09831 if(rsbac_debug_lists)
09832 rsbac_printk(KERN_DEBUG "rsbac_list_lol_get_all_desc: list %s.\n",
09833 list->name);
09834 #endif
09835 */
09836 rsbac_read_lock(&list->lock, &lock_flags);
09837 #ifdef CONFIG_RSBAC_LIST_TRANS
09838 if(ta_number && (list->ta_copied == ta_number))
09839 {
09840 if(list->ta_count)
09841 {
09842 item_size = list->info.desc_size;
09843 buffer = rsbac_vmalloc(item_size * list->ta_count);
09844 if(buffer)
09845 {
09846 item_p = list->ta_head;
09847 while(item_p)
09848 {
09849 if( !item_p->max_age
09850 || (item_p->max_age > RSBAC_CURRENT_TIME)
09851 )
09852 {
09853 memcpy(buffer + offset,
09854 ((char *) item_p) + sizeof(*item_p),
09855 item_size);
09856 offset += item_size;
09857 result++;
09858 }
09859 item_p = item_p->next;
09860 }
09861 *array_p = buffer;
09862 }
09863 else
09864 {
09865 result = -RSBAC_ENOMEM;
09866 }
09867 }
09868 }
09869 else
09870 #endif
09871 if(list->count)
09872 {
09873 item_size = list->info.desc_size;
09874 buffer = rsbac_vmalloc(item_size * list->count);
09875 if(buffer)
09876 {
09877 item_p = list->head;
09878 while(item_p)
09879 {
09880 if( !item_p->max_age
09881 || (item_p->max_age > RSBAC_CURRENT_TIME)
09882 )
09883 {
09884 memcpy(buffer + offset,
09885 ((char *) item_p) + sizeof(*item_p),
09886 item_size);
09887 offset += item_size;
09888 result++;
09889 }
09890 item_p = item_p->next;
09891 }
09892 *array_p = buffer;
09893 }
09894 else
09895 {
09896 result = -RSBAC_ENOMEM;
09897 }
09898 }
09899 rsbac_read_unlock(&list->lock, &lock_flags);
09900 rsbac_read_unlock(&lol_reg_head.lock, &rlock_flags);
09901 return result;
09902 }
|
|
||||||||||||||||
|
Definition at line 10625 of file gen_lists.c. References rsbac_list_lol_reg_item_t::count, rsbac_list_lol_info_t::data_size, rsbac_list_lol_info_t::desc_size, rsbac_list_lol_reg_item_t::head, rsbac_list_lol_reg_item_t::info, list_initialized, rsbac_list_lol_reg_head_t::lock, rsbac_list_lol_reg_item_t::lock, rsbac_list_reg_head_t::lock, rsbac_list_lol_item_t::max_age, rsbac_list_lol_item_t::next, NULL, RSBAC_EINVALIDTRANSACTION, RSBAC_EINVALIDVALUE, RSBAC_ENOMEM, RSBAC_ENOTINITIALIZED, rsbac_ta_list_exist(), rsbac_vmalloc, and rsbac_list_lol_reg_item_t::self. Referenced by rsbac_list_lol_get_all_items(). 10629 {
10630 struct rsbac_list_lol_reg_item_t * list;
10631 struct rsbac_list_lol_item_t * item_p;
10632 char * buffer;
10633 u_long lock_flags, rlock_flags;
10634 u_long offset = 0;
10635 long result = 0;
10636 u_int item_size;
10637
10638 if(!handle)
10639 return -RSBAC_EINVALIDVALUE;
10640 if(!array_p)
10641 return -RSBAC_EINVALIDVALUE;
10642 if(!list_initialized)
10643 return -RSBAC_ENOTINITIALIZED;
10644
10645 list = (struct rsbac_list_lol_reg_item_t *) handle;
10646 if(list->self != list)
10647 return -RSBAC_EINVALIDVALUE;
10648 *array_p = NULL;
10649
10650 #ifdef CONFIG_RSBAC_LIST_TRANS
10651 if(ta_number)
10652 {
10653 if(!rsbac_ta_list_exist(0, ta_handle, &ta_number))
10654 return -RSBAC_EINVALIDTRANSACTION;
10655 }
10656 #endif
10657
10658 rsbac_read_lock(&lol_reg_head.lock, &rlock_flags);
10659 /*
10660 #ifdef CONFIG_RSBAC_DEBUG
10661 if(rsbac_debug_lists)
10662 rsbac_printk(KERN_DEBUG "rsbac_list_lol_get_all_items: list %s.\n",
10663 list->name);
10664 #endif
10665 */
10666 rsbac_read_lock(&list->lock, &lock_flags);
10667 #ifdef CONFIG_RSBAC_LIST_TRANS
10668 if(ta_number && (list->ta_copied == ta_number))
10669 {
10670 if(list->ta_count)
10671 {
10672 item_size = list->info.desc_size + list->info.data_size;
10673 buffer = rsbac_vmalloc(item_size * list->ta_count);
10674 if(buffer)
10675 {
10676 item_p = list->ta_head;
10677 while(item_p)
10678 {
10679 if( !item_p->max_age
10680 || (item_p->max_age > RSBAC_CURRENT_TIME)
10681 )
10682 {
10683 memcpy(buffer + offset,
10684 ((char *) item_p) + sizeof(*item_p),
10685 item_size);
10686 offset += item_size;
10687 result++;
10688 }
10689 item_p = item_p->next;
10690 }
10691 *array_p = buffer;
10692 }
10693 else
10694 {
10695 result = -RSBAC_ENOMEM;
10696 }
10697 }
10698 }
10699 else
10700 #endif
10701 if(list->count)
10702 {
10703 item_size = list->info.desc_size + list->info.data_size;
10704 buffer = rsbac_vmalloc(item_size * list->count);
10705 if(buffer)
10706 {
10707 item_p = list->head;
10708 while(item_p)
10709 {
10710 if( !item_p->max_age
10711 || (item_p->max_age > RSBAC_CURRENT_TIME)
10712 )
10713 {
10714 memcpy(buffer + offset,
10715 ((char *) item_p) + sizeof(*item_p),
10716 item_size);
10717 offset += item_size;
10718 result++;
10719 }
10720 item_p = item_p->next;
10721 }
10722 *array_p = buffer;
10723 }
10724 else
10725 {
10726 result = -RSBAC_ENOMEM;
10727 }
10728 }
10729 rsbac_read_unlock(&list->lock, &lock_flags);
10730 rsbac_read_unlock(®_head.lock, &rlock_flags);
10731 return result;
10732 }
|
|
||||||||||||||||||||
|
Definition at line 10051 of file gen_lists.c. References rsbac_list_lol_item_t::count, rsbac_list_lol_item_t::head, rsbac_list_lol_reg_item_t::info, list_initialized, rsbac_list_lol_reg_head_t::lock, rsbac_list_lol_reg_item_t::lock, lookup_lol_item(), rsbac_list_item_t::max_age, rsbac_list_item_t::next, NULL, RSBAC_EINVALIDREQUEST, RSBAC_EINVALIDTRANSACTION, RSBAC_EINVALIDVALUE, RSBAC_ENOMEM, RSBAC_ENOTINITIALIZED, rsbac_ta_list_exist(), rsbac_vmalloc, rsbac_list_lol_reg_item_t::self, rsbac_list_lol_info_t::subdata_size, and rsbac_list_lol_info_t::subdesc_size. Referenced by rsbac_list_lol_get_all_subdata(). 10056 {
10057 struct rsbac_list_lol_reg_item_t * list;
10058 struct rsbac_list_lol_item_t * sublist;
10059 struct rsbac_list_item_t * item_p;
10060 char * buffer;
10061 u_long lock_flags, rlock_flags;
10062 u_long offset = 0;
10063 long result = 0;
10064 u_int item_size;
10065 u_int item_offset;
10066
10067 if(!handle)
10068 return -RSBAC_EINVALIDVALUE;
10069 if(!array_p)
10070 return -RSBAC_EINVALIDVALUE;
10071 if(!list_initialized)
10072 return -RSBAC_ENOTINITIALIZED;
10073
10074 list = (struct rsbac_list_lol_reg_item_t *) handle;
10075 if(list->self != list)
10076 return -RSBAC_EINVALIDVALUE;
10077 *array_p = NULL;
10078
10079 #ifdef CONFIG_RSBAC_LIST_TRANS
10080 if(ta_number)
10081 {
10082 if(!rsbac_ta_list_exist(0, ta_handle, &ta_number))
10083 return -RSBAC_EINVALIDTRANSACTION;
10084 }
10085 #endif
10086
10087 rsbac_read_lock(&lol_reg_head.lock, &rlock_flags);
10088 /*
10089 #ifdef CONFIG_RSBAC_DEBUG
10090 if(rsbac_debug_lists)
10091 rsbac_printk(KERN_DEBUG "rsbac_ta_list_lol_get_all_desc: list %s.\n",
10092 list->name);
10093 #endif
10094 */
10095 rsbac_read_lock(&list->lock, &lock_flags);
10096 if(!list->info.subdata_size)
10097 {
10098 rsbac_read_unlock(&list->lock, &lock_flags);
10099 rsbac_read_unlock(&lol_reg_head.lock, &rlock_flags);
10100 return -RSBAC_EINVALIDREQUEST;
10101 }
10102 #ifdef CONFIG_RSBAC_LIST_TRANS
10103 if(ta_number && (list->ta_copied == ta_number))
10104 sublist = ta_lookup_lol_item(ta_number, list, desc);
10105 else
10106 #endif
10107 sublist = lookup_lol_item(list, desc);
10108 if(sublist && sublist->count)
10109 {
10110 item_size = list->info.subdata_size;
10111 item_offset = list->info.subdesc_size;
10112 buffer = rsbac_vmalloc(item_size * sublist->count);
10113 if(buffer)
10114 {
10115 item_p = sublist->head;
10116 while(item_p)
10117 {
10118 if( !item_p->max_age
10119 || (item_p->max_age > RSBAC_CURRENT_TIME)
10120 )
10121 {
10122 memcpy(buffer + offset,
10123 ((char *) item_p) + sizeof(*item_p) + item_offset,
10124 item_size);
10125 offset += item_size;
10126 result++;
10127 }
10128 item_p = item_p->next;
10129 }
10130 *array_p = buffer;
10131 }
10132 else
10133 {
10134 result = -RSBAC_ENOMEM;
10135 }
10136 }
10137 rsbac_read_unlock(&list->lock, &lock_flags);
10138 rsbac_read_unlock(&lol_reg_head.lock, &rlock_flags);
10139 return result;
10140 }
|
|
||||||||||||||||||||||||
|
Definition at line 9671 of file gen_lists.c. References rsbac_list_lol_item_t::count, rsbac_list_lol_item_t::head, rsbac_list_lol_reg_item_t::info, list_initialized, rsbac_list_lol_reg_head_t::lock, rsbac_list_lol_reg_item_t::lock, lookup_lol_item(), rsbac_list_item_t::max_age, rsbac_list_item_t::next, NULL, RSBAC_EINVALIDTRANSACTION, RSBAC_EINVALIDVALUE, RSBAC_ENOMEM, RSBAC_ENOTINITIALIZED, rsbac_ta_list_exist(), rsbac_vmalloc, rsbac_list_lol_reg_item_t::self, and rsbac_list_lol_info_t::subdesc_size. Referenced by rsbac_acl_get_user_groups(), rsbac_auth_get_f_caplist(), rsbac_auth_get_p_caplist(), rsbac_list_lol_get_all_subdesc(), rsbac_list_lol_get_all_subdesc_ttl(), rsbac_mac_get_f_trulist(), rsbac_mac_get_p_trulist(), rsbac_rc_copy_role(), rsbac_rc_get_list(), and rsbac_um_get_gm_list(). 09677 {
09678 struct rsbac_list_lol_reg_item_t * list;
09679 struct rsbac_list_lol_item_t * sublist;
09680 struct rsbac_list_item_t * item_p;
09681 char * buffer;
09682 rsbac_time_t * ttl_p = NULL;
09683 u_long lock_flags, rlock_flags;
09684 u_long offset = 0;
09685 long result = 0;
09686 u_int item_size;
09687
09688 if(!handle)
09689 return -RSBAC_EINVALIDVALUE;
09690 if(!array_p)
09691 return -RSBAC_EINVALIDVALUE;
09692 if(!list_initialized)
09693 return -RSBAC_ENOTINITIALIZED;
09694
09695 list = (struct rsbac_list_lol_reg_item_t *) handle;
09696 if(list->self != list)
09697 return -RSBAC_EINVALIDVALUE;
09698 *array_p = NULL;
09699
09700 #ifdef CONFIG_RSBAC_LIST_TRANS
09701 if(ta_number)
09702 {
09703 if(!rsbac_ta_list_exist(0, ta_handle, &ta_number))
09704 return -RSBAC_EINVALIDTRANSACTION;
09705 }
09706 #endif
09707
09708 rsbac_read_lock(&lol_reg_head.lock, &rlock_flags);
09709 /*
09710 #ifdef CONFIG_RSBAC_DEBUG
09711 if(rsbac_debug_lists)
09712 rsbac_printk(KERN_DEBUG "rsbac_list_lol_get_all_desc: list %s.\n",
09713 list->name);
09714 #endif
09715 */
09716 rsbac_read_lock(&list->lock, &lock_flags);
09717 #ifdef CONFIG_RSBAC_LIST_TRANS
09718 if(ta_number && (list->ta_copied == ta_number))
09719 sublist = ta_lookup_lol_item(ta_number, list, desc);
09720 else
09721 #endif
09722 sublist = lookup_lol_item(list, desc);
09723 if(sublist && sublist->count)
09724 {
09725 item_size = list->info.subdesc_size;
09726 buffer = rsbac_vmalloc(item_size * sublist->count);
09727 if(buffer)
09728 {
09729 if(ttl_array_p)
09730 ttl_p = rsbac_vmalloc(sizeof(**ttl_array_p) * sublist->count);
09731 item_p = sublist->head;
09732 while(item_p)
09733 {
09734 if( !item_p->max_age
09735 || (item_p->max_age > RSBAC_CURRENT_TIME)
09736 )
09737 {
09738 memcpy(buffer + offset,
09739 ((char *) item_p) + sizeof(*item_p),
09740 item_size);
09741 if(ttl_p)
09742 {
09743 if(item_p->max_age)
09744 ttl_p[result] = item_p->max_age - RSBAC_CURRENT_TIME;
09745 else
09746 ttl_p[result] = 0;
09747 }
09748 offset += item_size;
09749 result++;
09750 }
09751 item_p = item_p->next;
09752 }
09753 *array_p = buffer;
09754 if(ttl_array_p)
09755 *ttl_array_p = ttl_p;
09756 }
09757 else
09758 {
09759 result = -RSBAC_ENOMEM;
09760 }
09761 }
09762 rsbac_read_unlock(&list->lock, &lock_flags);
09763 rsbac_read_unlock(&lol_reg_head.lock, &rlock_flags);
09764 return result;
09765 }
|
|
||||||||||||||||||||||||
|
Definition at line 10504 of file gen_lists.c. References rsbac_list_lol_item_t::count, rsbac_list_lol_item_t::head, rsbac_list_lol_reg_item_t::info, list_initialized, rsbac_list_lol_reg_head_t::lock, rsbac_list_lol_reg_item_t::lock, lookup_lol_item(), rsbac_list_item_t::max_age, rsbac_list_item_t::next, NULL, RSBAC_EINVALIDTRANSACTION, RSBAC_EINVALIDVALUE, RSBAC_ENOMEM, RSBAC_ENOTINITIALIZED, rsbac_ta_list_exist(), rsbac_vmalloc, rsbac_list_lol_reg_item_t::self, rsbac_list_lol_info_t::subdata_size, and rsbac_list_lol_info_t::subdesc_size. Referenced by rsbac_acl_get_tlist(), rsbac_list_lol_get_all_subitems(), rsbac_list_lol_get_all_subitems_ttl(), and rsbac_rc_copy_role(). 10510 {
10511 struct rsbac_list_lol_reg_item_t * list;
10512 struct rsbac_list_lol_item_t * sublist;
10513 struct rsbac_list_item_t * item_p;
10514 char * buffer;
10515 rsbac_time_t * ttl_p = NULL;
10516 u_long lock_flags, rlock_flags;
10517 u_long offset = 0;
10518 long result = 0;
10519 u_int item_size;
10520
10521 if(!handle)
10522 return -RSBAC_EINVALIDVALUE;
10523 if(!array_p)
10524 return -RSBAC_EINVALIDVALUE;
10525 if(!list_initialized)
10526 return -RSBAC_ENOTINITIALIZED;
10527
10528 list = (struct rsbac_list_lol_reg_item_t *) handle;
10529 if(list->self != list)
10530 return -RSBAC_EINVALIDVALUE;
10531 *array_p = NULL;
10532
10533 #ifdef CONFIG_RSBAC_LIST_TRANS
10534 if(ta_number)
10535 {
10536 if(!rsbac_ta_list_exist(0, ta_handle, &ta_number))
10537 return -RSBAC_EINVALIDTRANSACTION;
10538 }
10539 #endif
10540
10541 rsbac_read_lock(&lol_reg_head.lock, &rlock_flags);
10542 /*
10543 #ifdef CONFIG_RSBAC_DEBUG
10544 if(rsbac_debug_lists)
10545 rsbac_printk(KERN_DEBUG "rsbac_list_lol_get_all_subitems: list %s.\n",
10546 list->name);
10547 #endif
10548 */
10549 rsbac_read_lock(&list->lock, &lock_flags);
10550 #ifdef CONFIG_RSBAC_LIST_TRANS
10551 if(ta_number && (list->ta_copied == ta_number))
10552 sublist = ta_lookup_lol_item(ta_number, list, desc);
10553 else
10554 #endif
10555 sublist = lookup_lol_item(list, desc);
10556 if(sublist && sublist->count)
10557 {
10558 item_size = list->info.subdesc_size + list->info.subdata_size;
10559 buffer = rsbac_vmalloc(item_size * sublist->count);
10560 if(buffer)
10561 {
10562 if(ttl_array_p)
10563 ttl_p = rsbac_vmalloc(sizeof(**ttl_array_p) * sublist->count);
10564 item_p = sublist->head;
10565 while(item_p)
10566 {
10567 if( !item_p->max_age
10568 || (item_p->max_age > RSBAC_CURRENT_TIME)
10569 )
10570 {
10571 memcpy(buffer + offset,
10572 ((char *) item_p) + sizeof(*item_p),
10573 item_size);
10574 if(ttl_p)
10575 {
10576 if(item_p->max_age)
10577 ttl_p[result] = item_p->max_age - RSBAC_CURRENT_TIME;
10578 else
10579 ttl_p[result] = 0;
10580 }
10581 offset += item_size;
10582 result++;
10583 }
10584 item_p = item_p->next;
10585 }
10586 *array_p = buffer;
10587 if(ttl_array_p)
10588 *ttl_array_p = ttl_p;
10589 }
10590 else
10591 {
10592 result = -RSBAC_ENOMEM;
10593 }
10594 }
10595 rsbac_read_unlock(&list->lock, &lock_flags);
10596 rsbac_read_unlock(&lol_reg_head.lock, &rlock_flags);
10597 return result;
10598 }
|
|
||||||||||||||||||||||||
|
Definition at line 8469 of file gen_lists.c. References rsbac_list_lol_info_t::data_size, rsbac_list_lol_reg_item_t::def_data, rsbac_list_lol_info_t::desc_size, rsbac_list_lol_reg_item_t::info, list_initialized, rsbac_list_lol_reg_head_t::lock, rsbac_list_lol_reg_item_t::lock, lookup_lol_item(), rsbac_list_lol_item_t::max_age, RSBAC_EINVALIDREQUEST, RSBAC_EINVALIDTRANSACTION, RSBAC_EINVALIDVALUE, RSBAC_ENOTFOUND, RSBAC_ENOTINITIALIZED, rsbac_ta_list_exist(), and rsbac_list_lol_reg_item_t::self. Referenced by rsbac_acl_get_mask(), rsbac_acl_get_rights(), rsbac_acl_get_single_right(), rsbac_acl_remove_acl_entry(), rsbac_list_lol_get_data(), rsbac_list_lol_get_data_ttl(), rsbac_um_check_account(), rsbac_um_check_pass(), rsbac_um_get_user_entry(), rsbac_um_get_user_item(), rsbac_um_mod_user(), and rsbac_um_set_pass(). 08475 {
08476 struct rsbac_list_lol_reg_item_t * list;
08477 struct rsbac_list_lol_item_t * item_p;
08478 u_long lock_flags, rlock_flags;
08479 int err = 0;
08480
08481 if(!handle || !desc)
08482 return -RSBAC_EINVALIDVALUE;
08483 if(!list_initialized)
08484 return -RSBAC_ENOTINITIALIZED;
08485
08486 list = (struct rsbac_list_lol_reg_item_t *) handle;
08487 if(list->self != list)
08488 return -RSBAC_EINVALIDVALUE;
08489
08490 #ifdef CONFIG_RSBAC_LIST_TRANS
08491 if(ta_number)
08492 {
08493 if(!rsbac_ta_list_exist(0, ta_handle, &ta_number))
08494 return -RSBAC_EINVALIDTRANSACTION;
08495 }
08496 #endif
08497
08498 rsbac_read_lock(&lol_reg_head.lock, &rlock_flags);
08499 /*
08500 #ifdef CONFIG_RSBAC_DEBUG
08501 if(rsbac_debug_lists)
08502 rsbac_printk(KERN_DEBUG "rsbac_list_lol_get_data: getting data from list %s.\n",
08503 list->name);
08504 #endif
08505 */
08506 if(data && !list->info.data_size)
08507 {
08508 rsbac_read_unlock(&lol_reg_head.lock, &rlock_flags);
08509 return -RSBAC_EINVALIDREQUEST;
08510 }
08511
08512 rsbac_read_lock(&list->lock, &lock_flags);
08513
08514 #ifdef CONFIG_RSBAC_LIST_TRANS
08515 if(ta_number && (list->ta_copied == ta_number))
08516 item_p = ta_lookup_lol_item(ta_number, list, desc);
08517 else
08518 #endif
08519 item_p = lookup_lol_item(list, desc);
08520 if( item_p
08521 && ( !item_p->max_age
08522 || (item_p->max_age > RSBAC_CURRENT_TIME)
08523 )
08524 )
08525 { /* exists -> copy data, if any */
08526 if(ttl_p)
08527 {
08528 if(item_p->max_age)
08529 *ttl_p = item_p->max_age - RSBAC_CURRENT_TIME;
08530 else
08531 *ttl_p = 0;
08532 }
08533 if(data)
08534 {
08535 memcpy(data,
08536 ((char *) item_p) + sizeof(*item_p) + list->info.desc_size,
08537 list->info.data_size);
08538 }
08539 }
08540 else
08541 {
08542 if(!list->def_data)
08543 err = -RSBAC_ENOTFOUND;
08544 else
08545 {
08546 if(ttl_p)
08547 *ttl_p = 0;
08548 if(data)
08549 memcpy(data,
08550 list->def_data,
08551 list->info.data_size);
08552 }
08553 }
08554 rsbac_read_unlock(&list->lock, &lock_flags);
08555 rsbac_read_unlock(&lol_reg_head.lock, &rlock_flags);
08556 return err;
08557 }
|
|
||||||||||||||||||||||||
|
Definition at line 8915 of file gen_lists.c. References rsbac_list_lol_info_t::data_size, rsbac_list_lol_info_t::desc_size, rsbac_list_lol_reg_item_t::info, list_initialized, rsbac_list_lol_reg_head_t::lock, rsbac_list_lol_reg_item_t::lock, lookup_lol_item_data(), RSBAC_EINVALIDREQUEST, RSBAC_EINVALIDTRANSACTION, RSBAC_EINVALIDVALUE, RSBAC_ENOTFOUND, RSBAC_ENOTINITIALIZED, rsbac_ta_list_exist(), and rsbac_list_lol_reg_item_t::self. Referenced by rsbac_list_lol_get_desc(), and rsbac_um_get_uid(). 08921 {
08922 struct rsbac_list_lol_reg_item_t * list;
08923 struct rsbac_list_lol_item_t * item_p;
08924 u_long lock_flags, rlock_flags;
08925 int err = 0;
08926
08927 if(!handle || !desc || !data)
08928 return -RSBAC_EINVALIDVALUE;
08929 if(!list_initialized)
08930 return -RSBAC_ENOTINITIALIZED;
08931
08932 list = (struct rsbac_list_lol_reg_item_t *) handle;
08933 if(list->self != list)
08934 return -RSBAC_EINVALIDVALUE;
08935
08936 #ifdef CONFIG_RSBAC_LIST_TRANS
08937 if(ta_number)
08938 {
08939 if(!rsbac_ta_list_exist(0, ta_handle, &ta_number))
08940 return -RSBAC_EINVALIDTRANSACTION;
08941 }
08942 #endif
08943
08944 rsbac_read_lock(&lol_reg_head.lock, &rlock_flags);
08945 /*
08946 #ifdef CONFIG_RSBAC_DEBUG
08947 if(rsbac_debug_lists)
08948 rsbac_printk(KERN_DEBUG "rsbac_list_lol_get_desc: getting desc from list %s.\n",
08949 list->name);
08950 #endif
08951 */
08952 if(!list->info.data_size)
08953 {
08954 rsbac_read_unlock(&lol_reg_head.lock, &rlock_flags);
08955 return -RSBAC_EINVALIDREQUEST;
08956 }
08957
08958 rsbac_read_lock(&list->lock, &lock_flags);
08959
08960 #ifdef CONFIG_RSBAC_LIST_TRANS
08961 if(ta_number && (list->ta_copied == ta_number))
08962 item_p = ta_lookup_lol_item_data(ta_number, list, data, compare);
08963 else
08964 #endif
08965 item_p = lookup_lol_item_data(list, data, compare);
08966 if(item_p)
08967 { /* exists -> copy desc */
08968 memcpy(desc,
08969 ((char *) item_p) + sizeof(*item_p),
08970 list->info.desc_size);
08971 }
08972 else
08973 {
08974 err = -RSBAC_ENOTFOUND;
08975 }
08976 rsbac_read_unlock(&list->lock, &lock_flags);
08977 rsbac_read_unlock(&lol_reg_head.lock, &rlock_flags);
08978 return err;
08979 }
|
|
||||||||||||||||||||
|
Definition at line 8738 of file gen_lists.c. References rsbac_list_lol_reg_item_t::curr, rsbac_list_lol_info_t::desc_size, rsbac_list_lol_reg_item_t::head, rsbac_list_lol_reg_item_t::info, list_initialized, rsbac_list_lol_reg_head_t::lock, rsbac_list_lol_reg_item_t::lock, lookup_lol_item(), rsbac_list_lol_item_t::max_age, rsbac_list_lol_item_t::next, RSBAC_EINVALIDPOINTER, RSBAC_EINVALIDTRANSACTION, RSBAC_EINVALIDVALUE, RSBAC_ENOTFOUND, RSBAC_ENOTINITIALIZED, rsbac_ta_list_exist(), and rsbac_list_lol_reg_item_t::self. Referenced by rsbac_list_lol_get_next_desc(), and rsbac_um_get_next_user(). 08743 {
08744 struct rsbac_list_lol_reg_item_t * list;
08745 struct rsbac_list_lol_item_t * item_p;
08746 u_long lock_flags, rlock_flags;
08747
08748 if(!handle)
08749 return -RSBAC_EINVALIDVALUE;
08750 if(!list_initialized)
08751 return -RSBAC_ENOTINITIALIZED;
08752 if(!next_desc)
08753 return -RSBAC_EINVALIDPOINTER;
08754
08755 list = (struct rsbac_list_lol_reg_item_t *) handle;
08756 if(list->self != list)
08757 return -RSBAC_EINVALIDVALUE;
08758
08759 #ifdef CONFIG_RSBAC_LIST_TRANS
08760 if(ta_number)
08761 {
08762 if(!rsbac_ta_list_exist(0, ta_handle, &ta_number))
08763 return -RSBAC_EINVALIDTRANSACTION;
08764 }
08765 #endif
08766
08767 rsbac_read_lock(&lol_reg_head.lock, &rlock_flags);
08768 /*
08769 #ifdef CONFIG_RSBAC_DEBUG
08770 if(rsbac_debug_lists)
08771 rsbac_printk(KERN_DEBUG "rsbac_list_lol_get_next_desc: list %s.\n",
08772 list->name);
08773 #endif
08774 */
08775 rsbac_read_lock(&list->lock, &lock_flags);
08776 if(old_desc)
08777 {
08778 #ifdef CONFIG_RSBAC_LIST_TRANS
08779 if(ta_number && (list->ta_copied == ta_number))
08780 item_p = ta_lookup_lol_item(ta_number, list, old_desc);
08781 else
08782 #endif
08783 item_p = lookup_lol_item(list, old_desc);
08784 if(item_p)
08785 item_p = item_p->next;
08786 }
08787 else
08788 #ifdef CONFIG_RSBAC_LIST_TRANS
08789 if(ta_number && (list->ta_copied == ta_number))
08790 item_p = list->ta_head;
08791 else
08792 #endif
08793 item_p = list->head;
08794 while( item_p
08795 && item_p->max_age
08796 && (item_p->max_age > RSBAC_CURRENT_TIME)
08797 )
08798 item_p = item_p->next;
08799 if(item_p)
08800 {
08801 memcpy(next_desc, (char *)item_p + sizeof(*item_p), list->info.desc_size);
08802 list->curr = item_p;
08803 }
08804 rsbac_read_unlock(&list->lock, &lock_flags);
08805 rsbac_read_unlock(&lol_reg_head.lock, &rlock_flags);
08806 if(item_p)
08807 return 0;
08808 else
08809 return -RSBAC_ENOTFOUND;
08810 }
|
|
||||||||||||||||||||||||||||
|
Definition at line 8330 of file gen_lists.c. References rsbac_list_lol_reg_item_t::def_subdata, rsbac_list_lol_reg_item_t::info, list_initialized, rsbac_list_lol_reg_head_t::lock, rsbac_list_lol_reg_item_t::lock, lookup_lol_item(), lookup_lol_subitem(), rsbac_list_item_t::max_age, RSBAC_EINVALIDREQUEST, RSBAC_EINVALIDTRANSACTION, RSBAC_EINVALIDVALUE, RSBAC_ENOTFOUND, RSBAC_ENOTINITIALIZED, rsbac_ta_list_exist(), rsbac_list_lol_reg_item_t::self, rsbac_list_lol_info_t::subdata_size, and rsbac_list_lol_info_t::subdesc_size. Referenced by rsbac_acl_add_to_acl_entry(), rsbac_acl_get_group_members(), rsbac_acl_get_rights(), rsbac_acl_get_single_right(), rsbac_acl_remove_from_acl_entry(), rsbac_list_lol_get_subdata(), rsbac_list_lol_get_subdata_ttl(), rsbac_rc_copy_type(), and rsbac_rc_get_item(). 08337 {
08338 struct rsbac_list_lol_reg_item_t * list;
08339 struct rsbac_list_lol_item_t * sublist;
08340 struct rsbac_list_item_t * item_p;
08341 u_long lock_flags, rlock_flags;
08342 int err = 0;
08343
08344 if(!handle || !desc || !subdesc)
08345 return -RSBAC_EINVALIDVALUE;
08346 if(!list_initialized)
08347 return -RSBAC_ENOTINITIALIZED;
08348
08349 list = (struct rsbac_list_lol_reg_item_t *) handle;
08350 if(list->self != list)
08351 return -RSBAC_EINVALIDVALUE;
08352
08353 #ifdef CONFIG_RSBAC_LIST_TRANS
08354 if(ta_number)
08355 {
08356 if(!rsbac_ta_list_exist(0, ta_handle, &ta_number))
08357 return -RSBAC_EINVALIDTRANSACTION;
08358 }
08359 #endif
08360
08361 rsbac_read_lock(&lol_reg_head.lock, &rlock_flags);
08362 /*
08363 #ifdef CONFIG_RSBAC_DEBUG
08364 if(rsbac_debug_lists)
08365 rsbac_printk(KERN_DEBUG "rsbac_list_lol_get_subdata: getting data from list %s.\n",
08366 list->name);
08367 #endif
08368 */
08369 if(subdata && !list->info.subdata_size)
08370 {
08371 rsbac_read_unlock(&lol_reg_head.lock, &rlock_flags);
08372 return -RSBAC_EINVALIDREQUEST;
08373 }
08374
08375 rsbac_read_lock(&list->lock, &lock_flags);
08376
08377 #ifdef CONFIG_RSBAC_LIST_TRANS
08378 if(ta_number && (list->ta_copied == ta_number))
08379 sublist = ta_lookup_lol_item(ta_number, list, desc);
08380 else
08381 #endif
08382 sublist = lookup_lol_item(list, desc);
08383 if(sublist)
08384 { /* exists -> lookup subitem */
08385 item_p = lookup_lol_subitem(list, sublist, subdesc);
08386 if( item_p
08387 && ( !item_p->max_age
08388 || (item_p->max_age > RSBAC_CURRENT_TIME)
08389 )
08390 )
08391 { /* exists -> copy data, if any */
08392 if(ttl_p)
08393 {
08394 if(item_p->max_age)
08395 *ttl_p = item_p->max_age - RSBAC_CURRENT_TIME;
08396 else
08397 *ttl_p = 0;
08398 }
08399 if(subdata)
08400 {
08401 memcpy(subdata,
08402 ((char *) item_p) + sizeof(*item_p) + list->info.subdesc_size,
08403 list->info.subdata_size);
08404 }
08405 }
08406 else
08407 {
08408 if(!list->def_subdata)
08409 err = -RSBAC_ENOTFOUND;
08410 else
08411 {
08412 if(ttl_p)
08413 *ttl_p = 0;
08414 if(subdata)
08415 memcpy(subdata,
08416 list->def_subdata,
08417 list->info.subdata_size);
08418 }
08419 }
08420 }
08421 else
08422 {
08423 if(!list->def_subdata)
08424 err = -RSBAC_ENOTFOUND;
08425 else
08426 {
08427 if(ttl_p)
08428 *ttl_p = 0;
08429 if(subdata)
08430 memcpy(subdata,
08431 list->def_subdata,
08432 list->info.subdata_size);
08433 }
08434 }
08435 rsbac_read_unlock(&list->lock, &lock_flags);
08436 rsbac_read_unlock(&lol_reg_head.lock, &rlock_flags);
08437 return err;
08438 }
|
|
||||||||||||||||
|
Definition at line 8032 of file gen_lists.c. References rsbac_list_lol_reg_item_t::dirty, list_initialized, rsbac_list_lol_reg_head_t::lock, rsbac_list_lol_reg_item_t::lock, lol_touch, lookup_lol_item(), remove_lol_item(), RSBAC_EBUSY, RSBAC_EINVALIDTRANSACTION, RSBAC_EINVALIDVALUE, RSBAC_ENOTINITIALIZED, rsbac_ta_list_exist(), rsbac_list_lol_reg_item_t::self, and TRUE. Referenced by rsbac_acl_remove_acl(), rsbac_acl_remove_acl_entry(), rsbac_acl_remove_group_member(), rsbac_acl_remove_user(), rsbac_auth_clear_f_capset(), rsbac_auth_clear_p_capset(), rsbac_list_lol_remove(), rsbac_mac_clear_f_truset(), rsbac_mac_clear_p_truset(), rsbac_pm_exists(), rsbac_pm_remove_set(), rsbac_pm_remove_target(), rsbac_rc_copy_role(), rsbac_rc_set_item(), and rsbac_um_remove_user(). 08036 {
08037 struct rsbac_list_lol_reg_item_t * list;
08038 u_long lock_flags, rlock_flags;
08039
08040 if(!handle || !desc)
08041 return -RSBAC_EINVALIDVALUE;
08042 if(!list_initialized)
08043 return -RSBAC_ENOTINITIALIZED;
08044
08045 list = (struct rsbac_list_lol_reg_item_t *) handle;
08046 if(list->self != list)
08047 return -RSBAC_EINVALIDVALUE;
08048
08049 #ifdef CONFIG_RSBAC_LIST_TRANS
08050 if(ta_number)
08051 {
08052 if(!rsbac_ta_list_exist(0, ta_handle, &ta_number))
08053 return -RSBAC_EINVALIDTRANSACTION;
08054 }
08055 #endif
08056
08057 rsbac_read_lock(&lol_reg_head.lock, &rlock_flags);
08058 /*
08059 #ifdef CONFIG_RSBAC_DEBUG
08060 if(rsbac_debug_lists)
08061 rsbac_printk(KERN_DEBUG "rsbac_list_lol_remove: removing from list of lists %s.\n",
08062 list->name);
08063 #endif
08064 */
08065 rsbac_write_lock(&list->lock, &lock_flags);
08066 #ifdef CONFIG_RSBAC_LIST_TRANS
08067 if(list->ta_copied)
08068 {
08069 if(ta_number)
08070 {
08071 if(ta_lookup_lol_item(list->ta_copied, list, desc))
08072 {
08073 if(list->ta_copied != ta_number)
08074 {
08075 rsbac_write_unlock(&list->lock, &lock_flags);
08076 rsbac_read_unlock(&lol_reg_head.lock, &rlock_flags);
08077 return -RSBAC_EBUSY;
08078 }
08079 else
08080 ta_remove_lol_item(ta_number, list, desc);
08081 }
08082 }
08083 else
08084 ta_remove_lol_item(list->ta_copied, list, desc);
08085 }
08086 else
08087 {
08088 if(ta_number && lookup_lol_item(list, desc))
08089 {
08090 ta_lol_copy(ta_number, list);
08091 ta_remove_lol_item(ta_number, list, desc);
08092 }
08093 }
08094 if(!ta_number)
08095 #endif
08096 {
08097 if(lookup_lol_item(list, desc))
08098 { /* exists -> remove */
08099 remove_lol_item(list, desc);
08100 lol_touch(list);
08101 list->dirty = TRUE;
08102 }
08103 }
08104 rsbac_write_unlock(&list->lock, &lock_flags);
08105 rsbac_read_unlock(&lol_reg_head.lock, &rlock_flags);
08106 return 0;
08107 }
|
|
||||||||||||
|
Definition at line 8123 of file gen_lists.c. References rsbac_list_lol_reg_item_t::dirty, rsbac_list_lol_reg_item_t::head, list_initialized, rsbac_list_lol_reg_head_t::lock, rsbac_list_lol_reg_item_t::lock, lol_touch, NULL, remove_all_lol_items(), RSBAC_EBUSY, RSBAC_EINVALIDTRANSACTION, RSBAC_EINVALIDVALUE, RSBAC_ENOTINITIALIZED, rsbac_ta_list_exist(), rsbac_list_lol_reg_item_t::self, and TRUE. Referenced by rsbac_list_lol_remove_all(). 08124 {
08125 struct rsbac_list_lol_reg_item_t * list;
08126 u_long lock_flags, rlock_flags;
08127
08128 if(!handle)
08129 return -RSBAC_EINVALIDVALUE;
08130 if(!list_initialized)
08131 return -RSBAC_ENOTINITIALIZED;
08132
08133 list = (struct rsbac_list_lol_reg_item_t *) handle;
08134 if(list->self != list)
08135 return -RSBAC_EINVALIDVALUE;
08136
08137 #ifdef CONFIG_RSBAC_LIST_TRANS
08138 if(ta_number)
08139 {
08140 if(!rsbac_ta_list_exist(0, ta_handle, &ta_number))
08141 return -RSBAC_EINVALIDTRANSACTION;
08142 }
08143 #endif
08144
08145 rsbac_read_lock(&lol_reg_head.lock, &rlock_flags);
08146 /*
08147 #ifdef CONFIG_RSBAC_DEBUG
08148 if(rsbac_debug_lists)
08149 rsbac_printk(KERN_DEBUG "rsbac_list_lol_remove_all: removing all items from list of lists %s.\n",
08150 list->name);
08151 #endif
08152 */
08153 rsbac_write_lock(&list->lock, &lock_flags);
08154 #ifdef CONFIG_RSBAC_LIST_TRANS
08155 if(list->ta_copied)
08156 {
08157 if(ta_number)
08158 {
08159 if(list->ta_copied == ta_number)
08160 {
08161 ta_remove_all_lol_items(list);
08162 if(!list->head)
08163 {
08164 list->ta_copied = 0;
08165 }
08166 }
08167 else
08168 {
08169 rsbac_write_unlock(&list->lock, &lock_flags);
08170 rsbac_read_unlock(&lol_reg_head.lock, &rlock_flags);
08171 return -RSBAC_EBUSY;
08172 }
08173 }
08174 else
08175 ta_remove_all_lol_items(list);
08176 }
08177 else
08178 {
08179 if(ta_number)
08180 {
08181 if(list->head)
08182 {
08183 list->ta_head = NULL;
08184 list->ta_tail = NULL;
08185 list->ta_curr = NULL;
08186 list->ta_count = 0;
08187 list->ta_copied = ta_number;
08188 }
08189 }
08190 }
08191
08192 if(!ta_number)
08193 #endif
08194 if(list->head)
08195 {
08196 remove_all_lol_items(list);
08197 lol_touch(list);
08198 list->dirty = TRUE;
08199 }
08200 rsbac_write_unlock(&list->lock, &lock_flags);
08201 rsbac_read_unlock(&lol_reg_head.lock, &rlock_flags);
08202 return 0;
08203 }
|
|
||||||||||||||||||||||||||||
|
Definition at line 7114 of file gen_lists.c. References add_lol_item(), add_lol_subitem(), rsbac_list_lol_reg_item_t::def_data, rsbac_list_lol_reg_item_t::def_subdata, rsbac_list_lol_reg_item_t::dirty, do_remove_lol_subitem(), rsbac_list_lol_reg_item_t::flags, rsbac_list_lol_reg_item_t::info, list_initialized, rsbac_list_lol_reg_head_t::lock, rsbac_list_lol_reg_item_t::lock, lol_touch, lookup_lol_item(), lookup_lol_subitem(), rsbac_list_lol_item_t::max_age, rsbac_list_item_t::max_age, remove_lol_item(), RSBAC_EBUSY, RSBAC_EINVALIDTARGET, RSBAC_EINVALIDTRANSACTION, RSBAC_EINVALIDVALUE, RSBAC_ENOTINITIALIZED, RSBAC_LIST_DEF_DATA, RSBAC_LIST_MAX_AGE_LIMIT, RSBAC_LIST_TTL_KEEP, rsbac_ta_list_exist(), rsbac_list_lol_reg_item_t::self, rsbac_list_lol_info_t::subdata_size, rsbac_list_lol_info_t::subdesc_size, and TRUE. Referenced by rsbac_acl_add_group_member(), rsbac_acl_add_to_acl_entry(), rsbac_acl_remove_from_acl_entry(), rsbac_acl_set_acl_entry(), rsbac_auth_add_to_f_capset(), rsbac_auth_add_to_p_capset(), rsbac_list_lol_subadd(), rsbac_list_lol_subadd_ttl(), rsbac_mac_add_to_f_truset(), rsbac_mac_add_to_p_truset(), rsbac_pm_add_to_set(), rsbac_rc_copy_role(), rsbac_rc_copy_type(), rsbac_rc_set_item(), and rsbac_um_add_gm(). 07121 {
07122 struct rsbac_list_lol_reg_item_t * list;
07123 struct rsbac_list_lol_item_t * sublist;
07124 struct rsbac_list_item_t * item_p;
07125 u_long lock_flags, rlock_flags;
07126 int err = 0;
07127
07128 if(!handle || !desc || !subdesc)
07129 return -RSBAC_EINVALIDVALUE;
07130 if(!list_initialized)
07131 return -RSBAC_ENOTINITIALIZED;
07132
07133 list = (struct rsbac_list_lol_reg_item_t *) handle;
07134 if(!list || (list->self != list))
07135 return -RSBAC_EINVALIDVALUE;
07136
07137 #ifdef CONFIG_RSBAC_LIST_TRANS
07138 if(ta_number && !rsbac_ta_list_exist(0, ta_handle, &ta_number))
07139 return -RSBAC_EINVALIDTRANSACTION;
07140 #endif
07141
07142 rsbac_read_lock(&lol_reg_head.lock, &rlock_flags);
07143 if(list->info.subdata_size && !subdata)
07144 {
07145 rsbac_read_unlock(&lol_reg_head.lock, &rlock_flags);
07146 return -RSBAC_EINVALIDVALUE;
07147 }
07148
07149 /*
07150 #ifdef CONFIG_RSBAC_DEBUG
07151 if(rsbac_debug_lists)
07152 rsbac_printk(KERN_DEBUG "rsbac_list_lol_subadd: adding to list %s.\n",
07153 list->name);
07154 #endif
07155 */
07156 rsbac_write_lock(&list->lock, &lock_flags);
07157
07158 #ifdef CONFIG_RSBAC_LIST_TRANS
07159 if(!ta_number)
07160 #endif
07161 {
07162 sublist = lookup_lol_item(list, desc);
07163 if( !sublist
07164 && (list->flags & RSBAC_LIST_DEF_DATA)
07165 )
07166 sublist = add_lol_item(list, 0, desc, list->def_data);
07167 if(sublist)
07168 {
07169 if( sublist->max_age
07170 && (sublist->max_age <= RSBAC_CURRENT_TIME)
07171 )
07172 {
07173 remove_lol_item(list, desc);
07174 err = -RSBAC_EINVALIDTARGET;
07175 }
07176 else
07177 {
07178 /* exists -> lookup subitem */
07179 if(ttl && (ttl != RSBAC_LIST_TTL_KEEP))
07180 {
07181 if(ttl > RSBAC_LIST_MAX_AGE_LIMIT)
07182 ttl = RSBAC_LIST_MAX_AGE_LIMIT;
07183 ttl += RSBAC_CURRENT_TIME;
07184 }
07185 item_p = lookup_lol_subitem(list, sublist, subdesc);
07186 if(item_p)
07187 { /* exists -> update data, if any */
07188 if(ttl != RSBAC_LIST_TTL_KEEP)
07189 item_p->max_age = ttl;
07190 if(subdata && list->info.subdata_size)
07191 {
07192 if( list->def_subdata
07193 && !item_p->max_age
07194 && !memcmp(list->def_subdata, subdata, list->info.subdata_size)
07195 )
07196 do_remove_lol_subitem(sublist, item_p);
07197 else
07198 memcpy(((char *) item_p) + sizeof(*item_p) + list->info.subdesc_size,
07199 subdata,
07200 list->info.subdata_size);
07201 }
07202 }
07203 else
07204 {
07205 if(ttl == RSBAC_LIST_TTL_KEEP)
07206 ttl = 0;
07207 if( !list->def_subdata
07208 || memcmp(list->def_subdata, subdata, list->info.subdata_size)
07209 )
07210 add_lol_subitem(list, sublist, ttl, subdesc, subdata);
07211 }
07212 lol_touch(list);
07213 list->dirty = TRUE;
07214 }
07215 }
07216 else
07217 {
07218 err = -RSBAC_EINVALIDTARGET;
07219 goto out_unlock;
07220 }
07221 }
07222 #ifdef CONFIG_RSBAC_LIST_TRANS
07223 if(list->ta_copied || ta_number)
07224 {
07225 if(!list->ta_copied)
07226 {
07227 if((err = ta_lol_copy(ta_number,list)))
07228 goto out_unlock;
07229 }
07230 else
07231 if(ta_number)
07232 {
07233 if(list->ta_copied != ta_number)
07234 {
07235 err = -RSBAC_EBUSY;
07236 goto out_unlock;
07237 }
07238 }
07239 else
07240 ta_number = list->ta_copied;
07241 sublist = ta_lookup_lol_item(ta_number, list, desc);
07242 if( !sublist
07243 && (list->flags & RSBAC_LIST_DEF_DATA)
07244 )
07245 sublist = ta_add_lol_item(ta_number, list, 0, desc, list->def_data);
07246 if(sublist)
07247 {
07248 if( sublist->max_age
07249 && (sublist->max_age <= RSBAC_CURRENT_TIME)
07250 )
07251 {
07252 ta_remove_lol_item(ta_number, list, desc);
07253 err = -RSBAC_EINVALIDTARGET;
07254 }
07255 else
07256 {
07257 /* exists -> lookup subitem */
07258 if(ttl && (ttl != RSBAC_LIST_TTL_KEEP))
07259 {
07260 if(ttl > RSBAC_LIST_MAX_AGE_LIMIT)
07261 ttl = RSBAC_LIST_MAX_AGE_LIMIT;
07262 ttl += RSBAC_CURRENT_TIME;
07263 }
07264 item_p = lookup_lol_subitem(list, sublist, subdesc);
07265 if(item_p)
07266 { /* exists -> update data, if any */
07267 if(ttl != RSBAC_LIST_TTL_KEEP)
07268 item_p->max_age = ttl;
07269 if(subdata && list->info.subdata_size)
07270 {
07271 if( list->def_subdata
07272 && !item_p->max_age
07273 && !memcmp(list->def_subdata, subdata, list->info.subdata_size)
07274 )
07275 do_remove_lol_subitem(sublist, item_p);
07276 else
07277 memcpy(((char *) item_p) + sizeof(*item_p) + list->info.subdesc_size,
07278 subdata,
07279 list->info.subdata_size);
07280 }
07281 }
07282 else
07283 {
07284 if(ttl == RSBAC_LIST_TTL_KEEP)
07285 ttl = 0;
07286 if( !list->def_subdata
07287 || memcmp(list->def_subdata, subdata, list->info.subdata_size)
07288 )
07289 add_lol_subitem(list, sublist, ttl, subdesc, subdata);
07290 }
07291 }
07292 }
07293 else
07294 {
07295 err = -RSBAC_EINVALIDTARGET;
07296 }
07297 }
07298 #endif
07299
07300 out_unlock:
07301 rsbac_write_unlock(&list->lock, &lock_flags);
07302 rsbac_read_unlock(&lol_reg_head.lock, &rlock_flags);
07303 return err;
07304 }
|
|
||||||||||||||||
|
Definition at line 9320 of file gen_lists.c. References rsbac_list_lol_item_t::count, list_initialized, rsbac_list_lol_reg_head_t::lock, rsbac_list_lol_reg_item_t::lock, lookup_lol_item(), RSBAC_EINVALIDTRANSACTION, RSBAC_EINVALIDVALUE, RSBAC_ENOTFOUND, RSBAC_ENOTINITIALIZED, rsbac_ta_list_exist(), and rsbac_list_lol_reg_item_t::self. Referenced by rsbac_acl_remove_acl_entry(), rsbac_acl_remove_group_member(), rsbac_list_lol_subcount(), rsbac_rc_get_list(), and rsbac_um_get_gm_list(). 09324 {
09325 struct rsbac_list_lol_reg_item_t * list;
09326 struct rsbac_list_lol_item_t * sublist;
09327 u_long lock_flags, rlock_flags;
09328 long result;
09329
09330 if(!handle)
09331 return -RSBAC_EINVALIDVALUE;
09332 if(!list_initialized)
09333 return -RSBAC_ENOTINITIALIZED;
09334
09335 list = (struct rsbac_list_lol_reg_item_t *) handle;
09336 if(list->self != list)
09337 return -RSBAC_EINVALIDVALUE;
09338
09339 #ifdef CONFIG_RSBAC_LIST_TRANS
09340 if(ta_number)
09341 {
09342 if(!rsbac_ta_list_exist(0, ta_handle, &ta_number))
09343 return -RSBAC_EINVALIDTRANSACTION;
09344 }
09345 #endif
09346
09347 rsbac_read_lock(&lol_reg_head.lock, &rlock_flags);
09348 /*
09349 #ifdef CONFIG_RSBAC_DEBUG
09350 if(rsbac_debug_lists)
09351 rsbac_printk(KERN_DEBUG "rsbac_list_lol_subcount: list %s.\n",
09352 list->name);
09353 #endif
09354 */
09355 rsbac_read_lock(&list->lock, &lock_flags);
09356
09357 #ifdef CONFIG_RSBAC_LIST_TRANS
09358 if(ta_number && (list->ta_copied == ta_number))
09359 sublist = ta_lookup_lol_item(ta_number, list, desc);
09360 else
09361 #endif
09362 sublist = lookup_lol_item(list, desc);
09363 if(sublist)
09364 {
09365 result = sublist->count;
09366 }
09367 else
09368 {
09369 result = -RSBAC_ENOTFOUND;
09370 }
09371 rsbac_read_unlock(&list->lock, &lock_flags);
09372 rsbac_read_unlock(&lol_reg_head.lock, &rlock_flags);
09373 return result;
09374 }
|
|
||||||||||||||||||||
|
Definition at line 9071 of file gen_lists.c. References FALSE, list_initialized, rsbac_list_lol_reg_head_t::lock, rsbac_list_lol_reg_item_t::lock, lookup_lol_item(), lookup_lol_subitem(), rsbac_list_item_t::max_age, RSBAC_EINVALIDTRANSACTION, RSBAC_EINVALIDVALUE, rsbac_ta_list_exist(), rsbac_list_lol_reg_item_t::self, and TRUE. Referenced by rsbac_acl_group_member(), rsbac_list_lol_subexist(), rsbac_pm_set_member(), and rsbac_um_get_gm_user_list(). 09076 {
09077 struct rsbac_list_lol_reg_item_t * list;
09078 struct rsbac_list_lol_item_t * sublist;
09079 u_long lock_flags, rlock_flags;
09080 struct rsbac_list_item_t * item_p;
09081 int result;
09082
09083 if(!handle || !desc || !subdesc)
09084 return FALSE;
09085 if(!list_initialized)
09086 return FALSE;
09087
09088 list = (struct rsbac_list_lol_reg_item_t *) handle;
09089 if(list->self != list)
09090 return -RSBAC_EINVALIDVALUE;
09091
09092 #ifdef CONFIG_RSBAC_LIST_TRANS
09093 if(ta_number)
09094 {
09095 if(!rsbac_ta_list_exist(0, ta_handle, &ta_number))
09096 return -RSBAC_EINVALIDTRANSACTION;
09097 }
09098 #endif
09099
09100 rsbac_read_lock(&lol_reg_head.lock, &rlock_flags);
09101 /*
09102 #ifdef CONFIG_RSBAC_DEBUG
09103 if(rsbac_debug_lists)
09104 rsbac_printk(KERN_DEBUG "rsbac_list_lol_subexist: testing on list %s.\n",
09105 list->name);
09106 #endif
09107 */
09108 rsbac_read_lock(&list->lock, &lock_flags);
09109
09110 #ifdef CONFIG_RSBAC_LIST_TRANS
09111 if(ta_number && (list->ta_copied == ta_number))
09112 sublist = ta_lookup_lol_item(ta_number, list, desc);
09113 else
09114 #endif
09115 sublist = lookup_lol_item(list, desc);
09116 if(sublist)
09117 { /* exists -> lookup subitem */
09118 item_p = lookup_lol_subitem(list, sublist, subdesc);
09119 if( item_p
09120 && ( !item_p->max_age
09121 || (item_p->max_age > RSBAC_CURRENT_TIME)
09122 )
09123 )
09124 { /* exists -> TRUE */
09125 result = TRUE;
09126 }
09127 else
09128 {
09129 result = FALSE;
09130 }
09131 }
09132 else
09133 {
09134 result = FALSE;
09135 }
09136 rsbac_read_unlock(&list->lock, &lock_flags);
09137 rsbac_read_unlock(&lol_reg_head.lock, &rlock_flags);
09138 return result;
09139 }
|
|
||||||||||||||||||||||||
|
Definition at line 9155 of file gen_lists.c. References FALSE, list_initialized, rsbac_list_lol_reg_head_t::lock, rsbac_list_lol_reg_item_t::lock, lookup_lol_item(), lookup_lol_subitem_user_compare(), rsbac_list_item_t::max_age, RSBAC_EINVALIDTRANSACTION, RSBAC_EINVALIDVALUE, rsbac_list_lol_subexist(), rsbac_ta_list_exist(), rsbac_list_lol_reg_item_t::self, and TRUE. Referenced by rsbac_list_lol_subexist_compare(). 09161 {
09162 struct rsbac_list_lol_reg_item_t * list;
09163 struct rsbac_list_lol_item_t * sublist;
09164 u_long lock_flags, rlock_flags;
09165 struct rsbac_list_item_t * item_p;
09166 int result;
09167
09168 if(!handle || !desc || !subdesc)
09169 return FALSE;
09170 if(!list_initialized)
09171 return FALSE;
09172 /* Use standard function, if compare is not provided. */
09173 if(!compare)
09174 return rsbac_list_lol_subexist(handle, desc, subdesc);
09175
09176 list = (struct rsbac_list_lol_reg_item_t *) handle;
09177 if(list->self != list)
09178 return -RSBAC_EINVALIDVALUE;
09179
09180 #ifdef CONFIG_RSBAC_LIST_TRANS
09181 if(ta_number)
09182 {
09183 if(!rsbac_ta_list_exist(0, ta_handle, &ta_number))
09184 return -RSBAC_EINVALIDTRANSACTION;
09185 }
09186 #endif
09187
09188 rsbac_read_lock(&lol_reg_head.lock, &rlock_flags);
09189 /*
09190 #ifdef CONFIG_RSBAC_DEBUG
09191 if(rsbac_debug_lists)
09192 rsbac_printk(KERN_DEBUG "rsbac_list_lol_subexist_compare: testing on list %s.\n",
09193 list->name);
09194 #endif
09195 */
09196 rsbac_read_lock(&list->lock, &lock_flags);
09197
09198 #ifdef CONFIG_RSBAC_LIST_TRANS
09199 if(ta_number && (list->ta_copied == ta_number))
09200 sublist = ta_lookup_lol_item(ta_number, list, desc);
09201 else
09202 #endif
09203 sublist = lookup_lol_item(list, desc);
09204 if(sublist)
09205 { /* exists -> lookup subitem */
09206 item_p = lookup_lol_subitem_user_compare(list, sublist, subdesc, compare);
09207 if( item_p
09208 && ( !item_p->max_age
09209 || (item_p->max_age > RSBAC_CURRENT_TIME)
09210 )
09211 )
09212 { /* exists -> TRUE */
09213 result = TRUE;
09214 }
09215 else
09216 {
09217 result = FALSE;
09218 }
09219 }
09220 else
09221 {
09222 result = FALSE;
09223 }
09224 rsbac_read_unlock(&list->lock, &lock_flags);
09225 rsbac_read_unlock(&lol_reg_head.lock, &rlock_flags);
09226 return result;
09227 }
|
|
||||||||||||||||||||
|
Definition at line 7680 of file gen_lists.c. References rsbac_list_lol_item_t::count, rsbac_list_lol_info_t::data_size, rsbac_list_lol_reg_item_t::def_data, rsbac_list_lol_info_t::desc_size, rsbac_list_lol_reg_item_t::dirty, do_remove_lol_item(), rsbac_list_lol_reg_item_t::flags, rsbac_list_lol_reg_item_t::info, list_initialized, rsbac_list_lol_reg_head_t::lock, rsbac_list_lol_reg_item_t::lock, lol_touch, lookup_lol_item(), lookup_lol_subitem(), rsbac_list_lol_item_t::max_age, remove_lol_subitem(), RSBAC_EBUSY, RSBAC_EINVALIDTRANSACTION, RSBAC_EINVALIDVALUE, RSBAC_ENOTINITIALIZED, RSBAC_LIST_DEF_DATA, rsbac_ta_list_exist(), rsbac_list_lol_reg_item_t::self, and TRUE. Referenced by rsbac_acl_remove_acl_entry(), rsbac_acl_remove_group_member(), rsbac_auth_remove_from_f_capset(), rsbac_auth_remove_from_p_capset(), rsbac_list_lol_subremove(), rsbac_mac_remove_from_f_truset(), rsbac_mac_remove_from_p_truset(), rsbac_pm_remove_from_set(), rsbac_rc_set_item(), and rsbac_um_remove_gm(). 07685 {
07686 struct rsbac_list_lol_reg_item_t * list;
07687 struct rsbac_list_lol_item_t * sublist;
07688 u_long lock_flags, rlock_flags;
07689
07690 if(!handle || !desc || !subdesc)
07691 return -RSBAC_EINVALIDVALUE;
07692 if(!list_initialized)
07693 return -RSBAC_ENOTINITIALIZED;
07694
07695 list = (struct rsbac_list_lol_reg_item_t *) handle;
07696 if(list->self != list)
07697 return -RSBAC_EINVALIDVALUE;
07698
07699 #ifdef CONFIG_RSBAC_LIST_TRANS
07700 if(ta_number)
07701 {
07702 if(!rsbac_ta_list_exist(0, ta_handle, &ta_number))
07703 return -RSBAC_EINVALIDTRANSACTION;
07704 }
07705 #endif
07706
07707 rsbac_read_lock(&lol_reg_head.lock, &rlock_flags);
07708 /*
07709 #ifdef CONFIG_RSBAC_DEBUG
07710 if(rsbac_debug_lists)
07711 rsbac_printk(KERN_DEBUG "rsbac_ta_list_lol_subremove: removing from list of lists %s, device %02u:%02u.\n",
07712 list->name,
07713 RSBAC_MAJOR(list->device), RSBAC_MINOR(list->device));
07714 #endif
07715 */
07716 rsbac_write_lock(&list->lock, &lock_flags);
07717 #ifdef CONFIG_RSBAC_LIST_TRANS
07718 if(list->ta_copied)
07719 {
07720 sublist = ta_lookup_lol_item(list->ta_copied, list, desc);
07721 if(sublist)
07722 {
07723 if( sublist->max_age
07724 && (sublist->max_age <= RSBAC_CURRENT_TIME)
07725 )
07726 {
07727 ta_do_remove_lol_item(list, sublist);
07728 }
07729 else
07730 {
07731 if(ta_number && (list->ta_copied != ta_number))
07732 {
07733 rsbac_write_unlock(&list->lock, &lock_flags);
07734 rsbac_read_unlock(&lol_reg_head.lock, &rlock_flags);
07735 return -RSBAC_EBUSY;
07736 }
07737 if(lookup_lol_subitem(list, sublist, subdesc))
07738 remove_lol_subitem(list, sublist, subdesc);
07739 if( !sublist->count
07740 && ( ( list->def_data
07741 && !memcmp(((char *) sublist) + sizeof(*sublist) + list->info.desc_size,
07742 list->def_data,
07743 list->info.data_size)
07744 )
07745 || ( !list->info.data_size
07746 && (list->flags & RSBAC_LIST_DEF_DATA)
07747 )
07748 )
07749 )
07750 {
07751 ta_do_remove_lol_item(list, sublist);
07752 }
07753 }
07754 }
07755 }
07756 else
07757 {
07758 if(ta_number && lookup_lol_item(list, desc))
07759 {
07760 ta_lol_copy(ta_number, list);
07761 ta_remove_lol_item(ta_number, list, desc);
07762 }
07763 }
07764 if(!ta_number)
07765 #endif
07766 {
07767 sublist = lookup_lol_item(list, desc);
07768 if(sublist)
07769 {
07770 if( sublist->max_age
07771 && (sublist->max_age <= RSBAC_CURRENT_TIME)
07772 )
07773 {
07774 do_remove_lol_item(list, sublist);
07775 lol_touch(list);
07776 list->dirty = TRUE;
07777 }
07778 else
07779 {
07780 if(lookup_lol_subitem(list, sublist, subdesc))
07781 { /* exists -> remove and set dirty */
07782 remove_lol_subitem(list, sublist, subdesc);
07783 lol_touch(list);
07784 list->dirty = TRUE;
07785 }
07786 if( !sublist->count
07787 && ( ( list->def_data
07788 && !memcmp(((char *) sublist) + sizeof(*sublist) + list->info.desc_size,
07789 list->def_data,
07790 list->info.data_size)
07791 )
07792 || ( !list->info.data_size
07793 && (list->flags & RSBAC_LIST_DEF_DATA)
07794 )
07795 )
07796 )
07797 {
07798 do_remove_lol_item(list, sublist);
07799 lol_touch(list);
07800 list->dirty = TRUE;
07801 }
07802 }
07803 }
07804 }
07805 rsbac_write_unlock(&list->lock, &lock_flags);
07806 rsbac_read_unlock(&lol_reg_head.lock, &rlock_flags);
07807 return 0;
07808 }
|
|
||||||||||||||||
|
Definition at line 7923 of file gen_lists.c. References rsbac_list_lol_info_t::data_size, rsbac_list_lol_reg_item_t::def_data, rsbac_list_lol_info_t::desc_size, rsbac_list_lol_reg_item_t::dirty, rsbac_list_lol_reg_item_t::flags, rsbac_list_lol_item_t::head, rsbac_list_lol_reg_item_t::info, list_initialized, rsbac_list_lol_reg_head_t::lock, rsbac_list_lol_reg_item_t::lock, lol_touch, lookup_lol_item(), rsbac_list_lol_item_t::max_age, remove_all_lol_subitems(), RSBAC_EBUSY, RSBAC_EINVALIDTRANSACTION, RSBAC_EINVALIDVALUE, RSBAC_ENOTINITIALIZED, RSBAC_LIST_DEF_DATA, rsbac_ta_list_exist(), rsbac_list_lol_reg_item_t::self, and TRUE. Referenced by rsbac_list_lol_subremove_all(), and rsbac_pm_clear_set(). 07927 {
07928 struct rsbac_list_lol_reg_item_t * list;
07929 struct rsbac_list_lol_item_t * sublist;
07930 u_long lock_flags, rlock_flags;
07931
07932 if(!handle)
07933 return -RSBAC_EINVALIDVALUE;
07934 if(!list_initialized)
07935 return -RSBAC_ENOTINITIALIZED;
07936
07937 list = (struct rsbac_list_lol_reg_item_t *) handle;
07938 if(list->self != list)
07939 return -RSBAC_EINVALIDVALUE;
07940
07941 #ifdef CONFIG_RSBAC_LIST_TRANS
07942 if(ta_number)
07943 {
07944 if(!rsbac_ta_list_exist(0, ta_handle, &ta_number))
07945 return -RSBAC_EINVALIDTRANSACTION;
07946 }
07947 #endif
07948
07949 rsbac_read_lock(&lol_reg_head.lock, &rlock_flags);
07950 /*
07951 #ifdef CONFIG_RSBAC_DEBUG
07952 if(rsbac_debug_lists)
07953 rsbac_printk(KERN_DEBUG "rsbac_list_lol_subremove_all: removing all subitems from list of lists %s.\n",
07954 list->name);
07955 #endif
07956 */
07957 rsbac_write_lock(&list->lock, &lock_flags);
07958 #ifdef CONFIG_RSBAC_LIST_TRANS
07959 if(list->ta_copied)
07960 {
07961 sublist = ta_lookup_lol_item(list->ta_copied, list, desc);
07962 if(sublist)
07963 {
07964 if( sublist->max_age
07965 && (sublist->max_age <= RSBAC_CURRENT_TIME)
07966 )
07967 {
07968 ta_do_remove_lol_item(list, sublist);
07969 }
07970 else
07971 {
07972 if(ta_number && (list->ta_copied != ta_number))
07973 {
07974 rsbac_write_unlock(&list->lock, &lock_flags);
07975 rsbac_read_unlock(&lol_reg_head.lock, &rlock_flags);
07976 return -RSBAC_EBUSY;
07977 }
07978 remove_all_lol_subitems(sublist);
07979 if( ( list->def_data
07980 && !memcmp(((char *) sublist) + sizeof(*sublist) + list->info.desc_size,
07981 list->def_data,
07982 list->info.data_size)
07983 )
07984 || ( !list->info.data_size
07985 && (list->flags & RSBAC_LIST_DEF_DATA)
07986 )
07987
07988 )
07989 {
07990 ta_do_remove_lol_item(list, sublist);
07991 }
07992 }
07993 }
07994 }
07995 else
07996 {
07997 if(ta_number && lookup_lol_item(list, desc))
07998 {
07999 ta_lol_copy(ta_number, list);
08000 sublist = ta_lookup_lol_item(ta_number, list, desc);
08001 if(sublist)
08002 remove_all_lol_subitems(sublist);
08003 }
08004 }
08005 if(!ta_number)
08006 #endif
08007 {
08008 sublist = lookup_lol_item(list, desc);
08009 if(sublist && sublist->head)
08010 {
08011 remove_all_lol_subitems(sublist);
08012 lol_touch(list);
08013 list->dirty = TRUE;
08014 }
08015 }
08016 rsbac_write_unlock(&list->lock, &lock_flags);
08017 rsbac_read_unlock(&lol_reg_head.lock, &rlock_flags);
08018 return 0;
08019 }
|
|
||||||||||||||||
|
Definition at line 7825 of file gen_lists.c. References rsbac_list_lol_reg_item_t::dirty, rsbac_list_lol_reg_item_t::head, list_initialized, rsbac_list_lol_reg_head_t::lock, rsbac_list_lol_reg_item_t::lock, lol_touch, lookup_lol_subitem(), rsbac_list_lol_item_t::next, remove_lol_subitem(), RSBAC_EBUSY, RSBAC_EINVALIDTRANSACTION, RSBAC_EINVALIDVALUE, RSBAC_ENOTINITIALIZED, rsbac_ta_list_exist(), rsbac_list_lol_reg_item_t::self, and TRUE. Referenced by rsbac_acl_remove_group(), rsbac_acl_remove_subject(), rsbac_acl_remove_user(), rsbac_list_lol_subremove_from_all(), rsbac_rc_copy_type(), rsbac_rc_set_item(), and rsbac_um_remove_group(). 07829 {
07830 struct rsbac_list_lol_reg_item_t * list;
07831 struct rsbac_list_lol_item_t * sublist;
07832 u_long lock_flags, rlock_flags;
07833
07834 if(!handle || !subdesc)
07835 return -RSBAC_EINVALIDVALUE;
07836 if(!list_initialized)
07837 return -RSBAC_ENOTINITIALIZED;
07838
07839 list = (struct rsbac_list_lol_reg_item_t *) handle;
07840 if(list->self != list)
07841 return -RSBAC_EINVALIDVALUE;
07842
07843 #ifdef CONFIG_RSBAC_LIST_TRANS
07844 if(ta_number)
07845 {
07846 if(!rsbac_ta_list_exist(0, ta_handle, &ta_number))
07847 return -RSBAC_EINVALIDTRANSACTION;
07848 }
07849 #endif
07850
07851 rsbac_read_lock(&lol_reg_head.lock, &rlock_flags);
07852 /*
07853 #ifdef CONFIG_RSBAC_DEBUG
07854 if(rsbac_debug_lists)
07855 rsbac_printk(KERN_DEBUG "rsbac_list_lol_subremove_from_all: removing from list of lists %s.\n",
07856 list->name);
07857 #endif
07858 */
07859 rsbac_write_lock(&list->lock, &lock_flags);
07860 #ifdef CONFIG_RSBAC_LIST_TRANS
07861 if(list->ta_copied)
07862 {
07863 if(ta_number && (list->ta_copied != ta_number))
07864 {
07865 rsbac_write_unlock(&list->lock, &lock_flags);
07866 rsbac_read_unlock(&lol_reg_head.lock, &rlock_flags);
07867 return -RSBAC_EBUSY;
07868 }
07869 sublist = list->head;
07870 while(sublist)
07871 {
07872 remove_lol_subitem(list, sublist, subdesc);
07873 sublist = sublist->next;
07874 }
07875 }
07876 else
07877 {
07878 if(ta_number)
07879 {
07880 ta_lol_copy(ta_number, list);
07881 sublist = list->head;
07882 while(sublist)
07883 {
07884 remove_lol_subitem(list, sublist, subdesc);
07885 sublist = sublist->next;
07886 }
07887 }
07888 }
07889 if(!ta_number)
07890 #endif
07891 {
07892 sublist = list->head;
07893 while(sublist)
07894 {
07895 if(lookup_lol_subitem(list, sublist, subdesc))
07896 { /* exists -> remove and set dirty */
07897 remove_lol_subitem(list, sublist, subdesc);
07898 lol_touch(list);
07899 list->dirty = TRUE;
07900 }
07901 sublist = sublist->next;
07902 }
07903 }
07904 rsbac_write_unlock(&list->lock, &lock_flags);
07905 rsbac_read_unlock(&lol_reg_head.lock, &rlock_flags);
07906 return 0;
07907 }
|
|
||||||||||||||||
|
Definition at line 7496 of file gen_lists.c. References rsbac_list_reg_item_t::dirty, list_initialized, rsbac_list_reg_head_t::lock, rsbac_list_reg_item_t::lock, lookup_item(), remove_item(), RSBAC_EBUSY, RSBAC_EINVALIDTRANSACTION, RSBAC_EINVALIDVALUE, RSBAC_ENOTINITIALIZED, rsbac_ta_list_exist(), rsbac_list_reg_item_t::self, touch, and TRUE. Referenced by rsbac_acl_remove_acl_entry(), rsbac_acl_remove_group(), rsbac_acl_remove_subject(), rsbac_acl_remove_user(), rsbac_list_remove(), rsbac_pm_exists(), rsbac_pm_remove_target(), rsbac_rc_set_item(), rsbac_ta_remove_target(), rsbac_um_remove_group(), set_attr_fd(), and set_attr_user(). 07500 {
07501 struct rsbac_list_reg_item_t * list;
07502 u_long lock_flags, rlock_flags;
07503
07504 if(!handle || !desc)
07505 return -RSBAC_EINVALIDVALUE;
07506 if(!list_initialized)
07507 return -RSBAC_ENOTINITIALIZED;
07508
07509 list = (struct rsbac_list_reg_item_t *) handle;
07510 if(!list || (list->self != list))
07511 return -RSBAC_EINVALIDVALUE;
07512
07513 #ifdef CONFIG_RSBAC_LIST_TRANS
07514 if(ta_number)
07515 {
07516 if(!rsbac_ta_list_exist(0, ta_handle, &ta_number))
07517 return -RSBAC_EINVALIDTRANSACTION;
07518 }
07519 #endif
07520
07521 rsbac_read_lock(®_head.lock, &rlock_flags);
07522 /*
07523 #ifdef CONFIG_RSBAC_DEBUG
07524 if(rsbac_debug_lists)
07525 rsbac_printk(KERN_DEBUG "rsbac_list_ta_remove: removing from list %s.\n",
07526 list->name);
07527 #endif
07528 */
07529 rsbac_write_lock(&list->lock, &lock_flags);
07530 #ifdef CONFIG_RSBAC_LIST_TRANS
07531 if(list->ta_copied)
07532 {
07533 if(ta_number)
07534 {
07535 if(ta_lookup_item(list->ta_copied, list, desc))
07536 {
07537 if(list->ta_copied != ta_number)
07538 {
07539 rsbac_write_unlock(&list->lock, &lock_flags);
07540 rsbac_read_unlock(®_head.lock, &rlock_flags);
07541 return -RSBAC_EBUSY;
07542 }
07543 else
07544 ta_remove_item(ta_number, list, desc);
07545 }
07546 }
07547 else
07548 ta_remove_item(list->ta_copied, list, desc);
07549 }
07550 else
07551 {
07552 if(ta_number && lookup_item(list, desc))
07553 {
07554 ta_copy(ta_number, list);
07555 ta_remove_item(ta_number, list, desc);
07556 }
07557 }
07558 if(!ta_number)
07559 #endif
07560 {
07561 if(lookup_item(list, desc))
07562 { /* exists -> remove */
07563 remove_item(list, desc);
07564 touch(list);
07565 list->dirty = TRUE;
07566 }
07567 }
07568 rsbac_write_unlock(&list->lock, &lock_flags);
07569 rsbac_read_unlock(®_head.lock, &rlock_flags);
07570 return 0;
07571 }
|
|
||||||||||||
|
Definition at line 7587 of file gen_lists.c. References rsbac_list_reg_item_t::dirty, rsbac_list_reg_item_t::head, list_initialized, rsbac_list_reg_head_t::lock, rsbac_list_reg_item_t::lock, NULL, remove_all_items(), RSBAC_EBUSY, RSBAC_EINVALIDTRANSACTION, RSBAC_EINVALIDVALUE, RSBAC_ENOTINITIALIZED, rsbac_ta_list_exist(), rsbac_list_reg_item_t::self, touch, and TRUE. Referenced by rsbac_list_remove_all(). 07588 {
07589 struct rsbac_list_reg_item_t * list;
07590 u_long lock_flags, rlock_flags;
07591
07592 if(!handle)
07593 return -RSBAC_EINVALIDVALUE;
07594 if(!list_initialized)
07595 return -RSBAC_ENOTINITIALIZED;
07596
07597 list = (struct rsbac_list_reg_item_t *) handle;
07598 if(list->self != list)
07599 return -RSBAC_EINVALIDVALUE;
07600
07601 #ifdef CONFIG_RSBAC_LIST_TRANS
07602 if(ta_number)
07603 {
07604 if(!rsbac_ta_list_exist(0, ta_handle, &ta_number))
07605 return -RSBAC_EINVALIDTRANSACTION;
07606 }
07607 #endif
07608
07609 rsbac_read_lock(®_head.lock, &rlock_flags);
07610 /*
07611 #ifdef CONFIG_RSBAC_DEBUG
07612 if(rsbac_debug_lists)
07613 rsbac_printk(KERN_DEBUG "rsbac_ta_list_remove_all: removing all items from list %s.\n",
07614 list->name);
07615 #endif
07616 */
07617 rsbac_write_lock(&list->lock, &lock_flags);
07618 #ifdef CONFIG_RSBAC_LIST_TRANS
07619 if(list->ta_copied)
07620 {
07621 if(ta_number)
07622 {
07623 if(list->ta_copied == ta_number)
07624 {
07625 ta_remove_all_items(list);
07626 if(!list->head)
07627 {
07628 list->ta_copied = 0;
07629 }
07630 }
07631 else
07632 {
07633 rsbac_write_unlock(&list->lock, &lock_flags);
07634 rsbac_read_unlock(®_head.lock, &rlock_flags);
07635 return -RSBAC_EBUSY;
07636 }
07637 }
07638 else
07639 ta_remove_all_items(list);
07640 }
07641 else
07642 {
07643 if(ta_number)
07644 {
07645 if(list->head)
07646 {
07647 list->ta_head = NULL;
07648 list->ta_tail = NULL;
07649 list->ta_curr = NULL;
07650 list->ta_count = 0;
07651 list->ta_copied = ta_number;
07652 }
07653 }
07654 }
07655
07656 if(!ta_number)
07657 #endif
07658 if(list->head)
07659 {
07660 remove_all_items(list);
07661 touch(list);
07662 list->dirty = TRUE;
07663 }
07664 rsbac_write_unlock(&list->lock, &lock_flags);
07665 rsbac_read_unlock(®_head.lock, &rlock_flags);
07666 return 0;
07667 }
|
|
|
|
Definition at line 33 of file gen_lists.c. |
|
|
Definition at line 32 of file gen_lists.c. |
1.4.2