bool SNMPPdu::encodeData(unsigned char *buf,int len,int pklen) //��PDU��buffer
{
int point = 0;
int offset;
buf[0] = 0x30;
offset = encodeLength(&(buf[1]),len-1,pklen);//�ܳ���
point = offset+1;
offset = encodeInteger32( &(buf[point]),len-point,version,VT_Integer32);//version
point += offset;
buf[point-1] = 0x01;
offset = encodeOctetString( &(buf[point]),len-point,Community,cmtylen,VT_OctetString);
point += offset;
buf[point] = commond;
point += 1;
offset = encodeLength(&(buf[point]),len-point,getPDUCmdBerLength());//����
point += offset;
offset = encodeInteger32( &(buf[point]),len-point,requestID,VT_Integer32);//requestID
point += offset;
offset = encodeInteger32( &(buf[point]),len-point,errorStatus,VT_Integer32);//errorStatus
point += offset;
offset = encodeInteger32( &(buf[point]),len-point,errorIndex,VT_Integer32);//errorIndex
point += offset;
variableBindings.encodeData(&(buf[point]),len-point);
return true;
}
int encodeBitString (OOCTXT* pctxt, ASN1UINT numbits, const ASN1OCTET* data)
{
int enclen, octidx = 0, stat;
Asn1SizeCnst* pSizeList = pctxt->pSizeConstraint;
for (;;) {
if ((enclen = encodeLength (pctxt, numbits)) < 0) {
return LOG_ASN1ERR (pctxt, enclen);
}
if (enclen > 0) {
ASN1BOOL doAlign;
stat = bitAndOctetStringAlignmentTest
(pSizeList, numbits, TRUE, &doAlign);
if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
if (doAlign) {
stat = encodeByteAlign (pctxt);
if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
}
stat = encodeOctets (pctxt, &data[octidx], enclen);
if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
}
if (enclen < (int)numbits) {
numbits -= enclen;
octidx += (enclen/8);
}
else break;
}
return ASN_OK;
}
void Frame::write(QDataStream &stream)
{
QByteArray lenbuf;
if (!encodeLength(lenbuf, _data.size()))
{
qCritical("qmqtt: Control packet bigger than 256 MB, dropped!");
return;
}
stream << (quint8)_header;
if(_data.size() == 0) {
stream << (quint8)0;
return;
}
if (stream.writeRawData(lenbuf.data(), lenbuf.size()) != lenbuf.size())
{
qCritical("qmqtt: Control packet write error!");
return;
}
if (stream.writeRawData(_data.data(), _data.size()) != _data.size())
{
qCritical("qmqtt: Control packet write error!");
}
}
int ber_encode_myINS(unsigned char *buf, struct myINS *myINS) {
int offset = 0;
buf[offset++] = 0xA2;
offset += encodeLength(&buf[offset], ber_get_length_myINS(myINS));
offset += BER_ENCODE_CTYPE_INT32(&buf[offset], &myINS->stVal);
return offset;
}
int ber_encode_myBeh(unsigned char *buf, struct myBeh *myBeh) {
int offset = 0;
buf[offset++] = 0xA2;
offset += encodeLength(&buf[offset], ber_get_length_myBeh(myBeh));
offset += BER_ENCODE_CTYPE_ENUM(&buf[offset], (CTYPE_ENUM *) &myBeh->stVal);
return offset;
}
int ber_encode_myAnalogValue(unsigned char *buf, struct myAnalogValue *myAnalogValue) {
int offset = 0;
buf[offset++] = 0xA2;
offset += encodeLength(&buf[offset], ber_get_length_myAnalogValue(myAnalogValue));
offset += BER_ENCODE_CTYPE_FLOAT32(&buf[offset], &myAnalogValue->f);
return offset;
}
int BER_ENCODE_CTYPE_DBPOS(unsigned char *buf, CTYPE_DBPOS *value) {
CTYPE_INT16U offset = 0;
CTYPE_INT16U len = BER_GET_LENGTH_CTYPE_DBPOS(value);
buf[offset++] = 0x85;
offset += encodeLength(&buf[offset], len);
netmemcpy(&buf[offset], value, len);
return offset + len;
}
int ber_encode_simpleSAV(unsigned char *buf, struct simpleSAV *simpleSAV) {
int offset = 0;
buf[offset++] = 0xA2;
offset += encodeLength(&buf[offset], ber_get_length_simpleSAV(simpleSAV));
offset += ber_encode_myAnalogValue(&buf[offset], &simpleSAV->instMag);
offset += BER_ENCODE_CTYPE_QUALITY(&buf[offset], &simpleSAV->q);
return offset;
}
int ber_encode_myDPL(unsigned char *buf, struct myDPL *myDPL) {
int offset = 0;
buf[offset++] = 0xA2;
offset += encodeLength(&buf[offset], ber_get_length_myDPL(myDPL));
offset += BER_ENCODE_CTYPE_VISSTRING255(&buf[offset], &myDPL->vendor);
offset += BER_ENCODE_CTYPE_VISSTRING255(&buf[offset], &myDPL->hwRev);
return offset;
}
int ber_encode_ScaledValueConfig(unsigned char *buf, struct ScaledValueConfig *ScaledValueConfig) {
int offset = 0;
buf[offset++] = 0xA2;
offset += encodeLength(&buf[offset], ber_get_length_ScaledValueConfig(ScaledValueConfig));
offset += BER_ENCODE_CTYPE_FLOAT32(&buf[offset], &ScaledValueConfig->scaleFactor);
offset += BER_ENCODE_CTYPE_FLOAT32(&buf[offset], &ScaledValueConfig->offset);
return offset;
}
void
OpaqueVarbind::Build(unsigned char*& pdu)
{
unsigned int len = DataLength();
unsigned int lenLen = (len / 129) + 1;
pdu[0] = SNMPOPAQUE;
unsigned char* lPdu = pdu;
lPdu++;
encodeLength(lPdu, (long)len);
memcpy(&pdu[lenLen + 1], mData, len); // the tag too
}
int ber_encode_myVector(unsigned char *buf, struct myVector *myVector) {
int offset = 0;
buf[offset++] = 0xA2;
offset += encodeLength(&buf[offset], ber_get_length_myVector(myVector));
offset += ber_encode_myAnalogValue(&buf[offset], &myVector->mag);
offset += ber_encode_myAnalogValue(&buf[offset], &myVector->ang);
return offset;
}
int BER_ENCODE_CTYPE_TIMESTAMP(unsigned char *buf, CTYPE_TIMESTAMP *value) {
CTYPE_INT16U offset = 0;
CTYPE_INT16U len = BER_GET_LENGTH_CTYPE_TIMESTAMP(value);
buf[offset++] = ASN1_TAG_OCTET_STRING;
offset += encodeLength(&buf[offset], len);
memcpy(&buf[offset], value, len);
return offset + len;
}
int BER_ENCODE_CTYPE_BOOLEAN(unsigned char *buf, CTYPE_BOOLEAN *value) {
CTYPE_INT16U offset = 0;
CTYPE_INT16U len = BER_GET_LENGTH_CTYPE_BOOLEAN(value);
buf[offset++] = ASN1_TAG_BOOLEAN;
offset += encodeLength(&buf[offset], len);
netmemcpy(&buf[offset], value, len);
return offset + len;
}
int BER_ENCODE_CTYPE_QUALITY(unsigned char *buf, CTYPE_QUALITY *value) {
CTYPE_INT16U offset = 0;
CTYPE_INT16U len = BER_GET_LENGTH_CTYPE_QUALITY(value);
buf[offset++] = ASN1_TAG_BIT_STRING;
offset += encodeLength(&buf[offset], len);
buf[offset++] = QUALITY_UNUSED_BITS; // number of unused bits
netmemcpy(&buf[offset], value, len - 1);
return offset + len - 1;
}
int BER_ENCODE_CTYPE_FLOAT64(unsigned char *buf, CTYPE_FLOAT64 *value) {
CTYPE_INT16U offset = 0;
CTYPE_INT16U len = BER_GET_LENGTH_CTYPE_FLOAT64(value);
buf[offset++] = ASN1_TAG_FLOATING_POINT;
offset += encodeLength(&buf[offset], len);
buf[offset++] = 0x0B; // bits for exponent
netmemcpy(&buf[offset], value, len - 1);
return offset + len - 1;
}
int ber_encode_mySPS(unsigned char *buf, struct mySPS *mySPS) {
int offset = 0;
buf[offset++] = 0xA2;
offset += encodeLength(&buf[offset], ber_get_length_mySPS(mySPS));
offset += BER_ENCODE_CTYPE_INT32(&buf[offset], &mySPS->stVal);
offset += BER_ENCODE_CTYPE_QUALITY(&buf[offset], &mySPS->q);
offset += BER_ENCODE_CTYPE_TIMESTAMP(&buf[offset], &mySPS->t);
return offset;
}
int ber_encode_myCMV(unsigned char *buf, struct myCMV *myCMV) {
int offset = 0;
buf[offset++] = 0xA2;
offset += encodeLength(&buf[offset], ber_get_length_myCMV(myCMV));
offset += ber_encode_myVector(&buf[offset], &myCMV->cVal);
offset += BER_ENCODE_CTYPE_QUALITY(&buf[offset], &myCMV->q);
offset += BER_ENCODE_CTYPE_TIMESTAMP(&buf[offset], &myCMV->t);
return offset;
}
void Frame::write(QDataStream &stream)
{
QByteArray lenbuf;
stream << (quint8)_header;
if(_data.size() == 0) {
stream << (quint8)0;
return;
}
encodeLength(lenbuf, _data.size());
stream.writeRawData(lenbuf.data(), lenbuf.size());
stream.writeRawData(_data.data(), _data.size());
}
int ber_encode_simpleWYE(unsigned char *buf, struct simpleWYE *simpleWYE) {
int offset = 0;
buf[offset++] = 0xA2;
offset += encodeLength(&buf[offset], ber_get_length_simpleWYE(simpleWYE));
offset += ber_encode_simpleCMV(&buf[offset], &simpleWYE->phsA);
offset += ber_encode_simpleCMV(&buf[offset], &simpleWYE->phsB);
offset += ber_encode_simpleCMV(&buf[offset], &simpleWYE->phsC);
return offset;
}
int encodeConstrainedStringEx (OOCTXT* pctxt,
const char* string,
const char* charSet,
ASN1UINT abits, /* aligned char bits */
ASN1UINT ubits, /* unaligned char bits */
ASN1UINT canSetBits)
{
ASN1UINT i, len = strlen(string);
int stat;
/* note: need to save size constraint for use in alignCharStr */
/* because it will be cleared in encodeLength from the context.. */
Asn1SizeCnst* psize = pctxt->pSizeConstraint;
/* Encode length */
stat = encodeLength (pctxt, len);
if (stat < 0) return LOG_ASN1ERR (pctxt, stat);
/* Byte align */
if (alignCharStr (pctxt, len, abits, psize)) {
stat = encodeByteAlign (pctxt);
if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat);
}
/* Encode data */
if (abits >= canSetBits && canSetBits > 4) {
for (i = 0; i < len; i++) {
if ((stat = encodeBits (pctxt, string[i], abits)) != ASN_OK)
return LOG_ASN1ERR (pctxt, stat);
}
}
else if (0 != charSet) {
ASN1UINT nchars = strlen(charSet), pos;
const char* ptr;
for (i = 0; i < len; i++) {
ptr = memchr (charSet, string[i], nchars);
if (0 == ptr)
return LOG_ASN1ERR (pctxt, ASN_E_CONSVIO);
else
pos = ptr - charSet;
if ((stat = encodeBits (pctxt, pos, abits)) != ASN_OK)
return LOG_ASN1ERR (pctxt, stat);
}
}
else return LOG_ASN1ERR (pctxt, ASN_E_INVPARAM);
return stat;
}
int ber_encode_myMod(unsigned char *buf, struct myMod *myMod) {
int offset = 0;
buf[offset++] = 0xA2;
offset += encodeLength(&buf[offset], ber_get_length_myMod(myMod));
offset += BER_ENCODE_CTYPE_ENUM(&buf[offset], (CTYPE_ENUM *) &myMod->ctlVal);
offset += BER_ENCODE_CTYPE_ENUM(&buf[offset], (CTYPE_ENUM *) &myMod->stVal);
offset += BER_ENCODE_CTYPE_QUALITY(&buf[offset], &myMod->q);
offset += BER_ENCODE_CTYPE_TIMESTAMP(&buf[offset], &myMod->t);
return offset;
}
int ber_encode_myPos(unsigned char *buf, struct myPos *myPos) {
int offset = 0;
buf[offset++] = 0xA2;
offset += encodeLength(&buf[offset], ber_get_length_myPos(myPos));
offset += BER_ENCODE_CTYPE_DBPOS(&buf[offset], &myPos->stVal);
offset += BER_ENCODE_CTYPE_QUALITY(&buf[offset], &myPos->q);
offset += BER_ENCODE_CTYPE_TIMESTAMP(&buf[offset], &myPos->t);
offset += BER_ENCODE_CTYPE_BOOLEAN(&buf[offset], &myPos->ctlVal);
return offset;
}
int ber_encode_mySEQ(unsigned char *buf, struct mySEQ *mySEQ) {
int offset = 0;
buf[offset++] = 0xA2;
offset += encodeLength(&buf[offset], ber_get_length_mySEQ(mySEQ));
offset += ber_encode_myCMV(&buf[offset], &mySEQ->c1);
offset += ber_encode_myCMV(&buf[offset], &mySEQ->c2);
offset += ber_encode_myCMV(&buf[offset], &mySEQ->c3);
offset += BER_ENCODE_CTYPE_ENUM(&buf[offset], (CTYPE_ENUM *) &mySEQ->seqT);
return offset;
}
int ber_encode_simpleMV(unsigned char *buf, struct simpleMV *simpleMV) {
int offset = 0;
buf[offset++] = 0xA2;
offset += encodeLength(&buf[offset], ber_get_length_simpleMV(simpleMV));
offset += BER_ENCODE_CTYPE_FLOAT32(&buf[offset], &simpleMV->mag);
offset += BER_ENCODE_CTYPE_QUALITY(&buf[offset], &simpleMV->q);
offset += BER_ENCODE_CTYPE_TIMESTAMP(&buf[offset], &simpleMV->t);
offset += ber_encode_ScaledValueConfig(&buf[offset], &simpleMV->sVC);
return offset;
}
int BER_ENCODE_CTYPE_ENUM(unsigned char *buf, CTYPE_ENUM *value) {
CTYPE_INT16U offset = 0;
CTYPE_INT16U len = BER_GET_LENGTH_CTYPE_ENUM(value);
buf[offset++] = ASN1_TAG_INTEGER;
offset += encodeLength(&buf[offset], len);
#if GOOSE_FIXED_SIZE == 1
ber_encode_integer_fixed_size(&buf[offset], value, SV_GET_LENGTH_INT8);
#else
ber_encode_integer(&buf[offset], value, SV_GET_LENGTH_INT32U); // assuming enum is an int - allows any enum type to be used
#endif
return offset + len;
}
int BER_ENCODE_CTYPE_INT8(unsigned char *buf, CTYPE_INT8 *value) {
CTYPE_INT16U offset = 0;
CTYPE_INT16U len = BER_GET_LENGTH_CTYPE_INT8(value);
buf[offset++] = ASN1_TAG_INTEGER;
offset += encodeLength(&buf[offset], len);
#if GOOSE_FIXED_SIZE == 1
ber_encode_integer_fixed_size(&buf[offset], value, SV_GET_LENGTH_INT8);
#else
ber_encode_integer(&buf[offset], value, SV_GET_LENGTH_INT8);
#endif
return offset + len;
}
int ber_encode_simpleCMV(unsigned char *buf, struct simpleCMV *simpleCMV) {
int offset = 0;
buf[offset++] = 0xA2;
offset += encodeLength(&buf[offset], ber_get_length_simpleCMV(simpleCMV));
offset += ber_encode_simpleVector(&buf[offset], &simpleCMV->cVal);
offset += BER_ENCODE_CTYPE_QUALITY(&buf[offset], &simpleCMV->q);
offset += BER_ENCODE_CTYPE_TIMESTAMP(&buf[offset], &simpleCMV->t);
offset += ber_encode_mySPS(&buf[offset], &simpleCMV->testSecondLayerSDO);
offset += BER_ENCODE_CTYPE_INT32(&buf[offset], &simpleCMV->testInteger);
offset += BER_ENCODE_CTYPE_BOOLEAN(&buf[offset], &simpleCMV->testBoolean);
return offset;
}
int ber_encode_myMV(unsigned char *buf, struct myMV *myMV) {
int offset = 0;
buf[offset++] = 0xA2;
offset += encodeLength(&buf[offset], ber_get_length_myMV(myMV));
offset += ber_encode_myAnalogValue(&buf[offset], &myMV->mag);
offset += BER_ENCODE_CTYPE_QUALITY(&buf[offset], &myMV->q);
offset += BER_ENCODE_CTYPE_TIMESTAMP(&buf[offset], &myMV->t);
offset += ber_encode_ScaledValueConfig(&buf[offset], &myMV->sVC);
offset += BER_ENCODE_CTYPE_INT32(&buf[offset], &myMV->int1);
offset += BER_ENCODE_CTYPE_INT32(&buf[offset], &myMV->int2);
offset += BER_ENCODE_CTYPE_INT32(&buf[offset], &myMV->int3);
return offset;
}
int stats3_compress_bits(range_coder *c,unsigned char *m)
{
unsigned char alpha[1024]; // message with all non alpha/spaces removed
unsigned char lcalpha[1024]; // message with all alpha chars folded to lower-case
/* Use model instead of just packed ASCII */
range_encode_equiprobable(c,2,1); // not raw ASCII
range_encode_symbol(c,&probPackedASCII,2,1); // not packed ASCII
// printf("%f bits to encode model\n",c->entropy);
total_model_bits+=c->entropy;
double lastEntropy=c->entropy;
/* Encode length of message */
encodeLength(c,strlen((char *)m));
// printf("%f bits to encode length\n",c->entropy-lastEntropy);
total_length_bits+=c->entropy-lastEntropy;
lastEntropy=c->entropy;
/* encode any non-ASCII characters */
encodeNonAlpha(c,m);
stripNonAlpha(m,alpha);
int nonAlphaChars=strlen(m)-strlen(alpha);
// printf("%f bits (%d emitted) to encode non-alpha\n",c->entropy-lastEntropy,c->bits_used);
total_nonalpha_bits+=c->entropy-lastEntropy;
lastEntropy=c->entropy;
/* compress lower-caseified version of message */
stripCase(alpha,lcalpha);
encodeLCAlphaSpace(c,lcalpha);
// printf("%f bits (%d emitted) to encode chars\n",c->entropy-lastEntropy,c->bits_used);
total_alpha_bits+=c->entropy-lastEntropy;
lastEntropy=c->entropy;
/* case must be encoded after symbols, so we know how many
letters and where word breaks are.
*/
mungeCase((char *)alpha);
encodeCaseModel1(c,alpha);
// printf("%f bits (%d emitted) to encode case\n",c->entropy-lastEntropy,c->bits_used);
total_case_bits+=c->entropy-lastEntropy;
range_conclude(c);
// printf("%d bits actually used after concluding.\n",c->bits_used);
total_finalisation_bits+=c->bits_used-c->entropy;
if ((!nonAlphaChars)&&c->bits_used>=7*strlen((char *)m))
{
/* Can we code it more efficiently without statistical modelling? */
range_coder *c2=range_new_coder(1024);
range_encode_equiprobable(c2,2,1); // not raw ASCII
range_encode_symbol(c2,&probPackedASCII,2,0); // is packed ASCII
encodeLength(c2,strlen((char *)m));
encodePackedASCII(c2,(char *)m);
range_conclude(c2);
if (c2->bits_used<c->bits_used) {
range_coder_reset(c);
range_encode_equiprobable(c,2,1); // not raw ASCII
range_encode_symbol(c,&probPackedASCII,2,0); // is packed ASCII
encodeLength(c,strlen((char *)m));
encodePackedASCII(c,(char *)m);
range_conclude(c);
// printf("Reverting to raw non-statistical encoding: %d chars in %d bits\n",
// (int)strlen((char *)m),c->bits_used);
}
range_coder_free(c2);
}
if ((c->bits_used>=8*strlen((char*)m))
&&(!(m[0]&0x80)))
{
/* we can't encode it more efficiently than 8-bit raw.
We can only do this is MSB of first char of message is 0, as we use
the first bit of the message to indicate if it is compressed or not. */
int i;
range_coder_reset(c);
for(i=0;m[i];i++) c->bit_stream[i]=m[i];
c->bits_used=8*i;
c->entropy=8*i;
// printf("Reverting to raw 8-bit encoding: used %d bits\n",c->bits_used);
}
return 0;
}
