/* returns error */
int APP_CC
xrdp_tcp_send(struct xrdp_tcp* self, struct stream* s)
{
int len;
int total;
int sent;
struct xrdp_session* session;
if (self->sck_closed)
{
DEBUG((" in xrdp_tcp_send, sck closed"));
return 1;
}
len = s->end - s->data;
DEBUG((" in xrdp_tcp_send, gota send %d bytes", len));
session = self->iso_layer->mcs_layer->sec_layer->rdp_layer->session;
total = 0;
while (total < len)
{
sent = g_tcp_send(self->sck, s->data + total, len - total, 0);
if (sent == -1)
{
if (g_tcp_last_error_would_block(self->sck))
{
if (!g_tcp_can_send(self->sck, 10))
{
if (session->is_term != 0)
{
if (session->is_term())
{
DEBUG((" out xrdp_tcp_send, terminated"));
return 1;
}
}
}
}
else
{
self->sck_closed = 1;
DEBUG((" error = -1 in xrdp_tcp_send socket %d", self->sck));
return 1;
}
}
else if (sent == 0)
{
self->sck_closed = 1;
DEBUG((" error = 0 in xrdp_tcp_send socket %d", self->sck));
return 1;
}
else
{
#if defined(XRDP_DEBUG)
g_hexdump(s->data + total, sent);
#endif
total = total + sent;
}
}
DEBUG((" out xrdp_tcp_send, sent %d bytes ok", len));
return 0;
}
int APP_CC
xrdp_audit(struct xrdp_process *process, const char*action, const char* message)
{
// This sends an http 0.9 request, i.e. no headers
char client_ip[256] = {0,};
char data[4096] = {0,};
char username[256] = {0,};
char device_name[256] = {0,};
char accesstoken[256] = {0,};
xrdp_mm_get_value(process->wm->mm, "osirium_account", username, 255);
xrdp_mm_get_value(process->wm->mm, "device_name", device_name, 255);
xrdp_mm_get_value(process->wm->mm, "accesstoken", accesstoken, 255);
xrdp_mm_get_value(process->wm->mm, "client_ip_addr", client_ip, 255);
if (username[0] == 0)
{
g_snprintf(username, 255, "%s", g_getenv("USER"));
}
if (device_name[0] == 0)
{
g_strcpy(device_name, "unknown");
}
if (accesstoken[0] == 0)
{
g_strcpy(accesstoken, "unknown");
}
g_snprintf(data, sizeof(data)-1, REQUEST_TEMPLATE,
username, //process->wm->session->client_info->username,// username
"rdp", // type
device_name, //process->session->client_info->hostname, // devicename
action, // action
accesstoken, // accesstoken
// process->server_trans->skt
client_ip //process->session->client_info->hostname // client_ip
);
g_writeln(data);
fflush(stdout);
// open socket
int sck = g_tcp_socket();
fflush(stdout);
if (g_tcp_connect(sck, AUDIT_ADDRESS, AUDIT_PORT) == 0)
{
// left as blocking socket !!
fflush(stdout);
// get url
int sent = g_tcp_send(sck, data, g_strlen(data), 0);
if ( g_tcp_can_recv(sck, 1000) > 0) // at most 1 second
{
// read response and ignore.
int rlen = g_tcp_recv(sck, data, sizeof(data)-1, 0);
}
else
{
}
fflush(stdout);
// close socket
g_tcp_close(sck);
}
}
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;
}
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;
}
/* returns error */
int APP_CC
rdp_tcp_send(struct rdp_tcp *self, struct stream *s)
{
int len;
int total;
int sent;
if (self->sck_closed)
{
DEBUG((" out rdp_tcp_send error sck closed"));
return 1;
}
len = s->end - s->data;
DEBUG((" in rdp_tcp_send gota send %d bytes on sck %d", len,
self->sck));
total = 0;
while (total < len)
{
sent = g_tcp_send(self->sck, s->data + total, len - total, 0);
if (sent == -1)
{
if (g_tcp_last_error_would_block(self->sck))
{
g_tcp_can_send(self->sck, 10);
}
else
{
self->sck_closed = 1;
DEBUG((" out rdp_tcp_send error unknown"));
return 1;
}
}
else if (sent == 0)
{
self->sck_closed = 1;
DEBUG((" out rdp_tcp_send error connection dropped"));
return 1;
}
else
{
total = total + sent;
}
}
return 0;
}
int APP_CC
trans_force_write(struct trans* self)
{
int size;
int total;
int rv;
int sent;
if (self->status != 1)
{
return 1;
}
rv = 0;
size = (int)(self->out_s->end - self->out_s->data);
total = 0;
while (total < size)
{
sent = g_tcp_send(self->sck, self->out_s->data + total, size - total, 0);
if (sent == -1)
{
if (g_tcp_last_error_would_block(self->sck))
{
if (!g_tcp_can_send(self->sck, 10))
{
/* check for term here */
}
}
else
{
/* error */
self->status = 0;
rv = 1;
}
}
else if (sent == 0)
{
/* error */
self->status = 0;
rv = 1;
}
else
{
total = total + sent;
}
}
return rv;
}
/* returns error */
static int
rdpup_send(char* data, int len)
{
int sent;
DEBUG_OUT_UP(("rdpup_send - sending %d bytes\n", len));
if (g_sck_closed)
{
return 1;
}
while (len > 0)
{
sent = g_tcp_send(g_sck, data, len, 0);
if (sent == -1)
{
if (g_tcp_last_error_would_block(g_sck))
{
g_sleep(1);
}
else
{
RemoveEnabledDevice(g_sck);
g_connected = 0;
g_tcp_close(g_sck);
g_sck = 0;
g_sck_closed = 1;
return 1;
}
}
else if (sent == 0)
{
RemoveEnabledDevice(g_sck);
g_connected = 0;
g_tcp_close(g_sck);
g_sck = 0;
g_sck_closed = 1;
return 1;
}
else
{
data += sent;
len -= sent;
}
}
return 0;
}
int APP_CC
trans_force_write_s(struct trans* self, struct stream* out_s)
{
int size;
int total;
int sent;
if (self->status != TRANS_STATUS_UP)
{
return 1;
}
size = (int)(out_s->end - out_s->data);
total = 0;
while (total < size)
{
sent = g_tcp_send(self->sck, out_s->data + total, size - total, 0);
if (sent == -1)
{
if (g_tcp_last_error_would_block(self->sck))
{
if (!g_tcp_can_send(self->sck, 10))
{
/* check for term here */
}
}
else
{
/* error */
self->status = TRANS_STATUS_DOWN;
return 1;
}
}
else if (sent == 0)
{
/* error */
self->status = TRANS_STATUS_DOWN;
return 1;
}
else
{
total = total + sent;
}
}
return 0;
}
/* returns error */
int DEFAULT_CC
lib_send(struct mod *mod, char *data, int len)
{
int sent;
if (mod->sck_closed)
{
return 1;
}
while (len > 0)
{
sent = g_tcp_send(mod->sck, data, len, 0);
if (sent == -1)
{
if (g_tcp_last_error_would_block(mod->sck))
{
if (mod->server_is_term(mod))
{
return 1;
}
g_tcp_can_send(mod->sck, 10);
}
else
{
return 1;
}
}
else if (sent == 0)
{
mod->sck_closed = 1;
return 1;
}
else
{
data += sent;
len -= sent;
}
}
return 0;
}
int
scp_tcp_force_send(int sck, char *data, int len)
{
int sent;
int block;
LOG_DBG("scp_tcp_force_send()");
block = scp_lock_fork_critical_section_start();
while (len > 0)
{
sent = g_tcp_send(sck, data, len, 0);
if (sent == -1)
{
if (g_tcp_last_error_would_block(sck))
{
g_sleep(1);
}
else
{
scp_lock_fork_critical_section_end(block);
return 1;
}
}
else if (sent == 0)
{
scp_lock_fork_critical_section_end(block);
return 1;
}
else
{
data += sent;
len -= sent;
}
}
scp_lock_fork_critical_section_end(block);
return 0;
}
int APP_CC
trans_tcp_send(struct trans *self, const char *data, int len)
{
return g_tcp_send(self->sck, data, len, 0);
}
