void iot_subscribe_callback_handler(AWS_IoT_Client *pClient, char *topicName, uint16_t topicNameLen,
									IoT_Publish_Message_Params *params, void *pData) {
	IOT_UNUSED(pData);
	IOT_UNUSED(pClient);
	IOT_INFO("Subscribe callback");
	IOT_INFO("%.*s\t%.*s", topicNameLen, topicName, (int) params->payloadLen, params->payload);
}
IoT_Error_t iot_tls_write(Network *pNetwork, unsigned char *pMsg, size_t len, Timer *timer, size_t *written_len) {
    size_t i = 0;
    uint8_t firstByte, secondByte;
    uint16_t topicNameLen;
    IOT_UNUSED(pNetwork);
    IOT_UNUSED(timer);

    for(i = 0; (i < len) && left_ms(timer) > 0; i++) {
        TxBuffer.pBuffer[i] = pMsg[i];
    }
    TxBuffer.len = len;
    *written_len = len;

    /* Save last two subscribed topics */
    if((TxBuffer.pBuffer[0] == 0x82 ? true : false)) {
        snprintf(SecondLastSubscribeMessage, lastSubscribeMsgLen, "%s", LastSubscribeMessage);
        secondLastSubscribeMsgLen = lastSubscribeMsgLen;

        firstByte = (uint8_t)(TxBuffer.pBuffer[4]);
        secondByte = (uint8_t)(TxBuffer.pBuffer[5]);
        topicNameLen = (uint16_t) (secondByte + (256 * firstByte));

        snprintf(LastSubscribeMessage, topicNameLen + 1u, "%s", &(TxBuffer.pBuffer[6])); // Added one for null character
        lastSubscribeMsgLen = topicNameLen + 1u;
    }

    return SUCCESS;
}
示例#3
0
void windowActuate_Callback(const char *pJsonString, uint32_t JsonStringDataLen, jsonStruct_t *pContext) {
	IOT_UNUSED(pJsonString);
	IOT_UNUSED(JsonStringDataLen);

	if(pContext != NULL) {
		IOT_INFO("Delta - Window state changed to %d", *(bool *) (pContext->pData));
	}
}
static void AckStatusCallback(AWS_IoT_Client *pClient, char *topicName, uint16_t topicNameLen,
							  IoT_Publish_Message_Params *params, void *pData) {
	int32_t tokenCount;
	uint8_t i;
	void *pJsonHandler = NULL;
	char temporaryClientToken[MAX_SIZE_CLIENT_TOKEN_CLIENT_SEQUENCE];

	IOT_UNUSED(pClient);
	IOT_UNUSED(topicNameLen);
	IOT_UNUSED(pData);

	if(params->payloadLen > SHADOW_MAX_SIZE_OF_RX_BUFFER) {
		IOT_WARN("Payload larger than RX Buffer");
		return;
	}

	memcpy(shadowRxBuf, params->payload, params->payloadLen);
	shadowRxBuf[params->payloadLen] = '\0';    // jsmn_parse relies on a string

	if(!isJsonValidAndParse(shadowRxBuf, pJsonHandler, &tokenCount)) {
		IOT_WARN("Received JSON is not valid");
		return;
	}

	if(isAckForMyThingName(topicName)) {
		uint32_t tempVersionNumber = 0;
		if(extractVersionNumber(shadowRxBuf, pJsonHandler, tokenCount, &tempVersionNumber)) {
			if(tempVersionNumber > shadowJsonVersionNum) {
				shadowJsonVersionNum = tempVersionNumber;
			}
		}
	}

	if(extractClientToken(shadowRxBuf, temporaryClientToken)) {
		for(i = 0; i < MAX_ACKS_TO_COMEIN_AT_ANY_GIVEN_TIME; i++) {
			if(!AckWaitList[i].isFree) {
				if(strcmp(AckWaitList[i].clientTokenID, temporaryClientToken) == 0) {
					Shadow_Ack_Status_t status;
					if(strstr(topicName, "accepted") != NULL) {
						status = SHADOW_ACK_ACCEPTED;
					} else if(strstr(topicName, "rejected") != NULL) {
						status = SHADOW_ACK_REJECTED;
					} else {
						continue;
					}
					/* status == SHADOW_ACK_ACCEPTED || status == SHADOW_ACK_REJECTED */
					if(AckWaitList[i].callback != NULL) {
						AckWaitList[i].callback(AckWaitList[i].thingName, AckWaitList[i].action, status,
												shadowRxBuf, AckWaitList[i].pCallbackContext);
					}
					unsubscribeFromAcceptedAndRejected(i);
					AckWaitList[i].isFree = true;
					return;
				}
			}
		}
	}
}
示例#5
0
int privilege_check(launcher_t *l, const char *label, uid_t uid,
                    const char *privilege)
{
    IOT_UNUSED(l);
    IOT_UNUSED(label);
    IOT_UNUSED(uid);
    IOT_UNUSED(privilege);

    return 1;
}
static void shadow_delta_callback(AWS_IoT_Client *pClient, char *topicName,
								  uint16_t topicNameLen, IoT_Publish_Message_Params *params, void *pData) {
	int32_t tokenCount;
	uint32_t i = 0;
	void *pJsonHandler = NULL;
	int32_t DataPosition;
	uint32_t dataLength;
	uint32_t tempVersionNumber = 0;

	FUNC_ENTRY;

	IOT_UNUSED(pClient);
	IOT_UNUSED(topicName);
	IOT_UNUSED(topicNameLen);
	IOT_UNUSED(pData);

	if(params->payloadLen > SHADOW_MAX_SIZE_OF_RX_BUFFER) {
		IOT_WARN("Payload larger than RX Buffer");
		return;
	}

	memcpy(shadowRxBuf, params->payload, params->payloadLen);
	shadowRxBuf[params->payloadLen] = '\0';    // jsmn_parse relies on a string

	if(!isJsonValidAndParse(shadowRxBuf, pJsonHandler, &tokenCount)) {
		IOT_WARN("Received JSON is not valid");
		return;
	}

	if(shadowDiscardOldDeltaFlag) {
		if(extractVersionNumber(shadowRxBuf, pJsonHandler, tokenCount, &tempVersionNumber)) {
			if(tempVersionNumber > shadowJsonVersionNum) {
				shadowJsonVersionNum = tempVersionNumber;
			} else {
				IOT_WARN("Old Delta Message received - Ignoring rx: %d local: %d", tempVersionNumber,
						 shadowJsonVersionNum);
				return;
			}
		}
	}

	for(i = 0; i < tokenTableIndex; i++) {
		if(!tokenTable[i].isFree) {
			if(isJsonKeyMatchingAndUpdateValue(shadowRxBuf, pJsonHandler, tokenCount,
											   (jsonStruct_t *) tokenTable[i].pStruct, &dataLength, &DataPosition)) {
				if(tokenTable[i].callback != NULL) {
					tokenTable[i].callback(shadowRxBuf + DataPosition, dataLength,
										   (jsonStruct_t *) tokenTable[i].pStruct);
				}
			}
		}
	}
}
void ShadowUpdateStatusCallback(const char *pThingName, ShadowActions_t action, Shadow_Ack_Status_t status,const char *pReceivedJsonDocument, void *pContextData) {
	IOT_UNUSED(pThingName);
	IOT_UNUSED(action);
	IOT_UNUSED(pReceivedJsonDocument);
	IOT_UNUSED(pContextData);

	if (SHADOW_ACK_TIMEOUT == status) {
		IOT_INFO("Update Timeout--");
	} else if (SHADOW_ACK_REJECTED == status) {
		IOT_INFO("Update RejectedXX");
	} else if (SHADOW_ACK_ACCEPTED == status) {
		IOT_INFO("Update Accepted!!!");
	}
}
static void iot_tests_unit_acr_subscribe_callback_handler(AWS_IoT_Client *pClient, char *topicName,
														  uint16_t topicNameLen,
														  IoT_Publish_Message_Params *params, void *pData) {
	char *tmp = params->payload;
	unsigned int i;

	IOT_UNUSED(pClient);
	IOT_UNUSED(topicName);
	IOT_UNUSED(topicNameLen);
	IOT_UNUSED(pData);

	for(i = 0; i < params->payloadLen; i++) {
		CallbackMsgString[i] = tmp[i];
	}
}
IoT_Error_t aws_iot_mqtt_client_unlock_mutex(AWS_IoT_Client *pClient, IoT_Mutex_t *pMutex) {
	if(NULL == pClient || NULL == pMutex) {
		return NULL_VALUE_ERROR;
	}
	IOT_UNUSED(pClient);
	return aws_iot_thread_mutex_unlock(pMutex);
}
IoT_Error_t iot_tls_connect(Network *pNetwork, TLSConnectParams *params) {
    IOT_UNUSED(pNetwork);

    if(NULL != params) {
        _iot_tls_set_connect_params(pNetwork, params->pRootCALocation, params->pDeviceCertLocation,
                                    params->pDevicePrivateKeyLocation, params->pDestinationURL, params->DestinationPort,
                                    params->timeout_ms, params->ServerVerificationFlag);
    }

    if(NULL != invalidEndpointFilter && 0 == strcmp(invalidEndpointFilter, pNetwork->tlsConnectParams.pDestinationURL)) {
        return NETWORK_ERR_NET_UNKNOWN_HOST;
    }

    if(invalidPortFilter == pNetwork->tlsConnectParams.DestinationPort) {
        return NETWORK_ERR_NET_CONNECT_FAILED;
    }

    if(NULL != invalidRootCAPathFilter && 0 == strcmp(invalidRootCAPathFilter, pNetwork->tlsConnectParams.pRootCALocation)) {
        return NETWORK_ERR_NET_CONNECT_FAILED;
    }

    if(NULL != invalidCertPathFilter && 0 == strcmp(invalidCertPathFilter, pNetwork->tlsConnectParams.pDeviceCertLocation)) {
        return NETWORK_ERR_NET_CONNECT_FAILED;
    }

    if(NULL != invalidPrivKeyPathFilter && 0 == strcmp(invalidPrivKeyPathFilter, pNetwork->tlsConnectParams.pDevicePrivateKeyLocation)) {
        return NETWORK_ERR_NET_CONNECT_FAILED;
    }
    return SUCCESS;
}
示例#11
0
void ShadowUpdateStatusCallback(const char *pThingName, ShadowActions_t action, Shadow_Ack_Status_t status,
                                const char *pReceivedJsonDocument, void *pContextData) {
    IOT_UNUSED(pThingName);
    IOT_UNUSED(action);
    IOT_UNUSED(pReceivedJsonDocument);
    IOT_UNUSED(pContextData);

    shadowUpdateInProgress = false;

    if(SHADOW_ACK_TIMEOUT == status) {
        ESP_LOGE(TAG, "Update timed out");
    } else if(SHADOW_ACK_REJECTED == status) {
        ESP_LOGE(TAG, "Update rejected");
    } else if(SHADOW_ACK_ACCEPTED == status) {
        ESP_LOGI(TAG, "Update accepted");
    }
}
示例#12
0
void iot_subscribe_callback_handler(AWS_IoT_Client *pClient, char *topicName, uint16_t topicNameLen,
									IoT_Publish_Message_Params *params, void *pData) {
	IOT_UNUSED(pData);
	IOT_UNUSED(pClient);
	IOT_INFO("Message: %.*s\t%.*s", topicNameLen, topicName, (int) params->payloadLen, (char*)params->payload);

	char* msg = (char*)(malloc((int) params->payloadLen) + 1);
	strncpy(msg, (char*) params->payload, (int) params->payloadLen);
	msg[(int) params->payloadLen] = '\0';


	if (findCommand(msg)) {
		handleCommand();
	} else {
		publishRobotState();
		publishMessage("Undefined command");
	}
}
示例#13
0
static void del_defer(void *glue_data, void *id)
{
    dfr_t *d = (dfr_t *)id;

    IOT_UNUSED(glue_data);

    uv_timer_stop(&d->uv_tmr);
    iot_free(d);
}
示例#14
0
static void del_timer(void *glue_data, void *id)
{
    tmr_t *t = (tmr_t *)id;

    IOT_UNUSED(glue_data);

    uv_timer_stop(&t->uv_tmr);
    iot_free(t);
}
示例#15
0
static void del_io(void *glue_data, void *id)
{
    io_t *io = (io_t *)id;

    IOT_UNUSED(glue_data);

    uv_poll_stop(&io->uv_poll);
    iot_free(io);
}
void DeltaCallback(const char *pJsonValueBuffer, uint32_t valueLength, jsonStruct_t *pJsonStruct_t) {
	IOT_UNUSED(pJsonStruct_t);

	IOT_DEBUG("Received Delta message %.*s", valueLength, pJsonValueBuffer);

	if (buildJSONForReported(stringToEchoDelta, SHADOW_MAX_SIZE_OF_RX_BUFFER, pJsonValueBuffer, valueLength)) {
		messageArrivedOnDelta = true;
	}
}
static void iot_tests_unit_yield_test_subscribe_callback_handler(AWS_IoT_Client *pClient, char *topicName,
																 uint16_t topicNameLen,
																 IoT_Publish_Message_Params *params, void *pData) {
	char *tmp = params->payload;
	unsigned int i;
	IoT_Error_t rc = SUCCESS;

	IOT_UNUSED(pClient);
	IOT_UNUSED(topicName);
	IOT_UNUSED(topicNameLen);
	IOT_UNUSED(pData);

	rc = aws_iot_mqtt_yield(pClient, 1000);
	CHECK_EQUAL_C_INT(MQTT_CLIENT_NOT_IDLE_ERROR, rc);

	for(i = 0; i < params->payloadLen; i++) {
		CallbackMsgString[i] = tmp[i];
	}
}
IoT_Error_t iot_tls_read(Network *pNetwork, unsigned char *pMsg, size_t len, Timer *pTimer, size_t *read_len) {
    IOT_UNUSED(pNetwork);
    IOT_UNUSED(pTimer);

    if(RxIndex > TLSMaxBufferSize - 1) {
        RxIndex = TLSMaxBufferSize - 1;
    }

    if(RxBuffer.len <= RxIndex || !isTimerExpired(RxBuffer.expiry_time)) {
        return NETWORK_SSL_NOTHING_TO_READ;
    }

    if((false == RxBuffer.NoMsgFlag) && (RxIndex < RxBuffer.len)) {
        memcpy(pMsg, &(RxBuffer.pBuffer[RxIndex]), len);
        RxIndex += len;
        *read_len = len;
    }

    return SUCCESS;
}
示例#19
0
static void timer_cb(uv_timer_t *handle
#if UV_VERSION_MAJOR < 1
                     , int status
#endif
                     )
{
    tmr_t *t = (tmr_t *)handle->data;

#if UV_VERSION_MAJOR < 1
    IOT_UNUSED(status);
#endif

    t->cb(t->glue_data, t, t->user_data);
}
bool extractVersionNumber(const char *pJsonDocument, void *pJsonHandler, int32_t tokenCount, uint32_t *pVersionNumber) {
	int32_t i;
	IoT_Error_t ret_val = AWS_SUCCESS;

	IOT_UNUSED(pJsonHandler);

	for(i = 1; i < tokenCount; i++) {
		if(jsoneq(pJsonDocument, &(jsonTokenStruct[i]), SHADOW_VERSION_STRING) == 0) {
			ret_val = parseUnsignedInteger32Value(pVersionNumber, pJsonDocument, &jsonTokenStruct[i + 1]);
			if(ret_val == AWS_SUCCESS) {
				return true;
			}
		}
	}
	return false;
}
示例#21
0
static void defer_cb(uv_timer_t *handle
#if UV_VERSION_MAJOR < 1
                     , int status
#endif
                     )
{
    dfr_t *d = (dfr_t *)handle->data;

#if UV_VERSION_MAJOR < 1
    IOT_UNUSED(status);
#endif

    d->cb(d->glue_data, d, d->user_data);

    if (d->enabled)
        uv_timer_again(&d->uv_tmr);
}
示例#22
0
void disconnectCallbackHandler(AWS_IoT_Client *pClient, void *data) {
	IOT_WARN("MQTT Disconnect");
	IoT_Error_t rc = FAILURE;

	if (NULL == pClient) {
		return;
	}

	IOT_UNUSED(data);

	if (aws_iot_is_autoreconnect_enabled(pClient)) {
		IOT_INFO("Auto Reconnect is enabled, Reconnecting attempt will start now");
	} else {
		IOT_WARN("Auto Reconnect not enabled. Starting manual reconnect...");
		rc = aws_iot_mqtt_attempt_reconnect(pClient);
		if (NETWORK_RECONNECTED == rc) {
			IOT_WARN("Manual Reconnect Successful");
		} else {
			IOT_WARN("Manual Reconnect Failed - %d", rc);
		}
	}
}
IoT_Error_t iot_tls_destroy(Network *pNetwork) {
    IOT_UNUSED(pNetwork);
    return SUCCESS;
}
IoT_Error_t iot_tls_is_connected(Network *pNetwork) {
    IOT_UNUSED(pNetwork);

    /* Use this to add implementation which can check for physical layer disconnect */
    return NETWORK_PHYSICAL_LAYER_CONNECTED;
}
void iot_tests_unit_disconnect_handler(AWS_IoT_Client *pClient, void *disconParam) {
	IOT_UNUSED(pClient);
	IOT_UNUSED(disconParam);
	dcHandlerInvoked = true;
}
示例#26
0
void disconnectTestHandler(AWS_IoT_Client *pClient, void *disconHandlerParam) {
	IOT_UNUSED(pClient);
	IOT_UNUSED(disconHandlerParam);

	handlerInvoked = true;
}
IoT_Error_t iot_tls_disconnect(Network *pNetwork) {
    IOT_UNUSED(pNetwork);
    return SUCCESS;
}