void
serverLoop(void) {

    while (true) {
        // res stores the numbers of file descriptors throwed an event
        int res = poll(pollList->elements, pollList->size, INFINITE_TIMEOUT);
        // Poll returns without any events
        if (res == 0) {
            continue;
        }
        if (res < 0) {
            perror("poll failed!");
            break;
        }
        int i;
        struct pollfd *pollfd = NULL;
        for (i = 0 ; i < pollList->size; ++i) {
            pollfd = pollVector_get(pollList, i);
            // This fd didn't fired an event
            if (pollfd->revents == 0) {
                continue;
            }
            // The fd want to send something
            if ((pollfd->revents & POLLIN) == POLLIN) {
                // New client want to connect
                if (pollfd->fd == serverSocket) {
                    // try to accept new client
                    if (accept_newClient() == EXIT_FAILURE) {
                        return;
                    }
                }
                // Connected client want to send something
                else {
                    // Read it's input and handle it
                    int cRes = handle_client(pollfd->fd);
                    // sconnected
                    if (cRes == CLIENT_DISCONNECTED) {
                        printf("Client %d disconnected\n", pollfd->fd);
                        remove_client(pollfd->fd);
                        --i;
                    }
                    // An error occurred
                    else if (cRes == EXIT_FAILURE) {
                        printf("Client %d crashed!\n", pollfd->fd);
                        remove_client(pollfd->fd);
                        --i;
                    }
                    else {
                        // Do Nothing
                    }
                }
            }
            // Unregistered poll event was thrown
            else {
                fprintf(stderr, "Unkown poll event %d! Server is stopping\n", pollfd->revents);
                return;
            }
        }
    }
}

static void handle_client_connect_cmd(CLIENT_REC *client,
				      const char *cmd, const char *args)
{
	const char *password;

	password = settings_get_str("irssiproxy_password");

	if (password != NULL && g_strcmp0(cmd, "PASS") == 0) {
		if (g_strcmp0(password, args) == 0)
			client->pass_sent = TRUE;
		else {
			/* wrong password! */
			remove_client(client);
                        return;
		}
	} else if (g_strcmp0(cmd, "NICK") == 0) {
		g_free_not_null(client->nick);
		client->nick = g_strdup(args);
	} else if (g_strcmp0(cmd, "USER") == 0) {
		client->user_sent = TRUE;
	}

	if (client->nick != NULL && client->user_sent) {
		if (*password != '\0' && !client->pass_sent) {
			/* client didn't send us PASS, kill it */
			remove_client(client);
		} else {
			client->connected = TRUE;
			proxy_dump_data(client);
		}
	}
}

void read_from_clients(fd_set *fdset)
{
	char buf[48];
	int i;
	int sock;
	int n;
	for (i=0; i < num_clients; i++) {
		sock = clients[i].sock;
		if (!FD_ISSET(sock, fdset))
			continue;
		if (!readbytes(sock, buf, 1) || buf[0] >= '\t' &&
						buf[0] < '\033') {
			i = remove_client(i);
			continue;
		}
		n = 0;
		switch (buf[0]) {
		case 'N':
			if (readbytes(sock, buf+1, 1)) {
				if (buf[1] == '_') {
					send_opponent_name(i);
					continue;
				}
				if (readbytes(sock, buf+2, 15)) {
					memcpy(clients[i].name, buf+1, 16);
					continue;
				}
			}
			i = remove_client(i);
			continue;
		case 'b':
		case 'g':
		case 'h':
		case 'w':
			n = 1;
			break;
		case 'p':
			writebytes(sock, "N_", 2);
		case 'm':
		case 'n':
			n = 2;
			break;
		case 'x':
			n = 4;
		}
		if (n && !readbytes(sock, buf+1, n) ||
		    !fwd_to_opponent(i, buf, n+1))
			i = remove_client(i);
		else if (buf[0] == 'b') {
			n = buf[1];
			if (n > 0 && n <= 12) {
				n *= 4;
				if (!readbytes(sock, buf, n) ||
				    !fwd_to_opponent(i, buf, n))
					i = remove_client(i);
			}
		}
	}
}

int handle_requests()
{
    struct sockaddr_in remote;
    struct pollfd pfds[MAX_CLIENTS];
    int cli_fd, i, n;
    
    size_t len = sizeof(remote);

// akceptujemy przychodzace polaczenia i dodajemy nowych klientow do tablicy
    while ((cli_fd = accept(sock_fd, (struct sockaddr *)&remote, &len))>0)
	if( add_client(cli_fd) < 0) 
	{
	    close(cli_fd);
	    return 0;
	}


// przygotowujemy liste deskryptorow dla poll()-a
    for(n=i=0;i < MAX_CLIENTS;i++)
	if(client_tab[i].fd)
	{    
	    pfds[n].fd = client_tab[i].fd;
	    pfds[n].events = POLLIN | POLLHUP; // reagujemy na przychodzace dane i zerwanie sesji
	    pfds[n].revents = 0;

	    n++;
	}    

    int ret;

// pollujemy klientow    
    if(( ret = poll(pfds, n, 10)) < 0) die("poll error: %s", strerror(errno));

// brak ruchu - koniec pracy funkcji
    if(!ret)  return 0; 

// sprawdzamy, co sie wydarzylo:
    for(i=0; i<n ;i++)
    {
	if(pfds[i].revents & POLLHUP)					// klient zerwal polaczenie?
	{
	    fprintf(stderr, "[lsrv] client %d closed connection.\n", pfds[i].fd);
	    close(pfds[i].fd);
	    remove_client(pfds[i].fd);
	} else if(pfds[i].revents & POLLIN)				// nadeszly dane od klienta?
	{
	    if(handle_client(find_client(pfds[i].fd)) < 0)
	    {
	        close(pfds[i].fd);
		remove_client(pfds[i].fd);
    	    }
	}  	
    }
    
    return 0;    

}

static NMDHCPClient *
client_start (NMDHCPManager *self,
              const char *iface,
              const char *uuid,
              gboolean ipv6,
              NMSettingIP4Config *s_ip4,
              NMSettingIP6Config *s_ip6,
              guint32 timeout,
              guint8 *dhcp_anycast_addr,
              const char *hostname,
              gboolean info_only)
{
	NMDHCPManagerPrivate *priv;
	NMDHCPClient *client;
	gboolean success = FALSE;

	g_return_val_if_fail (self, NULL);
	g_return_val_if_fail (NM_IS_DHCP_MANAGER (self), NULL);
	g_return_val_if_fail (iface != NULL, NULL);
	g_return_val_if_fail (uuid != NULL, NULL);

	priv = NM_DHCP_MANAGER_GET_PRIVATE (self);

	/* Ensure we have a usable DHCP client */
	g_return_val_if_fail (priv->client_type != 0, NULL);

	/* Kill any old client instance */
	client = get_client_for_iface (self, iface, ipv6);
	if (client) {
		nm_dhcp_client_stop (client);
		remove_client (self, client);
	}

	/* And make a new one */
	client = g_object_new (priv->client_type,
	                       NM_DHCP_CLIENT_INTERFACE, iface,
	                       NM_DHCP_CLIENT_IPV6, ipv6,
	                       NM_DHCP_CLIENT_UUID, uuid,
	                       NM_DHCP_CLIENT_TIMEOUT, timeout ? timeout : DHCP_TIMEOUT,
	                       NULL);
	g_return_val_if_fail (client != NULL, NULL);
	add_client (self, client);

	if (ipv6)
		success = nm_dhcp_client_start_ip6 (client, s_ip6, dhcp_anycast_addr, hostname, info_only);
	else
		success = nm_dhcp_client_start_ip4 (client, s_ip4, dhcp_anycast_addr, hostname);

	if (!success) {
		remove_client (self, client);
		g_object_unref (client);
		client = NULL;
	}

	return client;
}

static gboolean
on_read_bytes (GPollableInputStream * stream, Client * client)
{
  gssize r;
  gchar data[4096];
  GError *err = NULL;

  do {
    r = g_pollable_input_stream_read_nonblocking (G_POLLABLE_INPUT_STREAM
        (client->istream), data, sizeof (data), NULL, &err);
    if (r > 0)
      g_byte_array_append (client->current_message, (guint8 *) data, r);
  } while (r > 0);

  if (r == 0) {
    remove_client (client);
    return FALSE;
  } else if (g_error_matches (err, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK)) {
    guint8 *tmp = client->current_message->data;

    g_clear_error (&err);

    while (client->current_message->len > 3) {
      if (tmp[0] == 0x0d && tmp[1] == 0x0a && tmp[2] == 0x0d && tmp[3] == 0x0a) {
        guint len;

        g_byte_array_append (client->current_message, (const guint8 *) "\0", 1);
        len = tmp - client->current_message->data + 5;
        client_message (client, (gchar *) client->current_message->data, len);
        g_byte_array_remove_range (client->current_message, 0, len);
        tmp = client->current_message->data;
      } else {
        tmp++;
      }
    }

    if (client->current_message->len >= 1024 * 1024) {
      g_print ("No complete request after 1MB of data\n");
      remove_client (client);
      return FALSE;
    }

    return TRUE;
  } else {
    g_print ("Read error %s\n", err->message);
    g_clear_error (&err);
    remove_client (client);
    return FALSE;
  }

  return FALSE;
}

void process_connection_disconnect(datasocket_t s,int32_t reason)
{
	remove_client(s);
	release_datasocket(&s);
	--count;
	printf("%d\n",count);	
}

Code_t
triplet_deregister(Client *client,
		   Destination *dest,
		   ZRealm *realm)
{
    Triplet *triplet;
    int retval;
    unsigned long hashval;

    hashval = DEST_HASHVAL(*dest);
    for (triplet = triplet_bucket[hashval]; triplet; triplet = triplet->next) {
	if (ZDest_eq(&triplet->dest, dest)) {
	    retval = remove_client(triplet, client, realm);
	    if (retval != ZERR_NONE)
		return retval;
	    if (*triplet->clients == NULL && !triplet->acl) {
		Triplet_delete(triplet);
		free_triplet(triplet);
		return ZSRV_EMPTYCLASS;
	    }
	    return ZERR_NONE;
	}
    }
    return(ZSRV_BADASSOC);
}

static void read_request(struct server *s, struct client *c, struct frame_buffers *fbs) {
    size_t len;
    char buf[SERVER_BUFFER_SIZE];
    memset(buf, 0, sizeof(buf));

    if (!c->request_received) {

        if ((len = client_read(c, buf, sizeof(buf))) < 1) {
            if (errno == EINTR) {
                return;
            }

            // len == 0 means that the client has disconnected
            // len == -1 means an error occured
            return remove_client(s, c);
        }
        c->last_communication = gettime();

        // Check if we have the whole thing
        strncpy(&c->request_headers[c->request_header_size], buf, MAX_REQUEST_HEADER_SIZE - c->request_header_size);
        c->request_header_size += len;

        if (strstr(c->request_headers, "\r\n\r\n") != NULL) {
            c->request_received = 1;
        }
    }

    // Parse request headers
    if (c->request_received && c->request == REQUEST_INCOMPLETE) {
        handle_request(s, c, fbs);
    }
}

void destroy_server(struct server *s) {
    int i;
    struct client *c;

    for (i = 0; i < FD_SETSIZE; i++) {
        c = s->clients[i];
        if (c != NULL) {
            remove_client(s, c);
        }
    }

    if (s->sock4 >= 0) {
        close(s->sock4);
    }

    if (s->sock6 >= 0) {
        close(s->sock6);
    }
    
    if (s->ssl_ctx != NULL) {
        SSL_CTX_free(s->ssl_ctx);
    }

    free(s->auth);
    free(s->static_root);
    free(s->stream_info);

    free(s);
}

static BOOL remove_idle_client(void)
{
	struct winbindd_cli_state *state, *remove_state = NULL;
	time_t last_access = 0;
	int nidle = 0;

	for (state = winbindd_client_list(); state; state = state->next) {
		if (state->read_buf_len == 0 && state->write_buf_len == 0 &&
				!state->getpwent_state && !state->getgrent_state) {
			nidle++;
			if (!last_access || state->last_access < last_access) {
				last_access = state->last_access;
				remove_state = state;
			}
		}
	}

	if (remove_state) {
		DEBUG(5,("Found %d idle client connections, shutting down sock %d, pid %u\n",
			nidle, remove_state->sock, (unsigned int)remove_state->pid));
		remove_client(remove_state);
		return True;
	}

	return False;
}

static void sig_listen_client(CLIENT_REC *client)
{
	char *str, *cmd, *args;
	int ret;

	g_return_if_fail(client != NULL);

	while (g_slist_find(proxy_clients, client) != NULL) {
		ret = net_sendbuffer_receive_line(client->handle, &str, 1);
		if (ret == -1) {
			/* connection lost */
			remove_client(client);
			break;
		}

		if (ret == 0)
			break;

		cmd = g_strdup(str);
		args = strchr(cmd, ' ');
		if (args != NULL) *args++ = '\0'; else args = "";
		if (*args == ':') args++;
		ascii_strup(cmd);

		handle_client_cmd(client, cmd, args, str);

		g_free(cmd);
	}
}

/* Start worker
 */
int start_worker(t_session *session) {
#ifndef ENABLE_THREAD_POOL
	int result = -1;
	pthread_attr_t child_attr;
	pthread_t      child_thread;

	if (pthread_attr_init(&child_attr) != 0) {
		log_system(session, "pthread init error");
	} else {
		if (pthread_attr_setdetachstate(&child_attr, PTHREAD_CREATE_DETACHED) != 0) {
			log_system(session, "pthread set detach state error");
		} else if (pthread_attr_setstacksize(&child_attr, PTHREAD_STACK_SIZE) != 0) {
			log_system(session, "pthread set stack size error");
		} else if (add_client(session) == 0) {
			if (pthread_create(&child_thread, &child_attr, (void*)connection_handler, (void*)session) == 0) {
				/* Worker thread started
				 */
				result = 0;
			} else {
				remove_client(session, false);
				log_system(session, "pthread create error");
			}
		}
		pthread_attr_destroy(&child_attr);
	}

	return result;
#else
	int result = 0;
	t_session_list *new_session;

	pthread_mutex_lock(&thread_pool_mutex);

	if (waiting_workers <= 0) {
		if (add_thread_to_pool(session) == -1) {
			result = -1;
		}
	} else if ((new_session = (t_session_list*)malloc(sizeof(t_session_list))) == NULL) {
		result = -1;
	} else {
		new_session->session = session;

		new_session->next = session_list;
		session_list = new_session;

		if (pthread_cond_signal(&thread_pool_cond) != 0) {
			result = -1;
			session_list = session_list->next;
			free(new_session);
		} else {
			waiting_workers--;
		}
	}

	pthread_mutex_unlock(&thread_pool_mutex);

	return result;
#endif
}

static gboolean
on_timeout (Client * client)
{
  g_print ("Timeout\n");
  remove_client (client);

  return FALSE;
}

void
kill_client(struct client *client)
{
    log(2, "kill_client %s\n", client->name);

    remove_client(client);
    free_client(client);
}

int cliser_server_client_close(lua_State *L) {
   server_client_t *server_client = (server_client_t *)lua_touserdata(L, 1);
   if (server_client->client == NULL) return LUA_HANDLE_ERROR_STR(L, "server client is invalid, either closed or used outside of server function scope");
   remove_client(server_client->server, server_client->client);
   destroy_client(L, server_client->client);
   server_client->server = NULL;
   server_client->client = NULL;
   return 0;
}

void process_send_block(datasocket_t s)
{
	remove_client(s);
	--count;
	printf("%d\n",count);		
	//·¢ËÍ×èÈû,Ö±½Ó¹Ø±Õ
	close_datasocket(s);
	
}

void
handler_destroynotify(XEvent *ev)
{
	struct client *c;

	dbg_print(__func__);

	if ((c = find_client_by_window(mons, ev->xdestroywindow.window)))
		remove_client(c, true);
}

static void drop_bads(void)
{
	int i;
	for (i = 0; i < MAX_CLIENTS; i++)
	{
		Client *c = server.clients + i;
		if (c->sock < 0) continue;
		if (!c->good || !raft_is_leader(raft)) remove_client(c);
	}
}

void
cb_handler(evutil_socket_t fd, short what, void *arg)
  {
    ssize_t rval;
    char buf[BUF_SIZE];
    struct client *c_arg = (struct client*) arg;
//    printf("handling\n");
//    fflush(stdout);
    
    rval = read (fd, buf, BUF_SIZE);
		if (rval < 0)
		  {
		    perror ("Reading stream message");
		    if (close (fd) < 0)
		      {
		        perror ("close");
    		    remove_client (c_arg);
		      }
		  }
		else if (rval == 0)
		  {
//		    fprintf (stderr, "Ending connection\n");
		    if (close (fd) < 0)
    			perror ("close");
    	  if (0 != event_del(c_arg->ev))
    	    {
    	      perror ("event del");
    	      exit (EXIT_FAILURE);
    	    }
    	  ++finished;
    	  if (finished == WAITING_FOR)
            check(event_base_loopbreak(base), "event loop break");
    	  
		    remove_client (c_arg);
		  }
    else
      {
        readed += (long long) rval;
//        printf ("-->%.*s \n", (int) rval, buf);
      }

//    fflush(stdout);
  }