/* 003 */
enum SCP_SERVER_STATES_E
scp_v1s_mng_deny_connection(struct SCP_CONNECTION *c, char *reason)
{
int rlen;
init_stream(c->out_s, c->out_s->size);
/* forcing message not to exceed 64k */
rlen = g_strlen(reason);
if (rlen > 65535)
{
rlen = 65535;
}
out_uint32_be(c->out_s, 1);
/* packet size: 4 + 4 + 2 + 2 + 2 + strlen(reason)*/
/* version + size + cmdset + cmd + msglen + msg */
out_uint32_be(c->out_s, rlen + 14);
out_uint16_be(c->out_s, SCP_COMMAND_SET_MANAGE);
out_uint16_be(c->out_s, SCP_CMD_MNG_LOGIN_DENY);
out_uint16_be(c->out_s, rlen);
out_uint8p(c->out_s, reason, rlen);
if (0 != scp_tcp_force_send(c->in_sck, c->out_s->data, rlen + 14))
{
return SCP_SERVER_STATE_NETWORK_ERR;
}
return SCP_SERVER_STATE_END;
}
/* 046 was: 031 struct SCP_DISCONNECTED_SESSION* ds, */
enum SCP_SERVER_STATES_E
scp_v1s_reconnect_session(struct SCP_CONNECTION* c, SCP_DISPLAY d)
{
tui32 version = 1;
tui32 size = 14;
tui16 cmd = 46;
/* ok, we send session data and display */
init_stream(c->out_s, c->out_s->size);
/* header */
out_uint32_be(c->out_s, version);
out_uint32_be(c->out_s, size);
out_uint16_be(c->out_s, SCP_COMMAND_SET_DEFAULT);
out_uint16_be(c->out_s, cmd);
/* session data */
out_uint16_be(c->out_s, d); /* session display */
/*out_uint8(c->out_s, ds->type);
out_uint16_be(c->out_s, ds->height);
out_uint16_be(c->out_s, ds->width);
out_uint8(c->out_s, ds->bpp);
out_uint8(c->out_s, ds->idle_days);
out_uint8(c->out_s, ds->idle_hours);
out_uint8(c->out_s, ds->idle_minutes);*/
/* these last three are not really needed... */
if (0!=scp_tcp_force_send(c->in_sck, c->out_s->data, size))
{
log_message(LOG_LEVEL_WARNING, "[v1s:%d] connection aborted: network error", __LINE__);
return SCP_SERVER_STATE_NETWORK_ERR;
}
return SCP_SERVER_STATE_OK;
}
enum SCP_SERVER_STATES_E
scp_v1s_deny_connection(struct SCP_CONNECTION* c, char* reason)
{
int rlen;
init_stream(c->out_s,c->out_s->size);
/* forcing message not to exceed 64k */
rlen = g_strlen(reason);
if (rlen > 65535)
{
rlen = 65535;
}
out_uint32_be(c->out_s, 1);
/* packet size: 4 + 4 + 2 + 2 + 2 + strlen(reason)*/
/* version + size + cmdset + cmd + msglen + msg */
out_uint32_be(c->out_s, rlen+14);
out_uint16_be(c->out_s, SCP_COMMAND_SET_DEFAULT);
out_uint16_be(c->out_s, 2);
out_uint16_be(c->out_s, rlen);
out_uint8p(c->out_s, reason, rlen);
if (0!=scp_tcp_force_send(c->in_sck, c->out_s->data, rlen+14))
{
log_message(LOG_LEVEL_WARNING, "[v1s:%d] connection aborted: network error", __LINE__);
return SCP_SERVER_STATE_NETWORK_ERR;
}
return SCP_SERVER_STATE_END;
}
/* 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);
}
/* 030 */
enum SCP_SERVER_STATES_E
scp_v1s_connect_new_session(struct SCP_CONNECTION* c, SCP_DISPLAY d)
{
/* send password request */
tui32 version=1;
tui32 size=14;
tui16 cmd=30;
init_stream(c->out_s, c->out_s->size);
out_uint32_be(c->out_s, version); /* version */
out_uint32_be(c->out_s, size); /* size */
out_uint16_be(c->out_s, SCP_COMMAND_SET_DEFAULT); /* cmdset */
out_uint16_be(c->out_s, cmd); /* cmd */
out_uint16_be(c->out_s, d); /* display */
if (0!=scp_tcp_force_send(c->in_sck, c->out_s->data, 14))
{
log_message(LOG_LEVEL_WARNING, "[v1s:%d] connection aborted: network error", __LINE__);
return SCP_SERVER_STATE_NETWORK_ERR;
}
return SCP_SERVER_STATE_OK;
}
enum SCP_SERVER_STATES_E
scp_v0s_deny_connection(struct SCP_CONNECTION *c)
{
out_uint32_be(c->out_s, 0); /* version */
out_uint32_be(c->out_s, 14); /* size */
out_uint16_be(c->out_s, 3); /* cmd */
out_uint16_be(c->out_s, 0); /* data = 0 - means NOT ok*/
out_uint16_be(c->out_s, 0); /* reserved for display number*/
s_mark_end(c->out_s);
if (0 != scp_tcp_force_send(c->in_sck, c->out_s->data, c->out_s->end - c->out_s->data))
{
log_message(LOG_LEVEL_WARNING, "[v0:%d] connection aborted: network error", __LINE__);
return SCP_SERVER_STATE_NETWORK_ERR;
}
LOG_DBG("[v0:%d] connection terminated (denied)", __LINE__);
return SCP_SERVER_STATE_OK;
}
enum SCP_SERVER_STATES_E
scp_v0s_allow_connection(struct SCP_CONNECTION *c, SCP_DISPLAY d)
{
out_uint32_be(c->out_s, 0); /* version */
out_uint32_be(c->out_s, 14); /* size */
out_uint16_be(c->out_s, 3); /* cmd */
out_uint16_be(c->out_s, 1); /* data */
out_uint16_be(c->out_s, d); /* data */
s_mark_end(c->out_s);
if (0 != scp_tcp_force_send(c->in_sck, c->out_s->data, c->out_s->end - c->out_s->data))
{
log_message(LOG_LEVEL_WARNING, "[v0:%d] connection aborted: network error", __LINE__);
return SCP_SERVER_STATE_NETWORK_ERR;
}
LOG_DBG("[v0:%d] connection terminated (allowed)", __LINE__);
return SCP_SERVER_STATE_OK;
}
/* 002 */
enum SCP_SERVER_STATES_E
scp_v1s_mng_allow_connection(struct SCP_CONNECTION *c, struct SCP_SESSION *s)
{
init_stream(c->out_s, c->out_s->size);
out_uint32_be(c->out_s, 1);
/* packet size: 4 + 4 + 2 + 2 */
/* version + size + cmdset + cmd */
out_uint32_be(c->out_s, 12);
out_uint16_be(c->out_s, SCP_COMMAND_SET_MANAGE);
out_uint16_be(c->out_s, SCP_CMD_MNG_LOGIN_ALLOW);
if (0 != scp_tcp_force_send(c->in_sck, c->out_s->data, 12))
{
return SCP_SERVER_STATE_NETWORK_ERR;
}
return _scp_v1s_mng_check_response(c, s);
}
int DEFAULT_CC
xml_send_error(int client, const char* message)
{
xmlChar* xmlbuff;
xmlDocPtr doc;
xmlNodePtr node;
struct stream* s;
int buff_size, size;
xmlChar* version;
xmlChar* error;
xmlChar* msg;
version = xmlCharStrdup("1.0");
doc = xmlNewDoc(version);
if (doc == NULL)
{
log_message(&(g_cfg->log), LOG_LEVEL_WARNING, "sesman[xml_send_error]: "
"Unable to create the document");
xmlFree(version);
return 0;
}
error = xmlCharStrdup("error");
msg = xmlCharStrdup(message);
doc->encoding = xmlCharStrdup("UTF-8");
node = xmlNewNode(NULL, error);
xmlNodeSetContent(node, msg);
xmlDocSetRootElement(doc, node);
xmlDocDumpFormatMemory(doc, &xmlbuff, &buff_size, 1);
log_message(&(g_cfg->log), LOG_LEVEL_WARNING, "sesman[xml_send_error]: "
"data send : %s",xmlbuff);
make_stream(s);
init_stream(s, buff_size + 6);
out_uint32_be(s,buff_size);
out_uint8p(s, xmlbuff, buff_size)
size = s->p - s->data;
if (g_tcp_can_send(client, 10))
{
buff_size = g_tcp_send(client, s->data, size, 0);
}
else
{
log_message(&(g_cfg->log), LOG_LEVEL_DEBUG_PLUS, "sesman[xml_send_error]: "
"Unable to send xml response: %s, cause: %s", xmlbuff, strerror(g_get_errno()));
}
free_stream(s);
xmlFreeDoc(doc);
xmlFree(xmlbuff);
xmlFree(version);
xmlFree(error);
xmlFree(msg);
return buff_size;
}
enum SCP_SERVER_STATES_E
scp_v0s_replyauthentication(struct SCP_CONNECTION *c, unsigned short int value)
{
out_uint32_be(c->out_s, 0); /* version */
out_uint32_be(c->out_s, 14); /* size */
/* cmd SCP_GW_AUTHENTICATION means authentication reply */
out_uint16_be(c->out_s, SCP_GW_AUTHENTICATION);
out_uint16_be(c->out_s, value); /* reply code */
out_uint16_be(c->out_s, 0); /* dummy data */
s_mark_end(c->out_s);
/* g_writeln("Total number of bytes that will be sent %d",c->out_s->end - c->out_s->data);*/
if (0 != scp_tcp_force_send(c->in_sck, c->out_s->data, c->out_s->end - c->out_s->data))
{
/* until syslog merge log_message(s_log, LOG_LEVEL_WARNING, "[v0:%d] connection aborted: network error", __LINE__); */
return SCP_SERVER_STATE_NETWORK_ERR;
}
/* until syslog merge LOG_DBG(s_log, "[v0:%d] connection terminated (scp_v0s_deny_authentication)", __LINE__);*/
return SCP_SERVER_STATE_OK;
}
/* 032 */
enum SCP_SERVER_STATES_E
scp_v1s_connection_error(struct SCP_CONNECTION* c, char* error)
{
tui16 len;
len = g_strlen(error);
init_stream(c->out_s,c->out_s->size);
out_uint32_be(c->out_s, 1);
/* packet size: 4 + 4 + 2 + 2 + len */
/* version + size + cmdset + cmd */
out_uint32_be(c->out_s, (12 + len));
out_uint16_be(c->out_s, SCP_COMMAND_SET_DEFAULT);
out_uint16_be(c->out_s, SCP_CMD_CONN_ERROR);
if (0 != scp_tcp_force_send(c->in_sck, c->out_s->data, (12 + len)))
{
return SCP_SERVER_STATE_NETWORK_ERR;
}
return SCP_SERVER_STATE_END;
}
int DEFAULT_CC
xml_send_info(int client, xmlDocPtr doc)
{
xmlChar* xmlbuff;
int buff_size, size;
struct stream* s;
xmlDocDumpFormatMemory(doc, &xmlbuff, &buff_size, 1);
log_message(&(g_cfg->log), LOG_LEVEL_DEBUG_PLUS, "sesman[xml_send_info]: "
"data send : %s\n",xmlbuff);
make_stream(s);
init_stream(s, buff_size + 6);
out_uint32_be(s,buff_size);
out_uint8p(s, xmlbuff, buff_size)
size = s->p - s->data;
if (g_tcp_can_send(client, 10))
{
int sended = 0;
int send = 0;
while(sended < size)
{
send = (size-sended) > 2048 ? 2048 : size-sended;
sended += g_tcp_send(client, s->data+sended, send, 0);
if (sended < size)
{
if (g_get_errno() != 0)
{
log_message(&(g_cfg->log), LOG_LEVEL_DEBUG_PLUS, "sesman[xml_send_info]: "
"Error while send %s\n",g_get_strerror());
goto end;
}
}
}
if (sended != size)
{
log_message(&(g_cfg->log), LOG_LEVEL_DEBUG_PLUS, "sesman[xml_send_info]: "
"Error while sending data %i != %i\n",sended, size);
}
}
else
{
log_message(&(g_cfg->log), LOG_LEVEL_DEBUG_PLUS, "sesman[xml_send_info]: "
"Unable to send xml response: %s, cause: %s", xmlbuff, strerror(g_get_errno()));
}
end:
free_stream(s);
xmlFree(xmlbuff);
return buff_size;
}
static void
rdpdr_send_connect(RDPCLIENT * This)
{
uint8 magic[4] = "rDCC";
STREAM s;
s = channel_init(This, This->rdpdr.channel, 12);
out_uint8a(s, magic, 4);
out_uint16_le(s, 1); /* unknown */
out_uint16_le(s, 5);
out_uint32_be(s, 0x815ed39d); /* IP address (use 127.0.0.1) 0x815ed39d */
s_mark_end(s);
channel_send(This, s, This->rdpdr.channel);
}
/* 006 */
enum SCP_SERVER_STATES_E
scp_v1s_mng_list_sessions(struct SCP_CONNECTION *c, struct SCP_SESSION *s,
int sescnt, struct SCP_DISCONNECTED_SESSION *ds)
{
tui32 version = 1;
tui32 size = 12;
tui16 cmd = SCP_CMD_MNG_LIST;
int pktcnt;
int idx;
int sidx;
int pidx;
struct SCP_DISCONNECTED_SESSION *cds;
/* calculating the number of packets to send */
pktcnt = sescnt / SCP_SERVER_MAX_LIST_SIZE;
if ((sescnt % SCP_SERVER_MAX_LIST_SIZE) != 0)
{
pktcnt++;
}
for (idx = 0; idx < pktcnt; idx++)
{
/* ok, we send session session list */
init_stream(c->out_s, c->out_s->size);
/* size: ver+size+cmdset+cmd+sescnt+continue+count */
size = 4 + 4 + 2 + 2 + 4 + 1 + 1;
/* header */
s_push_layer(c->out_s, channel_hdr, 8);
out_uint16_be(c->out_s, SCP_COMMAND_SET_MANAGE);
out_uint16_be(c->out_s, cmd);
/* session count */
out_uint32_be(c->out_s, sescnt);
/* setting the continue flag */
if ((idx + 1)*SCP_SERVER_MAX_LIST_SIZE >= sescnt)
{
out_uint8(c->out_s, 0);
/* setting session count for this packet */
pidx = sescnt - (idx * SCP_SERVER_MAX_LIST_SIZE);
out_uint8(c->out_s, pidx);
}
else
{
out_uint8(c->out_s, 1);
/* setting session count for this packet */
pidx = SCP_SERVER_MAX_LIST_SIZE;
out_uint8(c->out_s, pidx);
}
/* adding session descriptors */
for (sidx = 0; sidx < pidx; sidx++)
{
/* shortcut to the current session to send */
cds = ds + ((idx) * SCP_SERVER_MAX_LIST_SIZE) + sidx;
/* session data */
out_uint32_be(c->out_s, cds->SID); /* session id */
out_uint8(c->out_s, cds->type);
out_uint16_be(c->out_s, cds->height);
out_uint16_be(c->out_s, cds->width);
out_uint8(c->out_s, cds->bpp);
out_uint8(c->out_s, cds->idle_days);
out_uint8(c->out_s, cds->idle_hours);
out_uint8(c->out_s, cds->idle_minutes);
size += 13;
out_uint16_be(c->out_s, cds->conn_year);
out_uint8(c->out_s, cds->conn_month);
out_uint8(c->out_s, cds->conn_day);
out_uint8(c->out_s, cds->conn_hour);
out_uint8(c->out_s, cds->conn_minute);
out_uint8(c->out_s, cds->addr_type);
size += 7;
if (cds->addr_type == SCP_ADDRESS_TYPE_IPV4)
{
in_uint32_be(c->out_s, cds->ipv4addr);
size += 4;
}
else if (cds->addr_type == SCP_ADDRESS_TYPE_IPV6)
{
in_uint8a(c->out_s, cds->ipv6addr, 16);
size += 16;
}
}
s_pop_layer(c->out_s, channel_hdr);
out_uint32_be(c->out_s, version);
out_uint32_be(c->out_s, size);
if (0 != scp_tcp_force_send(c->in_sck, c->out_s->data, size))
{
log_message(LOG_LEVEL_WARNING, "[v1s_mng:%d] connection aborted: network error", __LINE__);
return SCP_SERVER_STATE_NETWORK_ERR;
}
}
return _scp_v1s_mng_check_response(c, s);
}
/* 001 */
enum SCP_CLIENT_STATES_E
scp_v1c_mng_connect(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 + 4 + g_strlen(s->hostname) + g_strlen(s->username) +
g_strlen(s->password);
if (s->addr_type == SCP_ADDRESS_TYPE_IPV4)
{
size = size + 4;
}
else
{
size = size + 16;
}
/* 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_MANAGE);
out_uint16_be(c->out_s, SCP_CMD_MNG_LOGIN);
/* data */
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);
/* address */
out_uint8(c->out_s, s->addr_type);
if (s->addr_type == SCP_ADDRESS_TYPE_IPV4)
{
out_uint32_be(c->out_s, s->ipv4addr);
}
else
{
out_uint8p(c->out_s, s->ipv6addr, 16);
}
/* hostname */
sz = g_strlen(s->hostname);
out_uint8(c->out_s, sz);
out_uint8p(c->out_s, s->hostname, sz);
if (0 != scp_tcp_force_send(c->in_sck, c->out_s->data, size))
{
log_message(LOG_LEVEL_WARNING, "[v1c_mng:%d] connection aborted: network error", __LINE__);
return SCP_CLIENT_STATE_NETWORK_ERR;
}
/* wait for response */
return _scp_v1c_mng_check_response(c, s);
}
/* 001 */
enum SCP_CLIENT_STATES_E
scp_v1c_connect(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 = 19 + 17 + 4 + g_strlen(s->hostname) + g_strlen(s->username) +
g_strlen(s->password);
if (s->addr_type == SCP_ADDRESS_TYPE_IPV4)
{
size = size + 4;
}
else
{
size = size + 16;
}
/* 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, 1);
/* body */
out_uint8(c->out_s, s->type);
out_uint16_be(c->out_s, s->height);
out_uint16_be(c->out_s, s->width);
out_uint8(c->out_s, s->bpp);
out_uint8(c->out_s, s->rsr);
out_uint8p(c->out_s, s->locale, 17);
out_uint8(c->out_s, s->addr_type);
if (s->addr_type == SCP_ADDRESS_TYPE_IPV4)
{
out_uint32_be(c->out_s, s->ipv4addr);
}
else if (s->addr_type == SCP_ADDRESS_TYPE_IPV6)
{
out_uint8p(c->out_s, s->ipv6addr, 16);
}
sz = g_strlen(s->hostname);
out_uint8(c->out_s, sz);
out_uint8p(c->out_s, s->hostname, sz);
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);
}
/* 004 */
enum SCP_CLIENT_STATES_E
scp_v1c_mng_get_session_list(struct SCP_CONNECTION *c, int *scount,
struct SCP_DISCONNECTED_SESSION **s)
{
tui32 version = 1;
tui32 size = 12;
tui16 cmd = SCP_CMD_MNG_LIST_REQ; /* request session list */
tui32 sescnt = 0; /* total session number */
tui32 sestmp = 0; /* additional total session number */
tui8 pktcnt = 0; /* packet session count */
tui32 totalcnt = 0; /* session counter */
tui8 continued = 0; /* continue flag */
int firstpkt = 1; /* "first packet" flag */
int idx;
struct SCP_DISCONNECTED_SESSION *ds = 0;
// tui8 addr[16];
init_stream(c->out_s, c->out_s->size);
/* we request session list */
out_uint32_be(c->out_s, version); /* version */
out_uint32_be(c->out_s, size); /* size */
out_uint16_be(c->out_s, SCP_COMMAND_SET_MANAGE); /* cmdset */
out_uint16_be(c->out_s, cmd); /* cmd */
if (0 != scp_tcp_force_send(c->in_sck, c->out_s->data, size))
{
log_message(LOG_LEVEL_WARNING, "[v1c_mng:%d] connection aborted: network error", __LINE__);
return SCP_CLIENT_STATE_NETWORK_ERR;
}
do
{
/* then we wait for server response */
init_stream(c->in_s, c->in_s->size);
if (0 != scp_tcp_force_recv(c->in_sck, c->in_s->data, 8))
{
log_message(LOG_LEVEL_WARNING, "[v1c_mng:%d] connection aborted: network error", __LINE__);
return SCP_CLIENT_STATE_NETWORK_ERR;
}
in_uint32_be(c->in_s, version);
if (version != 1)
{
log_message(LOG_LEVEL_WARNING, "[v1c_mng:%d] connection aborted: version error", __LINE__);
return SCP_CLIENT_STATE_VERSION_ERR;
}
in_uint32_be(c->in_s, size);
if (size < 12)
{
log_message(LOG_LEVEL_WARNING, "[v1c_mng:%d] connection aborted: size error", __LINE__);
return SCP_CLIENT_STATE_SIZE_ERR;
}
init_stream(c->in_s, c->in_s->size);
if (0 != scp_tcp_force_recv(c->in_sck, c->in_s->data, size - 8))
{
log_message(LOG_LEVEL_WARNING, "[v1c_mng:%d] connection aborted: network error", __LINE__);
return SCP_CLIENT_STATE_NETWORK_ERR;
}
in_uint16_be(c->in_s, cmd);
if (cmd != SCP_COMMAND_SET_MANAGE)
{
log_message(LOG_LEVEL_WARNING, "[v1c_mng:%d] connection aborted: sequence error", __LINE__);
return SCP_CLIENT_STATE_SEQUENCE_ERR;
}
in_uint16_be(c->in_s, cmd);
if (cmd != SCP_CMD_MNG_LIST) /* session list */
{
log_message(LOG_LEVEL_WARNING, "[v1c_mng:%d] connection aborted: sequence error", __LINE__);
return SCP_CLIENT_STATE_SEQUENCE_ERR;
}
if (firstpkt)
{
firstpkt = 0;
in_uint32_be(c->in_s, sescnt);
sestmp = sescnt;
if (0 == sescnt)
{
/* return data... */
(*scount) = sescnt;
(*s) = NULL;
LOG_DBG("[v1c_mng] end list - no session on TS");
return SCP_CLIENT_STATE_LIST_OK;
}
ds = g_malloc(sizeof(struct SCP_DISCONNECTED_SESSION) * sescnt, 0);
if (ds == 0)
{
log_message(LOG_LEVEL_WARNING, "[v1c_mng:%d] connection aborted: internal error", __LINE__);
return SCP_CLIENT_STATE_INTERNAL_ERR;
}
}
else
{
in_uint32_be(c->in_s, sestmp);
}
in_uint8(c->in_s, continued);
in_uint8(c->in_s, pktcnt);
for (idx = 0; idx < pktcnt; idx++)
{
in_uint32_be(c->in_s, (ds[totalcnt]).SID); /* session id */
in_uint8(c->in_s, (ds[totalcnt]).type);
in_uint16_be(c->in_s, (ds[totalcnt]).height);
in_uint16_be(c->in_s, (ds[totalcnt]).width);
in_uint8(c->in_s, (ds[totalcnt]).bpp);
in_uint8(c->in_s, (ds[totalcnt]).idle_days);
in_uint8(c->in_s, (ds[totalcnt]).idle_hours);
in_uint8(c->in_s, (ds[totalcnt]).idle_minutes);
in_uint16_be(c->in_s, (ds[totalcnt]).conn_year);
in_uint8(c->in_s, (ds[totalcnt]).conn_month);
in_uint8(c->in_s, (ds[totalcnt]).conn_day);
in_uint8(c->in_s, (ds[totalcnt]).conn_hour);
in_uint8(c->in_s, (ds[totalcnt]).conn_minute);
in_uint8(c->in_s, (ds[totalcnt]).addr_type);
if ((ds[totalcnt]).addr_type == SCP_ADDRESS_TYPE_IPV4)
{
in_uint32_be(c->in_s, (ds[totalcnt]).ipv4addr);
}
if ((ds[totalcnt]).addr_type == SCP_ADDRESS_TYPE_IPV6)
{
in_uint8a(c->in_s, (ds[totalcnt]).ipv6addr, 16);
}
totalcnt++;
}
}
while (continued);
/* return data... */
(*scount) = sescnt;
(*s) = ds;
LOG_DBG("[v1c_mng] end list");
return SCP_CLIENT_STATE_LIST_OK;
}
/* 041 */
enum SCP_CLIENT_STATES_E
scp_v1c_get_session_list(struct SCP_CONNECTION *c, int *scount,
struct SCP_DISCONNECTED_SESSION **s)
{
tui32 version = 1;
tui32 size = 12;
tui16 cmd = 41;
tui32 sescnt = 0; /* total session number */
tui32 sestmp = 0; /* additional total session number */
tui8 pktcnt = 0; /* packet session count */
tui32 totalcnt = 0; /* session counter */
tui8 continued = 0; /* continue flag */
int firstpkt = 1; /* "first packet" flag */
int idx;
struct SCP_DISCONNECTED_SESSION *ds = 0;
init_stream(c->out_s, c->out_s->size);
/* we request session list */
out_uint32_be(c->out_s, version); /* version */
out_uint32_be(c->out_s, size); /* size */
out_uint16_be(c->out_s, SCP_COMMAND_SET_DEFAULT); /* cmdset */
out_uint16_be(c->out_s, cmd); /* cmd */
if (0 != scp_tcp_force_send(c->in_sck, c->out_s->data, size))
{
return SCP_CLIENT_STATE_NETWORK_ERR;
}
do
{
/* then we wait for server response */
init_stream(c->in_s, c->in_s->size);
if (0 != scp_tcp_force_recv(c->in_sck, c->in_s->data, 8))
{
return SCP_CLIENT_STATE_NETWORK_ERR;
}
in_uint32_be(c->in_s, version);
if (version != 1)
{
return SCP_CLIENT_STATE_VERSION_ERR;
}
in_uint32_be(c->in_s, size);
if (size < 12)
{
return SCP_CLIENT_STATE_SIZE_ERR;
}
init_stream(c->in_s, c->in_s->size);
if (0 != scp_tcp_force_recv(c->in_sck, c->in_s->data, size - 8))
{
return SCP_CLIENT_STATE_NETWORK_ERR;
}
in_uint16_be(c->in_s, cmd);
if (cmd != SCP_COMMAND_SET_DEFAULT)
{
return SCP_CLIENT_STATE_SEQUENCE_ERR;
}
in_uint16_be(c->in_s, cmd);
if (cmd != 42)
{
return SCP_CLIENT_STATE_SEQUENCE_ERR;
}
if (firstpkt)
{
firstpkt = 0;
in_uint32_be(c->in_s, sescnt);
sestmp = sescnt;
ds = g_new(struct SCP_DISCONNECTED_SESSION, sescnt);
if (ds == 0)
{
return SCP_CLIENT_STATE_INTERNAL_ERR;
}
}
else
{
in_uint32_be(c->in_s, sestmp);
}
in_uint8(c->in_s, continued);
in_uint8(c->in_s, pktcnt);
for (idx = 0; idx < pktcnt; idx++)
{
in_uint32_be(c->in_s, (ds[totalcnt]).SID); /* session id */
in_uint8(c->in_s, (ds[totalcnt]).type);
in_uint16_be(c->in_s, (ds[totalcnt]).height);
in_uint16_be(c->in_s, (ds[totalcnt]).width);
in_uint8(c->in_s, (ds[totalcnt]).bpp);
in_uint8(c->in_s, (ds[totalcnt]).idle_days);
in_uint8(c->in_s, (ds[totalcnt]).idle_hours);
in_uint8(c->in_s, (ds[totalcnt]).idle_minutes);
in_uint16_be(c->in_s, (ds[totalcnt]).conn_year);
in_uint8(c->in_s, (ds[totalcnt]).conn_month);
in_uint8(c->in_s, (ds[totalcnt]).conn_day);
in_uint8(c->in_s, (ds[totalcnt]).conn_hour);
in_uint8(c->in_s, (ds[totalcnt]).conn_minute);
in_uint8(c->in_s, (ds[totalcnt]).addr_type);
if ((ds[totalcnt]).addr_type == SCP_ADDRESS_TYPE_IPV4)
{
in_uint32_be(c->in_s, (ds[totalcnt]).ipv4addr);
}
else if ((ds[totalcnt]).addr_type == SCP_ADDRESS_TYPE_IPV6)
{
in_uint8a(c->in_s, (ds[totalcnt]).ipv6addr, 16);
}
totalcnt++;
}
}
enum SCP_CLIENT_STATES_E
scp_v0c_connect(struct SCP_CONNECTION *c, struct SCP_SESSION *s)
{
tui32 version;
tui32 size;
tui16 sz;
init_stream(c->in_s, c->in_s->size);
init_stream(c->out_s, c->in_s->size);
LOG_DBG("[v0:%d] starting connection", __LINE__);
g_tcp_set_non_blocking(c->in_sck);
g_tcp_set_no_delay(c->in_sck);
s_push_layer(c->out_s, channel_hdr, 8);
/* code */
if (s->type == SCP_SESSION_TYPE_XVNC)
{
out_uint16_be(c->out_s, 0);
}
else if (s->type == SCP_SESSION_TYPE_XRDP)
{
out_uint16_be(c->out_s, 10);
}
else if (s->type == SCP_SESSION_TYPE_XORG)
{
out_uint16_be(c->out_s, 20);
}
else
{
log_message(LOG_LEVEL_WARNING, "[v0:%d] connection aborted: network error", __LINE__);
return SCP_CLIENT_STATE_INTERNAL_ERR;
}
sz = g_strlen(s->username);
out_uint16_be(c->out_s, sz);
out_uint8a(c->out_s, s->username, sz);
sz = g_strlen(s->password);
out_uint16_be(c->out_s, sz);
out_uint8a(c->out_s, s->password, sz);
out_uint16_be(c->out_s, s->width);
out_uint16_be(c->out_s, s->height);
out_uint16_be(c->out_s, s->bpp);
s_mark_end(c->out_s);
s_pop_layer(c->out_s, channel_hdr);
/* version */
out_uint32_be(c->out_s, 0);
/* size */
out_uint32_be(c->out_s, c->out_s->end - c->out_s->data);
if (0 != scp_tcp_force_send(c->in_sck, c->out_s->data, c->out_s->end - c->out_s->data))
{
log_message(LOG_LEVEL_WARNING, "[v0:%d] connection aborted: network error", __LINE__);
return SCP_CLIENT_STATE_NETWORK_ERR;
}
if (0 != scp_tcp_force_recv(c->in_sck, c->in_s->data, 8))
{
log_message(LOG_LEVEL_WARNING, "[v0:%d] connection aborted: network error", __LINE__);
return SCP_CLIENT_STATE_NETWORK_ERR;
}
in_uint32_be(c->in_s, version);
if (0 != version)
{
log_message(LOG_LEVEL_WARNING, "[v0:%d] connection aborted: version error", __LINE__);
return SCP_CLIENT_STATE_VERSION_ERR;
}
in_uint32_be(c->in_s, size);
if (size < 14)
{
log_message(LOG_LEVEL_WARNING, "[v0:%d] connection aborted: packet size error", __LINE__);
return SCP_CLIENT_STATE_SIZE_ERR;
}
/* getting payload */
init_stream(c->in_s, c->in_s->size);
if (0 != scp_tcp_force_recv(c->in_sck, c->in_s->data, size - 8))
{
log_message(LOG_LEVEL_WARNING, "[v0:%d] connection aborted: network error", __LINE__);
return SCP_CLIENT_STATE_NETWORK_ERR;
}
/* check code */
in_uint16_be(c->in_s, sz);
if (3 != sz)
{
log_message(LOG_LEVEL_WARNING, "[v0:%d] connection aborted: sequence error", __LINE__);
return SCP_CLIENT_STATE_SEQUENCE_ERR;
}
/* message payload */
in_uint16_be(c->in_s, sz);
if (1 != sz)
{
log_message(LOG_LEVEL_WARNING, "[v0:%d] connection aborted: connection denied", __LINE__);
return SCP_CLIENT_STATE_CONNECTION_DENIED;
}
in_uint16_be(c->in_s, sz);
s->display = sz;
LOG_DBG("[v0:%d] connection terminated", __LINE__);
return SCP_CLIENT_STATE_END;
}
int DEFAULT_CC
main(int argc, char** argv)
{
int sck;
int code;
int i;
int size;
int version;
int width;
int height;
int bpp;
int keylayout;
int display;
struct stream* in_s;
struct stream* out_s;
char* username;
char* password;
char* exec;
long data;
if (0 != config_read(&g_cfg))
{
g_printf("sesrun: error reading config. quitting.\n");
return 1;
}
g_pid = g_getpid();
if (argc == 1)
{
g_printf("xrdp session starter v0.2\n");
g_printf("\nusage:\n");
g_printf("sesrun <server> <username> <password> <exec> <width> <height> <bpp> <keylayout>\n");
}
else if (argc == 9)
{
username = argv[2];
password = argv[3];
exec = argv[4];
width = g_atoi(argv[5]);
height = g_atoi(argv[6]);
bpp = g_atoi(argv[7]);
keylayout = g_atoi(argv[8]);
make_stream(in_s);
init_stream(in_s, 8192);
make_stream(out_s);
init_stream(out_s, 8192);
sck = g_tcp_socket();
if (g_tcp_connect(sck, argv[1], "3350") == 0)
{
s_push_layer(out_s, channel_hdr, 8);
out_uint16_be(out_s, 20); /* code */
i = g_strlen(username);
out_uint16_be(out_s, i);
out_uint8a(out_s, username, i);
i = g_strlen(password);
out_uint16_be(out_s, i);
out_uint8a(out_s, password, i);
i = g_strlen(exec);
out_uint16_be(out_s, i);
out_uint8a(out_s, exec, i);
out_uint16_be(out_s, width);
out_uint16_be(out_s, height);
out_uint16_be(out_s, bpp);
out_uint16_be(out_s, keylayout);
s_mark_end(out_s);
s_pop_layer(out_s, channel_hdr);
out_uint32_be(out_s, 0); /* version */
out_uint32_be(out_s, out_s->end - out_s->data); /* size */
tcp_force_send(sck, out_s->data, out_s->end - out_s->data);
if (tcp_force_recv(sck, in_s->data, 8) == 0)
{
in_uint32_be(in_s, version);
in_uint32_be(in_s, size);
init_stream(in_s, 8192);
if (tcp_force_recv(sck, in_s->data, size - 8) == 0)
{
if (version == 0)
{
in_uint16_be(in_s, code);
if (code == 3)
{
in_uint16_be(in_s, data);
in_uint16_be(in_s, display);
g_printf("ok %d display %d\n", data, display);
}
}
}
}
}
else
{
g_printf("connect error\n");
}
g_tcp_close(sck);
free_stream(in_s);
free_stream(out_s);
}
return 0;
}
enum SCP_SERVER_STATES_E
scp_v1s_request_password(struct SCP_CONNECTION* c, struct SCP_SESSION* s, char* reason)
{
tui8 sz;
tui32 version;
tui32 size;
tui16 cmdset;
tui16 cmd;
int rlen;
char buf[257];
init_stream(c->in_s, c->in_s->size);
init_stream(c->out_s, c->out_s->size);
/* forcing message not to exceed 64k */
rlen = g_strlen(reason);
if (rlen > 65535)
{
rlen = 65535;
}
/* send password request */
version=1;
cmd=3;
out_uint32_be(c->out_s, version); /* version */
out_uint32_be(c->out_s, 14+rlen); /* size */
out_uint16_be(c->out_s, SCP_COMMAND_SET_DEFAULT); /* cmdset */
out_uint16_be(c->out_s, cmd); /* cmd */
out_uint16_be(c->out_s, rlen);
out_uint8p(c->out_s, reason, rlen);
if (0!=scp_tcp_force_send(c->in_sck, c->out_s->data, 14+rlen))
{
log_message(LOG_LEVEL_WARNING, "[v1s:%d] connection aborted: network error", __LINE__);
return SCP_SERVER_STATE_NETWORK_ERR;
}
/* receive password & username */
if (0!=scp_tcp_force_recv(c->in_sck, c->in_s->data, 8))
{
log_message(LOG_LEVEL_WARNING, "[v1s:%d] connection aborted: network error", __LINE__);
return SCP_SERVER_STATE_NETWORK_ERR;
}
in_uint32_be(c->in_s, version);
if (version!=1)
{
log_message(LOG_LEVEL_WARNING, "[v1s:%d] connection aborted: version error", __LINE__);
return SCP_SERVER_STATE_VERSION_ERR;
}
in_uint32_be(c->in_s, size);
if (size<12)
{
log_message(LOG_LEVEL_WARNING, "[v1s:%d] connection aborted: size error", __LINE__);
return SCP_SERVER_STATE_SIZE_ERR;
}
init_stream(c->in_s, c->in_s->size);
if (0!=scp_tcp_force_recv(c->in_sck, c->in_s->data, (size-8)))
{
log_message(LOG_LEVEL_WARNING, "[v1s:%d] connection aborted: network error", __LINE__);
return SCP_SERVER_STATE_NETWORK_ERR;
}
in_uint16_be(c->in_s, cmdset);
if (cmdset != SCP_COMMAND_SET_DEFAULT)
{
log_message(LOG_LEVEL_WARNING, "[v1s:%d] connection aborted: sequence error", __LINE__);
return SCP_SERVER_STATE_SEQUENCE_ERR;
}
in_uint16_be(c->in_s, cmd);
if (cmd != 4)
{
log_message(LOG_LEVEL_WARNING, "[v1s:%d] connection aborted: sequence error", __LINE__);
return SCP_SERVER_STATE_SEQUENCE_ERR;
}
buf[256] = '\0';
/* reading username */
in_uint8(c->in_s, sz);
buf[sz] = '\0';
in_uint8a(c->in_s, buf, sz);
if (0 != scp_session_set_username(s, buf))
{
scp_session_destroy(s);
log_message(LOG_LEVEL_WARNING, "[v1s:%d] connection aborted: internal error", __LINE__);
return SCP_SERVER_STATE_INTERNAL_ERR;
}
/* reading password */
in_uint8(c->in_s, sz);
buf[sz]='\0';
in_uint8a(c->in_s, buf, sz);
if (0 != scp_session_set_password(s, buf))
{
scp_session_destroy(s);
log_message(LOG_LEVEL_WARNING, "[v1s:%d] connection aborted: internal error", __LINE__);
return SCP_SERVER_STATE_INTERNAL_ERR;
}
return SCP_SERVER_STATE_OK;
}
int APP_CC
xrdp_caps_send_demand_active(struct xrdp_rdp *self)
{
struct stream *s;
int caps_count;
int caps_size;
int codec_caps_count;
int codec_caps_size;
int flags;
char *caps_count_ptr;
char *caps_size_ptr;
char *caps_ptr;
char *codec_caps_count_ptr;
char *codec_caps_size_ptr;
make_stream(s);
init_stream(s, 8192);
DEBUG(("in xrdp_caps_send_demand_active"));
if (xrdp_rdp_init(self, s) != 0)
{
free_stream(s);
return 1;
}
caps_count = 0;
out_uint32_le(s, self->share_id);
out_uint16_le(s, 4); /* 4 chars for RDP\0 */
/* 2 bytes size after num caps, set later */
caps_size_ptr = s->p;
out_uint8s(s, 2);
out_uint8a(s, "RDP", 4);
/* 4 byte num caps, set later */
caps_count_ptr = s->p;
out_uint8s(s, 4);
caps_ptr = s->p;
/* Output share capability set */
caps_count++;
out_uint16_le(s, RDP_CAPSET_SHARE);
out_uint16_le(s, RDP_CAPLEN_SHARE);
out_uint16_le(s, self->mcs_channel);
out_uint16_be(s, 0xb5e2); /* 0x73e1 */
/* Output general capability set */
caps_count++;
out_uint16_le(s, RDP_CAPSET_GENERAL); /* 1 */
out_uint16_le(s, RDP_CAPLEN_GENERAL); /* 24(0x18) */
out_uint16_le(s, 1); /* OS major type */
out_uint16_le(s, 3); /* OS minor type */
out_uint16_le(s, 0x200); /* Protocol version */
out_uint16_le(s, 0); /* pad */
out_uint16_le(s, 0); /* Compression types */
/* NO_BITMAP_COMPRESSION_HDR 0x0400
FASTPATH_OUTPUT_SUPPORTED 0x0001 */
if (self->client_info.use_fast_path & 1)
{
out_uint16_le(s, 0x401);
}
else
{
out_uint16_le(s, 0x400);
}
out_uint16_le(s, 0); /* Update capability */
out_uint16_le(s, 0); /* Remote unshare capability */
out_uint16_le(s, 0); /* Compression level */
out_uint16_le(s, 0); /* Pad */
/* Output bitmap capability set */
caps_count++;
out_uint16_le(s, RDP_CAPSET_BITMAP); /* 2 */
out_uint16_le(s, RDP_CAPLEN_BITMAP); /* 28(0x1c) */
out_uint16_le(s, self->client_info.bpp); /* Preferred BPP */
out_uint16_le(s, 1); /* Receive 1 BPP */
out_uint16_le(s, 1); /* Receive 4 BPP */
out_uint16_le(s, 1); /* Receive 8 BPP */
out_uint16_le(s, self->client_info.width); /* width */
out_uint16_le(s, self->client_info.height); /* height */
out_uint16_le(s, 0); /* Pad */
out_uint16_le(s, 1); /* Allow resize */
out_uint16_le(s, 1); /* bitmap compression */
out_uint16_le(s, 0); /* unknown */
out_uint16_le(s, 0); /* unknown */
out_uint16_le(s, 0); /* pad */
/* Output font capability set */
caps_count++;
out_uint16_le(s, RDP_CAPSET_FONT); /* 14 */
out_uint16_le(s, RDP_CAPLEN_FONT); /* 4 */
/* Output order capability set */
caps_count++;
out_uint16_le(s, RDP_CAPSET_ORDER); /* 3 */
out_uint16_le(s, RDP_CAPLEN_ORDER); /* 88(0x58) */
out_uint8s(s, 16);
out_uint32_be(s, 0x40420f00);
out_uint16_le(s, 1); /* Cache X granularity */
out_uint16_le(s, 20); /* Cache Y granularity */
out_uint16_le(s, 0); /* Pad */
out_uint16_le(s, 1); /* Max order level */
out_uint16_le(s, 0x2f); /* Number of fonts */
out_uint16_le(s, 0x22); /* Capability flags */
/* caps */
out_uint8(s, 1); /* NEG_DSTBLT_INDEX 0x00 0 */
out_uint8(s, 1); /* NEG_PATBLT_INDEX 0x01 1 */
out_uint8(s, 1); /* NEG_SCRBLT_INDEX 0x02 2 */
out_uint8(s, 1); /* NEG_MEMBLT_INDEX 0x03 3 */
out_uint8(s, 0); /* NEG_MEM3BLT_INDEX 0x04 4 */
out_uint8(s, 0); /* NEG_ATEXTOUT_INDEX 0x05 5 */
out_uint8(s, 0); /* NEG_AEXTTEXTOUT_INDEX 0x06 6 */
out_uint8(s, 0); /* NEG_DRAWNINEGRID_INDEX 0x07 7 */
out_uint8(s, 1); /* NEG_LINETO_INDEX 0x08 8 */
out_uint8(s, 0); /* NEG_MULTI_DRAWNINEGRID_INDEX 0x09 9 */
out_uint8(s, 1); /* NEG_OPAQUE_RECT_INDEX 0x0A 10 */
out_uint8(s, 0); /* NEG_SAVEBITMAP_INDEX 0x0B 11 */
out_uint8(s, 0); /* NEG_WTEXTOUT_INDEX 0x0C 12 */
out_uint8(s, 0); /* NEG_MEMBLT_V2_INDEX 0x0D 13 */
out_uint8(s, 0); /* NEG_MEM3BLT_V2_INDEX 0x0E 14 */
out_uint8(s, 0); /* NEG_MULTIDSTBLT_INDEX 0x0F 15 */
out_uint8(s, 0); /* NEG_MULTIPATBLT_INDEX 0x10 16 */
out_uint8(s, 0); /* NEG_MULTISCRBLT_INDEX 0x11 17 */
out_uint8(s, 1); /* NEG_MULTIOPAQUERECT_INDEX 0x12 18 */
out_uint8(s, 0); /* NEG_FAST_INDEX_INDEX 0x13 19 */
out_uint8(s, 0); /* NEG_POLYGON_SC_INDEX 0x14 20 */
out_uint8(s, 0); /* NEG_POLYGON_CB_INDEX 0x15 21 */
out_uint8(s, 0); /* NEG_POLYLINE_INDEX 0x16 22 */
out_uint8(s, 0); /* unused 0x17 23 */
out_uint8(s, 0); /* NEG_FAST_GLYPH_INDEX 0x18 24 */
out_uint8(s, 0); /* NEG_ELLIPSE_SC_INDEX 0x19 25 */
out_uint8(s, 0); /* NEG_ELLIPSE_CB_INDEX 0x1A 26 */
out_uint8(s, 1); /* NEG_GLYPH_INDEX_INDEX 0x1B 27 */
out_uint8(s, 0); /* NEG_GLYPH_WEXTTEXTOUT_INDEX 0x1C 28 */
out_uint8(s, 0); /* NEG_GLYPH_WLONGTEXTOUT_INDEX 0x1D 29 */
out_uint8(s, 0); /* NEG_GLYPH_WLONGEXTTEXTOUT_INDEX 0x1E 30 */
out_uint8(s, 0); /* unused 0x1F 31 */
out_uint16_le(s, 0x6a1);
/* declare support of bitmap cache rev3 */
out_uint16_le(s, XR_ORDERFLAGS_EX_CACHE_BITMAP_REV3_SUPPORT);
out_uint32_le(s, 0x0f4240); /* desk save */
out_uint32_le(s, 0x0f4240); /* desk save */
out_uint32_le(s, 1); /* ? */
out_uint32_le(s, 0); /* ? */
/* Output bmpcodecs capability set */
caps_count++;
out_uint16_le(s, RDP_CAPSET_BMPCODECS);
codec_caps_size_ptr = s->p;
out_uint8s(s, 2); /* cap len set later */
codec_caps_count = 0;
codec_caps_count_ptr = s->p;
out_uint8s(s, 1); /* bitmapCodecCount set later */
/* nscodec */
codec_caps_count++;
out_uint8a(s, XR_CODEC_GUID_NSCODEC, 16);
out_uint8(s, 1); /* codec id, must be 1 */
out_uint16_le(s, 3); /* codecPropertiesLength */
out_uint8(s, 0x01); /* fAllowDynamicFidelity */
out_uint8(s, 0x01); /* fAllowSubsampling */
out_uint8(s, 0x03); /* colorLossLevel */
#if defined(XRDP_RFXCODEC) || defined(XRDP_NEUTRINORDP)
/* remotefx */
codec_caps_count++;
out_uint8a(s, XR_CODEC_GUID_REMOTEFX, 16);
out_uint8(s, 0); /* codec id, client sets */
out_uint16_le(s, 4); /* codecPropertiesLength */
out_uint32_le(s, 0); /* reserved */
/* image remotefx */
codec_caps_count++;
out_uint8a(s, XR_CODEC_GUID_IMAGE_REMOTEFX, 16);
out_uint8(s, 0); /* codec id, client sets */
out_uint16_le(s, 4); /* codecPropertiesLength */
out_uint32_le(s, 0); /* reserved */
#endif
/* jpeg */
codec_caps_count++;
out_uint8a(s, XR_CODEC_GUID_JPEG, 16);
out_uint8(s, 0); /* codec id, client sets */
out_uint16_le(s, 1); /* codecPropertiesLength */
out_uint8(s, 75); /* jpeg compression ratio */
/* calculate and set size and count */
codec_caps_size = (int)(s->p - codec_caps_size_ptr);
codec_caps_size += 2; /* 2 bytes for RDP_CAPSET_BMPCODECS above */
codec_caps_size_ptr[0] = codec_caps_size;
codec_caps_size_ptr[1] = codec_caps_size >> 8;
codec_caps_count_ptr[0] = codec_caps_count;
/* Output color cache capability set */
caps_count++;
out_uint16_le(s, RDP_CAPSET_COLCACHE);
out_uint16_le(s, RDP_CAPLEN_COLCACHE);
out_uint16_le(s, 6); /* cache size */
out_uint16_le(s, 0); /* pad */
/* Output pointer capability set */
caps_count++;
out_uint16_le(s, RDP_CAPSET_POINTER);
out_uint16_le(s, RDP_CAPLEN_POINTER);
out_uint16_le(s, 1); /* Colour pointer */
out_uint16_le(s, 0x19); /* Cache size */
out_uint16_le(s, 0x19); /* Cache size */
/* Output input capability set */
caps_count++;
out_uint16_le(s, RDP_CAPSET_INPUT); /* 13(0xd) */
out_uint16_le(s, RDP_CAPLEN_INPUT); /* 88(0x58) */
flags = INPUT_FLAG_SCANCODES | INPUT_FLAG_MOUSEX | INPUT_FLAG_UNICODE;
if (self->client_info.use_fast_path & 2)
{
flags |= INPUT_FLAG_FASTPATH_INPUT | INPUT_FLAG_FASTPATH_INPUT2;
}
out_uint16_le(s, flags);
out_uint8s(s, 82);
/* Remote Programs Capability Set */
caps_count++;
out_uint16_le(s, 0x0017); /* CAPSETTYPE_RAIL */
out_uint16_le(s, 8);
out_uint32_le(s, 3); /* TS_RAIL_LEVEL_SUPPORTED
TS_RAIL_LEVEL_DOCKED_LANGBAR_SUPPORTED */
/* Window List Capability Set */
caps_count++;
out_uint16_le(s, 0x0018); /* CAPSETTYPE_WINDOW */
out_uint16_le(s, 11);
out_uint32_le(s, 2); /* TS_WINDOW_LEVEL_SUPPORTED_EX */
out_uint8(s, 3); /* NumIconCaches */
out_uint16_le(s, 12); /* NumIconCacheEntries */
/* 6 - bitmap cache v3 codecid */
caps_count++;
out_uint16_le(s, 0x0006);
out_uint16_le(s, 5);
out_uint8(s, 0); /* client sets */
if (self->client_info.use_fast_path & FASTPATH_OUTPUT_SUPPORTED) /* fastpath output on */
{
/* multifragment update */
caps_count++;
out_uint16_le(s, RDP_CAPSET_MULTIFRAGMENT); /* 26 CAPSETTYPE_MULTIFRAGMENTUPDATE */
out_uint16_le(s, RDP_CAPLEN_MULTIFRAGMENT);
out_uint32_le(s, 3 * 1024 * 1024); /* 3MB */
/* frame acks */
caps_count++;
out_uint16_le(s, RDP_CAPSET_FRAME_ACKNOWLEDGE); /* CAPSETTYPE_FRAME_ACKNOWLEDGE */
out_uint16_le(s, RDP_CAPLEN_FRAME_ACKNOWLEDGE);
out_uint32_le(s, 2); /* 2 frames in flight */
/* surface commands */
caps_count++;
out_uint16_le(s, RDP_CAPSET_SURFCMDS); /* CAPSETTYPE_SURFACE_COMMANDS */
out_uint16_le(s, RDP_CAPLEN_SURFCMDS); /* lengthCapability */
out_uint32_le(s, (SURFCMDS_SETSURFACEBITS |
SURFCMDS_FRAMEMARKER |
SURFCMDS_STREAMSUFRACEBITS)); /* cmdFlags */
out_uint32_le(s, 0); /* reserved */
}
out_uint8s(s, 4); /* pad */
s_mark_end(s);
caps_size = (int)(s->end - caps_ptr);
caps_size_ptr[0] = caps_size;
caps_size_ptr[1] = caps_size >> 8;
caps_count_ptr[0] = caps_count;
caps_count_ptr[1] = caps_count >> 8;
caps_count_ptr[2] = caps_count >> 16;
caps_count_ptr[3] = caps_count >> 24;
if (xrdp_rdp_send(self, s, RDP_PDU_DEMAND_ACTIVE) != 0)
{
free_stream(s);
return 1;
}
DEBUG(("out (1) xrdp_caps_send_demand_active"));
/* send Monitor Layout PDU for dual monitor */
if (self->client_info.monitorCount > 0 &&
self->client_info.multimon == 1)
{
DEBUG(("xrdp_caps_send_demand_active: sending monitor layout pdu"));
if (xrdp_caps_send_monitorlayout(self) != 0)
{
g_writeln("xrdp_caps_send_demand_active: error sending monitor layout pdu");
}
}
free_stream(s);
return 0;
}
static int APP_CC
xrdp_mm_send_login(struct xrdp_mm* self)
{
struct stream * s = (struct stream *)NULL;
int rv = 0;
int index = 0;
int count = 0;
char * username = (char *)NULL;
char * password = (char *)NULL;
char * name = (char *)NULL;
char * value = (char *)NULL;
xrdp_wm_log_msg(self->wm, "sending login info to session manager, "
"please wait...");
username = 0;
password = 0;
self->code = 0;
count = self->login_names->count;
for (index = 0; index < count; index++)
{
name = (char*)list_get_item(self->login_names, index);
value = (char*)list_get_item(self->login_values, index);
if (g_strcasecmp(name, "username") == 0)
{
username = value;
}
else if (g_strcasecmp(name, "password") == 0)
{
password = value;
}
else if (g_strcasecmp(name, "lib") == 0)
{
if ((g_strcasecmp(value, "libxup.so") == 0) ||
(g_strcasecmp(value, "xup.dll") == 0))
{
self->code = 10;
}
}
}
if ((username == 0) || (password == 0))
{
xrdp_wm_log_msg(self->wm, "Error finding username and password");
return 1;
}
s = trans_get_out_s(self->sesman_trans, 8192);
s_push_layer(s, channel_hdr, 8);
/* this code is either 0 for Xvnc or 10 for X11rdp */
out_uint16_be(s, self->code);
index = g_strlen(username);
out_uint16_be(s, index);
out_uint8a(s, username, index);
index = g_strlen(password);
out_uint16_be(s, index);
out_uint8a(s, password, index);
out_uint16_be(s, self->wm->screen->width);
out_uint16_be(s, self->wm->screen->height);
out_uint16_be(s, self->wm->screen->bpp);
/* send domain */
index = g_strlen(self->wm->client_info->domain);
out_uint16_be(s, index);
out_uint8a(s, self->wm->client_info->domain, index);
/* send program / shell */
index = g_strlen(self->wm->client_info->program);
out_uint16_be(s, index);
out_uint8a(s, self->wm->client_info->program, index);
/* send directory */
index = g_strlen(self->wm->client_info->directory);
out_uint16_be(s, index);
out_uint8a(s, self->wm->client_info->directory, index);
/* send client ip */
index = g_strlen(self->wm->client_info->client_ip);
out_uint16_be(s, index);
out_uint8a(s, self->wm->client_info->client_ip, index);
s_mark_end(s);
s_pop_layer(s, channel_hdr);
out_uint32_be(s, 0); /* version */
index = (int)(s->end - s->data);
out_uint32_be(s, index); /* size */
rv = trans_force_write(self->sesman_trans);
if (rv != 0) {
xrdp_wm_log_msg(self->wm, "xrdp_mm_send_login: xrdp_mm_send_login failed");
}
return rv;
}
/* 040 */
enum SCP_SERVER_STATES_E
scp_v1s_list_sessions(struct SCP_CONNECTION* c, int sescnt, struct SCP_DISCONNECTED_SESSION* ds, SCP_SID* sid)
{
tui32 version=1;
tui32 size=12;
tui16 cmd=40;
int pktcnt;
int idx;
int sidx;
int pidx;
struct SCP_DISCONNECTED_SESSION* cds;
/* first we send a notice that we have some disconnected sessions */
init_stream(c->out_s, c->out_s->size);
out_uint32_be(c->out_s, version); /* version */
out_uint32_be(c->out_s, size); /* size */
out_uint16_be(c->out_s, SCP_COMMAND_SET_DEFAULT); /* cmdset */
out_uint16_be(c->out_s, cmd); /* cmd */
if (0!=scp_tcp_force_send(c->in_sck, c->out_s->data, size))
{
log_message(LOG_LEVEL_WARNING, "[v1s:%d] connection aborted: network error", __LINE__);
return SCP_SERVER_STATE_NETWORK_ERR;
}
/* then we wait for client ack */
#warning maybe this message could say if the session should be resized on
#warning server side or client side
init_stream(c->in_s, c->in_s->size);
if (0!=scp_tcp_force_recv(c->in_sck, c->in_s->data, 8))
{
log_message(LOG_LEVEL_WARNING, "[v1s:%d] connection aborted: network error", __LINE__);
return SCP_SERVER_STATE_NETWORK_ERR;
}
in_uint32_be(c->in_s, version);
if (version!=1)
{
log_message(LOG_LEVEL_WARNING, "[v1s:%d] connection aborted: version error", __LINE__);
return SCP_SERVER_STATE_VERSION_ERR;
}
in_uint32_be(c->in_s, size);
if (size<12)
{
log_message(LOG_LEVEL_WARNING, "[v1s:%d] connection aborted: size error", __LINE__);
return SCP_SERVER_STATE_SIZE_ERR;
}
init_stream(c->in_s, c->in_s->size);
if (0!=scp_tcp_force_recv(c->in_sck, c->in_s->data, (size-8)))
{
log_message(LOG_LEVEL_WARNING, "[v1s:%d] connection aborted: network error", __LINE__);
return SCP_SERVER_STATE_NETWORK_ERR;
}
in_uint16_be(c->in_s, cmd);
if (cmd != SCP_COMMAND_SET_DEFAULT)
{
log_message(LOG_LEVEL_WARNING, "[v1s:%d] connection aborted: sequence error", __LINE__);
return SCP_SERVER_STATE_SEQUENCE_ERR;
}
in_uint16_be(c->in_s, cmd);
if (cmd != 41)
{
log_message(LOG_LEVEL_WARNING, "[v1s:%d] connection aborted: sequence error", __LINE__);
return SCP_SERVER_STATE_SEQUENCE_ERR;
}
/* calculating the number of packets to send */
pktcnt=sescnt/SCP_SERVER_MAX_LIST_SIZE;
if ((sescnt%SCP_SERVER_MAX_LIST_SIZE)!=0)
{
pktcnt++;
}
for (idx=0; idx<pktcnt; idx++)
{
/* ok, we send session session list */
init_stream(c->out_s, c->out_s->size);
/* size: ver+size+cmdset+cmd+sescnt+continue+count */
size=4+4+2+2+4+1+1;
/* header */
cmd=42;
s_push_layer(c->out_s, channel_hdr, 8);
out_uint16_be(c->out_s, SCP_COMMAND_SET_DEFAULT);
out_uint16_be(c->out_s, cmd);
/* session count */
out_uint32_be(c->out_s, sescnt);
/* setting the continue flag */
if ((idx+1)*SCP_SERVER_MAX_LIST_SIZE >= sescnt)
{
out_uint8(c->out_s, 0);
/* setting session count for this packet */
pidx=sescnt-(idx*SCP_SERVER_MAX_LIST_SIZE);
out_uint8(c->out_s, pidx);
}
else
{
out_uint8(c->out_s, 1);
/* setting session count for this packet */
pidx=SCP_SERVER_MAX_LIST_SIZE;
out_uint8(c->out_s, pidx);
}
/* adding session descriptors */
for (sidx=0; sidx<pidx; sidx++)
{
/* shortcut to the current session to send */
cds=ds+((idx)*SCP_SERVER_MAX_LIST_SIZE)+sidx;
/* session data */
out_uint32_be(c->out_s, cds->SID); /* session id */
out_uint8(c->out_s, cds->type);
out_uint16_be(c->out_s, cds->height);
out_uint16_be(c->out_s, cds->width);
out_uint8(c->out_s, cds->bpp);
out_uint8(c->out_s, cds->idle_days);
out_uint8(c->out_s, cds->idle_hours);
out_uint8(c->out_s, cds->idle_minutes);
size += 13;
out_uint16_be(c->out_s, cds->conn_year);
out_uint8(c->out_s, cds->conn_month);
out_uint8(c->out_s, cds->conn_day);
out_uint8(c->out_s, cds->conn_hour);
out_uint8(c->out_s, cds->conn_minute);
out_uint8(c->out_s, cds->addr_type);
size += 7;
if (cds->addr_type == SCP_ADDRESS_TYPE_IPV4)
{
in_uint32_be(c->out_s, cds->ipv4addr);
size += 4;
}
else if (cds->addr_type == SCP_ADDRESS_TYPE_IPV6)
{
in_uint8a(c->out_s, cds->ipv6addr, 16);
size += 16;
}
}
s_pop_layer(c->out_s, channel_hdr);
out_uint32_be(c->out_s, version);
out_uint32_be(c->out_s, size);
if (0 != scp_tcp_force_send(c->in_sck, c->out_s->data, size))
{
log_message(LOG_LEVEL_WARNING, "[v1s:%d] connection aborted: network error", __LINE__);
return SCP_SERVER_STATE_NETWORK_ERR;
}
}
/* we get the response */
init_stream(c->in_s, c->in_s->size);
if (0!=scp_tcp_force_recv(c->in_sck, c->in_s->data, (8)))
{
log_message(LOG_LEVEL_WARNING, "[v1s:%d] connection aborted: network error", __LINE__);
return SCP_SERVER_STATE_NETWORK_ERR;
}
in_uint32_be(c->in_s, version);
if (version != 1)
{
log_message(LOG_LEVEL_WARNING, "[v1s:%d] connection aborted: version error", __LINE__);
return SCP_SERVER_STATE_VERSION_ERR;
}
in_uint32_be(c->in_s, size);
if (size < 12)
{
log_message(LOG_LEVEL_WARNING, "[v1s:%d] connection aborted: size error", __LINE__);
return SCP_SERVER_STATE_SIZE_ERR;
}
/* rest of the packet */
init_stream(c->in_s, c->in_s->size);
if (0!=scp_tcp_force_recv(c->in_sck, c->in_s->data, (size-8)))
{
log_message(LOG_LEVEL_WARNING, "[v1s:%d] connection aborted: network error", __LINE__);
return SCP_SERVER_STATE_NETWORK_ERR;
}
in_uint16_be(c->in_s, cmd);
if (cmd != SCP_COMMAND_SET_DEFAULT)
{
log_message(LOG_LEVEL_WARNING, "[v1s:%d] connection aborted: sequence error", __LINE__);
return SCP_SERVER_STATE_SEQUENCE_ERR;
}
in_uint16_be(c->in_s, cmd);
if (cmd == 43)
{
/* select session */
in_uint32_be(c->in_s, (*sid));
/* checking sid value */
for (idx=0; idx<sescnt; idx++)
{
/* the sid is valid */
if (ds[idx].SID==(*sid))
{
/* ok, session selected */
return SCP_SERVER_STATE_OK;
}
}
/* if we got here, the requested sid wasn't one from the list we sent */
/* we should kill the connection */
log_message(LOG_LEVEL_WARNING, "[v1s:%d] connection aborted: internal error (no such session in list)", __LINE__);
return SCP_CLIENT_STATE_INTERNAL_ERR;
}
else if (cmd == 44)
{
/* cancel connection */
return SCP_SERVER_STATE_SELECTION_CANCEL;
}
// else if (cmd == 45)
// {
// /* force new connection */
// return SCP_SERVER_STATE_FORCE_NEW;
// }
else
{
/* wrong response */
log_message(LOG_LEVEL_WARNING, "[v1s:%d] connection aborted: sequence error", __LINE__);
return SCP_SERVER_STATE_SEQUENCE_ERR;
}
return SCP_SERVER_STATE_OK;
}