自学教程：C++ FLOM_TRACE函数代码示例

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);}

int flom_conn_authenticate(flom_conn_t *conn, const gchar *peer_id,                           int tls_check_peer_id){    enum Exception { TLS_CERT_CHECK_ERROR                     , NONE } excp;    int ret_cod = FLOM_RC_INTERNAL_ERROR;        gchar *unique_id = NULL;    gchar *peer_addr = NULL;    FLOM_TRACE(("flom_conn_authenticate/n"));    TRY {        if (NULL == flom_conn_get_tls(conn)) {            FLOM_TRACE(("flom_conn_authenticate: this is not a TLS coonection "                        "and authentication can not be performed/n"));        } else if (tls_check_peer_id) {            peer_addr = flom_tcp_retrieve_peer_name(                flom_conn_get_tcp(conn));            if (FLOM_RC_OK != (ret_cod = flom_tls_cert_check(                                   flom_conn_get_tls(conn), peer_id,                                   peer_addr))) {                THROW(TLS_CERT_CHECK_ERROR);            }                    } /* if (tls_check_peer_id) */        THROW(NONE);    } CATCH {        switch (excp) {            case TLS_CERT_CHECK_ERROR:                break;            case NONE:                ret_cod = FLOM_RC_OK;                break;            default:                ret_cod = FLOM_RC_INTERNAL_ERROR;        } /* switch (excp) */    } /* TRY-CATCH */    /* unique id object clean-up */    if (NULL != unique_id)        g_free(unique_id);    /* peer address object clean-up */    if (NULL != peer_addr)        g_free(peer_addr);    FLOM_TRACE(("flom_conn_authenticate/excp=%d/"                "ret_cod=%d/errno=%d/n", excp, ret_cod, errno));    return ret_cod;}

void flom_handle_set_resource_idle_lifespan(flom_handle_t *handle, int value){    FLOM_TRACE(("flom_handle_set_resource_idle_lifespan: "                "old value=%d, new value=%d/n",                flom_config_get_resource_idle_lifespan(handle->config),                value));    flom_config_set_resource_idle_lifespan(handle->config, (gint)value);}

int flom_handle_set_resource_name(flom_handle_t *handle, const char *value){    FLOM_TRACE(("flom_handle_set_resource_name: "                "old value='%s', new value='%s'/n",                STRORNULL(flom_config_get_resource_name(handle->config)),                STRORNULL(value)));    return flom_config_set_resource_name(handle->config, (const gchar *)value);}

void flom_conn_delete(flom_conn_t *obj){    FLOM_TRACE(("flom_conn_delete: obj=%p/n", obj));    if (NULL != obj) {        FLOM_TRACE(("flom_conn_delete: obj->msg=%p/n", obj->msg));        /* remove msg struct */        if (NULL != obj->msg) {            flom_msg_free(obj->msg);            g_free(obj->msg);            obj->msg = NULL;        }        /* clean TLS object */        flom_tls_delete(obj->tls);        obj->tls = NULL;        /* remove object itself */        g_free(obj);    }}

int 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));    switch (handle->state) {        case FLOM_HANDLE_STATE_INIT:        case FLOM_HANDLE_STATE_DISCONNECTED:            flom_config_set_unicast_port(handle->config, (gint)value);            break;        default:            FLOM_TRACE(("flom_handle_set_unicast_port: state %d " /                        "is not compatible with set operation/n",                        handle->state));            return FLOM_RC_API_IMMUTABLE_HANDLE;    } /* switch (handle->state) */    return FLOM_RC_OK;}

const struct addrinfo *flom_tcp_try_connect(    flom_config_t *config, const struct addrinfo *gai, int *fd){    const struct addrinfo *found = NULL;     *fd = FLOM_NULL_FD;    /* traverse the list and try to connect... */    while (NULL != gai && NULL == found) {        struct sockaddr_in6 sa6;        struct sockaddr *sa = gai->ai_addr;        /* IPv6 addresses could need sin6_scope_id set if the user specified           a network interface */        FLOM_TRACE_SOCKADDR("flom_tcp_try_connect: sa ",                            sa, gai->ai_addrlen);        if (AF_INET6 == sa->sa_family &&            NULL != flom_config_get_network_interface(config)) {            memcpy(&sa6, sa, gai->ai_addrlen);            sa6.sin6_scope_id = flom_config_get_sin6_scope_id(config);            sa = (struct sockaddr *)&sa6;            FLOM_TRACE(("flom_tcp_try_connect: overriding field "                        "sin6_scope_id with value %u/n", sa6.sin6_scope_id));        }                    if (FLOM_NULL_FD == (*fd = socket(gai->ai_family, gai->ai_socktype,                                          gai->ai_protocol))) {            FLOM_TRACE(("flom_tcp_try_connect/socket(): "                        "errno=%d '%s', skipping.../n", errno,                        strerror(errno)));            gai = gai->ai_next;        } else {            FLOM_TRACE_SOCKADDR("flom_tcp_try_connect: sa ",                                sa, gai->ai_addrlen);            if (-1 == connect(*fd, sa, gai->ai_addrlen)) {                FLOM_TRACE(("flom_tcp_try_connect/connect(): "                            "errno=%d '%s', skipping.../n", errno,                            strerror(errno)));                gai = gai->ai_next;                close(*fd);                *fd = FLOM_NULL_FD;            } else                found = gai;        } /* if (-1 == (*fd = socket( */    } /* while (NULL != gai && !connected) */    return found;}

int 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);    FLOM_TRACE_REOPEN(flom_config_get_command_trace_file(handle->config),                      FALSE);    return FLOM_RC_OK;}

int flom_conn_terminate(flom_conn_t *obj){    enum Exception { TCP_CLOSE                     , NONE } excp;    int ret_cod = FLOM_RC_INTERNAL_ERROR;        FLOM_TRACE(("flom_conn_terminate/n"));    TRY {        if (FLOM_CONN_STATE_REMOVE != flom_conn_get_state(obj)) {            flom_conn_set_state(obj, FLOM_CONN_STATE_REMOVE);            if (FLOM_NULL_FD == flom_tcp_get_sockfd(&obj->tcp)) {                FLOM_TRACE(("flom_conn_terminate: connection %p already "                            "closed, skipping.../n", obj));            } else {                FLOM_TRACE(("flom_conn_terminate: closing fd=%d/n",                            flom_tcp_get_sockfd(&obj->tcp)));                if (FLOM_RC_OK != (ret_cod = flom_tcp_close(&obj->tcp)))                    THROW(TCP_CLOSE);            }        } else {            FLOM_TRACE(("flom_conn_terminate: connection %p already "                        "in state %d, skipping.../n", obj,                        flom_conn_get_state(obj)));        } /* if (FLOM_CONN_STATE_REMOVE == flom_conn_get_state(c)) */                THROW(NONE);    } CATCH {        switch (excp) {            case TCP_CLOSE:                break;            case NONE:                ret_cod = FLOM_RC_OK;                break;            default:                ret_cod = FLOM_RC_INTERNAL_ERROR;        } /* switch (excp) */    } /* TRY-CATCH */    FLOM_TRACE(("flom_conn_terminate/excp=%d/"                "ret_cod=%d/errno=%d/n", excp, ret_cod, errno));    return ret_cod;}

int flom_handle_set_resource_name(flom_handle_t *handle, const char *value){    FLOM_TRACE(("flom_handle_set_resource_name: "                "old value='%s', new value='%s'/n",                STRORNULL(flom_config_get_resource_name(handle->config)),                STRORNULL(value)));    switch (handle->state) {        case FLOM_HANDLE_STATE_INIT:        case FLOM_HANDLE_STATE_DISCONNECTED:        case FLOM_HANDLE_STATE_CONNECTED:            flom_config_set_resource_name(handle->config,                                          (const gchar *)value);            break;        default:            FLOM_TRACE(("flom_handle_set_resource_name: state %d " /                        "is not compatible with set operation/n",                        handle->state));            return FLOM_RC_API_IMMUTABLE_HANDLE;    } /* switch (handle->state) */    return FLOM_RC_OK;}