void LLScriptByteCodeChunk::addFloat(F32 value)
{
U8 temp[4];
S32 offset = 0;
float2bytestream(temp, offset, value);
addBytes(temp, 4);
}
void LLScriptByteCodeChunk::addU16(U16 data)
{
U8 temp[2];
S32 offset = 0;
u162bytestream(temp, offset, data);
addBytes(temp, 2);
}
void LLScriptByteCodeChunk::addInteger(S32 value)
{
U8 temp[4];
S32 offset = 0;
integer2bytestream(temp, offset, value);
addBytes(temp, 4);
}
dBuffer::dBuffer(t_byteCP _buffer, t_int const _bufferSize)
: contents(0),
current_size(0),
read_counter(0),
lastInsertedBytes(0),
lastRemovedBytes(0)
{
addBytes(_buffer, _bufferSize);
}
R_API bool r_sign_add_anal(RAnal *a, const char *name, ut64 size, const ut8 *bytes, ut64 at) {
ut8 *mask = NULL;
bool retval = true;
mask = r_anal_mask (a, size, bytes, at);
retval = addBytes (a, name, size, bytes, mask);
free (mask);
return retval;
}
void QPF::addHeader(QFontEngine *fontEngine)
{
QFontEngineQPF::Header *header = reinterpret_cast<QFontEngineQPF::Header *>(addBytes(sizeof(QFontEngineQPF::Header)));
header->magic[0] = 'Q';
header->magic[1] = 'P';
header->magic[2] = 'F';
header->magic[3] = '2';
if (options & RenderGlyphs)
header->lock = 0xffffffff;
else
header->lock = 0;
header->majorVersion = QFontEngineQPF::CurrentMajorVersion;
header->minorVersion = QFontEngineQPF::CurrentMinorVersion;
header->dataSize = 0;
int oldSize = qpf.size();
addTaggedString(QFontEngineQPF::Tag_FontName, fontEngine->fontDef.family.toUtf8());
QFontEngine::FaceId face = fontEngine->faceId();
addTaggedString(QFontEngineQPF::Tag_FileName, face.filename);
addTaggedUInt32(QFontEngineQPF::Tag_FileIndex, face.index);
{
const QByteArray head = fontEngine->getSfntTable(MAKE_TAG('h', 'e', 'a', 'd'));
const quint32 revision = qFromBigEndian<quint32>(reinterpret_cast<const uchar *>(head.constData()) + 4);
addTaggedUInt32(QFontEngineQPF::Tag_FontRevision, revision);
}
addTaggedQFixed(QFontEngineQPF::Tag_Ascent, fontEngine->ascent());
addTaggedQFixed(QFontEngineQPF::Tag_Descent, fontEngine->descent());
addTaggedQFixed(QFontEngineQPF::Tag_Leading, fontEngine->leading());
addTaggedQFixed(QFontEngineQPF::Tag_XHeight, fontEngine->xHeight());
addTaggedQFixed(QFontEngineQPF::Tag_AverageCharWidth, fontEngine->averageCharWidth());
addTaggedQFixed(QFontEngineQPF::Tag_MaxCharWidth, QFixed::fromReal(fontEngine->maxCharWidth()));
addTaggedQFixed(QFontEngineQPF::Tag_LineThickness, fontEngine->lineThickness());
addTaggedQFixed(QFontEngineQPF::Tag_MinLeftBearing, QFixed::fromReal(fontEngine->minLeftBearing()));
addTaggedQFixed(QFontEngineQPF::Tag_MinRightBearing, QFixed::fromReal(fontEngine->minRightBearing()));
addTaggedQFixed(QFontEngineQPF::Tag_UnderlinePosition, fontEngine->underlinePosition());
addTaggedUInt8(QFontEngineQPF::Tag_PixelSize, fontEngine->fontDef.pixelSize);
addTaggedUInt8(QFontEngineQPF::Tag_Weight, fontEngine->fontDef.weight);
addTaggedUInt8(QFontEngineQPF::Tag_Style, fontEngine->fontDef.style);
QByteArray writingSystemBitField = getWritingSystems(fontEngine);
if (!writingSystemBitField.isEmpty())
addTaggedString(QFontEngineQPF::Tag_WritingSystems, writingSystemBitField);
addTaggedUInt8(QFontEngineQPF::Tag_GlyphFormat, QFontEngineQPF::AlphamapGlyphs);
addTaggedString(QFontEngineQPF::Tag_EndOfHeader, QByteArray());
align4();
header = reinterpret_cast<QFontEngineQPF::Header *>(qpf.data());
header->dataSize = qToBigEndian<quint16>(qpf.size() - oldSize);
}
ExceptionOr<void> CryptoAlgorithmSHA1::digest(const CryptoAlgorithmParametersDeprecated&, const CryptoOperationData& data, VectorCallback&& callback, VoidCallback&& failureCallback)
{
auto digest = CryptoDigest::create(CryptoDigest::Algorithm::SHA_1);
if (!digest) {
failureCallback();
return { };
}
digest->addBytes(data.first, data.second);
callback(digest->computeHash());
return { };
}
dBuffer& dBuffer::operator+=(dBuffer const& _dbuf)
{
dBuffer cdbuf = _dbuf;
t_uint src_size = cdbuf.size();
t_byte space[src_size];
cdbuf.getBytes(space, src_size);
addBytes(space, src_size);
return *this;
}
void CryptoAlgorithmSHA1::digest(Vector<uint8_t>&& message, VectorCallback&& callback, ExceptionCallback&& exceptionCallback, ScriptExecutionContext& context, WorkQueue& workQueue)
{
auto digest = CryptoDigest::create(CryptoDigest::Algorithm::SHA_1);
if (!digest) {
exceptionCallback(OperationError);
return;
}
context.ref();
workQueue.dispatch([digest = WTFMove(digest), message = WTFMove(message), callback = WTFMove(callback), &context]() mutable {
digest->addBytes(message.data(), message.size());
auto result = digest->computeHash();
context.postTask([callback = WTFMove(callback), result = WTFMove(result)](ScriptExecutionContext& context) {
callback(result);
context.deref();
});
});
}
void Serializer::addBytes(const uint8_t *newbuffer, size_t bytesRead, std::function<void(Serializer&)> onReceive) {
bool lengthKnown = false;
for (uint8_t b : *buffer) {
if ((b & 0x80) == 0) {
lengthKnown = true;
break;
}
}
if (!lengthKnown) {
// Pre-read buffer until we know the desired length
while (bytesRead) {
buffer->push_back(*newbuffer++);
bytesRead--;
if ((buffer->back() & 0x80) == 0x00) {
lengthKnown = true;
break;
}
}
}
if (!lengthKnown) {
// Buffer used and still no length known
return;
}
offset = 0;
size_t length = read<size_t>(*this);
buffer->reserve(length+offset);
if (buffer->size() + bytesRead >= length + offset) {
size_t bytesToGetFromNewbuffer = (length + offset) - (buffer->size());
buffer->insert(buffer->end(), newbuffer, newbuffer + bytesToGetFromNewbuffer);
newbuffer += bytesToGetFromNewbuffer;
bytesRead -= bytesToGetFromNewbuffer;
onReceive(*this);
buffer->clear();
addBytes(newbuffer, bytesRead, onReceive);
} else {
buffer->insert(buffer->end(), newbuffer, newbuffer + bytesRead);
}
}
R_API bool r_sign_add_bytes(RAnal *a, const char *name, ut64 size, const ut8 *bytes, const ut8 *mask) {
return addBytes (a, name, size, bytes, mask);
}
static void send_dhcp_message (void) {
uint8_t allOnes[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
memset(gPB, 0, UDP_DATA_P + sizeof( DHCPdata ));
EtherCard::udpPrepare(DHCP_DEST_PORT,
(dhcpState == DHCP_STATE_BOUND ? EtherCard::dhcpip : allOnes),
DHCP_SRC_PORT); // SRC<->DST ??
if (dhcpState != DHCP_STATE_BOUND)
EtherCard::copyMac(gPB + ETH_DST_MAC, allOnes); //force broadcast mac
// Build DHCP Packet from buf[UDP_DATA_P]
DHCPdata *dhcpPtr = (DHCPdata*) (gPB + UDP_DATA_P);
dhcpPtr->op = DHCP_BOOTREQUEST;
dhcpPtr->htype = 1;
dhcpPtr->hlen = 6;
dhcpPtr->xid = currentXid;
if (dhcpState == DHCP_STATE_BOUND) {
EtherCard::copyIp(dhcpPtr->ciaddr, EtherCard::myip);
}
EtherCard::copyMac(dhcpPtr->chaddr, EtherCard::mymac);
// options defined as option, length, value
bufPtr = gPB + UDP_DATA_P + sizeof( DHCPdata );
// DHCP magic cookie, followed by message type
static byte cookie[] = { 99, 130, 83, 99, 53, 1 };
addBytes(sizeof cookie, cookie);
// addToBuf(53); // DHCP_STATE_SELECTING, DHCP_STATE_REQUESTING
// addToBuf(1); // Length
addToBuf(dhcpState == DHCP_STATE_INIT ? DHCP_DISCOVER : DHCP_REQUEST);
// Client Identifier Option, this is the client mac address
addToBuf(61); // Client identifier
addToBuf(7); // Length
addToBuf(0x01); // Ethernet
addBytes(6, EtherCard::mymac);
addToBuf(12); // Host name Option
addToBuf(10);
addBytes(10, (byte*) hostname);
if( dhcpState == DHCP_STATE_SELECTING) {
addToBuf(50); // Request IP address
addToBuf(4);
addBytes(4, EtherCard::myip);
// Request using server ip address
addToBuf(54); // Server IP address
addToBuf(4);
addBytes(4, EtherCard::dhcpip);
}
// Additional info in parameter list - minimal list for what we need
static byte tail[] = { 55, 3, 1, 3, 6, 255 };
addBytes(sizeof tail, tail);
// addToBuf(55); // Parameter request list
// addToBuf(3); // Length
// addToBuf(1); // Subnet mask
// addToBuf(3); // Route/Gateway
// addToBuf(6); // DNS Server
// addToBuf(255); // end option
// packet size will be under 300 bytes
EtherCard::udpTransmit((bufPtr - gPB) - UDP_DATA_P);
}
void ab_addBytes_x(autoBlock_t *i, autoBlock_t *block)
{
addBytes(i, block);
releaseAutoBlock(block);
}
// Build and transmit a DHCP message.
// The argument is either DHCP_MSG_DISCOVER or DHCP_MSG_REQUEST
static void dhcp_send (byte request, byte flg) {
// How should this error be propagated ???
if (!EtherCard::isLinkUp())
return;
// Start with a clean buffer
memset(gPB, 0, UDP_DATA_P + sizeof(DHCPdata));
EtherCard::udpPrepare(DHCP_DEST_PORT, EtherCard::myip, DHCP_SRC_PORT);
EtherCard::copyMac(gPB + ETH_SRC_MAC, EtherCard::mymac);
EtherCard::copyMac(gPB + ETH_DST_MAC, allOnes);
gPB[IP_TOTLEN_L_P] = 0x82;
gPB[IP_PROTO_P] = IP_PROTO_UDP_V;
// If we don't know where we're going, go everywhere
if (flg)
EtherCard::copyIp(gPB + IP_DST_P, allOnes);
else
EtherCard::copyIp(gPB + IP_DST_P, EtherCard::dhcpip);
// Build a DHCP Packet from buf[UDP_DATA_P]
DHCPdata *dhcpPtr = (DHCPdata *) (gPB + UDP_DATA_P);
dhcpPtr->op = DHCP_BOOTREQUEST;
dhcpPtr->htype = 1;
dhcpPtr->hlen = 6;
dhcpPtr->hops = 0;
dhcpPtr->xid = currentXid;
dhcpPtr->secs = 0;
dhcpPtr->flags = flg ? 0x80 : 0; // Set broadcast flag
//dhcpPtr->ciaddr
//dhcpPtr->yiaddr
//dhcpPtr->siaddr
//dhcpPtr->giaddr
EtherCard::copyMac(dhcpPtr->chaddr, EtherCard::mymac);
//dhcpPtr->sname
//dhcpPtr->file
// Write the cookie 0x63,0x82,0x53,0x63 into the end of the header
static byte cookie[] = { 99, 130, 83, 99 };
bufPtr = gPB + UDP_DATA_P + sizeof(DHCPdata) - sizeof(cookie);
addBytes(sizeof(cookie), cookie);
// Options are defined as option, length, value
addToBuf(53); // DHCP message type
addToBuf(1); // Length
addToBuf(request);// DHCP_MSG_DISCOVER, DHCP_MSG_REQUEST
// Client Identifier Option, this is the client mac address
addToBuf(61); // Client identifier
addToBuf(7); // Length
addToBuf(0x01); // Ethernet
addBytes(6, EtherCard::mymac);
addToBuf(12); // Host name Option
byte len = (byte) strlen(hostname);
addToBuf(len);
addBytes(len, (byte *) hostname);
if (request == DHCP_MSG_REQUEST) {
addToBuf(50); // Request IP address
addToBuf(4);
addBytes(4, EtherCard::myip);
addToBuf(54); // Server IP address
addToBuf(4);
addBytes(4, EtherCard::dhcpip);
}
// Additional info in parameter list - minimal list for what we need
// addToBuf(55); // Parameter request list
// addToBuf(3); // Length
// addToBuf(1); // Subnet mask
// addToBuf(3); // Route/Gateway
// addToBuf(6); // DNS Server
// addToBuf(255); // end option
static byte tail[] = { 55, 3, 1, 3, 6, 255 };
addBytes(sizeof(tail), tail);
// The packet size will be under 300 bytes
EtherCard::udpTransmit((bufPtr - gPB) - UDP_DATA_P);
return;
}
void ab_addLine(autoBlock_t *i, char *line)
{
autoBlock_t gab;
addBytes(i, gndBlockLineVar(line, gab));
}
void ab_addFollowBytes(autoBlock_t *i, autoBlock_t *block, uint start)
{
autoBlock_t gab;
addBytes(i, gndFollowBytesVar(block, start, gab));
}
void ab_addSubBytes(autoBlock_t *i, autoBlock_t *block, uint start, uint size)
{
autoBlock_t gab;
addBytes(i, gndSubBytesVar(block, start, size, gab));
}
void ab_addBlock(autoBlock_t *i, void *block, uint size)
{
autoBlock_t gab;
addBytes(i, gndBlockVar(block, size, gab));
}
SigNat sign(PublicKey group, RogueKey rogue, Secret secret, Cert cert, Message msg)
{
char bsn[MAX_CHAR_ARRAY_LENGTH], m[MAX_CHAR_ARRAY_LENGTH];
char error[MAX_CHAR_ARRAY_LENGTH],c_h[MAX_CHAR_ARRAY_LENGTH];
char hash[MAX_CHAR_ARRAY_LENGTH], inner[MAX_CHAR_ARRAY_LENGTH];
BigInt n_v, c, sv, sf0, sf1, se, see, sew, sr, ser, sw;
Origin b;
BigInt n,gPrime,g,h,r0,r1,s;
BigInt biga,e, p2;
BigInt f0,f1,v;
Tuple wr,rf0rf1,rwrr,rewrer;
BigInt bigt1, bigt2, temp1, temp2, temp3, temp4, temp5, temp6, temp7, w, r;
BigInt zeta,bign_V,rf0,rf1, rv, bigt2inv, tilde_TPrime2,n_t;
BigInt tilde_T1t, tilde_rf, tilde_N_V,rw,rr,re,ree,rew, rer,hinv, tilde_T1, tilde_T2;
Hash hashPub, hashHost ,hashTpm1, hashTpm2;
Responses ss;
SigNat signat;
strcpy(bsn,msg.bsn); strcpy(m,msg.m);
b = msg.b; n_v = msg.n_v;
if(noOfBits(n_v) > hash_bits){
strcpy(error,"n_v out of bounds");
Abort(error);
}
n=group.n; gPrime=group.gPrime; g=group.g; h=group.h;
r0=group.r0; r1=group.r1; s=group.s;
biga = cert.biga; e = cert.e;
f0 = secret.f; f1=secret.s; v=secret.t;
wr = pick2(rsa_modulus_bits+distribution_bits);
w = wr.r; r = wr.m;
bigt1 = BImodMult(biga,BImodPower(h,wr.r,n),n);
temp1 = BIpower(g,w); temp2 = BIpower(h,e); temp3 = BIpower(gPrime,r);
temp4 = BImul(temp1, temp2); temp5 = BImul(temp4, temp3);
bigt2 = BImod(temp5,n);
zeta = base(bsn,rogue);
bign_V = tag(rogue,zeta,f0,f1);
rv = pick(random_bits+distribution_bits+hash_bits);
rf0rf1 = pick2(halfkeyBits+distribution_bits+hash_bits);
rf0 = rf0rf1.r; rf1 = rf0rf1.m;
temp1 = BIpower(r0,rf0); temp2 = BIpower(r1,rf1); temp3 = BIpower(s,rv);
temp4 = BImul(temp1, temp2); temp5 = BImul(temp4, temp3);
tilde_T1t = BImod(temp5,n);
temp1 = BIshiftLeft(rf1,halfkeyBits);
temp2 = BIadd(rf0, temp1);
tilde_rf = BImod(temp2,rogue.rho);
tilde_N_V = BImodPower(zeta,tilde_rf,rogue.bigGamma);
re = pick(prime_random_bits+distribution_bits+hash_bits);
ree = pick(2*prime_total_bits+distribution_bits+hash_bits+1);
rwrr = pick2(rsa_modulus_bits+2*distribution_bits+hash_bits);
rw = rwrr.r; rr = rwrr.m;
rewrer = pick2(prime_total_bits+rsa_modulus_bits+2*distribution_bits+hash_bits+1);
rew = rewrer.r; rer = rewrer.m;
hinv = BImodInv(h,n);
temp1 = tilde_T1t; temp2 = BIpower(bigt1,re); temp3 = BIpower(hinv,rew);
temp4 = BImul(temp1, temp2); temp5 = BImul(temp4, temp3);
tilde_T1 = BImod(temp5,n);
temp1 = BIpower(g,rw); temp2 = BIpower(h,re); temp3 = BIpower(gPrime,rr);
temp4 = BImul(temp1, temp2); temp5 = BImul(temp4, temp3);
tilde_T2 = BImod(temp5,n);
bigt2inv = BImodInv(bigt2,n);
temp1 = BIpower(bigt2inv,re); temp2 = BIpower(g,rew); temp3 = BIpower(h,ree); temp4 = BIpower(gPrime,rer);
temp5 = BImul(temp1, temp2); temp6 = BImul(temp5, temp3); temp7 = BImul(temp6, temp4);
tilde_TPrime2 = BImod(temp7,n);
//hash public inputs
hashPub = getSha1Hash();
addBI(&hashPub,group.n); addBI(&hashPub,group.g); addBI(&hashPub,group.gPrime); addBI(&hashPub,group.h);
addBI(&hashPub,group.r0); addBI(&hashPub,group.r1); addBI(&hashPub,group.s); addBI(&hashPub,group.z);
addBI(&hashPub,rogue.gamma); addBI(&hashPub,rogue.bigGamma); addBI(&hashPub,rogue.rho);
addBI(&hashPub,zeta); addBI(&hashPub,bigt1); addBI(&hashPub,bigt2); addBI(&hashPub,bign_V);
strcpy(hash,hashResult(hashPub));
//hash host inputs
hashHost = getSha1Hash();
addBI(&hashHost,tilde_T1); addBI(&hashHost,tilde_T2); addBI(&hashHost,tilde_TPrime2);
addBI(&hashHost,tilde_N_V); addBI(&hashHost,n_v);
strcpy(c_h,hashResult(hashHost));
n_t = pick(distribution_bits);
hashTpm1 = getSha1Hash();
addBytes(&hashTpm1,c_h);
addBI(&hashTpm1,n_t);
strcpy(inner,hashResult(hashTpm1));
hashTpm2 = getSha1Hash();
addBytes(&hashTpm2,inner);
if(b == Card)
addByte(&hashTpm2,0);
else if (b == Verifier)
addByte(&hashTpm2,1);
else
;
addBytes(&hashTpm2, m);
c = BItoNumber(hashResult(hashTpm2));
sv = rval(rv,v,c);
sf0 = rval(rf0,f0,c);
sf1 = rval(rf1,f1,c);
p2 = BIshiftLeft(BItoNumber("1"),prime_total_bits-1);
se = rval(re,BIsub(e, p2),c);
see = rval(ree,BImul(e,e),c);
sw = rval(rw,w,c);
sew = rval(rew,BImul(e,w),c);
sr = rval(rr,r,c);
ser = rval(rer,BImul(e,r),c);
ss.sv = sv;
ss.sf0 = sf0;
ss.sf1 = sf1;
ss.se = se;
ss.see = see;
ss.sw = sw;
ss.sew = sew;
ss.sr = sr;
ss.ser = ser;
signat.zeta = zeta;
signat.bigt1 = bigt1;
signat.bigt2 = bigt2;
signat.bign_V = bign_V;
signat.c = c;
signat.n_t = n_t;
signat.ss = ss;
return signat;
}
void ProtocolStatus::sendStatusString()
{
auto output = OutputMessagePool::getOutputMessage();
setRawMessages(true);
pugi::xml_document doc;
pugi::xml_node decl = doc.prepend_child(pugi::node_declaration);
decl.append_attribute("version") = "1.0";
pugi::xml_node tsqp = doc.append_child("tsqp");
tsqp.append_attribute("version") = "1.0";
pugi::xml_node serverinfo = tsqp.append_child("serverinfo");
uint64_t uptime = (OTSYS_TIME() - ProtocolStatus::start) / 1000;
serverinfo.append_attribute("uptime") = std::to_string(uptime).c_str();
serverinfo.append_attribute("ip") = g_config.getString(ConfigManager::IP).c_str();
serverinfo.append_attribute("servername") = g_config.getString(ConfigManager::SERVER_NAME).c_str();
serverinfo.append_attribute("port") = std::to_string(g_config.getNumber(ConfigManager::LOGIN_PORT)).c_str();
serverinfo.append_attribute("location") = g_config.getString(ConfigManager::LOCATION).c_str();
serverinfo.append_attribute("url") = g_config.getString(ConfigManager::URL).c_str();
serverinfo.append_attribute("server") = STATUS_SERVER_NAME;
serverinfo.append_attribute("version") = STATUS_SERVER_VERSION;
serverinfo.append_attribute("client") = CLIENT_VERSION_STR;
pugi::xml_node owner = tsqp.append_child("owner");
owner.append_attribute("name") = g_config.getString(ConfigManager::OWNER_NAME).c_str();
owner.append_attribute("email") = g_config.getString(ConfigManager::OWNER_EMAIL).c_str();
pugi::xml_node players = tsqp.append_child("players");
players.append_attribute("online") = std::to_string(g_game.getPlayersOnline()).c_str();
players.append_attribute("max") = std::to_string(g_config.getNumber(ConfigManager::MAX_PLAYERS)).c_str();
players.append_attribute("peak") = std::to_string(g_game.getPlayersRecord()).c_str();
pugi::xml_node monsters = tsqp.append_child("monsters");
monsters.append_attribute("total") = std::to_string(g_game.getMonstersOnline()).c_str();
pugi::xml_node npcs = tsqp.append_child("npcs");
npcs.append_attribute("total") = std::to_string(g_game.getNpcsOnline()).c_str();
pugi::xml_node rates = tsqp.append_child("rates");
rates.append_attribute("experience") = std::to_string(g_config.getNumber(ConfigManager::RATE_EXPERIENCE)).c_str();
rates.append_attribute("skill") = std::to_string(g_config.getNumber(ConfigManager::RATE_SKILL)).c_str();
rates.append_attribute("loot") = std::to_string(g_config.getNumber(ConfigManager::RATE_LOOT)).c_str();
rates.append_attribute("magic") = std::to_string(g_config.getNumber(ConfigManager::RATE_MAGIC)).c_str();
rates.append_attribute("spawn") = std::to_string(g_config.getNumber(ConfigManager::RATE_SPAWN)).c_str();
pugi::xml_node map = tsqp.append_child("map");
map.append_attribute("name") = g_config.getString(ConfigManager::MAP_NAME).c_str();
map.append_attribute("author") = g_config.getString(ConfigManager::MAP_AUTHOR).c_str();
uint32_t mapWidth, mapHeight;
g_game.getMapDimensions(mapWidth, mapHeight);
map.append_attribute("width") = std::to_string(mapWidth).c_str();
map.append_attribute("height") = std::to_string(mapHeight).c_str();
pugi::xml_node motd = tsqp.append_child("motd");
motd.text() = g_config.getString(ConfigManager::MOTD).c_str();
std::ostringstream ss;
doc.save(ss, "", pugi::format_raw);
std::string data = ss.str();
output->addBytes(data.c_str(), data.size());
send(output);
disconnect();
}
void ab_addBytes(autoBlock_t *i, autoBlock_t *block)
{
addBytes(i, block);
}
