extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
{
const otPanId panId = 0xdead;
otInstance * instance = NULL;
otMessage * message = NULL;
otError error = OT_ERROR_NONE;
otMessageSettings settings;
VerifyOrExit(size > 0);
FuzzerPlatformInit();
instance = otInstanceInitSingle();
otLinkSetPanId(instance, panId);
otIp6SetEnabled(instance, true);
otThreadSetEnabled(instance, true);
otThreadBecomeLeader(instance);
settings.mLinkSecurityEnabled = (data[0] & 0x1) != 0;
settings.mPriority = OT_MESSAGE_PRIORITY_NORMAL;
message = otIp6NewMessage(instance, &settings);
VerifyOrExit(message != NULL, error = OT_ERROR_NO_BUFS);
error = otMessageAppend(message, data + 1, static_cast<uint16_t>(size - 1));
SuccessOrExit(error);
error = otIp6Send(instance, message);
message = NULL;
exit:
if (message != NULL)
{
otMessageFree(message);
}
if (instance != NULL)
{
otInstanceFinalize(instance);
}
return 0;
}
otError UdpExample::ProcessSend(int argc, char *argv[])
{
otError error;
otMessageInfo messageInfo;
otMessage * message = NULL;
int curArg = 0;
memset(&messageInfo, 0, sizeof(messageInfo));
VerifyOrExit(argc == 1 || argc == 3, error = OT_ERROR_INVALID_ARGS);
if (argc == 3)
{
long value;
error = otIp6AddressFromString(argv[curArg++], &messageInfo.mPeerAddr);
SuccessOrExit(error);
error = Interpreter::ParseLong(argv[curArg++], value);
SuccessOrExit(error);
messageInfo.mPeerPort = static_cast<uint16_t>(value);
messageInfo.mInterfaceId = OT_NETIF_INTERFACE_ID_THREAD;
}
message = otUdpNewMessage(mInterpreter.mInstance, true);
VerifyOrExit(message != NULL, error = OT_ERROR_NO_BUFS);
error = otMessageAppend(message, argv[curArg], static_cast<uint16_t>(strlen(argv[curArg])));
SuccessOrExit(error);
error = otUdpSend(&mSocket, message, &messageInfo);
exit:
if (error != OT_ERROR_NONE && message != NULL)
{
otMessageFree(message);
}
return error;
}
otError Coap::ProcessRequest(int argc, char *argv[])
{
otError error = OT_ERROR_NONE;
otMessage *message = NULL;
otMessageInfo messageInfo;
otCoapHeader header;
uint16_t payloadLength = 0;
// Default parameters
char coapUri[kMaxUriLength] = "test";
otCoapType coapType = OT_COAP_TYPE_NON_CONFIRMABLE;
otCoapCode coapCode = OT_COAP_CODE_GET;
otIp6Address coapDestinationIp;
VerifyOrExit(argc > 0, error = OT_ERROR_INVALID_ARGS);
// CoAP-Code
if (strcmp(argv[0], "get") == 0)
{
coapCode = OT_COAP_CODE_GET;
}
else if (strcmp(argv[0], "post") == 0)
{
coapCode = OT_COAP_CODE_POST;
}
else if (strcmp(argv[0], "put") == 0)
{
coapCode = OT_COAP_CODE_PUT;
}
else if (strcmp(argv[0], "delete") == 0)
{
coapCode = OT_COAP_CODE_DELETE;
}
else
{
ExitNow(error = OT_ERROR_PARSE);
}
// Destination IPv6 address
if (argc > 1)
{
SuccessOrExit(error = otIp6AddressFromString(argv[1], &coapDestinationIp));
}
else
{
ExitNow(error = OT_ERROR_INVALID_ARGS);
}
// CoAP-URI
if (argc > 2)
{
strlcpy(coapUri, argv[2], kMaxUriLength);
}
else
{
ExitNow(error = OT_ERROR_INVALID_ARGS);
}
// CoAP-Type
if (argc > 3)
{
if (strcmp(argv[3], "con") == 0)
{
coapType = OT_COAP_TYPE_CONFIRMABLE;
}
}
otCoapHeaderInit(&header, coapType, coapCode);
otCoapHeaderGenerateToken(&header, ot::Coap::Header::kDefaultTokenLength);
SuccessOrExit(error = otCoapHeaderAppendUriPathOptions(&header, coapUri));
if (argc > 4)
{
payloadLength = static_cast<uint16_t>(strlen(argv[4]));
if (payloadLength > 0)
{
otCoapHeaderSetPayloadMarker(&header);
}
}
message = otCoapNewMessage(mInterpreter.mInstance, &header);
VerifyOrExit(message != NULL, error = OT_ERROR_NO_BUFS);
// Embed content into message if given
if (payloadLength > 0)
{
SuccessOrExit(error = otMessageAppend(message, argv[4], payloadLength));
}
memset(&messageInfo, 0, sizeof(messageInfo));
messageInfo.mPeerAddr = coapDestinationIp;
messageInfo.mPeerPort = OT_DEFAULT_COAP_PORT;
messageInfo.mInterfaceId = OT_NETIF_INTERFACE_ID_THREAD;
if ((coapType == OT_COAP_TYPE_CONFIRMABLE) || (coapCode == OT_COAP_CODE_GET))
{
error = otCoapSendRequest(mInterpreter.mInstance, message, &messageInfo, &Coap::HandleClientResponse, this);
}
else
{
error = otCoapSendRequest(mInterpreter.mInstance, message, &messageInfo, NULL, NULL);
}
mInterpreter.mServer->OutputFormat("Sending coap request: ");
exit:
if ((error != OT_ERROR_NONE) && (message != NULL))
{
otMessageFree(message);
}
return error;
}
void Coap::HandleServerResponse(otCoapHeader *aHeader, otMessage *aMessage, const otMessageInfo *aMessageInfo)
{
otError error = OT_ERROR_NONE;
otCoapHeader responseHeader;
otMessage *responseMessage;
otCoapCode responseCode = OT_COAP_CODE_EMPTY;
char responseContent = '0';
mInterpreter.mServer->OutputFormat("Received coap request from [%x:%x:%x:%x:%x:%x:%x:%x]: ",
HostSwap16(aMessageInfo->mSockAddr.mFields.m16[0]),
HostSwap16(aMessageInfo->mSockAddr.mFields.m16[1]),
HostSwap16(aMessageInfo->mSockAddr.mFields.m16[2]),
HostSwap16(aMessageInfo->mSockAddr.mFields.m16[3]),
HostSwap16(aMessageInfo->mSockAddr.mFields.m16[4]),
HostSwap16(aMessageInfo->mSockAddr.mFields.m16[5]),
HostSwap16(aMessageInfo->mSockAddr.mFields.m16[6]),
HostSwap16(aMessageInfo->mSockAddr.mFields.m16[7]));
switch (otCoapHeaderGetCode(aHeader))
{
case OT_COAP_CODE_GET:
mInterpreter.mServer->OutputFormat("GET");
break;
case OT_COAP_CODE_DELETE:
mInterpreter.mServer->OutputFormat("DELETE");
break;
case OT_COAP_CODE_PUT:
mInterpreter.mServer->OutputFormat("PUT");
break;
case OT_COAP_CODE_POST:
mInterpreter.mServer->OutputFormat("POST");
break;
default:
mInterpreter.mServer->OutputFormat("Undefined\r\n");
return;
}
PrintPayload(aMessage);
if ((otCoapHeaderGetType(aHeader) == OT_COAP_TYPE_CONFIRMABLE) || otCoapHeaderGetCode(aHeader) == OT_COAP_CODE_GET)
{
if (otCoapHeaderGetCode(aHeader) == OT_COAP_CODE_GET)
{
responseCode = OT_COAP_CODE_CONTENT;
}
else
{
responseCode = OT_COAP_CODE_VALID;
}
otCoapHeaderInit(&responseHeader, OT_COAP_TYPE_ACKNOWLEDGMENT, responseCode);
otCoapHeaderSetMessageId(&responseHeader, otCoapHeaderGetMessageId(aHeader));
otCoapHeaderSetToken(&responseHeader, otCoapHeaderGetToken(aHeader), otCoapHeaderGetTokenLength(aHeader));
if (otCoapHeaderGetCode(aHeader) == OT_COAP_CODE_GET)
{
otCoapHeaderSetPayloadMarker(&responseHeader);
}
responseMessage = otCoapNewMessage(mInterpreter.mInstance, &responseHeader);
VerifyOrExit(responseMessage != NULL, error = OT_ERROR_NO_BUFS);
if (otCoapHeaderGetCode(aHeader) == OT_COAP_CODE_GET)
{
SuccessOrExit(error = otMessageAppend(responseMessage, &responseContent, sizeof(responseContent)));
}
SuccessOrExit(error = otCoapSendResponse(mInterpreter.mInstance, responseMessage, aMessageInfo));
}
exit:
if (error != OT_ERROR_NONE && responseMessage != NULL)
{
mInterpreter.mServer->OutputFormat("Cannot send coap response message: Error %d: %s\r\n",
error, otThreadErrorToString(error));
otMessageFree(responseMessage);
}
else if (responseCode >= OT_COAP_CODE_RESPONSE_MIN)
{
mInterpreter.mServer->OutputFormat("coap response sent successfully!\r\n");
}
}