void DisplayChannel::create_primary_surface(int width, int height, uint32_t format) { Canvas *canvas; _mark = false; attach_to_screen(get_client().get_application(), get_id()); clear_area(); AutoRef<CreatePrimarySurfaceEvent> event(new CreatePrimarySurfaceEvent(*this, width, height, format)); get_client().push_event(*event); (*event)->wait(); if (!(*event)->success()) { THROW("Create primary surface failed"); } _x_res = width; _y_res = height; _format = format; canvas = surfaces_mngr.get_canvas(0); #ifdef USE_OGL if (canvas->get_pixmap_type() == CANVAS_TYPE_GL) { ((GCanvas *)(canvas))->touch_context(); screen()->set_update_interrupt_trigger(&_interrupt_update); screen()->set_type_gl(); } #endif }
void DisplayChannel::on_disconnect() { if (surfaces_mngr.is_present_canvas(0)) { Canvas *canvas; canvas = surfaces_mngr.get_canvas(0); canvas->clear(); } if (screen()) { screen()->set_update_interrupt_trigger(NULL); } AutoRef<DetachChannelsEvent> detach_channels(new DetachChannelsEvent(*this)); get_client().push_event(*detach_channels); if (screen()) { AutoRef<UnlockScreenEvent> unlock_event(new UnlockScreenEvent(screen())); get_client().push_event(*unlock_event); detach_from_screen(get_client().get_application()); } get_client().deactivate_interval_timer(*_streams_timer); AutoRef<SyncEvent> sync_event(new SyncEvent()); get_client().push_event(*sync_event); (*sync_event)->wait(); }
/** Deliver mouse move events to the proper client \todo Implement mouse dragging somewhere in the mouse_move chain \todo Support more than one client here */ void sdl_master::mouse_move(SDL_MouseMotionEvent *old, SDL_MouseMotionEvent *fresh) { if (clients[0] != 0) { if ((old->state == SDL_PRESSED) && (fresh->state == SDL_PRESSED)) { //drag event generated here dragging = true; } else { int old_num = get_client(old->x, old->y); if (old_num != get_client(fresh->x, fresh->y)) { //pointer tried to move from one client to another if (clients[old_num]->mouse_leave()) { printf("Prevent client %d from losing the mouse\n", old_num); *fresh = *old; } } int new_num = get_client(fresh->x, fresh->y); //don't do an else here, the fresh mouse position may have changed if (old_num == get_client(fresh->x, fresh->y)) { //mouse moved within a single client clients[old_num]->mouse_move(old, fresh); } else { //mouse was allowed to leave the old client clients[old_num]->mouse_from(old); clients[new_num]->mouse_to(fresh); } } } }
void DisplayChannel::streams_time() { _next_timer_time = 0; Lock lock(_streams_lock); uint32_t mm_time = get_client().get_mm_time(); uint32_t next_time = 0; VideoStream* stream = _active_streams; while (stream) { uint32_t next_frame_time; if ((next_frame_time = stream->handle_timer_update(mm_time))) { if (!next_time || int(next_frame_time - next_time) < 0) { next_time = next_frame_time; } } stream = stream->next; } Lock timer_lock(_timer_lock); mm_time = get_client().get_mm_time(); next_time = mm_time + 15; if (next_time && (!_next_timer_time || int(next_time - _next_timer_time) < 0)) { get_client().activate_interval_timer(*_streams_timer, MAX(int(next_time - mm_time), 0)); _next_timer_time = next_time; } else if (!_next_timer_time) { get_client().deactivate_interval_timer(*_streams_timer); } timer_lock.unlock(); lock.unlock(); Platform::yield(); }
void HTTP_Client_Connection::on_socket_timeout(int pending_operation, long timeout) { //ACE_OS::printf("socket timeout! op_code=%d timeout=%d\n", pending_operation, timeout); //@ //ACE_OS::printf("T"); if ( pending_operation == CONNECT ) ++get_client().n_ct; else ++get_client().n_st; }
void DisplayChannel::reset_screen() { AutoRef<UnlockScreenEvent> unlock_event(new UnlockScreenEvent(screen())); get_client().push_event(*unlock_event); screen()->set_update_interrupt_trigger(NULL); AutoRef<ResetTimer> reset_timer(new ResetTimer(screen()->ref(), get_client())); detach_from_screen(get_client().get_application()); get_client().activate_interval_timer(*reset_timer, RESET_TIMEOUT); }
void DisplayChannel::on_connect() { Message* message = new Message(SPICE_MSGC_DISPLAY_INIT); SpiceMsgcDisplayInit init; init.pixmap_cache_id = 1; init.pixmap_cache_size = get_client().get_pixmap_cache_size(); init.glz_dictionary_id = 1; init.glz_dictionary_window_size = get_client().get_glz_window_size(); _marshallers->msgc_display_init(message->marshaller(), &init); post_message(message); AutoRef<AttachChannelsEvent> attach_channels(new AttachChannelsEvent(*this)); get_client().push_event(*attach_channels); }
/* notification de déconnexion d'un joueur */ void sorti(char *name){ char buffer[MAX_SIZE]; sprintf(buffer, "DECONNEXION/%s/\n", name); client_list *l; client_list *l2; /* Récupération du client à supprimer */ client_list *tmp = get_client(clients, name); if(tmp == NULL){ tmp = get_client(file_attente, name); } if(tmp == NULL){ fprintf(stderr, "sorti : utilisateur inconnu\n"); return; } /* Notification pour les utilisateurs dans la liste des joueurs */ pthread_mutex_lock(&mutex_clients); l = clients; while(l != NULL){ if(strcmp(l->name, name) != 0){ write(l->socket, buffer, strlen(buffer)); } l = l->next; } pthread_mutex_unlock(&mutex_clients); /* Notification pour les utilisateurs dans la file d'attente */ pthread_mutex_lock(&mutex_attente); l2 = file_attente; while(l2 != NULL){ memset(buffer, '\0', MAX_SIZE); if(strcmp(l2->name, name) != 0){ write(l2->socket, buffer, strlen(buffer)); } l2 = l2->next; } pthread_mutex_unlock(&mutex_attente); /* suppression du client des listes et annulation des threads associées */ close(tmp->socket); pthread_mutex_lock(&mutex_clients); clients = suppr_client(clients, name); pthread_mutex_unlock(&mutex_clients); pthread_mutex_lock(&mutex_attente); file_attente = suppr_client(file_attente, name); pthread_mutex_unlock(&mutex_attente); }
ResultCode Store::connection_test() { ResultCode rc = OK; // Check that we can connect to cassandra by getting a client. This logs in // and switches to the specified keyspace, so is a good test of whether // cassandra is working properly. TRC_STATUS("Starting store"); try { get_client(); release_client(); } catch(TTransportException te) { TRC_ERROR("Store caught TTransportException: %s", te.what()); rc = CONNECTION_ERROR; } catch(NotFoundException nfe) { TRC_ERROR("Store caught NotFoundException: %s", nfe.what()); rc = NOT_FOUND; } catch(...) { TRC_ERROR("Store caught unknown exception!"); rc = UNKNOWN_ERROR; } return rc; }
/* validation de la connexion d'un utilisateur */ void bienvenue(char *name, int sock_com){ char buffer[MAX_SIZE]; client_list *tmp; pthread_mutex_lock(&mutex_clients); if(client_exists(clients, name)){ /* si le nom du joueur est déjà pris */ sprintf(buffer, "%s already used\n", name); write(sock_com, buffer, strlen(buffer)); pthread_mutex_unlock(&mutex_clients); }else{ /* ajout dans la file d'attente tant que le client n'est pas nommé */ pthread_mutex_lock(&mutex_attente); file_attente = add_name_client(file_attente, sock_com, name); if(get_phase() == -1){ /* transfert du client dans la file d'attente vers la liste des clients */ tmp = get_client(file_attente, name); file_attente = suppr_client(file_attente, name); tmp->next = clients; clients = tmp; } sprintf(buffer, "BIENVENUE/%s/\n", name); write(sock_com, buffer, strlen(buffer)); pthread_mutex_unlock(&mutex_clients); pthread_mutex_unlock(&mutex_attente); /* Notification à tous les clients de la connexion de ce joueur */ connecte(name); } pthread_mutex_unlock(&mutex_clients); }
gboolean gs_plugin_add_installed (GsPlugin *plugin, GsAppList *list, GCancellable *cancellable, GError **error) { g_autoptr(SnapdClient) client = NULL; g_autoptr(GPtrArray) snaps = NULL; guint i; client = get_client (plugin, error); if (client == NULL) return FALSE; snaps = snapd_client_get_snaps_sync (client, SNAPD_GET_SNAPS_FLAGS_NONE, NULL, cancellable, error); if (snaps == NULL) { snapd_error_convert (error); return FALSE; } for (i = 0; i < snaps->len; i++) { SnapdSnap *snap = g_ptr_array_index (snaps, i); g_autoptr(GsApp) app = NULL; app = snap_to_app (plugin, snap); gs_app_list_add (list, app); } return TRUE; }
gboolean gs_plugin_app_remove (GsPlugin *plugin, GsApp *app, GCancellable *cancellable, GError **error) { g_autoptr(SnapdClient) client = NULL; /* We can only remove apps we know of */ if (g_strcmp0 (gs_app_get_management_plugin (app), "snap") != 0) return TRUE; client = get_client (plugin, error); if (client == NULL) return FALSE; gs_app_set_state (app, AS_APP_STATE_REMOVING); if (!snapd_client_remove_sync (client, gs_app_get_metadata_item (app, "snap::name"), progress_cb, app, cancellable, error)) { gs_app_set_state_recover (app); snapd_error_convert (error); return FALSE; } gs_app_set_state (app, AS_APP_STATE_AVAILABLE); return TRUE; }
/** * 设置回调 */ void set_callback() { if (m_recv_callbackfun != NULL) { get_client()->set_callback(m_recv_callbackfun); } }
int message_complete_cb (http_parser *p) { client_t *client = get_client(p); client->complete = 1; return 0; }
Node *get_client(Node *head, char *nom){ if(head == NULL) return NULL; if(strcmp(head->name, nom) == 0) return head; return get_client(head->next, nom); }
void DisplayChannel::destroy_primary_surface() { if (screen()) { #ifdef USE_OGL if (surfaces_mngr.is_present_canvas(0)) { Canvas *canvas; canvas = surfaces_mngr.get_canvas(0); if (canvas->get_pixmap_type() == CANVAS_TYPE_GL) { screen()->unset_type_gl(); screen()->untouch_context(); } } #endif reset_screen(); } AutoRef<DestroyPrimarySurfaceEvent> event(new DestroyPrimarySurfaceEvent(*this)); get_client().push_event(*event); (*event)->wait(); if (!(*event)->success()) { THROW("Destroying primary surface failed"); } }
void DisplayChannel::handle_stream_create(RedPeer::InMessage* message) { SpiceMsgDisplayStreamCreate* stream_create = (SpiceMsgDisplayStreamCreate*)message->data(); int surface_id = stream_create->surface_id; Lock lock(_streams_lock); if (_streams.size() <= stream_create->id) { _streams.resize(stream_create->id + 1); } if (_streams[stream_create->id]) { THROW("stream exist"); } uint32_t num_clip_rects; SpiceRect* clip_rects; set_clip_rects(stream_create->clip, num_clip_rects, clip_rects); _streams[stream_create->id] = new VideoStream(get_client(), *surfaces_mngr.get_canvas(surface_id), *this, stream_create->codec_type, !!(stream_create->flags & SPICE_STREAM_FLAGS_TOP_DOWN), stream_create->stream_width, stream_create->stream_height, stream_create->src_width, stream_create->src_height, &stream_create->dest, stream_create->clip.type, num_clip_rects, clip_rects); _streams[stream_create->id]->next = _active_streams; _active_streams = _streams[stream_create->id]; }
/* validation de l'annonce d'une solution par le serveur, fin de la phase de reflexion */ void tuastrouve(char *name, int coups){ pthread_mutex_lock(&mutex_clients); client_list *aux = clients; client_list *user = get_client(clients, name); /* Notification à l'utilisateur */ write(user->socket, "TUASTROUVE/\n", strlen("TUASTROUVE/\n")); /* Mise à jour des information du client */ while(aux != NULL){ if(strcmp(aux->name, name) == 0){ aux->proposition = coups; user->proposition = coups; break; } aux = aux->next; } pthread_mutex_unlock(&mutex_clients); /* joueur_solution = 1 (une solution a été trouvée) */ pthread_mutex_lock(&mutex_joueur_solution); joueur_solution = 1; pthread_mutex_unlock(&mutex_joueur_solution); /* Annonce qu'une solution a été trouvée */ ilatrouve(name, coups); }
static int message_begin_cb(http_parser *p) { request *req = NULL; PyObject *environ = NULL; client_t *client = get_client(p); DEBUG("message_begin_cb"); req = new_request(); if(req == NULL){ return -1; } req->start_msec = current_msec; client->current_req = req; environ = new_environ(client); client->complete = 0; /* client->bad_request_code = 0; */ /* client->body_type = BODY_TYPE_NONE; */ /* client->body_readed = 0; */ /* client->body_length = 0; */ req->environ = environ; push_request(client->request_queue, client->current_req); return 0; }
int query_string_cb (http_parser *p, const char *buf, size_t len, char partial) { client_t *client = get_client(p); request *req = client->req; buffer_result ret = MEMORY_ERROR; if(req->query_string){ ret = write2buf(req->query_string, buf, len); }else{ req->query_string = new_buffer(1024*2, LIMIT_QUERY_STRING); ret = write2buf(req->query_string, buf, len); } switch(ret){ case MEMORY_ERROR: client->bad_request_code = 500; return -1; case LIMIT_OVER: client->bad_request_code = 400; return -1; default: break; } return 0; }
int oo_hw_filter_set_thc(struct oo_hw_filter* oofilter, tcp_helper_cluster_t* thc, int protocol, unsigned daddr, int dport, unsigned hwport_mask) { struct efx_filter_spec spec; int hwport, base_vi_id, rc; ci_assert_equal(oofilter->trs, NULL); oofilter->thc = thc; for( hwport = 0; hwport < CI_CFG_MAX_REGISTER_INTERFACES; ++hwport ) if( hwport_mask & (1 << hwport) && thc->thc_vi_set[hwport] != NULL ) { base_vi_id = efrm_vi_set_get_base(thc->thc_vi_set[hwport]); efx_filter_init_rx(&spec, EFX_FILTER_PRI_REQUIRED, EFX_FILTER_FLAG_RX_SCATTER | EFX_FILTER_FLAG_RX_RSS, base_vi_id); spec.rss_context = efrm_vi_set_get_rss_context(thc->thc_vi_set[hwport]); #if EFX_DRIVERLINK_API_VERSION >= 15 { int stack_id = tcp_helper_cluster_vi_hw_stack_id(thc, hwport); ci_assert( stack_id >= 0 ); efx_filter_set_stack_id(&spec, stack_id); } #endif rc = efx_filter_set_ipv4_local(&spec, protocol, daddr, dport); ci_assert_equal(rc, 0); rc = efrm_filter_insert(get_client(hwport), &spec, false); if( rc < 0 ) { oo_hw_filter_clear(oofilter); return rc; } oofilter->filter_id[hwport] = rc; } return 0; }
gboolean sb_settings_get_follow_moves (void) { return gconf_client_get_bool (get_client (), "/apps/source-browser/follow-moves", NULL); }
int body_cb (http_parser *p, const char *buf, size_t len, char partial) { client_t *client = get_client(p); if(max_content_length <= client->body_readed + len){ client->bad_request_code = 413; return -1; } if(client->body_type == BODY_TYPE_NONE){ if(client->body_length == 0){ //Length Required client->bad_request_code = 411; return -1; } //default memory stream #ifdef DEBUG printf("client->body_length %d \n", client->body_length); #endif client->body_type = BODY_TYPE_BUFFER; #ifdef DEBUG printf("BODY_TYPE_BUFFER \n"); #endif } write_body(client, buf, len); return 0; }
void HTTP_Client_Connection::on_read_error(const error_code& error) { //ACE_OS::printf("read error:%s\n", error.message().c_str()); //@ //ACE_OS::printf("R"); ++get_client().n_re; }
int header_value_cb (http_parser *p, const char *buf, size_t len, char partial) { uint32_t i; header *h; client_t *client = get_client(p); request *req = client->req; buffer_result ret = MEMORY_ERROR; i = req->num_headers; h = req->headers[i]; if(h){ ret = write2buf(h->value, buf, len); } switch(ret){ case MEMORY_ERROR: client->bad_request_code = 500; return -1; case LIMIT_OVER: client->bad_request_code = 400; return -1; default: break; } req->last_header_element = VAL; return 0; }
/* traitement d'une enchere */ void traitement_enchere(char *name, int coups){ pthread_mutex_lock(&mutex_clients); client_list *cl = get_client(clients, name); if(cl->proposition != -1 && coups >= cl->proposition){ /* Echec si un joueur essaye d'encherir une valeur plus grande que celle qu'il a déjà encheri */ echec(cl->socket, name); }else{ client_list *aux = clients; int bool = 0; char *user_incoherent; /* Vérification qu'il n'existe pas une enchere de même valeur */ while(aux != NULL){ if(aux->proposition == coups){ user_incoherent = aux->name; bool = 1; break; } aux = aux->next; } if(bool == 1){ /* Echec */ echec(cl->socket, user_incoherent); }else{
int fragment_cb (http_parser *p, const char *buf, size_t len, char partial) { client_t *client = get_client(p); register request *req = client->req; buffer_result ret = MEMORY_ERROR; if(req->fragment){ ret = write2buf(req->fragment, buf, len); }else{ req->fragment = new_buffer(1024, LIMIT_FRAGMENT); ret = write2buf(req->fragment, buf, len); } switch(ret){ case MEMORY_ERROR: client->bad_request_code = 500; return -1; case LIMIT_OVER: client->bad_request_code = 400; return -1; default: break; } return 0; }
gboolean gs_plugin_app_install (GsPlugin *plugin, GsApp *app, GCancellable *cancellable, GError **error) { g_autoptr(SnapdClient) client = NULL; SnapdInstallFlags flags = SNAPD_INSTALL_FLAGS_NONE; /* We can only install apps we know of */ if (g_strcmp0 (gs_app_get_management_plugin (app), "snap") != 0) return TRUE; client = get_client (plugin, error); if (client == NULL) return FALSE; gs_app_set_state (app, AS_APP_STATE_INSTALLING); if (g_strcmp0 (gs_app_get_metadata_item (app, "snap::confinement"), "classic") == 0) flags |= SNAPD_INSTALL_FLAGS_CLASSIC; if (!snapd_client_install2_sync (client, flags, gs_app_get_metadata_item (app, "snap::name"), NULL, NULL, progress_cb, app, cancellable, error)) { gs_app_set_state_recover (app); snapd_error_convert (error); return FALSE; } gs_app_set_state (app, AS_APP_STATE_INSTALLED); return TRUE; }
gboolean sb_settings_get_ignore_whitespaces (void) { return gconf_client_get_bool (get_client (), "/apps/source-browser/ignore-whitespaces", NULL); }
// Check if an app is graphical by checking if it uses a known GUI interface. // This doesn't necessarily mean that every binary uses this interfaces, but is probably true. // https://bugs.launchpad.net/bugs/1595023 static gboolean is_graphical (GsPlugin *plugin, GsApp *app, GCancellable *cancellable) { g_autoptr(SnapdClient) client = NULL; g_autoptr(GPtrArray) plugs = NULL; guint i; g_autoptr(GError) error = NULL; client = get_client (plugin, &error); if (client == NULL) return FALSE; if (!snapd_client_get_interfaces_sync (client, &plugs, NULL, cancellable, &error)) { g_warning ("Failed to check interfaces: %s", error->message); return FALSE; } for (i = 0; i < plugs->len; i++) { SnapdPlug *plug = plugs->pdata[i]; const gchar *interface; // Only looks at the plugs for this snap if (g_strcmp0 (snapd_plug_get_snap (plug), gs_app_get_metadata_item (app, "snap::name")) != 0) continue; interface = snapd_plug_get_interface (plug); if (interface == NULL) continue; if (g_strcmp0 (interface, "unity7") == 0 || g_strcmp0 (interface, "x11") == 0 || g_strcmp0 (interface, "mir") == 0) return TRUE; } return FALSE; }