void test_semaphore(void) { freerdp_sem sem; sem = freerdp_sem_new(1); freerdp_sem_wait(sem); freerdp_sem_signal(sem); freerdp_sem_free(sem); }
/* can be called from any thread */ static uint32 FREERDP_CC MyVirtualChannelWrite(uint32 openHandle, void* pData, uint32 dataLength, void* pUserData) { rdpChanMan* chan_man; struct chan_data* lchan; int index; chan_man = freerdp_chanman_find_by_open_handle(openHandle, &index); if ((chan_man == NULL) || (index < 0) || (index >= CHANNEL_MAX_COUNT)) { DEBUG_CHANMAN("error bad chanhan"); return CHANNEL_RC_BAD_CHANNEL_HANDLE; } if (!chan_man->is_connected) { DEBUG_CHANMAN("error not connected"); return CHANNEL_RC_NOT_CONNECTED; } if (pData == 0) { DEBUG_CHANMAN("error bad pData"); return CHANNEL_RC_NULL_DATA; } if (dataLength == 0) { DEBUG_CHANMAN("error bad dataLength"); return CHANNEL_RC_ZERO_LENGTH; } lchan = chan_man->chans + index; if (lchan->flags != 2) { DEBUG_CHANMAN("error not open"); return CHANNEL_RC_NOT_OPEN; } freerdp_sem_wait(chan_man->sync_data_sem); /* lock chan_man->sync* vars */ if (!chan_man->is_connected) { freerdp_sem_signal(chan_man->sync_data_sem); DEBUG_CHANMAN("error not connected"); return CHANNEL_RC_NOT_CONNECTED; } chan_man->sync_data = pData; chan_man->sync_data_length = dataLength; chan_man->sync_user_data = pUserData; chan_man->sync_index = index; /* set the event */ wait_obj_set(chan_man->signal); return CHANNEL_RC_OK; }
int main(int argc, char* argv[]) { pthread_t thread; freerdp* instance; dfContext* context; rdpChannels* channels; struct thread_data* data; setlocale(LC_ALL, ""); freerdp_channels_global_init(); g_sem = freerdp_sem_new(1); instance = freerdp_new(); instance->PreConnect = df_pre_connect; instance->PostConnect = df_post_connect; instance->VerifyCertificate = df_verify_certificate; instance->ReceiveChannelData = df_receive_channel_data; instance->context_size = sizeof(dfContext); instance->ContextNew = df_context_new; instance->ContextFree = df_context_free; freerdp_context_new(instance); context = (dfContext*) instance->context; channels = instance->context->channels; DirectFBInit(&argc, &argv); freerdp_parse_args(instance->settings, argc, argv, df_process_plugin_args, channels, NULL, NULL); data = (struct thread_data*) xzalloc(sizeof(struct thread_data)); data->instance = instance; g_thread_count++; pthread_create(&thread, 0, thread_func, data); while (g_thread_count > 0) { freerdp_sem_wait(g_sem); } freerdp_channels_global_uninit(); return 0; }
int main(int argc, char* argv[]) { pthread_t thread; freerdp* instance; tfContext* context; struct thread_data* data; rdpChannels* channels; freerdp_channels_global_init(); g_sem = freerdp_sem_new(1); instance = freerdp_new(); instance->PreConnect = tf_pre_connect; instance->PostConnect = tf_post_connect; instance->ReceiveChannelData = tf_receive_channel_data; instance->ContextSize = (pcContextSize) tf_context_size; instance->ContextNew = (pcContextNew) tf_context_new; instance->ContextFree = (pcContextFree) tf_context_free; freerdp_context_new(instance); context = (tfContext*) instance->context; channels = context->channels; freerdp_parse_args(instance->settings, argc, argv, tf_process_plugin_args, channels, NULL, NULL); data = (struct thread_data*) xzalloc(sizeof(struct thread_data)); data->instance = instance; g_thread_count++; pthread_create(&thread, 0, thread_func, data); while (g_thread_count > 0) { freerdp_sem_wait(g_sem); } freerdp_channels_global_uninit(); return 0; }
static uint32 FREERDP_CC MyVirtualChannelEventPush(uint32 openHandle, RDP_EVENT* event) { rdpChannels* chan_man; struct channel_data* lchan; int index; chan_man = freerdp_channels_find_by_open_handle(openHandle, &index); if ((chan_man == NULL) || (index < 0) || (index >= CHANNEL_MAX_COUNT)) { DEBUG_CHANNELS("error bad chanhan"); return CHANNEL_RC_BAD_CHANNEL_HANDLE; } if (!chan_man->is_connected) { DEBUG_CHANNELS("error not connected"); return CHANNEL_RC_NOT_CONNECTED; } if (event == NULL) { DEBUG_CHANNELS("error bad event"); return CHANNEL_RC_NULL_DATA; } lchan = chan_man->chans + index; if (lchan->flags != 2) { DEBUG_CHANNELS("error not open"); return CHANNEL_RC_NOT_OPEN; } freerdp_sem_wait(chan_man->event_sem); /* lock channels->event */ if (!chan_man->is_connected) { freerdp_sem_signal(chan_man->event_sem); DEBUG_CHANNELS("error not connected"); return CHANNEL_RC_NOT_CONNECTED; } chan_man->event = event; /* set the event */ wait_obj_set(chan_man->signal); return CHANNEL_RC_OK; }
int main(int argc, char* argv[]) { pthread_t thread; freerdp* instance; struct thread_data* data; rdpChanMan* chanman; freerdp_chanman_global_init(); g_sem = freerdp_sem_new(1); instance = freerdp_new(); instance->PreConnect = tf_pre_connect; instance->PostConnect = tf_post_connect; instance->ReceiveChannelData = tf_receive_channel_data; chanman = freerdp_chanman_new(); SET_CHANMAN(instance, chanman); freerdp_parse_args(instance->settings, argc, argv, tf_process_plugin_args, chanman, NULL, NULL); data = (struct thread_data*) xzalloc(sizeof(struct thread_data)); data->instance = instance; g_thread_count++; pthread_create(&thread, 0, thread_func, data); while (g_thread_count > 0) { freerdp_sem_wait(g_sem); } freerdp_chanman_global_uninit(); return 0; }
int main(int argc, char ** argv) { struct thread_data * data; int rv; pthread_t thread; int index = 1; char *home = getenv("HOME"); if (home) { static char resourcefile[512]; strncat(resourcefile, home, strlen(home)); resourcefile[512-1] = (char)0; strcat(resourcefile, "/.directfbrc"); resourcefile[512-1] = (char)0; char *display = getenv("DISPLAY"); #if defined(__unix) || defined(__linux) char *graphics = "fbdev"; #elif defined(__APPLE__) char *graphics = "opengl"; #else char *graphics = "gdi"; #endif if (display) graphics = "x11"; static char buffer[128]; strcat(buffer, "system="); strcat(buffer, graphics); strcat(buffer, "\ndepth=32\nmode=1024x768\nautoflip-window\nforce-windowed\n"); FILE *fp; fp = fopen(resourcefile, "wx"); /* "x" assures no overwrite of an existing resource file */ if (fp != NULL) { fputs((char *)(&buffer), fp); fclose(fp); printf("INFO: created default DirectFB resource file: %s\n", resourcefile); } } else { printf("WARNING: HOME variable not set, unable to create a default DirectFB ~/.directfbrc resource file\n"); } setlocale(LC_CTYPE, ""); if (!freerdp_global_init()) { printf("Error initializing freerdp\n"); return 1; } freerdp_chanman_init(); dfb_init(&argc, &argv); dfb_kb_init(); freerdp_sem_create(&g_sem, 0); while (1) { data = (struct thread_data *) xmalloc(sizeof(struct thread_data)); data->settings = (rdpSet *) xmalloc(sizeof(rdpSet)); data->chan_man = freerdp_chanman_new(); rv = process_params(data->settings, data->chan_man, argc, argv, &index); if (rv == 0) { g_thread_count++; printf("starting thread %d to %s:%d\n", g_thread_count, data->settings->server, data->settings->tcp_port_rdp); pthread_create(&thread, 0, thread_func, data); } else { free(data->settings); freerdp_chanman_free(data->chan_man); free(data); break; } } while (g_thread_count > 0) { DEBUG("main thread, waiting for all threads to exit"); freerdp_sem_wait(&g_sem); DEBUG("main thread, all threads did exit"); } freerdp_chanman_uninit(); freerdp_global_finish(); return 0; }
int main(int argc, char ** argv) { int rv; xfInfo * xfi; pthread_t thread; int index = 1; char reason_msg[ERRINFO_BUFFER_SIZE]; setlocale(LC_CTYPE, ""); if (argc == 1) { out_args(); return 0; } if (!freerdp_global_init()) { printf("Error initializing freerdp\n"); return 1; } freerdp_chanman_init(); freerdp_sem_create(&g_sem, 0); while (1) { xfi = (xfInfo *) malloc(sizeof(xfInfo)); memset(xfi, 0, sizeof(xfInfo)); xfi->settings = (rdpSet *) malloc(sizeof(rdpSet)); xfi->chan_man = freerdp_chanman_new(); xfi->clrconv = (HCLRCONV) malloc(sizeof(CLRCONV)); memset(xfi->clrconv, 0, sizeof(CLRCONV)); xfi->clrconv->alpha = 1; xfi->clrconv->palette = NULL; rv = process_params(xfi, argc, argv, &index); if (rv) { free(xfi->settings); freerdp_chanman_free(xfi->chan_man); free(xfi); break; } DEBUG_X11("starting thread %d to %s:%d", g_thread_count, xfi->settings->server, xfi->settings->tcp_port_rdp); if (pthread_create(&thread, 0, thread_func, xfi) == 0) { g_thread_count++; } } if (g_thread_count > 0) { DEBUG_X11("main thread, waiting for all threads to exit"); freerdp_sem_wait(&g_sem); DEBUG_X11("main thread, all threads did exit"); } freerdp_chanman_uninit(); freerdp_global_finish(); if (g_error_code) return g_error_code; else if (g_disconnect_reason) { printf("disconnect: %s\n", freerdp_str_disconnect_reason(g_disconnect_reason, reason_msg, ERRINFO_BUFFER_SIZE)); } return exit_code_from_disconnect_reason(g_disconnect_reason); }