NSAPI_PUBLIC int
ACL_ExprAddArg( NSErr_t *errp,
ACLExprHandle_t *expr,
const char *arg )
{
if ( expr == NULL )
return(ACLERRUNDEF);
if (expr->expr_argv == NULL)
expr->expr_argv = (char **) PERM_MALLOC( 2 * sizeof(char *) );
else
expr->expr_argv = (char **) PERM_REALLOC( expr->expr_argv,
(expr->expr_argc+2)
* sizeof(char *) );
if (expr->expr_argv == NULL)
return(ACLERRNOMEM);
expr->expr_argv[expr->expr_argc] = PERM_STRDUP( arg );
if (expr->expr_argv[expr->expr_argc] == NULL)
return(ACLERRNOMEM);
expr->expr_argc++;
expr->expr_argv[expr->expr_argc] = NULL;
return(0);
}
NSAPI_PUBLIC void *INTsession_set_thread_data(Session *sn, int slot, void *data)
{
SessionThreadData *thread_data = find_thread_data(sn);
if (!thread_data)
return NULL;
// Grow the slots[] array if necessary
if (slot >= thread_data->count) {
int count = slot + 1;
void **slots = (void **)PERM_REALLOC(thread_data->slots,
sizeof(thread_data->slots[0]) * count);
if (!slots)
return data;
for (int i = thread_data->count; i < count; i++) {
slots[i] = NULL;
}
thread_data->slots = slots;
thread_data->count = count;
}
void *old = thread_data->slots[slot];
thread_data->slots[slot] = data;
return old;
}
NSAPI_PUBLIC int
ACL_ExprOr( NSErr_t *errp, ACLExprHandle_t *acl_expr )
{
int idx;
int ii;
int expr_one = ACL_FALSE_IDX;
int expr_two = ACL_FALSE_IDX;
ACLExprRaw_t *raw_expr;
if ( acl_expr == NULL )
return(ACLERRUNDEF);
if ( acl_expr->expr_raw_index >= acl_expr->expr_raw_size ) {
acl_expr->expr_raw = ( ACLExprRaw_t *)
PERM_REALLOC ( acl_expr->expr_raw,
(acl_expr->expr_raw_size + ACL_TERM_BSIZE)
* sizeof(ACLExprRaw_t) );
if ( acl_expr->expr_raw == NULL )
return(ACLERRNOMEM);
acl_expr->expr_raw_size += ACL_TERM_BSIZE;
}
raw_expr = &acl_expr->expr_raw[acl_expr->expr_raw_index];
acl_expr->expr_raw_index++;
raw_expr->logical = ACL_EXPR_OP_OR;
raw_expr->attr_name = NULL;
/* Find the last two expressions */
idx = acl_expr->expr_term_index - 1;
for ( ii = idx; ii >= 0; ii-- ) {
if ( acl_expr->expr_arry[ii].start_flag ) {
if ( expr_two == ACL_FALSE_IDX )
expr_two = ii;
else if ( expr_one == ACL_FALSE_IDX ) {
expr_one = ii;
break;
}
}
}
#ifdef DEBUG_LEVEL_2
printf("or, index=%d, first expr=%d, second expr=%d\n", idx, expr_one, expr_two);
#endif
for ( ii = expr_one; ii < expr_two; ii++) {
if ( acl_expr->expr_arry[ii].true_idx == ACL_FALSE_IDX )
acl_expr->expr_arry[ii].true_idx = expr_two;
if ( acl_expr->expr_arry[ii].false_idx == ACL_FALSE_IDX )
acl_expr->expr_arry[ii].false_idx = expr_two;
}
acl_expr->expr_arry[expr_two].start_flag = 0;
return(0);
}
/*
* Gets a name list of consisting of all ACL names for input list.
*
* Input:
* acl_list an ACL List handle
* name_list pointer to a list of string pointers
* Returns:
* 0 success
* < 0 failure
*/
NSAPI_PUBLIC int
ACL_ListGetNameList(NSErr_t *errp, ACLListHandle_t *acl_list, char ***name_list)
{
const int block_size = 50;
ACLWrapper_t *wrapper;
int list_index;
int list_size;
char **tmp_list;
char **local_list;
const char *name;
if ( acl_list == NULL )
return(ACLERRUNDEF);
list_size = block_size;
local_list = (char **) PERM_MALLOC(sizeof(char *) * list_size);
if ( local_list == NULL )
return(ACLERRNOMEM);
list_index = 0;
local_list[list_index] = NULL;
for ( wrapper = acl_list->acl_list_head; wrapper != NULL;
wrapper = wrapper->wrap_next ) {
if ( wrapper->acl->tag )
name = wrapper->acl->tag;
else
name = "noname";
if ( list_index + 2 > list_size ) {
list_size += block_size;
tmp_list = (char **) PERM_REALLOC(local_list,
sizeof(char *) * list_size);
if ( tmp_list == NULL ) {
ACL_NameListDestroy(errp, local_list);
return(ACLERRNOMEM);
}
local_list = tmp_list;
}
local_list[list_index] = PERM_STRDUP(name);
if ( local_list[list_index] == NULL ) {
ACL_NameListDestroy(errp, local_list);
return(ACLERRNOMEM);
}
list_index++;
local_list[list_index] = NULL;
}
*name_list = local_list;
return(0);
}
NSAPI_PUBLIC int INTnet_buffer_input(SYS_NETFD sd, int sz)
{
NetLayer *nl = _netlayer_find(sd);
if (nl) {
if (sz > nl->maxsize) {
void *inbuf = PERM_REALLOC(nl->inbuf, sz);
if (!inbuf)
return -1;
nl->inbuf = (char *) inbuf;
}
nl->maxsize = sz;
return 0;
}
nl = (NetLayer *) PERM_MALLOC(sizeof(NetLayer));
if (!nl)
return -1;
nl->pos = 0;
nl->cursize = 0;
nl->maxsize = sz;
nl->inbuf = (char *) PERM_MALLOC(sz);
if (!nl->inbuf) {
PERM_FREE(nl);
return -1;
}
PRFileDesc *layer = PR_CreateIOLayerStub(_netlayer_identity, &_netlayer_methods);
if (!layer) {
PERM_FREE(nl->inbuf);
PERM_FREE(nl);
return -1;
}
layer->secret = (PRFilePrivate *) nl;
PRStatus rv = PR_PushIOLayer(sd, PR_NSPR_IO_LAYER, layer);
if (rv != PR_SUCCESS) {
PR_Close(layer);
return -1;
}
return 0;
}
NSAPI_PUBLIC int session_alloc_thread_slot(SlotDestructorFuncPtr destructor)
{
PR_CallOnce(&_session_thread_once, &session_thread_init);
PR_Lock(_session_thread_lock);
int slot = _session_thread_slots;
_session_thread_slots++;
_session_thread_destructors = (SlotDestructorFuncPtr*)
PERM_REALLOC(_session_thread_destructors,
sizeof(_session_thread_destructors[0]) *
_session_thread_slots);
_session_thread_destructors[slot] = destructor;
PR_Unlock(_session_thread_lock);
return slot;
}
NSAPI_PUBLIC int
ACL_ExprNot( NSErr_t *errp, ACLExprHandle_t *acl_expr )
{
int idx;
int ii;
int expr_one = 0;
ACLExprRaw_t *raw_expr;
if ( acl_expr == NULL )
return(ACLERRUNDEF);
if ( acl_expr->expr_raw_index >= acl_expr->expr_raw_size ) {
acl_expr->expr_raw = ( ACLExprRaw_t *)
PERM_REALLOC ( acl_expr->expr_raw,
(acl_expr->expr_raw_size + ACL_TERM_BSIZE)
* sizeof(ACLExprRaw_t));
if ( acl_expr->expr_raw == NULL )
return(ACLERRNOMEM);
acl_expr->expr_raw_size += ACL_TERM_BSIZE;
}
raw_expr = &acl_expr->expr_raw[acl_expr->expr_raw_index];
acl_expr->expr_raw_index++;
raw_expr->logical = ACL_EXPR_OP_NOT;
raw_expr->attr_name = NULL;
/* Find the last expression */
idx = acl_expr->expr_term_index - 1;
for ( ii = idx; ii >= 0; ii-- ) {
if ( acl_expr->expr_arry[ii].start_flag ) {
expr_one = ii;
break;
}
}
#ifdef DEBUG_LEVEL_2
printf("not, start index=%d\n", expr_one);
#endif
/*
* The intent here is negate the last expression by
* modifying the true and false links.
*/
for ( ii = expr_one; ii < acl_expr->expr_term_index; ii++ ) {
if ( acl_expr->expr_arry[ii].true_idx == ACL_TRUE_IDX )
acl_expr->expr_arry[ii].true_idx = ACL_FALSE_IDX;
else if ( acl_expr->expr_arry[ii].true_idx == ACL_FALSE_IDX )
acl_expr->expr_arry[ii].true_idx = ACL_TRUE_IDX;
if ( acl_expr->expr_arry[ii].false_idx == ACL_TRUE_IDX )
acl_expr->expr_arry[ii].false_idx = ACL_FALSE_IDX;
else if ( acl_expr->expr_arry[ii].false_idx == ACL_FALSE_IDX )
acl_expr->expr_arry[ii].false_idx = ACL_TRUE_IDX;
}
return(0) ;
}
NSAPI_PUBLIC int
ACL_ExprTerm( NSErr_t *errp, ACLExprHandle_t *acl_expr,
const char *attr_name,
CmpOp_t cmp,
char *attr_pattern )
{
ACLExprEntry_t *expr;
ACLExprRaw_t *raw_expr;
if ( acl_expr == NULL || acl_expr->expr_arry == NULL )
return(ACLERRUNDEF);
if ( acl_expr->expr_term_index >= acl_expr->expr_arry_size ) {
acl_expr->expr_arry = ( ACLExprEntry_t *)
PERM_REALLOC ( acl_expr->expr_arry,
(acl_expr->expr_arry_size + ACL_TERM_BSIZE)
* sizeof(ACLExprEntry_t));
if ( acl_expr->expr_arry == NULL )
return(ACLERRNOMEM);
acl_expr->expr_arry_size += ACL_TERM_BSIZE;
}
expr = &acl_expr->expr_arry[acl_expr->expr_term_index];
acl_expr->expr_term_index++;
expr->attr_name = PERM_STRDUP(attr_name);
if ( expr->attr_name == NULL )
return(ACLERRNOMEM);
expr->comparator = cmp;
expr->attr_pattern = PERM_STRDUP(attr_pattern);
if ( expr->attr_pattern == NULL )
return(ACLERRNOMEM);
expr->true_idx = ACL_TRUE_IDX;
expr->false_idx = ACL_FALSE_IDX;
expr->start_flag = 1;
expr->las_cookie = 0;
expr->las_eval_func = 0;
if ( acl_expr->expr_raw_index >= acl_expr->expr_raw_size ) {
acl_expr->expr_raw = ( ACLExprRaw_t *)
PERM_REALLOC ( acl_expr->expr_raw,
(acl_expr->expr_raw_size + ACL_TERM_BSIZE)
* sizeof(ACLExprRaw_t));
if ( acl_expr->expr_raw == NULL )
return(ACLERRNOMEM);
acl_expr->expr_raw_size += ACL_TERM_BSIZE;
}
raw_expr = &acl_expr->expr_raw[acl_expr->expr_raw_index];
acl_expr->expr_raw_index++;
raw_expr->attr_name = expr->attr_name;
raw_expr->comparator = cmp;
raw_expr->attr_pattern = expr->attr_pattern;
raw_expr->logical = (ACLExprOp_t)0;
#ifdef DEBUG_LEVEL_2
printf ( "%d: %s %s %s, t=%d, f=%d\n",
acl_expr->expr_term_index - 1,
expr->attr_name,
acl_comp_string( expr->comparator ),
expr->attr_pattern,
expr->true_idx,
expr->false_idx );
#endif
return(0);
}
