//----------------------------------------------------------------------------- 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; }