本文整理汇总了C++中remove_client函数的典型用法代码示例。如果您正苦于以下问题:C++ remove_client函数的具体用法?C++ remove_client怎么用?C++ remove_client使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了remove_client函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: serverLoop
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;
}
}
}
}
示例2: handle_client_connect_cmd
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);
}
}
}
示例3: read_from_clients
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);
}
}
}
}
示例4: handle_requests
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;
}
示例5: client_start
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;
}
示例6: on_read_bytes
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;
}
示例7: process_connection_disconnect
void process_connection_disconnect(datasocket_t s,int32_t reason)
{
remove_client(s);
release_datasocket(&s);
--count;
printf("%d\n",count);
}
示例8: triplet_deregister
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);
}
示例9: read_request
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);
}
}
示例10: destroy_server
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);
}
示例11: remove_idle_client
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;
}
示例12: sig_listen_client
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);
}
}
示例13: start_worker
/* 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
}
示例14: on_timeout
static gboolean
on_timeout (Client * client)
{
g_print ("Timeout\n");
remove_client (client);
return FALSE;
}
示例15: kill_client
void
kill_client(struct client *client)
{
log(2, "kill_client %s\n", client->name);
remove_client(client);
free_client(client);
}