示例#1
0
OCTagsPayload* OCCopyTagsResources(const char *deviceName, const unsigned char *id, const char *baseURI,
        uint8_t bitmap, uint16_t port, uint8_t ins, const char *rts,const  char *drel, uint32_t ttl)
{
    OCTagsPayload *tags = (OCTagsPayload *)OICCalloc(1, sizeof(OCTagsPayload));
    if (!tags)
    {
        return NULL;
    }
	if (deviceName)
    {
        tags->n.deviceName = OICStrdup(deviceName);
        if (!tags->n.deviceName)
        {
            goto memory_allocation_failed;
        }
    }
    if (id)
    {
        OICStrcpy((char*)tags->di.id, MAX_IDENTITY_SIZE, (char *)id);
        if (!tags->di.id)
        {
            goto memory_allocation_failed;
        }
    }
    if (baseURI)
    {
        tags->baseURI = OICStrdup(baseURI);
        if (!tags->baseURI)
        {
            goto memory_allocation_failed;
        }
    }
    tags->bitmap = bitmap;
    tags->port = port;
    tags->ins = ins;
    if (rts)
    {
        tags->rts = OICStrdup(rts);
        if (!tags->rts)
        {
            goto memory_allocation_failed;
        }
    }
    if (drel)
    {
        tags->drel = OICStrdup(drel);
        if (!tags->drel)
        {
            goto memory_allocation_failed;
        }
    }
    tags->ttl = ttl;
    return tags;

memory_allocation_failed:
    OC_LOG(ERROR, TAG, "Memory allocation failed.");
    OCFreeTagsResource(tags);
    return NULL;
}
OCStackResult SetPlatformInfo()
{
    static const OCPlatformInfo platformInfo =
        {
            .platformID = "IoTivityZigbeeID",
            .manufacturerName = "IoTivity",
            .manufacturerUrl = "http://iotivity.org",
            .modelNumber = "T1000",
            .dateOfManufacture = "January 14th, 2015",
            .platformVersion = "0.9.2",
            .operatingSystemVersion = "7",
            .hardwareVersion = "0.5",
            .firmwareVersion = "0",
            .supportUrl = "http://iotivity.org",
            .systemTime = ""
        };

    return OCSetPlatformInfo(platformInfo);
}

OCStackResult SetDeviceInfo()
{
    static OCDeviceInfo deviceInfo =
        {
            .deviceName = "IoTivity/Zigbee Server Sample",
            .specVersion = "IoTivity/Zigbee Device Spec Version",
        };
    char *dmv = OICStrdup("IoTivity/Zigbee Data Model Version");
    deviceInfo.dataModelVersions = (OCStringLL *)OICCalloc(1, sizeof(OCStringLL));
    deviceInfo.dataModelVersions->value = dmv;
    char *dup = OICStrdup("oic.wk.d");
    deviceInfo.types = (OCStringLL *)OICCalloc(1, sizeof(OCStringLL));
    deviceInfo.types->value = dup;
    return OCSetDeviceInfo(deviceInfo);
}

bool processSignal(bool set)
{
    static sig_atomic_t signal = 0;
    if (set)
    {
        signal = 1;
    }

    return signal == 1;
}

void processCancel(int signal)
{
    if(signal == SIGINT)
    {
        processSignal(true);
    }
}
示例#3
0
/* This function searches for the resource(sid:uri) in the ResourceList.
 * If the Resource is found in the list then it returns 0 else insert
 * the resource to front of the list and returns 1.
 */
int insertResource(const char * sid, char const * uri,
            const OCClientResponse * clientResponse)
{
    ResourceNode * iter = resourceList;
    char * sid_cpy =  OICStrdup(sid);
    char * uri_cpy = OICStrdup(uri);

    //Checking if the resource(sid:uri) is new
    while(iter)
    {
        if((strcmp(iter->sid, sid) == 0) && (strcmp(iter->uri, uri) == 0))
        {
            OICFree(sid_cpy);
            OICFree(uri_cpy);
            return 0;
        }
        else
        {
            iter = iter->next;
        }
    }

    //Creating new ResourceNode
    if((iter = (ResourceNode *) OICMalloc(sizeof(ResourceNode))))
    {
        iter->sid = sid_cpy;
        iter->uri = uri_cpy;
        iter->endpoint = clientResponse->devAddr;
        iter->next = NULL;
    }
    else
    {
        OC_LOG(ERROR, TAG, "Memory not allocated to ResourceNode");
        OICFree(sid_cpy);
        OICFree(uri_cpy);
        return -1;
    }

    //Adding new ResourceNode to front of the ResourceList
    if(!resourceList)
    {
        resourceList = iter;
    }
    else
    {
        iter->next = resourceList;
        resourceList = iter;
    }
    return 1;
}
示例#4
0
 NSResult NSProviderService::EnableRemoteService(const std::string &serverAddress)
 {
     NS_LOG(DEBUG, "EnableRemoteService - IN");
     NSResult result = NSProviderEnableRemoteService(OICStrdup(serverAddress.c_str()));
     NS_LOG(DEBUG, "EnableRemoteService - OUT");
     return result;
 }
示例#5
0
CAResult_t CABleGattDiscoverCharacteristics(bt_gatt_attribute_h service,
        const char *remoteAddress)
{
    OIC_LOG(DEBUG, TZ_BLE_CLIENT_TAG, "IN");

    VERIFY_NON_NULL_RET(service, TZ_BLE_CLIENT_TAG, "service is NULL", CA_STATUS_FAILED);

    VERIFY_NON_NULL_RET(remoteAddress, TZ_BLE_CLIENT_TAG, "remoteAddress is NULL", CA_STATUS_FAILED);

    char *addr = OICStrdup(remoteAddress);
    VERIFY_NON_NULL_RET(addr, TZ_BLE_CLIENT_TAG, "Malloc failed", CA_STATUS_FAILED);

    int32_t ret = bt_gatt_discover_characteristics(service, CABleGattCharacteristicsDiscoveredCb,
                  (void *)addr); // addr will be freed in callback.
    if (BT_ERROR_NONE != ret)
    {
        OIC_LOG_V(ERROR, TZ_BLE_CLIENT_TAG,
                  "bt_gatt_discover_characteristics failed with error [%d]", ret);
        OICFree(addr);
        return CA_STATUS_FAILED;
    }

    OIC_LOG(DEBUG, TZ_BLE_CLIENT_TAG, "OUT");
    return CA_STATUS_OK;
}
示例#6
0
CAResult_t CABleGattDiscoverServices(const char *remoteAddress)
{
    OIC_LOG(DEBUG, TZ_BLE_CLIENT_TAG, "IN");

    VERIFY_NON_NULL_RET(remoteAddress, TZ_BLE_CLIENT_TAG,
                        "remote address is NULL", CA_STATUS_FAILED);

    char *addr = OICStrdup(remoteAddress);
    VERIFY_NON_NULL_RET(addr, TZ_BLE_CLIENT_TAG, "Malloc failed", CA_STATUS_FAILED);

    int32_t ret = bt_gatt_foreach_primary_services(remoteAddress, CABleGattPrimaryServiceCb,
                  (void *)addr); // addr memory will be free in callback.
    if (BT_ERROR_NONE != ret)
    {
        OIC_LOG_V(ERROR, TZ_BLE_CLIENT_TAG,
                  "bt_gatt_foreach_primary_services Failed with ret value [%d] ", ret);
        OICFree(addr);
        return CA_STATUS_FAILED;
    }
    else
    {
        OIC_LOG_V(DEBUG, TZ_BLE_CLIENT_TAG,
                  "bt_gatt_foreach_primary_services success for address [%s]", remoteAddress);
    }

    OIC_LOG(DEBUG, TZ_BLE_CLIENT_TAG, "OUT");
    return CA_STATUS_OK;
}
CAResult_t CAEthernetGetInterfaceInfo(char **interfaceName, char **ipAddress)
{
    OIC_LOG(DEBUG, ETHERNET_MONITOR_TAG, "IN");

    VERIFY_NON_NULL(interfaceName, ETHERNET_MONITOR_TAG, "interface name");
    VERIFY_NON_NULL(ipAddress, ETHERNET_MONITOR_TAG, "ip address");

    // Get the interface and ipaddress information from cache
    u_mutex_lock(g_ethernetNetInfoMutex);
    if (g_ethernetInterfaceName == NULL || g_ethernetIPAddress == NULL)
    {
        OIC_LOG(DEBUG, ETHERNET_MONITOR_TAG, "Network not enabled");

        u_mutex_unlock(g_ethernetNetInfoMutex);
        return CA_ADAPTER_NOT_ENABLED;
    }

    *interfaceName = (g_ethernetInterfaceName) ? strndup(g_ethernetInterfaceName,
                     strlen(g_ethernetInterfaceName)) : NULL;
    *ipAddress = (g_ethernetIPAddress) ? OICStrdup((const char *)g_ethernetIPAddress)
                 : NULL;

    u_mutex_unlock(g_ethernetNetInfoMutex);

    OIC_LOG(DEBUG, ETHERNET_MONITOR_TAG, "OUT");
    return CA_STATUS_OK;
}
示例#8
0
OCRDDiscoveryPayload *OCRDDiscoveryPayloadCreate(const char *deviceName, const char *id, int biasFactor)
{
    OCRDDiscoveryPayload *discoveryPayload = (OCRDDiscoveryPayload *)OICCalloc(1, sizeof(OCRDDiscoveryPayload));

    if (!discoveryPayload)
    {
        return NULL;
    }

    if (deviceName)
    {
        discoveryPayload->n.deviceName = OICStrdup(deviceName);
        if (!discoveryPayload->n.deviceName)
        {
            OICFree(discoveryPayload);
            return NULL;
        }
    }
    if (id)
    {
        OICStrcpy((char*)discoveryPayload->di.id, MAX_IDENTITY_SIZE, id);
    }

    discoveryPayload->sel = biasFactor;

    return discoveryPayload;
}
示例#9
0
static OCStackResult appendStringLL(OCStringLL **type, const unsigned char *value)
{
    OCStringLL *temp= (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
    if (!temp)
    {
        return OC_STACK_NO_MEMORY;
    }
    temp->value = OICStrdup((char *)value);
    if (!temp->value)
    {
        return OC_STACK_NO_MEMORY;
    }
    temp->next = NULL;

    if (!*type)
    {
        *type = temp;
    }
    else
    {
        OCStringLL *tmp = *type;
        for (; tmp->next; tmp = tmp->next);
        tmp->next = temp;
    }
    return OC_STACK_OK;
}
示例#10
0
OCTagsPayload* OCCopyTagsResources(const char *deviceName, const unsigned char *id, uint64_t ttl)
{
    OCTagsPayload *tags = (OCTagsPayload *)OICCalloc(1, sizeof(OCTagsPayload));
    if (!tags)
    {
        return NULL;
    }
    if (deviceName)
    {
        tags->n.deviceName = OICStrdup(deviceName);
        if (!tags->n.deviceName)
        {
            goto memory_allocation_failed;
        }
    }
    if (id)
    {
        OICStrcpy((char*)tags->di.id, MAX_IDENTITY_SIZE, (char *)id);
    }
    tags->ttl = ttl;
    return tags;

memory_allocation_failed:
    OIC_LOG(ERROR, TAG, "Memory allocation failed.");
    OCFreeTagsResource(tags);
    return NULL;
}
示例#11
0
static void OCCopyPropertyValue (OCRepPayloadValue *dest, OCRepPayloadValue *source)
{
    if (!source || !dest)
    {
        return;
    }

    switch(source->type)
    {
        case OCREP_PROP_STRING:
            dest->str = OICStrdup(source->str);
            break;
        case OCREP_PROP_BYTE_STRING:
            dest->ocByteStr.bytes = (uint8_t*)OICMalloc(source->ocByteStr.len * sizeof(uint8_t));
            VERIFY_PARAM_NON_NULL(TAG, dest->ocByteStr.bytes, "Failed allocating memory");
            dest->ocByteStr.len = source->ocByteStr.len;
            memcpy(dest->ocByteStr.bytes, source->ocByteStr.bytes, dest->ocByteStr.len);
            break;
        case OCREP_PROP_OBJECT:
            dest->obj = OCRepPayloadClone(source->obj);
            break;
        case OCREP_PROP_ARRAY:
            OCCopyPropertyValueArray(dest, source);
            break;
        default:
            // Nothing to do for the trivially copyable types.
            break;
    }
exit:
    return;
}
示例#12
0
static OCStackResult CreateStringLL(uint8_t numElements, OCResourceHandle handle,
                                    const char* (*getValue)(OCResourceHandle handle, uint8_t i),
                                    OCStringLL **stringLL)
{
    for (uint8_t i = 0; i < numElements; ++i)
    {
        const char *value = getValue(handle, i);
        OIC_LOG_V(ERROR, TAG, "value: %s", value);
        if (!*stringLL)
        {
            *stringLL = (OCStringLL *)OICCalloc(1, sizeof(OCStringLL));
            if (!*stringLL)
            {
                OIC_LOG(ERROR, TAG, "Failed allocating memory.");
                return OC_STACK_NO_MEMORY;
            }
            (*stringLL)->value = OICStrdup(value);
            if (!(*stringLL)->value)
            {
                OIC_LOG(ERROR, TAG, "Failed copying to OCStringLL.");
                return OC_STACK_NO_MEMORY;
            }
        }
        else
        {
            OCStringLL *cur = *stringLL;
            while (cur->next)
            {
                cur = cur->next;
            }
            cur->next = (OCStringLL *)OICCalloc(1, sizeof(OCStringLL));
            if (!cur->next)
            {
                OIC_LOG(ERROR, TAG, "Failed allocating memory.");
                return OC_STACK_NO_MEMORY;
            }
            cur->next->value = OICStrdup(value);
            if (!cur->next->value)
            {
                OIC_LOG(ERROR, TAG, "Failed copying to OCStringLL.");
                return OC_STACK_NO_MEMORY;
            }
        }
    }
    return OC_STACK_OK;
}
示例#13
0
static void OCCopyPropertyValueArray(OCRepPayloadValue* dest, OCRepPayloadValue* source)
{
    if (!dest || !source)
    {
        return;
    }

    size_t dimTotal = calcDimTotal(source->arr.dimensions);
    switch(source->arr.type)
    {
        case OCREP_PROP_INT:
            dest->arr.iArray = (int64_t*)OICMalloc(dimTotal * sizeof(int64_t));
            VERIFY_PARAM_NON_NULL(TAG, dest->arr.iArray, "Failed allocating memory");
            memcpy(dest->arr.iArray, source->arr.iArray, dimTotal * sizeof(int64_t));
            break;
        case OCREP_PROP_DOUBLE:
            dest->arr.dArray = (double*)OICMalloc(dimTotal * sizeof(double));
            VERIFY_PARAM_NON_NULL(TAG, dest->arr.dArray, "Failed allocating memory");
            memcpy(dest->arr.dArray, source->arr.dArray, dimTotal * sizeof(double));
            break;
        case OCREP_PROP_BOOL:
            dest->arr.bArray = (bool*)OICMalloc(dimTotal * sizeof(bool));
            VERIFY_PARAM_NON_NULL(TAG, dest->arr.bArray, "Failed allocating memory");
            memcpy(dest->arr.bArray, source->arr.bArray, dimTotal * sizeof(bool));
            break;
        case OCREP_PROP_STRING:
            dest->arr.strArray = (char**)OICMalloc(dimTotal * sizeof(char*));
            VERIFY_PARAM_NON_NULL(TAG, dest->arr.strArray, "Failed allocating memory");
            for(size_t i = 0; i < dimTotal; ++i)
            {
                dest->arr.strArray[i] = OICStrdup(source->arr.strArray[i]);
            }
            break;
        case OCREP_PROP_OBJECT:
            dest->arr.objArray = (OCRepPayload**)OICMalloc(dimTotal * sizeof(OCRepPayload*));
            VERIFY_PARAM_NON_NULL(TAG, dest->arr.objArray, "Failed allocating memory");
            for(size_t i = 0; i < dimTotal; ++i)
            {
                dest->arr.objArray[i] = OCRepPayloadClone(source->arr.objArray[i]);
            }
            break;
        case OCREP_PROP_ARRAY:
            dest->arr.objArray = (OCRepPayload**)OICMalloc(dimTotal * sizeof(OCRepPayload*));
            VERIFY_PARAM_NON_NULL(TAG, dest->arr.objArray, "Failed allocating memory");
            for(size_t i = 0; i < dimTotal; ++i)
            {
                dest->arr.objArray[i] = OCRepPayloadClone(source->arr.objArray[i]);
            }
            break;
        default:
            OIC_LOG(ERROR, TAG, "CopyPropertyValueArray invalid type");
            break;
    }
exit:
    return;
}
示例#14
0
        ::NSMessage *NSProviderService::getNSMessage(NSMessage *msg)
        {
            ::NSMessage *nsMsg = new ::NSMessage;
            nsMsg->messageId = msg->getMessageId();
            OICStrcpy(nsMsg->providerId, msg->getProviderId().length(), msg->getProviderId().c_str());
            nsMsg->sourceName = OICStrdup(msg->getSourceName().c_str());
            nsMsg->type = (::NSMessageType) msg->getType();
            nsMsg->dateTime = OICStrdup(msg->getTime().c_str());
            nsMsg->ttl = msg->getTTL();
            nsMsg->title = OICStrdup(msg->getTitle().c_str());
            nsMsg->contentText = OICStrdup(msg->getContentText().c_str());

            nsMsg->mediaContents = new ::NSMediaContents;
            if (msg->getMediaContents() != nullptr)
                nsMsg->mediaContents->iconImage = OICStrdup(msg->getMediaContents()->getIconImage().c_str());
            else
                nsMsg->mediaContents->iconImage = nullptr;
            return nsMsg;
        }
示例#15
0
OCStackResult getZigBeeAttributesForOICResource (char * OICResourceType,
                                                    AttributeList *attributeList) // GET
{
    if (strcmp (OICResourceType, OIC_TEMPERATURE_SENSOR) == 0)
    {
        attributeList->count = 1;
        attributeList->list[0].oicAttribute = OICStrdup(OIC_TEMPERATURE_ATTRIBUTE);
        attributeList->list[0].zigBeeAttribute = ZB_TEMPERATURE_ATTRIBUTE_ID;
        attributeList->list[0].oicType = OIC_ATTR_DOUBLE;
        attributeList->list[0].zigbeeType = ZB_16_SINT;
        return OC_STACK_OK;
    }
    else if (strcmp (OICResourceType, OIC_DIMMABLE_LIGHT) == 0)
    {
        attributeList->count = 1;
        attributeList->list[0].oicAttribute = OICStrdup(OIC_DIMMING_ATTRIBUTE);
        attributeList->list[0].zigBeeAttribute = ZB_CURRENT_LEVEL_ATTRIBUTE_READONLY;
        attributeList->list[0].oicType = OIC_ATTR_INT;
        attributeList->list[0].zigbeeType = ZB_8_UINT;
        return OC_STACK_OK;
    }
    else if (strcmp (OICResourceType, OIC_CONTACT_SENSOR) == 0)
    {
        attributeList->count = 1;
        attributeList->list[0].oicAttribute = OICStrdup(OIC_CONTACT_ATTRIBUTE);
        attributeList->list[0].zigBeeAttribute = ZB_CONTACT_ATTRIBUTE_ID;
        attributeList->list[0].oicType = OIC_ATTR_BOOL;
        attributeList->list[0].zigbeeType = ZB_BOOL;
        return OC_STACK_OK;
    }
    else if (strcmp (OICResourceType, OIC_BINARY_SWITCH) == 0)
    {
        attributeList->count = 1;
        attributeList->list[0].oicAttribute = OICStrdup(OIC_ON_OFF_ATTRIBUTE);
        attributeList->list[0].zigBeeAttribute = ZB_ON_OFF_ATTRIBUTE_ID;
        attributeList->list[0].oicType = OIC_ATTR_BOOL;
        attributeList->list[0].zigbeeType = ZB_BOOL;
        return OC_STACK_OK;
    }

    return OC_STACK_ERROR;
}
示例#16
0
TEST(DoxmEntityHandlerTest, DoxmEntityHandlerValidRequest)
{
    EXPECT_EQ(OC_STACK_INVALID_PARAM, InitDoxmResource());
    char query[] = "oxm=0&owned=false&owner=owner1";
    OCEntityHandlerRequest req = {0};
    req.method = OC_REST_GET;
    req.query = OICStrdup(query);
    EXPECT_EQ(OC_EH_ERROR, DoxmEntityHandler(OCEntityHandlerFlag::OC_REQUEST_FLAG, &req));

    OICFree(req.query);
}
示例#17
0
void CALEGattServerConnectionStateChanged(bool connected, const char *remoteAddress)
{
    VERIFY_NON_NULL_VOID(remoteAddress, TAG, "remote address");

    CAResult_t res = CA_STATUS_OK;
    if (connected)
    {
        OIC_LOG_V(DEBUG, TAG, "Connected to [%s]", remoteAddress);
        g_LEConnectedState = true;
        char *addr = OICStrdup(remoteAddress);
        oc_mutex_lock(g_LEClientListMutex);
        res  = CAAddLEClientInfoToList(&g_LEClientList, addr);
        if (CA_STATUS_OK != res)
        {
            OIC_LOG(ERROR, TAG, "CAAddLEClientInfoToList failed");
            oc_mutex_unlock(g_LEClientListMutex);
            OICFree(addr);
            return;
        }
        oc_mutex_unlock(g_LEClientListMutex);

        /*
         * TV Easysetup does not use IoTivity BLE advertisement.
         */

        // res = CALEStopAdvertise();
        // if (CA_STATUS_OK != res)
        // {
        //     OIC_LOG_V(ERROR, TAG, "Failed to stop advertising [%d]", res);
        //     return;
        // }
    }
    else
    {
        OIC_LOG_V(DEBUG, TAG, "Disconnected from [%s]", remoteAddress);
        g_LEConnectedState = false;
        oc_mutex_lock(g_LEClientListMutex);
        CARemoveLEClientInfoFromList(&g_LEClientList, remoteAddress);
        oc_mutex_unlock(g_LEClientListMutex);

        /*
         * TV Easysetup does not use IoTivity BLE advertisement.
         */

        // res = CALEStartAdvertise();
        // if (CA_STATUS_OK != res)
        // {
        //     OIC_LOG_V(ERROR, TAG, "Failed to start advertising [%d]", res);
        //     return;
        // }
    }
}
示例#18
0
NSTopicLL * NSProviderGetTopicsCacheData(NSCacheList * regTopicList)
{
    NS_LOG(DEBUG, "NSProviderGetTopicsCache - IN");
    pthread_mutex_lock(&NSCacheMutex);

    NSCacheElement * iter = regTopicList->head;

    if (!iter)
    {
        pthread_mutex_unlock(&NSCacheMutex);
        return NULL;
    }

    NSTopicLL * iterTopic = NULL;
    NSTopicLL * newTopic = NULL;
    NSTopicLL * topics = NULL;

    while (iter)
    {
        NSCacheTopicData * curr = (NSCacheTopicData *) iter->data;
        newTopic = (NSTopicLL *) OICMalloc(sizeof(NSTopicLL));

        if (!newTopic)
        {
            pthread_mutex_unlock(&NSCacheMutex);
            return NULL;
        }

        newTopic->state = curr->state;
        newTopic->next = NULL;
        newTopic->topicName = OICStrdup(curr->topicName);

        if (!topics)
        {
            iterTopic = topics = newTopic;
        }
        else
        {
            iterTopic->next = newTopic;
            iterTopic = newTopic;
        }

        iter = iter->next;
    }

    pthread_mutex_unlock(&NSCacheMutex);
    NS_LOG(DEBUG, "NSProviderGetTopicsCache - OUT");

    return topics;
}
示例#19
0
CAResult_t CAIPGetInterfaceSubnetMask(const char *ipAddress, char **subnetMask)
{
    OIC_LOG(DEBUG, IP_MONITOR_TAG, "IN");

    VERIFY_NON_NULL(subnetMask, IP_MONITOR_TAG, "subnet mask");
    VERIFY_NON_NULL(ipAddress, IP_MONITOR_TAG, "ipAddress is null");
    VERIFY_NON_NULL(g_networkMonitorContext, IP_MONITOR_TAG, "g_networkMonitorContext is null");
    VERIFY_NON_NULL(g_networkMonitorContextMutex, IP_MONITOR_TAG,
                    "g_networkMonitorContextMutex is null");

    // Get the interface and ipaddress information from cache
    ca_mutex_lock(g_networkMonitorContextMutex);
    if (!g_networkMonitorContext->netInterfaceList
        || (0 == u_arraylist_length(g_networkMonitorContext->netInterfaceList)))
    {
        OIC_LOG(DEBUG, IP_MONITOR_TAG, "Network not enabled");
        ca_mutex_unlock(g_networkMonitorContextMutex);
        return CA_ADAPTER_NOT_ENABLED;
    }

    uint32_t list_length = u_arraylist_length(g_networkMonitorContext->netInterfaceList);
    OIC_LOG_V(DEBUG, IP_MONITOR_TAG, "list lenght [%d]", list_length);
    for (uint32_t list_index = 0; list_index < list_length; list_index++)
    {
        CANetInfo_t *info = (CANetInfo_t *) u_arraylist_get(
                g_networkMonitorContext->netInterfaceList, list_index);
        if (!info)
        {
            continue;
        }

        if (strncmp(info->ipAddress, ipAddress, strlen(ipAddress)) == 0)
        {
            if (!info->subnetMask)
            {
                OIC_LOG(ERROR, IP_MONITOR_TAG,
                        "CAIPGetInterfaceSubnetMask subnetmask is null");
            }
            OIC_LOG_V(DEBUG, IP_MONITOR_TAG,
                      "CAIPGetInterfaceSubnetMask subnetmask is %s", info->subnetMask);
            *subnetMask = info->subnetMask ? OICStrdup(info->subnetMask) : NULL;
            break;
        }
    }
    ca_mutex_unlock(g_networkMonitorContextMutex);

    OIC_LOG(DEBUG, IP_MONITOR_TAG, "OUT");
    return CA_STATUS_OK;
}
示例#20
0
TEST(StringTests, StrdupNormalDup)
{
    char param[] = "This is a normal parameter";

    char* result = OICStrdup(param);

    EXPECT_TRUE(result != NULL);

    // ensure not the same pointer
    EXPECT_NE(param, result);

    EXPECT_STREQ(param, result);

    OICFree(result);
}
示例#21
0
CARemoteEndpoint_t *CAAdapterCopyRemoteEndpoint(const CARemoteEndpoint_t *remoteEndpoint)
{
    VERIFY_NON_NULL_RET(remoteEndpoint, CA_ADAPTER_UTILS_TAG, "Remote endpoint is NULL", NULL);

    CARemoteEndpoint_t *info = (CARemoteEndpoint_t *)
                               OICCalloc(1, sizeof(CARemoteEndpoint_t));
    if (NULL == info)
    {
        OIC_LOG(ERROR, CA_ADAPTER_UTILS_TAG, "Memory allocation failed !");
        return NULL;
    }

    info->connectivityType = remoteEndpoint->connectivityType;
    if (CA_EDR == info->connectivityType && strlen(remoteEndpoint->addressInfo.BT.btMacAddress))
    {
        strncpy(info->addressInfo.BT.btMacAddress, remoteEndpoint->addressInfo.BT.btMacAddress,
                CA_MACADDR_SIZE - 1);
        info->addressInfo.BT.btMacAddress[CA_MACADDR_SIZE - 1] = '\0';
    }
    else if (CA_LE == info->connectivityType && strlen(remoteEndpoint->addressInfo.LE.leMacAddress))
    {
        strncpy(info->addressInfo.LE.leMacAddress, remoteEndpoint->addressInfo.LE.leMacAddress,
                CA_MACADDR_SIZE - 1);
        info->addressInfo.LE.leMacAddress[CA_MACADDR_SIZE - 1] = '\0';
    }
    else if ((CA_WIFI == info->connectivityType || CA_ETHERNET == info->connectivityType)
             && strlen(remoteEndpoint->addressInfo.IP.ipAddress))
    {
        strncpy(info->addressInfo.IP.ipAddress, remoteEndpoint->addressInfo.IP.ipAddress,
                CA_IPADDR_SIZE - 1);
        info->addressInfo.IP.ipAddress[CA_IPADDR_SIZE - 1] = '\0';
        info->addressInfo.IP.port = remoteEndpoint->addressInfo.IP.port;
    }
    else
    {
        OIC_LOG(DEBUG, CA_ADAPTER_UTILS_TAG, "Its not matching. May be multicast.");
    }

    //For Multicast, remote address will be null while resourceUri will have the service UUID

    if (remoteEndpoint->resourceUri && strlen(remoteEndpoint->resourceUri))
    {
        info->resourceUri = OICStrdup(remoteEndpoint->resourceUri);
    }

    info->isSecured = remoteEndpoint->isSecured;
    return info;
}
示例#22
0
CARemoteEndpoint_t *CAAdapterCreateRemoteEndpoint(CAConnectivityType_t type,
        const char *address,
        const char *resourceUri)
{
    CARemoteEndpoint_t *info = (CARemoteEndpoint_t *)
                               OICCalloc(1, sizeof(CARemoteEndpoint_t));
    if (NULL == info)
    {
        OIC_LOG(ERROR, CA_ADAPTER_UTILS_TAG, "Memory allocation failed !");
        return NULL;
    }

    info->connectivityType = type;
    if (address && strlen(address))
    {
        if (CA_EDR == type)
        {
            strncpy(info->addressInfo.BT.btMacAddress, address, CA_MACADDR_SIZE - 1);
            info->addressInfo.BT.btMacAddress[CA_MACADDR_SIZE - 1] = '\0';
        }
        else if (CA_LE == type)
        {
            strncpy(info->addressInfo.LE.leMacAddress, address, CA_MACADDR_SIZE - 1);
            info->addressInfo.LE.leMacAddress[CA_MACADDR_SIZE - 1] = '\0';
        }
        else if (CA_WIFI == type || CA_ETHERNET == type)
        {
            strncpy(info->addressInfo.IP.ipAddress, address, CA_IPADDR_SIZE - 1);
            info->addressInfo.IP.ipAddress[CA_IPADDR_SIZE - 1] = '\0';
        }
        else
        {
            OIC_LOG(ERROR, CA_ADAPTER_UTILS_TAG, "type is not matched with any transport!");
            OICFree(info);
            return NULL;
        }
    }

    if (resourceUri && strlen(resourceUri))
    {
        info->resourceUri = OICStrdup(resourceUri);
    }

    return info;
}
示例#23
0
OCEntityHandlerRequest *CopyRequest(OCEntityHandlerRequest *entityHandlerRequest)
{
    OC_LOG(INFO, TAG, "Copying received request for slow response");

    OCEntityHandlerRequest *copyOfRequest =
            (OCEntityHandlerRequest *)OICMalloc(sizeof(OCEntityHandlerRequest));

    if (copyOfRequest)
    {
        // Do shallow copy
        memcpy(copyOfRequest, entityHandlerRequest, sizeof(OCEntityHandlerRequest));


        if (copyOfRequest->query)
        {
            copyOfRequest->query = OICStrdup(entityHandlerRequest->query);
            if(!copyOfRequest->query)
            {
                OC_LOG(ERROR, TAG, "Copy failed due to allocation failure");
                OICFree(copyOfRequest);
                return NULL;
            }
        }

        if (entityHandlerRequest->payload)
        {
            copyOfRequest->payload = reinterpret_cast<OCPayload*>
                    (OCRepPayloadClone ((OCRepPayload*) entityHandlerRequest->payload));
        }

        // Ignore vendor specific header options for example
        copyOfRequest->numRcvdVendorSpecificHeaderOptions = 0;
        copyOfRequest->rcvdVendorSpecificHeaderOptions = NULL;
    }

    if (copyOfRequest)
    {
        OC_LOG(INFO, TAG, "Copied client request");
    }
    else
    {
        OC_LOG(ERROR, TAG, "Error copying client request");
    }
    return copyOfRequest;
}
示例#24
0
void CAEDRGetLocalAddress(char **address)
{
    bool isAttached = false;
    JNIEnv* env;
    jint res = (*g_jvm)->GetEnv(g_jvm, (void**) &env, JNI_VERSION_1_6);
    if (JNI_OK != res)
    {
        OIC_LOG(DEBUG, TAG, "CAEDRGetLocalAddress - Could not get JNIEnv pointer");
        res = (*g_jvm)->AttachCurrentThread(g_jvm, &env, NULL);
        if (JNI_OK != res)
        {
            OIC_LOG(ERROR, TAG, "AttachCurrentThread failed");
            return;
        }
        isAttached = true;
    }

    jstring jni_address = CAEDRNativeGetLocalDeviceAddress(env);
    if (jni_address)
    {
        const char* localAddress = (*env)->GetStringUTFChars(env, jni_address, NULL);
        *address = OICStrdup(localAddress);
        if (*address == NULL)
        {
            if (isAttached)
            {
                (*g_jvm)->DetachCurrentThread(g_jvm);
            }
            (*env)->ReleaseStringUTFChars(env, jni_address, localAddress);
            (*env)->DeleteLocalRef(env, jni_address);
            return;
        }

        (*env)->ReleaseStringUTFChars(env, jni_address, localAddress);
        (*env)->DeleteLocalRef(env, jni_address);
    }

    OIC_LOG_V(DEBUG, TAG, "Local Address : %s", *address);
    if (isAttached)
    {
        (*g_jvm)->DetachCurrentThread(g_jvm);
    }
}
示例#25
0
OCStackResult BuildVirtualCollectionResourceResponse(const OCResourceCollectionPayload *resourcePtr,
        OCDiscoveryPayload *payload, OCDevAddr *devAddr)
{
    if (!resourcePtr || !payload)
    {
        return OC_STACK_INVALID_PARAM;
    }
    if (resourcePtr->tags && (resourcePtr->tags->bitmap & OC_SECURE))
    {
       if (GetSecurePortInfo(devAddr, &resourcePtr->tags->port) != OC_STACK_OK)
       {
           OC_LOG(ERROR, TAG, "Failed setting secure port.");
       }
    }
    if (resourcePtr->tags && !resourcePtr->tags->baseURI)
    {
        resourcePtr->tags->baseURI = OICStrdup(devAddr->addr);
    }
    OCDiscoveryCollectionPayloadAddResource(payload, resourcePtr->tags, resourcePtr->setLinks);
    return OC_STACK_OK;
}
示例#26
0
OCStackResult ZigbeeInit(const char * comPort, PIPlugin_Zigbee ** plugin,
                         PINewResourceFound newResourceCB)
{
    if(!plugin)
    {
        return OC_STACK_INVALID_PARAM;
    }
    *plugin = (PIPlugin_Zigbee *) OICMalloc(sizeof(PIPlugin_Zigbee) + sizeof(PIPluginBase));
    if(!*plugin)
    {
        return OC_STACK_NO_MEMORY;
    }
    ((*plugin)->header).type = PLUGIN_ZIGBEE;
    ((*plugin)->header).comPort = OICStrdup(comPort);
    ((*plugin)->header).NewResourceFoundCB = newResourceCB;
    ((*plugin)->header).next = NULL;
    ((*plugin)->header).resourceList = NULL;
    ((*plugin)->header).processEHRequest = ProcessEHRequest;

    gPlugin = plugin;
    return TWInitialize(comPort);
}
OCRDDiscoveryPayload *OCRDDiscoveryPayloadCreate(const char *deviceName, const char *id, int biasFactor)
{
    OCRDDiscoveryPayload *discoveryPayload = (OCRDDiscoveryPayload *)OICCalloc(1, sizeof(OCRDDiscoveryPayload));
    VERIFY_PARAM_NON_NULL(TAG, discoveryPayload, "Failed allocating memory for discovery payload");

    if (deviceName)
    {
        discoveryPayload->n.deviceName = OICStrdup(deviceName);
        VERIFY_PARAM_NON_NULL(TAG, discoveryPayload->n.deviceName,
                "Failed allocating memory for discovery device name");
    }
    if (id)
    {
        OICStrcpy((char*)discoveryPayload->di.id, MAX_IDENTITY_SIZE, id);
    }

    discoveryPayload->sel = biasFactor;
    return discoveryPayload;
exit:
    OICFree(discoveryPayload);
    discoveryPayload = NULL;
    return discoveryPayload;
}
示例#28
0
static void OCCopyPropertyValue (OCRepPayloadValue *dest, OCRepPayloadValue *source)
{
    if (!source || !dest)
    {
        return;
    }

    switch(source->type)
    {
        case OCREP_PROP_STRING:
            dest->str = OICStrdup(source->str);
            break;
        case OCREP_PROP_OBJECT:
            dest->obj = OCRepPayloadClone(source->obj);
            break;
        case OCREP_PROP_ARRAY:
            OCCopyPropertyValueArray(dest, source);
            break;
        default:
            // Nothing to do for the trivially copyable types.
            break;
    }
}
示例#29
0
int oic_log_set_module(oic_log_ctx_t *ctx, const char *module_name)
{
    char *mn;

    if (0 == ctx)
        return 0;

    /* Swap pointers so that module data's not erased in the event of failure: */
    mn = OICStrdup(module_name);
    if (0 == mn)
    {
        if (0 != ctx->module_name)
            free(ctx->module_name);
        return 0;
    }

    if (0 != ctx->module_name)
        free(ctx->module_name);

    ctx->module_name = mn;

    /* Notify: */
    return ctx->set_module(ctx, ctx->module_name);
}
示例#30
0
static void OCCopyPropertyValueArray(OCRepPayloadValue* dest, OCRepPayloadValue* source)
{
    size_t dimTotal = calcDimTotal(source->arr.dimensions);
    switch(source->arr.type)
    {
        case OCREP_PROP_INT:
            dest->arr.iArray = (int64_t*)OICMalloc(dimTotal * sizeof(int64_t));
            memcpy(dest->arr.iArray, source->arr.iArray, dimTotal * sizeof(int64_t));
            break;
        case OCREP_PROP_DOUBLE:
            dest->arr.dArray = (double*)OICMalloc(dimTotal * sizeof(double));
            memcpy(dest->arr.dArray, source->arr.dArray, dimTotal * sizeof(double));
            break;
        case OCREP_PROP_BOOL:
            dest->arr.bArray = (bool*)OICMalloc(dimTotal * sizeof(bool));
            memcpy(dest->arr.bArray, source->arr.bArray, dimTotal * sizeof(bool));
            break;
        case OCREP_PROP_STRING:
            dest->arr.strArray = (char**)OICMalloc(dimTotal * sizeof(char*));
            for(size_t i = 0; i < dimTotal; ++i)
            {
                dest->arr.strArray[i] = OICStrdup(source->arr.strArray[i]);
            }
            break;
        case OCREP_PROP_ARRAY:
            dest->arr.objArray = (OCRepPayload**)OICMalloc(dimTotal * sizeof(OCRepPayload*));
            for(size_t i = 0; i < dimTotal; ++i)
            {
                dest->arr.objArray[i] = OCRepPayloadClone(source->arr.objArray[i]);
            }
            break;
        default:
            OC_LOG(ERROR, TAG, PCF("CopyPropertyValueArray invalid type"));
            break;
    }
}