// : vi ts=4 sw=4 noet :
/*
==================================================================================
- Copyright (c) 2019 Nokia
- Copyright (c) 2018-2019 AT&T Intellectual Property.
+ Copyright (c) 2019-2020 Nokia
+ Copyright (c) 2018-2020 AT&T Intellectual Property.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
incorporated into the RIC msg routing library and will be
available to user applications.
+ There is NO logging from this module! The caller is asusmed to
+ report any failures as it might handle them making any error messages
+ generated here misleading if not incorrect.
+
Date: 11 Feb 2000
Author: E. Scott Daniels
------------------------------------------------------------------------------
*/
+#include <errno.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <memory.h>
#include <netdb.h>
+#include <pthread.h>
#include "rmr_symtab.h"
{
const char *p;
long t = 0;
- unsigned long tt = 0;
- unsigned long x = 79;
for( p = n; *p; p++ ) /* a bit of magic */
t = (t * 79 ) + *p;
return (int ) (t % size);
}
-/* delete element pointed to by eptr at hash loc hv */
+/*
+ Delete element pointed to by eptr which is assumed to be
+ a member of the list at symtab[i].
+*/
static void del_ele( Sym_tab *table, int hv, Sym_ele *eptr )
{
Sym_ele **sym_tab;
}
}
+/*
+ Delete the head element from table[i]. This isn't really
+ needed, but keeps code analysers from claiming that memory
+ is being used after it is freed.
+*/
+static void del_head_ele( Sym_tab *table, int hv ) {
+ Sym_ele **sym_tab;
+ Sym_ele *eptr; // first in list
+
+
+ if( hv < 0 || hv >= table->size ) {
+ return;
+ }
+
+ sym_tab = table->symlist;
+ if( (eptr = sym_tab[hv]) != NULL ) // not an empty element; yank it off
+ {
+ if( (sym_tab[hv] = eptr->next) != NULL ) { // bump list to next if not the only thing here
+ sym_tab[hv]->prev = NULL; // new head
+ }
+ eptr->next = NULL; // take no chances
+
+ if( eptr->class && eptr->name ) { // class 0 entries are numeric, so name is NOT a pointer
+ free( (void *) eptr->name );
+ }
+
+ free( eptr );
+
+ table->deaths++;
+ table->inhabitants--;
+ }
+}
+
/*
Determine if these are the same.
*/
much the same.
*/
static int putin( Sym_tab *table, const char *name, unsigned int class, void *val ) {
- Sym_ele *eptr; /* pointer into hash table */
- Sym_ele **sym_tab; /* pointer into hash table */
+ Sym_ele *eptr; /* pointer into hash table */
+ Sym_ele **sym_tab; /* pointer into hash table */
int hv; /* hash value */
int rc = 0; /* assume it existed */
uint64_t nkey = 0; // numeric key if class == 0
for( eptr=sym_tab[hv]; eptr && eptr->nkey != nkey; eptr=eptr->next );
}
- if( ! eptr ) { // not found above, so add
+ if( ! eptr ) { // not found above, so add
rc++;
table->inhabitants++;
eptr = (Sym_ele *) malloc( sizeof( Sym_ele) );
if( ! eptr ) {
- fprintf( stderr, "[FAIL] symtab/putin: out of memory\n" );
+ errno = ENOMEM;
return -1;
}
table = (Sym_tab *) vtable;
sym_tab = table->symlist;
- for( i = 0; i < table->size; i++ )
- while( sym_tab[i] )
- del_ele( table, i, sym_tab[i] );
+ for( i = 0; i < table->size; i++ ) {
+ while( sym_tab[i] ) {
+ del_head_ele( table, i ); // delete the head element (and keep bloody sonar from claiming use after free)
+ }
+ }
}
/*
table = (Sym_tab *) vtable;
sym_tab = table->symlist;
- for( i = 0; i < table->size; i++ )
- {
- if( sym_tab[i] )
- for( eptr = sym_tab[i]; eptr; eptr = eptr->next )
- {
- if( eptr->val && eptr->class ) {
- fprintf( stderr, "key=%s val@=%p\n", eptr->name, eptr->val );
- } else {
- fprintf( stderr, "nkey=%lu val@=%p\n", (unsigned long) eptr->nkey, eptr->val );
+ for( i = 0; i < table->size; i++ ) {
+ if( sym_tab[i] ) {
+ for( eptr = sym_tab[i]; eptr; eptr = eptr->next ) {
+ if( eptr->val && eptr->class ) {
+ fprintf( stderr, "symtab dump: key=%s val@=%p\n", eptr->name, eptr->val );
+ } else {
+ fprintf( stderr, "symtab dump: nkey=%lu val@=%p\n", (unsigned long) eptr->nkey, eptr->val );
+ }
}
}
}
*/
extern void *rmr_sym_alloc( int size )
{
- int i;
Sym_tab *table;
if( size < 11 ) /* provide a bit of sanity */
if( (table = (Sym_tab *) malloc( sizeof( Sym_tab ))) == NULL )
{
- fprintf( stderr, "rmr_sym_alloc: unable to get memory for symtable (%d elements)", size );
+ errno = ENOMEM;
return NULL;
}
}
else
{
- fprintf( stderr, "sym_alloc: unable to get memory for %d elements", size );
+ errno = ENOMEM;
return NULL;
}
/*
Delete element by numberic key.
*/
-extern void *rmr_sym_ndel( void *vtable, uint64_t key ) {
+extern void rmr_sym_ndel( void *vtable, uint64_t key ) {
rmr_sym_del( vtable, (const char *) &key, 0 );
}
int hv; // hash value of key
uint64_t nkey; // numeric key if class 0
- table = (Sym_tab *) vtable;
+ if( (table = (Sym_tab *) vtable) == NULL ) {
+ return NULL;
+ }
+
sym_tab = table->symlist;
if( class ) {
ch_count++;
if( level > 3 ) {
if( eptr->class ) { // a string key
- fprintf( stderr, "sym: (%d) key=%s val@=%p ref=%ld mod=%lu\n", i, eptr->name, eptr->val, eptr->rcount, eptr->mcount );
+ fprintf( stderr, " symtab stats: sym: (%d) key=%s val@=%p ref=%ld mod=%lu\n", i, eptr->name, eptr->val, eptr->rcount, eptr->mcount );
} else {
- fprintf( stderr, "sym: (%d) key=%lu val@=%p ref=%ld mod=%lu\n", i, (unsigned long) eptr->nkey, eptr->val, eptr->rcount, eptr->mcount );
+ fprintf( stderr, "symtab stats: sym: (%d) key=%lu val@=%p ref=%ld mod=%lu\n", i, (unsigned long) eptr->nkey, eptr->val, eptr->rcount, eptr->mcount );
}
}
}
twoper++;
if( level > 2 )
- fprintf( stderr, "sym: (%d) chained=%ld\n", i, ch_count );
+ fprintf( stderr, "symtab stats: sym: (%d) chained=%ld\n", i, ch_count );
}
if( level > 1 )
{
- fprintf( stderr, "sym: longest chain: idx=%d has %ld elsements):\n", maxi, max_chain );
+ fprintf( stderr, "symtab stats: sym: longest chain: idx=%d has %ld elsements):\n", maxi, max_chain );
for( eptr = sym_tab[maxi]; eptr; eptr = eptr->next ) {
if( eptr->class ) {
fprintf( stderr, "\t%s\n", eptr->name );
}
}
- fprintf( stderr, "sym:%ld(size) %ld(inhab) %ld(occupied) %ld(dead) %ld(maxch) %d(>2per)\n",
+ fprintf( stderr, "symtab stats: sym:%ld(size) %ld(inhab) %ld(occupied) %ld(dead) %ld(maxch) %d(>2per)\n",
table->size, table->inhabitants, table->size - empty, table->deaths, max_chain, twoper );
}
Sym_ele **list;
Sym_ele *se;
Sym_ele *next; /* allows user to delete the node(s) we return */
- int i;
+ int i;
- st = (Sym_tab *) vst;
+ if( (st = (Sym_tab *) vst) == NULL ) {
+ return;
+ }
- if( st && (list = st->symlist) != NULL && user_fun != NULL )
- for( i = 0; i < st->size; i++ )
- for( se = list[i]; se; se = next ) /* using next allows user to delet via this */
- {
- next = se->next;
+ if( (list = st->symlist) != NULL && user_fun != NULL ) {
+ for( i = 0; i < st->size; i++ ) {
+ se = list[i];
+ while( se ) {
+ next = se->next; // allow callback to delete from the list w/o borking us
if( class == se->class ) {
user_fun( st, se, se->name, se->val, user_data );
}
+ se = next;
}
+ }
+ }
}
Code Review / ric-plt / lib / rmr.git / blobdiff