static inline void AddHexChar(char *csBuf, unsigned long & ulOffset, bool bAddSpace, unsigned char uc)
{
csBuf[ulOffset++] = ToHex(uc / 16);
csBuf[ulOffset++] = ToHex(uc % 16);
if (bAddSpace)
csBuf[ulOffset++] = ' ';
}
void
DevicePCI::InitFromAttributes()
{
// Process the attributes
fClassBaseId = atoi(fAttributeMap[B_DEVICE_TYPE].String());
fClassSubId = atoi(fAttributeMap[B_DEVICE_SUB_TYPE].String());
fClassApiId = atoi(fAttributeMap[B_DEVICE_INTERFACE].String());
fVendorId = atoi(fAttributeMap[B_DEVICE_VENDOR_ID].String());
fDeviceId = atoi(fAttributeMap[B_DEVICE_ID].String());
// Looks better in Hex, so rewrite
fAttributeMap[B_DEVICE_TYPE] = ToHex(fClassBaseId);
fAttributeMap[B_DEVICE_SUB_TYPE] = ToHex(fClassSubId);
fAttributeMap[B_DEVICE_INTERFACE] = ToHex(fClassApiId);
fAttributeMap[B_DEVICE_VENDOR_ID] = ToHex(fVendorId);
fAttributeMap[B_DEVICE_ID] = ToHex(fDeviceId);
// Fetch ClassInfo
char classInfo[64];
get_class_info(fClassBaseId, fClassSubId, fClassApiId, classInfo,
sizeof(classInfo));
// Fetch ManufacturerName
BString ManufacturerName;
const char *venShort;
const char *venFull;
get_vendor_info(fVendorId, &venShort, &venFull);
if (!venShort && !venFull) {
ManufacturerName << B_TRANSLATE("Unknown");
} else if (venShort && venFull) {
ManufacturerName << venFull << "(" << venShort << ")";
} else {
ManufacturerName << (venShort ? venShort : venFull);
}
// Fetch DeviceName
BString DeviceName;
const char *devShort;
const char *devFull;
get_device_info(fVendorId, fDeviceId, fSubsystemVendorId, fSubSystemId,
&devShort, &devFull);
if (!devShort && !devFull) {
DeviceName << B_TRANSLATE("Unknown");
} else if (devShort && devFull) {
DeviceName << devFull << "(" << devShort << ")";
} else {
DeviceName << (devShort ? devShort : devFull);
}
SetAttribute(B_TRANSLATE("Device name"), DeviceName);
SetAttribute(B_TRANSLATE("Manufacturer"), ManufacturerName);
SetAttribute(B_TRANSLATE("Driver used"), B_TRANSLATE("Not implemented"));
SetAttribute(B_TRANSLATE("Device paths"), B_TRANSLATE("Not implemented"));
SetAttribute(B_TRANSLATE("Class info"), classInfo);
fCategory = (Category)fClassBaseId;
BString outlineName;
outlineName << ManufacturerName << " " << DeviceName;
SetText(outlineName.String());
}
//获取模拟端口数据
void GetAngolags(u8 ch,int chNum)
{
adcx=Get_Adc_Average(ch,10);
PacketBuf[24+5*chNum]=ToHex(adcx/1000);
PacketBuf[25+5*chNum]=ToHex(adcx%1000/100);
PacketBuf[26+5*chNum]=ToHex(adcx%100/10);
PacketBuf[27+5*chNum]=ToHex(adcx%10);
}
std::string NullUnsolicited(uint8_t seq, const IINField& iin)
{
Buffer buffer(DEFAULT_MAX_APDU_SIZE);
APDUResponse response(buffer.GetWSlice());
build::NullUnsolicited(response, seq, iin);
return ToHex(response.ToRSlice());
}
_tsTraceMethodExt::~_tsTraceMethodExt()
{
TSTRACEValidateHeaps();
if (enabled)
{
if (m_outMessage.size() != 0)
{
if (m_error)
{
FrameworkError << m_outMessage << tscrypto::endl;
LOG(CallTrace, "Error: " << m_outMessage);
}
else
{
LOG(CallTrace, m_outMessage);
}
}
else
{
LOG(FrameworkError, "Error: Exception or unknown return value\n");
LOG(CallTrace, "Error: Exception or unknown return value\n");
}
LOGD(CallTrace, outdent);
LOG(CallTrace, "END // " << m_method << " [" << ToHex()(this) << " - " << classInstance << "]");
}
}
_tsTraceFunctionExt::~_tsTraceFunctionExt()
{
TSTRACEValidateHeaps();
if (m_info.enabled)
{
if (m_outMessage.size() != 0)
{
if (m_error)
{
LOG(FrameworkError, m_outMessage);
LOG(CallTrace, "Error: " << m_outMessage);
}
else
{
LOG(CallTrace, m_outMessage);
}
}
else
{
LOG(FrameworkError, "Error: Exception or unknown return value\n");
LOG(CallTrace, "Error: Exception or unknown return value\n");
}
if (m_This != NULL)
{
LOGD(CallTrace, outdent);
LOG(CallTrace, "END " << m_info.name << " // 0x" << ToHex()(this));
}
else
{
LOGD(CallTrace, outdent);
LOG(CallTrace, "END " << m_info.name);
}
CallTrace << tscrypto::endl;
}
}
std::string AuthErrorResponse(
opendnp3::IINField iin,
uint8_t appSeq,
uint32_t challengeSeqNum,
uint16_t user,
uint16_t assocId,
opendnp3::AuthErrorCode code,
opendnp3::DNPTime timestamp,
std::string hexErrorText)
{
Buffer buffer(DEFAULT_MAX_APDU_SIZE);
APDUResponse apdu(buffer.GetWSlice());
apdu.SetControl(AppControlField(true, true, false, false, appSeq));
apdu.SetFunction(FunctionCode::AUTH_RESPONSE);
apdu.SetIIN(iin);
HexSequence hexErrorTextBuff(hexErrorText);
Group120Var7 error(
challengeSeqNum,
user,
assocId,
code,
timestamp,
hexErrorTextBuff.ToRSlice()
);
apdu.GetWriter().WriteFreeFormat(error);
return ToHex(apdu.ToRSlice());
}
_tsTraceClassExt::~_tsTraceClassExt()
{
if (m_TraceInfo.enabled)
{
LOG(CallTrace, "DESTROY " << m_TraceInfo.name << " [" << ToHex()(this) << " - " << m_classInstance << "]");
}
}
std::string KeyStatusResponse(
IINField iin,
uint8_t seq,
uint32_t ksq,
uint16_t user,
KeyWrapAlgorithm keyWrap,
KeyStatus status,
HMACType hmacType,
const std::string& challenge,
const std::string& hmac
)
{
Buffer buffer(DEFAULT_MAX_APDU_SIZE);
APDUResponse apdu(buffer.GetWSlice());
apdu.SetControl(AppControlField(true, true, false, false, seq));
apdu.SetFunction(FunctionCode::AUTH_RESPONSE);
apdu.SetIIN(iin);
HexSequence challengeBuff(challenge);
HexSequence hmacBuff(hmac);
Group120Var5 rsp;
rsp.keyChangeSeqNum = ksq;
rsp.userNum = user;
rsp.keyWrapAlgo = keyWrap;
rsp.keyStatus = status;
rsp.hmacAlgo = hmacType;
rsp.challengeData = challengeBuff.ToRSlice();
rsp.hmacValue = hmacBuff.ToRSlice();
apdu.GetWriter().WriteFreeFormat(rsp);
return ToHex(apdu.ToRSlice());
}
std::string UrlCode::Encode(std::string url)
{
const char *pstr = url.c_str();
char *buf = new char[url.length() * 3 + 1];
char *pbuf = buf;
while (*pstr) {
if (isalnum(*pstr) || *pstr == '-' || *pstr == '_' || *pstr == '.' || *pstr == '~') {
*pbuf++ = *pstr;
} else if (*pstr == ' ') {
*pbuf++ = '+';
} else {
*pbuf++ = '%';
*pbuf++ = ToHex(*pstr >> 4);
*pbuf++ = ToHex(*pstr & 15);
}
pstr++;
}
*pbuf = '\0';
std::string encoded = buf;
delete buf;
return encoded;
}
std::string ClassTask(FunctionCode fc, uint8_t seq, const ClassField& field)
{
Buffer buffer(DEFAULT_MAX_APDU_SIZE);
APDURequest request(buffer.GetWSlice());
opendnp3::build::ClassRequest(request, fc, field, seq);
return ToHex(request.ToRSlice());
}
cacheItem* WCache<cacheItem, cacheActual>::AttemptNew(const string& filename, int submode)
{
cacheItem* item = NEW cacheItem;
if (!item)
{
mError = CACHE_ERROR_BAD_ALLOC;
return NULL;
}
mError = CACHE_ERROR_NONE;
if (!item->Attempt(filename, submode, mError) || !item->isGood())
{
//No such file. Fail
if (mError == CACHE_ERROR_404)
{
DebugTrace("AttemptNew failed to load. Deleting cache item " << ToHex(item));
SAFE_DELETE(item);
return NULL;
}
else
{
DebugTrace("AttemptNew failed to load (not a 404 error). Deleting cache item " << ToHex(item));
SAFE_DELETE(item);
mError = CACHE_ERROR_BAD;
return NULL;
}
}
//Success! Enforce cache limits, then return.
mError = CACHE_ERROR_NONE;
return item;
}
std::string ClearRestartIIN(uint8_t seq)
{
Buffer buffer(DEFAULT_MAX_APDU_SIZE);
APDURequest request(buffer.GetWSlice());
build::ClearRestartIIN(request, seq);
return ToHex(request.ToRSlice());
}
std::string MeasureDelay(uint8_t seq)
{
Buffer buffer(DEFAULT_MAX_APDU_SIZE);
APDURequest request(buffer.GetWSlice());
build::MeasureDelay(request, seq);
return ToHex(request.ToRSlice());
}
std::string ChallengeResponse(
opendnp3::IINField iin,
uint8_t seq,
uint32_t csq,
uint16_t user,
HMACType hmacType,
ChallengeReason reason,
std::string challengeDataHex
)
{
Buffer buffer(DEFAULT_MAX_APDU_SIZE);
APDUResponse apdu(buffer.GetWSlice());
apdu.SetControl(AppControlField(true, true, false, false, seq));
apdu.SetFunction(FunctionCode::AUTH_RESPONSE);
apdu.SetIIN(iin);
HexSequence challengeBuff(challengeDataHex);
Group120Var1 rsp(
csq,
user,
hmacType,
reason,
challengeBuff.ToRSlice()
);
apdu.GetWriter().WriteFreeFormat(rsp);
return ToHex(apdu.ToRSlice());
}
void CKadScript::SaveData()
{
wstring FileName = ToHex(m_CodeID.GetData(), m_CodeID.GetSize());
wstring ScriptPath = GetParent<CKademlia>()->Cfg()->GetString("ScriptCachePath");
if(!ScriptPath.empty())
SaveData(ScriptPath + L"/" + FileName + L".dat");
}
char * getQueryParam(const char * queryString, const char *name)
{
char bufferAmpersand[MAX_BUFFER_SIZE];
char bufferQuestion[MAX_BUFFER_SIZE];
snprintf(bufferQuestion,MAX_BUFFER_SIZE-1,"?%s=",name);
snprintf(bufferAmpersand,MAX_BUFFER_SIZE-1,"&%s=",name);
char *buffer;
char *pos1;
char *value = malloc(MAX_BUFFER_SIZE*sizeof(char));
if (value == NULL) {
printf("Could not allocate memory.");
exit(EXIT_FAILURE);
}
int i;
buffer=bufferQuestion;
pos1 = strstr(queryString,bufferQuestion);
printf ("Buffer %s Pos %s\n",buffer,pos1);
if (!pos1) {
buffer=bufferAmpersand;
pos1 = strstr(queryString, bufferAmpersand);
}
if (pos1) {
pos1 += strlen(buffer);
i=0;
while (*pos1 && *pos1 != '&' && i<MAX_BUFFER_SIZE) {
if (*pos1 == '%') {
value[i]= (char)ToHex(pos1[1]) * 16 + ToHex(pos1[2]);
pos1 += 3;
} else if( *pos1=='+' ) {
value[i] = ' ';
pos1++;
} else {
value[i] = *pos1++;
}
i++;
}
value[i] = '\0';
return value;
}
strcpy(value, UNDEFINED);
return value;
}
//合并温湿度传感器数据并生成数据包
void MergeDHT1(void)
{
Clear(PacketBuf);
PacketBuf[0]=0x15;
PacketBuf[4]=0x00;
PacketBuf[8]=0x09;
PacketBuf[1]=PacketBuf[2]=PacketBuf[3]=PacketBuf[5]=PacketBuf[6]=PacketBuf[7]=PacketBuf[9]=PacketBuf[10]=PacketBuf[11]=0;
PacketBuf[12]= ToHex(((int)buf[0]/10));
PacketBuf[13]= ToHex(((int)buf[0]%10));
PacketBuf[14]='.';
PacketBuf[15]='0';
PacketBuf[16]='%';
PacketBuf[17]=ToHex(((int)buf[2]/10));
PacketBuf[18]=ToHex(((int)buf[2]%10));
PacketBuf[19]='.';
PacketBuf[20]='0';
}
std::string Confirm(uint8_t seq, bool unsol)
{
Buffer buffer(DEFAULT_MAX_APDU_SIZE);
APDURequest apdu(buffer.GetWSlice());
apdu.SetControl(AppControlField(true, true, false, unsol, seq));
apdu.SetFunction(FunctionCode::CONFIRM);
return ToHex(apdu.ToRSlice());
}
_tsTraceClassExt::_tsTraceClassExt(const _tsTraceInfoExt &info) :
m_TraceInfo(info),
m_classInstance(GetNewObjectId())
{
if (m_TraceInfo.enabled)
{
LOG(CallTrace, "CREATE " << m_TraceInfo.name << " [" << ToHex()(this) << " - " << m_classInstance << "]");
}
}
CK_ULONG ByteArrayToString( CK_CHAR_PTR* destString ,CK_ULONG ulDestLen,CK_BYTE* byteArray, CK_ULONG ulArrayLen)
{
unsigned long ulOffset = 0;
CK_ULONG i;
CK_CHAR_PTR pcbuf = *destString;
if((ulDestLen+1) < ulArrayLen)
return 1;
for (i = 0; i < ulArrayLen; i++)
{
pcbuf[ulOffset++] = ToHex(byteArray[i] / 16);
pcbuf[ulOffset++] = ToHex(byteArray[i] % 16);
}
pcbuf[ulOffset] = '\0';
return 0;
}
CString CEIBRecord::PrintValue() const
{
CString ret("0x");
for(int i =0; i < _value_len; ++i)
{
ret += ToHex((int)_value[i]);
}
return ret;
}
std::string KeyWrapData(
uint16_t keyLengthBytes,
uint8_t keyRepeatValue,
std::string keyStatusMsg
)
{
Buffer key(keyLengthBytes);
key.GetWSlice().SetAllTo(keyRepeatValue);
auto keyHex = ToHex(key.ToRSlice());
HexSequence statusBuffer(keyStatusMsg);
Buffer lengthBuff(2);
auto lenDest = lengthBuff.GetWSlice();
UInt16::WriteBuffer(lenDest, keyLengthBytes);
auto lengthHex = ToHex(lengthBuff.ToRSlice());
return AppendHex({lengthHex, keyHex, keyHex, keyStatusMsg});
}
std::string EmptyAuthResponse(uint8_t seq, const opendnp3::IINField& iin)
{
Buffer buffer(DEFAULT_MAX_APDU_SIZE);
APDUResponse response(buffer.GetWSlice());
response.SetFunction(FunctionCode::AUTH_RESPONSE);
response.SetControl(AppControlField(true, true, false, false, seq));
response.SetIIN(iin);
return ToHex(response.ToRSlice());
}
std::string ToNibblesString() const
{
assert(IsNibbles());
const uint_t fixed = Zeroes ^ Ones;
const uint_t hiNibble = fixed >> 4;
const uint_t loNibble = fixed & 15;
std::string result(3, ' ');
result[0] = hiNibble == 15 ? ToHex(Ones >> 4) : 'x';
result[1] = loNibble == 15 ? ToHex(Ones & 15) : 'x';
return result;
}
std::string RequestKeyStatus(uint8_t seq, uint16_t user)
{
Buffer buffer(DEFAULT_MAX_APDU_SIZE);
APDURequest apdu(buffer.GetWSlice());
apdu.SetControl(AppControlField(true, true, false, false, seq));
apdu.SetFunction(FunctionCode::AUTH_REQUEST);
Group120Var4 status;
status.userNum = user;
apdu.GetWriter().WriteSingleValue<UInt8>(QualifierCode::UINT8_CNT, status);
return ToHex(apdu.ToRSlice());
}
void rawUrlDecode(char *qs, char *rtn, int maxChar)
{
int i = 0;
for(; *qs != '\0'; qs++, rtn++) {
if(i == maxChar){
break;
}
if(*qs == '%') {
*rtn = (char) ToHex(qs[1]) * 16 + ToHex(qs[2]);
qs++;
qs++;
} else if(*qs == '+') {
*rtn = ' ';
} else
*rtn = *qs;
}
rtn++;
*rtn = '\0';
}
//合并数字信号和模拟信号
void MergeDigitalAndAnalog(void)
{
Clear(PacketBuf);
PacketBuf[0]=0x59;
PacketBuf[4]=0x02;
PacketBuf[8]=0x4D;
PacketBuf[1]=PacketBuf[2]=PacketBuf[3]=PacketBuf[5]=PacketBuf[6]
=PacketBuf[7]=PacketBuf[9]=PacketBuf[10]=PacketBuf[11]=0;
PacketBuf[12]='{';
PacketBuf[13]=PacketBuf[21]=PacketBuf[60]=PacketBuf[69]='"';
PacketBuf[14]='A';
PacketBuf[15]='n';
PacketBuf[16]='a';
PacketBuf[17]='l';
PacketBuf[18]='o';
PacketBuf[19]='g';
PacketBuf[20]='s';
PacketBuf[22]=PacketBuf[70]=':';
PacketBuf[23]=PacketBuf[71]='[';
PacketBuf[28]=PacketBuf[33]=PacketBuf[38]=PacketBuf[43]=PacketBuf[48]
=PacketBuf[53]=PacketBuf[59]=PacketBuf[73]=PacketBuf[75]=PacketBuf[77]
=PacketBuf[79]=PacketBuf[81]=PacketBuf[83]=PacketBuf[85]=',';
PacketBuf[58]=PacketBuf[87]=']';
PacketBuf[61]='D';
PacketBuf[62]='i';
PacketBuf[63]='g';
PacketBuf[64]='i';
PacketBuf[65]='t';
PacketBuf[66]='a';
PacketBuf[67]='l';
PacketBuf[68]='s';
PacketBuf[88]='}';
GetAngolags(ADC_Channel_0,0);
GetAngolags(ADC_Channel_1,1);
GetAngolags(ADC_Channel_2,2);
GetAngolags(ADC_Channel_3,3);
GetAngolags(ADC_Channel_4,4);
GetAngolags(ADC_Channel_5,5);
GetAngolags(ADC_Channel_6,6);
PacketBuf[72]=ToHex(LED1);
PacketBuf[74]=ToHex(LED2);
PacketBuf[76]=ToHex(LED3);
PacketBuf[78]=ToHex(LED4);
PacketBuf[80]=ToHex(LED5);
PacketBuf[82]=ToHex(LED6);
PacketBuf[84]=ToHex(LED7);
PacketBuf[86]=ToHex(LED8);
}
//----------------------------------------------------------------------
// Parse the raw file data in to an array of uchar's. The data must
// be hex characters possible seperated by white space
// 12 34 456789ABCD EF
// FE DC BA 98 7654 32 10
// would be converted to an array of 16 uchars.
// return the array length. If an invalid hex pair is found then the
// return will be 0.
//
int ParseData(char *inbuf, int insize, uchar *outbuf, int maxsize)
{
int ps, outlen=0, gotmnib=0;
uchar mnib;
// loop until end of data
for (ps = 0; ps < insize; ps++)
{
// check for white space
if (isspace(inbuf[ps]))
continue;
// not white space, make sure hex
else if (isxdigit(inbuf[ps]))
{
// check if have first nibble yet
if (gotmnib)
{
// this is the second nibble
outbuf[outlen++] = (mnib << 4) | ToHex(inbuf[ps]);
gotmnib = 0;
}
else
{
// this is the first nibble
mnib = (uchar)ToHex(inbuf[ps]);
gotmnib = 1;
}
}
else
return 0;
// if getting to the max return what we have
if ((outlen + 1) >= maxsize)
return outlen;
}
return outlen;
}
//----------------------------------------------------------------------
// Enter a hex string and convert it to an unsigned long
// (1-8) characters
//
int EnterHex(char *msg, int numchars, ulong *value)
{
int tmp,cnt;
int ch;
// prompt
printf("%s (enter hex, up to %d chars):",msg,numchars);
*value = 0;
cnt = 0;
do
{
ch = getkeystroke();
if (ch == 0x08)
{
printf("%c %c",ch,ch);
if (cnt)
cnt--;
}
else if (ch == 0x1B)
{
printf(" Aborted\n\n");
return FALSE;
}
// caraige return
else if (ch == 0x0A)
{
printf("\n");
return TRUE;
}
else
{
tmp = ToHex((char)ch);
if (tmp)
{
printf("%c",ch);
*value <<= 4;
*value |= tmp;
cnt++;
}
}
}
while (cnt < numchars);
printf("\n");
return TRUE;
}
