/* This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/.

 *

 *    Copyright 2015-2020 (c) Fraunhofer IOSB (Author: Julius Pfrommer)

 *    Copyright 2015-2016 (c) Sten Grüner

 *    Copyright 2015-2016 (c) Chris Iatrou

 *    Copyright 2015 (c) hfaham

 *    Copyright 2015-2017 (c) Florian Palm

 *    Copyright 2017-2018 (c) Thomas Stalder, Blue Time Concept SA

 *    Copyright 2015 (c) Holger Jeromin

 *    Copyright 2015 (c) Oleksiy Vasylyev

 *    Copyright 2016 (c) TorbenD

 *    Copyright 2017 (c) Stefan Profanter, fortiss GmbH

 *    Copyright 2016 (c) Lykurg

 *    Copyright 2017 (c) Mark Giraud, Fraunhofer IOSB

 *    Copyright 2018 (c) Kalycito Infotech Private Limited

 *    Copyright 2020 (c) Christian von Arnim, ISW University of Stuttgart

 *    Copyright 2021 (c) Fraunhofer IOSB (Author: Jan Hermes)

 *    Copyright 2022 (c) Linutronix GmbH (Author: Muddasir Shakil)

 */

#include <open62541/transport_generated.h>

#include "ua_client_internal.h"

#include "../ua_types_encoding_binary.h"

static void

clientHouseKeeping(UA_Client *client, void *_);

/********************/

/* Client Lifecycle */

/********************/

UA_StatusCode

UA_ClientConfig_copy(UA_ClientConfig const *src, UA_ClientConfig *dst){

    UA_StatusCode retval = UA_STATUSCODE_GOOD;

    retval = UA_ApplicationDescription_copy(&src->clientDescription, &dst->clientDescription);

    if(retval != UA_STATUSCODE_GOOD)

        goto cleanup;

    retval = UA_String_copy(&src->endpointUrl, &dst->endpointUrl);

    if(retval != UA_STATUSCODE_GOOD)

        goto cleanup;

    retval = UA_ExtensionObject_copy(&src->userIdentityToken, &dst->userIdentityToken);

    if(retval != UA_STATUSCODE_GOOD)

        goto cleanup;

    retval = UA_String_copy(&src->securityPolicyUri, &dst->securityPolicyUri);

    if(retval != UA_STATUSCODE_GOOD)

        goto cleanup;

    retval = UA_EndpointDescription_copy(&src->endpoint, &dst->endpoint);

    if(retval != UA_STATUSCODE_GOOD)

        goto cleanup;

    retval = UA_UserTokenPolicy_copy(&src->userTokenPolicy, &dst->userTokenPolicy);

    if(retval != UA_STATUSCODE_GOOD)

        goto cleanup;

    retval = UA_String_copy(&src->applicationUri, &dst->applicationUri);

    if(retval != UA_STATUSCODE_GOOD)

        goto cleanup;

    retval = UA_String_copy(&src->authSecurityPolicyUri,

                            &dst->authSecurityPolicyUri);

    if(retval != UA_STATUSCODE_GOOD)

        goto cleanup;

    retval = UA_String_copy(&src->sessionName, &dst->sessionName);

    if(retval != UA_STATUSCODE_GOOD)

        goto cleanup;

    retval = UA_Array_copy(src->sessionLocaleIds, src->sessionLocaleIdsSize,

                           (void **)&dst->sessionLocaleIds, &UA_TYPES[UA_TYPES_LOCALEID]);

    if(retval != UA_STATUSCODE_GOOD)

        goto cleanup;

    dst->sessionLocaleIdsSize = src->sessionLocaleIdsSize;

    retval = UA_Array_copy(src->namespaces, src->namespacesSize,

                           (void**)&dst->namespaces, &UA_TYPES[UA_TYPES_STRING]);

    if(retval != UA_STATUSCODE_GOOD)

        goto cleanup;

    dst->namespacesSize = src->namespacesSize;

    dst->tcpReuseAddr = src->tcpReuseAddr;

    dst->allowNonePolicyPassword = src->allowNonePolicyPassword;

    dst->globalNotificationCallback = src->globalNotificationCallback;

    dst->lifecycleNotificationCallback = src->lifecycleNotificationCallback;

    dst->serviceNotificationCallback = src->serviceNotificationCallback;

#ifdef UA_ENABLE_ENCRYPTION

    dst->maxTrustListSize = src->maxTrustListSize;

    dst->maxRejectedListSize = src->maxRejectedListSize;

#endif

    dst->connectivityCheckInterval = src->connectivityCheckInterval;

    dst->certificateVerification = src->certificateVerification;

    dst->clientContext = src->clientContext;

    dst->customDataTypes = src->customDataTypes;

    dst->eventLoop = src->eventLoop;

    dst->externalEventLoop = src->externalEventLoop;

    dst->inactivityCallback = src->inactivityCallback;

    dst->localConnectionConfig = src->localConnectionConfig;

    dst->logging = src->logging;

    dst->noSession = src->noSession;

    dst->noReconnect = src->noReconnect;

    dst->noNewSession = src->noNewSession;

    if(src->certificateVerification.logging == NULL)

        dst->certificateVerification.logging = dst->logging;

#ifdef UA_ENABLE_SUBSCRIPTIONS

    dst->outStandingPublishRequests = src->outStandingPublishRequests;

#endif

    dst->requestedSessionTimeout = src->requestedSessionTimeout;

    dst->secureChannelLifeTime = src->secureChannelLifeTime;

    dst->securityMode = src->securityMode;

    dst->stateCallback = src->stateCallback;

#ifdef UA_ENABLE_SUBSCRIPTIONS

    dst->subscriptionInactivityCallback = src->subscriptionInactivityCallback;

#endif

    dst->timeout = src->timeout;

    dst->securityPolicies = src->securityPolicies;

    dst->securityPoliciesSize = src->securityPoliciesSize;

    dst->securityPolicyHistory = src->securityPolicyHistory;

    dst->authSecurityPolicies = src->authSecurityPolicies;

    dst->authSecurityPoliciesSize = src->authSecurityPoliciesSize;

#ifdef UA_ENABLE_ENCRYPTION

    dst->privateKeyPasswordCallback = src->privateKeyPasswordCallback;

#endif

cleanup:

    if(retval != UA_STATUSCODE_GOOD) {

        /* _clear will free the plugins in dst that are a shallow copy from src. */

        dst->authSecurityPolicies = NULL;

        dst->certificateVerification.context = NULL;

        dst->eventLoop = NULL;

        dst->logging = NULL;

        dst->securityPolicies = NULL;

        dst->securityPolicyHistory = NULL;

        UA_ClientConfig_clear(dst);

    }

    return retval;

}

UA_Client *

UA_Client_newWithConfig(const UA_ClientConfig *config) {

    if(!config)

        return NULL;

    UA_Client *client = (UA_Client*)UA_malloc(sizeof(UA_Client));

    if(!client)

        return NULL;

    memset(client, 0, sizeof(UA_Client));

    client->config = *config;

    UA_SecureChannel_init(&client->channel);

    client->channel.config = client->config.localConnectionConfig;

    client->connectStatus = UA_STATUSCODE_GOOD;

#if UA_MULTITHREADING >= 100

    UA_LOCK_INIT(&client->clientMutex);

#endif

    /* Initialize the namespace mapping */

    UA_StatusCode res = UA_STATUSCODE_GOOD;

    size_t initialNs = 2 + config->namespacesSize;

    client->namespaces = (UA_String*)UA_calloc(initialNs, sizeof(UA_String));

    if(!client->namespaces)

        goto error;

    client->namespacesSize = initialNs;

    client->namespaces[0] = UA_STRING_ALLOC("http://opcfoundation.org/UA/");

    client->namespaces[1] = UA_STRING_NULL; /* Gets set when we connect to the server */

    for(size_t i = 0; i < config->namespacesSize; i++) {

        res |= UA_String_copy(&config->namespaces[i], &client->namespaces[i+2]);

    }

    if(res != UA_STATUSCODE_GOOD)

        goto error;

    return client;

error:

    memset(&client->config, 0, sizeof(UA_ClientConfig));

    UA_Client_delete(client);

    return NULL;

}

void

UA_ClientConfig_clear(UA_ClientConfig *config) {

    UA_ApplicationDescription_clear(&config->clientDescription);

    UA_String_clear(&config->endpointUrl);

    UA_ExtensionObject_clear(&config->userIdentityToken);

    /* Delete the SecurityPolicies for Authentication */

    if(config->authSecurityPolicies != 0) {

        for(size_t i = 0; i < config->authSecurityPoliciesSize; i++)

            config->authSecurityPolicies[i].clear(&config->authSecurityPolicies[i]);

        UA_free(config->authSecurityPolicies);

        config->authSecurityPolicies = 0;

    }

    UA_String_clear(&config->securityPolicyUri);

    UA_String_clear(&config->authSecurityPolicyUri);

    UA_EndpointDescription_clear(&config->endpoint);

    UA_UserTokenPolicy_clear(&config->userTokenPolicy);

    UA_String_clear(&config->applicationUri);

    if(config->certificateVerification.clear)

        config->certificateVerification.clear(&config->certificateVerification);

    /* Delete the SecurityPolicies */

    if(config->securityPolicies != 0) {

        for(size_t i = 0; i < config->securityPoliciesSize; i++)

            config->securityPolicies[i].clear(&config->securityPolicies[i]);

        UA_free(config->securityPolicies);

        config->securityPolicies = 0;

    }

    while(config->securityPolicyHistory) {

        UA_ClientConfig_PolicyHistory *previous = config->securityPolicyHistory;

        config->securityPolicyHistory = previous->next;

        for(size_t i = 0; i < previous->policiesSize; i++)

            previous->policies[i].clear(&previous->policies[i]);

        UA_free(previous->policies);

        UA_free(previous);

    }

    /* Stop and delete the EventLoop */

    UA_EventLoop *el = config->eventLoop;

    if(el && !config->externalEventLoop) {

        if(el->state != UA_EVENTLOOPSTATE_FRESH &&

           el->state != UA_EVENTLOOPSTATE_STOPPED) {

            el->stop(el);

            while(el->state != UA_EVENTLOOPSTATE_STOPPED) {

                el->run(el, 100);

            }

        }

        el->free(el);

        config->eventLoop = NULL;

    }

    /* Logging */

    if(config->logging != NULL && config->logging->clear != NULL)

        config->logging->clear(config->logging);

    config->logging = NULL;

    UA_String_clear(&config->sessionName);

    if(config->sessionLocaleIdsSize > 0 && config->sessionLocaleIds) {

        UA_Array_delete(config->sessionLocaleIds,

                        config->sessionLocaleIdsSize, &UA_TYPES[UA_TYPES_LOCALEID]);

    }

    config->sessionLocaleIds = NULL;

    config->sessionLocaleIdsSize = 0;

    UA_Array_delete(config->namespaces, config->namespacesSize, &UA_TYPES[UA_TYPES_STRING]);

    config->namespaces = NULL;

    config->namespacesSize = 0;

    config->securityPoliciesSize = 0;

    config->authSecurityPoliciesSize = 0;

    /* Custom Data Types */

    UA_cleanupDataTypeWithCustom(config->customDataTypes);

#ifdef UA_ENABLE_ENCRYPTION

    config->privateKeyPasswordCallback = NULL;

#endif

}

void

UA_ClientConfig_delete(UA_ClientConfig *config){

    UA_assert(config != NULL);

    UA_ClientConfig_clear(config);

    UA_free(config);

}

static void

UA_Client_clear(UA_Client *client) {

    /* Prevent new async service calls in UA_Client_AsyncService_removeAll */

    UA_SessionState oldState = client->sessionState;

    client->sessionState = UA_SESSIONSTATE_CLOSING;

    /* Delete the async service calls with BADHSUTDOWN */

    __Client_AsyncService_removeAll(client, UA_STATUSCODE_BADSHUTDOWN);

    /* Reset to the old state to properly close the session */

    client->sessionState = oldState;

    UA_Client_disconnect(client);

    /* Prevent reconnection attempts during the EventLoop teardown

     * in UA_ClientConfig_clear */

    client->connectStatus = UA_STATUSCODE_BADSHUTDOWN;

    UA_String_clear(&client->discoveryUrl);

    UA_EndpointDescription_clear(&client->endpoint);

    UA_ByteString_clear(&client->serverSessionNonce);

    UA_ByteString_clear(&client->clientSessionNonce);

    /* Delete the subscriptions */

#ifdef UA_ENABLE_SUBSCRIPTIONS

    __Client_Subscriptions_clear(client);

#endif

    /* Remove the internal regular callback */

    UA_Client_removeCallback(client, client->houseKeepingCallbackId);

    client->houseKeepingCallbackId = 0;

    /* Clean up the SecureChannel */

    UA_SecureChannel_clear(&client->channel);

    /* Free the namespace mapping */

    UA_Array_delete(client->namespaces, client->namespacesSize,

                    &UA_TYPES[UA_TYPES_STRING]);

    client->namespaces = NULL;

    client->namespacesSize = 0;

    /* Call the application notification callback */

    UA_ClientConfig *config = &client->config;

    if(config->lifecycleNotificationCallback)

        config->lifecycleNotificationCallback(client, UA_APPLICATIONNOTIFICATIONTYPE_LIFECYCLE_STOPPED,

                                              UA_KEYVALUEMAP_NULL);

    if(config->globalNotificationCallback)

        config->globalNotificationCallback(client, UA_APPLICATIONNOTIFICATIONTYPE_LIFECYCLE_STOPPED,

                                           UA_KEYVALUEMAP_NULL);

#if UA_MULTITHREADING >= 100

    UA_LOCK_DESTROY(&client->clientMutex);

#endif

}

void

UA_Client_delete(UA_Client* client) {

    UA_Client_disconnect(client);

    UA_Client_clear(client);

    UA_ClientConfig_clear(&client->config);

    UA_free(client);

}

void

UA_Client_getState(UA_Client *client, UA_SecureChannelState *channelState,

                   UA_SessionState *sessionState, UA_StatusCode *connectStatus) {

    lockClient(client);

    if(channelState)

        *channelState = client->channel.state;

    if(sessionState)

        *sessionState = client->sessionState;

    if(connectStatus)

        *connectStatus = client->connectStatus;

    unlockClient(client);

}

UA_ClientConfig *

UA_Client_getConfig(UA_Client *client) {

    if(!client)

        return NULL;

    return &client->config;

}

#if UA_LOGLEVEL <= 300

static const char *channelStateTexts[14] = {

    "Closed", "ReverseListening", "Connecting", "Connected", "ReverseConnected", "RHESent", "HELSent", "HELReceived", "ACKSent",

    "AckReceived", "OPNSent", "Open", "Closing"};

static const char *sessionStateTexts[6] =

    {"Closed", "CreateRequested", "Created",

     "ActivateRequested", "Activated", "Closing"};

#endif

void

setConnectStatus(UA_Client *client, UA_StatusCode status) {

    UA_LOCK_ASSERT(&client->clientMutex);

    client->connectStatus = status;

    if(status != UA_STATUSCODE_GOOD)

        closeSecureChannel(client);

    notifyClientState(client);

}

void

notifyClientState(UA_Client *client) {

    UA_LOCK_ASSERT(&client->clientMutex);

    if(client->connectStatus == client->oldConnectStatus &&

       client->channel.state == client->oldChannelState &&

       client->sessionState == client->oldSessionState)

        return;

#if UA_LOGLEVEL <= 300

    UA_Boolean info = (client->connectStatus != UA_STATUSCODE_GOOD);

    if(client->oldChannelState != client->channel.state)

        info |= (client->channel.state == UA_SECURECHANNELSTATE_OPEN ||

                 client->channel.state == UA_SECURECHANNELSTATE_CLOSED);

    if(client->oldSessionState != client->sessionState)

        info |= (client->sessionState == UA_SESSIONSTATE_CREATED ||

                 client->sessionState == UA_SESSIONSTATE_ACTIVATED ||

                 client->sessionState == UA_SESSIONSTATE_CLOSED);

    const char *channelStateText = channelStateTexts[client->channel.state];

    const char *sessionStateText = sessionStateTexts[client->sessionState];

    const char *connectStatusText = UA_StatusCode_name(client->connectStatus);

    if(info)

        UA_LOG_INFO(client->config.logging, UA_LOGCATEGORY_CLIENT,

                    "Client Status: ChannelState: %s, SessionState: %s, ConnectStatus: %s",

                    channelStateText, sessionStateText, connectStatusText);

    else

        UA_LOG_DEBUG(client->config.logging, UA_LOGCATEGORY_CLIENT,

                     "Client Status: ChannelState: %s, SessionState: %s, ConnectStatus: %s",

                     channelStateText, sessionStateText, connectStatusText);

#endif

    client->oldConnectStatus = client->connectStatus;

    client->oldChannelState = client->channel.state;

    client->oldSessionState = client->sessionState;

    if(client->config.stateCallback)

        client->config.stateCallback(client, client->channel.state,

                                     client->sessionState, client->connectStatus);

}

/****************/

/* Raw Services */

/****************/

/* For both synchronous and asynchronous service calls */

static UA_StatusCode

sendRequest(UA_Client *client, const void *request,

            const UA_DataType *requestType, UA_UInt32 *requestId) {

    UA_LOCK_ASSERT(&client->clientMutex);

    /* Renew SecureChannel if necessary */

    __Client_renewSecureChannel(client);

    if(client->connectStatus != UA_STATUSCODE_GOOD)

        return client->connectStatus;

    UA_EventLoop *el = client->config.eventLoop;

    /* Adjusting the request header. The const attribute is violated, but we

     * reset to the original state before returning. Use the AuthenticationToken

     * only once the session is active (or to activate / close it). */

    UA_RequestHeader *rr = (UA_RequestHeader*)(uintptr_t)request;

    UA_NodeId oldToken = rr->authenticationToken; /* Put back in place later */

    if(client->sessionState == UA_SESSIONSTATE_ACTIVATED ||

       requestType == &UA_TYPES[UA_TYPES_ACTIVATESESSIONREQUEST] ||

       requestType == &UA_TYPES[UA_TYPES_CLOSESESSIONREQUEST])

        rr->authenticationToken = client->authenticationToken;

    rr->timestamp = el->dateTime_now(el);

    /* Create a unique handle >100,000 if not manually defined. The handle is

     * not necessarily unique when manually defined and used to cancel async

     * service requests. */

    if(rr->requestHandle == 0) {

        if(UA_UNLIKELY(client->requestHandle < 100000))

            client->requestHandle = 100000;

        rr->requestHandle = ++client->requestHandle;

    }

    /* Set the timeout hint if not manually defined */

    if(rr->timeoutHint == 0)

        rr->timeoutHint = client->config.timeout;

    /* Generate the request id */

    UA_UInt32 rqId = ++client->requestId;

#ifdef UA_ENABLE_TYPEDESCRIPTION

    UA_LOG_DEBUG_CHANNEL(client->config.logging, &client->channel,

                         "Sending request with RequestId %u of type %s",

                         (unsigned)rqId, requestType->typeName);

#else

    UA_LOG_DEBUG_CHANNEL(client->config.logging, &client->channel,

                         "Sending request with RequestId %u of type %" PRIu32,

                         (unsigned)rqId, requestType->binaryEncodingId.identifier.numeric);

#endif

    /* Send the message */

    UA_StatusCode retval =

        UA_SecureChannel_sendMSG(&client->channel, rqId, rr, requestType);

    rr->authenticationToken = oldToken; /* Set back to the original token */

    /* Sending failed. The SecureChannel cannot recover from that. Call

     * closeSecureChannel to a) close from our end and b) set the session to

     * non-activated. */

    if(retval != UA_STATUSCODE_GOOD)

        closeSecureChannel(client);

    /* Return the request id */

    *requestId = rqId;

    return retval;

}

static const UA_NodeId

serviceFaultId = {0, UA_NODEIDTYPE_NUMERIC, {UA_NS0ID_SERVICEFAULT_ENCODING_DEFAULTBINARY}};

/* Look for the async callback in the linked list, execute and delete it */

static UA_StatusCode

processMSGResponse(UA_Client *client, UA_UInt32 requestId,

                   const UA_ByteString *msg) {

    UA_ClientConfig *config = &client->config;

    /* Find the callback */

    AsyncServiceCall *ac;

    LIST_FOREACH(ac, &client->asyncServiceCalls, pointers) {

        if(ac->requestId == requestId)

            break;

    }

    /* Part 6, 6.7.6: After the security validation is complete the receiver

     * shall verify the RequestId and the SequenceNumber. If these checks fail a

     * Bad_SecurityChecksFailed error is reported. The RequestId only needs to

     * be verified by the Client since only the Client knows if it is valid or

     * not.

     *

     * But! If an async request has timed out, the RequestId is no longer found.

     * In theory the server should send an error back before the timeout. But

     * not all do. In these cases we don't want to close the entire

     * SecureChannel and just log a warning. The service callback has already

     * been notified about the timeout before. */

    if(!ac) {

        UA_LOG_WARNING(config->logging, UA_LOGCATEGORY_CLIENT,

                       "Request with unknown RequestId %u", requestId);

        return UA_STATUSCODE_GOOD;

    }

    UA_Response asyncResponse;

    UA_Response *response = (ac->syncResponse) ? ac->syncResponse : &asyncResponse;

    const UA_DataType *responseType = ac->responseType;

    /* Also initialize before decoding the type NodeId: errors there already

     * invoke the callback and clear the response. ServiceFault decoding only

     * initializes the header, so initialize the full expected response type. */

    UA_init(response, responseType);

    /* Dequeue ac. We might disconnect the client (remove all ac) in the callback. */

    LIST_REMOVE(ac, pointers);

    /* Decode the response type */

    size_t offset = 0;

    UA_NodeId responseTypeId;

    UA_StatusCode retval = UA_NodeId_decodeBinary(msg, &offset, &responseTypeId);

    if(retval != UA_STATUSCODE_GOOD)

        goto process;

    /* Verify the type of the response */

    if(!UA_NodeId_equal(&responseTypeId, &ac->responseType->binaryEncodingId)) {

        if(UA_NodeId_equal(&responseTypeId, &serviceFaultId)) {

            /* Decode as a ServiceFault, i.e. only the response header */

            UA_LOG_DEBUG(config->logging, UA_LOGCATEGORY_CLIENT,

                         "Received a ServiceFault response");

            responseType = &UA_TYPES[UA_TYPES_SERVICEFAULT];

        } else {

            UA_LOG_ERROR(config->logging, UA_LOGCATEGORY_CLIENT,

                         "Service response type does not match");

            retval = UA_STATUSCODE_BADCOMMUNICATIONERROR;

            goto process; /* Do not decode */

        }

    }

    /* Decode the response */

#ifdef UA_ENABLE_TYPEDESCRIPTION

    UA_LOG_DEBUG(config->logging, UA_LOGCATEGORY_CLIENT,

                 "Decode a message of type %s", responseType->typeName);

#else

    UA_LOG_DEBUG(config->logging, UA_LOGCATEGORY_CLIENT,

                 "Decode a message of type %" PRIu32,

                 responseTypeId.identifier.numeric);

#endif

    UA_DecodeBinaryOptions opt;

    memset(&opt, 0, sizeof(UA_DecodeBinaryOptions));

    opt.customTypes = config->customDataTypes;

    opt.namespaceMapping = client->channel.namespaceMapping;

    retval = UA_decodeBinaryInternal(msg, &offset, response, responseType, &opt);

 process:

    /* Process the received MSG response */

    if(retval != UA_STATUSCODE_GOOD) {

        UA_LOG_WARNING(config->logging, UA_LOGCATEGORY_CLIENT,

                       "Could not decode the response with RequestId %u with status %s",

                       (unsigned)requestId, UA_StatusCode_name(retval));

        response->responseHeader.serviceResult = retval;

    }

    /* The Session closed. The current response is processed with the return code.

     * The next request first recreates a session. */

    if(responseType != &UA_TYPES[UA_TYPES_ACTIVATESESSIONRESPONSE] &&

       (response->responseHeader.serviceResult == UA_STATUSCODE_BADSESSIONIDINVALID ||

        response->responseHeader.serviceResult == UA_STATUSCODE_BADSESSIONCLOSED)) {

        /* Clean up the session information and reset the state */

        cleanupSession(client);

        if(config->noNewSession) {

            /* Configuration option to not create a new Session. Disconnect the

             * client. */

            client->connectStatus = response->responseHeader.serviceResult;

            UA_LOG_ERROR(config->logging, UA_LOGCATEGORY_CLIENT,

                         "Session cannot be activated with StatusCode %s. "

                         "The client is configured not to create a new Session.",

                         UA_StatusCode_name(client->connectStatus));

            closeSecureChannel(client);

        } else {

            UA_LOG_WARNING(config->logging, UA_LOGCATEGORY_CLIENT,

                           "Session no longer valid. A new Session is created for the next "

                           "Service request but we do not re-send the current request.");

        }

    }

    /* Prepare the notification payload */

    UA_ApplicationNotificationType nt;

    static UA_THREAD_LOCAL UA_KeyValuePair notifyPayload[4] = {

        {{0, UA_STRING_STATIC("securechannel-id")}, {0}},

        {{0, UA_STRING_STATIC("session-id")}, {0}},

        {{0, UA_STRING_STATIC("request-id")}, {0}},

        {{0, UA_STRING_STATIC("service-type")}, {0}}

    };

    UA_KeyValueMap notifyPayloadMap = {4, notifyPayload};

    if(config->globalNotificationCallback || config->serviceNotificationCallback) {

        UA_Variant_setScalar(&notifyPayload[0].value,

                             &client->channel.securityToken.channelId,

                             &UA_TYPES[UA_TYPES_UINT32]);

        UA_Variant_setScalar(&notifyPayload[1].value, &client->sessionId,

                             &UA_TYPES[UA_TYPES_NODEID]);

        UA_Variant_setScalar(&notifyPayload[2].value, &requestId,

                             &UA_TYPES[UA_TYPES_UINT32]);

        UA_Variant_setScalar(&notifyPayload[3].value,

                             (void *)(uintptr_t)&ac->responseType->typeId,

                             &UA_TYPES[UA_TYPES_NODEID]);

    }

    if(ac->callback) {

        /* Notify with UA_APPLICATIONNOTIFICATIONTYPE_SERVICE_BEGIN before the

         * service response is processed asynchronously */

        nt = UA_APPLICATIONNOTIFICATIONTYPE_SERVICE_BEGIN;

        if(config->serviceNotificationCallback)

            config->serviceNotificationCallback(client, nt, notifyPayloadMap);

        if(config->globalNotificationCallback)

            config->globalNotificationCallback(client, nt, notifyPayloadMap);

        /* Call the async callback */

        ac->callback(client, ac->userdata, requestId, response);

    }

    /* Always notify with UA_APPLICATIONNOTIFICATIONTYPE_SERVICE_END that the

     * service was processed. For the synchronous case this gets called before

     * the response is returned together with the main control flow. */

    nt = UA_APPLICATIONNOTIFICATIONTYPE_SERVICE_END;

    if(config->serviceNotificationCallback)

        config->serviceNotificationCallback(client, nt, notifyPayloadMap);

    if(config->globalNotificationCallback)

        config->globalNotificationCallback(client, nt, notifyPayloadMap);

    /* Clean up */

    UA_NodeId_clear(&responseTypeId);

    if(!ac->syncResponse) {

        UA_clear(response, ac->responseType);

        UA_free(ac);

    } else {

        /* Return a special status code after processing a synchronous message.

         * This makes the client return control immediately. */

        ac->syncResponse = NULL; /* Indicate that response was received */

        if(retval == UA_STATUSCODE_GOOD)

            retval = UA_STATUSCODE_GOODCOMPLETESASYNCHRONOUSLY;

    }

    return retval;

}

UA_StatusCode

processServiceResponse(UA_Client *client, UA_SecureChannel *channel,

                       UA_MessageType messageType, UA_UInt32 requestId,

                       UA_ByteString *message) {

    if(!UA_SecureChannel_isConnected(channel)) {

        if(messageType == UA_MESSAGETYPE_MSG) {

            UA_LOG_DEBUG_CHANNEL(client->config.logging, channel, "Discard MSG message "

                                 "with RequestId %u as the SecureChannel is not connected",

                                 requestId);

        } else {

            UA_LOG_DEBUG_CHANNEL(client->config.logging, channel, "Discard message "

                                 "as the SecureChannel is not connected");

        }

        return UA_STATUSCODE_BADCONNECTIONCLOSED;

    }

    switch(messageType) {

    case UA_MESSAGETYPE_RHE:

        UA_LOG_DEBUG_CHANNEL(client->config.logging, channel, "Process RHE message");

        processRHEMessage(client, message);

        return UA_STATUSCODE_GOOD;

    case UA_MESSAGETYPE_ACK:

        UA_LOG_DEBUG_CHANNEL(client->config.logging, channel, "Process ACK message");

        processACKResponse(client, message);

        return UA_STATUSCODE_GOOD;

    case UA_MESSAGETYPE_OPN:

        UA_LOG_DEBUG_CHANNEL(client->config.logging, channel, "Process OPN message");

        processOPNResponse(client, message);

        return UA_STATUSCODE_GOOD;

    case UA_MESSAGETYPE_ERR:

        UA_LOG_DEBUG_CHANNEL(client->config.logging, channel, "Process ERR message");

        processERRResponse(client, message);

        return UA_STATUSCODE_GOOD;

    case UA_MESSAGETYPE_MSG:

        UA_LOG_DEBUG_CHANNEL(client->config.logging, channel, "Process MSG message "

                             "with RequestId %u", requestId);

        return processMSGResponse(client, requestId, message);

    default:

        UA_LOG_TRACE_CHANNEL(client->config.logging, channel,

                             "Invalid message type");

        channel->state = UA_SECURECHANNELSTATE_CLOSING;

        return UA_STATUSCODE_BADTCPMESSAGETYPEINVALID;

    }

}

void

__Client_Service(UA_Client *client, const void *request,

                 const UA_DataType *requestType, void *response,

                 const UA_DataType *responseType) {

    UA_ResponseHeader *respHeader = (UA_ResponseHeader*)response;

    /* Initialize. Response is valied in case of aborting. */

    UA_init(response, responseType);

    /* Verify that the EventLoop is running */

    UA_EventLoop *el = client->config.eventLoop;

    if(!el || el->state != UA_EVENTLOOPSTATE_STARTED) {

        respHeader->serviceResult = UA_STATUSCODE_BADINTERNALERROR;

        return;

    }

    /* Check that the SecureChannel is open and also a Session active (if we

     * want a Session). Otherwise reopen. */

    if(!isFullyConnected(client)) {

        UA_LOG_INFO(client->config.logging, UA_LOGCATEGORY_CLIENT,

                    "Re-establish the connection for the synchronous service call");

        connectSync(client);

        if(client->connectStatus != UA_STATUSCODE_GOOD) {

            respHeader->serviceResult = client->connectStatus;

            return;

        }

    }

    /* Store the channelId to detect if the channel was changed by a

     * reconnection within the EventLoop run method. */

    UA_UInt32 channelId = client->channel.securityToken.channelId;

    /* Send the request */

    UA_UInt32 requestId = 0;

    UA_StatusCode retval = sendRequest(client, request, requestType, &requestId);

    if(retval != UA_STATUSCODE_GOOD) {

        /* If sending failed, the status is set to closing. The SecureChannel is

         * the actually closed in the next iteration of the EventLoop. */

        UA_assert(client->channel.state == UA_SECURECHANNELSTATE_CLOSING ||

                  client->channel.state == UA_SECURECHANNELSTATE_CLOSED);

        UA_LOG_WARNING(client->config.logging, UA_LOGCATEGORY_CLIENT,

                       "Sending the request failed with status %s",

                       UA_StatusCode_name(retval));

        notifyClientState(client);

        respHeader->serviceResult = retval;

        return;

    }

    /* Temporarily insert an AsyncServiceCall */

    const UA_RequestHeader *rh = (const UA_RequestHeader*)request;

    AsyncServiceCall ac;

    ac.callback = NULL;

    ac.userdata = NULL;

    ac.responseType = responseType;

    ac.syncResponse = (UA_Response*)response;

    ac.requestId = requestId;

    ac.start = el->dateTime_nowMonotonic(el); /* Start timeout after sending */

    ac.timeout = rh->timeoutHint;

    ac.requestHandle = rh->requestHandle;

    if(ac.timeout == 0)

        ac.timeout = UA_UINT32_MAX; /* 0 -> unlimited */

    LIST_INSERT_HEAD(&client->asyncServiceCalls, &ac, pointers);

    /* Time until which the request has to be answered */

    UA_DateTime maxDate = ac.start + ((UA_DateTime)ac.timeout * UA_DATETIME_MSEC);

    /* Run the EventLoop until the request was processed, the request has timed

     * out or the client connection fails */

    UA_UInt32 timeout_remaining = ac.timeout;

    while(true) {

        /* Unlock before dropping into the EventLoop. The client lock is

         * re-taken in the network callback if an event occurs. */

        retval = el->run(el, timeout_remaining);

        /* Was the response received? In that case we can directly return. The

         * ac was already removed from the internal linked list. */

        if(ac.syncResponse == NULL)

            return;

        /* Check the status. Do not try to resend if the connection breaks.

         * Leave this to the application-level user. For example, we do not want

         * to call a method twice is the connection broke after sending the

         * request. */

        if(retval != UA_STATUSCODE_GOOD)

            break;

        /* The connection was lost */

        retval = client->connectStatus;

        if(retval != UA_STATUSCODE_GOOD)

            break;

        /* The channel is no longer the same or was closed */

        if(channelId != client->channel.securityToken.channelId) {

            retval = UA_STATUSCODE_BADSECURECHANNELCLOSED;

            break;

        }

        /* Update the remaining timeout or break */

        UA_DateTime now = ac.start = el->dateTime_nowMonotonic(el);

        if(now > maxDate) {

            retval = UA_STATUSCODE_BADTIMEOUT;

            break;

        }

        timeout_remaining = (UA_UInt32)((maxDate - now) / UA_DATETIME_MSEC);

    }

    /* Detach from the internal async service list */

    LIST_REMOVE(&ac, pointers);

    /* Return the status code */

    respHeader->serviceResult = retval;

}

/***********************************/

/* Handling of Async Service Calls */

/***********************************/

static void

__Client_AsyncService_cancel(UA_Client *client, AsyncServiceCall *ac,

                             UA_StatusCode statusCode) {

    /* Set the status for the synchronous service call. Don't free the ac. */

    if(ac->syncResponse) {

        ac->syncResponse->responseHeader.serviceResult = statusCode;

        ac->syncResponse = NULL; /* Indicate the async service call was processed */

        return;

    }

    if(ac->callback) {

        /* Create an empty response with the statuscode and call the callback */

        UA_Response response;

        UA_init(&response, ac->responseType);

        response.responseHeader.serviceResult = statusCode;

        ac->callback(client, ac->userdata, ac->requestId, &response);

        /* Clean up the response. The user callback might move data into it. For

         * whatever reasons. */

        UA_clear(&response, ac->responseType);

    }

    UA_free(ac);

}

void

__Client_AsyncService_removeAll(UA_Client *client, UA_StatusCode statusCode) {

    /* Make this function reentrant. One of the async callbacks could indirectly

     * operate on the list. Moving all elements to a local list before iterating

     * that. */

    UA_AsyncServiceList asyncServiceCalls = client->asyncServiceCalls;

    LIST_INIT(&client->asyncServiceCalls);

    if(asyncServiceCalls.lh_first)

        asyncServiceCalls.lh_first->pointers.le_prev = &asyncServiceCalls.lh_first;

    /* Cancel and remove the elements from the local list */

    AsyncServiceCall *ac, *ac_tmp;

    LIST_FOREACH_SAFE(ac, &asyncServiceCalls, pointers, ac_tmp) {

        LIST_REMOVE(ac, pointers);

        __Client_AsyncService_cancel(client, ac, statusCode);

    }

}

UA_StatusCode

__Client_AsyncService(UA_Client *client, const void *request,

                      const UA_DataType *requestType,

                      UA_ClientAsyncServiceCallback callback,

                      const UA_DataType *responseType,

                      void *userdata, UA_UInt32 *requestId) {

    UA_LOCK_ASSERT(&client->clientMutex);

    /* Is the SecureChannel connected? */

    if(client->channel.state != UA_SECURECHANNELSTATE_OPEN) {

        UA_LOG_ERROR(client->config.logging, UA_LOGCATEGORY_CLIENT,

                     "SecureChannel must be connected to send request");

        return UA_STATUSCODE_BADSERVERNOTCONNECTED;

    }

    /* Prepare the entry for the linked list */

    AsyncServiceCall *ac = (AsyncServiceCall*)UA_malloc(sizeof(AsyncServiceCall));

    if(!ac)

        return UA_STATUSCODE_BADOUTOFMEMORY;

    /* Call the service and set the requestId */

    UA_StatusCode retval = sendRequest(client, request, requestType, &ac->requestId);

    if(retval != UA_STATUSCODE_GOOD) {

        /* If sending failed, the status is set to closing. The SecureChannel is

         * the actually closed in the next iteration of the EventLoop. */

        UA_assert(client->channel.state == UA_SECURECHANNELSTATE_CLOSING ||

                  client->channel.state == UA_SECURECHANNELSTATE_CLOSED);

        UA_free(ac);

        notifyClientState(client);

        return retval;

    }

    /* Set up the AsyncServiceCall for processing the response */

    UA_EventLoop *el = client->config.eventLoop;

    const UA_RequestHeader *rh = (const UA_RequestHeader*)request;

    ac->callback = callback;

    ac->responseType = responseType;

    ac->userdata = userdata;

    ac->syncResponse = NULL;

    ac->start = el->dateTime_nowMonotonic(el);

    ac->timeout = rh->timeoutHint;

    ac->requestHandle = rh->requestHandle;

    if(ac->timeout == 0)

        ac->timeout = UA_UINT32_MAX; /* 0 -> unlimited */

    LIST_INSERT_HEAD(&client->asyncServiceCalls, ac, pointers);

    /* Return the generated request id */

    if(requestId)

        *requestId = ac->requestId;

    /* Notify the userland if a change happened */

    notifyClientState(client);

    return UA_STATUSCODE_GOOD;

}