/* Respond to a demand active PDU */
static void process_demand_active(STREAM s) {
uint8 type;
uint16 len_src_descriptor, len_combined_caps;
in_uint32_le(s, g_rdp_shareid);
in_uint16_le(s, len_src_descriptor);
in_uint16_le(s, len_combined_caps);
in_uint8s(s, len_src_descriptor);
DEBUG(("DEMAND_ACTIVE(id=0x%x)\n", g_rdp_shareid));
rdp_process_server_caps(s, len_combined_caps);
rdp_send_confirm_active();
rdp_send_synchronise();
rdp_send_control(RDP_CTL_COOPERATE);
rdp_send_control(RDP_CTL_REQUEST_CONTROL);
rdp_recv(&type); /* RDP_PDU_SYNCHRONIZE */
rdp_recv(&type); /* RDP_CTL_COOPERATE */
rdp_recv(&type); /* RDP_CTL_GRANT_CONTROL */
rdp_send_input(0, RDP_INPUT_SYNCHRONIZE, 0,
g_numlock_sync ? ui_get_numlock_state(read_keyboard_state()) : 0,
0);
if (g_use_rdp5) {
rdp_enum_bmpcache2();
rdp_send_fonts(3);
} else {
rdp_send_fonts(1);
rdp_send_fonts(2);
}
rdp_recv(&type); /* RDP_PDU_UNKNOWN 0x28 (Fonts?) */
reset_order_state();
}
int main(int argc, char** argv) {
int sockfd;
struct sockaddr_in sendaddr;
struct sockaddr_in recvaddr;
int optval = 1;
if( argc != 6) {
printf("Incorrect number of parameters!\nUsage: ./rwsc client_ip client_port server_ip server_port URL\n");
return -1;
}
if((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
{
perror("socket");
return -1;
}
setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval));
sendaddr.sin_family = AF_INET;
sendaddr.sin_port = htons(atoi(argv[2]));
sendaddr.sin_addr.s_addr = inet_addr(argv[1]);
if(bind(sockfd, (struct sockaddr*)&sendaddr, sizeof(sendaddr)) == -1) {
perror("bind");
return -1;
}
recvaddr.sin_family = AF_INET;
recvaddr.sin_port = htons(atoi(argv[4]));
recvaddr.sin_addr.s_addr = inet_addr(argv[3]);
//struct to hold the receiver's address
//delete later
rdp_connect(sockfd, argv[3], argv[4]);
char* storage = malloc(sizeof(char)*990);
char* request = "GET / HTTP/1.0\r\n\r\n";
rdp_send(sockfd, request, strlen(request), &recvaddr);
rdp_recv(sockfd, storage, strlen(storage), &recvaddr);
printf("%s\n", storage);
rdp_recv(sockfd, storage, strlen(storage), &recvaddr);
printf("%s\n", storage);
rdp_recv(sockfd, storage, strlen(storage), &recvaddr);
printf("%s\n", storage);
rdp_recv(sockfd, storage, strlen(storage), &recvaddr);
printf("%s\n", storage);
close(sockfd);
return 0;
}
/* Respond to a demand active PDU */
static BOOL
process_demand_active(RDPCLIENT * This, STREAM s)
{
uint8 type;
uint16 len_src_descriptor, len_combined_caps;
in_uint32_le(s, This->rdp_shareid);
in_uint16_le(s, len_src_descriptor);
in_uint16_le(s, len_combined_caps);
in_uint8s(s, len_src_descriptor);
DEBUG(("DEMAND_ACTIVE(id=0x%x)\n", This->rdp_shareid));
rdp_process_server_caps(This, s, len_combined_caps);
if
(
!rdp_send_confirm_active(This) ||
!rdp_send_synchronise(This) ||
!rdp_send_control(This, RDP_CTL_COOPERATE) ||
!rdp_send_control(This, RDP_CTL_REQUEST_CONTROL) ||
!rdp_recv(This, &type) || /* RDP_PDU_SYNCHRONIZE */
!rdp_recv(This, &type) || /* RDP_CTL_COOPERATE */
!rdp_recv(This, &type) || /* RDP_CTL_GRANT_CONTROL */
!rdp_send_input(This, 0, RDP_INPUT_SYNCHRONIZE, 0,
/*This->numlock_sync ? ui_get_numlock_state(This, read_keyboard_state(This)) :*/ 0, 0) // TODO: keyboard mess
)
return False;
if (This->use_rdp5)
{
if(!rdp_enum_bmpcache2(This) || !rdp_send_fonts(This, 3))
return False;
}
else
{
if(!rdp_send_fonts(This, 1) || !rdp_send_fonts(This, 2))
return False;
}
if(!rdp_recv(This, &type)) /* RDP_PDU_UNKNOWN 0x28 (Fonts?) */
return False;
reset_order_state(This);
return True;
}
boolean rdp_client_activate(rdpRdp* rdp)
{
while (rdp->activated != True)
{
rdp_recv(rdp);
}
printf("client is activated\n");
return True;
}
/* Respond to a demand active PDU */
static void
process_demand_active(STREAM s)
{
uint8 type;
in_uint32_le(s, g_rdp_shareid);
DEBUG(("DEMAND_ACTIVE(id=0x%x)\n", g_rdp_shareid));
rdp_send_confirm_active();
rdp_send_synchronise();
rdp_send_control(RDP_CTL_COOPERATE);
rdp_send_control(RDP_CTL_REQUEST_CONTROL);
rdp_recv(&type); /* RDP_PDU_SYNCHRONIZE */
rdp_recv(&type); /* RDP_CTL_COOPERATE */
rdp_recv(&type); /* RDP_CTL_GRANT_CONTROL */
rdp_send_input(0, RDP_INPUT_SYNCHRONIZE, 0, ui_get_numlock_state(read_keyboard_state()), 0);
rdp_send_fonts(1);
rdp_send_fonts(2);
rdp_recv(&type); /* RDP_PDU_UNKNOWN 0x28 */
reset_order_state();
}
/* used in uiports and rdp_main_loop, processes the rdp packets waiting */
RD_BOOL
rdp_loop(RD_BOOL * deactivated, uint32 * ext_disc_reason)
{
uint8 type;
RD_BOOL cont = True;
STREAM s;
while (cont)
{
s = rdp_recv(&type);
if (s == NULL)
return False;
switch (type)
{
case RDP_PDU_DEMAND_ACTIVE:
process_demand_active(s);
*deactivated = False;
break;
case RDP_PDU_DEACTIVATE:
DEBUG(("RDP_PDU_DEACTIVATE\n"));
*deactivated = True;
break;
case RDP_PDU_REDIRECT:
return process_redirect_pdu(s, False);
break;
case RDP_PDU_ENHANCED_REDIRECT:
return process_redirect_pdu(s, True);
break;
case RDP_PDU_DATA:
/* If we got a data PDU, we don't need to keep the password in memory
anymore and therefor we should clear it for security reasons. */
if (g_password[0] != '\0')
memset(g_password, 0, sizeof(g_password));
process_data_pdu(s, ext_disc_reason);
break;
case 0:
break;
default:
unimpl("PDU %d\n", type);
}
cont = g_next_packet < s->end;
}
return True;
}
/* used in uiports and rdp_main_loop, processes the rdp packets waiting */
RD_BOOL rdp_loop(RD_BOOL * deactivated, uint32 * ext_disc_reason) {
__android_log_print(ANDROID_LOG_INFO, "JNIMsg", "rdp_loop");
uint8 type;
RD_BOOL cont = True;
STREAM s;
while (cont) {
s = rdp_recv(&type);
if (s == NULL)
return False;
switch (type) {
case RDP_PDU_DEMAND_ACTIVE:
__android_log_print(ANDROID_LOG_INFO, "JNIMsg",
"rdp_loop RDP_PDU_DEMAND_ACTIVE");
process_demand_active(s);
*deactivated = False;
break;
case RDP_PDU_DEACTIVATE:
__android_log_print(ANDROID_LOG_INFO, "JNIMsg",
"rdp_loop RDP_PDU_DEACTIVATE");
DEBUG(("RDP_PDU_DEACTIVATE\n"));
*deactivated = True;
break;
case RDP_PDU_REDIRECT:
__android_log_print(ANDROID_LOG_INFO, "JNIMsg",
"rdp_loop RDP_PDU_REDIRECT");
return process_redirect_pdu(s);
break;
case RDP_PDU_DATA:
__android_log_print(ANDROID_LOG_INFO, "JNIMsg",
"rdp_loop RDP_PDU_DATA");
process_data_pdu(s, ext_disc_reason);
break;
case 0:
break;
default:
unimpl("PDU %d\n", type);
}
cont = g_next_packet < s->end;
}
return True;
}
/* used in uiports and rdp_main_loop, processes the rdp packets waiting */
BOOL
rdp_loop(RDPCLIENT * This, BOOL * deactivated, uint32 * ext_disc_reason)
{
uint8 type;
BOOL disc = False; /* True when a disconnect PDU was received */
BOOL cont = True;
STREAM s;
while (cont)
{
s = rdp_recv(This, &type);
if (s == NULL)
return False;
switch (type)
{
case RDP_PDU_DEMAND_ACTIVE:
if(!process_demand_active(This, s))
return False;
*deactivated = False;
break;
case RDP_PDU_DEACTIVATE:
DEBUG(("RDP_PDU_DEACTIVATE\n"));
*deactivated = True;
break;
case RDP_PDU_REDIRECT:
return process_redirect_pdu(This, s);
break;
case RDP_PDU_DATA:
disc = process_data_pdu(This, s, ext_disc_reason);
break;
case 0:
break;
default:
unimpl("PDU %d\n", type);
}
if (disc)
return False;
cont = This->next_packet < s->end;
}
return True;
}
/* Process incoming packets */
BOOL
rdp_main_loop(void)
{
uint8 type;
STREAM s;
while ((s = rdp_recv(&type)) != NULL)
{
switch (type)
{
case RDP_PDU_DEMAND_ACTIVE:
process_demand_active(s);
break;
case RDP_PDU_DEACTIVATE:
DEBUG(("RDP_PDU_DEACTIVATE\n"));
/* We thought we could detect a clean
shutdown of the session by this
packet, but it seems Windows 2003
is sending us one of these when we
reconnect to a disconnected session
return True; */
break;
case RDP_PDU_DATA:
process_data_pdu(s);
break;
case 0:
break;
default:
unimpl("PDU %d\n", type);
}
}
return True;
/* We want to detect if we got a clean shutdown, but we
can't. Se above.
return False; */
}
/* used in uiports and rdp_main_loop, processes the rdp packets waiting */
RD_BOOL
rdp_loop(RD_BOOL * deactivated, uint32 * ext_disc_reason)
{
uint8 type;
RD_BOOL cont = True;
STREAM s;
while (cont)
{
s = rdp_recv(&type);
if (s == NULL)
return False;
switch (type)
{
case RDP_PDU_DEMAND_ACTIVE:
process_demand_active(s);
*deactivated = False;
break;
case RDP_PDU_DEACTIVATE:
DEBUG(("RDP_PDU_DEACTIVATE\n"));
*deactivated = True;
break;
case RDP_PDU_REDIRECT:
return process_redirect_pdu(s);
break;
case RDP_PDU_DATA:
process_data_pdu(s, ext_disc_reason);
break;
case 0:
break;
default:
unimpl("PDU %d\n", type);
}
cont = g_next_packet < s->end;
}
return True;
}
