dps.h

Go to the documentation of this file.

/*
 *******************************************************************
 *
 * Copyright 2016 Intel Corporation All rights reserved.
 *
 *-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 *
 * Licensed 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 _DPS_H
#define _DPS_H

#include <stdint.h>
#include <stddef.h>
#ifdef _WIN32
#include <winsock2.h>
#else
#include <sys/socket.h>
#endif
#include <dps/err.h>
#include <dps/uuid.h>

#ifdef __cplusplus
extern "C" {
#endif

#define DPS_TRUE  1 
#define DPS_FALSE 0 
typedef struct _DPS_NodeAddress DPS_NodeAddress;

const char* DPS_NodeAddrToString(const DPS_NodeAddress* addr);

DPS_NodeAddress* DPS_CreateAddress(void);

DPS_NodeAddress* DPS_SetAddress(DPS_NodeAddress* addr, const char* addrText);

void DPS_CopyAddress(DPS_NodeAddress* dest, const DPS_NodeAddress* src);

void DPS_DestroyAddress(DPS_NodeAddress* addr);
 /* end of nodeaddress group */

typedef enum {
    DPS_KEY_SYMMETRIC,          
    DPS_KEY_EC,                 
    DPS_KEY_EC_CERT             
} DPS_KeyType;

typedef struct _DPS_KeySymmetric {
    const uint8_t* key;         
    size_t len;                 
} DPS_KeySymmetric;

#define DPS_AES_256_KEY_LEN 32 
typedef enum {
    DPS_EC_CURVE_RESERVED = 0,
    DPS_EC_CURVE_P384 = 2, 
    DPS_EC_CURVE_P521 = 3  
} DPS_ECCurve;

typedef struct _DPS_KeyEC {
    DPS_ECCurve curve; 
    const uint8_t* x; 
    const uint8_t* y; 
    const uint8_t* d; 
} DPS_KeyEC;

typedef struct _DPS_KeyCert {
    const char *cert;           
    const char *privateKey;     
    const char *password;       
} DPS_KeyCert;

typedef struct _DPS_Key {
    DPS_KeyType type; 
    union {
        DPS_KeySymmetric symmetric; 
        DPS_KeyEC ec;               
        DPS_KeyCert cert;           
    };
} DPS_Key;

typedef struct _DPS_KeyId {
    const uint8_t* id; 
    size_t len; 
} DPS_KeyId;

typedef struct _DPS_KeyStore DPS_KeyStore;

typedef struct _DPS_KeyStoreRequest DPS_KeyStoreRequest;

typedef DPS_Status (*DPS_KeyAndIdHandler)(DPS_KeyStoreRequest* request);

typedef DPS_Status (*DPS_KeyHandler)(DPS_KeyStoreRequest* request, const DPS_KeyId* keyId);

typedef DPS_Status (*DPS_EphemeralKeyHandler)(DPS_KeyStoreRequest* request, const DPS_Key* key);

typedef DPS_Status (*DPS_CAHandler)(DPS_KeyStoreRequest* request);

DPS_Status DPS_SetKeyAndId(DPS_KeyStoreRequest* request, const DPS_Key* key, const DPS_KeyId* keyId);

DPS_Status DPS_SetKey(DPS_KeyStoreRequest* request, const DPS_Key* key);

DPS_Status DPS_SetCA(DPS_KeyStoreRequest* request, const char* ca);

DPS_KeyStore* DPS_KeyStoreHandle(DPS_KeyStoreRequest* request);

DPS_KeyStore* DPS_CreateKeyStore(DPS_KeyAndIdHandler keyAndIdHandler, DPS_KeyHandler keyHandler,
                                 DPS_EphemeralKeyHandler ephemeralKeyHandler, DPS_CAHandler caHandler);

void DPS_DestroyKeyStore(DPS_KeyStore* keyStore);

DPS_Status DPS_SetKeyStoreData(DPS_KeyStore* keyStore, void* data);

void* DPS_GetKeyStoreData(const DPS_KeyStore* keyStore);
 /* end of KeyStore subgroup */

typedef struct _DPS_MemoryKeyStore DPS_MemoryKeyStore;

DPS_MemoryKeyStore* DPS_CreateMemoryKeyStore(void);

void DPS_DestroyMemoryKeyStore(DPS_MemoryKeyStore* keyStore);

DPS_Status DPS_SetContentKey(DPS_MemoryKeyStore* keyStore, const DPS_KeyId* keyId, const DPS_Key* key);

DPS_Status DPS_SetNetworkKey(DPS_MemoryKeyStore* keyStore, const DPS_KeyId* keyId, const DPS_Key* key);

DPS_Status DPS_SetTrustedCA(DPS_MemoryKeyStore* mks, const char* ca);

DPS_Status DPS_SetCertificate(DPS_MemoryKeyStore* mks, const char* cert, const char* key,
                              const char* password);

DPS_KeyStore* DPS_MemoryKeyStoreHandle(DPS_MemoryKeyStore* keyStore);
 /* end of MemoryKeyStore subgroup */
 /* end of keystore group */

typedef struct _DPS_Node DPS_Node;

DPS_Node* DPS_CreateNode(const char* separators, DPS_KeyStore* keyStore, const DPS_KeyId* keyId);

DPS_Status DPS_SetNodeData(DPS_Node* node, void* data);

void* DPS_GetNodeData(const DPS_Node* node);

#define DPS_MCAST_PUB_DISABLED       0

#define DPS_MCAST_PUB_ENABLE_SEND    1

#define DPS_MCAST_PUB_ENABLE_RECV    2

DPS_Status DPS_StartNode(DPS_Node* node, int mcastPub, DPS_NodeAddress* listenAddr);

typedef void (*DPS_OnNodeShutdown)(DPS_Node* node, void* data);

DPS_Status DPS_ShutdownNode(DPS_Node* node, DPS_OnNodeShutdown cb, void* data);

typedef void (*DPS_OnNodeDestroyed)(DPS_Node* node, void* data);

DPS_Status DPS_DestroyNode(DPS_Node* node, DPS_OnNodeDestroyed cb, void* data);

#define DPS_SUBSCRIPTION_UPDATE_RATE 2000

#define DPS_LINK_LOSS_TIMEOUT 30000

void DPS_SetNodeSubscriptionUpdateDelay(DPS_Node* node, uint32_t subsRateMsecs);

void DPS_SetNodeLinkLossTimeout(DPS_Node* node, uint32_t linkLossMsecs);

const DPS_NodeAddress* DPS_GetListenAddress(DPS_Node* node);

const char* DPS_GetListenAddressString(DPS_Node* node);

typedef void (*DPS_OnLinkComplete)(DPS_Node* node, const DPS_NodeAddress* addr, DPS_Status status, void* data);

DPS_Status DPS_Link(DPS_Node* node, const char* addrText, DPS_OnLinkComplete cb, void* data);

typedef void (*DPS_OnUnlinkComplete)(DPS_Node* node, const DPS_NodeAddress* addr, void* data);

DPS_Status DPS_Unlink(DPS_Node* node, const DPS_NodeAddress* addr, DPS_OnUnlinkComplete cb, void* data);

typedef void (*DPS_OnLinkLoss)(DPS_Node* node, const DPS_NodeAddress* addr, void* data);

DPS_Status DPS_SetLinkLossCallback(DPS_Node* node, DPS_OnLinkLoss cb, void* data);

typedef void (*DPS_OnResolveAddressComplete)(DPS_Node* node, const DPS_NodeAddress* addr, void* data);

DPS_Status DPS_ResolveAddress(DPS_Node* node, const char* host, const char* service, DPS_OnResolveAddressComplete cb, void* data);
 /* end of node group */

typedef struct _DPS_Publication DPS_Publication;

const DPS_UUID* DPS_PublicationGetUUID(const DPS_Publication* pub);

uint32_t DPS_PublicationGetSequenceNum(const DPS_Publication* pub);

int16_t DPS_PublicationGetTTL(const DPS_Publication* pub);

const char* DPS_PublicationGetTopic(const DPS_Publication* pub, size_t index);

size_t DPS_PublicationGetNumTopics(const DPS_Publication* pub);

int DPS_PublicationIsAckRequested(const DPS_Publication* pub);

const DPS_KeyId* DPS_PublicationGetSenderKeyId(const DPS_Publication* pub);

DPS_Node* DPS_PublicationGetNode(const DPS_Publication* pub);

DPS_Publication* DPS_CreatePublication(DPS_Node* node);

DPS_Publication* DPS_CopyPublication(const DPS_Publication* pub);

DPS_Status DPS_SetPublicationData(DPS_Publication* pub, void* data);

void* DPS_GetPublicationData(const DPS_Publication* pub);

typedef void (*DPS_AcknowledgementHandler)(DPS_Publication* pub, uint8_t* payload, size_t len);

DPS_Status DPS_InitPublication(DPS_Publication* pub,
                               const char** topics,
                               size_t numTopics,
                               int noWildCard,
                               const DPS_KeyId* keyId,
                               DPS_AcknowledgementHandler handler);

DPS_Status DPS_PublicationAddSubId(DPS_Publication* pub, const DPS_KeyId* keyId);

void DPS_PublicationRemoveSubId(DPS_Publication* pub, const DPS_KeyId* keyId);

DPS_Status DPS_Publish(DPS_Publication* pub, const uint8_t* pubPayload, size_t len, int16_t ttl);

typedef struct _DPS_Buffer {
    uint8_t* base;              
    size_t len;                 
} DPS_Buffer;

typedef void (*DPS_PublishBufsComplete)(DPS_Publication* pub, const DPS_Buffer* bufs, size_t numBufs,
                                        DPS_Status status, void* data);

DPS_Status DPS_PublishBufs(DPS_Publication* pub, const DPS_Buffer* bufs, size_t numBufs, int16_t ttl,
                           DPS_PublishBufsComplete cb, void* data);

typedef void (*DPS_OnPublicationDestroyed)(DPS_Publication* pub);

DPS_Status DPS_DestroyPublication(DPS_Publication* pub, DPS_OnPublicationDestroyed cb);

DPS_Status DPS_AckPublication(const DPS_Publication* pub, const uint8_t* ackPayload, size_t len);

typedef void (*DPS_AckPublicationBufsComplete)(DPS_Publication* pub, const DPS_Buffer* bufs, size_t numBufs,
                                               DPS_Status status, void* data);

DPS_Status DPS_AckPublicationBufs(const DPS_Publication* pub, const DPS_Buffer* bufs, size_t numBufs,
                                  DPS_AckPublicationBufsComplete cb, void* data);

uint32_t DPS_AckGetSequenceNum(const DPS_Publication* pub);

const DPS_KeyId* DPS_AckGetSenderKeyId(const DPS_Publication* pub);
 /* end of publication group */

typedef struct _DPS_Subscription DPS_Subscription;

const char* DPS_SubscriptionGetTopic(const DPS_Subscription* sub, size_t index);

size_t DPS_SubscriptionGetNumTopics(const DPS_Subscription* sub);

DPS_Subscription* DPS_CreateSubscription(DPS_Node* node, const char** topics, size_t numTopics);

DPS_Status DPS_SetSubscriptionData(DPS_Subscription* sub, void* data);

void* DPS_GetSubscriptionData(DPS_Subscription* sub);

DPS_Node* DPS_SubscriptionGetNode(const DPS_Subscription* sub);

DPS_Status DPS_SubscribeExpired(DPS_Subscription* sub, int enable);

typedef void (*DPS_PublicationHandler)(DPS_Subscription* sub, const DPS_Publication* pub, uint8_t* payload, size_t len);

DPS_Status DPS_Subscribe(DPS_Subscription* sub, DPS_PublicationHandler handler);

typedef void (*DPS_OnSubscriptionDestroyed)(DPS_Subscription* sub);

DPS_Status DPS_DestroySubscription(DPS_Subscription* sub, DPS_OnSubscriptionDestroyed cb);
 /* end of subscription group */

#ifdef __cplusplus
}
#endif

#endif