void UDPConnection::Update()
{
if (!sharedSocket)
{
unsigned recv = 0;
unsigned char buffer[UDPBufferSize];
sockaddr_in fromAddr;
while ((recv = mySocket->RecvFrom(buffer, UDPBufferSize, &fromAddr)) >= hsize)
{
RawPacket* data = new RawPacket(buffer, recv);
if (CheckAddress(fromAddr))
ProcessRawPacket(data);
else
; // silently drop
}
}
const unsigned curTime = SDL_GetTicks();
bool force = false; // should we force to send a packet?
if((dataRecv == 0) && lastSendTime < curTime-1000 && !unackedPackets.empty()){ //server hasnt responded so try to send the connection attempt again
SendRawPacket(unackedPackets[0].data,unackedPackets[0].length,0);
lastSendTime = curTime;
force = true;
}
if (lastSendTime<curTime-5000 && !(dataRecv == 0)) { //we havent sent anything for a while so send something to prevent timeout
force = true;
}
else if(lastSendTime<curTime-200 && !waitingPackets.empty()){ //we have at least one missing incomming packet lying around so send a packet to ensure the other side get a nak
force = true;
}
Flush(force);
}
size_t GetFileLineFromAddress(void* address, char* fileName, size_t size,
size_t* lineNumber, size_t* offsetBytes)
{
if (size) *fileName = 0;
if (lineNumber) *lineNumber = 0;
if (offsetBytes) *offsetBytes = 0;
{
char* sourceName;
IMAGEHLP_LINE line = { sizeof (line) };
GC_ULONG_PTR dwOffset = 0;
if (!SymGetLineFromAddr(GetSymHandle(), CheckAddress(address), &dwOffset,
&line)) {
return 0;
}
if (lineNumber) {
*lineNumber = line.LineNumber;
}
if (offsetBytes) {
*offsetBytes = dwOffset;
}
sourceName = line.FileName;
/* TODO: resolve relative filenames, found in 'source directories' */
/* registered with MSVC IDE. */
if (size) {
strncpy(fileName, sourceName, size)[size - 1] = 0;
}
return strlen(sourceName);
}
}
void DoCheck (const PolyWord pt)
{
if (pt == PolyWord::FromUnsigned(0)) return;
if (pt.IsTagged()) return;
CheckAddress(pt.AsStackAddr());
}
uint8_t Bowler_Server_Local(BowlerPacket * Packet){
Print_Level l = getPrintLevel();
//setPrintLevelNoPrint();
if (GetBowlerPacket_arch(Packet)){
//setLed(1,1,1);
if(Packet->use.head.RPC != _PNG){
println_I("Got:");printPacket(Packet,INFO_PRINT);
}
if ( (CheckAddress(MyMAC.v,Packet->use.head.MAC.v) == true) || ((CheckAddress((uint8_t *)Broadcast.v,(uint8_t *)Packet->use.head.MAC.v) == true) )) {
float start=getMs();
Process_Self_Packet(Packet);
if(getMs()-start>5){
println_E("Process too long: ");p_fl_E(getMs()-start);
}
for (i=0;i<6;i++){
Packet->use.head.MAC.v[i]=MyMAC.v[i];
}
SetCRC(Packet);
start=getMs();
PutBowlerPacket(Packet);
if(getMs()-start>5){
println_E("Return too long: ");p_fl_E(getMs()-start);
}
if(Packet->use.head.RPC != _PNG){
println_I("Response:");printPacket(Packet,INFO_PRINT);
}
}else{
//println_I("Packet not addressed to me: ");printByteArray(Packet->use.head.MAC.v,6); print_I(" is not mine: ");printByteArray(MyMAC.v,6);
}
//setLed(0,0,1);
setPrintLevel(l);
return true;
}//Have a packet
setPrintLevel(l);
return false;
}
void DoCheckObject (const PolyObject *base, POLYUNSIGNED L)
{
PolyWord *pt = (PolyWord*)base;
CheckAddress(pt);
MemSpace *space = gMem.SpaceForAddress(pt-1);
if (space == 0)
Crash ("Bad pointer 0x%08" PRIxPTR " found", (uintptr_t)pt);
ASSERT (OBJ_IS_LENGTH(L));
POLYUNSIGNED n = OBJ_OBJECT_LENGTH(L);
if (n == 0) return;
ASSERT (n > 0);
ASSERT(pt-1 >= space->bottom && pt+n <= space->top);
byte flags = GetTypeBits(L); /* discards GC flag and mutable bit */
if (flags == F_BYTE_OBJ) /* possibly signed byte object */
return; /* Nothing more to do */
if (flags == F_CODE_OBJ) /* code object */
{
ScanCheckAddress checkAddr;
/* We flush the instruction cache here in case we change any of the
instructions when we update addresses. */
machineDependent->FlushInstructionCache(pt, (n + 1) * sizeof(PolyWord));
machineDependent->ScanConstantsWithinCode((PolyObject *)base, (PolyObject *)base, n, &checkAddr);
/* Skip to the constants. */
base->GetConstSegmentForCode(n, pt, n);
}
else if (flags == F_CLOSURE_OBJ)
{
n -= sizeof(PolyObject*) / sizeof(PolyWord);
pt += sizeof(PolyObject*) / sizeof(PolyWord);
}
else ASSERT (flags == 0); /* ordinary word object */
while (n--) DoCheck (*pt++);
}
size_t GetModuleNameFromAddress(void* address, char* moduleName, size_t size)
{
if (size) *moduleName = 0;
{
const char* sourceName;
IMAGEHLP_MODULE moduleInfo = { sizeof (moduleInfo) };
if (!SymGetModuleInfo(GetSymHandle(), CheckAddress(address), &moduleInfo)) {
return 0;
}
sourceName = strrchr(moduleInfo.ImageName, '\\');
if (sourceName) {
sourceName++;
} else {
sourceName = moduleInfo.ImageName;
}
if (size) {
strncpy(moduleName, sourceName, size)[size - 1] = 0;
}
return strlen(sourceName);
}
}
size_t GetSymbolNameFromAddress(void* address, char* symbolName, size_t size,
size_t* offsetBytes)
{
if (size) *symbolName = 0;
if (offsetBytes) *offsetBytes = 0;
__try {
ULONG_ADDR dwOffset = 0;
union {
IMAGEHLP_SYMBOL sym;
char symNameBuffer[sizeof(IMAGEHLP_SYMBOL) + MAX_SYM_NAME];
} u;
u.sym.SizeOfStruct = sizeof(u.sym);
u.sym.MaxNameLength = sizeof(u.symNameBuffer) - sizeof(u.sym);
if (!SymGetSymFromAddr(GetSymHandle(), CheckAddress(address), &dwOffset,
&u.sym)) {
return 0;
} else {
const char* sourceName = u.sym.Name;
char undName[1024];
if (UnDecorateSymbolName(u.sym.Name, undName, sizeof(undName),
UNDNAME_NO_MS_KEYWORDS | UNDNAME_NO_ACCESS_SPECIFIERS)) {
sourceName = undName;
} else if (SymUnDName(&u.sym, undName, sizeof(undName))) {
sourceName = undName;
}
if (offsetBytes) {
*offsetBytes = dwOffset;
}
if (size) {
strncpy(symbolName, sourceName, size)[size - 1] = 0;
}
return strlen(sourceName);
}
} __except (EXCEPTION_EXECUTE_HANDLER) {
SetLastError(GetExceptionCode());
}
return 0;
}
/**This should get called every time a new byte is availible from the UART.
* @param byte the new byte that just arrived.
*/
void OnByteRecieved(const unsigned char byte)
{
//Check the interframe spacing.
//If it has been more than that time it is either an error or a new packet.
//also check if we arent recieving a message at all.
//Either of these conditions indicate that this byte could be the start of a new character.
if (((TimeSinceLastByteWasRecieved() >= CurrentTimeOut)) | !(RecievingMessage))
{
//A byte time of silence or more always delimits packets
//So reset the recieve pointer to clear any garbage and reset the hash state.
RecievePointer = 0;
HashState = 0;
//Consider this the start of a new packet ONLY if it matches the valid start code
//And ONLY if the required interframe distance has been met or exceeded.
//This lets us send one byte messages outside of a full packet
if (byte == 0x55)
{
RecievingMessage = 1;
}
else
{
//If we don't see the valid start code we stay idle
RecievingMessage = 0;
}
return;
}
//Only if a valid start code was detected at the start should we enter the byte in the buffer.
else
{
RecieveBuffer[RecievePointer] = byte;
RecievePointer++;
//Update the checksum as we go so we don't have to do one huge batch of calculations
//At the end, which would suck for realtime performance.
//Also dont CRC the CRC because that would
//not make sense unless we did that weird crc(message +crc)=0 thing
if (!((RecievePointer >= (RecieveBuffer[LENGTH_OFFSET]-1)) &(RecievePointer>LENGTH_OFFSET)))
{
HashUpdate(byte);
}
//Not only check and see if we have as mny bytes as the length field says,
//But also check that we even have the length field.
if ((RecievePointer >= RecieveBuffer[LENGTH_OFFSET]) &(RecievePointer>LENGTH_OFFSET))
{
//If we have recieved a complete message, Check the checksum.
// DisableReciever(); //We must re enable this to be ready for the next packet.
RecievingMessage = 0;
//Do nothing with the packet if we have just been waiting for the end of it.
if (CheckAddress(RecieveBuffer))
{
//Don't do anything with incorrect packets, they are bad.
if (GetByteOf(0,HashState ) == RecieveBuffer[RecievePointer-1])
{
if(GetByteOf(1,HashState) == RecieveBuffer[RecievePointer-2])
{
HandleNewPacket(RecieveBuffer);
}
}
}
}
}
}
MdErrEnum MdDataDeal(Md_Tcp_Dep *Tcp)
{
MdErrEnum ret;
// 1. 地址判断
#define MD_DEV_ADDR_CHK
if(CheckAddress(Tcp))
{
return MD_DEV_ADDR_ERR;
}
// 2. 判断命令
#define MD_CMD_CHK
if(Tcp->RawData[MD_DEV_CMD_INDEX] != MD_CMD_WRP &&
Tcp->RawData[MD_DEV_CMD_INDEX] != MD_CMD_WR &&
Tcp->RawData[MD_DEV_CMD_INDEX] != MD_CMD_RD)
{
return MD_CMD_ERR;
}
// 3. 判断CRC
#define MD_CRC_CHK
if(1)
{
uint16 tmpCRC1 = GetCRC16(Tcp->RawData,Tcp->RawDataLen-2);
uint16 tmpCRC2 = Tcp->RawData[Tcp->RawDataLen-1]*256+Tcp->RawData[Tcp->RawDataLen-2];
if(tmpCRC1 != tmpCRC2)
{
return MD_CRC_ERR;
}
}
// 3. 判断包总长度
if(Tcp->RawData[MD_DEV_CMD_INDEX] == MD_CMD_WRP||
Tcp->RawData[MD_DEV_CMD_INDEX] == MD_CMD_WR)
{
#define MD_WRITINGING_TOTAL_CHK
if(Tcp->RawDataLen == MD_SHORT_CMD_LEN)
{
;
}
else if (Tcp->RawDataLen == (MD_0X10_EXTRA_BYTE+Tcp->RawData[MD_0X03_TRG_NUM_INDEX]) &&
(Tcp->RawData[MD_0X03_TRG_NUM_INDEX] == (Tcp->RawData[MD_0X03_TRG_NUM_INDEX-1]*2)))
{
;
}
else
{
return MD_WRITE_TOTAL_LEN_ERR;
}
}
else
{
#define MD_READING_TOTAL_CHK
if(Tcp->RawDataLen == MD_SHORT_CMD_LEN)
{
;
}
else if (Tcp->RawDataLen == (MD_0X03_EXTRA_BYTE+Tcp->RawData[MD_0X03_RSP_NUM_INDEX]))
{
;
}
else
{
return MD_READ_TOTAL_LEN_ERR;
}
}
// 4. 判断命令长度
#define MD_LEN_CHK_SHORT
if(Tcp->RawDataLen == MD_SHORT_CMD_LEN)
{
if(Tcp->RawData[MD_DEV_CMD_INDEX] == MD_CMD_WRP||
Tcp->RawData[MD_DEV_CMD_INDEX] == MD_CMD_WR)
{
//NO ECHO
return MD_ERR_OK;
}
else
{
#define MD_READING_RSP
uint16 trgaddr = Tcp->RawData[MD_0X10_TRG_ADDR_INDEX]*256+Tcp->RawData[MD_0X10_TRG_ADDR_INDEX+1];
uint16 length = Tcp->RawData[MD_0X10_TRG_LEN_INDEX+1];
ret = (*Tcp->LenChkCheck)(trgaddr,length);
if(ret != MD_ERR_OK)
{
return ret;
}
// Data Setup
Tcp->rePkglen=Slave_ModbusDataSetup(Tcp);
return MD_ERR_OK;
}
}
// 5. 按需要回复
#define MD_LEN_CHK_LONG
if(Tcp->RawData[MD_DEV_CMD_INDEX] == MD_CMD_WRP||
Tcp->RawData[MD_DEV_CMD_INDEX] == MD_CMD_WR)
{
//slave data deal
#define SLAVE_DATA_DEAL
uint16 trgaddr = Tcp->RawData[MD_0X10_TRG_ADDR_INDEX]*256+Tcp->RawData[MD_0X10_TRG_ADDR_INDEX+1];
uint16 length = Tcp->RawData[MD_0X10_TRG_LEN_INDEX]*256+Tcp->RawData[MD_0X10_TRG_LEN_INDEX+1];
ret = (*Tcp->LenChkCheck)(trgaddr,length);
if(ret != MD_ERR_OK)
{
return ret;
}
//数据处理
#define DATA_WRITING
if( 1 )
{
uint16 itmp;
uint16 tmpindex = MD_MST_DATA_INDEX;
uint08 tmp;
for(tmp=0;tmp<length;tmp++)
{
itmp = Tcp->p2trg[tmpindex++]*256;
itmp +=Tcp->p2trg[tmpindex++];
(*Tcp->WrData)((trgaddr+tmp),itmp);
}
}
//长的,写命令,回复一个短回复
Tcp->rePkglen=Slave_ModbusDataSetup(Tcp);
return MD_ERR_OK;
}
else
{
//长的,读命令,不需要回复
//NO ECHO
return MD_ERR_OK;
}
}
void
QualityOfServiceData::ReadDistributionChannels()
{
//insert Local channel first
m_DistributionChannelNameTable.insert(std::make_pair(L"Local",LOCAL_DISTRIBUTION_CHANNEL));
int nextChannelNumber = SYSTEM_DISTRIBUTION_CHANNEL; //start at 64. System must always get this number
try
{
for (int ix = 0; ix < Dob::DistributionChannelParameters::DistributionChannelsArraySize(); ++ix)
{
Dob::DistributionChannelPtr channelItem = Dob::DistributionChannelParameters::DistributionChannels(ix);
const std::wstring name = channelItem->Name().GetVal();
if (name.empty())
{
throw Dob::Typesystem::ConfigurationErrorException(L"Illegal distribution channel name",__WFILE__,__LINE__);
}
boost::uint64_t includedNodes;
int numNodesInChannel;
int theSingleNode; //is only used when numNodesInChannel == 1
ConvertNodesString(channelItem->IncludedNodes().GetVal(),includedNodes,numNodesInChannel, theSingleNode);
lllout << LLL_PREFIX << "Read DistributionChannel '" << name << "' ";
//special handling for the System distribution channel.
if (ix == 0)
{
//check that the first one is System
if(name != L"System")
{
throw Dob::Typesystem::ConfigurationErrorException(L"System must be first defined distribution channel",__WFILE__,__LINE__);
}
const std::string multicastAddress = channelItem->MulticastAddress().Utf8String();
if (multicastAddress == "127.0.0.1")
{
m_bIsStandalone = true;
lllout << " which is local (all messages will be local and no other channels or priorities will be read)" <<std::endl;
return;
}
}
if (ix == 1)
{
//check that the second one is PoolDistribution
if(name != L"PoolDistribution")
{
throw Dob::Typesystem::ConfigurationErrorException(L"PoolDistribution must be second defined distribution channel",__WFILE__,__LINE__);
}
}
if (numNodesInChannel == 0)
{
throw Dob::Typesystem::ConfigurationErrorException(L"Channel must contain at least one node",__WFILE__,__LINE__);
}
else if (numNodesInChannel == 1)
{
//is this node the single node --> use Local
const int nodeId=Dob::ThisNodeParameters::NodeNumber();
if (theSingleNode == nodeId)
{
m_DistributionChannelNameTable.insert(std::make_pair(name,LOCAL_DISTRIBUTION_CHANNEL));
lllout << "which is this node, so data will be local" << std::endl;
}
else
{
//use singlecast for this distribution channel name
m_DistributionChannelNameTable.insert(std::make_pair(name,theSingleNode));
lllout << "which will use singlecast to node " << theSingleNode <<std::endl;
}
}
else
{
const std::string multicastAddress = channelItem->MulticastAddress().Utf8String();
if (!CheckAddress(multicastAddress))
{
throw Dob::Typesystem::ConfigurationErrorException(std::wstring(L"Illegal multicast address: ") +
channelItem->MulticastAddress().GetVal(),__WFILE__,__LINE__);
}
m_DistributionChannelTable.insert(std::make_pair
(nextChannelNumber,DistributionChannelData(includedNodes,multicastAddress)));
m_DistributionChannelNameTable.insert(std::make_pair(name,nextChannelNumber));
++nextChannelNumber;
lllout << " (id="
<< nextChannelNumber - 1
<< ") with included nodes '"
<< std::hex << includedNodes << std::dec
<< "'" <<std::endl;
}
}
}
catch (const Dob::Typesystem::FundamentalException &)
{
std::wcout << "Failed to read QoS DistributionChannel parameters" <<std::endl;
throw;
}
}
virtual PolyObject *ScanObjectAddress(PolyObject *pt) { CheckAddress((PolyWord*)pt); return pt; }
