ConditionVariable::ConditionVariable()
{
TRACE_CALL(lib_com.cnd, ("ConditionVariable{0x%x}::ConditionVariable", _T_PTR(this)));
pthread_cond_init(&cid_, 0);
atomicIncrement(num_);
}
void
CopyPasteDnDX11::SetDnDAllowed(bool allowed)
{
ASSERT(m_dndUI);
TRACE_CALL();
m_dndUI->SetDnDAllowed(allowed);
}
size_t IOSocketSSL::write(const struct io_buf &buffer) {
size_t written = 0;
size_t offset = 0;
size_t to_write = buffer.length;
struct io_buf buf;
TRACE_CALL();
if (to_write > IOSOCKET_NET_BUF_SIZE)
to_write = IOSOCKET_NET_BUF_SIZE;
do {
::memcpy(buf.content, buffer.content + offset, to_write);
buf.length = to_write;
try {
written = writeSSL(buf);
} catch (const char *e) {
stringstream ss;
ss << new_SSL_error("writeSSL error") << "(" << e << ")";
throw(ss.str().c_str());
}
offset += written;
stats.client.bytesSent += written; /* Update stats */
if (buffer.length - offset < IOSOCKET_NET_BUF_SIZE)
to_write = buffer.length - offset;
} while (offset != buffer.length);
return offset;
}
//--------------------------------------------------------------------
// @mfunc Convert string user passed in to initilaize the col class
//
//
//
// @rdesc ParseFlags
//
// @void |
//
void CParseInitFile::ParseFlags(LPSTR pszColumnFlags, CCol &NewCol)
{
ASSERT(pszColumnFlags);
TRACE_CALL(L"PRIVLIB: CParseInitFile::ParseFlags.\n");
//TODO - all of these flags are not needed - just here for the time being until
if(strstr(pszColumnFlags,"DBCOLUMNFLAGS_MAYBENULL"))
NewCol.SetNullable(FALSE);
if(strstr(pszColumnFlags,"DBCOLUMNFLAGS_ISNULLABLE"))
NewCol.SetNullable(TRUE);
if(strstr(pszColumnFlags,"DBCOLUMNFLAGS_ISLONG"))
NewCol.SetIsLong(TRUE);
if(strstr(pszColumnFlags,"IS_AUTOINC"))
NewCol.SetAutoInc(TRUE);
if(strstr(pszColumnFlags,"IS_UNSIGNED"))
NewCol.SetUnsigned(TRUE);
if(strstr(pszColumnFlags,"IS_SIGNED"))
NewCol.SetUnsigned(FALSE);
if(strstr(pszColumnFlags,"DBCOLUMNFLAGS_WRITE"))
NewCol.SetUpdateable(TRUE);
if(strstr(pszColumnFlags,"DBCOLUMNFLAGS_WRITEUNKNOWN"))
NewCol.SetUpdateable(TRUE);
if(strstr(pszColumnFlags,"IS_CASESENSITIVE"))
NewCol.SetCaseSensitive(TRUE);
if(strstr(pszColumnFlags,"IS_NOTCASESENSITIVE"))
NewCol.SetCaseSensitive(FALSE);
if(strstr(pszColumnFlags,"DBCOLUMNFLAGS_ISFIXEDLENGTH"))
NewCol.SetIsFixedLength(TRUE);
if(strstr(pszColumnFlags,"DBCOLUMNFLAGS_ISCHAPTER"))
NewCol.SetIsChapter(TRUE);
}
static gboolean remmina_plugin_dummy_close_connection(RemminaProtocolWidget *gp)
{
TRACE_CALL("remmina_plugin_dummy_close_connection");
remmina_plugin_service->log_printf("[%s] Plugin close connection\n", PLUGIN_NAME);
remmina_plugin_service->protocol_plugin_emit_signal(gp, "disconnect");
return FALSE;
}
BOOL rf_Bitmap_New(rdpContext* context, rdpBitmap* bitmap)
{
TRACE_CALL("rf_Bitmap_New");
#ifdef RF_BITMAP
UINT8* data;
Pixmap pixmap;
XImage* image;
rfContext* rfi = (rfContext*) context;
XSetFunction(rfi->display, rfi->gc, GXcopy);
pixmap = XCreatePixmap(rfi->display, rfi->drawable, bitmap->width, bitmap->height, rfi->depth);
if (bitmap->data != NULL)
{
data = freerdp_image_convert(bitmap->data, NULL,
bitmap->width, bitmap->height, rfi->srcBpp, rfi->bpp, rfi->clrconv);
if (bitmap->ephemeral != TRUE)
{
image = XCreateImage(rfi->display, rfi->visual, rfi->depth,
ZPixmap, 0, (char*) data, bitmap->width, bitmap->height, rfi->scanline_pad, 0);
XPutImage(rfi->display, pixmap, rfi->gc, image, 0, 0, 0, 0, bitmap->width, bitmap->height);
XFree(image);
if (data != bitmap->data) && (data != NULL)
free(data);
}
void IOSocket::write(const struct io_buf &buffer) {
int written = 0;
size_t offset = 0;
size_t to_write = buffer.length;
TRACE_CALL();
if (to_write > IOSOCKET_NET_BUF_SIZE)
to_write = IOSOCKET_NET_BUF_SIZE;
do {
written = ::write((int) sock, ((char *) buffer.content) + offset, to_write);
if (written < 0) {
if (errno != EINTR)
throw("Write error");
continue;
}
offset += written;
stats.client.bytesSent += written; /* Update stats */
if (buffer.length - offset < IOSOCKET_NET_BUF_SIZE)
to_write = buffer.length - offset;
} while (offset != buffer.length);
}
void
ConditionVariable1::reset()
{
TRACE_CALL(lib_com.cnd, ("ConditionVariable1{0x%x}::reset", _T_PTR(this)));
ResetEvent(event_);
}
void remmina_rdp_cliprdr_send_client_format_list(RemminaProtocolWidget *gp)
{
TRACE_CALL(__func__);
RemminaPluginRdpUiObject* ui;
rfContext* rfi = GET_PLUGIN_DATA(gp);
rfClipboard* clipboard;
CLIPRDR_FORMAT_LIST *pFormatList;
RemminaPluginRdpEvent rdp_event = { 0 };
if (!rfi || !rfi->connected || rfi->is_reconnecting)
return;
clipboard = &(rfi->clipboard);
ui = g_new0(RemminaPluginRdpUiObject, 1);
ui->type = REMMINA_RDP_UI_CLIPBOARD;
ui->clipboard.clipboard = clipboard;
ui->clipboard.type = REMMINA_RDP_UI_CLIPBOARD_FORMATLIST;
pFormatList = remmina_rdp_event_queue_ui_sync_retptr(gp, ui);
rdp_event.type = REMMINA_RDP_EVENT_TYPE_CLIPBOARD_SEND_CLIENT_FORMAT_LIST;
rdp_event.clipboard_formatlist.pFormatList = pFormatList;
remmina_rdp_event_event_push(gp, &rdp_event);
}
ConditionVariable1::~ConditionVariable1()
{
TRACE_CALL(lib_com.cnd, ("ConditionVariable1{0x%x}::~ConditionVariable1", _T_PTR(this)));
CloseHandle(event_);
atomicDecrement(num_);
}
bool
ConditionVariable1::wait(int msec)
{
TRACE_CALL(lib_com.cnd, ("ConditionVariable1{0x%x}::wait", _T_PTR(this)));
return (WAIT_TIMEOUT != WaitForSingleObject(event_, msec ? msec : INFINITE));
}
ConditionVariable1::ConditionVariable1()
{
TRACE_CALL(lib_com.cnd, ("ConditionVariable1{0x%x}::ConditionVariable1", _T_PTR(this)));
event_ = CreateEvent(0, true, false, 0);
atomicIncrement(num_);
}
ConditionVariable1::~ConditionVariable1()
{
TRACE_CALL(lib_com.cnd, ("ConditionVariable1{0x%x}::~ConditionVariable1", _T_PTR(this)));
pthread_cond_destroy(&cid_);
atomicDecrement(num_);
}
void
ConditionVariable::wakeup()
{
TRACE_CALL(lib_com.cnd, ("ConditionVariable{0x%x}::wakeup", _T_PTR(this)));
pthread_cond_broadcast(&cid_);
}
static void remmina_rdp_settings_grid_load_quality(RemminaPluginRdpsetGrid* grid)
{
TRACE_CALL(__func__);
gchar* value;
GtkTreeIter iter;
gtk_list_store_append(grid->quality_store, &iter);
gtk_list_store_set(grid->quality_store, &iter, 0, -1, 1, _("<Choose a quality level to edit…>"), -1);
gtk_list_store_append(grid->quality_store, &iter);
gtk_list_store_set(grid->quality_store, &iter, 0, 0, 1, _("Poor (fastest)"), -1);
gtk_list_store_append(grid->quality_store, &iter);
gtk_list_store_set(grid->quality_store, &iter, 0, 1, 1, _("Medium"), -1);
gtk_list_store_append(grid->quality_store, &iter);
gtk_list_store_set(grid->quality_store, &iter, 0, 2, 1, _("Good"), -1);
gtk_list_store_append(grid->quality_store, &iter);
gtk_list_store_set(grid->quality_store, &iter, 0, 9, 1, _("Best (slowest)"), -1);
memset(grid->quality_values, 0, sizeof(grid->quality_values));
value = remmina_plugin_service->pref_get_value("rdp_quality_0");
grid->quality_values[0] = (value && value[0] ? strtoul(value, NULL, 16) : DEFAULT_QUALITY_0);
g_free(value);
value = remmina_plugin_service->pref_get_value("rdp_quality_1");
grid->quality_values[1] = (value && value[0] ? strtoul(value, NULL, 16) : DEFAULT_QUALITY_1);
g_free(value);
value = remmina_plugin_service->pref_get_value("rdp_quality_2");
grid->quality_values[2] = (value && value[0] ? strtoul(value, NULL, 16) : DEFAULT_QUALITY_2);
g_free(value);
value = remmina_plugin_service->pref_get_value("rdp_quality_9");
grid->quality_values[9] = (value && value[0] ? strtoul(value, NULL, 16) : DEFAULT_QUALITY_9);
g_free(value);
}
UINT32 remmina_rdp_cliprdr_get_format_from_gdkatom(GdkAtom atom)
{
TRACE_CALL(__func__);
UINT32 rc;
gchar* name = gdk_atom_name(atom);
rc = 0;
if (g_strcmp0("UTF8_STRING", name) == 0 || g_strcmp0("text/plain;charset=utf-8", name) == 0) {
rc = CF_UNICODETEXT;
}
if (g_strcmp0("TEXT", name) == 0 || g_strcmp0("text/plain", name) == 0) {
rc = CF_TEXT;
}
if (g_strcmp0("text/html", name) == 0) {
rc = CB_FORMAT_HTML;
}
if (g_strcmp0("image/png", name) == 0) {
rc = CB_FORMAT_PNG;
}
if (g_strcmp0("image/jpeg", name) == 0) {
rc = CB_FORMAT_JPEG;
}
if (g_strcmp0("image/bmp", name) == 0) {
rc = CF_DIB;
}
g_free(name);
return rc;
}
void remmina_rdp_settings_get_orientation_scale_prefs(int *desktopOrientation, int *desktopScaleFactor, int *deviceScaleFactor)
{
TRACE_CALL(__func__);
/* See https://msdn.microsoft.com/en-us/library/cc240510.aspx */
int orientation, dpsf, desf;
gchar* s;
*desktopOrientation = *desktopScaleFactor = *deviceScaleFactor = 0;
s = remmina_plugin_service->pref_get_value("rdp_desktopOrientation");
orientation = s ? atoi(s) : 0;
g_free(s);
if (orientation != 90 && orientation != 180 && orientation != 270)
orientation = 0;
*desktopOrientation = orientation;
s = remmina_plugin_service->pref_get_value("rdp_desktopScaleFactor");
dpsf = s ? atoi(s) : 0;
g_free(s);
if (dpsf < 100 || dpsf > 500)
return;
s = remmina_plugin_service->pref_get_value("rdp_deviceScaleFactor");
desf = s ? atoi(s) : 0;
g_free(s);
if (desf != 100 && desf != 140 && desf != 180)
return;
*desktopScaleFactor = dpsf;
*deviceScaleFactor = desf;
}
CLIPRDR_FORMAT_LIST *remmina_rdp_cliprdr_get_client_format_list(RemminaProtocolWidget* gp)
{
TRACE_CALL(__func__);
GtkClipboard* gtkClipboard;
rfContext* rfi = GET_PLUGIN_DATA(gp);
GdkAtom* targets;
gboolean result = 0;
gint loccount, srvcount;
gint formatId, i;
CLIPRDR_FORMAT *formats;
struct retp_t {
CLIPRDR_FORMAT_LIST pFormatList;
CLIPRDR_FORMAT formats[];
} *retp;
formats = NULL;
retp = NULL;
gtkClipboard = gtk_widget_get_clipboard(rfi->drawing_area, GDK_SELECTION_CLIPBOARD);
if (gtkClipboard) {
result = gtk_clipboard_wait_for_targets(gtkClipboard, &targets, &loccount);
}
if (result && loccount > 0) {
formats = (CLIPRDR_FORMAT*)malloc(loccount * sizeof(CLIPRDR_FORMAT));
srvcount = 0;
for (i = 0; i < loccount; i++) {
formatId = remmina_rdp_cliprdr_get_format_from_gdkatom(targets[i]);
if ( formatId != 0 ) {
formats[srvcount].formatId = formatId;
formats[srvcount].formatName = NULL;
srvcount++;
}
}
if (srvcount > 0) {
retp = (struct retp_t *)malloc(sizeof(struct retp_t) + sizeof(CLIPRDR_FORMAT) * srvcount);
retp->pFormatList.formats = retp->formats;
retp->pFormatList.numFormats = srvcount;
memcpy(retp->formats, formats, sizeof(CLIPRDR_FORMAT) * srvcount);
} else {
retp = (struct retp_t *)malloc(sizeof(struct retp_t));
retp->pFormatList.formats = NULL;
retp->pFormatList.numFormats = 0;
}
free(formats);
} else {
retp = (struct retp_t *)malloc(sizeof(struct retp_t) + sizeof(CLIPRDR_FORMAT));
retp->pFormatList.formats = NULL;
retp->pFormatList.numFormats = 0;
}
if (result)
g_free(targets);
retp->pFormatList.msgFlags = CB_RESPONSE_OK;
return (CLIPRDR_FORMAT_LIST*)retp;
}
void IOSocket::connectToServer(const char *hostname, const int &port) {
struct sockaddr_in sin = {0};
struct hostent *hp;
int rc = 0;
TRACE_CALL();
hp = gethostbyname(hostname);
if (hp == NULL)
throw("Hostname resolution failed");
memcpy(&(sin.sin_addr.s_addr), hp->h_addr, hp->h_length);
sin.sin_family = AF_INET;
sin.sin_port = htons(port);
again:
rc = connect((int) sock, (struct sockaddr *) &sin, sizeof(sin));
if (rc < 0) {
if (errno != EINTR)
throw("Unable to connect to host");
goto again;
}
/* Store start Time */
stats.client.startTime = time(NULL);
connected = true;
}
void remmina_rdp_cliprdr_init(rfContext* rfi, CliprdrClientContext* cliprdr)
{
TRACE_CALL(__func__);
rfClipboard* clipboard;
clipboard = &(rfi->clipboard);
rfi->clipboard.rfi = rfi;
cliprdr->custom = (void*)clipboard;
clipboard->context = cliprdr;
pthread_mutex_init(&clipboard->transfer_clip_mutex, NULL);
pthread_cond_init(&clipboard->transfer_clip_cond, NULL);
clipboard->srv_clip_data_wait = SCDW_NONE;
cliprdr->MonitorReady = remmina_rdp_cliprdr_monitor_ready;
cliprdr->ServerCapabilities = remmina_rdp_cliprdr_server_capabilities;
cliprdr->ServerFormatList = remmina_rdp_cliprdr_server_format_list;
cliprdr->ServerFormatListResponse = remmina_rdp_cliprdr_server_format_list_response;
cliprdr->ServerFormatDataRequest = remmina_rdp_cliprdr_server_format_data_request;
cliprdr->ServerFormatDataResponse = remmina_rdp_cliprdr_server_format_data_response;
// cliprdr->ServerFileContentsRequest = remmina_rdp_cliprdr_server_file_contents_request;
// cliprdr->ServerFileContentsResponse = remmina_rdp_cliprdr_server_file_contents_response;
}
void IOSocket::bindSocket(const int &port) {
struct sockaddr_in sin;
int rc = 0;
int reuse_addr = 1;
TRACE_CALL();
sin.sin_addr.s_addr = htonl(INADDR_ANY);
sin.sin_family = AF_INET;
sin.sin_port = htons(port);
rc = bind(sock, (struct sockaddr *)&sin, sizeof(sin));
if (rc < 0)
throw("bind error");
/* Set reusable */
rc = setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (const void *)&reuse_addr, sizeof(reuse_addr));
if (rc < 0)
throw("setsockopt error");
rc = listen(sock, 5);
if (rc < 0)
throw("listen error");
connected = true;
}
static UINT8* lf2crlf(UINT8* data, int* size)
{
TRACE_CALL(__func__);
UINT8 c;
UINT8* outbuf;
UINT8* out;
UINT8* in_end;
UINT8* in;
int out_size;
out_size = (*size) * 2 + 1;
outbuf = (UINT8*)malloc(out_size);
out = outbuf;
in = data;
in_end = data + (*size);
while (in < in_end) {
c = *in++;
if (c == '\n') {
*out++ = '\r';
*out++ = '\n';
}else {
*out++ = c;
}
}
*out++ = 0;
*size = out - outbuf;
return outbuf;
}
//--------------------------------------------------------------------
// @mfunc Obtain the column metadata from the file
// Obtain the offsets into the file that each row exists at.
//
//
// @rdesc BOOL
// @flag TRUE | Got the offsets, Column Names and Data Types
// @flag FALSE | Could not obtain all the necessary info
//
BOOL CParseInitFile::GenerateFileInfo()
{
TRACE_CALL(L"PRIVLIB: CParseInitFile::GenerateFileInfo.\n");
//Obtain ProviderInfo, including TableName of generated Data...
if(!ParseProviderInfo())
return FALSE;
//Obtain URLInfo
if(!ParseURLInfo())
return FALSE;
//Obtain QueryInfo, (all SQL Statements)
if(!ParseQueryInfo())
return FALSE;
// Generate Column Info, if FALSE is returned, a problem
// was encountered while reading the Column Names.
if(!ParseColumnInfo())
return FALSE;
// Get the Data in the file
// FALSE is returned if error was encountered while reading the Data
if(!ParseDataInfo())
return FALSE;
return TRUE;
}
static int
fg_readlink (const char *path, char *buf, size_t size)
{
TRACE_CALL ("%s, %p, %zu", path, buf, size);
const char *r;
int free_it = 0;
r = rlc_lookup (path);
if (!r) {
r = guestfs_readlink (g, path);
if (r == NULL)
return error ();
free_it = 1;
}
/* Note this is different from the real readlink(2) syscall. FUSE wants
* the string to be always nul-terminated, even if truncated.
*/
size_t len = strlen (r);
if (len > size - 1)
len = size - 1;
memcpy (buf, r, len);
buf[len] = '\0';
if (free_it) {
char *tmp = (char *) r;
free (tmp);
}
return 0;
}
gboolean
CopyPasteDnDX11::RegisterDnD()
{
TRACE_CALL();
CopyPasteDnDWrapper *wrapper = CopyPasteDnDWrapper::GetInstance();
if (!wrapper->IsDnDEnabled()) {
return FALSE;
}
if (!wrapper->IsDnDRegistered()) {
m_dndUI = new DnDUIX11(wrapper->GetToolsAppCtx());
if (m_dndUI) {
BlockService *bs = BlockService::GetInstance();
m_dndUI->SetBlockControl(bs->GetBlockCtrl());
if (m_dndUI->Init()) {
wrapper->SetDnDIsRegistered(TRUE);
m_dndUI->SetDnDAllowed(TRUE);
int version = wrapper->GetDnDVersion();
g_debug("%s: dnd version is %d\n", __FUNCTION__, version);
if (version >= 3) {
DnDVersionChanged(version);
}
} else {
delete m_dndUI;
m_dndUI = NULL;
}
}
}
g_debug("%s: dnd is registered? %d\n", __FUNCTION__, (int) wrapper->IsDnDRegistered());
return wrapper->IsDnDRegistered();
}
static int
fg_statfs (const char *path, struct statvfs *stbuf)
{
TRACE_CALL ("%s, %p", path, stbuf);
struct guestfs_statvfs *r;
r = guestfs_statvfs (g, path);
if (r == NULL)
return error ();
stbuf->f_bsize = r->bsize;
stbuf->f_frsize = r->frsize;
stbuf->f_blocks = r->blocks;
stbuf->f_bfree = r->bfree;
stbuf->f_bavail = r->bavail;
stbuf->f_files = r->files;
stbuf->f_ffree = r->ffree;
stbuf->f_favail = r->favail;
stbuf->f_fsid = r->fsid;
stbuf->f_flag = r->flag;
stbuf->f_namemax = r->namemax;
guestfs_free_statvfs (r);
return 0;
}
void
CopyPasteDnDX11::SetCopyPasteAllowed(bool allowed)
{
ASSERT(m_copyPasteUI);
TRACE_CALL();
m_copyPasteUI->SetCopyPasteAllowed(allowed);
}
static void remmina_rdp_settings_grid_load_layout(RemminaPluginRdpsetGrid* grid)
{
TRACE_CALL(__func__);
gint i;
gchar* s;
GtkTreeIter iter;
RDP_KEYBOARD_LAYOUT* layouts;
gtk_list_store_append(grid->keyboard_layout_store, &iter);
gtk_list_store_set(grid->keyboard_layout_store, &iter, 0, 0, 1, _("<Auto detect>"), -1);
if (rdp_keyboard_layout == 0)
gtk_combo_box_set_active(GTK_COMBO_BOX(grid->keyboard_layout_combo), 0);
gtk_label_set_text(GTK_LABEL(grid->keyboard_layout_label), "-");
layouts = freerdp_keyboard_get_layouts(RDP_KEYBOARD_LAYOUT_TYPE_STANDARD | RDP_KEYBOARD_LAYOUT_TYPE_VARIANT);
for (i = 0; layouts[i].code; i++) {
s = g_strdup_printf("%08X - %s", layouts[i].code, layouts[i].name);
gtk_list_store_append(grid->keyboard_layout_store, &iter);
gtk_list_store_set(grid->keyboard_layout_store, &iter, 0, layouts[i].code, 1, s, -1);
if (rdp_keyboard_layout == layouts[i].code)
gtk_combo_box_set_active(GTK_COMBO_BOX(grid->keyboard_layout_combo), i + 1);
if (keyboard_layout == layouts[i].code)
gtk_label_set_text(GTK_LABEL(grid->keyboard_layout_label), s);
g_free(s);
}
free(layouts);
}
/**
* @desc Throw the correct SSL error message
* @throw char *
* @return True if EINTR was catched and syscall should be retried
*/
bool IOSocketSSL::throwSSLError(const int error) {
int err = error;
TRACE_CALL();
switch (SSL_get_error(ssl, err)) {
case SSL_ERROR_WANT_READ:
case SSL_ERROR_WANT_WRITE:
throw(new_SSL_error("SSL_CTX_set_mode() should have fixed this... STRANGE !"));
break;
case SSL_ERROR_ZERO_RETURN:
/* Connection closed */
throw(new_SSL_error("Connection closed by remote host"));
break;
case SSL_ERROR_SYSCALL:
if (err == -1) {
if (errno == EINTR)
return true;
}
break;
case SSL_ERROR_SSL:
throw(new_SSL_error("Internal library error"));
break;
default:
throw(new_SSL_error("Unknown error"));
break;
}
return false;
}
void
ConditionVariable1::wakeup()
{
TRACE_CALL(lib_com.cnd, ("ConditionVariable1{0x%x}::wakeup", _T_PTR(this)));
SetEvent(event_);
}
