char
__thiscall send_cm_req_encrypt(struct_this_2 *
this
, _DWORD *buf,
int
final_length, unsigned
int
definelength)
{
unsigned
int
len2;
_DWORD *buf_1;
SIZE_T
len1;
unsigned
int
lenbuf_2;
__m128i *buf_2;
__int8
*v10;
struct_name_3 *arr;
char
err;
int
dword28;
int
final_length_2;
_DWORD *buf_4;
unsigned
int
len_1;
_DWORD *calltb;
_DWORD *buf_3;
char
v19;
int
v20;
char
*v21;
int
v22;
char
flag;
unsigned
int
len1_;
int
*plaintext;
char
err_1;
unsigned
int
v28;
int
flag_1;
struct_reallocateMem lpMem;
char
*v31;
int
v32;
int
v33;
int
len;
int
final_length_1;
char
gapshould1;
int
issuccess;
len2 = 0x1000;
buf_1 = buf;
if
( definelength > 0x1000 )
len2 = definelength;
len1 = final_length + 56;
v33 = 0;
*(_OWORD *)&lpMem.dword0 = 0i64;
if
( len2 > final_length + 56 )
len1 = len2;
lenbuf_2 = 0;
final_length_1 = 0;
*(_DWORD *)&lpMem.isReallocated = 1;
len = len2;
LOBYTE(flag_1) = 0;
gapshould1 = 0;
v28 = 0;
len1_ = len1;
lpMem.dword0 = &YS0073::YS0080<unsigned
char
>::`vftable';
memset
(&lpMem.pBuf, 0, 12);
*(_OWORD *)&lpMem.doInit0 = 0i64;
issuccess = 0;
if
( len1 )
{
buf_2 = (__m128i *)allocmem(len1);
lenbuf_2 = len1_;
lpMem.pBuf = buf_2->m128i_i32;
lpMem.size = len1_;
lpMem.used_size = len1_;
if
( lpMem.doInit0 == 1 )
{
memset
(buf_2, 0, len1_);
lenbuf_2 = lpMem.used_size;
buf_2 = (__m128i *)lpMem.pBuf;
}
}
else
{
buf_2 = 0;
}
lpMem.pBuf = buf_2->m128i_i32;
issuccess = 1;
if
( lenbuf_2 )
{
v10 = &buf_2->m128i_i8[lenbuf_2];
}
else
{
v10 = 0;
buf_2 = 0;
}
memset
(buf_2, 0, v10 - (
__int8
*)buf_2);
err_1 = prepareNetwork((
int
)
this
);
if
( err_1 )
{
final_length_1 = final_length;
arr = 0;
if
( lpMem.used_size )
arr = (struct_name_3 *)lpMem.pBuf;
plaintext = &arr->buf_new;
err_1 = (*(
int
(__thiscall **)(_DWORD *,
int
*,
int
*))(*buf + 4))(buf, &arr->buf_new, &final_length_1);
if
( err_1 && final_length_1 == final_length )
{
flag = (*(
int
(__thiscall **)(_DWORD *))(*buf + 24))(buf);
if
( flag )
{
final_length_2 = final_length_1;
}
else
{
err = (*(
int
(__thiscall **)(struct_this_2 *,
int
*,
int
*, _DWORD))(
this
->dword0 + 12))(
this
,
plaintext,
&final_length_1,
this
->unsigned___int840);
dword28 =
this
->dword28;
err_1 = err;
if
( !err )
{
*(_DWORD *)(dword28 + 12) = 301;
goto
LABEL_45;
}
final_length_2 = final_length_1;
if
( (unsigned
int
)final_length_1 > *(_DWORD *)(dword28 + 16) )
{
*(_DWORD *)(dword28 + 12) = 112;
goto
LABEL_45;
}
}
buf_4 = 0;
if
( lpMem.used_size )
buf_4 = lpMem.pBuf;
len_1 = final_length_2 + 1;
*((_BYTE *)buf_4 + 15) = 0xA0;
calltb = (_DWORD *)
this
->dword28;
if
( len_1 < calltb[4] )
{
err_1 = (*(
int
(__thiscall **)(_DWORD *,
int
, unsigned
int
,
char
))(*calltb + 24))(
calltb,
(
int
)buf_4 + 15,
len_1,
flag);
if
( err_1 )
{
sub_56E3D0(buf);
while
( 1 )
{
err_1 = (*(
int
(__thiscall **)(_DWORD, struct_reallocateMem *,
int
*,
int
*,
char
*, _DWORD))(*(_DWORD *)
this
->dword28 + 32))(
this
->dword28,
&lpMem,
&len,
&flag_1,
&gapshould1,
0);
if
( !err_1 )
break
;
(*(
void
(__thiscall **)(_DWORD *,
int
))(*buf_1 + 28))(buf_1, flag_1);
buf_3 = 0;
if
( lpMem.used_size )
buf_3 = lpMem.pBuf;
if
( !flag )
{
if
( len == 1 )
goto
LABEL_40;
err_1 = (*(
int
(__thiscall **)(struct_this_2 *, _DWORD *,
int
*, _DWORD))(
this
->dword0 + 16))(
this
,
buf_3,
&len,
this
->unsigned___int840);
if
( !err_1 )
{
*(_DWORD *)(
this
->dword28 + 12) = 302;
break
;
}
}
v28 = 0;
if
( !sub_56F180(buf, buf_3, len, &v28) )
{
if
( sub_56E240(buf_3, len) )
{
*(_DWORD *)(
this
->dword28 + 12) = 309;
LABEL_40:
err_1 = 0;
break
;
}
v19 = (*(
int
(__thiscall **)(_DWORD *, _DWORD *,
int
))(*buf + 8))(buf, buf_3, len);
v20 =
this
->dword28;
err_1 = v19;
if
( v19 )
*(_DWORD *)(v20 + 12) = buf[2];
else
*(_DWORD *)(v20 + 12) = 100;
break
;
}
buf_1 = buf;
}
}
}
else
{
calltb[3] = 112;
err_1 = 0;
}
}
else
{
*(_DWORD *)(
this
->dword28 + 12) = 100;
}
}
LABEL_45:
v21 = v31;
v22 = v32;
issuccess = 2;
for
( lpMem.dword0 = &YS0073::YS0080<unsigned
char
>::`vftable'; v21 != (
char
*)v22; v21 += 4 )
{
if
( *(_DWORD *)v21 )
{
(*(
void
(__thiscall **)(_DWORD, _DWORD))(**(_DWORD **)v21 + 4))(*(_DWORD *)v21, 0);
v22 = v32;
}
}
if
( lpMem.isReallocated )
{
if
( lpMem.pBuf )
{
if
( lpMem.doInit0 == 1 )
memset
((__m128i *)lpMem.pBuf, 0, lpMem.used_size);
free
(lpMem.pBuf);
}
memset
(&lpMem.pBuf, 0, 12);
lpMem.isReallocated = 1;
}
release(&v31);
return
err_1;
}
char
__userpurge func_10_send_message@<al>(
_DWORD *
this
@<ecx>,
int
a2@<ebx>,
int
a3@<edi>,
char
*buf,
unsigned
int
len,
int
a6)
{
unsigned
int
i;
int
len_1;
int
v12;
int
v14;
if
( (
this
[2] & 2) == 0 )
{
this
[3] = 100;
return
0;
}
if
( (*(unsigned
__int8
(__thiscall **)(_DWORD *, unsigned
int
,
int
))(*
this
+ 112))(
this
, len, a6) )
{
i = 0;
if
( !len )
return
1;
while
( 1 )
{
len_1 = send(
this
[5], buf, len - i, 0);
if
( len_1 < 0 )
break
;
i += len_1;
buf += len_1;
if
( i >= len )
return
1;
}
if
( (*(unsigned
__int8
(__thiscall **)(_DWORD *,
int
,
int
))(*
this
+ 80))(
this
, a3, a2) )
send(
this
[5], Default, 0, 0);
if
( (*(unsigned
__int8
(__thiscall **)(_DWORD *,
int
,
int
))(*
this
+ 80))(
this
, v12, v14) )
{
shutdown(
this
[5], 2);
if
( closesocket(
this
[5]) < 0 )
this
[3] = 100;
this
[2] &= ~2u;
this
[5] = -1;
}
sub_4FE2C0();
this
[3] = 102;
}
return
0;
}
bool
__thiscall func_9_send_handshake(_DWORD *
this
,
int
len,
char
a3)
{
char
buf[16];
constractHandshake((
int
)buf, len, a3);
return
send_handshake(
this
,
this
[5], buf, 16) == 16;
}
handshake_package *__cdecl constractHandshake(handshake_package *buf,
int
len,
char
a3)
{
*buf = 0i64;
buf->len = len;
*(_DWORD *)buf->magic =
'cmas'
;
buf->gap[1] = 1;
if
( a3 )
buf->flag = a3 | 1;
else
buf->flag = 65;
return
buf;
}
char
__thiscall func_5_recv_message(
struct_this_1 *
this
,
struct_reallocateMem *buf,
int
pLen,
_BYTE *flag,
int
gapshould1,
int
a6)
{
SOCKET fd;
*flag = 0;
fd =
this
->fd;
if
( (
this
->dword8 & 2) != 0 )
{
if
( (*(unsigned
__int8
(__thiscall **)(struct_this_1 *, SOCKET, struct_reallocateMem *,
int
, _BYTE *,
int
))(
this
->dword0 + 36))(
this
,
this
->fd,
buf,
pLen,
flag,
gapshould1) )
{
return
1;
}
else
{
if
( fd ==
this
->fd )
{
this
->dword8 &= ~2u;
this
->fd = -1;
}
return
0;
}
}
else
{
this
->errcode = 100;
return
0;
}
}
bool
__thiscall func_6_recv_telegram(
struct_this_1 *
this
,
SOCKET fd,
struct_reallocateMem *buf_2,
int
*plen,
char
*flag_1,
_BYTE *gapshould1)
{
int
v6;
int
len;
char
flag;
int
len_1;
struct_this_1 *v10;
unsigned
int
used_size;
SIZE_T
newsize;
int
v13;
__m128i *buf;
int
v15;
unsigned
int
v17;
__m128i *pBuf;
int
recvlen;
handshake_package buf_1;
*flag_1 = 0;
v6 = 0;
*gapshould1 = 0;
if
( !*plen )
return
0;
buf_1 = 0i64;
len = recv_message((
int
)
this
, fd, buf_1.magic, 16);
if
( !(*(unsigned
__int8
(__thiscall **)(struct_this_1 *,
int
,
int
*))(
this
->dword0 + 108))(
this
, len, plen) )
return
0;
if
( len == 16 )
{
if
( *(_DWORD *)buf_1.magic ==
'cmas'
)
{
flag = buf_1.flag;
len_1 = buf_1.len;
if
( (buf_1.flag & 1) == 0 && buf_1.len >= 0x20000u )
return
0;
v10 =
this
;
if
( buf_1.len >= *(_DWORD *)
this
->gap10 )
return
0;
used_size = buf_2->used_size;
if
( used_size < buf_1.len )
{
newsize = 0x1000;
if
( buf_1.len > 0x1000u )
newsize = buf_1.len;
reallocateMem(buf_2, newsize);
v13 = buf_2->used_size;
if
( !v13 )
return
0;
flag = buf_1.flag;
len_1 = buf_1.len;
v10 =
this
;
*plen = v13;
used_size = buf_2->used_size;
}
if
( used_size )
buf = buf_2->pBuf;
else
buf = 0;
*flag_1 = flag;
*gapshould1 = buf_1.gap[1];
if
( len_1 > 0 )
{
while
( 1 )
{
v15 = recv_message((
int
)v10, fd, buf->m128i_i8, len_1 - v6);
if
( v15 < 0 )
break
;
if
( !v15 )
goto
LABEL_34;
len_1 = buf_1.len;
v6 += v15;
v10 =
this
;
buf = (__m128i *)((
char
*)buf + v15);
if
( v6 >= buf_1.len )
{
*plen = v6;
return
v6 != 0;
}
}
if
( v15 == -2 )
v6 = -1;
goto
LABEL_23;
}
goto
LABEL_34;
}
}
else
if
( len < 16 )
{
goto
LABEL_34;
}
v17 = buf_2->used_size;
if
( v17 < 0x1000 )
{
reallocateMem(buf_2, 0x1000u);
v17 = buf_2->used_size;
}
if
( v17 )
pBuf = buf_2->pBuf;
else
pBuf = 0;
memmove
((unsigned
int
)pBuf, (unsigned
int
)&buf_1, len);
v6 = len;
recvlen = recv_message((
int
)
this
, fd, &pBuf->m128i_i8[len], *plen - len);
if
( recvlen < 0 )
{
LABEL_23:
*plen = v6;
return
0;
}
if
( recvlen )
v6 = recvlen + len;
LABEL_34:
*plen = v6;
return
v6 != 0;
}