int
xrdpvr_set_geometry(void *channel, int stream_id, int xpos, int ypos,
int width, int height)
{
STREAM *s;
char *cptr;
int rv;
int len;
printf("xrdpvr_set_geometry: entered; x=%d y=%d\n", xpos, ypos);
stream_new(s, MAX_PDU_SIZE);
stream_ins_u32_le(s, 0); /* number of bytes to follow */
stream_ins_u32_le(s, CMD_SET_GEOMETRY);
stream_ins_u32_le(s, stream_id);
stream_ins_u32_le(s, xpos);
stream_ins_u32_le(s, ypos);
stream_ins_u32_le(s, width);
stream_ins_u32_le(s, height);
/* insert number of bytes in stream */
len = stream_length(s) - 4;
cptr = s->p;
s->p = s->data;
stream_ins_u32_le(s, len);
s->p = cptr;
/* write data to virtual channel */
rv = xrdpvr_write_to_client(channel, s);
stream_free(s);
return rv;
}
void
bgp_zebra_init (void)
{
/* Set default values. */
zclient = zclient_new ();
zclient_init (zclient, ZEBRA_ROUTE_BGP);
zclient->router_id_update = bgp_router_id_update;
zclient->interface_add = bgp_interface_add;
zclient->interface_delete = bgp_interface_delete;
zclient->interface_address_add = bgp_interface_address_add;
zclient->interface_address_delete = bgp_interface_address_delete;
zclient->ipv4_route_add = zebra_read_ipv4;
zclient->ipv4_route_delete = zebra_read_ipv4;
zclient->interface_up = bgp_interface_up;
zclient->interface_down = bgp_interface_down;
#ifdef HAVE_IPV6
zclient->ipv6_route_add = zebra_read_ipv6;
zclient->ipv6_route_delete = zebra_read_ipv6;
#endif /* HAVE_IPV6 */
/* Interface related init. */
if_init ();
bgp_nexthop_buf = stream_new(BGP_NEXTHOP_BUF_SIZE);
}
tbool rpch_in_send_ping(rdpRpch* rpch)
{
STREAM* pdu = stream_new(20);
uint8 rpc_vers = 0x05;
uint8 rpc_vers_minor = 0x00;
uint8 ptype = PTYPE_RTS;
uint8 pfc_flags = PFC_FIRST_FRAG | PFC_LAST_FRAG;
uint32 packet_drep = 0x00000010;
uint16 frag_length = 56;
uint16 auth_length = 0;
uint32 call_id = 0x00000000;
uint16 flags = 0x0001;
uint16 num_commands = 0x0000;
stream_write_uint8(pdu, rpc_vers);
stream_write_uint8(pdu, rpc_vers_minor);
stream_write_uint8(pdu, ptype);
stream_write_uint8(pdu, pfc_flags);
stream_write_uint32(pdu, packet_drep);
stream_write_uint16(pdu, frag_length);
stream_write_uint16(pdu, auth_length);
stream_write_uint32(pdu, call_id);
stream_write_uint16(pdu, flags);
stream_write_uint16(pdu, num_commands);
rpch_in_write(rpch, pdu->data, pdu->p - pdu->data);
stream_free(pdu);
return true;
}
BOOL certificate_read_server_certificate(rdpCertificate* certificate, BYTE* server_cert, int length)
{
STREAM* s;
UINT32 dwVersion;
if (length < 1)
{
DEBUG_CERTIFICATE("null server certificate\n");
return FALSE;
}
s = stream_new(0);
stream_attach(s, server_cert, length);
stream_read_UINT32(s, dwVersion); /* dwVersion (4 bytes) */
switch (dwVersion & CERT_CHAIN_VERSION_MASK)
{
case CERT_CHAIN_VERSION_1:
certificate_read_server_proprietary_certificate(certificate, s);
break;
case CERT_CHAIN_VERSION_2:
certificate_read_server_x509_certificate_chain(certificate, s);
break;
default:
printf("invalid certificate chain version:%d\n", dwVersion & CERT_CHAIN_VERSION_MASK);
break;
}
free(s);
return TRUE;
}
// Wrap streams in Ruby objects
VALUE streams_to_ruby_array(VALUE self, AVFormatContext * format) {
VALUE streams = rb_ary_new();
unsigned i = 0;
for(; i < format->nb_streams; ++i) {
switch (format->streams[i]->codec->codec_type) {
case AVMEDIA_TYPE_VIDEO: {
// Video stream
rb_ary_push(streams, video_stream_new(self, format->streams[i]));
break;
}
case AVMEDIA_TYPE_AUDIO: {
// Audio stream
rb_ary_push(streams, audio_stream_new(self, format->streams[i]));
break;
}
default: {
// All other streams
rb_ary_push(streams, stream_new(self, format->streams[i]));
break;
}
}
}
return streams;
}
static int drdynvc_process_capability_request(drdynvcPlugin* drdynvc, int Sp, int cbChId, STREAM* s)
{
STREAM* data_out;
int error;
DEBUG_DVC("Sp=%d cbChId=%d", Sp, cbChId);
stream_seek(s, 1); /* pad */
stream_read_UINT16(s, drdynvc->version);
if (drdynvc->version == 2)
{
stream_read_UINT16(s, drdynvc->PriorityCharge0);
stream_read_UINT16(s, drdynvc->PriorityCharge1);
stream_read_UINT16(s, drdynvc->PriorityCharge2);
stream_read_UINT16(s, drdynvc->PriorityCharge3);
}
data_out = stream_new(4);
stream_write_UINT16(data_out, 0x0050); /* Cmd+Sp+cbChId+Pad. Note: MSTSC sends 0x005c */
stream_write_UINT16(data_out, drdynvc->version);
error = svc_plugin_send((rdpSvcPlugin*) drdynvc, data_out);
if (error != CHANNEL_RC_OK)
{
DEBUG_WARN("VirtualChannelWrite failed %d", error);
return 1;
}
drdynvc->channel_error = error;
return 0;
}
int credssp_authenticate(rdpCredssp* credssp)
{
NTLMSSP* ntlmssp = credssp->ntlmssp;
STREAM* s = stream_new(0);
uint8* negoTokenBuffer = (uint8*) xmalloc(2048);
if (credssp_ntlmssp_init(credssp) == 0)
return 0;
if (credssp_get_public_key(credssp) == 0)
return 0;
/* NTLMSSP NEGOTIATE MESSAGE */
s->p = s->data = negoTokenBuffer;
ntlmssp_send(ntlmssp, s);
credssp->negoToken.data = s->data;
credssp->negoToken.length = s->p - s->data;
credssp_send(credssp, &credssp->negoToken, NULL, NULL);
/* NTLMSSP CHALLENGE MESSAGE */
if (credssp_recv(credssp, &credssp->negoToken, NULL, NULL) < 0)
return -1;
s->p = s->data = credssp->negoToken.data;
ntlmssp_recv(ntlmssp, s);
freerdp_blob_free(&credssp->negoToken);
/* NTLMSSP AUTHENTICATE MESSAGE */
s->p = s->data = negoTokenBuffer;
ntlmssp_send(ntlmssp, s);
/* The last NTLMSSP message is sent with the encrypted public key */
credssp->negoToken.data = s->data;
credssp->negoToken.length = s->p - s->data;
credssp_encrypt_public_key(credssp, &credssp->pubKeyAuth);
credssp_send(credssp, &credssp->negoToken, NULL, &credssp->pubKeyAuth);
/* Encrypted Public Key +1 */
if (credssp_recv(credssp, &credssp->negoToken, NULL, &credssp->pubKeyAuth) < 0)
return -1;
if (credssp_verify_public_key(credssp, &credssp->pubKeyAuth) == 0)
{
/* Failed to verify server public key echo */
return 0; /* DO NOT SEND CREDENTIALS! */
}
freerdp_blob_free(&credssp->negoToken);
freerdp_blob_free(&credssp->pubKeyAuth);
/* Send encrypted credentials */
credssp_encode_ts_credentials(credssp);
credssp_encrypt_ts_credentials(credssp, &credssp->authInfo);
credssp_send(credssp, NULL, &credssp->authInfo, NULL);
xfree(s);
return 1;
}
boolean rts_send_keep_alive_pdu(rdpRpc* rpc)
{
STREAM* s;
RTS_PDU_HEADER header;
header.rpc_vers = 5;
header.rpc_vers_minor = 0;
header.ptype = PTYPE_RTS;
header.pfc_flags = PFC_FIRST_FRAG | PFC_LAST_FRAG;
header.packed_drep[0] = 0x10;
header.packed_drep[1] = 0x00;
header.packed_drep[2] = 0x00;
header.packed_drep[3] = 0x00;
header.frag_length = 28;
header.auth_length = 0;
header.call_id = 0;
header.flags = 2;
header.numberOfCommands = 1;
DEBUG_RPC("Sending Keep-Alive RTS PDU");
s = stream_new(header.frag_length);
rts_pdu_header_write(s, &header); /* RTS Header (20 bytes) */
rts_client_keepalive_command_write(s, 0x00007530); /* ClientKeepalive (8 bytes) */
stream_seal(s);
rpc_in_write(rpc, s->data, s->size);
stream_free(s);
return true;
}
KrbAPREQ* krb_apreq_new(KRB_CONTEXT* krb_ctx, Ticket* ticket, Authenticator* krb_auth)
{
KrbAPREQ* krb_apreq;
STREAM* as;
rdpBlob msg;
rdpBlob* encmsg;
uint32 len;
as = stream_new(1024);
stream_seek(as, 1023);
krb_apreq = xnew(KrbAPREQ);
krb_apreq->pvno = KRB_VERSION;
krb_apreq->type = KRB_TAG_APREQ;
krb_apreq->ap_options = 0x00000000 | 0x00000000 | 0x00000000; /* Reserved (bit 31), Use session Key (bit 30), Mututal Required (bit 29) */
krb_apreq->ticket = ticket;
if (krb_auth != NULL)
{
len = krb_encode_authenticator(as, krb_auth);
msg.data = as->p;
msg.length = len;
encmsg = crypto_kdcmsg_encrypt(&msg, krb_ctx->askey, 7); /* RFC4757 section 3 for msgtype (T=7) */
krb_apreq->enc_auth.enctype = krb_ctx->askey->enctype;
krb_apreq->enc_auth.kvno = -1;
krb_apreq->enc_auth.encblob.data = encmsg->data;
krb_apreq->enc_auth.encblob.length = encmsg->length;
xfree(encmsg);
}
stream_free(as);
return krb_apreq;
}
/* Finish initializing a session from a connection, or kills it if the
* connection shows and error. Returns <0 if the connection was killed.
*/
static int conn_complete_session(struct connection *conn)
{
struct task *task = conn->owner;
struct session *sess = task->context;
struct stream *strm;
if (conn->flags & CO_FL_ERROR)
goto fail;
/* we want the connection handler to notify the stream interface about updates. */
conn->flags |= CO_FL_WAKE_DATA;
/* if logs require transport layer information, note it on the connection */
if (sess->fe->to_log & LW_XPRT)
conn->flags |= CO_FL_XPRT_TRACKED;
session_count_new(sess);
task->process = sess->listener->handler;
strm = stream_new(sess, task, &conn->obj_type);
if (!strm)
goto fail;
strm->target = sess->listener->default_target;
strm->req.analysers = sess->listener->analysers;
conn->flags &= ~CO_FL_INIT_DATA;
return 0;
fail:
session_kill_embryonic(sess);
return -1;
}
void test_ber_write_length(void)
{
STREAM *s1, *s2;
s1 = stream_new(sizeof(ber_length_expected_1));
s2 = stream_new(sizeof(ber_length_expected_2));
ber_write_length(s1, 64);
ASSERT_STREAM(s1, (uint8*) ber_length_expected_1, sizeof(ber_length_expected_1));
ber_write_length(s2, 404);
ASSERT_STREAM(s2, (uint8*) ber_length_expected_2, sizeof(ber_length_expected_2));
stream_free(s1);
stream_free(s2);
}
s32 ldp_accept(struct thread * t)
{
s32 fd ;
union sockunion su ;
struct ldp_peer * peer ;
s32 sock = THREAD_FD(t);
struct ldp * ldp = THREAD_ARG(t);
ldp->t_accept = NULL ;
THREAD_READ_ON(master, ldp->t_accept, ldp_accept, ldp, sock);
fd = sockunion_accept(sock, &su);
if( fd <= 0 )
return -1 ;
peer = ldp_peer_new();
if( NULL == peer )
{
close(fd);
return -1 ;
}
peer->state = ACCEPT_PEER ;
peer->fd = fd ;
peer->ldp = ldp;
peer->transport = su.sin.sin_addr.s_addr;
peer->input = stream_new(LDP_MAX_PDU_LEN);
listnode_add(ldp->accepts, peer);
LDP_FSM_EVENT(peer, ConnectSuccess);
return 0 ;
}
/**
* set video format
*
* @param channel opaque handle returned by WTSVirtualChannelOpenEx
* @param stream_id unique identification number for this stream
*
* @return 0 on success, -1 on error
*****************************************************************************/
int
xrdpvr_set_video_format(void *channel, uint32_t stream_id, int format,
int width, int height)
{
STREAM *s;
char *cptr;
int rv;
int len;
width = (width + 15) & ~15;
stream_new(s, MAX_PDU_SIZE);
stream_ins_u32_le(s, 0); /* number of bytes to follow */
stream_ins_u32_le(s, CMD_SET_VIDEO_FORMAT);
stream_ins_u32_le(s, stream_id);
stream_ins_u32_le(s, format);
stream_ins_u32_le(s, width);
stream_ins_u32_le(s, height);
/* insert number of bytes in stream */
len = stream_length(s) - 4;
cptr = s->p;
s->p = s->data;
stream_ins_u32_le(s, len);
s->p = cptr;
/* write data to virtual channel */
rv = xrdpvr_write_to_client(channel, s);
stream_free(s);
return rv;
}
/**
* send audio data to client
*
* @param channel opaque handle returned by WTSVirtualChannelOpenEx
* @param stream_id unique identification number for this stream
* @param data_len number of bytes to send
* @param data audio data to send
*
* @return 0 on success, -1 on error
*****************************************************************************/
int
xrdpvr_send_audio_data(void *channel, uint32_t stream_id, uint32_t data_len,
uint8_t *data)
{
STREAM *s;
char *cptr;
int rv;
int len;
//printf("xrdpvr_send_audio_data:\n");
stream_new(s, MAX_PDU_SIZE + data_len);
stream_ins_u32_le(s, 0); /* number of bytes to follow */
stream_ins_u32_le(s, CMD_SEND_AUDIO_DATA);
stream_ins_u32_le(s, stream_id);
stream_ins_u32_le(s, data_len);
stream_ins_byte_array(s, data, data_len);
/* insert number of bytes in stream */
len = stream_length(s) - 4;
cptr = s->p;
s->p = s->data;
stream_ins_u32_le(s, len);
s->p = cptr;
/* write data to virtual channel */
rv = xrdpvr_write_to_client(channel, s);
stream_free(s);
return rv;
}
void test_decode(void)
{
RFX_CONTEXT* context;
uint8 decode_buffer[4096 * 3];
STREAM* s;
s = stream_new(sizeof(y_data) + sizeof(cb_data) + sizeof(cr_data));
stream_write(s, y_data, sizeof(y_data));
stream_write(s, cb_data, sizeof(cb_data));
stream_write(s, cr_data, sizeof(cr_data));
stream_set_pos(s, 0);
context = rfx_context_new();
context->mode = RLGR3;
rfx_context_set_pixel_format(context, RFX_PIXEL_FORMAT_RGB);
rfx_decode_rgb(context, s,
sizeof(y_data), test_quantization_values,
sizeof(cb_data), test_quantization_values,
sizeof(cr_data), test_quantization_values,
decode_buffer);
rfx_context_free(context);
stream_free(s);
dump_ppm_image(decode_buffer);
}
BOOL rts_send_ping_pdu(rdpRpc* rpc)
{
STREAM* s;
RTS_PDU_HEADER header;
header.rpc_vers = 5;
header.rpc_vers_minor = 0;
header.ptype = PTYPE_RTS;
header.pfc_flags = PFC_FIRST_FRAG | PFC_LAST_FRAG;
header.packed_drep[0] = 0x10;
header.packed_drep[1] = 0x00;
header.packed_drep[2] = 0x00;
header.packed_drep[3] = 0x00;
header.frag_length = 20;
header.auth_length = 0;
header.call_id = 0;
header.flags = 1;
header.numberOfCommands = 0;
DEBUG_RPC("Sending Ping RTS PDU");
s = stream_new(header.frag_length);
rts_pdu_header_write(s, &header); /* RTS Header (20 bytes) */
stream_seal(s);
rpc_in_write(rpc, s->data, s->size);
stream_free(s);
return TRUE;
}
void credssp_read_ts_credentials(rdpCredssp* credssp, PSecBuffer ts_credentials)
{
STREAM* s;
int length;
int ts_password_creds_length;
s = stream_new(0);
stream_attach(s, ts_credentials->pvBuffer, ts_credentials->cbBuffer);
/* TSCredentials (SEQUENCE) */
ber_read_sequence_tag(s, &length);
/* [0] credType (INTEGER) */
ber_read_contextual_tag(s, 0, &length, TRUE);
ber_read_integer(s, NULL);
/* [1] credentials (OCTET STRING) */
ber_read_contextual_tag(s, 1, &length, TRUE);
ber_read_octet_string_tag(s, &ts_password_creds_length);
credssp_read_ts_password_creds(credssp, s);
stream_detach(s);
stream_free(s);
}
void test_nsc_encode(void)
{
int i;
uint8* rgb_data;
STREAM* enc_stream;
NSC_CONTEXT* context;
rgb_data = (uint8 *) malloc(64 * 64 * 3);
for (i = 0; i < 64; i++)
memcpy(rgb_data + i * 64 * 3, rgb_scanline_data, 64 * 3);
context = nsc_context_new();
nsc_context_set_cpu_opt(context, CPU_SSE2);
nsc_context_set_pixel_format(context, RDP_PIXEL_FORMAT_R8G8B8);
enc_stream = stream_new(65536);
stream_clear(enc_stream);
for (i = 0; i < 30000; i++)
{
stream_set_pos(enc_stream, 0);
nsc_compose_message(context, enc_stream, rgb_data, 64, 64, 64 * 3);
}
/*freerdp_hexdump(stream_get_head(enc_stream), stream_get_length(enc_stream));*/
nsc_process_message(context, 32, 64, 64, stream_get_head(enc_stream), stream_get_length(enc_stream));
/*freerdp_hexdump(context->bmpdata, 64 * 64 * 4);*/
stream_free(enc_stream);
nsc_context_free(context);
}
static void skel_process_receive(rdpSvcPlugin* plugin, STREAM* data_in)
{
skelPlugin* skel = (skelPlugin*)plugin;
STREAM* data_out;
int bytes;
printf("skel_process_receive:\n");
if (skel == NULL)
{
printf("skel_process_receive: skel is nil\n");
return;
}
/* process data in(from server) here */
/* here we just send the same data back */
bytes = stream_get_size(data_in);
printf("skel_process_receive: got bytes %d\n", bytes);
if (bytes > 0)
{
data_out = stream_new(bytes);
stream_copy(data_out, data_in, bytes);
/* svc_plugin_send takes ownership of data_out, that is why
we do not free it */
bytes = stream_get_length(data_in);
printf("skel_process_receive: sending bytes %d\n", bytes);
svc_plugin_send(plugin, data_out);
}
stream_free(data_in);
}
static void sample_process_receive(rdpSvcPlugin* plugin, wStream* data_in)
{
int bytes;
wStream* data_out;
samplePlugin* sample = (samplePlugin*) plugin;
fprintf(stderr, "sample_process_receive:\n");
if (!sample)
{
fprintf(stderr, "sample_process_receive: sample is nil\n");
return;
}
/* process data in (from server) here */
/* here we just send the same data back */
bytes = stream_get_size(data_in);
fprintf(stderr, "sample_process_receive: got bytes %d\n", bytes);
if (bytes > 0)
{
data_out = stream_new(bytes);
stream_copy(data_out, data_in, bytes);
/* svc_plugin_send takes ownership of data_out, that is why
we do not free it */
bytes = stream_get_length(data_in);
fprintf(stderr, "sample_process_receive: sending bytes %d\n", bytes);
svc_plugin_send(plugin, data_out);
}
stream_free(data_in);
}
void test_nsc_encode(void)
{
int i;
BYTE* rgb_data;
wStream* enc_stream;
NSC_CONTEXT* context;
rgb_data = (BYTE *) malloc(64 * 64 * 3);
for (i = 0; i < 64; i++)
memcpy(rgb_data + i * 64 * 3, rgb_scanline_data, 64 * 3);
context = nsc_context_new();
nsc_context_set_pixel_format(context, RDP_PIXEL_FORMAT_R8G8B8);
enc_stream = stream_new(65536);
stream_clear(enc_stream);
for (i = 0; i < 30000; i++)
{
Stream_SetPosition(enc_stream, 0);
nsc_compose_message(context, enc_stream, rgb_data, 64, 64, 64 * 3);
}
/*winpr_HexDump(Stream_Buffer(enc_stream), Stream_GetPosition(enc_stream));*/
nsc_process_message(context, 32, 64, 64, Stream_Buffer(enc_stream), Stream_GetPosition(enc_stream));
/*winpr_HexDump(context->bmpdata, 64 * 64 * 4);*/
stream_free(enc_stream);
nsc_context_free(context);
}
int
main (void)
{
struct stream *s;
s = stream_new (1024);
stream_putc (s, ham);
stream_putw (s, ham);
stream_putl (s, ham);
stream_putq (s, ham);
print_stream (s);
stream_resize (s, stream_get_endp (s));
print_stream (s);
printf ("c: 0x%hhx\n", stream_getc (s));
printf ("w: 0x%hx\n", stream_getw (s));
printf ("l: 0x%x\n", stream_getl (s));
printf ("q: 0x%" PRIu64 "\n", stream_getq (s));
return 0;
}
static void rdpdr_send_client_name_request(rdpdrPlugin* rdpdr)
{
char* s;
STREAM* data_out;
UNICONV* uniconv;
size_t computerNameLenW;
uniconv = freerdp_uniconv_new();
if (!rdpdr->computerName[0])
gethostname(rdpdr->computerName, sizeof(rdpdr->computerName) - 1);
s = freerdp_uniconv_out(uniconv, rdpdr->computerName, &computerNameLenW);
data_out = stream_new(16 + computerNameLenW + 2);
stream_write_uint16(data_out, RDPDR_CTYP_CORE);
stream_write_uint16(data_out, PAKID_CORE_CLIENT_NAME);
stream_write_uint32(data_out, 1); /* unicodeFlag, 0 for ASCII and 1 for Unicode */
stream_write_uint32(data_out, 0); /* codePage, must be set to zero */
stream_write_uint32(data_out, computerNameLenW + 2); /* computerNameLen, including null terminator */
stream_write(data_out, s, computerNameLenW);
stream_write_uint16(data_out, 0); /* null terminator */
xfree(s);
freerdp_uniconv_free(uniconv);
svc_plugin_send((rdpSvcPlugin*) rdpdr, data_out);
}
STREAM* rail_pdu_init(int length)
{
STREAM* s;
s = stream_new(length + RAIL_PDU_HEADER_LENGTH);
stream_seek(s, RAIL_PDU_HEADER_LENGTH);
return s;
}
static void svc_plugin_process_received(rdpSvcPlugin* plugin, void* pData, uint32 dataLength,
uint32 totalLength, uint32 dataFlags)
{
STREAM* data_in;
if (dataFlags & CHANNEL_FLAG_FIRST)
{
if (plugin->priv->data_in != NULL)
stream_free(plugin->priv->data_in);
plugin->priv->data_in = stream_new(totalLength);
}
data_in = plugin->priv->data_in;
stream_check_size(data_in, dataLength);
stream_write(data_in, pData, dataLength);
if (dataFlags & CHANNEL_FLAG_LAST)
{
if (stream_get_size(data_in) != stream_get_length(data_in))
{
printf("svc_plugin_process_received: read error\n");
}
/* the stream ownership is passed to the callback who is responsible for freeing it. */
plugin->priv->data_in = NULL;
stream_set_pos(data_in, 0);
plugin->receive_callback(plugin, data_in);
}
}
boolean certificate_read_server_certificate(rdpCertificate* certificate, uint8* server_cert, int length)
{
STREAM* s;
uint32 dwVersion;
s = stream_new(0);
s->p = s->data = server_cert;
if (length < 1)
{
printf("null server certificate\n");
return False;
}
stream_read_uint32(s, dwVersion); /* dwVersion (4 bytes) */
switch (dwVersion & CERT_CHAIN_VERSION_MASK)
{
case CERT_CHAIN_VERSION_1:
certificate_read_server_proprietary_certificate(certificate, s);
break;
case CERT_CHAIN_VERSION_2:
certificate_read_server_x509_certificate_chain(certificate, s);
break;
default:
printf("invalid certificate chain version:%d\n", dwVersion & CERT_CHAIN_VERSION_MASK);
break;
}
xfree(s);
return True;
}
int
xrdpvr_send_init(void *channel)
{
STREAM *s;
char *cptr;
int rv;
int len;
printf("xrdpvr_send_init:\n");
stream_new(s, MAX_BUFSIZE);
stream_ins_u32_le(s, 0); /* number of bytes to follow */
stream_ins_u32_le(s, CMD_INIT_XRDPVR);
/* insert number of bytes in stream */
len = stream_length(s) - 4;
cptr = s->p;
s->p = s->data;
stream_ins_u32_le(s, len);
s->p = cptr;
/* write data to virtual channel */
rv = xrdpvr_write_to_client(channel, s);
stream_free(s);
return rv;
}
/**
* write set volume to a xrdpvr client
*
* @param channel opaque handle returned by WTSVirtualChannelOpenEx
* @param volume volume 0x0000 to 0xffff
*
* @return 0 on success, -1 on failure
******************************************************************************/
int
xrdpvr_set_volume(void *channel, int volume)
{
STREAM *s;
char *cptr;
int rv;
int len;
stream_new(s, MAX_BUFSIZE);
stream_ins_u32_le(s, 0); /* number of bytes to follow */
stream_ins_u32_le(s, CMD_SET_VOLUME);
stream_ins_u32_le(s, volume);
/* insert number of bytes in stream */
len = stream_length(s) - 4;
cptr = s->p;
s->p = s->data;
stream_ins_u32_le(s, len);
s->p = cptr;
/* write data to virtual channel */
rv = xrdpvr_write_to_client(channel, s);
stream_free(s);
return rv;
}
void dev_redir_send_server_core_cap_req()
{
struct stream *s;
int bytes;
stream_new(s, 1024);
/* setup header */
stream_wr_u16_le(s, RDPDR_CTYP_CORE);
stream_wr_u16_le(s, PAKID_CORE_SERVER_CAPABILITY);
stream_wr_u16_le(s, 5); /* num of caps we are sending */
stream_wr_u16_le(s, 0x0000); /* padding */
/* setup general capability */
stream_wr_u16_le(s, CAP_GENERAL_TYPE); /* CapabilityType */
stream_wr_u16_le(s, 44); /* CapabilityLength - len of this */
/* CAPABILITY_SET in bytes, inc */
/* the header */
stream_wr_u32_le(s, 2); /* Version */
stream_wr_u32_le(s, 2); /* O.S type */
stream_wr_u32_le(s, 0); /* O.S version */
stream_wr_u16_le(s, 1); /* protocol major version */
stream_wr_u16_le(s, g_client_rdp_version); /* protocol minor version */
stream_wr_u32_le(s, 0xffff); /* I/O code 1 */
stream_wr_u32_le(s, 0); /* I/O code 2 */
stream_wr_u32_le(s, 7); /* Extended PDU */
stream_wr_u32_le(s, 0); /* extra flags 1 */
stream_wr_u32_le(s, 0); /* extra flags 2 */
stream_wr_u32_le(s, 2); /* special type device cap */
/* setup printer capability */
stream_wr_u16_le(s, CAP_PRINTER_TYPE);
stream_wr_u16_le(s, 8);
stream_wr_u32_le(s, 1);
/* setup serial port capability */
stream_wr_u16_le(s, CAP_PORT_TYPE);
stream_wr_u16_le(s, 8);
stream_wr_u32_le(s, 1);
/* setup file system capability */
stream_wr_u16_le(s, CAP_DRIVE_TYPE); /* CapabilityType */
stream_wr_u16_le(s, 8); /* CapabilityLength - len of this */
/* CAPABILITY_SET in bytes, inc */
/* the header */
stream_wr_u32_le(s, 2); /* Version */
/* setup smart card capability */
stream_wr_u16_le(s, CAP_SMARTCARD_TYPE);
stream_wr_u16_le(s, 8);
stream_wr_u32_le(s, 1);
/* send to client */
bytes = stream_len(s);
send_channel_data(g_rdpdr_chan_id, s->data, bytes);
stream_free(s);
}
void credssp_send(rdpCredssp* credssp)
{
STREAM* s;
int length;
int ts_request_length;
int nego_tokens_length;
int pub_key_auth_length;
int auth_info_length;
nego_tokens_length = (credssp->negoToken.cbBuffer > 0) ? credssp_skip_nego_tokens(credssp->negoToken.cbBuffer) : 0;
pub_key_auth_length = (credssp->pubKeyAuth.cbBuffer > 0) ? credssp_skip_pub_key_auth(credssp->pubKeyAuth.cbBuffer) : 0;
auth_info_length = (credssp->authInfo.cbBuffer > 0) ? credssp_skip_auth_info(credssp->authInfo.cbBuffer) : 0;
length = nego_tokens_length + pub_key_auth_length + auth_info_length;
ts_request_length = credssp_skip_ts_request(length);
s = stream_new(ts_request_length);
/* TSRequest */
length = der_get_content_length(ts_request_length);
der_write_sequence_tag(s, length); /* SEQUENCE */
/* [0] version */
ber_write_contextual_tag(s, 0, 3, true);
ber_write_integer(s, 2); /* INTEGER */
/* [1] negoTokens (NegoData) */
if (nego_tokens_length > 0)
{
length = der_get_content_length(nego_tokens_length);
length -= der_write_contextual_tag(s, 1, length, true); /* NegoData */
length -= der_write_sequence_tag(s, length); /* SEQUENCE OF NegoDataItem */
length -= der_write_sequence_tag(s, length); /* NegoDataItem */
length -= der_write_contextual_tag(s, 0, length, true); /* [0] negoToken */
der_write_octet_string(s, (uint8*) credssp->negoToken.pvBuffer, length); /* OCTET STRING */
}
/* [2] authInfo (OCTET STRING) */
if (auth_info_length > 0)
{
length = ber_get_content_length(auth_info_length);
length -= ber_write_contextual_tag(s, 2, length, true);
ber_write_octet_string(s, credssp->authInfo.pvBuffer, credssp->authInfo.cbBuffer);
}
/* [3] pubKeyAuth (OCTET STRING) */
if (pub_key_auth_length > 0)
{
length = ber_get_content_length(pub_key_auth_length);
length -= ber_write_contextual_tag(s, 3, length, true);
ber_write_octet_string(s, credssp->pubKeyAuth.pvBuffer, length);
}
//printf("Sending TSRequest: (%d)\n", stream_get_length(s));
//freerdp_hexdump(s->data, stream_get_length(s));
tls_write(credssp->tls, s->data, stream_get_length(s));
stream_free(s);
}
