// scan for windows and add them to the list of managed clients // from dwm.c void scan(void) { unsigned int num; Window d1, d2, *cl, *wins = NULL; unsigned long cl_count; XWindowAttributes wa; ewmh_get_original_client_list(&cl, &cl_count); if (XQueryTree(g_display, g_root, &d1, &d2, &wins, &num)) { for (int i = 0; i < num; i++) { if(!XGetWindowAttributes(g_display, wins[i], &wa) || wa.override_redirect || XGetTransientForHint(g_display, wins[i], &d1)) continue; // only manage mapped windows.. no strange wins like: // luakit/dbus/(ncurses-)vim // but manage it if it was in the ewmh property _NET_CLIENT_LIST by // the previous window manager // TODO: what would dwm do? if (is_window_mapped(g_display, wins[i]) || 0 <= array_find(cl, cl_count, sizeof(Window), wins+i)) { manage_client(wins[i]); XMapWindow(g_display, wins[i]); } } if(wins) XFree(wins); } }
int waiting_for_connection(t_info *info) { int b; unsigned int size; b = 1; while (info->accept_connections) { size = sizeof(info->sin_client); info->csock = accept(info->socket, (struct sockaddr *)(&(info->sin_client)), &size); if (info->csock == -1) { b = 0; info->accept_connections = 0; } else if (manage_client(info) == 0) info->accept_connections = 0; close(info->csock); } waiting_for_pid(info->pid_list); close_everything(info); return (b); }
int main(int argc, char **argv) { int sock; int new_sock; pid_t pid = 0; int opt = 1; parse_options(argc, argv); sock = create_sock(); while (1) { new_sock = accept_request(sock); if (new_sock < 1) { break; } if ((setsockopt(new_sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt))) < 0) { perror("setsockopt"); } pid = client_fork(); if (pid == 0) { printf("Client spawned\n"); manage_client(new_sock, "A_PASS_HERE", "ENC_TYPE_HERE"); close(new_sock); } } return 0; }
int post_select(t_server *server, fd_set *rfds, fd_set *wfds) { if (FD_ISSET(server->fd, rfds)) { add_client(server); } else { manage_client(server, rfds, wfds); } return (0); }
// scan for windows and add them to the list of managed clients void scan(void) { unsigned int i, num; Window d1, d2, *wins = NULL; XWindowAttributes wa; if(XQueryTree(gDisplay, gRoot, &d1, &d2, &wins, &num)) { for(i = 0; i < num; i++) { if(!XGetWindowAttributes(gDisplay, wins[i], &wa) || wa.override_redirect || XGetTransientForHint(gDisplay, wins[i], &d1)) continue; if (wa.map_state == IsViewable) manage_client(wins[i]); } for(i = 0; i < num; i++){ // now the transients if(!XGetWindowAttributes(gDisplay, wins[i], &wa)) continue; if(XGetTransientForHint(gDisplay, wins[i], &d1) && (wa.map_state == IsViewable)) manage_client(wins[i]); } if(wins) XFree(wins); } }
void maprequest(XEvent* event) { XMapRequestEvent* mapreq = &event->xmaprequest; Client *c; if((c = wintosystrayicon(mapreq->window))) { resizebarwin(get_current_monitor()); updatesystray(); } if (!get_client_from_window(mapreq->window)) { // client should be managed (is not ignored but is not managed yet Client* client = manage_client(mapreq->window); if (client && find_monitor_with_tag(client->tag)) XMapWindow(gDisplay, mapreq->window); } }
/** * gst_rtsp_server_io_func: * @channel: a #GIOChannel * @condition: the condition on @source * * A default #GIOFunc that creates a new #GstRTSPClient to accept and handle a * new connection on @channel or @server. * * Returns: TRUE if the source could be connected, FALSE if an error occured. */ gboolean gst_rtsp_server_io_func (GIOChannel * channel, GIOCondition condition, GstRTSPServer * server) { gboolean result; GstRTSPClient *client = NULL; GstRTSPServerClass *klass; if (condition & G_IO_IN) { klass = GST_RTSP_SERVER_GET_CLASS (server); if (klass->create_client) client = klass->create_client (server); if (client == NULL) goto client_failed; /* a new client connected, create a client object to handle the client. */ if (klass->accept_client) result = klass->accept_client (server, client, channel); if (!result) goto accept_failed; /* manage the client connection */ manage_client (server, client); } else { GST_WARNING_OBJECT (server, "received unknown event %08x", condition); } return TRUE; /* ERRORS */ client_failed: { GST_ERROR_OBJECT (server, "failed to create a client"); return FALSE; } accept_failed: { GST_ERROR_OBJECT (server, "failed to accept client"); gst_object_unref (client); return FALSE; } }
void maprequest(XEvent* event) { HSDebug("name is: MapRequest\n"); XMapRequestEvent* mapreq = &event->xmaprequest; if (is_herbstluft_window(g_display, mapreq->window)) { // just map the window if it wants that XWindowAttributes wa; if (!XGetWindowAttributes(g_display, mapreq->window, &wa)) { return; } XMapWindow(g_display, mapreq->window); } else if (!get_client_from_window(mapreq->window)) { // client should be managed (is not ignored) // but is not managed yet HSClient* client = manage_client(mapreq->window); if (client && find_monitor_with_tag(client->tag)) { XMapWindow(g_display, mapreq->window); } } // else: ignore all other maprequests from windows // that are managed already }
void manage_serveur(t_desc *serv, t_env *e) { int i; t_timev t; struct timeval tv; FD_ZERO(&e->readfs); FD_ZERO(&e->wrtefs); i = -1; FD_SET(serv->s, &e->readfs); t = manage_time(serv); while (++i < MAX_FD) if (serv->players[i].type != FD_FREE) { FD_SET(serv->players[i].cs, &e->readfs); FD_SET(serv->players[i].cs, &e->wrtefs); } e->fd_max = search_max_fd(serv->players, e->fd_max); manage_time_in_select(t, &tv); xselect(e->fd_max + 1, &e->readfs, &e->wrtefs, NULL, &tv); if (FD_ISSET(serv->s, &e->readfs)) add_players(serv, e); manage_client(serv, e, t); }