void Message::prepare()
{
if( !packet ) createPacket();
size_t totalSize = (size_t) ms->position;
size_t bufSize = GetCompressionBufferSize(totalSize);
enet_packet_resize(packet, bufSize);
MemoryStream pms;
StreamMemoryInit(&pms);
StreamMemorySetRawBuffer(&pms, packet->data);
EncodeVariableInteger(&pms, id);
StreamWrite(&pms, &flags, sizeof(flags));
if( GetBitFlag(flags, MessageFlags::Compressed) )
{
uint8* in = &ms->data[0];
uint8* out = pms.buffer + pms.position;
int32 length = fastlz_compress_level(1, in, totalSize, out);
pms.position += length;
}
else
{
enet_packet_resize(packet, totalSize + pms.position);
StreamWrite(&pms, &ms->data[0], totalSize);
}
packet->dataLength = (size_t) pms.position;
}
void ntlm_write_ntlm_v2_client_challenge(PStream s, NTLMv2_CLIENT_CHALLENGE* challenge)
{
ULONG length;
StreamWrite_UINT8(s, challenge->RespType);
StreamWrite_UINT8(s, challenge->HiRespType);
StreamWrite_UINT16(s, challenge->Reserved1);
StreamWrite_UINT32(s, challenge->Reserved2);
StreamWrite(s, challenge->Timestamp, 8);
StreamWrite(s, challenge->ClientChallenge, 8);
StreamWrite_UINT32(s, challenge->Reserved3);
length = ntlm_av_pair_list_length(challenge->AvPairs);
StreamWrite(s, challenge->AvPairs, length);
}
void Message::setPacket(ENetPacket* packet)
{
MemoryStream pms;
StreamMemoryInit(&pms);
StreamMemorySetRawBuffer(&pms, packet->data);
uint64 id;
if( !DecodeVariableInteger(&pms, id) )
return;
this->id = (MessageId) id;
this->packet = packet;
StreamReadBuffer(&pms, &flags, sizeof(MessageFlags::Enum));
uint8* in = packet->data + pms.position;
size_t inSize = packet->dataLength - (size_t) pms.position;
if( GetBitFlag(flags, MessageFlags::Compressed) )
{
size_t bufSize = GetCompressionBufferSize(packet->dataLength);
StreamResize(ms, bufSize);
int32 length = fastlz_decompress(in, inSize, &ms->data[0], ms->data.size());
StreamResize(ms, length);
}
else
{
StreamResize(ms, inSize);
StreamWrite(ms, in, inSize);
}
freePacket = true;
}
void ntlm_output_restriction_encoding(NTLM_CONTEXT* context)
{
PStream s;
AV_PAIR* restrictions = &context->av_pairs->Restrictions;
BYTE machineID[32] =
"\x3A\x15\x8E\xA6\x75\x82\xD8\xF7\x3E\x06\xFA\x7A\xB4\xDF\xFD\x43"
"\x84\x6C\x02\x3A\xFD\x5A\x94\xFE\xCF\x97\x0F\x3D\x19\x2C\x38\x20";
restrictions->value = malloc(48);
restrictions->length = 48;
s = PStreamAllocAttach(restrictions->value, restrictions->length);
StreamWrite_UINT32(s, 48); /* Size */
StreamZero(s, 4); /* Z4 (set to zero) */
/* IntegrityLevel (bit 31 set to 1) */
StreamWrite_UINT8(s, 1);
StreamZero(s, 3);
StreamWrite_UINT32(s, 0x00002000); /* SubjectIntegrityLevel */
StreamWrite(s, machineID, 32); /* MachineID */
PStreamFreeDetach(s);
}
void CXMLObject::write ( RCFile f ) {
int i;
f.CreateWrite ( objTag );
f.CreateWrite ( objData );
f.WriteInt ( &nObjects );
for (i=0;i<nObjects;i++)
StreamWrite ( f,object[i] );
}
void ntlm_write_version_info(PStream s, NTLM_VERSION_INFO* versionInfo)
{
StreamWrite_UINT8(s, versionInfo->ProductMajorVersion); /* ProductMajorVersion (1 byte) */
StreamWrite_UINT8(s, versionInfo->ProductMinorVersion); /* ProductMinorVersion (1 byte) */
StreamWrite_UINT16(s, versionInfo->ProductBuild); /* ProductBuild (2 bytes) */
StreamWrite(s, versionInfo->Reserved, sizeof(versionInfo->Reserved)); /* Reserved (3 bytes) */
StreamWrite_UINT8(s, versionInfo->NTLMRevisionCurrent); /* NTLMRevisionCurrent (1 byte) */
}
static size_t HandleHTTP(void* ptr, size_t size, size_t nmemb, void* userdata)
{
WebStream* ws = (WebStream*) userdata;
MemoryStream* ms = &ws->ms;
ws->downloaded = true;
size_t total = size*nmemb;
int64 written = StreamWrite(ms, (uint8*) ptr, total);
return (size_t) written;
}
/*++
StreamPuts
Writes a string to an I/O stream.
Arguments:
stream - Pointer to a stream.
str - Pointer to a null-terminated string.
Return Values:
Returns an APR status code.
--*/
apr_status_t
StreamPuts(
STREAM *stream,
const char *str
)
{
ASSERT(stream != NULL);
ASSERT(str != NULL);
return StreamWrite(stream, (const apr_byte_t *)str, strlen(str), NULL);
}
void CSSGraph::write ( RCFile f ) {
int i;
int Version=1;
f.WriteInt ( &Version );
f.CreateWrite ( name );
f.WriteTerLine ( devChain,False );
f.WriteInt ( &nVertices );
for (i=0;i<nVertices;i++)
StreamWrite ( f,Vertex[i] );
}
bool CPlist::Serialize( QTextStream * out, int &level )
{
xmlHelper * helper = xmlHelper::Instance();
StreamWrite( out, "<plist version=\"1.0\">" );
StreamWriteLevUp( out, oTag( helper->getStringByKeyDef(kv_Dict) ) );
StreamWrite( out, xmlHelper::wrapKeyValInKeyVal( kv_key, kv_hexs ) );
StreamWriteLevUp( out, oTag( helper->getStringByKeyDef(kv_Array) ) );
map< int, CCell* >::const_iterator it;
for( it = arr.begin(); it != arr.end(); ++it )
{
it->second->Serialize( out, level );
}
StreamWriteLevDown( out, cTag( helper->getStringByKeyDef(kv_Array) ) );
params.Serialize( out, level );
StreamWriteLevDown( out, cTag( helper->getStringByKeyDef(kv_Dict) ) );
StreamWriteLevDown( out, "</plist>" );
return true;
}
int GetPattern(struct sockaddr_in ServerID, char *patternbuf, int pattern_max, struct htx_data * stats)
{
SOCKET ToServerSock;
int rc;
int i;
struct CoordMsg CMsg;
int pflength;
char msg_text[1024];
ToServerSock = SetUpConnect(&ServerID, stats, 0);
memset(&CMsg, '\0', sizeof(CMsg));
CMsg.msg_type = htonl(CM_REQ_PATTERN);
CMsg.ID.Wsize.size = htonl((uint32_t)pattern_max);
rc = StreamWrite(ToServerSock, (char *) &CMsg, sizeof(CMsg));
if(rc == -1) {
sprintf(msg_text, "GetPattern: Error writing to Server - %s\n", STRERROR(errno));
hxfmsg(stats, HTXERROR(EX_PATT1,ERRNO), HTX_HE_SOFT_ERROR, msg_text);
HE_exit(EX_PAT1);
}
rc = StreamRead(ToServerSock, (char *) &CMsg, sizeof(CMsg));
CMsg.msg_type = ntohl(CMsg.msg_type);
if(CMsg.msg_type != CM_PATTERN) {
sprintf(msg_text, "GetPattern: Unable to obtain pattern file - %s\n", STRERROR(errno));
hxfmsg(stats, HTXERROR(EX_PATT2,ERRNO), HTX_HE_SOFT_ERROR, msg_text);
HE_exit(EX_PAT2);
}
pflength = ntohl(CMsg.ID.Wsize.size);
if(pflength > pattern_max || pflength <= 0) {
sprintf(msg_text, "GetPattern: Server wrote too many characters - %s\n", STRERROR(errno));
hxfmsg(stats, HTXERROR(EX_PATT3,ERRNO), HTX_HE_SOFT_ERROR, msg_text);
HE_exit(EX_PAT3);
}
rc = StreamRead(ToServerSock, (char *) patternbuf, pflength);
if(rc != pflength) {
sprintf(msg_text, "GetPattern: Unable to receive pattern file - %s\n", STRERROR(errno));
hxfmsg(stats, HTXERROR(EX_PATT4,ERRNO), HTX_HE_SOFT_ERROR, msg_text);
HE_exit(EX_PAT4);
}
closesocket(ToServerSock);
/********************************************************************/
/* Fill remainder of patternbuf. */
/********************************************************************/
for(i=pflength; i<pattern_max; i++)
patternbuf[i] = patternbuf[i%pflength];
return pattern_max;
}
void ImageWriter::save( Image* image, Stream* stream )
{
#ifdef ENABLE_IMAGE_WRITER
if( !stream ) return;
// TODO: sleep until the image is not loaded
if( !image->isLoaded() ) return;
if( image->isCompressed() )
output = image->getBuffer();
else if( !convert(image) )
return;
if( output.empty() ) return;
StreamWrite(stream, output.data(), output.size());
#endif
}
void ShutdownTest(struct sockaddr_in ServerID, struct htx_data * stats)
{
SOCKET ToServerSock;
struct CoordMsg CMsg;
int rc;
ToServerSock = SetUpConnect(&ServerID, stats, SH_FORCE);
memset(&CMsg, '\0', sizeof(CMsg));
CMsg.msg_type = htonl(CM_SHUTDOWN);
rc = StreamWrite(ToServerSock, (char *) &CMsg, sizeof(CMsg));
if(rc == -1) {
/* I am shutting down don't care about error here. just exit.
sprintf(msg_text, "ShutdownTest: Error writing to Server - %s\n", STRERROR(errno));
hxfmsg(stats, HTXERROR(EX_SHUTD,ERRNO), HTX_HE_SOFT_ERROR, msg_text);
*/
}
closesocket(ToServerSock);
}
bool CParametres::Serialize( QTextStream * out, int &level )
{
xmlHelper * helper = xmlHelper::Instance();
StreamWrite( out, xmlHelper::wrapKeyValInKeyVal( kv_key, kv_parametres ) );
StreamWriteLevUp( out, oTag( helper->getStringByKeyDef(kv_Dict) ) );
StreamWrite( out, xmlHelper::wrapKeyValInKeyVal( kv_key, kv_steps) );
StreamWrite( out, xmlHelper::wrapStringInKeyVal( kv_Integer, xmlHelper::getStringByInteger(_steps)) );
StreamWrite( out, xmlHelper::wrapKeyValInKeyVal( kv_key, kv_horizontalNumber) );
StreamWrite( out, xmlHelper::wrapStringInKeyVal( kv_Integer, xmlHelper::getStringByInteger(_horizontalNumber)) );
StreamWrite( out, xmlHelper::wrapKeyValInKeyVal( kv_key, kv_verticalNumber) );
StreamWrite( out, xmlHelper::wrapStringInKeyVal( kv_Integer, xmlHelper::getStringByInteger(_verticalNumber)) );
StreamWriteLevDown( out, cTag( helper->getStringByKeyDef(kv_Dict) ) );
return true;
}
void ntlm_output_target_name(NTLM_CONTEXT* context)
{
PStream s;
AV_PAIR* TargetName = &context->av_pairs->TargetName;
/*
* TODO: No idea what should be set here (observed MsvAvTargetName = MsvAvDnsComputerName or
* MsvAvTargetName should be the name of the service be accessed after authentication)
* here used: "TERMSRV/192.168.0.123" in unicode (Dmitrij Jasnov)
*/
BYTE name[42] =
"\x54\x00\x45\x00\x52\x00\x4d\x00\x53\x00\x52\x00\x56\x00\x2f\x00\x31\x00\x39\x00\x32"
"\x00\x2e\x00\x31\x00\x36\x00\x38\x00\x2e\x00\x30\x00\x2e\x00\x31\x00\x32\x00\x33\x00";
TargetName->length = 42;
TargetName->value = (BYTE*) malloc(TargetName->length);
s = PStreamAllocAttach(TargetName->value, TargetName->length);
StreamWrite(s, name, TargetName->length);
PStreamFreeDetach(s);
}
int GetRules(struct sockaddr_in ServerID, struct rule_format rule[], int max_rules, struct htx_data * stats)
{
SOCKET ToServerSock;
struct CoordMsg CMsg;
int rc;
int i;
int NoStanzas;
char msg[1024];
errno = 0;
ToServerSock = SetUpConnect(&ServerID, stats, 0);
memset(&CMsg, '\0', sizeof(CMsg));
CMsg.msg_type = htonl(CM_REQ_RULES);
CMsg.ID.Wsize.size = htonl((uint32_t)sizeof(struct rule_format));
rc = StreamWrite(ToServerSock, (char *) &CMsg, sizeof(CMsg));
if(rc == -1) {
sprintf(msg, "GetRules: Error writing to Server - %s\n", STRERROR(errno));
hxfmsg(stats, HTXERROR(EX_RULE1,ERRNO), HTX_HE_SOFT_ERROR, msg);
HE_exit(EX_RULE1);
}
StreamRead(ToServerSock, (char *) &CMsg, sizeof(CMsg));
CMsg.msg_type = ntohl(CMsg.msg_type);
CMsg.ID.Wsize.size = ntohl(CMsg.ID.Wsize.size);
if(CMsg.msg_type != CM_RULES_STANZA) {
sprintf(msg, "GetRules: Illegal Packet recvd.\n");
hxfmsg(stats, HTXERROR(EX_RULE3,0), HTX_HE_SOFT_ERROR, msg);
HE_exit(EX_RULE3);
}
#ifdef __DEBUG__
sprintf(msg, "GetRules: Sock = %d, Recvd msg = %x of size = %#x, rule_format size = %x, pid = %d \n", ToServerSock, CMsg.msg_type, sizeof(CMsg), (uint32_t)sizeof(struct rule_format), getpid());
hxfmsg(stats, 0, 7, msg);
#endif
memset(rule, '\0', sizeof(struct rule_format) * max_rules);
memset(&CMsg, '\0', sizeof(CMsg));
for(i=0; i < max_rules; i++) {
rc = StreamRead(ToServerSock, (char *) &CMsg.msg_type, sizeof(CMsg.msg_type));
CMsg.msg_type = ntohl(CMsg.msg_type);
#ifdef __DEBUG__
sprintf(msg, "i = %#x, GetRules: Recvd msg = %x, of size = %x \n", i, CMsg.msg_type, sizeof(CMsg.msg_type));
hxfmsg(stats, 0, 7, msg);
#endif
if(CMsg.msg_type == CM_RULES_FINISHED)
break;
if(CMsg.msg_type != CM_RULES_STANZA) {
sprintf(msg, "GetRules: Unable to obtain rules - type %x\n", (int)CMsg.msg_type);
hxfmsg(stats, HTXERROR(EX_RULE2,ERRNO), HTX_HE_SOFT_ERROR, msg);
HE_exit(EX_RULE2);
}
rc = StreamRead(ToServerSock, (char*) &rule[i], sizeof(struct rule_format));
if(rc != sizeof(struct rule_format)) {
sprintf(msg, "GetRules: Unable to read rules from server - %s\n", STRERROR(errno));
hxfmsg(stats, HTXERROR(EX_RULE4,ERRNO), HTX_HE_SOFT_ERROR, msg);
HE_exit(EX_RULE3);
}
NetToHostRules(&rule[i]);
}
NoStanzas = i;
closesocket(ToServerSock);
return NoStanzas;
}
int CBuffer::writechars(char*str)
{
int len = (int)strlen(str);
StreamWrite(str, len);
return len;
}
int CBuffer::writedouble(double a)
{
StreamWrite(&a, 8);
return 8;
}
bool CCell::Serialize( QTextStream * out, int &level )
{
xmlHelper * helper = xmlHelper::Instance();
StreamWriteLevUp( out, oTag( helper->getStringByKeyDef(kv_Dict) ) );
StreamWrite( out, xmlHelper::wrapKeyValInKeyVal( kv_key, kv_active ) );
StreamWrite( out, ocTag( xmlHelper::getStringByBoolean( unit == s_active ) ) );
StreamWrite( out, xmlHelper::wrapKeyValInKeyVal( kv_key, kv_block ) );
StreamWrite( out, ocTag( xmlHelper::getStringByBoolean( hextype == s_block ) ) );
StreamWrite( out, xmlHelper::wrapKeyValInKeyVal( kv_key, kv_bomb) );
StreamWrite( out, xmlHelper::wrapStringInKeyVal( kv_Integer, xmlHelper::getStringByInteger(timer)) );
StreamWrite( out, xmlHelper::wrapKeyValInKeyVal( kv_key, kv_bunny ) );
StreamWrite( out, ocTag( xmlHelper::getStringByBoolean( unit == s_bunny ) ) );
StreamWrite( out, xmlHelper::wrapKeyValInKeyVal( kv_key, kv_fire ) );
StreamWrite( out, ocTag( xmlHelper::getStringByBoolean( hextype == s_fire ) ) );
StreamWrite( out, xmlHelper::wrapKeyValInKeyVal( kv_key, kv_monster ) );
StreamWrite( out, ocTag( xmlHelper::getStringByBoolean( unit == s_monster ) ) );
StreamWrite( out, xmlHelper::wrapKeyValInKeyVal( kv_key, kv_number) );
StreamWrite( out, xmlHelper::wrapStringInKeyVal( kv_Integer, xmlHelper::getStringByInteger(index)) );
StreamWrite( out, xmlHelper::wrapKeyValInKeyVal( kv_key, kv_strong ) );
StreamWrite( out, ocTag( xmlHelper::getStringByBoolean( hextype == s_strong ) ) );
StreamWrite( out, xmlHelper::wrapKeyValInKeyVal( kv_key, kv_teleport ) );
StreamWrite( out, ocTag( xmlHelper::getStringByBoolean( hextype == s_teleport ) ) );
StreamWrite( out, xmlHelper::wrapKeyValInKeyVal( kv_key, kv_visible ) );
StreamWrite( out, ocTag( xmlHelper::getStringByBoolean( isVisible ) ) );
StreamWriteLevDown( out, cTag( helper->getStringByKeyDef(kv_Dict) ) );
return true;
}
int CBuffer::writeushort(unsigned short a)
{
StreamWrite(&a, 2);
return 2;
}
int CBuffer::writebyte(unsigned char val)
{
StreamWrite(&val, 1);
return 1;
}
int CBuffer::addBuffer(char *data, int len)
{
StreamWrite(data, len);
return len;
}
int CBuffer::addBuffer(CBuffer *buffer)
{
StreamWrite(buffer->data, buffer->count);
return buffer->count;
}
int CBuffer::writeint(int a)
{
StreamWrite(&a, 4);
return 4;
}
int CBuffer::writeuint(unsigned int a)
{
StreamWrite(&a, 4);
return 4;
}
void ntlm_write_ntlm_v2_response(PStream s, NTLMv2_RESPONSE* response)
{
StreamWrite(s, response->Response, 16);
ntlm_write_ntlm_v2_client_challenge(s, &(response->Challenge));
}
int CBuffer::writefloat(float a)
{
StreamWrite(&a, 4);
return 4;
}
int CBuffer::writeshort(short a)
{
StreamWrite(&a, 2);
return 2;
}
void ntlm_output_av_pairs(NTLM_CONTEXT* context, PSecBuffer buffer)
{
PStream s;
AV_PAIRS* av_pairs = context->av_pairs;
s = PStreamAllocAttach(buffer->pvBuffer, buffer->cbBuffer);
if (av_pairs->NbDomainName.length > 0)
{
StreamWrite_UINT16(s, MsvAvNbDomainName); /* AvId */
StreamWrite_UINT16(s, av_pairs->NbDomainName.length); /* AvLen */
StreamWrite(s, av_pairs->NbDomainName.value, av_pairs->NbDomainName.length); /* Value */
}
if (av_pairs->NbComputerName.length > 0)
{
StreamWrite_UINT16(s, MsvAvNbComputerName); /* AvId */
StreamWrite_UINT16(s, av_pairs->NbComputerName.length); /* AvLen */
StreamWrite(s, av_pairs->NbComputerName.value, av_pairs->NbComputerName.length); /* Value */
}
if (av_pairs->DnsDomainName.length > 0)
{
StreamWrite_UINT16(s, MsvAvDnsDomainName); /* AvId */
StreamWrite_UINT16(s, av_pairs->DnsDomainName.length); /* AvLen */
StreamWrite(s, av_pairs->DnsDomainName.value, av_pairs->DnsDomainName.length); /* Value */
}
if (av_pairs->DnsComputerName.length > 0)
{
StreamWrite_UINT16(s, MsvAvDnsComputerName); /* AvId */
StreamWrite_UINT16(s, av_pairs->DnsComputerName.length); /* AvLen */
StreamWrite(s, av_pairs->DnsComputerName.value, av_pairs->DnsComputerName.length); /* Value */
}
if (av_pairs->DnsTreeName.length > 0)
{
StreamWrite_UINT16(s, MsvAvDnsTreeName); /* AvId */
StreamWrite_UINT16(s, av_pairs->DnsTreeName.length); /* AvLen */
StreamWrite(s, av_pairs->DnsTreeName.value, av_pairs->DnsTreeName.length); /* Value */
}
if (av_pairs->Timestamp.length > 0)
{
StreamWrite_UINT16(s, MsvAvTimestamp); /* AvId */
StreamWrite_UINT16(s, av_pairs->Timestamp.length); /* AvLen */
StreamWrite(s, av_pairs->Timestamp.value, av_pairs->Timestamp.length); /* Value */
}
if (av_pairs->Flags > 0)
{
StreamWrite_UINT16(s, MsvAvFlags); /* AvId */
StreamWrite_UINT16(s, 4); /* AvLen */
StreamWrite_UINT32(s, av_pairs->Flags); /* Value */
}
if (av_pairs->Restrictions.length > 0)
{
StreamWrite_UINT16(s, MsvAvRestrictions); /* AvId */
StreamWrite_UINT16(s, av_pairs->Restrictions.length); /* AvLen */
StreamWrite(s, av_pairs->Restrictions.value, av_pairs->Restrictions.length); /* Value */
}
if (av_pairs->ChannelBindings.length > 0)
{
StreamWrite_UINT16(s, MsvChannelBindings); /* AvId */
StreamWrite_UINT16(s, av_pairs->ChannelBindings.length); /* AvLen */
StreamWrite(s, av_pairs->ChannelBindings.value, av_pairs->ChannelBindings.length); /* Value */
}
if (av_pairs->TargetName.length > 0)
{
StreamWrite_UINT16(s, MsvAvTargetName); /* AvId */
StreamWrite_UINT16(s, av_pairs->TargetName.length); /* AvLen */
StreamWrite(s, av_pairs->TargetName.value, av_pairs->TargetName.length); /* Value */
}
/* This indicates the end of the AV_PAIR array */
StreamWrite_UINT16(s, MsvAvEOL); /* AvId */
StreamWrite_UINT16(s, 0); /* AvLen */
if (context->ntlm_v2)
{
StreamZero(s, 8);
}
free(s);
}
