[public/netxms.git] / include / nxcpapi.h

/*
** NetXMS - Network Management System
** NXCP API
** Copyright (C) 2003-2010 Victor Kirhenshtein
**
** This program is free software; you can redistribute it and/or modify
** it under the terms of the GNU Lesser General Public License as published by
** the Free Software Foundation; either version 3 of the License, or
** (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public License
** along with this program; if not, write to the Free Software
** Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
**
** File: nxcpapi.h
**
**/

#ifndef _nxcpapi_h_
#define _nxcpapi_h_

#include <nms_util.h>
#include <nms_threads.h>
#include <nxcrypto.h>
#include <uuid.h>

#ifdef _WIN32
#include <wincrypt.h>
#endif

/**
 * Temporary buffer structure for RecvNXCPMessage() function
 */
typedef struct
{
   UINT32 bufferSize;
   UINT32 bufferPos;
   char buffer[NXCP_TEMP_BUF_SIZE];
} NXCP_BUFFER;


#ifdef __cplusplus

struct MessageField;

/**
 * Parsed NXCP message
 */
class LIBNETXMS_EXPORTABLE NXCPMessage
{
private:
   UINT16 m_code;
   UINT16 m_flags;
   UINT32 m_id;
   MessageField *m_fields; // Message fields
   int m_version;          // Protocol version
   BYTE *m_data;           // binary data
   size_t m_dataSize;      // binary data size

   void *set(UINT32 fieldId, BYTE type, const void *value, bool isSigned = false, size_t size = 0);
   void *get(UINT32 fieldId, BYTE requiredType, BYTE *fieldType = NULL) const;
   NXCP_MESSAGE_FIELD *find(UINT32 fieldId) const;

public:
   NXCPMessage(int version = NXCP_VERSION);
   NXCPMessage(NXCPMessage *msg);
   NXCPMessage(NXCP_MESSAGE *rawMag, int version = NXCP_VERSION);
   ~NXCPMessage();

   NXCP_MESSAGE *createMessage(bool allowCompression = false) const;

   UINT16 getCode() const { return m_code; }
   void setCode(UINT16 code) { m_code = code; }

   UINT32 getId() const { return m_id; }
   void setId(UINT32 id) { m_id = id; }

   int getProtocolVersion() const { return m_version; }
   void setProtocolVersion(int version) { m_version = version; }

   bool isEndOfFile() const { return (m_flags & MF_END_OF_FILE) ? true : false; }
   bool isEndOfSequence() const { return (m_flags & MF_END_OF_SEQUENCE) ? true : false; }
   bool isReverseOrder() const { return (m_flags & MF_REVERSE_ORDER) ? true : false; }
   bool isBinary() const { return (m_flags & MF_BINARY) ? true : false; }
   bool isControl() const { return (m_flags & MF_CONTROL) ? true : false; }
   bool isCompressedStream() const { return ((m_flags & (MF_COMPRESSED | MF_STREAM)) == (MF_COMPRESSED | MF_STREAM)) ? true : false; }

   const BYTE *getBinaryData() const { return m_data; }
   size_t getBinaryDataSize() const { return m_dataSize; }

   bool isFieldExist(UINT32 fieldId) const { return find(fieldId) != NULL; }
   int getFieldType(UINT32 fieldId) const;

   void setField(UINT32 fieldId, INT16 value) { set(fieldId, NXCP_DT_INT16, &value, true); }
   void setField(UINT32 fieldId, UINT16 value) { set(fieldId, NXCP_DT_INT16, &value, false); }
   void setField(UINT32 fieldId, INT32 value) { set(fieldId, NXCP_DT_INT32, &value, true); }
   void setField(UINT32 fieldId, UINT32 value) { set(fieldId, NXCP_DT_INT32, &value, false); }
   void setField(UINT32 fieldId, INT64 value) { set(fieldId, NXCP_DT_INT64, &value, true); }
   void setField(UINT32 fieldId, UINT64 value) { set(fieldId, NXCP_DT_INT64, &value, false); }
   void setField(UINT32 fieldId, double value) { set(fieldId, NXCP_DT_FLOAT, &value); }
   void setField(UINT32 fieldId, bool value) { INT16 v = value ? 1 : 0; set(fieldId, NXCP_DT_INT16, &v, true); }
   void setField(UINT32 fieldId, const TCHAR *value) { if (value != NULL) set(fieldId, NXCP_DT_STRING, value); }
   void setField(UINT32 fieldId, const TCHAR *value, size_t maxLen) { if (value != NULL) set(fieldId, NXCP_DT_STRING, value, false, maxLen); }
   void setField(UINT32 fieldId, const BYTE *value, size_t size) { set(fieldId, NXCP_DT_BINARY, value, false, size); }
   void setField(UINT32 fieldId, const InetAddress& value) { set(fieldId, NXCP_DT_INETADDR, &value); }
   void setField(UINT32 fieldId, const uuid& value) { set(fieldId, NXCP_DT_BINARY, value.getValue(), false, UUID_LENGTH); }
#ifdef UNICODE
   void setFieldFromMBString(UINT32 fieldId, const char *value);
#else
   void setFieldFromMBString(UINT32 fieldId, const char *value) { set(fieldId, NXCP_DT_STRING, value); }
#endif
   void setFieldFromTime(UINT32 fieldId, time_t value) { UINT64 t = (UINT64)value; set(fieldId, NXCP_DT_INT64, &t); }
   void setFieldFromInt32Array(UINT32 fieldId, size_t numElements, const UINT32 *elements);
   void setFieldFromInt32Array(UINT32 fieldId, const IntegerArray<UINT32> *data);
   bool setFieldFromFile(UINT32 fieldId, const TCHAR *pszFileName);

   INT16 getFieldAsInt16(UINT32 fieldId) const;
   UINT16 getFieldAsUInt16(UINT32 fieldId) const;
   INT32 getFieldAsInt32(UINT32 fieldId) const;
   UINT32 getFieldAsUInt32(UINT32 fieldId) const;
   INT64 getFieldAsInt64(UINT32 fieldId) const;
   UINT64 getFieldAsUInt64(UINT32 fieldId) const;
   double getFieldAsDouble(UINT32 fieldId) const;
   bool getFieldAsBoolean(UINT32 fieldId) const;
   time_t getFieldAsTime(UINT32 fieldId) const;
   UINT32 getFieldAsInt32Array(UINT32 fieldId, UINT32 numElements, UINT32 *buffer) const;
   UINT32 getFieldAsInt32Array(UINT32 fieldId, IntegerArray<UINT32> *data) const;
   const BYTE *getBinaryFieldPtr(UINT32 fieldId, size_t *size) const;
   TCHAR *getFieldAsString(UINT32 fieldId, TCHAR *buffer = NULL, size_t bufferSize = 0) const;
	char *getFieldAsMBString(UINT32 fieldId, char *buffer = NULL, size_t bufferSize = 0) const;
	char *getFieldAsUtf8String(UINT32 fieldId, char *buffer = NULL, size_t bufferSize = 0) const;
   UINT32 getFieldAsBinary(UINT32 fieldId, BYTE *buffer, size_t bufferSize) const;
   InetAddress getFieldAsInetAddress(UINT32 fieldId) const;
   uuid getFieldAsGUID(UINT32 fieldId) const;

   void deleteAllFields();

   void disableEncryption() { m_flags |= MF_DONT_ENCRYPT; }
   void setEndOfSequence() { m_flags |= MF_END_OF_SEQUENCE; }
   void setReverseOrderFlag() { m_flags |= MF_REVERSE_ORDER; }

   static String dump(const NXCP_MESSAGE *msg, int version);
};

/**
 * Message waiting queue element structure
 */
typedef struct
{
   void *msg;         // Pointer to message, either to NXCPMessage object or raw message
   UINT64 sequence;   // Sequence number
   UINT32 id;         // Message ID
   UINT32 ttl;        // Message time-to-live in milliseconds
   UINT16 code;       // Message code
   UINT16 isBinary;   // 1 for binary (raw) messages
} WAIT_QUEUE_ELEMENT;

/**
 * Max number of waiting threads in message queue
 */
#define MAX_MSGQUEUE_WAITERS     32

/**
 * Message waiting queue class
 */
class LIBNETXMS_EXPORTABLE MsgWaitQueue
{
private:
#if defined(_WIN32)
   CRITICAL_SECTION m_mutex;
   HANDLE m_wakeupEvents[MAX_MSGQUEUE_WAITERS];
   BYTE m_waiters[MAX_MSGQUEUE_WAITERS];
#elif defined(_USE_GNU_PTH)
   pth_mutex_t m_mutex;
   pth_cond_t m_wakeupCondition;
#else
   pthread_mutex_t m_mutex;
   pthread_cond_t m_wakeupCondition;
#endif
   UINT32 m_holdTime;
   int m_size;
   int m_allocated;
   WAIT_QUEUE_ELEMENT *m_elements;
   UINT64 m_sequence;

   void *waitForMessageInternal(UINT16 isBinary, UINT16 code, UINT32 id, UINT32 timeout);

   void lock()
   {
#ifdef _WIN32
      EnterCriticalSection(&m_mutex);
#elif defined(_USE_GNU_PTH)
      pth_mutex_acquire(&m_mutex, FALSE, NULL);
#else
      pthread_mutex_lock(&m_mutex);
#endif
   }

   void unlock()
   {
#ifdef _WIN32
      LeaveCriticalSection(&m_mutex);
#elif defined(_USE_GNU_PTH)
      pth_mutex_release(&m_mutex);
#else
      pthread_mutex_unlock(&m_mutex);
#endif
   }

   void housekeeperRun();

   static Mutex m_housekeeperLock;
   static HashMap<UINT64, MsgWaitQueue> *m_activeQueues;
   static Condition m_shutdownCondition;
   static THREAD m_housekeeperThread;
   static EnumerationCallbackResult houseKeeperCallback(const void *key, const void *object, void *arg);
   static THREAD_RESULT THREAD_CALL housekeeperThread(void *);
   static EnumerationCallbackResult diagInfoCallback(const void *key, const void *object, void *arg);

public:
   MsgWaitQueue();
   ~MsgWaitQueue();

   void put(NXCPMessage *pMsg);
   void put(NXCP_MESSAGE *pMsg);
   NXCPMessage *waitForMessage(WORD wCode, UINT32 dwId, UINT32 dwTimeOut)
   {
      return (NXCPMessage *)waitForMessageInternal(0, wCode, dwId, dwTimeOut);
   }
   NXCP_MESSAGE *waitForRawMessage(WORD wCode, UINT32 dwId, UINT32 dwTimeOut)
   {
      return (NXCP_MESSAGE *)waitForMessageInternal(1, wCode, dwId, dwTimeOut);
   }

   void clear();
   void setHoldTime(UINT32 holdTime) { m_holdTime = holdTime; }

   static void shutdown();
   static String getDiagInfo();
};

/**
 * NXCP encryption context
 */
class LIBNETXMS_EXPORTABLE NXCPEncryptionContext : public RefCountObject
{
private:
	int m_cipher;
	BYTE *m_sessionKey;
	int m_keyLength;
	BYTE m_iv[EVP_MAX_IV_LENGTH];
#ifdef _WITH_ENCRYPTION
   MUTEX m_encryptorLock;
#if WITH_OPENSSL
   EVP_CIPHER_CTX m_encryptor;
   EVP_CIPHER_CTX m_decryptor;
#elif WITH_COMMONCRYPTO
   CCCryptorRef m_encryptor;
   CCCryptorRef m_decryptor;
#endif
#endif

	NXCPEncryptionContext();
   bool initCipher(int cipher);

public:
	static NXCPEncryptionContext *create(NXCPMessage *msg, RSA *privateKey);
	static NXCPEncryptionContext *create(UINT32 ciphers);

	virtual ~NXCPEncryptionContext();

   NXCP_ENCRYPTED_MESSAGE *encryptMessage(NXCP_MESSAGE *msg);
   bool decryptMessage(NXCP_ENCRYPTED_MESSAGE *msg, BYTE *decryptionBuffer);

	int getCipher() { return m_cipher; }
	BYTE *getSessionKey() { return m_sessionKey; }
	int getKeyLength() { return m_keyLength; }
	BYTE *getIV() { return m_iv; }
};

/**
 * Message receiver result codes
 */
enum MessageReceiverResult
{
   MSGRECV_SUCCESS = 0,
   MSGRECV_CLOSED = 1,
   MSGRECV_TIMEOUT = 2,
   MSGRECV_COMM_FAILURE = 3,
   MSGRECV_DECRYPTION_FAILURE = 4,
   MSGRECV_PROTOCOL_ERROR = 5
};

/**
 * Message receiver - abstract base class
 */
class LIBNETXMS_EXPORTABLE AbstractMessageReceiver
{
private:
   BYTE *m_buffer;
   BYTE *m_decryptionBuffer;
   NXCPEncryptionContext *m_encryptionContext;
   size_t m_initialSize;
   size_t m_size;
   size_t m_maxSize;
   size_t m_dataSize;
   size_t m_bytesToSkip;

   NXCPMessage *getMessageFromBuffer(bool *protocolError);

protected:
   virtual int readBytes(BYTE *buffer, size_t size, UINT32 timeout) = 0;

public:
   AbstractMessageReceiver(size_t initialSize, size_t maxSize);
   virtual ~AbstractMessageReceiver();

   void setEncryptionContext(NXCPEncryptionContext *ctx) { m_encryptionContext = ctx; }

   NXCPMessage *readMessage(UINT32 timeout, MessageReceiverResult *result);
   NXCP_MESSAGE *getRawMessageBuffer() { return (NXCP_MESSAGE *)m_buffer; }

   static const TCHAR *resultToText(MessageReceiverResult result);
};

/**
 * Message receiver - socket implementation
 */
class LIBNETXMS_EXPORTABLE SocketMessageReceiver : public AbstractMessageReceiver
{
private:
   SOCKET m_socket;

protected:
   virtual int readBytes(BYTE *buffer, size_t size, UINT32 timeout);

public:
   SocketMessageReceiver(SOCKET socket, size_t initialSize, size_t maxSize);
   virtual ~SocketMessageReceiver();
};

/**
 * Message receiver - UNIX socket/named pipe implementation
 */
class LIBNETXMS_EXPORTABLE PipeMessageReceiver : public AbstractMessageReceiver
{
private:
   HPIPE m_pipe;
#ifdef _WIN32
	HANDLE m_readEvent;
#endif

protected:
   virtual int readBytes(BYTE *buffer, size_t size, UINT32 timeout);

public:
   PipeMessageReceiver(HPIPE pipe, size_t initialSize, size_t maxSize);
   virtual ~PipeMessageReceiver();
};

/**
 * NXCP stresam compression methods
 */
enum NXCPStreamCompressionMethod
{
   NXCP_STREAM_COMPRESSION_NONE = 0,
   NXCP_STREAM_COMPRESSION_LZ4 = 1,
   NXCP_STREAM_COMPRESSION_DEFLATE = 2
};

/**
 * Abstract stream compressor
 */
class LIBNETXMS_EXPORTABLE StreamCompressor
{
public:
   virtual ~StreamCompressor();

   virtual size_t compress(const BYTE *in, size_t inSize, BYTE *out, size_t maxOutSize) = 0;
   virtual size_t decompress(const BYTE *in, size_t inSize, const BYTE **out) = 0;
   virtual size_t compressBufferSize(size_t dataSize) = 0;

   static StreamCompressor *create(NXCPStreamCompressionMethod method, bool compress, size_t maxBlockSize);
};

/**
 * Dummy stream compressor
 */
class LIBNETXMS_EXPORTABLE DummyStreamCompressor : public StreamCompressor
{
public:
   virtual ~DummyStreamCompressor();

   virtual size_t compress(const BYTE *in, size_t inSize, BYTE *out, size_t maxOutSize);
   virtual size_t decompress(const BYTE *in, size_t inSize, const BYTE **out);
   virtual size_t compressBufferSize(size_t dataSize);
};

struct __LZ4_stream_t;
struct __LZ4_streamDecode_t;

/**
 * LZ4 stream compressor
 */
class LIBNETXMS_EXPORTABLE LZ4StreamCompressor : public StreamCompressor
{
private:
   union
   {
      __LZ4_stream_t *encoder;
      __LZ4_streamDecode_t *decoder;
   } m_stream;
   char *m_buffer;
   size_t m_maxBlockSize;
   size_t m_bufferSize;
   size_t m_bufferPos;
   bool m_compress;

public:
   LZ4StreamCompressor(bool compress, size_t maxBlockSize);
   virtual ~LZ4StreamCompressor();

   virtual size_t compress(const BYTE *in, size_t inSize, BYTE *out, size_t maxOutSize);
   virtual size_t decompress(const BYTE *in, size_t inSize, const BYTE **out);
   virtual size_t compressBufferSize(size_t dataSize);
};

struct z_stream_s;

/**
 * Deflate stream compressor
 */
class LIBNETXMS_EXPORTABLE DeflateStreamCompressor : public StreamCompressor
{
private:
   z_stream_s *m_stream;
   BYTE *m_buffer;
   size_t m_bufferSize;
   bool m_compress;

public:
   DeflateStreamCompressor(bool compress, size_t maxBlockSize);
   virtual ~DeflateStreamCompressor();

   virtual size_t compress(const BYTE *in, size_t inSize, BYTE *out, size_t maxOutSize);
   virtual size_t decompress(const BYTE *in, size_t inSize, const BYTE **out);
   virtual size_t compressBufferSize(size_t dataSize);
};

#if 0
/**
 * NXCP message consumer interface
 */
class LIBNETXMS_EXPORTABLE MessageConsumer
{
public:
   virtual SOCKET getSocket() = 0;
   virtual void processMessage(NXCPMessage *msg) = 0;
};

/**
 * Socket receiver - manages receiving NXCP messages from multiple sockets
 */
class LIBNETXMS_EXPORTABLE SocketReceiver
{
private:
   THREAD m_thread;
   HashMap<SOCKET, MessageConsumer> *m_consumers;

   static int m_maxSocketsPerThread;
   static ObjectArray<SocketReceiver> *m_receivers;

public:
   static void start();
   static void shutdown();

   static void addConsumer(MessageConsumer *mc);
   static void removeConsumer(MessageConsumer *mc);

   static String getDiagInfo();
};
#endif

#else    /* __cplusplus */

typedef void NXCPMessage;
typedef void NXCPEncryptionContext;

#endif

typedef bool (*NXCPMessageNameResolver)(UINT16 code, TCHAR *buffer);


//
// Functions
//

#ifdef __cplusplus

int LIBNETXMS_EXPORTABLE RecvNXCPMessage(SOCKET hSocket, NXCP_MESSAGE *pMsg,
                                         NXCP_BUFFER *pBuffer, UINT32 dwMaxMsgSize,
                                         NXCPEncryptionContext **ppCtx,
                                         BYTE *pDecryptionBuffer, UINT32 dwTimeout);
int LIBNETXMS_EXPORTABLE RecvNXCPMessageEx(SOCKET hSocket, NXCP_MESSAGE **msgBuffer,
                                           NXCP_BUFFER *nxcpBuffer, UINT32 *bufferSize,
                                           NXCPEncryptionContext **ppCtx,
                                           BYTE **decryptionBuffer, UINT32 dwTimeout,
														 UINT32 maxMsgSize);
NXCP_MESSAGE LIBNETXMS_EXPORTABLE *CreateRawNXCPMessage(UINT16 code, UINT32 id, UINT16 flags,
                                                        const void *data, size_t dataSize,
                                                        NXCP_MESSAGE *buffer, bool allowCompression);
BOOL LIBNETXMS_EXPORTABLE SendFileOverNXCP(SOCKET hSocket, UINT32 dwId, const TCHAR *pszFile,
                                           NXCPEncryptionContext *pCtx, long offset,
														 void (* progressCallback)(INT64, void *), void *cbArg,
														 MUTEX mutex, NXCPStreamCompressionMethod compressionMethod = NXCP_STREAM_COMPRESSION_NONE);
BOOL LIBNETXMS_EXPORTABLE NXCPGetPeerProtocolVersion(SOCKET hSocket, int *pnVersion, MUTEX mutex);

TCHAR LIBNETXMS_EXPORTABLE *NXCPMessageCodeName(UINT16 wCode, TCHAR *buffer);
void LIBNETXMS_EXPORTABLE NXCPRegisterMessageNameResolver(NXCPMessageNameResolver r);
void LIBNETXMS_EXPORTABLE NXCPUnregisterMessageNameResolver(NXCPMessageNameResolver r);

bool LIBNETXMS_EXPORTABLE InitCryptoLib(UINT32 dwEnabledCiphers);
UINT32 LIBNETXMS_EXPORTABLE NXCPGetSupportedCiphers();
String LIBNETXMS_EXPORTABLE NXCPGetSupportedCiphersAsText();
NXCP_ENCRYPTED_MESSAGE LIBNETXMS_EXPORTABLE *NXCPEncryptMessage(NXCPEncryptionContext *pCtx, NXCP_MESSAGE *pMsg);
bool LIBNETXMS_EXPORTABLE NXCPDecryptMessage(NXCPEncryptionContext *pCtx,
                                             NXCP_ENCRYPTED_MESSAGE *pMsg,
                                             BYTE *pDecryptionBuffer);
UINT32 LIBNETXMS_EXPORTABLE SetupEncryptionContext(NXCPMessage *pMsg,
                                                  NXCPEncryptionContext **ppCtx,
                                                  NXCPMessage **ppResponse,
                                                  RSA *pPrivateKey, int nNXCPVersion);
void LIBNETXMS_EXPORTABLE PrepareKeyRequestMsg(NXCPMessage *pMsg, RSA *pServerKey, bool useX509Format);
RSA LIBNETXMS_EXPORTABLE *LoadRSAKeys(const TCHAR *pszKeyFile);

#ifdef _WIN32
BOOL LIBNETXMS_EXPORTABLE SignMessageWithCAPI(BYTE *pMsg, UINT32 dwMsgLen, const CERT_CONTEXT *pCert,
												          BYTE *pBuffer, size_t bufferSize, UINT32 *pdwSigLen);
#endif

#endif

#endif   /* _nxcpapi_h_ */
Commit	Line	Data
9fa031cd	1	/*
0d9c1b96	2	** NetXMS - Network Management System
9f2ad16c	3	** NXCP API
68f384ea	4	** Copyright (C) 2003-2010 Victor Kirhenshtein
0d9c1b96 VK	5	**
0d9c1b96 VK	6	** This program is free software; you can redistribute it and/or modify
65d2c384 VK	7	** it under the terms of the GNU Lesser General Public License as published by
65d2c384 VK	8	** the Free Software Foundation; either version 3 of the License, or
0d9c1b96 VK	9	** (at your option) any later version.
	10	**
	11	** This program is distributed in the hope that it will be useful,
	12	** but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	** GNU General Public License for more details.
	15	**
68f384ea	16	** You should have received a copy of the GNU Lesser General Public License
0d9c1b96 VK	17	** along with this program; if not, write to the Free Software
	18	** Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	19	**
9f2ad16c	20	** File: nxcpapi.h
0d9c1b96 VK	21	**
	22	**/
	23
9f2ad16c VK	24	#ifndef _nxcpapi_h_
9f2ad16c VK	25	#define _nxcpapi_h_
0d9c1b96	26
9f2ad16c	27	#include <nms_util.h>
bf6fb6c3	28	#include <nms_threads.h>
9c3bf7f4	29	#include <nxcrypto.h>
de4af576	30	#include <uuid.h>
8c290af0	31
bb8136f7 VK	32	#ifdef _WIN32
	33	#include <wincrypt.h>
	34	#endif
	35
4af351c7	36	/**
b368969c	37	* Temporary buffer structure for RecvNXCPMessage() function
4af351c7	38	*/
0d9c1b96 VK	39	typedef struct
0d9c1b96 VK	40	{
b368969c VK	41	UINT32 bufferSize;
b368969c VK	42	UINT32 bufferPos;
43a6f3ca	43	char buffer[NXCP_TEMP_BUF_SIZE];
b368969c	44	} NXCP_BUFFER;
0d9c1b96 VK	45
0d9c1b96 VK	46
9f2ad16c VK	47	#ifdef __cplusplus
9f2ad16c VK	48
5c44534b VK	49	struct MessageField;
5c44534b VK	50
4af351c7 VK	51	/**
	52	* Parsed NXCP message
	53	*/
b368969c	54	class LIBNETXMS_EXPORTABLE NXCPMessage
0d9c1b96 VK	55	{
0d9c1b96 VK	56	private:
b368969c VK	57	UINT16 m_code;
b368969c VK	58	UINT16 m_flags;
5c44534b	59	UINT32 m_id;
6be0a20b VK	60	MessageField *m_fields; // Message fields
	61	int m_version; // Protocol version
	62	BYTE *m_data; // binary data
	63	size_t m_dataSize; // binary data size
0d9c1b96	64
712b2760	65	void set(UINT32 fieldId, BYTE type, const void value, bool isSigned = false, size_t size = 0);
ca0a165b VK	66	void get(UINT32 fieldId, BYTE requiredType, BYTE fieldType = NULL) const;
ca0a165b VK	67	NXCP_MESSAGE_FIELD *find(UINT32 fieldId) const;
0d9c1b96 VK	68
0d9c1b96 VK	69	public:
b368969c VK	70	NXCPMessage(int version = NXCP_VERSION);
	71	NXCPMessage(NXCPMessage *msg);
	72	NXCPMessage(NXCP_MESSAGE *rawMag, int version = NXCP_VERSION);
	73	~NXCPMessage();
0d9c1b96	74
9674aefa	75	NXCP_MESSAGE *createMessage(bool allowCompression = false) const;
0d9c1b96	76
ca0a165b	77	UINT16 getCode() const { return m_code; }
b368969c	78	void setCode(UINT16 code) { m_code = code; }
0d9c1b96	79
ca0a165b	80	UINT32 getId() const { return m_id; }
b368969c	81	void setId(UINT32 id) { m_id = id; }
0d9c1b96	82
4970ef34 VK	83	int getProtocolVersion() const { return m_version; }
	84	void setProtocolVersion(int version) { m_version = version; }
	85
ca0a165b VK	86	bool isEndOfFile() const { return (m_flags & MF_END_OF_FILE) ? true : false; }
	87	bool isEndOfSequence() const { return (m_flags & MF_END_OF_SEQUENCE) ? true : false; }
	88	bool isReverseOrder() const { return (m_flags & MF_REVERSE_ORDER) ? true : false; }
	89	bool isBinary() const { return (m_flags & MF_BINARY) ? true : false; }
	90	bool isControl() const { return (m_flags & MF_CONTROL) ? true : false; }
3a1356ab	91	bool isCompressedStream() const { return ((m_flags & (MF_COMPRESSED \| MF_STREAM)) == (MF_COMPRESSED \| MF_STREAM)) ? true : false; }
6be0a20b	92
ca0a165b VK	93	const BYTE *getBinaryData() const { return m_data; }
ca0a165b VK	94	size_t getBinaryDataSize() const { return m_dataSize; }
4af351c7	95
ca0a165b VK	96	bool isFieldExist(UINT32 fieldId) const { return find(fieldId) != NULL; }
ca0a165b VK	97	int getFieldType(UINT32 fieldId) const;
4101571e	98
712b2760 VK	99	void setField(UINT32 fieldId, INT16 value) { set(fieldId, NXCP_DT_INT16, &value, true); }
	100	void setField(UINT32 fieldId, UINT16 value) { set(fieldId, NXCP_DT_INT16, &value, false); }
	101	void setField(UINT32 fieldId, INT32 value) { set(fieldId, NXCP_DT_INT32, &value, true); }
	102	void setField(UINT32 fieldId, UINT32 value) { set(fieldId, NXCP_DT_INT32, &value, false); }
	103	void setField(UINT32 fieldId, INT64 value) { set(fieldId, NXCP_DT_INT64, &value, true); }
	104	void setField(UINT32 fieldId, UINT64 value) { set(fieldId, NXCP_DT_INT64, &value, false); }
b368969c	105	void setField(UINT32 fieldId, double value) { set(fieldId, NXCP_DT_FLOAT, &value); }
19a2cd39	106	void setField(UINT32 fieldId, bool value) { INT16 v = value ? 1 : 0; set(fieldId, NXCP_DT_INT16, &v, true); }
b368969c	107	void setField(UINT32 fieldId, const TCHAR *value) { if (value != NULL) set(fieldId, NXCP_DT_STRING, value); }
712b2760	108	void setField(UINT32 fieldId, const TCHAR *value, size_t maxLen) { if (value != NULL) set(fieldId, NXCP_DT_STRING, value, false, maxLen); }
5f573844	109	void setField(UINT32 fieldId, const BYTE *value, size_t size) { set(fieldId, NXCP_DT_BINARY, value, false, size); }
de4af576 VK	110	void setField(UINT32 fieldId, const InetAddress& value) { set(fieldId, NXCP_DT_INETADDR, &value); }
de4af576 VK	111	void setField(UINT32 fieldId, const uuid& value) { set(fieldId, NXCP_DT_BINARY, value.getValue(), false, UUID_LENGTH); }
35f836fe	112	#ifdef UNICODE
b368969c	113	void setFieldFromMBString(UINT32 fieldId, const char *value);
35f836fe	114	#else
b368969c	115	void setFieldFromMBString(UINT32 fieldId, const char *value) { set(fieldId, NXCP_DT_STRING, value); }
35f836fe	116	#endif
b368969c	117	void setFieldFromTime(UINT32 fieldId, time_t value) { UINT64 t = (UINT64)value; set(fieldId, NXCP_DT_INT64, &t); }
14149881	118	void setFieldFromInt32Array(UINT32 fieldId, size_t numElements, const UINT32 *elements);
e30c2442	119	void setFieldFromInt32Array(UINT32 fieldId, const IntegerArray<UINT32> *data);
8f238fd7	120	bool setFieldFromFile(UINT32 fieldId, const TCHAR *pszFileName);
967893bb	121
ca0a165b VK	122	INT16 getFieldAsInt16(UINT32 fieldId) const;
	123	UINT16 getFieldAsUInt16(UINT32 fieldId) const;
	124	INT32 getFieldAsInt32(UINT32 fieldId) const;
	125	UINT32 getFieldAsUInt32(UINT32 fieldId) const;
	126	INT64 getFieldAsInt64(UINT32 fieldId) const;
	127	UINT64 getFieldAsUInt64(UINT32 fieldId) const;
	128	double getFieldAsDouble(UINT32 fieldId) const;
	129	bool getFieldAsBoolean(UINT32 fieldId) const;
	130	time_t getFieldAsTime(UINT32 fieldId) const;
	131	UINT32 getFieldAsInt32Array(UINT32 fieldId, UINT32 numElements, UINT32 *buffer) const;
	132	UINT32 getFieldAsInt32Array(UINT32 fieldId, IntegerArray<UINT32> *data) const;
	133	const BYTE getBinaryFieldPtr(UINT32 fieldId, size_t size) const;
	134	TCHAR getFieldAsString(UINT32 fieldId, TCHAR buffer = NULL, size_t bufferSize = 0) const;
	135	char getFieldAsMBString(UINT32 fieldId, char buffer = NULL, size_t bufferSize = 0) const;
	136	char getFieldAsUtf8String(UINT32 fieldId, char buffer = NULL, size_t bufferSize = 0) const;
	137	UINT32 getFieldAsBinary(UINT32 fieldId, BYTE *buffer, size_t bufferSize) const;
	138	InetAddress getFieldAsInetAddress(UINT32 fieldId) const;
	139	uuid getFieldAsGUID(UINT32 fieldId) const;
4101571e	140
b368969c	141	void deleteAllFields();
e44ac467	142
5c44534b VK	143	void disableEncryption() { m_flags \|= MF_DONT_ENCRYPT; }
	144	void setEndOfSequence() { m_flags \|= MF_END_OF_SEQUENCE; }
	145	void setReverseOrderFlag() { m_flags \|= MF_REVERSE_ORDER; }
934f53da	146
ca0a165b	147	static String dump(const NXCP_MESSAGE *msg, int version);
0d9c1b96 VK	148	};
0d9c1b96 VK	149
4af351c7 VK	150	/**
	151	* Message waiting queue element structure
	152	*/
deaa4491 VK	153	typedef struct
deaa4491 VK	154	{
b368969c	155	void *msg; // Pointer to message, either to NXCPMessage object or raw message
14149881	156	UINT64 sequence; // Sequence number
f128c07c VK	157	UINT32 id; // Message ID
	158	UINT32 ttl; // Message time-to-live in milliseconds
	159	UINT16 code; // Message code
	160	UINT16 isBinary; // 1 for binary (raw) messages
deaa4491 VK	161	} WAIT_QUEUE_ELEMENT;
deaa4491 VK	162
4af351c7	163	/**
f128c07c VK	164	* Max number of waiting threads in message queue
	165	*/
	166	#define MAX_MSGQUEUE_WAITERS 32
	167
	168	/**
4af351c7 VK	169	* Message waiting queue class
4af351c7 VK	170	*/
9f2ad16c	171	class LIBNETXMS_EXPORTABLE MsgWaitQueue
deaa4491	172	{
deaa4491	173	private:
ef8a3c32	174	#if defined(_WIN32)
f128c07c VK	175	CRITICAL_SECTION m_mutex;
	176	HANDLE m_wakeupEvents[MAX_MSGQUEUE_WAITERS];
	177	BYTE m_waiters[MAX_MSGQUEUE_WAITERS];
ef8a3c32 VK	178	#elif defined(_USE_GNU_PTH)
	179	pth_mutex_t m_mutex;
	180	pth_cond_t m_wakeupCondition;
f128c07c VK	181	#else
	182	pthread_mutex_t m_mutex;
	183	pthread_cond_t m_wakeupCondition;
	184	#endif
f128c07c VK	185	UINT32 m_holdTime;
	186	int m_size;
	187	int m_allocated;
	188	WAIT_QUEUE_ELEMENT *m_elements;
14149881	189	UINT64 m_sequence;
deaa4491	190
f128c07c VK	191	void *waitForMessageInternal(UINT16 isBinary, UINT16 code, UINT32 id, UINT32 timeout);
	192
	193	void lock()
	194	{
	195	#ifdef _WIN32
	196	EnterCriticalSection(&m_mutex);
ef8a3c32 VK	197	#elif defined(_USE_GNU_PTH)
ef8a3c32 VK	198	pth_mutex_acquire(&m_mutex, FALSE, NULL);
f128c07c VK	199	#else
	200	pthread_mutex_lock(&m_mutex);
	201	#endif
	202	}
	203
	204	void unlock()
	205	{
	206	#ifdef _WIN32
	207	LeaveCriticalSection(&m_mutex);
ef8a3c32 VK	208	#elif defined(_USE_GNU_PTH)
ef8a3c32 VK	209	pth_mutex_release(&m_mutex);
f128c07c VK	210	#else
	211	pthread_mutex_unlock(&m_mutex);
	212	#endif
	213	}
cc022855	214
d87ddcc2 VK	215	void housekeeperRun();
d87ddcc2 VK	216
c73c3ba9	217	static Mutex m_housekeeperLock;
669fcb92	218	static HashMap<UINT64, MsgWaitQueue> *m_activeQueues;
c73c3ba9	219	static Condition m_shutdownCondition;
d87ddcc2 VK	220	static THREAD m_housekeeperThread;
	221	static EnumerationCallbackResult houseKeeperCallback(const void key, const void object, void *arg);
	222	static THREAD_RESULT THREAD_CALL housekeeperThread(void *);
	223	static EnumerationCallbackResult diagInfoCallback(const void key, const void object, void *arg);
deaa4491 VK	224
	225	public:
	226	MsgWaitQueue();
	227	~MsgWaitQueue();
	228
b368969c VK	229	void put(NXCPMessage *pMsg);
	230	void put(NXCP_MESSAGE *pMsg);
	231	NXCPMessage *waitForMessage(WORD wCode, UINT32 dwId, UINT32 dwTimeOut)
deaa4491	232	{
b368969c	233	return (NXCPMessage *)waitForMessageInternal(0, wCode, dwId, dwTimeOut);
deaa4491	234	}
b368969c	235	NXCP_MESSAGE *waitForRawMessage(WORD wCode, UINT32 dwId, UINT32 dwTimeOut)
deaa4491	236	{
b368969c	237	return (NXCP_MESSAGE *)waitForMessageInternal(1, wCode, dwId, dwTimeOut);
deaa4491	238	}
cc022855	239
c17f6cbc	240	void clear();
f128c07c	241	void setHoldTime(UINT32 holdTime) { m_holdTime = holdTime; }
d87ddcc2 VK	242
	243	static void shutdown();
	244	static String getDiagInfo();
deaa4491 VK	245	};
deaa4491 VK	246
b549a0f8 VK	247	/**
	248	* NXCP encryption context
	249	*/
98abc9f1 VK	250	class LIBNETXMS_EXPORTABLE NXCPEncryptionContext : public RefCountObject
	251	{
	252	private:
	253	int m_cipher;
	254	BYTE *m_sessionKey;
	255	int m_keyLength;
	256	BYTE m_iv[EVP_MAX_IV_LENGTH];
e4e091f0	257	#ifdef _WITH_ENCRYPTION
9c3bf7f4 VK	258	MUTEX m_encryptorLock;
9c3bf7f4 VK	259	#if WITH_OPENSSL
e6336a90 VK	260	EVP_CIPHER_CTX m_encryptor;
e6336a90 VK	261	EVP_CIPHER_CTX m_decryptor;
9c3bf7f4 VK	262	#elif WITH_COMMONCRYPTO
	263	CCCryptorRef m_encryptor;
	264	CCCryptorRef m_decryptor;
	265	#endif
e4e091f0	266	#endif
98abc9f1 VK	267
98abc9f1 VK	268	NXCPEncryptionContext();
e6336a90	269	bool initCipher(int cipher);
98abc9f1 VK	270
98abc9f1 VK	271	public:
b368969c	272	static NXCPEncryptionContext create(NXCPMessage msg, RSA *privateKey);
967893bb	273	static NXCPEncryptionContext *create(UINT32 ciphers);
98abc9f1 VK	274
	275	virtual ~NXCPEncryptionContext();
	276
b368969c	277	NXCP_ENCRYPTED_MESSAGE encryptMessage(NXCP_MESSAGE msg);
6be0a20b	278	bool decryptMessage(NXCP_ENCRYPTED_MESSAGE msg, BYTE decryptionBuffer);
e6336a90	279
98abc9f1 VK	280	int getCipher() { return m_cipher; }
	281	BYTE *getSessionKey() { return m_sessionKey; }
	282	int getKeyLength() { return m_keyLength; }
	283	BYTE *getIV() { return m_iv; }
	284	};
	285
6be0a20b VK	286	/**
	287	* Message receiver result codes
	288	*/
	289	enum MessageReceiverResult
	290	{
	291	MSGRECV_SUCCESS = 0,
	292	MSGRECV_CLOSED = 1,
	293	MSGRECV_TIMEOUT = 2,
	294	MSGRECV_COMM_FAILURE = 3,
1bb62997 VK	295	MSGRECV_DECRYPTION_FAILURE = 4,
1bb62997 VK	296	MSGRECV_PROTOCOL_ERROR = 5
6be0a20b VK	297	};
	298
	299	/**
	300	* Message receiver - abstract base class
	301	*/
	302	class LIBNETXMS_EXPORTABLE AbstractMessageReceiver
	303	{
	304	private:
	305	BYTE *m_buffer;
	306	BYTE *m_decryptionBuffer;
	307	NXCPEncryptionContext *m_encryptionContext;
	308	size_t m_initialSize;
	309	size_t m_size;
	310	size_t m_maxSize;
	311	size_t m_dataSize;
	312	size_t m_bytesToSkip;
	313
1bb62997	314	NXCPMessage getMessageFromBuffer(bool protocolError);
6be0a20b VK	315
	316	protected:
	317	virtual int readBytes(BYTE *buffer, size_t size, UINT32 timeout) = 0;
	318
	319	public:
	320	AbstractMessageReceiver(size_t initialSize, size_t maxSize);
	321	virtual ~AbstractMessageReceiver();
	322
	323	void setEncryptionContext(NXCPEncryptionContext *ctx) { m_encryptionContext = ctx; }
	324
b368969c VK	325	NXCPMessage readMessage(UINT32 timeout, MessageReceiverResult result);
	326	NXCP_MESSAGE getRawMessageBuffer() { return (NXCP_MESSAGE )m_buffer; }
	327
	328	static const TCHAR *resultToText(MessageReceiverResult result);
6be0a20b VK	329	};
	330
	331	/**
	332	* Message receiver - socket implementation
	333	*/
	334	class LIBNETXMS_EXPORTABLE SocketMessageReceiver : public AbstractMessageReceiver
	335	{
	336	private:
	337	SOCKET m_socket;
	338
	339	protected:
	340	virtual int readBytes(BYTE *buffer, size_t size, UINT32 timeout);
	341
	342	public:
	343	SocketMessageReceiver(SOCKET socket, size_t initialSize, size_t maxSize);
	344	virtual ~SocketMessageReceiver();
	345	};
	346
	347	/**
	348	* Message receiver - UNIX socket/named pipe implementation
	349	*/
	350	class LIBNETXMS_EXPORTABLE PipeMessageReceiver : public AbstractMessageReceiver
	351	{
	352	private:
	353	HPIPE m_pipe;
	354	#ifdef _WIN32
	355	HANDLE m_readEvent;
	356	#endif
	357
	358	protected:
	359	virtual int readBytes(BYTE *buffer, size_t size, UINT32 timeout);
	360
	361	public:
	362	PipeMessageReceiver(HPIPE pipe, size_t initialSize, size_t maxSize);
	363	virtual ~PipeMessageReceiver();
	364	};
	365
503da871	366	/**
d3a20572	367	* NXCP stresam compression methods
503da871	368	*/
d3a20572	369	enum NXCPStreamCompressionMethod
503da871	370	{
d3a20572	371	NXCP_STREAM_COMPRESSION_NONE = 0,
90ed558d VK	372	NXCP_STREAM_COMPRESSION_LZ4 = 1,
90ed558d VK	373	NXCP_STREAM_COMPRESSION_DEFLATE = 2
503da871 VK	374	};
	375
	376	/**
	377	* Abstract stream compressor
	378	*/
	379	class LIBNETXMS_EXPORTABLE StreamCompressor
	380	{
	381	public:
9757ca46 VK	382	virtual ~StreamCompressor();
9757ca46 VK	383
503da871 VK	384	virtual size_t compress(const BYTE in, size_t inSize, BYTE out, size_t maxOutSize) = 0;
	385	virtual size_t decompress(const BYTE in, size_t inSize, const BYTE *out) = 0;
	386	virtual size_t compressBufferSize(size_t dataSize) = 0;
	387
d3a20572	388	static StreamCompressor *create(NXCPStreamCompressionMethod method, bool compress, size_t maxBlockSize);
503da871 VK	389	};
	390
	391	/**
	392	* Dummy stream compressor
	393	*/
	394	class LIBNETXMS_EXPORTABLE DummyStreamCompressor : public StreamCompressor
	395	{
	396	public:
9757ca46 VK	397	virtual ~DummyStreamCompressor();
9757ca46 VK	398
503da871 VK	399	virtual size_t compress(const BYTE in, size_t inSize, BYTE out, size_t maxOutSize);
	400	virtual size_t decompress(const BYTE in, size_t inSize, const BYTE *out);
	401	virtual size_t compressBufferSize(size_t dataSize);
	402	};
	403
	404	struct __LZ4_stream_t;
	405	struct __LZ4_streamDecode_t;
	406
	407	/**
	408	* LZ4 stream compressor
	409	*/
	410	class LIBNETXMS_EXPORTABLE LZ4StreamCompressor : public StreamCompressor
	411	{
	412	private:
	413	union
	414	{
	415	__LZ4_stream_t *encoder;
	416	__LZ4_streamDecode_t *decoder;
	417	} m_stream;
	418	char *m_buffer;
	419	size_t m_maxBlockSize;
	420	size_t m_bufferSize;
	421	size_t m_bufferPos;
	422	bool m_compress;
	423
	424	public:
	425	LZ4StreamCompressor(bool compress, size_t maxBlockSize);
	426	virtual ~LZ4StreamCompressor();
	427
	428	virtual size_t compress(const BYTE in, size_t inSize, BYTE out, size_t maxOutSize);
	429	virtual size_t decompress(const BYTE in, size_t inSize, const BYTE *out);
	430	virtual size_t compressBufferSize(size_t dataSize);
	431	};
	432
90ed558d VK	433	struct z_stream_s;
	434
	435	/**
	436	* Deflate stream compressor
	437	*/
	438	class LIBNETXMS_EXPORTABLE DeflateStreamCompressor : public StreamCompressor
	439	{
	440	private:
	441	z_stream_s *m_stream;
	442	BYTE *m_buffer;
	443	size_t m_bufferSize;
	444	bool m_compress;
	445
	446	public:
	447	DeflateStreamCompressor(bool compress, size_t maxBlockSize);
	448	virtual ~DeflateStreamCompressor();
	449
	450	virtual size_t compress(const BYTE in, size_t inSize, BYTE out, size_t maxOutSize);
	451	virtual size_t decompress(const BYTE in, size_t inSize, const BYTE *out);
	452	virtual size_t compressBufferSize(size_t dataSize);
	453	};
	454
208d7427 VK	455	#if 0
	456	/**
	457	* NXCP message consumer interface
	458	*/
	459	class LIBNETXMS_EXPORTABLE MessageConsumer
	460	{
	461	public:
	462	virtual SOCKET getSocket() = 0;
	463	virtual void processMessage(NXCPMessage *msg) = 0;
	464	};
	465
	466	/**
	467	* Socket receiver - manages receiving NXCP messages from multiple sockets
	468	*/
	469	class LIBNETXMS_EXPORTABLE SocketReceiver
	470	{
	471	private:
	472	THREAD m_thread;
	473	HashMap<SOCKET, MessageConsumer> *m_consumers;
	474
	475	static int m_maxSocketsPerThread;
	476	static ObjectArray<SocketReceiver> *m_receivers;
	477
	478	public:
	479	static void start();
	480	static void shutdown();
	481
	482	static void addConsumer(MessageConsumer *mc);
	483	static void removeConsumer(MessageConsumer *mc);
	484
	485	static String getDiagInfo();
	486	};
	487	#endif
	488
9f2ad16c VK	489	#else /* __cplusplus */
9f2ad16c VK	490
b368969c	491	typedef void NXCPMessage;
98abc9f1	492	typedef void NXCPEncryptionContext;
9f2ad16c VK	493
	494	#endif
	495
da9ac8fc VK	496	typedef bool (NXCPMessageNameResolver)(UINT16 code, TCHAR buffer);
da9ac8fc VK	497
deaa4491 VK	498
deaa4491 VK	499	//
0d9c1b96 VK	500	// Functions
	501	//
	502
	503	#ifdef __cplusplus
0d9c1b96	504
b368969c VK	505	int LIBNETXMS_EXPORTABLE RecvNXCPMessage(SOCKET hSocket, NXCP_MESSAGE *pMsg,
b368969c VK	506	NXCP_BUFFER *pBuffer, UINT32 dwMaxMsgSize,
98abc9f1	507	NXCPEncryptionContext **ppCtx,
967893bb	508	BYTE *pDecryptionBuffer, UINT32 dwTimeout);
b368969c VK	509	int LIBNETXMS_EXPORTABLE RecvNXCPMessageEx(SOCKET hSocket, NXCP_MESSAGE **msgBuffer,
b368969c VK	510	NXCP_BUFFER nxcpBuffer, UINT32 bufferSize,
cc022855	511	NXCPEncryptionContext **ppCtx,
967893bb VK	512	BYTE **decryptionBuffer, UINT32 dwTimeout,
967893bb VK	513	UINT32 maxMsgSize);
d3a20572 VK	514	NXCP_MESSAGE LIBNETXMS_EXPORTABLE *CreateRawNXCPMessage(UINT16 code, UINT32 id, UINT16 flags,
	515	const void *data, size_t dataSize,
	516	NXCP_MESSAGE *buffer, bool allowCompression);
967893bb	517	BOOL LIBNETXMS_EXPORTABLE SendFileOverNXCP(SOCKET hSocket, UINT32 dwId, const TCHAR *pszFile,
cc022855	518	NXCPEncryptionContext *pCtx, long offset,
7b8b337e	519	void (* progressCallback)(INT64, void ), void cbArg,
d3a20572	520	MUTEX mutex, NXCPStreamCompressionMethod compressionMethod = NXCP_STREAM_COMPRESSION_NONE);
7b8b337e	521	BOOL LIBNETXMS_EXPORTABLE NXCPGetPeerProtocolVersion(SOCKET hSocket, int *pnVersion, MUTEX mutex);
cc022855	522
da9ac8fc VK	523	TCHAR LIBNETXMS_EXPORTABLE NXCPMessageCodeName(UINT16 wCode, TCHAR buffer);
	524	void LIBNETXMS_EXPORTABLE NXCPRegisterMessageNameResolver(NXCPMessageNameResolver r);
	525	void LIBNETXMS_EXPORTABLE NXCPUnregisterMessageNameResolver(NXCPMessageNameResolver r);
	526
2df047f4	527	bool LIBNETXMS_EXPORTABLE InitCryptoLib(UINT32 dwEnabledCiphers);
e5390fb5 VK	528	UINT32 LIBNETXMS_EXPORTABLE NXCPGetSupportedCiphers();
e5390fb5 VK	529	String LIBNETXMS_EXPORTABLE NXCPGetSupportedCiphersAsText();
b368969c	530	NXCP_ENCRYPTED_MESSAGE LIBNETXMS_EXPORTABLE NXCPEncryptMessage(NXCPEncryptionContext pCtx, NXCP_MESSAGE *pMsg);
bf6fb6c3	531	bool LIBNETXMS_EXPORTABLE NXCPDecryptMessage(NXCPEncryptionContext *pCtx,
6be0a20b	532	NXCP_ENCRYPTED_MESSAGE *pMsg,
e44ac467	533	BYTE *pDecryptionBuffer);
b368969c	534	UINT32 LIBNETXMS_EXPORTABLE SetupEncryptionContext(NXCPMessage *pMsg,
98abc9f1	535	NXCPEncryptionContext **ppCtx,
b368969c	536	NXCPMessage **ppResponse,
4bd3d6c5	537	RSA *pPrivateKey, int nNXCPVersion);
b368969c	538	void LIBNETXMS_EXPORTABLE PrepareKeyRequestMsg(NXCPMessage pMsg, RSA pServerKey, bool useX509Format);
3aa0061c	539	RSA LIBNETXMS_EXPORTABLE LoadRSAKeys(const TCHAR pszKeyFile);
15cf5acc	540
bb8136f7	541	#ifdef _WIN32
967893bb	542	BOOL LIBNETXMS_EXPORTABLE SignMessageWithCAPI(BYTE pMsg, UINT32 dwMsgLen, const CERT_CONTEXT pCert,
b368969c	543	BYTE pBuffer, size_t bufferSize, UINT32 pdwSigLen);
bb8136f7 VK	544	#endif
bb8136f7 VK	545
0d9c1b96 VK	546	#endif
0d9c1b96 VK	547
9f2ad16c	548	#endif /* _nxcpapi_h_ */