partial revert, and followed the propsal of @FlorianPalm, #212

README.md

@@ -45,7 +45,7 @@ int main(int argc, char** argv) {
     signal(SIGINT, signalHandler);
 
     /* init the server */
-    UA_Server *server = UA_Server_new();
+    UA_Server *server = UA_Server_new(NULL);
     UA_Server_addNetworkLayer(server,
         ServerNetworkLayerTCP_new(UA_ConnectionConfig_standard, PORT));
     UA_Server_setLogger(server, Logger_Stdout_new());

examples/client.c

@@ -10,8 +10,10 @@
 #include "networklayer_tcp.h"
 
 int main(int argc, char *argv[]) {
-    UA_Client *client = UA_Client_new();
-    client->config.timeout=500;
+    UA_ClientConfig config;
+    UA_ClientConfig_init(&config);
+    config.timeout = 500;
+    UA_Client *client = UA_Client_new(&config);
     UA_ClientNetworkLayer nl = ClientNetworkLayerTCP_new(UA_ConnectionConfig_standard);
     UA_StatusCode retval = UA_Client_connect(client, UA_ConnectionConfig_standard, nl,
             "opc.tcp://localhost:16664");
@@ -29,7 +31,7 @@ int main(int argc, char *argv[]) {
     bReq.nodesToBrowse = UA_BrowseDescription_new();
     bReq.nodesToBrowseSize = 1;
     bReq.nodesToBrowse[0].nodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER); //browse objects folder
-    bReq.nodesToBrowse[0].resultMask = UA_BROWSERESULTMASK_ALL;	//return everything
+    bReq.nodesToBrowse[0].resultMask = UA_BROWSERESULTMASK_ALL; //return everything
 
     UA_BrowseResponse bResp = UA_Client_browse(client, &bReq);
     printf("%-9s %-16s %-16s %-16s\n", "NAMESPACE", "NODEID", "BROWSE NAME", "DISPLAY NAME");
@@ -59,9 +61,9 @@ int main(int argc, char *argv[]) {
 
     UA_ReadResponse rResp = UA_Client_read(client, &rReq);
     if(rResp.responseHeader.serviceResult == UA_STATUSCODE_GOOD &&
-            rResp.resultsSize > 0 && rResp.results[0].hasValue &&
-            rResp.results[0].value.data /* an empty array returns a null-ptr */ &&
-            rResp.results[0].value.type == &UA_TYPES[UA_TYPES_INT32]){
+       rResp.resultsSize > 0 && rResp.results[0].hasValue &&
+       rResp.results[0].value.data /* an empty array returns a null-ptr */ &&
+       rResp.results[0].value.type == &UA_TYPES[UA_TYPES_INT32]){
         value = *(UA_Int32*)rResp.results[0].value.data;
         printf("the value is: %i\n", value);
     }
@@ -85,7 +87,7 @@ int main(int argc, char *argv[]) {
 
     UA_WriteResponse wResp = UA_Client_write(client, &wReq);
     if(wResp.responseHeader.serviceResult == UA_STATUSCODE_GOOD)
-        printf("the new value is: %i\n", value);
+            printf("the new value is: %i\n", value);
 
     UA_WriteRequest_deleteMembers(&wReq);
     UA_WriteResponse_deleteMembers(&wResp);

include/ua_client.h

@@ -15,7 +15,7 @@ extern "C" {
  * is only concerned with getting messages to the client and receiving them.
  */
 typedef struct {
-	void *nlHandle;
+    void *nlHandle;
 
     UA_StatusCode (*connect)(const UA_String endpointUrl, void **resultHandle);
     void (*disconnect)(void *handle);
@@ -25,19 +25,17 @@ typedef struct {
     UA_StatusCode (*awaitResponse)(void *handle, UA_ByteString *response, UA_UInt32 timeout);
 } UA_ClientNetworkLayer;
 
+struct UA_Client;
+typedef struct UA_Client UA_Client;
 
 typedef struct UA_ClientConfig {
-	UA_Int32 timeout; //sync resonse timeout
+    UA_Int32 timeout; //sync resonse timeout
 } UA_ClientConfig;
 
-/*
- * This is the 'public part' of UA_Client_private
- */
-typedef struct UA_Client {
-	UA_ClientConfig config;
-} UA_Client;
+void UA_EXPORT UA_ClientConfig_init(UA_ClientConfig* config);
+
+UA_Client UA_EXPORT * UA_Client_new(UA_ClientConfig* config);
 
-UA_Client UA_EXPORT * UA_Client_new(void);
 void UA_Client_delete(UA_Client* client);
 
 UA_StatusCode UA_EXPORT UA_Client_connect(UA_Client *client, UA_ConnectionConfig conf,

src/client/ua_client.c

@@ -4,13 +4,8 @@
 #include "ua_types_encoding_binary.h"
 #include "ua_transport_generated.h"
 
-typedef struct UA_Client_private {
-	/*** public ***/
-    /* Config */
-    UA_ClientConfig config;
-
-    /*** private ***/
-	/* Connection */
+struct UA_Client {
+    /* Connection */
     UA_ClientNetworkLayer networkLayer;
     UA_String endpointUrl;
     UA_Connection connection;
@@ -22,16 +17,24 @@ typedef struct UA_Client_private {
     UA_ChannelSecurityToken securityToken;
     UA_ByteString clientNonce;
     UA_ByteString serverNonce;
-	/* UA_SequenceHeader sequenceHdr; */
-	/* UA_NodeId authenticationToken; */
+    /* UA_SequenceHeader sequenceHdr; */
+    /* UA_NodeId authenticationToken; */
 
     /* Session */
     UA_NodeId sessionId;
     UA_NodeId authenticationToken;
-} UA_Client_private;
 
-UA_Client * UA_Client_new(void) {
-    UA_Client_private *client = UA_malloc(sizeof(UA_Client_private));
+    /* Config */
+    UA_ClientConfig config;
+};
+
+/* Default config values */
+void UA_ClientConfig_init(UA_ClientConfig* config){
+    config->timeout = 500;
+}
+
+UA_Client * UA_Client_new(UA_ClientConfig* config) {
+    UA_Client *client = UA_malloc(sizeof(UA_Client));
     if(!client)
         return UA_NULL;
     UA_String_init(&client->endpointUrl);
@@ -48,14 +51,16 @@ UA_Client * UA_Client_new(void) {
     
     UA_NodeId_init(&client->authenticationToken);
 
-    /* default clientConfig */
-    client->config.timeout = 500;
+    if(config){
+        client->config = *config;
+    }else{
+        UA_ClientConfig_init(&client->config);
+    }
 
-    return (UA_Client*)client;
+    return client;
 }
 
-void UA_Client_delete(UA_Client* clientPublic){
-	UA_Client_private* client = (UA_Client_private*) clientPublic;
+void UA_Client_delete(UA_Client* client){
     client->networkLayer.destroy(client->networkLayer.nlHandle);
     UA_String_deleteMembers(&client->endpointUrl);
     // client->connection
@@ -68,29 +73,29 @@ void UA_Client_delete(UA_Client* clientPublic){
 }
 
 // The tcp connection is established. Now do the handshake
-static UA_StatusCode HelAckHandshake(UA_Client_private *c) {
-	UA_TcpMessageHeader messageHeader;
+static UA_StatusCode HelAckHandshake(UA_Client *c) {
+    UA_TcpMessageHeader messageHeader;
     messageHeader.messageTypeAndFinal = UA_MESSAGETYPEANDFINAL_HELF;
 
-	UA_TcpHelloMessage hello;
-	UA_String_copy(&c->endpointUrl, &hello.endpointUrl);
+    UA_TcpHelloMessage hello;
+    UA_String_copy(&c->endpointUrl, &hello.endpointUrl);
 
     UA_Connection *conn = &c->connection;
-	hello.maxChunkCount = conn->localConf.maxChunkCount;
-	hello.maxMessageSize = conn->localConf.maxMessageSize;
-	hello.protocolVersion = conn->localConf.protocolVersion;
-	hello.receiveBufferSize = conn->localConf.recvBufferSize;
-	hello.sendBufferSize = conn->localConf.sendBufferSize;
+    hello.maxChunkCount = conn->localConf.maxChunkCount;
+    hello.maxMessageSize = conn->localConf.maxMessageSize;
+    hello.protocolVersion = conn->localConf.protocolVersion;
+    hello.receiveBufferSize = conn->localConf.recvBufferSize;
+    hello.sendBufferSize = conn->localConf.sendBufferSize;
 
-	messageHeader.messageSize = UA_TcpHelloMessage_calcSizeBinary((UA_TcpHelloMessage const*)&hello) +
+    messageHeader.messageSize = UA_TcpHelloMessage_calcSizeBinary((UA_TcpHelloMessage const*)&hello) +
                                 UA_TcpMessageHeader_calcSizeBinary((UA_TcpMessageHeader const*)&messageHeader);
-	UA_ByteString message;
+    UA_ByteString message;
     message.data = UA_alloca(messageHeader.messageSize);
     message.length = messageHeader.messageSize;
 
-	size_t offset = 0;
-	UA_TcpMessageHeader_encodeBinary(&messageHeader, &message, &offset);
-	UA_TcpHelloMessage_encodeBinary(&hello, &message, &offset);
+    size_t offset = 0;
+    UA_TcpMessageHeader_encodeBinary(&messageHeader, &message, &offset);
+    UA_TcpHelloMessage_encodeBinary(&hello, &message, &offset);
     UA_TcpHelloMessage_deleteMembers(&hello);
 
     UA_ByteStringArray buf = {.stringsSize = 1, .strings = &message};
@@ -101,11 +106,11 @@ static UA_StatusCode HelAckHandshake(UA_Client_private *c) {
     UA_Byte replybuf[1024];
     UA_ByteString reply = {.data = replybuf, .length = 1024};
     retval = c->networkLayer.awaitResponse(c->networkLayer.nlHandle, &reply, c->config.timeout * 1000);
-	if (retval)
-		return retval;
+    if (retval)
+        return retval;
 
     offset = 0;
-	UA_TcpMessageHeader_decodeBinary(&reply, &offset, &messageHeader);
+    UA_TcpMessageHeader_decodeBinary(&reply, &offset, &messageHeader);
     UA_TcpAcknowledgeMessage ackMessage;
     retval = UA_TcpAcknowledgeMessage_decodeBinary(&reply, &offset, &ackMessage);
     if(retval != UA_STATUSCODE_GOOD) {
@@ -120,59 +125,59 @@ static UA_StatusCode HelAckHandshake(UA_Client_private *c) {
     conn->state = UA_CONNECTION_ESTABLISHED;
 
     UA_TcpAcknowledgeMessage_deleteMembers(&ackMessage);
-	return UA_STATUSCODE_GOOD;
+    return UA_STATUSCODE_GOOD;
 }
 
-static UA_StatusCode SecureChannelHandshake(UA_Client_private *client) {
+static UA_StatusCode SecureChannelHandshake(UA_Client *client) {
     UA_ByteString_deleteMembers(&client->clientNonce); // if the handshake is repeated
-	UA_ByteString_newMembers(&client->clientNonce, 1);
-	client->clientNonce.data[0] = 0;
+    UA_ByteString_newMembers(&client->clientNonce, 1);
+    client->clientNonce.data[0] = 0;
 
-	UA_SecureConversationMessageHeader messageHeader;
-	messageHeader.messageHeader.messageTypeAndFinal = UA_MESSAGETYPEANDFINAL_OPNF;
-	messageHeader.secureChannelId = 0;
+    UA_SecureConversationMessageHeader messageHeader;
+    messageHeader.messageHeader.messageTypeAndFinal = UA_MESSAGETYPEANDFINAL_OPNF;
+    messageHeader.secureChannelId = 0;
 
-	UA_SequenceHeader seqHeader;
+    UA_SequenceHeader seqHeader;
     seqHeader.sequenceNumber = ++client->sequenceNumber;
     seqHeader.requestId = ++client->requestId;
 
-	UA_AsymmetricAlgorithmSecurityHeader asymHeader;
-	UA_AsymmetricAlgorithmSecurityHeader_init(&asymHeader);
-	asymHeader.securityPolicyUri = UA_STRING_ALLOC("http://opcfoundation.org/UA/SecurityPolicy#None");
+    UA_AsymmetricAlgorithmSecurityHeader asymHeader;
+    UA_AsymmetricAlgorithmSecurityHeader_init(&asymHeader);
+    asymHeader.securityPolicyUri = UA_STRING_ALLOC("http://opcfoundation.org/UA/SecurityPolicy#None");
 
     /* id of opensecurechannelrequest */
-	UA_NodeId requestType = UA_NODEID_NUMERIC(0, UA_NS0ID_OPENSECURECHANNELREQUEST + UA_ENCODINGOFFSET_BINARY);
+    UA_NodeId requestType = UA_NODEID_NUMERIC(0, UA_NS0ID_OPENSECURECHANNELREQUEST + UA_ENCODINGOFFSET_BINARY);
 
-	UA_OpenSecureChannelRequest opnSecRq;
-	UA_OpenSecureChannelRequest_init(&opnSecRq);
-	opnSecRq.requestHeader.timestamp = UA_DateTime_now();
+    UA_OpenSecureChannelRequest opnSecRq;
+    UA_OpenSecureChannelRequest_init(&opnSecRq);
+    opnSecRq.requestHeader.timestamp = UA_DateTime_now();
     UA_ByteString_copy(&client->clientNonce, &opnSecRq.clientNonce);
-	opnSecRq.requestedLifetime = 30000;
-	opnSecRq.securityMode = UA_MESSAGESECURITYMODE_NONE;
-	opnSecRq.requestType = UA_SECURITYTOKENREQUESTTYPE_ISSUE;
-	opnSecRq.requestHeader.authenticationToken.identifier.numeric = 10;
-	opnSecRq.requestHeader.authenticationToken.identifierType = UA_NODEIDTYPE_NUMERIC;
-	opnSecRq.requestHeader.authenticationToken.namespaceIndex = 10;
-
-	messageHeader.messageHeader.messageSize =
+    opnSecRq.requestedLifetime = 30000;
+    opnSecRq.securityMode = UA_MESSAGESECURITYMODE_NONE;
+    opnSecRq.requestType = UA_SECURITYTOKENREQUESTTYPE_ISSUE;
+    opnSecRq.requestHeader.authenticationToken.identifier.numeric = 10;
+    opnSecRq.requestHeader.authenticationToken.identifierType = UA_NODEIDTYPE_NUMERIC;
+    opnSecRq.requestHeader.authenticationToken.namespaceIndex = 10;
+
+    messageHeader.messageHeader.messageSize =
         UA_SecureConversationMessageHeader_calcSizeBinary(&messageHeader) +
         UA_AsymmetricAlgorithmSecurityHeader_calcSizeBinary(&asymHeader) +
         UA_SequenceHeader_calcSizeBinary(&seqHeader) +
         UA_NodeId_calcSizeBinary(&requestType) +
         UA_OpenSecureChannelRequest_calcSizeBinary(&opnSecRq);
 
-	UA_ByteString message;
+    UA_ByteString message;
     message.data = UA_alloca(messageHeader.messageHeader.messageSize);
     message.length = messageHeader.messageHeader.messageSize;
 
-	size_t offset = 0;
-	UA_SecureConversationMessageHeader_encodeBinary(&messageHeader, &message, &offset);
-	UA_AsymmetricAlgorithmSecurityHeader_encodeBinary(&asymHeader, &message, &offset);
-	UA_SequenceHeader_encodeBinary(&seqHeader, &message, &offset);
-	UA_NodeId_encodeBinary(&requestType, &message, &offset);
-	UA_OpenSecureChannelRequest_encodeBinary(&opnSecRq, &message, &offset);
+    size_t offset = 0;
+    UA_SecureConversationMessageHeader_encodeBinary(&messageHeader, &message, &offset);
+    UA_AsymmetricAlgorithmSecurityHeader_encodeBinary(&asymHeader, &message, &offset);
+    UA_SequenceHeader_encodeBinary(&seqHeader, &message, &offset);
+    UA_NodeId_encodeBinary(&requestType, &message, &offset);
+    UA_OpenSecureChannelRequest_encodeBinary(&opnSecRq, &message, &offset);
 
-	UA_AsymmetricAlgorithmSecurityHeader_deleteMembers(&asymHeader);
+    UA_AsymmetricAlgorithmSecurityHeader_deleteMembers(&asymHeader);
     UA_OpenSecureChannelRequest_deleteMembers(&opnSecRq);
 
     UA_ByteStringArray buf = {.stringsSize = 1, .strings = &message};
@@ -192,21 +197,21 @@ static UA_StatusCode SecureChannelHandshake(UA_Client_private *client) {
         reply = UA_Connection_completeMessages(&client->connection, reply);
     } while(reply.length < 0);
 
-	offset = 0;
-	UA_SecureConversationMessageHeader_decodeBinary(&reply, &offset, &messageHeader);
-	UA_AsymmetricAlgorithmSecurityHeader_decodeBinary(&reply, &offset, &asymHeader);
-	UA_SequenceHeader_decodeBinary(&reply, &offset, &seqHeader);
-	UA_NodeId_decodeBinary(&reply, &offset, &requestType);
+    offset = 0;
+    UA_SecureConversationMessageHeader_decodeBinary(&reply, &offset, &messageHeader);
+    UA_AsymmetricAlgorithmSecurityHeader_decodeBinary(&reply, &offset, &asymHeader);
+    UA_SequenceHeader_decodeBinary(&reply, &offset, &seqHeader);
+    UA_NodeId_decodeBinary(&reply, &offset, &requestType);
 
-	if(!UA_NodeId_equal(&requestType, &UA_NODEID_NUMERIC(0, UA_NS0ID_OPENSECURECHANNELRESPONSE +
+    if(!UA_NodeId_equal(&requestType, &UA_NODEID_NUMERIC(0, UA_NS0ID_OPENSECURECHANNELRESPONSE +
                                                         UA_ENCODINGOFFSET_BINARY))) {
         UA_ByteString_deleteMembers(&reply);
         UA_AsymmetricAlgorithmSecurityHeader_deleteMembers(&asymHeader);
         return UA_STATUSCODE_BADINTERNALERROR;
     }
 
-	UA_OpenSecureChannelResponse response;
-	UA_OpenSecureChannelResponse_decodeBinary(&reply, &offset, &response);
+    UA_OpenSecureChannelResponse response;
+    UA_OpenSecureChannelResponse_decodeBinary(&reply, &offset, &response);
     UA_ByteString_deleteMembers(&reply);
     retval = response.responseHeader.serviceResult;
 
@@ -216,8 +221,8 @@ static UA_StatusCode SecureChannelHandshake(UA_Client_private *client) {
         UA_ByteString_copy(&response.serverNonce, &client->serverNonce);
     }
 
-	UA_OpenSecureChannelResponse_deleteMembers(&response);
-	UA_AsymmetricAlgorithmSecurityHeader_deleteMembers(&asymHeader);
+    UA_OpenSecureChannelResponse_deleteMembers(&response);
+    UA_AsymmetricAlgorithmSecurityHeader_deleteMembers(&asymHeader);
     return retval;
 
 }
@@ -225,39 +230,39 @@ static UA_StatusCode SecureChannelHandshake(UA_Client_private *client) {
 /** If the request fails, then the response is cast to UA_ResponseHeader (at the beginning of every
     response) and filled with the appropriate error code */
 static void sendReceiveRequest(UA_RequestHeader *request, const UA_DataType *requestType,
-                               void *response, const UA_DataType *responseType, UA_Client_private *client,
+                               void *response, const UA_DataType *responseType, UA_Client *client,
                                UA_Boolean sendOnly)
 {
-	if(response)
-		UA_init(response, responseType);
+    if(response)
+        UA_init(response, responseType);
 
     UA_NodeId_copy(&client->authenticationToken, &request->authenticationToken);
 
     UA_SecureConversationMessageHeader msgHeader;
     if(sendOnly)
-    	msgHeader.messageHeader.messageTypeAndFinal = UA_MESSAGETYPEANDFINAL_CLOF;
+        msgHeader.messageHeader.messageTypeAndFinal = UA_MESSAGETYPEANDFINAL_CLOF;
     else
-    	msgHeader.messageHeader.messageTypeAndFinal = UA_MESSAGETYPEANDFINAL_MSGF;
+        msgHeader.messageHeader.messageTypeAndFinal = UA_MESSAGETYPEANDFINAL_MSGF;
     msgHeader.secureChannelId = client->securityToken.channelId;
 
     UA_SymmetricAlgorithmSecurityHeader symHeader;
     symHeader.tokenId = client->securityToken.tokenId;
     
-	UA_SequenceHeader seqHeader;
+    UA_SequenceHeader seqHeader;
     seqHeader.sequenceNumber = ++client->sequenceNumber;
     seqHeader.requestId = ++client->requestId;
 
-	UA_NodeId requestId = UA_NODEID_NUMERIC(0, requestType->typeId.identifier.numeric +
+    UA_NodeId requestId = UA_NODEID_NUMERIC(0, requestType->typeId.identifier.numeric +
                                            UA_ENCODINGOFFSET_BINARY);
 
-	msgHeader.messageHeader.messageSize =
+    msgHeader.messageHeader.messageSize =
         UA_SecureConversationMessageHeader_calcSizeBinary(&msgHeader) +
         UA_SymmetricAlgorithmSecurityHeader_calcSizeBinary(&symHeader) +
         UA_SequenceHeader_calcSizeBinary(&seqHeader) +
         UA_NodeId_calcSizeBinary(&requestId) +
         UA_calcSizeBinary(request, requestType);
 
-	UA_ByteString message;
+    UA_ByteString message;
     UA_StatusCode retval = UA_ByteString_newMembers(&message, msgHeader.messageHeader.messageSize);
     if(retval != UA_STATUSCODE_GOOD) {
         // todo
@@ -277,7 +282,7 @@ static void sendReceiveRequest(UA_RequestHeader *request, const UA_DataType *req
 
     //TODO: rework to get return value
     if(sendOnly)
-    	return;
+        return;
 
     UA_ResponseHeader *respHeader = (UA_ResponseHeader*)response;
     if(retval != UA_STATUSCODE_GOOD) {
@@ -298,14 +303,14 @@ static void sendReceiveRequest(UA_RequestHeader *request, const UA_DataType *req
         reply = UA_Connection_completeMessages(&client->connection, reply);
     } while(reply.length < 0);
 
-	offset = 0;
-	retval |= UA_SecureConversationMessageHeader_decodeBinary(&reply, &offset, &msgHeader);
-	retval |= UA_SymmetricAlgorithmSecurityHeader_decodeBinary(&reply, &offset, &symHeader);
-	retval |= UA_SequenceHeader_decodeBinary(&reply, &offset, &seqHeader);
+    offset = 0;
+    retval |= UA_SecureConversationMessageHeader_decodeBinary(&reply, &offset, &msgHeader);
+    retval |= UA_SymmetricAlgorithmSecurityHeader_decodeBinary(&reply, &offset, &symHeader);
+    retval |= UA_SequenceHeader_decodeBinary(&reply, &offset, &seqHeader);
     UA_NodeId responseId;
-	retval |= UA_NodeId_decodeBinary(&reply, &offset, &responseId);
+    retval |= UA_NodeId_decodeBinary(&reply, &offset, &responseId);
 
-	if(!UA_NodeId_equal(&responseId, &UA_NODEID_NUMERIC(0, responseType->typeId.identifier.numeric +
+    if(!UA_NodeId_equal(&responseId, &UA_NODEID_NUMERIC(0, responseType->typeId.identifier.numeric +
                                                        UA_ENCODINGOFFSET_BINARY))) {
         UA_ByteString_deleteMembers(&reply);
         UA_SymmetricAlgorithmSecurityHeader_deleteMembers(&symHeader);
@@ -313,20 +318,20 @@ static void sendReceiveRequest(UA_RequestHeader *request, const UA_DataType *req
         return;
     }
 
-	retval = UA_decodeBinary(&reply, &offset, response, responseType);
+    retval = UA_decodeBinary(&reply, &offset, response, responseType);
     UA_ByteString_deleteMembers(&reply);
     if(retval != UA_STATUSCODE_GOOD)
         respHeader->serviceResult = retval;
 }
 
 static void synchronousRequest(void *request, const UA_DataType *requestType,
-                               void *response, const UA_DataType *responseType, UA_Client_private *client){
-	sendReceiveRequest(request, requestType, response, responseType, client, UA_FALSE);
+                               void *response, const UA_DataType *responseType, UA_Client *client){
+    sendReceiveRequest(request, requestType, response, responseType, client, UA_FALSE);
 }
 
-static UA_StatusCode ActivateSession(UA_Client_private *client) {
-	UA_ActivateSessionRequest request;
-	UA_ActivateSessionRequest_init(&request);
+static UA_StatusCode ActivateSession(UA_Client *client) {
+    UA_ActivateSessionRequest request;
+    UA_ActivateSessionRequest_init(&request);
 
     request.requestHeader.requestHandle = 2; //TODO: is it a magic number?
     request.requestHeader.authenticationToken = client->authenticationToken;
@@ -343,7 +348,8 @@ static UA_StatusCode ActivateSession(UA_Client_private *client) {
     return response.responseHeader.serviceResult; // not deleted
 }
 
-static UA_StatusCode SessionHandshake(UA_Client_private *client) {
+static UA_StatusCode SessionHandshake(UA_Client *client) {
+
     UA_CreateSessionRequest request;
     UA_CreateSessionRequest_init(&request);
 
@@ -351,14 +357,14 @@ static UA_StatusCode SessionHandshake(UA_Client_private *client) {
     UA_NodeId_copy(&client->authenticationToken, &request.requestHeader.authenticationToken);
 
     request.requestHeader.timestamp = UA_DateTime_now();
-	request.requestHeader.timeoutHint = 10000;
+    request.requestHeader.timeoutHint = 10000;
     UA_ByteString_copy(&client->clientNonce, &request.clientNonce);
-	request.requestedSessionTimeout = 1200000;
-	request.maxResponseMessageSize = UA_INT32_MAX;
+    request.requestedSessionTimeout = 1200000;
+    request.maxResponseMessageSize = UA_INT32_MAX;
 
-	/* UA_String_copy(endpointUrl, &rq.endpointUrl); */
-	/* UA_String_copycstring("mysession", &rq.sessionName); */
-	/* UA_String_copycstring("abcd", &rq.clientCertificate); */
+    /* UA_String_copy(endpointUrl, &rq.endpointUrl); */
+    /* UA_String_copycstring("mysession", &rq.sessionName); */
+    /* UA_String_copycstring("abcd", &rq.clientCertificate); */
 
     UA_CreateSessionResponse response;
     UA_CreateSessionResponse_init(&response);
@@ -373,15 +379,14 @@ static UA_StatusCode SessionHandshake(UA_Client_private *client) {
     return response.responseHeader.serviceResult; // not deleted
 }
 
-static UA_StatusCode CloseSession(UA_Client *clientPublic) {
-	UA_Client_private* client = (UA_Client_private*) clientPublic;
-	UA_CloseSessionRequest request;
-	UA_CloseSessionRequest_init(&request);
+static UA_StatusCode CloseSession(UA_Client *client) {
+    UA_CloseSessionRequest request;
+    UA_CloseSessionRequest_init(&request);
 
-	request.requestHeader.timestamp = UA_DateTime_now();
-	request.requestHeader.timeoutHint = 10000;
-	request.deleteSubscriptions = UA_TRUE;
-	UA_NodeId_copy(&client->authenticationToken, &request.requestHeader.authenticationToken);
+    request.requestHeader.timestamp = UA_DateTime_now();
+    request.requestHeader.timeoutHint = 10000;
+    request.deleteSubscriptions = UA_TRUE;
+    UA_NodeId_copy(&client->authenticationToken, &request.requestHeader.authenticationToken);
     UA_CreateSessionResponse response;
     synchronousRequest(&request, &UA_TYPES[UA_TYPES_CLOSESESSIONREQUEST],
                        &response, &UA_TYPES[UA_TYPES_CLOSESESSIONRESPONSE],
@@ -392,16 +397,15 @@ static UA_StatusCode CloseSession(UA_Client *clientPublic) {
     return response.responseHeader.serviceResult; // not deleted
 }
 
-static UA_StatusCode CloseSecureChannel(UA_Client *clientPublic) {
-	UA_Client_private* client = (UA_Client_private*) clientPublic;
-	UA_CloseSecureChannelRequest request;
+static UA_StatusCode CloseSecureChannel(UA_Client *client) {
+    UA_CloseSecureChannelRequest request;
     UA_CloseSecureChannelRequest_init(&request);
 
     request.requestHeader.requestHandle = 1; //TODO: magic number?
     request.requestHeader.timestamp = UA_DateTime_now();
     request.requestHeader.timeoutHint = 10000;
     request.requestHeader.authenticationToken = client->authenticationToken;
-	sendReceiveRequest(&request.requestHeader, &UA_TYPES[UA_TYPES_CLOSESECURECHANNELREQUEST], UA_NULL, UA_NULL,
+    sendReceiveRequest(&request.requestHeader, &UA_TYPES[UA_TYPES_CLOSESECURECHANNELREQUEST], UA_NULL, UA_NULL,
                        client, UA_TRUE);
 
     return UA_STATUSCODE_GOOD;
@@ -413,10 +417,9 @@ static UA_StatusCode CloseSecureChannel(UA_Client *clientPublic) {
 /*************************/
 
 
-UA_StatusCode UA_Client_connect(UA_Client *clientPublic, UA_ConnectionConfig conf,
+UA_StatusCode UA_Client_connect(UA_Client *client, UA_ConnectionConfig conf,
                                 UA_ClientNetworkLayer networkLayer, char *endpointUrl)
 {
-	UA_Client_private* client = (UA_Client_private*) clientPublic;
     client->endpointUrl = UA_STRING_ALLOC(endpointUrl);
     if(client->endpointUrl.length < 0)
         return UA_STATUSCODE_BADOUTOFMEMORY;
@@ -439,76 +442,68 @@ UA_StatusCode UA_Client_connect(UA_Client *clientPublic, UA_ConnectionConfig con
 
 
 UA_StatusCode UA_EXPORT UA_Client_disconnect(UA_Client *client) {
-	UA_StatusCode retval;
-	retval = CloseSession(client);
+    UA_StatusCode retval;
+    retval = CloseSession(client);
     if(retval == UA_STATUSCODE_GOOD)
         retval = CloseSecureChannel(client);
     return retval;
 }
 
 UA_ReadResponse UA_Client_read(UA_Client *client, UA_ReadRequest *request) {
-	UA_Client_private* clientPrivate = (UA_Client_private*)client;
     UA_ReadResponse response;
     synchronousRequest(request, &UA_TYPES[UA_TYPES_READREQUEST], &response,
-                       &UA_TYPES[UA_TYPES_READRESPONSE], clientPrivate);
+                       &UA_TYPES[UA_TYPES_READRESPONSE], client);
     return response;
 }
 
 UA_WriteResponse UA_Client_write(UA_Client *client, UA_WriteRequest *request) {
-	UA_Client_private* clientPrivate = (UA_Client_private*)client;
     UA_WriteResponse response;
     synchronousRequest(request, &UA_TYPES[UA_TYPES_WRITEREQUEST], &response,
-                       &UA_TYPES[UA_TYPES_WRITERESPONSE], clientPrivate);
+                       &UA_TYPES[UA_TYPES_WRITERESPONSE], client);
     return response;
 }
 
 UA_BrowseResponse UA_Client_browse(UA_Client *client, UA_BrowseRequest *request) {
-	UA_Client_private* clientPrivate = (UA_Client_private*)client;
     UA_BrowseResponse response;
     synchronousRequest(request, &UA_TYPES[UA_TYPES_BROWSEREQUEST], &response,
-                       &UA_TYPES[UA_TYPES_BROWSERESPONSE], clientPrivate);
+                       &UA_TYPES[UA_TYPES_BROWSERESPONSE], client);
     return response;
 }
 
 UA_TranslateBrowsePathsToNodeIdsResponse
     UA_Client_translateTranslateBrowsePathsToNodeIds(UA_Client *client,
                                                      UA_TranslateBrowsePathsToNodeIdsRequest *request) {
-	UA_Client_private* clientPrivate = (UA_Client_private*)client;
     UA_TranslateBrowsePathsToNodeIdsResponse response;
     synchronousRequest(request, &UA_TYPES[UA_TYPES_BROWSEREQUEST], &response,
-                       &UA_TYPES[UA_TYPES_BROWSERESPONSE], clientPrivate);
+                       &UA_TYPES[UA_TYPES_BROWSERESPONSE], client);
     return response;
 }
 
 UA_AddNodesResponse UA_Client_addNodes(UA_Client *client, UA_AddNodesRequest *request) {
-	UA_Client_private* clientPrivate = (UA_Client_private*)client;
     UA_AddNodesResponse response;
     synchronousRequest(request, &UA_TYPES[UA_TYPES_BROWSEREQUEST], &response,
-                       &UA_TYPES[UA_TYPES_BROWSERESPONSE], clientPrivate);
+                       &UA_TYPES[UA_TYPES_BROWSERESPONSE], client);
     return response;
 }
 
 UA_AddReferencesResponse UA_Client_addReferences(UA_Client *client, UA_AddReferencesRequest *request) {
-	UA_Client_private* clientPrivate = (UA_Client_private*)client;
     UA_AddReferencesResponse response;
     synchronousRequest(request, &UA_TYPES[UA_TYPES_BROWSEREQUEST], &response,
-                       &UA_TYPES[UA_TYPES_BROWSERESPONSE], clientPrivate);
+                       &UA_TYPES[UA_TYPES_BROWSERESPONSE], client);
     return response;
 }
 
 UA_DeleteNodesResponse UA_Client_deleteNodes(UA_Client *client, UA_DeleteNodesRequest *request) {
-	UA_Client_private* clientPrivate = (UA_Client_private*)client;
     UA_DeleteNodesResponse response;
     synchronousRequest(request, &UA_TYPES[UA_TYPES_BROWSEREQUEST], &response,
-                       &UA_TYPES[UA_TYPES_BROWSERESPONSE], clientPrivate);
+                       &UA_TYPES[UA_TYPES_BROWSERESPONSE], client);
     return response;
 }
 
 UA_DeleteReferencesResponse UA_EXPORT
 UA_Client_deleteReferences(UA_Client *client, UA_DeleteReferencesRequest *request) {
-	UA_Client_private* clientPrivate = (UA_Client_private*)client;
     UA_DeleteReferencesResponse response;
     synchronousRequest(request, &UA_TYPES[UA_TYPES_BROWSEREQUEST], &response,
-                       &UA_TYPES[UA_TYPES_BROWSERESPONSE], clientPrivate);
-    return response;
+                       &UA_TYPES[UA_TYPES_BROWSERESPONSE], client);
+    return response;;
 }