/**
 * Send an event to controller thread on reception of any message.
 * data - Pointer to received message, should be copied for future usage.
 * sendorId - Pointer to user/device ID, should be copied for future usage.
 * datasize - Received message size.
 */
static bool PostControllerEventReceivedMessage(const FlowQueue* receiveMsgQueue, const char *data, const char *sendorId, const unsigned int datasize)
{
	bool success = false;
	ControllerEvent *event = NULL;
	ReceivedMessage *receivedMsg = NULL;

	event = (ControllerEvent *)Flow_MemAlloc(sizeof(ControllerEvent));

	if (event)
	{
		event->evtType = ControllerEvent_ReceivedMessage;
		receivedMsg = (ReceivedMessage *)Flow_MemAlloc(sizeof(ReceivedMessage));

		if (receivedMsg)
		{
			//Allocate one extra byte for data, as the datasize we got from
			//FlowMessagingMessage_GetContentLength() doesn't include null terminator
			receivedMsg->data = (char *)Flow_MemAlloc(datasize + 1);
			receivedMsg->sendorId = (char *)Flow_MemAlloc(strlen(sendorId) + 1);

			if (receivedMsg->data && receivedMsg->sendorId)
			{
				strncpy(receivedMsg->data, data, datasize);
				receivedMsg->data[datasize] = '\0';
				strcpy(receivedMsg->sendorId, sendorId);
				event->details = receivedMsg;
				success = FlowQueue_Enqueue(*receiveMsgQueue, event);
			}

			if (!success)
			{
				if (receivedMsg->data)
				{
					Flow_MemFree((void **)&receivedMsg->data);
				}

				if (receivedMsg->sendorId)
				{
					Flow_MemFree((void **)&receivedMsg->sendorId);
				}

				Flow_MemFree((void **)&receivedMsg);
			}
		}

		if (!success)
		{
			Flow_MemFree((void **)&event);
		}
	}

	return success;
}
/**
 * Send an event to controller thread for success/failure of reading KVS config
 * data - Device setting read from datastore.
 *        In case of any failure, user should free any memory allocated to it.
 *        Otherwise, would be freed by receiver if successfully added to queue.
 */
static bool PostControllerEventSetting(const FlowQueue* receiveMsgQueue, char *data)
{
	bool success = false;
	ControllerEvent *event = NULL;

	//Allocated memory should be freed by the receiver
	event = (ControllerEvent *)Flow_MemAlloc(sizeof(ControllerEvent));
	if (event)
	{
		if (data)
		{
			event->evtType = ControllerEvent_SettingSuccess;
		}
		else
		{
			event->evtType = ControllerEvent_SettingFailure;
		}

		event->details = data;
		success = FlowQueue_Enqueue(*receiveMsgQueue, event);

		if (!success)
		{
			Flow_MemFree((void **)&event);
		}
	}

	return success;
}
示例#3
0
TreeNode TreeNode_Create(void)
{
    _treeNode node = (_treeNode) Flow_MemAlloc(sizeof(TreeNodeImpl));
    if (node)
    {
        memset(node, 0 , sizeof(TreeNodeImpl));

        node->ChildSlots = INITIAL_TREENODE_CHILD_SLOTS;
        node->Children = (struct TreeNodeImpl**) Flow_MemAlloc(sizeof(struct TreeNodeImpl*)*node->ChildSlots);
        if (node->Children)
        {
            memset(node->Children, 0, sizeof(TreeNodeImpl*) * node->ChildSlots);
        }
        else
        {
            node->ChildSlots = 0;
            node->Children  = NULL;
        }
    }
    return node;
}
示例#4
0
static char *FlowString_DuplicateWithLength(const char *text, int textLength)
{
    char *result = NULL;
    if (text)
    {
        result = (char*)Flow_MemAlloc(textLength+1);
        if (result)
        {
            memcpy(result, text, textLength);
            result[textLength] = '\0';
        }
    }
    return result;
}
示例#5
0
bool TreeNode_AddChild(TreeNode node, TreeNode child)
{
    bool result = false;
    _treeNode _node = (_treeNode) node;
    if (_node && child)
    {
        // Check whether we need to resize the children list to add a new child
        if (_node->ChildSlots <= _node->ChildCount)
        {
            TreeNodeImpl **oldChildrenList = (TreeNodeImpl**) _node->Children;

            // Double list capacity
            uint32_t newChildrenListSize = sizeof(TreeNode) * (_node->ChildSlots * 2);
            _node->Children = (struct TreeNodeImpl**) Flow_MemAlloc(newChildrenListSize);
            if (_node->Children)
            {
                _node->ChildSlots = (_node->ChildSlots * 2);
                memset(_node->Children, 0, newChildrenListSize);
                memcpy(_node->Children, oldChildrenList, _node->ChildCount * sizeof(TreeNode));
                Flow_MemFree((void **) &oldChildrenList);
            }
            else
            {
                _node->Children = (struct TreeNodeImpl**) oldChildrenList;
                goto error;
            }

        }

        // Add the new child to the list        
        _node->Children[_node->ChildCount] = child;
        _node->ChildCount++;
        ((_treeNode)child)->ChildID = _node->ChildCount;

        // Make sure the Parent pointer is set so that
        // Tree_Delete will also free the root node.
        ((_treeNode)child)->Parent = (struct TreeNodeImpl *)_node;

        result = true;
    }
error:
    return result;
}
示例#6
0
bool TreeNode_SetValue(const TreeNode node, const uint8_t* value, const uint32_t length)
{
    bool result = false;
    _treeNode _node = (_treeNode) node;
    if (_node && value)
    {
        if (_node->Value)
            Flow_MemFree((void **) &_node->Value);

        _node->Value = Flow_MemAlloc(sizeof(uint8_t) * (length+1));
        if (_node->Value)
        {
            if (length > 0)
                memcpy(_node->Value, value, length);
            
            _node->Value[length] = '\0';
            result = true;
        }
    }
    return result;
}
示例#7
0
bool TreeNode_SetName(const TreeNode node, const char* name, const uint32_t length)
{
    bool result = false;
    _treeNode _node = (_treeNode) node;
    if (_node && name)
    {
        if (_node->Name)
            Flow_MemFree((void **) &_node->Name);

        _node->Name = Flow_MemAlloc(sizeof(char) * (length+1));
        if (_node->Name)
        {
            if (length > 0)
                memcpy(_node->Name, name, length);
            
            _node->Name[length] = '\0';
            result = true;
        }
    }
    return result;
}
示例#8
0
TreeNode TreeNode_Navigate(const TreeNode rootNode, const char* path)
{
    _treeNode currentNode = rootNode;
    _treeNode _node = (_treeNode) rootNode;

    // Validate inputs (Check rootNode & path are not null)
    // Assuming path is null-terminated 
    if (rootNode && path)
    {
        char* _path = (char*) Flow_MemAlloc(sizeof(char) * (strlen((const char*) path)+1) );
        if (_path)
        {
            // Design note: Need to make a copy of path ('_path') as Microchip's implementation
            // of strtok() appears to try to modify the string it's working on
            memset((void*)_path, 0, (sizeof(char) * (strlen((const char*) path)+1) ));
            memcpy((void*) _path, (void*) path, sizeof(char) * strlen((const char*) path) );

            // Check for path separator '/' character
            if (strchr((const char*) _path, '/') == NULL)
            {
                if (strcmp((const char*) _node->Name, (const char*) _path) != 0)
                    currentNode = NULL;
            }
            else
            {
                // Tokenise path and ensure first pathElement matches
                char *pathElement = strtok((char*) _path, (const char*) "/");
                if (pathElement)
                {
                    if (strcmp((const char*) currentNode->Name, (const char*) pathElement) == 0)
                    {
                        bool childFound = false;
                        bool pathError = false;
                        do
                        {
                            // Then, get next path-token and find a match for a child node's name
                            pathElement = strtok(0, "/");
                            if (pathElement)
                            {
                                childFound = false;
                                uint32_t childIndex = 0;
                                for (childIndex = 0; childIndex < currentNode->ChildCount; childIndex++)
                                {
                                    // For each token, check if a child's node name matches the next token in the path
                                    _treeNode thisChild = (_treeNode) currentNode->Children[childIndex];
                                    if (strcmp((const char*) thisChild->Name, pathElement) == 0)
                                    {
                                        currentNode = thisChild;
                                        childFound = true;
                                        break;
                                    }
                                }

                                if (!childFound)
                                {
                                    currentNode = NULL;
                                    pathError = true;
                                }
                            }
                        } while(pathElement && !pathError);
                        if (pathError)
                            currentNode = NULL;
                    }
                }
            }
            Flow_MemFree((void **) &_path);
        }
        else
        {
        }
    }
    return (TreeNode) currentNode;
}