static BOOL
iso_send_connection_request(RDPCLIENT * This, char *cookie)
{
STREAM s;
int cookielen = (int)strlen(cookie);
int length = 11 + cookielen;
s = tcp_init(This, length);
if(s == NULL)
return False;
out_uint8(s, 3); /* version */
out_uint8(s, 0); /* reserved */
out_uint16_be(s, length); /* length */
out_uint8(s, length - 5); /* hdrlen */
out_uint8(s, ISO_PDU_CR);
out_uint16(s, 0); /* dst_ref */
out_uint16(s, 0); /* src_ref */
out_uint8(s, 0); /* class */
out_uint8p(s, cookie, cookielen);
s_mark_end(s);
return tcp_send(This, s);
}
bool APP_CC
xrdp_emt_send_result(struct xrdp_rdp* self, struct xrdp_emt* emt)
{
struct stream* s;
if (emt == NULL)
{
printf("emt is null\n");
return false;
}
make_stream(s);
init_stream(s, 40);
xrdp_sec_init(self->sec_layer, s);
out_uint8(s, SEC_AUTODETECT_REQ_LENGTH); // headerLength
out_uint8(s, TYPE_ID_AUTODETECT_REQUEST); // headerTypeId
out_uint16_le(s, emt->seq_number++); // sequenceNumber
out_uint16_le(s, field_all); // responseType
out_uint32_le(s, self->session->base_RTT);
out_uint32_le(s, self->session->bandwidth);
out_uint32_le(s, self->session->average_RTT);
s_mark_end(s);
xrdp_emt_send_packet(self, emt, s);
free_stream(s);
return true;
}
/* Output TPKT header for length length.
* Length should include the TPKT header (4 bytes) */
static void
tpkt_output_header(STREAM s, int length)
{
out_uint8(s, 3); /* version */
out_uint8(s, 0); /* reserved */
out_uint16_be(s, length); /* length */
}
/* Send a Licensing packet with Platform Challenge Response */
static void
licence_send_authresp(rdpLicence * licence, uint8 * token, uint8 * crypt_hwid, uint8 * signature)
{
uint32 sec_flags = SEC_LICENSE_PKT;
uint16 length = 58;
STREAM s;
s = sec_init(licence->sec, sec_flags, length + 2);
/* Licensing Preamble (LICENSE_PREAMBLE) */
out_uint8(s, PLATFORM_CHALLENGE_RESPONSE); /* PLATFORM_CHALLENGE_RESPONSE */
out_uint8(s, 2); /* PREAMBLE_VERSION_2_0 */
out_uint16_le(s, length);
/* Licensing Binary BLOB with EncryptedPlatformChallengeResponse: */
out_uint16_le(s, 1); /* wBlobType should be 0x0009 (BB_ENCRYPTED_DATA_BLOB) */
out_uint16_le(s, LICENCE_TOKEN_SIZE); /* wBlobLen */
out_uint8p(s, token, LICENCE_TOKEN_SIZE); /* RC4-encrypted challenge data */
/* Licensing Binary BLOB with EncryptedHWID: */
out_uint16_le(s, 1); /* wBlobType should be 0x0009 (BB_ENCRYPTED_DATA_BLOB) */
out_uint16_le(s, LICENCE_HWID_SIZE); /* wBlobLen */
out_uint8p(s, crypt_hwid, LICENCE_HWID_SIZE); /* RC4-encrypted Client Hardware Identification */
out_uint8p(s, signature, LICENCE_SIGNATURE_SIZE); /* MACData */
s_mark_end(s);
sec_send(licence->sec, s, sec_flags);
}
/* Send an authentication response packet */
static void
licence_send_authresp(uint8 * token, uint8 * crypt_hwid, uint8 * signature)
{
uint32 sec_flags = SEC_LICENCE_NEG;
uint16 length = 58;
STREAM s;
s = sec_init(sec_flags, length + 2);
out_uint8(s, LICENCE_TAG_AUTHRESP);
out_uint8(s, 2); /* version */
out_uint16_le(s, length);
out_uint16_le(s, 1);
out_uint16_le(s, LICENCE_TOKEN_SIZE);
out_uint8p(s, token, LICENCE_TOKEN_SIZE);
out_uint16_le(s, 1);
out_uint16_le(s, LICENCE_HWID_SIZE);
out_uint8p(s, crypt_hwid, LICENCE_HWID_SIZE);
out_uint8p(s, signature, LICENCE_SIGNATURE_SIZE);
s_mark_end(s);
sec_send(s, sec_flags);
}
void rdp_out_general_capset(rdpRdp * rdp, STREAM s)
{
int flags;
capsetHeaderRef header;
header = rdp_skip_capset_header(s);
out_uint16_le(s, OS_MAJOR_TYPE_WINDOWS); /* osMajorType */
out_uint16_le(s, OS_MINOR_TYPE_WINDOWS_NT); /* osMinorType */
out_uint16_le(s, CAPS_PROTOCOL_VERSION); /* protocolVersion */
out_uint16_le(s, 0); /* pad */
out_uint16_le(s, 0); /* generalCompressionTypes, must be set to 0 */
flags = 0;
if (rdp->settings->rdp_version >= 5)
{
flags = FASTPATH_OUTPUT_SUPPORTED | NO_BITMAP_COMPRESSION_HDR |
LONG_CREDENTIALS_SUPPORTED | AUTORECONNECT_SUPPORTED;
}
out_uint16_le(s, flags); /* extraFlags */
out_uint16_le(s, 0); /* updateCapabilityFlag, must be set to 0 */
out_uint16_le(s, 0); /* remoteUnshareFlag, must be set to 0 */
out_uint16_le(s, 0); /* generalCompressionLevel, must be set to 0 */
out_uint8(s, 0); /* refreshRectSupport, either TRUE (0x01) or FALSE (0x00) */
out_uint8(s, 0); /* suppressOutputSupport, either TRUE (0x01) or FALSE (0x00) */
rdp_out_capset_header(s, header, CAPSET_TYPE_GENERAL);
}
/* Send a platform challenge response packet */
static void
licence_send_platform_challenge_response(uint8 * token, uint8 * crypt_hwid, uint8 * signature)
{
uint32 sec_flags = SEC_LICENSE_PKT;
uint16 length = 58;
STREAM s;
s = sec_init(sec_flags, length + 2);
out_uint8(s, LICENCE_TAG_PLATFORM_CHALLENGE_RESPONSE);
out_uint8(s, ((g_rdp_version >= RDP_V5) ? 3 : 2)); /* version */
out_uint16_le(s, length);
out_uint16_le(s, 1);
out_uint16_le(s, LICENCE_TOKEN_SIZE);
out_uint8p(s, token, LICENCE_TOKEN_SIZE);
out_uint16_le(s, 1);
out_uint16_le(s, LICENCE_HWID_SIZE);
out_uint8p(s, crypt_hwid, LICENCE_HWID_SIZE);
out_uint8p(s, signature, LICENCE_SIGNATURE_SIZE);
s_mark_end(s);
sec_send(s, sec_flags);
}
/* Send an authentication response packet */
static BOOL
licence_send_authresp(RDPCLIENT * This, uint8 * token, uint8 * crypt_hwid, uint8 * signature)
{
uint32 sec_flags = SEC_LICENCE_NEG;
uint16 length = 58;
STREAM s;
s = sec_init(This, sec_flags, length + 2);
if(s == NULL)
return False;
out_uint8(s, LICENCE_TAG_AUTHRESP);
out_uint8(s, 2); /* version */
out_uint16_le(s, length);
out_uint16_le(s, 1);
out_uint16_le(s, LICENCE_TOKEN_SIZE);
out_uint8p(s, token, LICENCE_TOKEN_SIZE);
out_uint16_le(s, 1);
out_uint16_le(s, LICENCE_HWID_SIZE);
out_uint8p(s, crypt_hwid, LICENCE_HWID_SIZE);
out_uint8p(s, signature, LICENCE_SIGNATURE_SIZE);
s_mark_end(s);
return sec_send(This, s, sec_flags);
}
/* flags can contain WINDOW_ORDER_STATE_NEW and/or
WINDOW_ORDER_FIELD_ICON_BIG */
int
xrdp_orders_send_window_cached_icon(struct xrdp_orders *self,
int window_id, int cache_entry,
int cache_id, int flags)
{
int order_size;
int order_flags;
int field_present_flags;
order_size = 14;
if (xrdp_orders_check(self, order_size) != 0)
{
return 1;
}
self->order_count++;
order_flags = RDP_ORDER_SECONDARY;
order_flags |= 0xb << 2; /* type TS_ALTSEC_WINDOW */
out_uint8(self->out_s, order_flags);
/* orderSize (2 bytes) */
out_uint16_le(self->out_s, order_size);
/* FieldsPresentFlags (4 bytes) */
field_present_flags = flags | WINDOW_ORDER_TYPE_WINDOW |
WINDOW_ORDER_CACHED_ICON;
out_uint32_le(self->out_s, field_present_flags);
/* windowId (4 bytes) */
out_uint32_le(self->out_s, window_id);
/* CacheEntry (2 bytes) */
out_uint16_le(self->out_s, cache_entry);
/* CacheId (1 byte) */
out_uint8(self->out_s, cache_id);
return 0;
}
/* used for both Non-Monitored Desktop and Actively Monitored Desktop */
int
xrdp_orders_send_monitored_desktop(struct xrdp_orders *self,
struct rail_monitored_desktop_order *mdo,
int flags)
{
int order_size;
int order_flags;
int field_present_flags;
int index;
order_size = 7;
field_present_flags = flags | WINDOW_ORDER_TYPE_DESKTOP;
if (field_present_flags & WINDOW_ORDER_FIELD_DESKTOP_ACTIVE_WND)
{
/* ActiveWindowId (4 bytes) */
order_size += 4;
}
if (field_present_flags & WINDOW_ORDER_FIELD_DESKTOP_ZORDER)
{
/* NumWindowIds (1 byte) */
order_size += 1;
/* WindowIds (variable) */
order_size += mdo->num_window_ids * 4;
}
if (xrdp_orders_check(self, order_size) != 0)
{
return 1;
}
self->order_count++;
order_flags = RDP_ORDER_SECONDARY;
order_flags |= 0xb << 2; /* type TS_ALTSEC_WINDOW */
out_uint8(self->out_s, order_flags);
/* orderSize (2 bytes) */
out_uint16_le(self->out_s, order_size);
/* FieldsPresentFlags (4 bytes) */
out_uint32_le(self->out_s, field_present_flags);
if (field_present_flags & WINDOW_ORDER_FIELD_DESKTOP_ACTIVE_WND)
{
/* ActiveWindowId (4 bytes) */
out_uint32_le(self->out_s, mdo->active_window_id);
}
if (field_present_flags & WINDOW_ORDER_FIELD_DESKTOP_ZORDER)
{
/* NumWindowIds (1 byte) */
out_uint8(self->out_s, mdo->num_window_ids);
/* WindowIds (variable) */
for (index = 0; index < mdo->num_window_ids; index++)
{
out_uint32_le(self->out_s, mdo->window_ids[index]);
}
}
return 0;
}
/* 004 */
enum SCP_CLIENT_STATES_E
scp_v1c_resend_credentials(struct SCP_CONNECTION *c, struct SCP_SESSION *s)
{
tui8 sz;
tui32 size;
init_stream(c->out_s, c->out_s->size);
init_stream(c->in_s, c->in_s->size);
size = 12 + 2 + g_strlen(s->username) + g_strlen(s->password);
/* sending request */
/* header */
out_uint32_be(c->out_s, 1); /* version */
out_uint32_be(c->out_s, size);
out_uint16_be(c->out_s, SCP_COMMAND_SET_DEFAULT);
out_uint16_be(c->out_s, 4);
/* body */
sz = g_strlen(s->username);
out_uint8(c->out_s, sz);
out_uint8p(c->out_s, s->username, sz);
sz = g_strlen(s->password);
out_uint8(c->out_s, sz);
out_uint8p(c->out_s, s->password, sz);
if (0 != scp_tcp_force_send(c->in_sck, c->out_s->data, size))
{
return SCP_CLIENT_STATE_NETWORK_ERR;
}
/* wait for response */
return _scp_v1c_check_response(c, s);
}
bool APP_CC
xrdp_emt_send_request(struct xrdp_rdp* self, struct xrdp_emt* emt, int type)
{
struct stream* s;
if (emt == NULL)
{
printf("emt is null\n");
return false;
}
make_stream(s);
init_stream(s, 40);
xrdp_sec_init(self->sec_layer, s);
out_uint8(s, SEC_AUTODETECT_REQ_LENGTH); // headerLength
out_uint8(s, TYPE_ID_AUTODETECT_REQUEST); // headerTypeId
out_uint16_le(s, emt->seq_number++); // sequenceNumber
out_uint16_le(s, type); // responseType
s_mark_end(s);
xrdp_emt_send_packet(self, emt, s);
free_stream(s);
return true;
}
void rdp_out_bitmap_capset(rdpRdp * rdp, STREAM s)
{
capsetHeaderRef header;
header = rdp_skip_capset_header(s);
/*
* preferredBitsPerPixel (2 bytes):
* A 16-bit, unsigned integer. Color depth of the remote session. In RDP 4.0 and 5.0,
* this field MUST be set to 8 (even for a 16-color session)
*/
if(rdp->settings->rdp_version <= 5)
out_uint16_le(s, 8); /* preferredBitsPerPixel */
else
out_uint16_le(s, rdp->settings->server_depth); /* preferredBitsPerPixel */
out_uint16_le(s, 1); /* receive1BitPerPixel */
out_uint16_le(s, 1); /* receive4BitsPerPixel */
out_uint16_le(s, 1); /* receive8BitsPerPixel */
out_uint16_le(s, rdp->settings->width); /* desktopWidth */
out_uint16_le(s, rdp->settings->height); /* desktopHeight */
out_uint16_le(s, 0); /* pad */
out_uint16_le(s, 1); /* desktopResizeFlag */
out_uint16_le(s, rdp->settings->bitmap_compression ? 1 : 0); /* bitmapCompressionFlag */
out_uint8(s, 0); /* highColorFlags, ignored and should be set to zero */
out_uint8(s, 1); /* drawingFlags, indicating support for 32 bpp bitmaps */
out_uint16_le(s, 1); /* multipleRectangleSupport, must be set to true */
out_uint16_le(s, 0); /* pad */
rdp_out_capset_header(s, header, CAPSET_TYPE_BITMAP);
}
/* Send an fast path data PDU */
void
iso_fp_send(rdpIso * iso, STREAM s, uint32 flags)
{
int fp_flags;
int len;
int index;
fp_flags = (1 << 2) | 0; /* one event, fast path */
if (flags & SEC_ENCRYPT)
{
fp_flags |= 2 << 6; /* FASTPATH_INPUT_ENCRYPTED */
}
s_pop_layer(s, iso_hdr);
len = (int) (s->end - s->p);
out_uint8(s, fp_flags);
if (len >= 128)
{
out_uint16_be(s, len | 0x8000);
}
else
{
/* copy the bits up to pack and save 1 byte */
for (index = 3; index < len; index++)
{
s->data[index - 1] = s->data[index];
}
len--;
s->end--;
out_uint8(s, len);
}
tcp_send(iso->tcp, s);
}
static int APP_CC
rdp_iso_send_msg(struct rdp_iso *self, struct stream *s, int code)
{
if (rdp_tcp_init(self->tcp_layer, s) != 0)
{
return 1;
}
out_uint8(s, 3);
out_uint8(s, 0);
out_uint16_be(s, 11); /* length */
out_uint8(s, 6);
out_uint8(s, code);
out_uint16_le(s, 0);
out_uint16_le(s, 0);
out_uint8(s, 0);
s_mark_end(s);
if (rdp_tcp_send(self->tcp_layer, s) != 0)
{
return 1;
}
return 0;
}
static int APP_CC
sound_send_server_formats(void)
{
struct stream *s;
int bytes;
char *size_ptr;
print_got_here();
make_stream(s);
init_stream(s, 8182);
out_uint16_le(s, SNDC_FORMATS);
size_ptr = s->p;
out_uint16_le(s, 0); /* size, set later */
out_uint32_le(s, 0); /* dwFlags */
out_uint32_le(s, 0); /* dwVolume */
out_uint32_le(s, 0); /* dwPitch */
out_uint16_le(s, 0); /* wDGramPort */
out_uint16_le(s, 1); /* wNumberOfFormats */
out_uint8(s, g_cBlockNo); /* cLastBlockConfirmed */
out_uint16_le(s, 2); /* wVersion */
out_uint8(s, 0); /* bPad */
/* sndFormats */
/*
wFormatTag 2 byte offset 0
nChannels 2 byte offset 2
nSamplesPerSec 4 byte offset 4
nAvgBytesPerSec 4 byte offset 8
nBlockAlign 2 byte offset 12
wBitsPerSample 2 byte offset 14
cbSize 2 byte offset 16
data variable offset 18
*/
/* examples
01 00 02 00 44 ac 00 00 10 b1 02 00 04 00 10 00 ....D...........
00 00
01 00 02 00 22 56 00 00 88 58 01 00 04 00 10 00 ...."V...X......
00 00
*/
out_uint16_le(s, 1); // wFormatTag - WAVE_FORMAT_PCM
out_uint16_le(s, 2); // num of channels
out_uint32_le(s, 44100); // samples per sec
out_uint32_le(s, 176400); // avg bytes per sec
out_uint16_le(s, 4); // block align
out_uint16_le(s, 16); // bits per sample
out_uint16_le(s, 0); // size
s_mark_end(s);
bytes = (int)((s->end - s->data) - 4);
size_ptr[0] = bytes;
size_ptr[1] = bytes >> 8;
bytes = (int)(s->end - s->data);
send_channel_data(g_rdpsnd_chan_id, s->data, bytes);
free_stream(s);
return 0;
}
void rdp_out_bitmapcache_hostsupport_capset(rdpRdp * rdp, STREAM s)
{
capsetHeaderRef header;
header = rdp_skip_capset_header(s);
out_uint8(s, BITMAPCACHE_REV2); /* cacheVersion, must be set to BITMAPCACHE_REV2 */
out_uint8(s, 0); /* pad */
out_uint16_le(s, 0); /* pad */
rdp_out_capset_header(s, header, CAPSET_TYPE_BITMAPCACHE_HOSTSUPPORT);
}
static STREAM
rdpsnd_init_packet(uint8 type, uint16 size)
{
STREAM s;
s = channel_init(rdpsnd_channel, size + 4);
out_uint8(s, type);
out_uint8(s, 0); /* protocol-mandated padding */
out_uint16_le(s, size);
return s;
}
void
rdpsnd_send_completion(uint16 tick, uint8 packet_index)
{
STREAM s;
s = rdpsnd_init_packet(RDPSND_COMPLETION, 4);
out_uint16_le(s, tick + 50);
out_uint8(s, packet_index);
out_uint8(s, 0);
s_mark_end(s);
rdpsnd_send(s);
}
static void rdpsnd_send_completion(uint16 tick, uint8 packet_index) {
STREAM s;
s = rdpsnd_init_packet(RDPSND_COMPLETION, 4);
out_uint16_le(s, tick);
out_uint8(s, packet_index);
out_uint8(s, 0);
s_mark_end(s);
rdpsnd_send(s);
DEBUG_SOUND(("RDPSND: -> RDPSND_COMPLETION(tick: %u, index: %u)\n",
(unsigned) tick, (unsigned) packet_index));
}
static void
rdpsnd_send_waveconfirm(uint16 tick, uint8 packet_index)
{
STREAM s;
s = rdpsnd_init_packet(SNDC_WAVECONFIRM, 4);
out_uint16_le(s, tick);
out_uint8(s, packet_index);
out_uint8(s, 0);
s_mark_end(s);
rdpsnd_send(s);
logger(Sound, Debug, "rdpsnd_send_waveconfirm(), tick=%u, index=%u",
(unsigned) tick, (unsigned) packet_index);
}
/* returns error */
int
xrdp_orders_send_notify_delete(struct xrdp_orders *self, int window_id,
int notify_id)
{
int order_size;
int order_flags;
int field_present_flags;
order_size = 15;
if (xrdp_orders_check(self, order_size) != 0)
{
return 1;
}
self->order_count++;
order_flags = RDP_ORDER_SECONDARY;
order_flags |= 0xb << 2; /* type TS_ALTSEC_WINDOW */
out_uint8(self->out_s, order_flags);
/* orderSize (2 bytes) */
out_uint16_le(self->out_s, order_size);
/* FieldsPresentFlags (4 bytes) */
field_present_flags = WINDOW_ORDER_TYPE_NOTIFY | WINDOW_ORDER_STATE_DELETED;
out_uint32_le(self->out_s, field_present_flags);
/* windowId (4 bytes) */
out_uint32_le(self->out_s, window_id);
/* notifyIconId (4 bytes) */
out_uint32_le(self->out_s, notify_id);
return 0;
}
void rdp_out_bitmapcache_rev2_capset(rdpRdp * rdp, STREAM s)
{
capsetHeaderRef header;
uint16 flag;
header = rdp_skip_capset_header(s);
flag = ALLOW_CACHE_WAITING_LIST_FLAG;
if (rdp->settings->bitmap_cache_persist_enable)
flag |= PERSISTENT_KEYS_EXPECTED_FLAG;
out_uint16_le(s, flag); /* CacheFlags */
out_uint8s(s, 1); /* pad */
out_uint8(s, 3); /* numCellCaches */
/* max cell size for cache 0 is 16x16, 1 = 32x32, 2 = 64x64, etc */
out_uint32_le(s, BMPCACHE2_C0_CELLS);
out_uint32_le(s, BMPCACHE2_C1_CELLS);
if (pstcache_init(rdp->pcache, 2))
{
out_uint32_le(s, BMPCACHE2_NUM_PSTCELLS | BMPCACHE2_FLAG_PERSIST);
}
else
{
out_uint32_le(s, BMPCACHE2_C2_CELLS);
}
out_uint8s(s, 20); /* other bitmap caches not used */
rdp_out_capset_header(s, header, CAPSET_TYPE_BITMAPCACHE_REV2);
}
static void
iso_send_connection_request(char *username)
{
STREAM s;
int length = 30 + strlen(username);
s = tcp_init(length);
out_uint8(s, 3); /* version */
out_uint8(s, 0); /* reserved */
out_uint16_be(s, length); /* length */
out_uint8(s, length - 5); /* hdrlen */
out_uint8(s, ISO_PDU_CR);
out_uint16(s, 0); /* dst_ref */
out_uint16(s, 0); /* src_ref */
out_uint8(s, 0); /* class */
out_uint8p(s, "Cookie: mstshash=", strlen("Cookie: mstshash="));
out_uint8p(s, username, strlen(username));
out_uint8(s, 0x0d); /* Unknown */
out_uint8(s, 0x0a); /* Unknown */
s_mark_end(s);
tcp_send(s);
}
/* Send a Licensing packet with Client License Information */
static void
licence_present(rdpLicence * licence, uint8 * client_random, uint8 * rsa_data,
uint8 * licence_data, int licence_size, uint8 * hwid, uint8 * signature)
{
uint32 sec_flags = SEC_LICENSE_PKT;
uint16 length =
16 + SEC_RANDOM_SIZE + SEC_MODULUS_SIZE + SEC_PADDING_SIZE +
licence_size + LICENCE_HWID_SIZE + LICENCE_SIGNATURE_SIZE;
STREAM s;
s = sec_init(licence->sec, sec_flags, length + 4);
/* Licensing Preamble (LICENSE_PREAMBLE) */
out_uint8(s, LICENSE_INFO); /* bMsgType LICENSE_INFO */
out_uint8(s, 2); /* bVersion PREAMBLE_VERSION_2_0 */
out_uint16_le(s, length);
/* Client License Information: */
out_uint32_le(s, 1); /* PreferredKeyExchangeAlg KEY_EXCHANGE_ALG_RSA */
out_uint16_le(s, 0); /* PlatformId, unknown platform and ISV */
out_uint16_le(s, 0x0201); /* PlatformId, build/version */
out_uint8p(s, client_random, SEC_RANDOM_SIZE); /* ClientRandom */
/* Licensing Binary Blob with EncryptedPreMasterSecret: */
out_uint16_le(s, 0); /* wBlobType should be 0x0002 (BB_RANDOM_BLOB) */
out_uint16_le(s, (SEC_MODULUS_SIZE + SEC_PADDING_SIZE)); /* wBlobLen */
out_uint8p(s, rsa_data, SEC_MODULUS_SIZE); /* 48 bit random number encrypted for server */
out_uint8s(s, SEC_PADDING_SIZE);
/* Licensing Binary Blob with LicenseInfo: */
out_uint16_le(s, 1); /* wBlobType BB_DATA_BLOB */
out_uint16_le(s, licence_size); /* wBlobLen */
out_uint8p(s, licence_data, licence_size); /* CAL issued by servers license server */
/* Licensing Binary Blob with EncryptedHWID */
out_uint16_le(s, 1); /* wBlobType BB_DATA_BLOB */
out_uint16_le(s, LICENCE_HWID_SIZE); /* wBlobLen */
out_uint8p(s, hwid, LICENCE_HWID_SIZE); /* RC4-encrypted Client Hardware Identification */
out_uint8p(s, signature, LICENCE_SIGNATURE_SIZE); /* MACData */
s_mark_end(s);
sec_send(licence->sec, s, sec_flags);
}
/* Send an ISO data PDU */
void
iso_send(rdpIso * iso, STREAM s)
{
uint16 length;
s_pop_layer(s, iso_hdr);
length = s->end - s->p;
out_uint8(s, 3); /* version */
out_uint8(s, 0); /* reserved */
out_uint16_be(s, length);
out_uint8(s, 2); /* hdrlen */
out_uint8(s, X224_TPDU_DATA); /* code */
out_uint8(s, 0x80); /* eot */
tcp_send(iso->tcp, s);
}
/* Send an ISO data PDU */
void
iso_send(STREAM s)
{
uint16 length;
s_pop_layer(s, iso_hdr);
length = s->end - s->p;
out_uint8(s, 3); /* version */
out_uint8(s, 0); /* reserved */
out_uint16_be(s, length);
out_uint8(s, 2); /* hdrlen */
out_uint8(s, ISO_PDU_DT); /* code */
out_uint8(s, 0x80); /* eot */
tcp_send(s);
}
/* Send an ISO data PDU */
BOOL
iso_send(RDPCLIENT * This, STREAM s)
{
uint16 length;
s_pop_layer(s, iso_hdr);
length = (uint16)(s->end - s->p);
out_uint8(s, 3); /* version */
out_uint8(s, 0); /* reserved */
out_uint16_be(s, length);
out_uint8(s, 2); /* hdrlen */
out_uint8(s, ISO_PDU_DT); /* code */
out_uint8(s, 0x80); /* eot */
return tcp_send(This, s);
}
/* Output and send 7 bytes X.224 headers for
* Client X.224 Connection Request TPDU (X224_TPDU_CONNECTION_REQUEST)
* Server X.224 Connection Confirm TPDU
* FIXME: is this also suitable for X224_TPDU_DISCONNECT_REQUEST ??? */
static void
x224_send_dst_src_class(rdpIso * iso, uint8 code)
{
STREAM s;
s = tcp_init(iso->tcp, 11);
tpkt_output_header(s, 11);
out_uint8(s, 6); /* length indicator */
out_uint8(s, code);
out_uint16_le(s, 0); /* dst_ref */
out_uint16_le(s, 0); /* src_ref */
out_uint8(s, 0); /* class */
s_mark_end(s);
tcp_send(iso->tcp, s);
}
static void
rdpusb_send_reply (uint8_t code, uint8_t status, uint32_t devid)
{
STREAM s = rdpusb_init_packet(5, code);
out_uint8(s, status);
out_uint32_le(s, devid);
s_mark_end(s);
rdpusb_send(s);
}
