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_); }