amps_impl.h

/*//////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2010-2020 60East Technologies Inc., All Rights Reserved.
//
// This computer software is owned by 60East Technologies Inc. and is
// protected by U.S. copyright laws and other laws and by international
// treaties.  This computer software is furnished by 60East Technologies
// Inc. pursuant to a written license agreement and may be used, copied,
// transmitted, and stored only in accordance with the terms of such
// license agreement and with the inclusion of the above copyright notice.
// This computer software or any other copies thereof may not be provided
// or otherwise made available to any other person.
//
// U.S. Government Restricted Rights.  This computer software: (a) was
// developed at private expense and is in all respects the proprietary
// information of 60East Technologies Inc.; (b) was not developed with
// government funds; (c) is a trade secret of 60East Technologies Inc.
// for all purposes of the Freedom of Information Act; and (d) is a
// commercial item and thus, pursuant to Section 12.212 of the Federal
// Acquisition Regulations (FAR) and DFAR Supplement Section 227.7202,
// Government's use, duplication or disclosure of the computer software
// is subject to the restrictions set forth by 60East Technologies Inc..
//
#ifndef _AMPS_IMPL_H_
#define _AMPS_IMPL_H_
#ifndef _WIN32
#define _GNU_SOURCE 1
#endif
#define _AMPS_BUILD_C_CLIENT 1
#include <amps.h>
#include <assert.h>
#include <stdlib.h>

#define AMPSASSERT assert

#ifdef _WIN32

#include <Windows.h>
#define _AMPS_SNPRINTF(buf_, count_, ...) _snprintf_s(buf_, count_, _TRUNCATE, __VA_ARGS__)
#define _AMPS_KEYCREATE TlsAlloc
#define _AMPS_TLS_KEY DWORD

#else
#include <pthread.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>
#include <malloc.h>
#define _AMPS_SNPRINTF snprintf
#define _AMPS_KEYCREATE pthread_key_create
#define _AMPS_TLS_KEY pthread_key_t
#define closesocket close
#endif

#define AMPS_MIN(x,y) (x<y?x:y)
#define AMPS_MAX(x,y) (x>y?x:y)


typedef struct
{
    char clientName[128];
    size_t transportType;
    amps_handle transport;
    char lastError[1024];

    amps_predisconnect_handler predisconnectHandler;
    void* predisconnectHandlerUserData;
    amps_handler disconnectHandler;
    void* disconnectHandlerUserData;

    amps_handler messageHandler;
    void* messageHandlerUserData;

    amps_transport_filter_function transportFilterFunction;
    void* transportFilterFunctionUserData;

    amps_thread_created_callback threadCreatedCallback;
    void* threadCreatedCallbackUserData;
}
amps_client_t;

typedef struct
{
    char name[8];
    amps_handle(*createFunc)(void);
    amps_result(*connectFunc)(amps_handle, const amps_char*);
    amps_result(*predisconnectFunc)(amps_handle, amps_predisconnect_handler, void*);
    amps_result(*disconnectFunc)(amps_handle, amps_handler, void*);
    amps_result(*receiveFunc)(amps_handle, amps_handler, void*);
    amps_result(*sendFunc)(amps_handle, amps_handle);
    amps_result(*sendWithVersionFunc)(amps_handle, amps_handle, unsigned*);
    const amps_char*(*getError)(amps_handle);
    void(*closeFunc)(amps_handle);
    void(*destroyFunc)(amps_handle);
    amps_result(*reconnectFunc)(amps_handle, unsigned);
    amps_result(*setReadTimeoutFunc)(amps_handle,int);
    amps_result(*setIdleTimeFunc)(amps_handle,int);
    void(*setTransportFilterFunc)(amps_handle, amps_transport_filter_function, void*);
    void(*setThreadCreatedCallback)(amps_handle, amps_thread_created_callback, void*);
} transport_entry_t;

extern transport_entry_t g_transports[];
extern size_t g_transport_count;
typedef struct
{
    char* begin;
    size_t length;
    short owner;
    size_t capacity;
} amps_field_t;


typedef struct
{
    const char* rawBuffer;
    size_t length;
    size_t capacity;
    unsigned long long bitmask;
    amps_field_t fields[MESSAGEFIELDS];
    amps_field_t data;
} amps_message_t;

typedef struct
{
    char name[8];
    int(*serializeFunc)(amps_handle message, amps_char* buffer, size_t length);
    amps_result(*preDeserializeFunc)(amps_handle message, const amps_char* buffer, size_t length);
    amps_result(*deserializeFunc)(amps_handle message, size_t startingPosition, unsigned long* bytesRead);
} protocol_entry_t;
extern protocol_entry_t g_message_protocols[];
extern size_t g_message_protocol_count;



int amps_message_get_protocol(
    const amps_char* protocolname);

int amps_message_serialize(
    amps_handle message,
    int serializer,
    amps_char* buffer,
    size_t length);

amps_result amps_message_pre_deserialize(
    amps_handle message,
    int serializer,
    const amps_char* buffer,
    size_t length);

amps_result amps_message_deserialize(
    amps_handle message,
    int serializer,
    size_t startingPosition,
    unsigned long* bytesRead);


amps_result amps_protocol_pre_deserialize(amps_handle message,const amps_char* buffer,size_t length);
amps_result amps_protocol_deserialize(amps_handle message,size_t startingPosition,unsigned long* bytesRead);
int amps_protocol_serialize(amps_handle message,amps_char* buffer,size_t length);

#ifndef _WIN32
int amps_spin_lock_counted(pthread_mutex_t* lock_);
void amps_spin_lock_unlimited(pthread_mutex_t* lock_);
void amps_cleanup_unlock_mutex(void* m);
void amps_cleanup_free_buffer(void* data);
#endif

typedef void(*_amps_atfork_callback_function)(void*,int);
void amps_atfork_init(void);
void amps_atfork_add(void*, _amps_atfork_callback_function);
void amps_atfork_remove(void*);


#endif