fix #125. session handling still needs work.

src/server/ua_server_binary.c

@@ -3,6 +3,7 @@
 #include "ua_statuscodes.h"
 #include "ua_namespace_0.h"
 #include "ua_securechannel_manager.h"
+#include "ua_session_manager.h"
 #include "util/ua_util.h"
 
 static UA_Int32 UA_ByteStringArray_init(UA_ByteStringArray *stringarray, UA_UInt32 length) {
@@ -197,8 +198,7 @@ static void processMessage(UA_Connection *connection, UA_Server *server,
         UA_GetEndpointsResponse_init(&r);
         init_response_header(&p.requestHeader, &r.responseHeader);
         Service_GetEndpoints(server, &p, &r);
-        UA_ByteString_newMembers(&responseBuf.strings[1],
-                                 UA_GetEndpointsResponse_calcSizeBinary(&r));
+        UA_ByteString_newMembers(&responseBuf.strings[1], UA_GetEndpointsResponse_calcSizeBinary(&r));
         UA_GetEndpointsResponse_encodeBinary(&r, &responseBuf.strings[1], &sendOffset);
         UA_GetEndpointsRequest_deleteMembers(&p);
         UA_GetEndpointsResponse_deleteMembers(&r);
@@ -213,8 +213,7 @@ static void processMessage(UA_Connection *connection, UA_Server *server,
         UA_CreateSessionResponse_init(&r);
         init_response_header(&p.requestHeader, &r.responseHeader);
         Service_CreateSession(server, channel,  &p, &r);
-        UA_ByteString_newMembers(&responseBuf.strings[1],
-                                 UA_CreateSessionResponse_calcSizeBinary(&r));
+        UA_ByteString_newMembers(&responseBuf.strings[1], UA_CreateSessionResponse_calcSizeBinary(&r));
         UA_CreateSessionResponse_encodeBinary(&r, &responseBuf.strings[1], &sendOffset);
         UA_CreateSessionRequest_deleteMembers(&p);
         UA_CreateSessionResponse_deleteMembers(&r);
@@ -222,8 +221,19 @@ static void processMessage(UA_Connection *connection, UA_Server *server,
         break;
     }
 
-    case UA_ACTIVATESESSIONREQUEST_NS0:
-        INVOKE_SERVICE(ActivateSession);
+    case UA_ACTIVATESESSIONREQUEST_NS0: {
+        UA_ActivateSessionRequest  p;
+        UA_ActivateSessionResponse r;
+        CHECK_PROCESS(UA_ActivateSessionRequest_decodeBinary(msg, pos, &p),; );
+        UA_ActivateSessionResponse_init(&r);
+        init_response_header(&p.requestHeader, &r.responseHeader);
+        Service_ActivateSession(server, channel->session,  &p, &r);
+        UA_ByteString_newMembers(&responseBuf.strings[1], UA_ActivateSessionResponse_calcSizeBinary(&r));
+        UA_ActivateSessionResponse_encodeBinary(&r, &responseBuf.strings[1], &sendOffset);
+        UA_ActivateSessionRequest_deleteMembers(&p);
+        UA_ActivateSessionResponse_deleteMembers(&r);
+        responseType = requestType.nodeId.identifier.numeric + 3;
+    }
         break;
 
     case UA_READREQUEST_NS0:

src/server/ua_services_attribute.c

@@ -217,14 +217,15 @@ static UA_DataValue service_read_node(UA_Server *server, const UA_ReadValueId *i
 UA_Int32 Service_Read(UA_Server *server, UA_Session *session, const UA_ReadRequest *request,
                       UA_ReadResponse *response) {
     UA_Int32 readsize;
-    if(server == UA_NULL || session == UA_NULL)
+    if(session == UA_NULL) {
+        response->responseHeader.serviceResult = UA_STATUSCODE_BADSESSIONIDINVALID;
         return UA_ERROR;
+    }
 
     readsize = request->nodesToReadSize;
     /* NothingTodo */
     if(readsize <= 0) {
         response->responseHeader.serviceResult = UA_STATUSCODE_BADNOTHINGTODO;
-        response->resultsSize = 0;
         return UA_SUCCESS;
     }
 

src/server/ua_services_session.c

@@ -1,42 +1,39 @@
 #include "ua_services.h"
 #include "ua_server.h"
+#include "ua_session_manager.h"
 
 UA_Int32 Service_CreateSession(UA_Server *server, UA_SecureChannel *channel,
                                const UA_CreateSessionRequest *request,
                                UA_CreateSessionResponse *response) {
-    /* UA_Session *newSession;
-       UA_Int64 timeout;
+    // creates a session and adds a pointer to the channel. Only when the
+    // session is activated will the channel point to the session as well
+    UA_Session *newSession;
+    UA_SessionManager_createSession(server->sessionManager, channel, &newSession);
 
-       UA_SessionManager_getSessionTimeout(&timeout);
-       UA_Session_new(&newSession);
-       //TODO get maxResponseMessageSize
-       UA_Session_setApplicationPointer(newSession, &server->applications[0]); // todo: select application according to the endpointurl in the request
-       UA_Session_init(newSession, (UA_String*)&request->sessionName,
-       request->requestedSessionTimeout,
-       request->maxResponseMessageSize,
-       9999,
-       (UA_Session_idProvider)UA_SessionManager_generateSessionId,
-       timeout);
+    //TODO get maxResponseMessageSize
+    UA_String_copy(&request->sessionName, &newSession->sessionName);
+    newSession->maxResponseMessageSize = request->maxResponseMessageSize;
 
-       UA_SessionManager_addSession(newSession);
-       UA_Session_getId(newSession, &response->sessionId);
-       UA_Session_getToken(newSession, &(response->authenticationToken));
-       response->revisedSessionTimeout = timeout; */
-    //TODO fill results
+    response->sessionId = newSession->sessionId;
+    response->revisedSessionTimeout = newSession->timeout;
+    response->authenticationToken = newSession->authenticationToken;
+    channel->session = newSession;
     return UA_SUCCESS;
 }
 
 UA_Int32 Service_ActivateSession(UA_Server *server, UA_Session *session,
                                  const UA_ActivateSessionRequest *request,
                                  UA_ActivateSessionResponse *response) {
-    //UA_Session_bind(session, channel);
-    //TODO fill results
+    // make the channel know about the session
+    //session->channel->session = session;
     return UA_SUCCESS;
 }
 
 UA_Int32 Service_CloseSession(UA_Server *server, UA_Session *session,
                               const UA_CloseSessionRequest *request,
                               UA_CloseSessionResponse *response) {
+    session->channel->session = UA_NULL;
+    UA_SessionManager_removeSession(server->sessionManager, &session->sessionId);
     /* UA_NodeId sessionId; */
     /* UA_Session_getId(session,&sessionId); */
 

src/server/ua_session_manager.c

@@ -29,15 +29,6 @@ UA_Int32 UA_SessionManager_delete(UA_SessionManager *sessionManager) {
     return UA_SUCCESS;
 }
 
-
-UA_Int32 UA_SessionManager_generateSessionId(UA_SessionManager *sessionManager,
-                                             UA_NodeId         *sessionId) {
-    sessionId->namespaceIndex     = 0;
-    sessionId->identifierType     = UA_NODEIDTYPE_NUMERIC;
-    sessionId->identifier.numeric = sessionManager->lastSessionId++;
-    return UA_SUCCESS;
-}
-
 UA_Boolean UA_SessionManager_sessionExists(UA_SessionManager *sessionManager,
                                            UA_Session        *session) {
     if(sessionManager == UA_NULL)
@@ -122,18 +113,21 @@ UA_Int32 UA_SessionManager_getSessionByToken(UA_SessionManager *sessionManager,
 }
 
 /** Creates and adds a session. */
-UA_Int32 UA_SessionManager_addSession(UA_SessionManager *sessionManager,
-                                      UA_SecureChannel *channel, UA_Session **session) {
+UA_Int32 UA_SessionManager_createSession(UA_SessionManager *sessionManager,
+                                         UA_SecureChannel *channel, UA_Session **session) {
     UA_Int32 retval = UA_SUCCESS;
     if(sessionManager->currentSessionCount >= sessionManager->maxSessionCount)
         return UA_ERROR;
     UA_Session_new(session);
     (*session)->sessionId = (UA_NodeId) {.namespaceIndex     = 1, .identifierType = UA_NODEIDTYPE_NUMERIC,
                                          .identifier.numeric = sessionManager->lastSessionId++ };
+    (*session)->authenticationToken = (UA_NodeId) {.namespaceIndex = 1,
+                                                   .identifierType = UA_NODEIDTYPE_NUMERIC,
+                                                   .identifier.numeric = sessionManager->lastSessionId };
     (*session)->channel   = channel;
-    channel->session      = *session;
-
+    (*session)->timeout = 3600 * 000; // 1h
     sessionManager->currentSessionCount++;
+    UA_list_addPayloadToFront(&sessionManager->sessions, *session);
     return retval;
 }
 
@@ -144,21 +138,9 @@ UA_Int32 UA_SessionManager_removeSession(UA_SessionManager *sessionManager,
         UA_list_search(&sessionManager->sessions, (UA_list_PayloadComparer)UA_Session_compare,
                        sessionId);
     if(element) {
-        UA_Session *session = element->payload;
-        session->channel->session = UA_NULL;
         retval |= UA_list_removeElement(element, (UA_list_PayloadVisitor)UA_Session_delete);
         printf("UA_SessionManager_removeSession - session removed, current count: %i \n",
                sessionManager->sessions.size);
     }
     return retval;
 }
-
-UA_Int32 UA_SessionManager_getSessionTimeout(UA_SessionManager *sessionManager,
-                                             UA_Int64          *timeout_ms) {
-    if(sessionManager) {
-        *timeout_ms = sessionManager->sessionTimeout;
-        return UA_SUCCESS;
-    }
-    *timeout_ms = 0;
-    return UA_ERROR;
-}

src/server/ua_session_manager.h

@@ -9,14 +9,9 @@ UA_Int32 UA_SessionManager_new(UA_SessionManager **sessionManager, UA_UInt32 max
 
 UA_Int32 UA_SessionManager_delete(UA_SessionManager *sessionManager);
 
-UA_Int32 UA_SessionManager_addSession(UA_SessionManager *sessionManager,
-                                      UA_SecureChannel *channel, UA_Session **session);
+UA_Int32 UA_SessionManager_createSession(UA_SessionManager *sessionManager,
+                                         UA_SecureChannel *channel, UA_Session **session);
 
-/**
- * @brief removes a session from the manager list
- * @param sessionId id which assign to a session
- * @return error code
- */
 UA_Int32 UA_SessionManager_removeSession(UA_SessionManager *sessionManager,
                                          UA_NodeId         *sessionId);
 
@@ -38,18 +33,7 @@ UA_Int32 UA_SessionManager_getSessionById(UA_SessionManager *sessionManager,
 UA_Int32 UA_SessionManager_getSessionByToken(UA_SessionManager *sessionManager,
                                              UA_NodeId *token, UA_Session **session);
 
-/**
- * @brief gets the session timeout value which should be assigned to
- * all sessions handled by the manager
- * @param timeout_ms timeout in milliseconds
- * @return error code
- */
-UA_Int32 UA_SessionManager_getSessionTimeout(UA_SessionManager *sessionManager,
-                                             UA_Int64          *timeout_ms);
-
 //UA_Int32 UA_SessionManager_updateSessions();
 //UA_Int32 UA_SessionManager_generateToken(UA_Session session, UA_Int32 requestedLifeTime, SecurityTokenRequestType requestType, UA_ChannelSecurityToken* newToken);
-UA_Int32 UA_SessionManager_generateSessionId(UA_SessionManager *sessionManager,
-                                             UA_NodeId         *newSessionId);
 
 #endif /* UA_SESSION_MANAGER_H_ */

src/ua_session.c

@@ -43,6 +43,7 @@ UA_Int32 UA_Session_init(UA_Session *session) {
     if(!session)
         return UA_ERROR;
 
+    UA_ApplicationDescription_init(&session->clientDescription);
     UA_NodeId_init(&session->authenticationToken);
     UA_NodeId_init(&session->sessionId);
     UA_String_init(&session->sessionName);
@@ -56,6 +57,7 @@ UA_Int32 UA_Session_init(UA_Session *session) {
 
 UA_Int32 UA_Session_deleteMembers(UA_Session *session) {
     UA_Int32 retval = UA_SUCCESS;
+    UA_ApplicationDescription_deleteMembers(&session->clientDescription);
     retval |= UA_NodeId_deleteMembers(&session->authenticationToken);
     retval |= UA_NodeId_deleteMembers(&session->sessionId);
     retval |= UA_String_deleteMembers(&session->sessionName);