Changeset 1369:f1bbcab403a6 in freeDiameter

Timestamp:

Jun 10, 2019, 11:27:54 PM (5 years ago)

Author:

Thomas Klausner <tk@giga.or.at>

Branch:

default

Phase:

public

Message:

Clean up trailing whitespace in sessions.c

File:

• libfdproto/sessions.c (modified) (57 diffs)

libfdproto/sessions.c

@@ -35 +35 @@
 
 /* Sessions module.
- * 
+ *
  * Basic functionalities to help implementing User sessions state machines from RFC3588.
  */
@@ -92 +92 @@
 struct session {
         int             eyec;   /* Eyecatcher, SI_EYEC */
-        
+
         os0_t           sid;    /* The \0-terminated Session-Id */
         size_t          sidlen; /* cached length of sid */
         uint32_t        hash;   /* computed hash of sid */
         struct fd_list  chain_h;/* chaining in the hash table of sessions. */
-        
+
         struct timespec timeout;/* Timeout date for the session */
         struct fd_list  expire; /* List of expiring sessions, ordered by timeouts. */
-        
+
         pthread_mutex_t stlock; /* A lock to protect the list of states associated with this session */
         struct fd_list  states; /* Sentinel for the list of states of this session. */
@@ -126 +126 @@
 static struct fd_list   exp_sentinel = FD_LIST_INITIALIZER(exp_sentinel);       /* list of sessions ordered by their timeout date */
 static pthread_mutex_t  exp_lock = PTHREAD_MUTEX_INITIALIZER;   /* lock protecting the list. */
-static pthread_cond_t   exp_cond = PTHREAD_COND_INITIALIZER;    /* condvar used by the expiry mecahinsm. */
+static pthread_cond_t   exp_cond = PTHREAD_COND_INITIALIZER;    /* condvar used by the expiry mechainsm. */
 static pthread_t        exp_thr = (pthread_t)NULL;      /* The expiry thread that handles cleanup of expired sessions */
 
@@ -141 +141 @@
 {
         struct session * sess;
-        
+
         TRACE_ENTRY("%p %zd", sid, sidlen);
         CHECK_PARAMS_DO( sid && sidlen, return NULL );
-        
+
         CHECK_MALLOC_DO( sess = malloc(sizeof(struct session)), return NULL );
         memset(sess, 0, sizeof(struct session));
-        
+
         sess->eyec = SI_EYEC;
-        
+
         sess->sid  = sid;
         sess->sidlen = sidlen;
         sess->hash = hash;
         fd_list_init(&sess->chain_h, sess);
-        
+
         CHECK_SYS_DO( clock_gettime(CLOCK_REALTIME, &sess->timeout), return NULL );
         sess->timeout.tv_sec += SESS_DEFAULT_LIFETIME;
         fd_list_init(&sess->expire, sess);
-        
+
         CHECK_POSIX_DO( pthread_mutex_init(&sess->stlock, NULL), return NULL );
         fd_list_init(&sess->states, sess);
-        
+
         return sess;
 }
@@ -175 +175 @@
         free(s);
 }
-        
+
 /* The expiry thread */
 static void * exp_fct(void * arg)
@@ -181 +181 @@
         fd_log_threadname ( "Session/expire" );
         TRACE_ENTRY( "" );
-        
-        
+
+
         do {
                 struct timespec now;
                 struct session * first;
-                
+
                 CHECK_POSIX_DO( pthread_mutex_lock(&exp_lock),  break );
                 pthread_cleanup_push( fd_cleanup_mutex, &exp_lock );
-again:          
+again:
                 /* Check if there are expiring sessions available */
                 if (FD_IS_LIST_EMPTY(&exp_sentinel)) {
@@ -197 +197 @@
                         goto again;
                 }
-                
+
                 /* Get the pointer to the session that expires first */
                 first = (struct session *)(exp_sentinel.next->o);
                 ASSERT( VALIDATE_SI(first) );
-                
+
                 /* Get the current time */
                 CHECK_SYS_DO(  clock_gettime(CLOCK_REALTIME, &now),  break  );
@@ -207 +207 @@
                 /* If first session is not expired, we just wait until it happens */
                 if ( TS_IS_INFERIOR( &now, &first->timeout ) ) {
-                        
-                        CHECK_POSIX_DO2(  pthread_cond_timedwait( &exp_cond, &exp_lock, &first->timeout ),  
+                        CHECK_POSIX_DO2(  pthread_cond_timedwait( &exp_cond, &exp_lock, &first->timeout ),
                                         ETIMEDOUT, /* ETIMEDOUT is a normal error, continue */,
                                         /* on other error, */ break );
-        
+
                         /* on wakeup, loop */
                         goto again;
                 }
-                
+
                 /* Now, the first session in the list is expired; destroy it */
                 pthread_cleanup_pop( 0 );
                 CHECK_POSIX_DO( pthread_mutex_unlock(&exp_lock),  break );
-                
+
                 CHECK_FCT_DO( fd_sess_destroy( &first ), break );
-                
+
         } while (1);
-        
+
         TRACE_DEBUG(INFO, "A system error occurred in session module! Expiry thread is terminating...");
         ASSERT(0);
         return NULL;
 }
-        
-        
+
+
 
 /********************************************************************************************************/
@@ -237 +236 @@
 {
         int i;
-        
+
         TRACE_ENTRY( "" );
-        
+
         /* Initialize the global counters */
         sid_h = (uint32_t) time(NULL);
         sid_l = 0;
-        
+
         /* Initialize the hash table */
         for (i = 0; i < sizeof(sess_hash) / sizeof(sess_hash[0]); i++) {
@@ -249 +248 @@
                 CHECK_POSIX(  pthread_mutex_init(&sess_hash[i].lock, NULL)  );
         }
-        
+
         return 0;
 }
@@ -258 +257 @@
         /* Start session garbage collector (expiry) */
         CHECK_POSIX(  pthread_create(&exp_thr, NULL, exp_fct, NULL)  );
-        
+
         return 0;
 }
@@ -267 +266 @@
         TRACE_ENTRY("");
         CHECK_FCT_DO( fd_thr_term(&exp_thr), /* continue */ );
-        
+
         /* Destroy all sessions in the hash table, and the hash table itself? -- How to do it without a race condition ? */
-        
+
         return;
 }
@@ -277 +276 @@
 {
         struct session_handler *new;
-        
+
         TRACE_ENTRY("%p %p", handler, cleanup);
-        
+
         CHECK_PARAMS( handler && cleanup );
-        
+
         CHECK_MALLOC( new = malloc(sizeof(struct session_handler)) );
         memset(new, 0, sizeof(struct session_handler));
-        
+
         CHECK_POSIX( pthread_mutex_lock(&hdl_lock) );
         new->id = ++hdl_id;
         CHECK_POSIX( pthread_mutex_unlock(&hdl_lock) );
-        
+
         new->eyec = SH_EYEC;
         new->cleanup = cleanup;
         new->state_dump = dumper;
         new->opaque = opaque;
-        
+
         *handler = new;
         return 0;
 }
 
-/* Destroy a handler, and all states attached to this handler. This operation is very slow but we don't care since it's rarely used. 
+/* Destroy a handler, and all states attached to this handler. This operation is very slow but we don't care since it's rarely used.
  * Note that it's better to call this function after all sessions have been deleted... */
 int fd_sess_handler_destroy ( struct session_handler ** handler, void ** opaque )
@@ -306 +305 @@
         struct fd_list deleted_states = FD_LIST_INITIALIZER( deleted_states );
         int i;
-        
+
         TRACE_ENTRY("%p", handler);
         CHECK_PARAMS( handler && VALIDATE_SH(*handler) );
-        
+
         del = *handler;
         *handler = NULL;
-        
+
         del->eyec = 0xdead; /* The handler is not valid anymore for any other operation */
-        
+
         /* Now find all sessions with data registered for this handler, and move this data to the deleted_states list. */
         for (i = 0; i < sizeof(sess_hash) / sizeof(sess_hash[0]); i++) {
                 struct fd_list * li_si;
                 CHECK_POSIX(  pthread_mutex_lock(&sess_hash[i].lock)  );
-                
+
                 for (li_si = sess_hash[i].sentinel.next; li_si != &sess_hash[i].sentinel; li_si = li_si->next) { /* for each session in the hash line */
                         struct fd_list * li_st;
@@ -341 +340 @@
                 CHECK_POSIX(  pthread_mutex_unlock(&sess_hash[i].lock)  );
         }
-        
+
         /* Now, delete all states after calling their cleanup handler */
         while (!FD_IS_LIST_EMPTY(&deleted_states)) {
@@ -350 +349 @@
                 free(st);
         }
-        
+
         if (opaque)
                 *opaque = del->opaque;
-        
+
         /* Free the handler */
         free(del);
-        
+
         return 0;
 }
@@ -372 +371 @@
         int found = 0;
         int ret = 0;
-        
+
         TRACE_ENTRY("%p %p %zd %p %zd", session, diamid, diamidlen, opt, optlen);
         CHECK_PARAMS( session && (diamid || opt) );
 
-        if (diamid) {   
+        if (diamid) {
                 if (!diamidlen) {
                         diamidlen = strlen(diamid);
-                } 
+                }
                 /* We check if the string is a valid DiameterIdentity */
                 CHECK_PARAMS( fd_os_is_valid_DiameterIdentity((uint8_t *)diamid, diamidlen) );
@@ -385 +384 @@
                 diamidlen = 0;
         }
-        if (opt) {      
+        if (opt) {
                 if (!optlen) {
                         optlen = strlen((char *)opt);
@@ -394 +393 @@
                 optlen = 0;
         }
-                
+
         /* Ok, first create the identifier for the string */
         if (diamid == NULL) {
@@ -410 +409 @@
                 sidlen++; /* space for the final \0 also */
                 CHECK_MALLOC( sid = malloc(sidlen) );
-                
+
                 CHECK_POSIX( pthread_mutex_lock(&sid_lock) );
                 if ( ++sid_l == 0 ) /* overflow */
@@ -417 +416 @@
                 sid_l_cpy = sid_l;
                 CHECK_POSIX( pthread_mutex_unlock(&sid_lock) );
-                
+
                 if (opt) {
                         sidlen = snprintf((char*)sid, sidlen, "%.*s;%u;%u;%.*s", (int)diamidlen, diamid, sid_h_cpy, sid_l_cpy, (int)optlen, opt);
@@ -424 +423 @@
                 }
         }
-        
+
         hash = fd_os_hash(sid, sidlen);
-        
+
         /* Now find the place to add this object in the hash table. */
         CHECK_POSIX( pthread_mutex_lock( H_LOCK(hash) ) );
         pthread_cleanup_push( fd_cleanup_mutex, H_LOCK(hash) );
-        
+
         for (li = H_LIST(hash)->next; li != H_LIST(hash); li = li->next) {
                 int cmp;
                 struct session * s = (struct session *)(li->o);
-                
+
                 /* The list is ordered by hash and sid (in case of collisions) */
                 if (s->hash < hash)
@@ -440 +439 @@
                 if (s->hash > hash)
                         break;
-                
+
                 cmp = fd_os_cmp(s->sid, s->sidlen, sid, sidlen);
                 if (cmp < 0)
@@ -446 +445 @@
                 if (cmp > 0)
                         break;
-                
+
                 /* A session with the same sid was already in the hash table */
                 found = 1;
@@ -452 +451 @@
                 break;
         }
-        
+
         /* If the session did not exist, we can create it & link it in global tables */
         if (!found) {
@@ -461 +460 @@
                                 goto out;
                         } );
-        
+
                 fd_list_insert_before(li, &sess->chain_h); /* hash table */
                 sess->msg_cnt++;
         } else {
                 free(sid);
-                
-                CHECK_POSIX( pthread_mutex_lock(&(*session)->stlock) ); 
+
+                CHECK_POSIX( pthread_mutex_lock(&(*session)->stlock) );
                 (*session)->msg_cnt++;
-                CHECK_POSIX( pthread_mutex_unlock(&(*session)->stlock) ); 
-                
+                CHECK_POSIX( pthread_mutex_unlock(&(*session)->stlock) );
+
                 /* it was found: was it previously destroyed? */
                 if ((*session)->is_destroyed == 0) {
@@ -479 +478 @@
                         sess = *session;
                         sess->is_destroyed = 0;
-                        
+
                         /* update the expiry time */
                         CHECK_SYS_DO( clock_gettime(CLOCK_REALTIME, &sess->timeout), { ASSERT(0); } );
@@ -485 +484 @@
                 }
         }
-                
+
         /* We must insert in the expiry list */
         CHECK_POSIX( pthread_mutex_lock( &exp_lock ) );
@@ -512 +511 @@
         pthread_cleanup_pop(0);
         CHECK_POSIX( pthread_mutex_unlock( H_LOCK(hash) ) );
-        
+
         if (ret) /* in case of error */
                 return ret;
-        
+
         *session = sess;
         return 0;
@@ -524 +523 @@
 {
         int ret;
-        
+
         TRACE_ENTRY("%p %zd %p %p", sid, len, session, new);
         CHECK_PARAMS( sid && session );
-        
+
         if (!fd_os_is_valid_os0(sid,len)) {
                 TRACE_DEBUG(INFO, "Warning: a Session-Id value contains \\0 chars... (len:%zd, begin:'%.*s') => Debug messages may be truncated.", len, (int)len, sid);
         }
-        
+
         /* All the work is done in sess_new */
         ret = fd_sess_new ( session, NULL, 0, sid, len );
@@ -538 +537 @@
                 case EALREADY:
                         break;
-                
+
                 default:
                         CHECK_FCT(ret);
         }
-        
+
         if (new)
                 *new = ret ? 0 : 1;
-        
+
         return 0;
 }
@@ -553 +552 @@
 {
         TRACE_ENTRY("%p %p", session, sid);
-        
+
         CHECK_PARAMS( VALIDATE_SI(session) && sid );
-        
+
         *sid = session->sid;
         if (sidlen)
                 *sidlen = session->sidlen;
-        
+
         return 0;
 }
@@ -567 +566 @@
 {
         struct fd_list * li;
-        
+
         TRACE_ENTRY("%p %p", session, timeout);
         CHECK_PARAMS( VALIDATE_SI(session) && timeout );
-        
+
         /* Lock -- do we need to lock the hash table as well? I don't think so... */
         CHECK_POSIX( pthread_mutex_lock( &exp_lock ) );
         pthread_cleanup_push( fd_cleanup_mutex, &exp_lock );
-        
+
         /* Update the timeout */
         fd_list_unlink(&session->expire);
         memcpy(&session->timeout, timeout, sizeof(struct timespec));
-        
+
         /* Find the new position in expire list. We take it in normal order */
         for (li = exp_sentinel.next; li != &exp_sentinel; li = li->next) {
@@ -598 +597 @@
         pthread_cleanup_pop(0);
         CHECK_POSIX( pthread_mutex_unlock( &exp_lock ) );
-        
+
         return 0;
 }
@@ -609 +608 @@
         os0_t sid;
         int ret = 0;
-        
+
         /* place to save the list of states to be cleaned up. We do it after finding them to avoid deadlocks. the "o" field becomes a copy of the sid. */
         struct fd_list deleted_states = FD_LIST_INITIALIZER( deleted_states );
-        
+
         TRACE_ENTRY("%p", session);
         CHECK_PARAMS( session && VALIDATE_SI(*session) );
-        
+
         sess = *session;
         *session = NULL;
-        
+
         /* Lock the hash line */
         CHECK_POSIX( pthread_mutex_lock( H_LOCK(sess->hash) ) );
         pthread_cleanup_push( fd_cleanup_mutex, H_LOCK(sess->hash) );
-        
+
         /* Unlink from the expiry list */
         CHECK_POSIX_DO( pthread_mutex_lock( &exp_lock ), { ASSERT(0); /* otherwise cleanup handler is not pop'd */ } );
+        pthread_cleanup_push( fd_cleanup_mutex, &exp_lock );
         if (!FD_IS_LIST_EMPTY(&sess->expire)) {
                 sess_cnt--;
                 fd_list_unlink( &sess->expire ); /* no need to signal the condition here */
         }
+        pthread_cleanup_pop(0);
         CHECK_POSIX_DO( pthread_mutex_unlock( &exp_lock ), { ASSERT(0); /* otherwise cleanup handler is not pop'd */ } );
-        
+
         /* Now move all states associated to this session into deleted_states */
         CHECK_POSIX_DO( pthread_mutex_lock( &sess->stlock ), { ASSERT(0); /* otherwise cleanup handler is not pop'd */ } );
@@ -639 +640 @@
         }
         CHECK_POSIX_DO( pthread_mutex_unlock( &sess->stlock ), { ASSERT(0); /* otherwise cleanup handler is not pop'd */ } );
-        
+
         /* Mark the session as destroyed */
         destroy_now = (sess->msg_cnt == 0);
@@ -651 +652 @@
         pthread_cleanup_pop(0);
         CHECK_POSIX( pthread_mutex_unlock( H_LOCK(sess->hash) ) );
-        
+
         if (ret)
                 return ret;
-        
+
         /* Now, really delete the states */
         while (!FD_IS_LIST_EMPTY(&deleted_states)) {
@@ -663 +664 @@
                 free(st);
         }
-        
+
         /* Finally, destroy the session itself, if it is not referrenced by any message anymore */
         if (destroy_now) {
@@ -670 +671 @@
                 free(sid);
         }
-        
+
         return 0;
 }
@@ -680 +681 @@
         uint32_t hash;
         int destroy_now = 0;
-        
+
         TRACE_ENTRY("%p", session);
         CHECK_PARAMS( session && VALIDATE_SI(*session) );
-        
+
         sess = *session;
         hash = sess->hash;
         *session = NULL;
-        
+
         CHECK_POSIX( pthread_mutex_lock( H_LOCK(hash) ) );
         pthread_cleanup_push( fd_cleanup_mutex, H_LOCK(hash) );
@@ -693 +694 @@
         pthread_cleanup_push( fd_cleanup_mutex, &sess->stlock );
         CHECK_POSIX_DO( pthread_mutex_lock( &exp_lock ), { ASSERT(0); /* otherwise, cleanup not poped on FreeBSD */ } );
-        
+        pthread_cleanup_push( fd_cleanup_mutex, &exp_lock );
+
         /* We only do something if the states list is empty */
         if (FD_IS_LIST_EMPTY(&sess->states)) {
@@ -706 +708 @@
                 }
         }
-        
+
+        pthread_cleanup_pop(0);
         CHECK_POSIX_DO( pthread_mutex_unlock( &exp_lock ), { ASSERT(0); /* otherwise, cleanup not poped on FreeBSD */ } );
         pthread_cleanup_pop(0);
@@ -712 +715 @@
         pthread_cleanup_pop(0);
         CHECK_POSIX( pthread_mutex_unlock( H_LOCK(hash) ) );
-        
+
         if (destroy_now)
                 del_session(sess);
-        
+
         return 0;
 }
@@ -726 +729 @@
         int already = 0;
         int ret = 0;
-        
+
         TRACE_ENTRY("%p %p %p", handler, session, state);
         CHECK_PARAMS( handler && VALIDATE_SH(handler) && session && VALIDATE_SI(session) && (!session->is_destroyed) && state );
-        
+
         /* Lock the session state list */
         CHECK_POSIX( pthread_mutex_lock(&session->stlock) );
         pthread_cleanup_push( fd_cleanup_mutex, &session->stlock );
-                        
+
         /* Create the new state object */
         CHECK_MALLOC_DO(new = malloc(sizeof(struct state)), { ret = ENOMEM; goto out; } );
         memset(new, 0, sizeof(struct state));
-        
+
         new->eyec = SD_EYEC;
         new->state= *state;
         fd_list_init(&new->chain, new);
         new->hdl = handler;
-        
+
         /* find place for this state in the list */
         for (li = session->states.next; li != &session->states; li = li->next) {
@@ -749 +752 @@
                 if (st->hdl->id < handler->id)
                         continue;
-                
+
                 if (st->hdl->id == handler->id) {
                         TRACE_DEBUG(INFO, "A state was already stored for session '%s' and handler '%p', at location %p", session->sid, st->hdl, st->state);
                         already = EALREADY;
                 }
-                
+
                 break;
         }
-        
+
         if (!already) {
                 fd_list_insert_before(li, &new->chain);
@@ -765 +768 @@
         }
 out:
-        ;       
+        ;
         pthread_cleanup_pop(0);
         CHECK_POSIX( pthread_mutex_unlock(&session->stlock) );
-        
+
         return ret ?: already;
 }
@@ -777 +780 @@
         struct fd_list * li;
         struct state * st = NULL;
-        
+
         TRACE_ENTRY("%p %p %p", handler, session, state);
         CHECK_PARAMS( handler && VALIDATE_SH(handler) && session && VALIDATE_SI(session) && state );
-        
+
         *state = NULL;
-        
+
         /* Lock the session state list */
         CHECK_POSIX( pthread_mutex_lock(&session->stlock) );
         pthread_cleanup_push( fd_cleanup_mutex, &session->stlock );
-        
+
         /* find the state in the list */
         for (li = session->states.next; li != &session->states; li = li->next) {
                 st = (struct state *)(li->o);
-                
+
                 /* The list is ordered by handler's id */
                 if (st->hdl->id > handler->id)
                         break;
         }
-        
+
         /* If we found the state */
         if (st && (st->hdl == handler)) {
@@ -802 +805 @@
                 free(st);
         }
-        
+
         pthread_cleanup_pop(0);
         CHECK_POSIX( pthread_mutex_unlock(&session->stlock) );
-        
+
         return 0;
 }
@@ -814 +817 @@
         TRACE_ENTRY("%p %zd %p %p", sid, len, session, new);
         CHECK_PARAMS( sid && len && session );
-        
+
         /* Get the session object */
         CHECK_FCT( fd_sess_fromsid_msg ( sid, len, session, new) );
-        
+
         /* Decrease the refcount */
         CHECK_POSIX( pthread_mutex_lock(&(*session)->stlock) );
         (*session)->msg_cnt--; /* was increased in fd_sess_new */
         CHECK_POSIX( pthread_mutex_unlock(&(*session)->stlock) );
-                
+
         /* Done */
         return 0;
@@ -836 +839 @@
         session->msg_cnt++;
         CHECK_POSIX( pthread_mutex_unlock(&session->stlock) );
-        
+
         return 0;
 }
@@ -844 +847 @@
         int reclaim;
         uint32_t hash;
-        
+
         TRACE_ENTRY("%p", session);
         CHECK_PARAMS( session && VALIDATE_SI(*session) );
-        
+
         /* Lock the hash line to avoid possibility that session is freed while we are reclaiming */
         hash = (*session)->hash;
         CHECK_POSIX( pthread_mutex_lock( H_LOCK(hash)) );
-        pthread_cleanup_push( fd_cleanup_mutex, H_LOCK(hash) ); 
+        pthread_cleanup_push( fd_cleanup_mutex, H_LOCK(hash) );
 
         /* Update the msg refcount */
@@ -858 +861 @@
         (*session)->msg_cnt = reclaim - 1;
         CHECK_POSIX( pthread_mutex_unlock(&(*session)->stlock) );
-        
+
         /* Ok, now unlock the hash line */
         pthread_cleanup_pop( 0 );
         CHECK_POSIX( pthread_mutex_unlock( H_LOCK(hash) ) );
-        
+
         /* and reclaim if no message references the session anymore */
         if (reclaim == 1) {
@@ -878 +881 @@
 {
         FD_DUMP_HANDLE_OFFSET();
-        
+
         CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "{session}(@%p): ", session), return NULL);
-        
+
         if (!VALIDATE_SI(session)) {
                 CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "INVALID/NULL"), return NULL);
@@ -890 +893 @@
                 CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "'%s'(%zd) h:%x m:%d d:%d to:%s.%06ld",
                                                         session->sid, session->sidlen, session->hash, session->msg_cnt, session->is_destroyed,
-                                                        timebuf, session->timeout.tv_nsec/1000), 
+                                                        timebuf, session->timeout.tv_nsec/1000),
                                  return NULL);
-                
+
                 if (with_states) {
                         struct fd_list * li;
                         CHECK_POSIX_DO( pthread_mutex_lock(&session->stlock), /* ignore */ );
                         pthread_cleanup_push( fd_cleanup_mutex, &session->stlock );
-                        
+
                         for (li = session->states.next; li != &session->states; li = li->next) {
                                 struct state * st = (struct state *)(li->o);
                                 CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "\n  {state i:%d}(@%p): ", st->hdl->id, st), return NULL);
                                 if (st->hdl->state_dump) {
-                                        CHECK_MALLOC_DO( (*st->hdl->state_dump)( FD_DUMP_STD_PARAMS, st->state), 
+                                        CHECK_MALLOC_DO( (*st->hdl->state_dump)( FD_DUMP_STD_PARAMS, st->state),
                                                         fd_dump_extend( FD_DUMP_STD_PARAMS, "[dumper error]"));
                                 } else {
@@ -908 +911 @@
                                 }
                         }
-                        
+
                         pthread_cleanup_pop(0);
                         CHECK_POSIX_DO( pthread_mutex_unlock(&session->stlock), /* ignore */ );
                 }
         }
-        
+
         return *buf;
 }
@@ -920 +923 @@
 {
         FD_DUMP_HANDLE_OFFSET();
-        
+
         CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "{sesshdl}(@%p): ", handler), return NULL);
-        
+
         if (!VALIDATE_SH(handler)) {
                 CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "INVALID/NULL"), return NULL);
@@ -929 +932 @@
         }
         return *buf;
-}       
+}
 
 int fd_sess_getcount(uint32_t *cnt)