void flom_handle_delete(flom_handle_t *handle)
{
    /* dummy loop */
    while (TRUE) {
        int ret_cod;
        
        /* check flom library is initialized */
        if (FLOM_RC_OK != flom_init_check())
            break;
        FLOM_TRACE(("flom_handle_delete: handle=%p\n", handle));
        /* check handle is not NULL */
        if (NULL == handle) {
            FLOM_TRACE(("flom_handle_delete: handle is null, skipping...\n"));
            break;
        }
        /* clean object handle */
        if (FLOM_RC_OK != (ret_cod = flom_handle_clean(handle))) {
            FLOM_TRACE(("flom_handle_new: flom_handle_clean returned %d, "
                        "ignoring it and going on...\n", ret_cod));
        }
        /* reset the object handle to prevent misuse of the associated
           memory */
        memset(handle, 0, sizeof(flom_handle_t));
        /* remove object handle */
        g_free(handle);
        FLOM_TRACE(("flom_handle_new: deallocated handle %p\n", handle));
        /* exit the loop after one cycle */
        break;
    } /* while (TRUE) */
    FLOM_TRACE(("flom_handle_delete: exiting\n"));
}

int flom_resource_simple_can_lock(flom_resource_t *resource,
                                  flom_lock_mode_t lock)
{
    static const flom_lock_mode_t lock_table[
        FLOM_LOCK_MODE_N][FLOM_LOCK_MODE_N] =
        { { TRUE,  TRUE,  TRUE,  TRUE,  TRUE,  TRUE } ,
          { TRUE,  TRUE,  TRUE,  TRUE,  TRUE,  FALSE } ,
          { TRUE,  TRUE,  TRUE,  FALSE, FALSE, FALSE } ,
          { TRUE,  TRUE,  FALSE, TRUE,  FALSE, FALSE } ,
          { TRUE,  TRUE,  FALSE, FALSE, FALSE, FALSE } ,
          { TRUE,  FALSE, FALSE, FALSE, FALSE, FALSE } };
    
    GSList *p = NULL;
    flom_lock_mode_t old_lock;
    int can_lock = TRUE;
    
    FLOM_TRACE(("flom_resource_simple_can_lock: checking lock=%d\n", lock));
    p = resource->data.simple.holders;
    while (NULL != p) {
        old_lock = ((struct flom_rsrc_conn_lock_s *)p->data)->info.lock_mode;
        FLOM_TRACE(("flom_resource_simple_can_lock: current_lock=%d, "
                    "asked_lock=%d, lock_table[%d][%d]=%d\n",
                    old_lock, lock, old_lock, lock,
                    lock_table[old_lock][lock]));
        can_lock &= lock_table[old_lock][lock];
        if (!can_lock)
            break;
        else
            p = p->next;
    } /* while (NULL != p) */
    return can_lock;
}

int flom_handle_set_unicast_address(flom_handle_t *handle, const char *value)
{
    FLOM_TRACE(("flom_handle_set_unicast_address: "
                "old value='%s', new value='%s'\n",
                STRORNULL(flom_config_get_unicast_address(handle->config)),
                STRORNULL(value)));
    switch (handle->state) {
        case FLOM_HANDLE_STATE_INIT:
        case FLOM_HANDLE_STATE_DISCONNECTED:
            flom_config_set_unicast_address(handle->config,
                                            (const gchar *)value);
            /* reset socket name and multicast address*/
            if (NULL != value) {
                flom_handle_set_socket_name(handle, NULL);
                flom_handle_set_multicast_address(handle, NULL);
            } /* if (NULL != value) */
            break;
        default:
            FLOM_TRACE(("flom_handle_set_unicast_address: state %d " \
                        "is not compatible with set operation\n",
                        handle->state));
            return FLOM_RC_API_IMMUTABLE_HANDLE;
    } /* switch (handle->state) */
    return FLOM_RC_OK;
}

int flom_tcp_close(flom_tcp_t *obj)
{
    enum Exception { CLOSE_ERROR
                     , NONE } excp;
    int ret_cod = FLOM_RC_INTERNAL_ERROR;
    
    FLOM_TRACE(("flom_tcp_close\n"));
    TRY {
        if (FLOM_NULL_FD == obj->sockfd) {
            FLOM_TRACE(("flom_tcp_close: sockfd is NULL, skipping...\n"));
        } else {
            if (0 != close(obj->sockfd))
                THROW(CLOSE_ERROR);
            obj->sockfd = FLOM_NULL_FD;
        } /* if (FLOM_NULL_FD == obj->sockfd) */
        
        THROW(NONE);
    } CATCH {
        switch (excp) {
            case CLOSE_ERROR:
                ret_cod = FLOM_RC_CLOSE_ERROR;
                break;
            case NONE:
                ret_cod = FLOM_RC_OK;
                break;
            default:
                ret_cod = FLOM_RC_INTERNAL_ERROR;
        } /* switch (excp) */
    } /* TRY-CATCH */
    FLOM_TRACE(("flom_tcp_close/excp=%d/"
                "ret_cod=%d/errno=%d\n", excp, ret_cod, errno));
    return ret_cod;
}

void flom_resource_simple_free(flom_resource_t *resource)
{    
    /* clean-up holders list... */
    FLOM_TRACE(("flom_resource_simple_free: cleaning-up holders list...\n"));
    while (NULL != resource->data.simple.holders) {
        struct flom_rsrc_conn_lock_s *cl =
            (struct flom_rsrc_conn_lock_s *)resource->data.simple.holders->data;
        resource->data.simple.holders = g_slist_remove(
            resource->data.simple.holders, cl);
        flom_rsrc_conn_lock_delete(cl);
    }
    resource->data.simple.holders = NULL;
    /* clean-up waitings queue... */
    FLOM_TRACE(("flom_resource_simple_free: cleaning-up waitings queue...\n"));
    while (!g_queue_is_empty(resource->data.simple.waitings)) {
        struct flom_rsrc_conn_lock_s *cl =
            (struct flom_rsrc_conn_lock_s *)g_queue_pop_head(
                resource->data.simple.waitings);
        flom_rsrc_conn_lock_delete(cl);
    }
    g_queue_free(resource->data.simple.waitings);
    resource->data.simple.waitings = NULL;
    /* releasing resource name */
    if (NULL != resource->name)
        g_free(resource->name);
    resource->name = NULL;
}

int flom_conn_set_keepalive(flom_config_t *config, int fd)
{
    enum Exception { NULL_OBJECT
                     , SETSOCKOPT_ERROR1
                     , SETSOCKOPT_ERROR2
                     , SETSOCKOPT_ERROR3
                     , SETSOCKOPT_ERROR4
                     , NONE } excp;
    int ret_cod = FLOM_RC_INTERNAL_ERROR;
    
    FLOM_TRACE(("flom_conn_set_keepalive\n"));
    TRY {
        int optval;
        socklen_t optlen = sizeof(optval);
        
        if (FLOM_NULL_FD == fd)
            THROW(NULL_OBJECT);

        FLOM_TRACE(("flom_conn_set_keepalive: setting SO_KEEPALIVE "
                    "for socket fd=%d\n", fd));
        /* set SO_KEEPALIVE feature for this socket */
        optval = 1;
        if (-1 == setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &optval, optlen))
            THROW(SETSOCKOPT_ERROR1);
        /* set tcp_keepalive_time parameter related to SO_KEEPALIVE */
        optval = flom_config_get_tcp_keepalive_time(config);
        if (-1 == setsockopt(fd, SOL_TCP, TCP_KEEPIDLE, &optval, optlen))
            THROW(SETSOCKOPT_ERROR2);
        /* set tcp_keepalive_intvl parameter related to SO_KEEPALIVE */
        optval = flom_config_get_tcp_keepalive_intvl(config);
        if (-1 == setsockopt(fd, SOL_TCP, TCP_KEEPINTVL, &optval, optlen))
            THROW(SETSOCKOPT_ERROR3);
        /* set tcp_keepalive_probes parameter related to SO_KEEPALIVE */
        optval = flom_config_get_tcp_keepalive_probes(config);
        if (-1 == setsockopt(fd, SOL_TCP, TCP_KEEPCNT, &optval, optlen))
            THROW(SETSOCKOPT_ERROR4);
        
        THROW(NONE);
    } CATCH {
        switch (excp) {
            case NULL_OBJECT:
                ret_cod = FLOM_RC_NULL_OBJECT;
                break;
            case SETSOCKOPT_ERROR1:
            case SETSOCKOPT_ERROR2:
            case SETSOCKOPT_ERROR3:
            case SETSOCKOPT_ERROR4:
                ret_cod = FLOM_RC_SETSOCKOPT_ERROR;
                break;
            case NONE:
                ret_cod = FLOM_RC_OK;
                break;
            default:
                ret_cod = FLOM_RC_INTERNAL_ERROR;
        } /* switch (excp) */
    } /* TRY-CATCH */
    FLOM_TRACE(("flom_conn_set_keepalive/excp=%d/"
                "ret_cod=%d/errno=%d\n", excp, ret_cod, errno));
    return ret_cod;
}

gchar *flom_tcp_retrieve_peer_name(const flom_tcp_t *obj)
{
    struct sockaddr_storage sa;
    socklen_t addrlen = sizeof(sa);
    char host[NI_MAXHOST+1];
    char serv[NI_MAXSERV+1];
    int ret_cod;
    char *tmp;
    size_t tmp_size;

    memset(&sa, 0, sizeof(sa));
    if (0 != getpeername(obj->sockfd, (struct sockaddr *)&sa, &addrlen)) {
        FLOM_TRACE(("flom_tcp_retrieve_peer_name/getpeername: errno=%d\n",
                    errno));
        return NULL;
    }
    if (0 != (ret_cod = getnameinfo(
                  (struct sockaddr *)&sa, addrlen,
                  host, sizeof(host), serv, sizeof(serv),
                  NI_NUMERICHOST|NI_NUMERICSERV))) {
        FLOM_TRACE(("flom_tcp_retrieve_peer_name/getnameinfo: ret_cod=%d, "
                    "errno=%d\n", ret_cod, errno));
        return NULL;
    }
    tmp_size = strlen(host) + strlen(serv) + 2;
    if (NULL != (tmp = g_try_malloc0(tmp_size))) {
        snprintf(tmp, tmp_size, "%s/%s", host, serv);
    }
    return tmp;
}

int flom_handle_clean(flom_handle_t *handle)
{
    enum Exception { FLOM_HANDLE_UNLOCK_ERROR
                     , API_INVALID_SEQUENCE
                     , NONE } excp;
    int ret_cod = FLOM_RC_INTERNAL_ERROR;
    
    /* check flom library is initialized */
    if (FLOM_RC_OK != (ret_cod = flom_init_check()))
        return ret_cod;
    
    FLOM_TRACE(("flom_handle_clean\n"));
    TRY {
        /* is the handle locked? we must unlock it before going on... */
        if (FLOM_HANDLE_STATE_LOCKED == handle->state) {
            if (FLOM_RC_OK != (ret_cod = flom_handle_unlock(handle)))
                THROW(FLOM_HANDLE_UNLOCK_ERROR);
        }
        /* check handle state */
        if (FLOM_HANDLE_STATE_INIT != handle->state &&
            FLOM_HANDLE_STATE_DISCONNECTED != handle->state) {
            FLOM_TRACE(("flom_handle_clean: handle->state=%d\n",
                        handle->state));
            THROW(API_INVALID_SEQUENCE);
        }
        /* release memory allocated for configuration object */
        flom_config_free(handle->config);
        g_free(handle->config);
        handle->config = NULL;
        /* release memory of connection data structure */
        g_free(handle->conn);
        handle->conn = NULL;
        /* release memory of locked element */
        g_free(handle->locked_element);
        handle->locked_element = NULL;
        /* clean handle state */
        handle->state = FLOM_HANDLE_STATE_CLEANED;
        
        THROW(NONE);
    } CATCH {
        switch (excp) {
            case FLOM_HANDLE_UNLOCK_ERROR:
                break;
            case API_INVALID_SEQUENCE:
                ret_cod = FLOM_RC_API_INVALID_SEQUENCE;
                break;
            case NONE:
                ret_cod = FLOM_RC_OK;
                break;
            default:
                ret_cod = FLOM_RC_INTERNAL_ERROR;
        } /* switch (excp) */
    } /* TRY-CATCH */
    FLOM_TRACE(("flom_handle_clean/excp=%d/"
                "ret_cod=%d/errno=%d\n", excp, ret_cod, errno));
    return ret_cod;
}

int flom_tcp_recv(const flom_tcp_t *obj, void *buf, size_t len,
                  size_t *received,
                  struct sockaddr *src_addr, socklen_t *addrlen)
{
    enum Exception { INVALID_SOCKET_TYPE
                     , RECV_ERROR
                     , RECVFROM_ERROR
                     , NONE } excp;
    int ret_cod = FLOM_RC_INTERNAL_ERROR;
    
    FLOM_TRACE(("flom_tcp_recv\n"));
    TRY {
        switch (obj->socket_type) {
            case SOCK_STREAM:
                if (0 > (*received = recv(obj->sockfd, buf, len, 0)))
                    THROW(RECV_ERROR);
                break;
            case SOCK_DGRAM:
                if (0 > (*received = recvfrom(
                             obj->sockfd, buf, len, 0,
                             (struct sockaddr *)src_addr, addrlen)))
                    THROW(RECVFROM_ERROR);
                FLOM_TRACE_HEX_DATA("flom_tcp_recv: from ",
                                    (void *)src_addr, *addrlen);        
                break;
            default:
                THROW(INVALID_SOCKET_TYPE);
        } /* switch (type) */
        
        FLOM_TRACE(("flom_tcp_recv: fd=%d returned "
                    SSIZE_T_FORMAT " bytes '%*.*s'\n", obj->sockfd,
                    *received, *received, *received, buf));

        THROW(NONE);
    } CATCH {
        switch (excp) {
            case INVALID_SOCKET_TYPE:
                ret_cod = FLOM_RC_INVALID_OPTION;
                break;
            case RECV_ERROR:
                ret_cod = FLOM_RC_RECV_ERROR;
                break;
            case RECVFROM_ERROR:
                ret_cod = FLOM_RC_RECVFROM_ERROR;
                break;
            case NONE:
                ret_cod = FLOM_RC_OK;
                break;
            default:
                ret_cod = FLOM_RC_INTERNAL_ERROR;
        } /* switch (excp) */
    } /* TRY-CATCH */
    FLOM_TRACE(("flom_tcp_recv/excp=%d/"
                "ret_cod=%d/errno=%d\n", excp, ret_cod, errno));
    return ret_cod;
}

void flom_conn_trace(const flom_conn_t *conn)
{
    FLOM_TRACE(("flom_conn_trace: object=%p\n", conn));
    FLOM_TRACE(("flom_conn_trace: "
                "fd=%d, type=%d, state=%d, wait=%d, msg=%p, parser=%p, "
                "addr_len=%d\n",
                flom_tcp_get_sockfd(&conn->tcp),
                flom_tcp_get_socket_type(&conn->tcp),
                conn->state, conn->wait, conn->msg, conn->parser,
                flom_tcp_get_addrlen(&conn->tcp)));
}

int flom_conn_send(flom_conn_t *obj, const void *buf, size_t len)
{
    int ret_cod = FLOM_RC_OK;
    FLOM_TRACE(("flom_conn_send\n"));

    if (NULL != obj->tls)
        ret_cod = flom_tls_send(obj->tls, buf, len);
    else
        ret_cod = flom_tcp_send(&obj->tcp, buf, len);
    FLOM_TRACE(("flom_conn_send/"
                "ret_cod=%d/errno=%d\n", ret_cod, errno));
    return ret_cod;
}

void flom_handle_set_resource_timeout(flom_handle_t *handle, int value)
{
    FLOM_TRACE(("flom_handle_set_resource_timeout: "
                "old value=%d, new value=%d\n",
                flom_config_get_resource_timeout(handle->config), value));
    return flom_config_set_resource_timeout(handle->config, (int)value);
}

void flom_handle_set_resource_quantity(flom_handle_t *handle, int value)
{
    FLOM_TRACE(("flom_handle_set_resource_quantity: "
                "old value=%d, new value=%d\n",
                flom_config_get_resource_quantity(handle->config), value));
    flom_config_set_resource_quantity(handle->config, (int)value);
}

void flom_handle_set_resource_create(flom_handle_t *handle, int value)
{
    FLOM_TRACE(("flom_handle_set_resource_create: "
                "old value=%d, new value=%d\n",
                flom_config_get_resource_create(handle->config), value));
    return flom_config_set_resource_create(handle->config, value);
}

void flom_handle_set_discovery_ttl(flom_handle_t *handle, int value)
{
    FLOM_TRACE(("flom_handle_set_discovery_ttl: "
                "old value=%d, new value=%d\n",
                flom_config_get_discovery_ttl(handle->config), value));
    flom_config_set_discovery_ttl(handle->config, (gint)value);
}

void flom_handle_set_unicast_port(flom_handle_t *handle, int value)
{
    FLOM_TRACE(("flom_handle_set_unicast_port: "
                "old value=%d, new value=%d\n",
                flom_config_get_unicast_port(handle->config), value));
    flom_config_set_unicast_port(handle->config, (gint)value);
}

const char *flom_handle_get_tls_ca_certificate(const flom_handle_t *handle)
{
    FLOM_TRACE(("flom_handle_get_tls_ca_certificate: value='%s'\n",
                STRORNULL(
                    flom_config_get_tls_ca_certificate(handle->config))));
    return (const char *)flom_config_get_tls_ca_certificate(handle->config);
}

void flom_handle_set_lock_mode(flom_handle_t *handle, flom_lock_mode_t value)
{
    FLOM_TRACE(("flom_handle_set_lock_mode: "
                "old value=%d, new value=%d\n",
                flom_config_get_lock_mode(handle->config), value));
    flom_config_set_lock_mode(handle->config, value);
}

void flom_tcp_init(flom_tcp_t *obj, flom_config_t *config)
{
    FLOM_TRACE(("flom_tcp_init\n"));
    /* memory reset */
    memset(obj, 0, sizeof(flom_tcp_t));
    obj->config = config;
}

void flom_handle_set_trace_filename(flom_handle_t *handle, const char *value)
{
    FLOM_TRACE(("flom_handle_set_trace_filename: "
                "old value='%s', new value='%s'\n",
                STRORNULL(flom_config_get_command_trace_file(handle->config)),
                STRORNULL(value)));
    flom_config_set_command_trace_file(handle->config, (const gchar *)value);
}