void setup_socket() { printf("%s\n","We are starting zzz..."); int listen_fd = Open_listenfd(my_port); printf("Setting up listen_fd with number: %d\n", listen_fd); SA clientaddr; /*// Setup your read_set with FD_ZERO and the server socket descriptor FD_ZERO(&p.read_set); FD_SET(listen_fd, &p.read_set); p.maxfd = listen_fd + 1;*/ init_pool(listen_fd, &p); while(1) { p.ready_set = p.read_set; p.nready = select(p.maxfd + 1, &p.ready_set, &p.write_set, NULL, NULL); if(FD_ISSET(listen_fd, &p.ready_set)) { socklen_t clientlen = sizeof(clientaddr); int conn_fd = Accept(listen_fd, &clientaddr, &clientlen);//If there is a request then accept it printf("Accepting with conn_fd: %d\n", conn_fd); add_client(conn_fd, &p); } check_clients(&p); /*socklen_t clientlen = sizeof(clientaddr); int conn_fd = Accept(listen_fd, &clientaddr, &clientlen);//If there is a request then accept it printf("Accepting with conn_fd: %d\n", conn_fd); break;*/ } }
void cql::cql_client_pool_impl_t::add_client(const std::string& server, unsigned int port) { std::list<std::string> e; add_client(server, port, NULL, e); }
static void server_read(t_select *select, t_client *server) { #ifdef DEBUG printf("*** select: server read\n"); #endif /* !DEBUG */ add_client(select, server); }
/* adds a new X11 client to the list, IF it does not already exist */ void set_client_window(Window win) { int i, scr_count; struct client *cnode; /* When a magellan application exits, the SDK sets another window to avoid * crashing the original proprietary daemon. The new free SDK will set * consistently the root window for that purpose, which we can ignore here * easily. */ scr_count = ScreenCount(dpy); for(i=0; i<scr_count; i++) { if(win == RootWindow(dpy, i)) { return; } } cnode = client_list->next; while(cnode) { if(cnode->win == win) { return; } cnode = cnode->next; } add_client(CLIENT_X11, &win); }
void server_read(t_info *info, t_client **client) { t_client *c; c = add_client(info, (*client)->socket, 0, 0); begin_session(info, &c); }
void test_add_client(struct login_message lm) { if(add_client(lm)){ printf("client %s is in %s\n", lm.userid, lm.dir); } else { printf("client %s added to %s\n", lm.userid, lm.dir); } }
/** :* @method : SockServer::accept6 * @return : * < Socket : success, new client accepted. * < NULL : fail. * @desc : * This method is used by server socket for accepting a new client * connection. This is a for IPv6 server socket. */ Socket* SockServer::accept6() { socklen_t client_addrlen; struct sockaddr_in6 client_addr; Socket* client = NULL; client = new Socket(); if (!client) { return NULL; } client_addrlen = SockAddr::IN_SIZE; client->_d = ::accept(_d, (struct sockaddr *) &client_addr , &client_addrlen); if (client->_d < 0) { delete client; return NULL; } inet_ntop(_family, &client_addr.sin6_addr, client->_name._v , client->_name._l); client->_status = O_RDWR | O_SYNC; add_client(client); return client; }
int main(int argc, char **argv) { int listenfd, connfd, port; socklen_t clientlen = sizeof(struct sockaddr_in); struct sockaddr_in clientaddr; static pool pool; if (argc != 2) { fprintf(stderr, "usage: %s <port>\n", argv[0]); exit(0); } port = atoi(argv[1]); listenfd = Open_listenfd(port); init_pool(listenfd, &pool); while (1) { /* Wait for listening/connected descriptor(s) to become ready */ pool.ready_set = pool.read_set; pool.nready = Select(pool.maxfd+1, &pool.ready_set, NULL, NULL, NULL); /* If listening descriptor ready, add new client to pool */ if (FD_ISSET(listenfd, &pool.ready_set)) { connfd = Accept(listenfd, (SA *)&clientaddr, &clientlen); add_client(connfd, &pool); } /* Echo a text line from each ready connected descriptor */ check_client(&pool); } }
void server_read(t_env *e, int fd) { int cs; cs = add_client(e, fd); printf("New client : %d\n", cs); }
/* 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 }
struct client * create_client(struct domain *domain, int sockfd, #ifndef DISABLE_LOGGING struct sockaddr *addr, socklen_t addrlen, #endif int randomfd) { struct client *client; int ret; #ifdef HAVE_DEV_RANDOM ssize_t nbytes; #endif client = calloc(1, sizeof(*client)); if (client == NULL) return NULL; #ifndef DISABLE_LOGGING if ((size_t)addrlen > sizeof(client->address)) addrlen = sizeof(client->address); memcpy(&client->address, addr, addrlen); #endif /* DISABLE_LOGGING */ /* a good random client id is vitally important for security, because secondary connections authorized themselves with it */ #ifdef HAVE_DEV_RANDOM nbytes = read(randomfd, &client->id, sizeof(client->id)); if (nbytes < (ssize_t)sizeof(client->id)) { fprintf(stderr, "random number generation failed\n"); free(client); return NULL; } #else (void)randomfd; client->id = (random() << 24) + (random() << 16) + (random() << 8) + random(); #endif client->sockets[0] = sockfd; client->num_sockets = 1; client->timeout = time(NULL) + 60; #ifndef DISABLE_LOGGING update_client_name(client); #endif ret = add_client(domain, client); if (!ret) { log(1, "domain 0 is full, rejecting new client %s\n", client->name); free_client(client); return NULL; } log(2, "new client: %s\n", client->name); return client; }
void on_connect(SOCK s,void*ud,int err) { if(s != INVALID_SOCK) { struct connection * con = new_conn(s,0); add_client(con); bind2engine((ENGINE)ud,con,on_process_packet,remove_client); } }
void process_new_connection(datasocket_t s) { set_recv_timeout(s,10*1000); set_send_timeout(s,10*1000); add_client(s); ++count; printf("%d\n",count); }
void new_client(int fd) { fcntl(fd, F_SETFL, 0); if (init_sf_source(fd) < 0) close(fd); else add_client(fd); }
static void try_connect (server_auth_t * auth) { int f; CONNECTION *cli; unsigned int ip; /* attempt a connection. we do this nonblocking so that the server doesn't halt if it takes a long time to connect */ f = make_tcp_connection (auth->name, auth->port, &ip); if (f == -1) return; cli = new_connection (); if (!cli) goto error; cli->fd = f; cli->host = STRDUP (auth->alias ? auth->alias : auth->name); if (!cli->host) { OUTOFMEMORY ("try_connect"); goto error; } cli->server_login = 1; if ((cli->opt.auth = CALLOC (1, sizeof (AUTH))) == 0) { OUTOFMEMORY ("try_connect"); goto error; } cli->opt.auth->nonce = generate_nonce (); if (!cli->opt.auth->nonce) { log_message ("try_connect: could not generate nonce, closing connection"); goto error; } cli->ip = BSWAP32 (ip); cli->port = auth->port; if (add_client (cli, 1/* server connection */)) goto error; return; error: log_message ("try_connect: closing connection"); if (cli) { CLOSE (cli->fd); if (cli->host) FREE (cli->host); if (cli->opt.auth) { if (cli->opt.auth->nonce) FREE (cli->opt.auth->nonce); FREE (cli->opt.auth); } FREE (cli); } }
void accept_client(SOCK s,void*ud) { struct connection *c = new_conn(s,0); add_client(c); struct netservice *tcpserver = (struct netservice *)ud; tcpserver->bind(tcpserver,c,on_process_packet,remove_client ,5000,c_recv_timeout,5000,c_send_timeout ); }
fc::shared_ptr<ServiceClientType> get_client( const fc::sha1& id ) { auto scp = get_client( id, ServiceClientType::static_name() ); if( !scp ) { fc::shared_ptr<ServiceClientType> sc( new ServiceClientType( *this, id ) ); add_client( id, sc ); return sc; } return fc::dynamic_pointer_cast<ServiceClientType>(scp); }
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; }
pthread_t * thread_client_handle(client * this_client){ pthread_t * current_thread = malloc(sizeof(pthread_t)); if (pthread_create(current_thread, NULL, client_handle_middle, (void *) this_client)) { return NULL; } else { add_client(this_client); return current_thread; } }
void cql::cql_client_pool_impl_t::add_client(const std::string& server, unsigned int port, cql::cql_client_t::cql_event_callback_t event_callback, const std::list<std::string>& events) { std::map<std::string, std::string> credentials; add_client(server, port, event_callback, events, credentials); }
TreelogServer::~TreelogServer () { // Handle case where no log has been attached yet. if (has_unhandled_events ()) { boost::shared_ptr<Treelog> progress (new TreelogProgress ()); add_client (progress); } }
void accept_callback(SOCK s,void *ud) { ENGINE *engine = (ENGINE*)ud; struct connection *c = connection_create(s,0,SINGLE_THREAD,on_process_packet,remove_client); add_client(c); setNonblock(s); connection_start_recv(c); Bind2Engine(*engine,s,RecvFinish,SendFinish,NULL); }
/* Main loop for thread in thread pool */ static void thread_wait_loop(t_thread_pool *self) { t_session *session; t_thread_pool *prev; do { if (self->session == NULL) { pthread_mutex_lock(&thread_pool_mutex); waiting_workers++; if (pthread_cond_wait(&thread_pool_cond, &thread_pool_mutex) != 0) { waiting_workers--; session = NULL; } else { session = last_session(session_list); } pthread_mutex_unlock(&thread_pool_mutex); } else { session = self->session; self->session = NULL; } if (session != NULL) { if (add_client(session) == 0) { connection_handler(session); } else { close(session->client_socket); free(session); } } } while (self->quit == false); /* Remove thread record from pool */ pthread_mutex_lock(&thread_pool_mutex); if (thread_pool == self) { thread_pool = thread_pool->next; } else { prev = thread_pool; while (prev != NULL) { if (prev->next == self) { prev->next = self->next; break; } prev = prev->next; } } thread_pool_size--; pthread_mutex_unlock(&thread_pool_mutex); free(self); pthread_exit(NULL); }
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; }
void Manage(int what) { cout << "Would you like to:" << endl; cout << "1. Search existing objects" << endl; cout << "2. Add a new one" << endl; cout << "3. Go back" << endl; char ch; cin.clear(); cin.ignore(numeric_limits<streamsize>::max(), '\n'); ch = getchar(); switch (ch) { case'1': switch (what) { case 1: bookSearch(); break; case 2: clientSearch(); break; case 3: catSearch(); break; } break; case '2': switch (what) { case 1: add_book(); break; case 2: add_client(); break; case 3: add_cat(); break; } break; case '3': break; default: cout << "Please provide a valid response." << endl; cin.clear(); cin.ignore(numeric_limits<streamsize>::max(), '\n'); Manage(what); break; } system("pause"); }
void Network::accept_stream(void) { NetStream *s = wait_for_connect(); cerr << "Network accept_stream from ---->" << s->name() << endl; add_stream(s); add_client(s); // notify observers notify_net(Network_obs::accept_str, s); }
int Epoll::listen_new_client(int fd, __uint32_t flags) { Client *client; client = new Client(); init_event_struct((void*)client, flags); client->set_socket(fd); add_client(client); this->new_events[Epoll::NEW_CONN].push_back(client); return (0); }
void accept_callback(HANDLE s,void *ud) { HANDLE *engine = (HANDLE*)ud; struct connection *c = connection_create(s,0,SINGLE_THREAD,on_process_packet,remove_client); add_client(c); printf("cli fd:%d\n",s); setNonblock(s); //发出第一个读请求 connection_start_recv(c); Bind2Engine(*engine,s,RecvFinish,SendFinish); }
void accept_callback(SOCKET s,void *ud) { DWORD err_code = 0; HANDLE *iocp = (HANDLE*)ud; struct connection *c = connection_create(s,1,on_process_packet,remove_client); add_client(c); //++clientcount; printf("cli fd:%d\n",s); Bind2Engine(*iocp,(Socket_t)c); //发出第一个读请求 connection_recv(c); }
static gboolean accept_client(GIOChannel* source, GIOCondition condition, gpointer p) { int opt; socklen_t optlen; int newfd; dsmesock_connection_t* newconn = 0; if( condition & (G_IO_ERR | G_IO_HUP | G_IO_NVAL) ) { dsme_log(LOG_CRIT, "disabling client connect watcher"); return FALSE; } newfd = accept(g_io_channel_unix_get_fd(source), 0, 0); if(newfd == -1) return TRUE; newconn = dsmesock_init(newfd); if(newconn == 0) { close(newfd); return TRUE; } opt = 1; optlen = sizeof(opt); setsockopt(newfd, SOL_SOCKET, SO_PASSCRED, &opt, optlen); /* If that fails it is not fatal */ optlen = sizeof(newconn->ucred); if(getsockopt(newfd, SOL_SOCKET, SO_PEERCRED, &newconn->ucred, &optlen) == -1) { /* if that fails, fill some bogus values */ newconn->ucred.pid = 0; newconn->ucred.uid = -1; newconn->ucred.gid = -1; } if (!(newconn->channel = g_io_channel_unix_new(newfd)) || !g_io_add_watch(newconn->channel, G_IO_IN | G_IO_ERR | G_IO_HUP | G_IO_NVAL, handle_client, newconn)) { close_client(newconn); } else { add_client(newconn); } return TRUE; /* do not discard the listening channel */ }