sopc_sockets_internal_ctx.h

Go to the documentation of this file.

/*
 * Licensed to Systerel under one or more contributor license
 * agreements. See the NOTICE file distributed with this work
 * for additional information regarding copyright ownership.
 * Systerel licenses this file to you under the Apache
 * License, Version 2.0 (the "License"); you may not use this
 * file except in compliance with the License. You may obtain
 * a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
 
#ifndef SOPC_SOCKETS_INTERNAL_CTX_H_
#define SOPC_SOCKETS_INTERNAL_CTX_H_
 
#include <stdbool.h>
 
#include "sopc_async_queue.h"
#include "sopc_event_handler.h"
#include "sopc_mutexes.h"
#include "sopc_raw_sockets.h"
#include "sopc_sockets_api.h"
#include "sopc_toolkit_config_constants.h"
 
typedef enum
{
    SOCKET_STATE_CLOSED = 0,
    SOCKET_STATE_CONNECTING, 
    SOCKET_STATE_CONNECTED,  
    SOCKET_STATE_LISTENING,  
    SOCKET_STATE_ACCEPTED 
} SOPC_Socket_State;
 
typedef struct SOPC_InternalSocket
{
    uint32_t socketIdx;    /* Index in the socket array */
    uint32_t connectionId; /* High-level associated connection id
                             (secure channel connection index when state = CONNECTING/CONNECTED only
                              OR endpoint description configuration index when state = LISTENING only) */
    SOPC_Socket sock;
    SOPC_AsyncQueue* writeQueue;
    bool isNotWritable; // Indicates when a write attempt blocked, the flag is set until a write event occurs on socket
    bool isUsed;        /* Indicates if the socket is free (false) or used (true) */
    // false if it is a client connection, otherwise it is a server connection (linked to a listener)
    bool isServerConnection;
    SOPC_Socket_State state;
    // addresses for connection
    void* connectAddrs;           // Possible connection addresses (to free on connection)
    void* curConnectAttemptAddr;  // Current connection attempt address
    void* nextConnectAttemptAddr; // Next connection attempt address
    // number of connection for a listener (state = LISTENING)
    uint32_t listenerConnections;
    // define if isServerConnection != false
    uint32_t listenerSocketIdx;
    // socket address
    SOPC_Socket_Address* addr;
} SOPC_InternalSocket;
 
extern SOPC_InternalSocket socketsArray[SOPC_MAX_SOCKETS];
 
extern SOPC_EventHandler* socketsEventHandler;
 
extern uint32_t maxBufferSize;
 
void SOPC_SocketsInternalContext_Initialize(void);
 
void SOPC_SocketsInternalContext_Clear(void);
 
SOPC_InternalSocket* SOPC_SocketsInternalContext_GetFreeSocket(bool isListener);
 
void SOPC_SocketsInternalContext_CloseSocket(uint32_t socketIdx);
 
void SOPC_Sockets_Emit(SOPC_Sockets_OutputEvent event, uint32_t eltId, uintptr_t params, uintptr_t auxParam);
 
SOPC_ReturnStatus SOPC_Sockets_EnqueueInputEvent(SOPC_Sockets_InputEvent socketEvent,
                                                 uint32_t id,
                                                 uintptr_t params,
                                                 uintptr_t auxParam);
 
SOPC_ReturnStatus SOPC_Sockets_DequeueAndDispatchInputEvent(void);
 
#endif /* SOPC_SOCKETS_INTERNAL_CTX_H_ */