//-----------------------------------------------------------------------------
AJ_Status AJ_Net_Send(AJ_IOBuffer* buf)
{
uint32_t ret;
uint32_t tx = AJ_IO_BUF_AVAIL(buf);
printf("AJ_Net_Send(buf=0x%p)\n", buf);
// printf("tcp_client_socket=%d", tcp_client_socket);
if (tx > 0)
{
// ret = g_client.write(buf->readPtr, tx);
send(tcp_client_socket, buf->readPtr, tx, 0);
// while(tcp_tx_ready==0) m2m_wifi_handle_events(NULL);
/* if (ret != 0)
{
//AJ_ErrPrintf(("AJ_Net_Send(): send() failed. error=%d, status=AJ_ERR_WRITE\n", g_client.getWriteError()));
return AJ_ERR_WRITE;
}*/
buf->readPtr += tcp_tx_ready;
tcp_tx_ready=0;
}
// if (AJ_IO_BUF_AVAIL(buf) == 0)
// {
AJ_IO_BUF_RESET(buf);
// }
//printf("AJ_Net_Send end\n");
return AJ_OK;
}
static AJ_Status AJ_Net_Send(AJ_IOBuffer* buf)
{
DWORD ret;
DWORD tx = AJ_IO_BUF_AVAIL(buf);
AJ_InfoPrintf(("AJ_Net_Send(buf=0x%p)\n", buf));
assert(buf->direction == AJ_IO_BUF_TX);
if (tx > 0) {
NetContext* ctx = (NetContext*) buf->context;
WSAOVERLAPPED ov;
DWORD flags = 0;
WSABUF wsbuf;
memset(&ov, 0, sizeof(ov));
ov.hEvent = sendEvent;
wsbuf.len = tx;
wsbuf.buf = buf->readPtr;
ret = WSASend(ctx->tcpSock, &wsbuf, 1, NULL, flags, &ov, NULL);
if (!WSAGetOverlappedResult(ctx->tcpSock, &ov, &tx, TRUE, &flags)) {
AJ_ErrPrintf(("AJ_Net_Send(): send() failed. WSAGetLastError()=0x%x, status=AJ_ERR_WRITE\n", WSAGetLastError()));
return AJ_ERR_WRITE;
}
buf->readPtr += tx;
}
if (AJ_IO_BUF_AVAIL(buf) == 0) {
AJ_IO_BUF_RESET(buf);
}
AJ_InfoPrintf(("AJ_Net_Send(): status=AJ_OK\n"));
return AJ_OK;
}
AJ_Status AJ_Net_SendTo(AJ_IOBuffer* buf)
{
int ret;
uint32_t tx = AJ_IO_BUF_AVAIL(buf);
//AJ_InfoPrintf(("AJ_Net_SendTo(buf=0x%p)\n", buf));
if (tx > 0)
{
ret = sendto(rx_socket, buf->readPtr, tx, 0, (struct sockaddr *)&addr, sizeof(addr));
m2m_wifi_handle_events(NULL);
//AJ_InfoPrintf(("AJ_Net_SendTo(): SendTo write %d\n", ret));
if (sock_tx_state != 1)
{
//AJ_ErrPrintf(("AJ_Net_Sendto(): no bytes. status=AJ_ERR_WRITE\n"));
return AJ_ERR_WRITE;
}
buf->readPtr += ret;
}
AJ_IO_BUF_RESET(buf);
//AJ_InfoPrintf(("AJ_Net_SendTo(): status=AJ_OK\n"));
return AJ_OK;
}
AJ_Status AJ_CloseMsg(AJ_Message* msg)
{
AJ_Status status = AJ_OK;
/*
* This function is idempotent
*/
if (msg->bus) {
AJ_IOBuffer* ioBuf = &msg->bus->sock.rx;
/*
* Skip any unconsumed bytes
*/
while (msg->bodyBytes) {
uint16_t sz = AJ_IO_BUF_AVAIL(ioBuf);
sz = min(sz, msg->bodyBytes);
if (!sz) {
AJ_IO_BUF_RESET(ioBuf);
sz = min(msg->bodyBytes, ioBuf->bufSize);
}
status = LoadBytes(ioBuf, sz, 0);
if (status != AJ_OK) {
break;
}
msg->bodyBytes -= sz;
ioBuf->readPtr += sz;
}
memset(msg, 0, sizeof(AJ_Message));
#ifndef NDEBUG
currentMsg = NULL;
#endif
}
return status;
}
static AJ_Status TxFunc(AJ_IOBuffer* buf)
{
size_t tx = AJ_IO_BUF_AVAIL(buf);;
if ((wireBytes + tx) > sizeof(wireBuffer)) {
return AJ_ERR_WRITE;
} else {
memcpy(wireBuffer + wireBytes, buf->bufStart, tx);
AJ_IO_BUF_RESET(buf);
wireBytes += tx;
return AJ_OK;
}
}
AJ_Status AJ_Net_SendTo(AJ_IOBuffer* buf)
{
int ret;
uint32_t tx = AJ_IO_BUF_AVAIL(buf);
AJ_InfoPrintf(("AJ_Net_SendTo(buf=0x%p)\n", buf));
if (tx > 0) {
// send to subnet-directed broadcast address
#ifdef WIFI_UDP_WORKING
IPAddress subnet = WiFi.subnetMask();
IPAddress localIp = WiFi.localIP();
#else
IPAddress subnet = Ethernet.subnetMask();
IPAddress localIp = Ethernet.localIP();
#endif
uint32_t directedBcastAddr = (uint32_t(subnet) & uint32_t(localIp)) | (~uint32_t(subnet));
IPAddress a(directedBcastAddr);
ret = g_clientUDP.beginPacket(IPAddress(directedBcastAddr), AJ_UDP_PORT);
AJ_InfoPrintf(("AJ_Net_SendTo(): beginPacket to %d.%d.%d.%d, result = %d\n", a[0], a[1], a[2], a[3], ret));
if (ret == 0) {
AJ_InfoPrintf(("AJ_Net_SendTo(): no sender\n"));
}
ret = g_clientUDP.write(buf->readPtr, tx);
AJ_InfoPrintf(("AJ_Net_SendTo(): SendTo write %d\n", ret));
if (ret == 0) {
AJ_ErrPrintf(("AJ_Net_Sendto(): no bytes. status=AJ_ERR_WRITE\n"));
return AJ_ERR_WRITE;
}
buf->readPtr += ret;
ret = g_clientUDP.endPacket();
if (ret == 0) {
AJ_ErrPrintf(("AJ_Net_Sendto(): endPacket() error. status=AJ_ERR_WRITE\n"));
return AJ_ERR_WRITE;
}
}
AJ_IO_BUF_RESET(buf);
AJ_InfoPrintf(("AJ_Net_SendTo(): status=AJ_OK\n"));
return AJ_OK;
}
AJ_Status AJ_Net_Send(AJ_IOBuffer* buf)
{
uint32_t ret;
uint32_t tx = AJ_IO_BUF_AVAIL(buf);
AJ_InfoPrintf(("AJ_Net_Send(buf=0x%p)\n", buf));
if (tx > 0) {
ret = g_client.write(buf->readPtr, tx);
if (ret == 0) {
AJ_ErrPrintf(("AJ_Net_Send(): send() failed. error=%d, status=AJ_ERR_WRITE\n", g_client.getWriteError()));
return AJ_ERR_WRITE;
}
buf->readPtr += ret;
}
if (AJ_IO_BUF_AVAIL(buf) == 0) {
AJ_IO_BUF_RESET(buf);
}
AJ_InfoPrintf(("AJ_Net_Send(): status=AJ_OK\n"));
return AJ_OK;
}
AJ_Status AJ_ARDP_UDP_Connect(AJ_BusAttachment* bus, void* context, const AJ_Service* service, AJ_NetSocket* netSock)
{
AJ_Message hello;
AJ_GUID localGuid;
char guid_buf[33];
AJ_Status status;
AJ_Message helloResponse;
AJ_GetLocalGUID(&localGuid);
AJ_GUID_ToString(&localGuid, guid_buf, sizeof(guid_buf));
AJ_MarshalMethodCall(bus, &hello, AJ_METHOD_BUS_SIMPLE_HELLO, AJ_BusDestination, 0, AJ_FLAG_ALLOW_REMOTE_MSG, AJ_UDP_CONNECT_TIMEOUT);
AJ_MarshalArgs(&hello, "su", guid_buf, 10);
hello.hdr->bodyLen = hello.bodyBytes;
status = AJ_ARDP_Connect(bus->sock.tx.readPtr, AJ_IO_BUF_AVAIL(&bus->sock.tx), context, netSock);
if (status != AJ_OK) {
return status;
}
status = AJ_UnmarshalMsg(bus, &helloResponse, AJ_UDP_CONNECT_TIMEOUT);
if (status == AJ_OK && helloResponse.msgId == AJ_REPLY_ID(AJ_METHOD_BUS_SIMPLE_HELLO)) {
if (helloResponse.hdr->msgType == AJ_MSG_ERROR) {
status = AJ_ERR_CONNECT;
} else {
AJ_Arg uniqueName, protoVersion;
AJ_UnmarshalArg(&helloResponse, &uniqueName);
AJ_SkipArg(&helloResponse);
AJ_UnmarshalArg(&helloResponse, &protoVersion);
/**
* The two most-significant bits are reserved for the nameType,
* which we don't currently care about in the thin client
*/
routingProtoVersion = (uint8_t) ((*protoVersion.val.v_uint32) & 0x3FFFFFFF);
if (uniqueName.len >= (sizeof(bus->uniqueName) - 1)) {
AJ_ErrPrintf(("AJ_ARDP_Connect(): Blacklisting routing node, uniqueName.len = %d\n", uniqueName.len));
AddRoutingNodeToBlacklist(service, AJ_ADDR_UDP4);
status = AJ_ERR_ACCESS_ROUTING_NODE;
} else {
memcpy(bus->uniqueName, uniqueName.val.v_string, uniqueName.len);
bus->uniqueName[uniqueName.len] = '\0';
}
AJ_InfoPrintf(("Received name: %s and version %u\n", bus->uniqueName, routingProtoVersion));
if (routingProtoVersion < AJ_GetMinProtoVersion()) {
AJ_InfoPrintf(("AJ_ARDP_Connect(): Blacklisting routing node, found %u but require >= %u\n",
routingProtoVersion, AJ_GetMinProtoVersion()));
// add to blacklist because of invalid version
AddRoutingNodeToBlacklist(service, AJ_ADDR_UDP4);
status = AJ_ERR_OLD_VERSION;
}
}
} else {
status = AJ_ERR_CONNECT;
}
AJ_CloseMsg(&helloResponse);
// reset the transmit queue!
AJ_IO_BUF_RESET(&bus->sock.tx);
if (status == AJ_OK) {
// ARDP does not require additional authentication
bus->isAuthenticated = TRUE;
// ARDP does not require ProbeReq/ProbeAck
bus->isProbeRequired = FALSE;
}
return status;
}
static AJ_Status AJ_Net_SendTo(AJ_IOBuffer* buf)
{
DWORD ret;
DWORD tx = AJ_IO_BUF_AVAIL(buf);
int numWrites = 0;
AJ_InfoPrintf(("AJ_Net_SendTo(buf=0x%p)\n", buf));
assert(buf->direction == AJ_IO_BUF_TX);
assert(NumMcastSocks > 0);
if (tx > 0) {
size_t i;
// our router (hopefully) lives on one of the networks but we don't know which one.
// send discovery requests to all of them.
for (i = 0; i < NumMcastSocks; ++i) {
SOCKET sock = McastSocks[i].sock;
int family = McastSocks[i].family;
if ((buf->flags & AJ_IO_BUF_AJ) && !McastSocks[i].is_mdns) {
// try sending IPv6 multicast
if (family == AF_INET6) {
struct sockaddr_in6 sin6;
memset(&sin6, 0, sizeof(struct sockaddr_in6));
sin6.sin6_family = AF_INET6;
sin6.sin6_port = htons(AJ_UDP_PORT);
inet_pton(AF_INET6, AJ_IPV6_MULTICAST_GROUP, &sin6.sin6_addr);
ret = sendto(sock, buf->readPtr, tx, 0, (struct sockaddr*) &sin6, sizeof(struct sockaddr_in6));
if (ret == SOCKET_ERROR) {
AJ_ErrPrintf(("AJ_Net_SendTo(): sendto() failed (IPV6). WSAGetLastError()=0x%x\n", WSAGetLastError()));
} else {
++numWrites;
}
}
// try sending IPv4 multicast
if (family == AF_INET && McastSocks[i].has_mcast4) {
struct sockaddr_in sin;
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_port = htons(AJ_UDP_PORT);
inet_pton(AF_INET, AJ_IPV4_MULTICAST_GROUP, &sin.sin_addr);
ret = sendto(sock, buf->readPtr, tx, 0, (struct sockaddr*) &sin, sizeof(struct sockaddr_in));
if (ret == SOCKET_ERROR) {
AJ_ErrPrintf(("AJ_Net_SendTo(): sendto() failed (IPV4). WSAGetLastError()=0x%x\n", WSAGetLastError()));
} else {
++numWrites;
}
}
// try sending IPv4 subnet broadcast
if (family == AF_INET && McastSocks[i].v4_bcast.s_addr) {
struct sockaddr_in bsin;
memset(&bsin, 0, sizeof(bsin));
bsin.sin_family = AF_INET;
bsin.sin_port = htons(AJ_UDP_PORT);
bsin.sin_addr.s_addr = McastSocks[i].v4_bcast.s_addr;
ret = sendto(sock, buf->readPtr, tx, 0, (struct sockaddr*) &bsin, sizeof(struct sockaddr_in));
if (ret == SOCKET_ERROR) {
AJ_ErrPrintf(("AJ_Net_SendTo(): sendto() failed (bcast). WSAGetLastError()=0x%x\n", WSAGetLastError()));
} else {
++numWrites;
}
}
}
if ((buf->flags & AJ_IO_BUF_MDNS) && McastSocks[i].is_mdns) {
// Update the packet with receiver info for this socket
if (RewriteSenderInfo(buf, ntohl(McastSocks[i].v4_addr.s_addr), McastSocks[i].recv_port) != AJ_OK) {
AJ_WarnPrintf(("AJ_Net_SendTo(): RewriteSenderInfo failed.\n"));
continue;
}
tx = AJ_IO_BUF_AVAIL(buf);
// try sending IPv4 multicast
if (family == AF_INET && McastSocks[i].has_mcast4) {
struct sockaddr_in sin;
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_port = htons(MDNS_UDP_PORT);
inet_pton(AF_INET, MDNS_IPV4_MULTICAST_GROUP, &sin.sin_addr);
ret = sendto(sock, buf->readPtr, tx, 0, (struct sockaddr*) &sin, sizeof(struct sockaddr_in));
if (ret == SOCKET_ERROR) {
AJ_ErrPrintf(("AJ_Net_SendTo(): sendto() multicast failed (IPV4). WSAGetLastError()=0x%x\n", WSAGetLastError()));
} else {
++numWrites;
}
}
// try sending IPv4 subnet broadcast
if (family == AF_INET && McastSocks[i].v4_bcast.s_addr) {
struct sockaddr_in bsin;
memset(&bsin, 0, sizeof(bsin));
bsin.sin_family = AF_INET;
bsin.sin_port = htons(MDNS_UDP_PORT);
bsin.sin_addr.s_addr = McastSocks[i].v4_bcast.s_addr;
ret = sendto(sock, buf->readPtr, tx, 0, (struct sockaddr*) &bsin, sizeof(struct sockaddr_in));
if (ret == SOCKET_ERROR) {
AJ_ErrPrintf(("AJ_Net_SendTo(): sendto() broadcast failed. WSAGetLastError()=0x%x\n", WSAGetLastError()));
} else {
++numWrites;
}
}
// try sending IPv6 multicast
if (family == AF_INET6) {
struct sockaddr_in6 sin6;
memset(&sin6, 0, sizeof(struct sockaddr_in6));
sin6.sin6_family = AF_INET6;
sin6.sin6_port = htons(MDNS_UDP_PORT);
inet_pton(AF_INET6, MDNS_IPV6_MULTICAST_GROUP, &sin6.sin6_addr);
ret = sendto(sock, buf->readPtr, tx, 0, (struct sockaddr*) &sin6, sizeof(struct sockaddr_in6));
if (ret == SOCKET_ERROR) {
AJ_ErrPrintf(("AJ_Net_SendTo(): sendto() failed (IPV6). WSAGetLastError()=0x%x\n", WSAGetLastError()));
} else {
++numWrites;
}
}
}
}
if (numWrites == 0) {
AJ_ErrPrintf(("AJ_Net_SendTo(): Did not sendto() at least one socket. status=AJ_ERR_WRITE\n"));
return AJ_ERR_WRITE;
}
buf->readPtr += ret;
}
AJ_IO_BUF_RESET(buf);
AJ_InfoPrintf(("AJ_Net_SendTo(): status=AJ_OK\n"));
return AJ_OK;
}
static AJ_Status MarshalMsg(AJ_Message* msg, uint8_t msgType, uint32_t msgId, uint8_t flags)
{
AJ_Status status = AJ_OK;
AJ_IOBuffer* ioBuf = &msg->bus->sock.tx;
uint8_t fieldId;
uint8_t secure = FALSE;
/*
* Use the msgId to lookup information in the object and interface descriptions to
* initialize the message header fields.
*/
status = AJ_InitMessageFromMsgId(msg, msgId, msgType, &secure);
if (status != AJ_OK) {
return status;
}
AJ_IO_BUF_RESET(ioBuf);
msg->hdr = (AJ_MsgHeader*)ioBuf->bufStart;
memset(msg->hdr, 0, sizeof(AJ_MsgHeader));
ioBuf->writePtr += sizeof(AJ_MsgHeader);
msg->hdr->endianess = HOST_ENDIANESS;
msg->hdr->msgType = msgType;
msg->hdr->flags = flags;
if (secure) {
msg->hdr->flags |= AJ_FLAG_ENCRYPTED;
}
/*
* The wire-protocol calls this flag NO_AUTO_START we toggle the meaning in the API
* so the default flags value can be zero.
*/
msg->hdr->flags ^= AJ_FLAG_AUTO_START;
/*
* Serial number cannot be zero (wire-spec wierdness)
*/
do { msg->hdr->serialNum = msg->bus->serial++; } while (msg->bus->serial == 1);
/*
* Marshal the header fields
*/
for (fieldId = AJ_HDR_OBJ_PATH; fieldId <= AJ_HDR_SESSION_ID; ++fieldId) {
char typeId = TypeForHdr[fieldId];
char buf[4];
const char* fieldSig = &buf[2];
AJ_Arg hdrVal;
/*
* Skip field id's that are not currently used.
*/
if (typeId == AJ_ARG_INVALID) {
continue;
}
InitArg(&hdrVal, typeId, NULL);
switch (fieldId) {
case AJ_HDR_OBJ_PATH:
if ((msgType == AJ_MSG_METHOD_CALL) || (msgType == AJ_MSG_SIGNAL)) {
hdrVal.val.v_objPath = msg->objPath;
}
break;
case AJ_HDR_INTERFACE:
hdrVal.val.v_string = msg->iface;
break;
case AJ_HDR_MEMBER:
if (msgType != AJ_MSG_ERROR) {
int32_t len = AJ_StringFindFirstOf(msg->member, " ");
hdrVal.val.v_string = msg->member;
hdrVal.len = (len >= 0) ? len : 0;
}
break;
case AJ_HDR_ERROR_NAME:
if (msgType == AJ_MSG_ERROR) {
hdrVal.val.v_string = msg->error;
}
break;
case AJ_HDR_REPLY_SERIAL:
if ((msgType == AJ_MSG_METHOD_RET) || (msgType == AJ_MSG_ERROR)) {
hdrVal.val.v_uint32 = &msg->replySerial;
}
break;
case AJ_HDR_DESTINATION:
hdrVal.val.v_string = msg->destination;
break;
case AJ_HDR_SENDER:
hdrVal.val.v_string = AJ_GetUniqueName(msg->bus);
break;
case AJ_HDR_SIGNATURE:
hdrVal.val.v_signature = msg->signature;
break;
case AJ_HDR_TIMESTAMP:
if (msg->ttl) {
AJ_Time timer;
timer.seconds = 0;
timer.milliseconds = 0;
msg->timestamp = AJ_GetElapsedTime(&timer, FALSE);
hdrVal.val.v_uint32 = &msg->timestamp;
}
break;
case AJ_HDR_TIME_TO_LIVE:
if (msg->ttl) {
hdrVal.val.v_uint32 = &msg->ttl;
}
break;
case AJ_HDR_SESSION_ID:
if (msg->sessionId) {
hdrVal.val.v_uint32 = &msg->sessionId;
}
break;
case AJ_HDR_HANDLES:
case AJ_HDR_COMPRESSION_TOKEN:
default:
continue;
}
/*
* Ignore empty fields.
*/
if (!hdrVal.val.v_data) {
continue;
}
/*
* Custom marshal the header field - signature is "(yv)" so starts off with STRUCT aligment.
*/
buf[0] = fieldId;
buf[1] = 1;
buf[2] = typeId;
buf[3] = 0;
WriteBytes(msg, buf, 4, PadForType(AJ_ARG_STRUCT, ioBuf));
/*
* Now marshal the field value
*/
Marshal(msg, &fieldSig, &hdrVal);
}
if (status == AJ_OK) {
/*
* Write the header length
*/
msg->hdr->headerLen = (uint32_t)((ioBuf->writePtr - ioBuf->bufStart) - sizeof(AJ_MsgHeader));
/*
* Header must be padded to an 8 byte boundary
*/
status = WritePad(msg, (8 - msg->hdr->headerLen) & 7);
}
return status;
}