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>
#include <uv.h>
#include <dps/err.h>
#include <dps/uuid.h>

#ifdef __cplusplus
extern "C" {
#endif

#define A_SIZEOF(a)  (sizeof(a) / sizeof((a)[0]))

#define DPS_TRUE  1
#define DPS_FALSE 0

#define DPS_MCAST_PUB_DISABLED       0
#define DPS_MCAST_PUB_ENABLE_SEND    1
#define DPS_MCAST_PUB_ENABLE_RECV    2


typedef struct _DPS_Node DPS_Node;

typedef struct _DPS_NodeAddress DPS_NodeAddress;

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);

typedef struct _DPS_Publication DPS_Publication;

const DPS_UUID* DPS_PublicationGetUUID(const DPS_Publication* pub);

uint32_t DPS_PublicationGetSequenceNum(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);

DPS_Node* DPS_PublicationGetNode(const DPS_Publication* pub);

typedef struct _DPS_KeyStore DPS_KeyStore;

typedef DPS_Status (*DPS_ContentKeyCallback)(DPS_KeyStore* keyStore, const DPS_UUID* kid, uint8_t* key, size_t keyLen);

typedef DPS_Status (*DPS_NetworkKeyCallback)(DPS_KeyStore* keyStore, uint8_t* buffer, size_t bufferLen, size_t* keyLen);

struct _DPS_KeyStore {
    /* TODO: Add version information to this exposed struct or make it opaque and add setters. */
    void* userData;
    DPS_ContentKeyCallback contentKeyCB;
    DPS_NetworkKeyCallback networkKeyCB;
};

typedef struct _DPS_MemoryKeyStore DPS_MemoryKeyStore;
DPS_MemoryKeyStore* DPS_CreateMemoryKeyStore();
void DPS_DestroyMemoryKeyStore(DPS_MemoryKeyStore* mks);
DPS_Status DPS_SetContentKey(DPS_MemoryKeyStore* mks, const DPS_UUID* kid, uint8_t* key, size_t keyLen);
DPS_Status DPS_SetNetworkKey(DPS_MemoryKeyStore* mks, uint8_t* key, size_t keyLen);
DPS_KeyStore* DPS_MemoryKeyStoreHandle(DPS_MemoryKeyStore* mks);

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

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

void* DPS_GetNodeData(const DPS_Node* node);

DPS_Status DPS_StartNode(DPS_Node* node, int mcastPub, int listenPort);

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

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

uv_loop_t* DPS_GetLoop(DPS_Node* node);

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

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);

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

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

DPS_Status DPS_DestroyPublication(DPS_Publication* pub);

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

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

DPS_Node* DPS_GetPublicationNode(const DPS_Publication* pub);

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_Subscribe(DPS_Subscription* sub, DPS_PublicationHandler handler);

DPS_Status DPS_DestroySubscription(DPS_Subscription* sub);

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

DPS_Status DPS_Link(DPS_Node* node, DPS_NodeAddress* addr, DPS_OnLinkComplete cb, void* data);

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

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

uint16_t DPS_GetPortNumber(DPS_Node* node);

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

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

const char* DPS_NodeAddrToString(DPS_NodeAddress* addr);

DPS_NodeAddress* DPS_CreateAddress();

DPS_NodeAddress* DPS_SetAddress(DPS_NodeAddress* addr, const struct sockaddr* sa);

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

void DPS_DestroyAddress(DPS_NodeAddress* addr);

uint32_t DPS_Rand();

#ifdef __cplusplus
}
#endif

#endif