evutil_socket_t bind_socket_ai_(struct evutil_addrinfo* ai, int reuse) { evutil_socket_t fd; int on = 1, r; int serrno; fd = socket(ai ? ai->ai_family : AF_INET, SOCK_STREAM, 0); if (fd == -1) return -1; if (evutil_make_socket_nonblocking(fd) < 0) goto out; if (evutil_make_socket_closeonexec(fd) < 0) goto out; setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, (void *)&on, sizeof(on)); if (reuse) evutil_make_listen_socket_reuseable(fd); if (ai != NULL) { r = bind(fd, ai->ai_addr, (ev_socklen_t)ai->ai_addrlen); if (r == -1) goto out; } return (fd); out: serrno = EVUTIL_SOCKET_ERROR(); evutil_closesocket(fd); EVUTIL_SET_SOCKET_ERROR(serrno); return -1; }
bool xRedisServerBase::BindPort(const char* ip, int port) { if (NULL==ip) { return false; } evutil_socket_t listener; listener = socket(AF_INET, SOCK_STREAM, 0); if (listener<=0){ return false; } evutil_make_socket_nonblocking(listener); evutil_make_listen_socket_reuseable(listener); struct sockaddr_in sin; sin.sin_family = AF_INET; sin.sin_addr.s_addr = inet_addr(ip); sin.sin_port = htons(port); if (bind(listener, (struct sockaddr *)&sin, sizeof(sin)) < 0) { return false; } if (listen(listener, 128) < 0) { return false; } struct event *listen_event; listen_event = event_new(evbase, listener, EV_READ | EV_PERSIST, AcceptCallback, (void*)this); event_add(listen_event, NULL); return true; }
/* * Start Master init event, and wait client */ int StartMaster(void *arg) { char *ip = ((SERVER_START_ARG *)arg)->ip; int port = ((SERVER_START_ARG *)arg)->port; int max_conn = ((SERVER_START_ARG *)arg)->max_conn; event_callback_fn recv_callback_fn = ((SERVER_START_ARG *)arg)->recv_callback_fn; // prepare socket int server_sockfd = PrepareSocket(); if ( InitServer(server_sockfd, ip, port, max_conn) != 0 ) { printf("Master start error.\n"); return -1; } // make non_blocking evutil_make_listen_socket_reuseable(server_sockfd); // init event struct event_base *base = event_base_new(); assert(base != NULL); struct event *listen_event; callback_arg callarg; callarg.base = base; callarg.callback_fn = recv_callback_fn; listen_event = event_new(base, server_sockfd, EV_READ|EV_PERSIST, MasterAcceptHandle, (void *)&callarg); event_add(listen_event, NULL); // start event printf("Master Start\n"); event_base_dispatch(base); return server_sockfd; }
void hub_init(struct hub *hub, struct event_base *evbase) { int lfd; struct sockaddr_in addr; if (tnt_tun_open(&hub->tun) == -1) errx(1, NULL); if (evutil_make_socket_nonblocking(hub->tun.fd) == -1) err(1, NULL); hub->ievent = event_new(evbase, hub->tun.fd, EV_READ | EV_PERSIST, interface_callback, hub); if (hub->ipaddr == NULL || tnt_tun_iface_set_ipv4(&hub->tun, hub->ipaddr) == -1) errx(1, "missing or wrong IP address"); tnt_tun_iface_set_status(&hub->tun, TNT_STATUS_ALL_UP); lfd = socket(PF_INET, SOCK_DGRAM, 0); if (lfd == -1) err(1, NULL); addr.sin_family = AF_INET; addr.sin_port = htons(hub->port); addr.sin_addr.s_addr = INADDR_ANY; if (evutil_make_socket_nonblocking(lfd) == -1) err(1, NULL); if (bind(lfd, (struct sockaddr *) &addr, sizeof(addr)) == -1) err(1, NULL); if (evutil_make_listen_socket_reuseable(lfd) == -1) err(1, NULL); hub->levent = event_new(evbase, lfd, EV_READ | EV_PERSIST, listen_callback, hub); }
inline void FileClient::DownloadFile(std::shared_ptr<FileRequest> request, int ai_family){ ++num_downloads_; struct addrinfo hints, *res, *p; // first, load up address structs with getaddrinfo(): memset(&hints, 0, sizeof hints); hints.ai_family = ai_family; // use IPv4 or IPv6, whichever hints.ai_socktype = SOCK_STREAM; int rv; if((rv = getaddrinfo(request->address()->c_str(), std::to_string(request->port()).c_str(), &hints, &res)) < 0){ LOG_ERR("Error from getaddrinfo: " + std::string(gai_strerror(rv))); } int one = 1; int fd = 0; // loop through until successful connection for(p = res;p != nullptr; p = p->ai_next) { fd = socket(p->ai_family, p->ai_socktype, p->ai_protocol); // make the socket reusable if((rv = evutil_make_listen_socket_reuseable(fd)) < 0){ LOG_ERR("Make reusable failed with code: " + std::to_string(rv)); continue; } // try to connect if ((rv = connect(fd, res->ai_addr, res->ai_addrlen)) < 0) { LOG_ERR("connect failed with code: " + std::to_string(rv)); continue; } // disable Nagle's algorithm if((rv = setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &one, sizeof one)) < 0){ LOG_ERR("Set no delay failed with code: " + std::to_string(rv)); continue; } // set the socket to non blocking mode if((rv = evutil_make_socket_nonblocking(fd)) < 0){ LOG_ERR("make non blocking failed with code: " + std::to_string(rv)); continue; } break; // successfully connected } if(p == nullptr){ LOG_ERR("File client connect failed"); exit(EXIT_FAILURE); } // free the linked list freeaddrinfo(res); LOG_DEBUG("Downloading: " + request->file()->filename() + " from: " + std::to_string(request->port()) + " to: " + *request->output_path()); auto d_ptr = new FileDownload(this, request); d_ptr->set_fd(fd); d_ptr->set_ev_read(event_new(base_, fd, EV_READ|EV_PERSIST, FileClient::on_read, d_ptr)); d_ptr->set_ev_write(event_new(base_, fd, EV_WRITE, FileClient::on_write, d_ptr)); event_add(d_ptr->ev_write(), nullptr); }
GuNET_Server_Error_t GuNET_Server_Init(GuNET_Server_t ** server, int port, GuNET_Server_Client_OnConnect_t onConnect, GuNET_Server_Client_OnDisconnect_t onDisconnect, GuNET_Server_Client_OnData_t onData, void * userdata) { GuNET_Server_t * newServer; struct sockaddr_in addr; #ifdef _WIN32 WORD wVersionRequested; WSADATA wsaData; wVersionRequested = MAKEWORD(2, 2); WSAStartup(wVersionRequested, &wsaData); #endif check(!server, GuNET_SERVER_ERROR_INVALID_ARGS); newServer = malloc(sizeof(GuNET_Server_t)); check(!newServer, GuNET_SERVER_ERROR_MEMORY_ERROR); newServer->base = event_base_new(); addr.sin_family = AF_INET; addr.sin_addr.s_addr = 0; addr.sin_port = htons(port); newServer->fd = socket(AF_INET, SOCK_STREAM, 0); evutil_make_socket_nonblocking(newServer->fd); evutil_make_listen_socket_reuseable(newServer->fd); check(bind(newServer->fd, (struct sockaddr * )&addr, sizeof(addr)) < 0, GuNET_SERVER_ERROR_SOCKET_ERROR); check(listen(newServer->fd, 16) < 0, GuNET_SERVER_ERROR_SOCKET_ERROR); newServer->listen = event_new(newServer->base, newServer->fd, EV_READ | EV_PERSIST, GuNET_Server_Client_onConnect, (void *) newServer); event_add(newServer->listen, NULL ); newServer->onConnect = onConnect; newServer->onDisconnect = onDisconnect; newServer->onData = onData; newServer->userdata = userdata; newServer->clients = NULL; newServer->signal = evsignal_new(newServer->base, SIGINT, GuNET_Server_Client_onSignal, (void *)newServer->base); if (!newServer->signal || event_add(newServer->signal, NULL ) < 0) { fprintf(stderr, "Could not create/add a signal event!\n"); return 1; } *server = newServer; return GuNET_SERVER_ERROR_NONE; }
static void * togo_mt_process(void* args) { struct event_base *base_ev; struct event *ev; evutil_socket_t server_socketfd; struct sockaddr_in server_addr; togo_memzero(&server_addr, sizeof(server_addr)); server_addr.sin_family = AF_INET; if (strcmp(togo_global_c->ip, TOGO_C_DEFAULT_IP) == 0) { server_addr.sin_addr.s_addr = INADDR_ANY; } else { server_addr.sin_addr.s_addr = inet_addr(togo_global_c->ip); } if (togo_global_c->port == 0) { server_addr.sin_port = htons(TOGO_C_DEFAULT_PORT); } else { server_addr.sin_port = htons(togo_global_c->port); } server_socketfd = socket(PF_INET, SOCK_STREAM, 0); if (server_socketfd < 0) { togo_log(ERROR, "Socket error."); togo_exit(); } evutil_make_listen_socket_reuseable(server_socketfd); evutil_make_socket_nonblocking(server_socketfd); BOOL is_set = togo_wt_set_socket_opt(server_socketfd); if (is_set == FALSE) { togo_log(ERROR, "togo_wt_set_socket_opt error."); togo_exit(); } if (bind(server_socketfd, (struct sockaddr *) &server_addr, sizeof(struct sockaddr)) < 0) { togo_log(ERROR, "bind error."); togo_exit(); } listen(server_socketfd, 32); togo_log(INFO, "Togo Server Start......."); /* event_base */ base_ev = event_base_new(); ev = event_new(base_ev, server_socketfd, EV_TIMEOUT | EV_READ | EV_PERSIST, togo_mt_doaccept, base_ev); event_add(ev, NULL); event_base_dispatch(base_ev); //loop event_base_free(base_ev); }
struct evconnlistener * evconnlistener_new_bind(struct event_base *base, evconnlistener_cb cb, void *ptr, unsigned flags, int backlog, const struct sockaddr *sa, int socklen) { struct evconnlistener *listener; evutil_socket_t fd; int on = 1; int family = sa ? sa->sa_family : AF_UNSPEC; if (backlog == 0) return NULL; fd = socket(family, SOCK_STREAM, 0); if (fd == -1) return NULL; if (evutil_make_socket_nonblocking(fd) < 0) { evutil_closesocket(fd); return NULL; } if (flags & LEV_OPT_CLOSE_ON_EXEC) { if (evutil_make_socket_closeonexec(fd) < 0) { evutil_closesocket(fd); return NULL; } } if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, (void*)&on, sizeof(on))<0) { evutil_closesocket(fd); return NULL; } if (flags & LEV_OPT_REUSEABLE) { if (evutil_make_listen_socket_reuseable(fd) < 0) { evutil_closesocket(fd); return NULL; } } if (sa) { if (bind(fd, sa, socklen)<0) { evutil_closesocket(fd); return NULL; } } listener = evconnlistener_new(base, cb, ptr, flags, backlog, fd); if (!listener) { evutil_closesocket(fd); return NULL; } return listener; }
struct evconnlistener * evconnlistener_new_bind(struct event_base *base, evconnlistener_cb cb, void *ptr, unsigned flags, int backlog, const struct sockaddr *sa, int socklen) { struct evconnlistener *listener; evutil_socket_t fd; int on = 1; int family = sa ? sa->sa_family : AF_UNSPEC; int socktype = SOCK_STREAM | EVUTIL_SOCK_NONBLOCK; if (backlog == 0) return NULL; if (flags & LEV_OPT_CLOSE_ON_EXEC) socktype |= EVUTIL_SOCK_CLOEXEC; fd = evutil_socket_(family, socktype, 0); if (fd == -1) return NULL; if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, (void*)&on, sizeof(on))<0) goto err; if (flags & LEV_OPT_REUSEABLE) { if (evutil_make_listen_socket_reuseable(fd) < 0) goto err; } if (flags & LEV_OPT_REUSEABLE_PORT) { if (evutil_make_listen_socket_reuseable_port(fd) < 0) goto err; } if (flags & LEV_OPT_DEFERRED_ACCEPT) { if (evutil_make_tcp_listen_socket_deferred(fd) < 0) goto err; } if (sa) { if (bind(fd, sa, socklen)<0) goto err; } listener = evconnlistener_new(base, cb, ptr, flags, backlog, fd); if (!listener) goto err; return listener; err: evutil_closesocket(fd); return NULL; }
int main(int argc, char *argv[]) { int ret; evutil_socket_t listener; listener = socket(AF_INET, SOCK_STREAM, 0); assert(listener > 0); evutil_make_listen_socket_reuseable(listener); struct sockaddr_in sin; sin.sin_family = AF_INET; sin.sin_addr.s_addr = 0; sin.sin_port = htons(LISTEN_PORT); if (bind(listener, (struct sockaddr *)&sin, sizeof(sin)) < 0) { perror("bind"); return 1; } if (listen(listener, LISTEN_BACKLOG) < 0) { perror("listen"); return 1; } printf ("Listening...\n"); evutil_make_socket_nonblocking(listener); struct event_base *base = event_base_new(); assert(base != NULL); struct event *listen_event; listen_event = event_new(base, listener, EV_READ|EV_PERSIST, do_accept, (void*)base); event_add(listen_event, NULL); LOG_SYSTEM_INIT(); ret = ofs_init_system(); if (ret < 0) { printf("Index system init failed.\n"); } else { event_base_dispatch(base); ofs_exit_system(); } LOG_SYSTEM_EXIT(); _CrtDumpMemoryLeaks(); printf("The End."); return 0; }
// only in child void child(Dict* config, struct ChildContext* context) { context->dataFromParent = event_new(context->eventBase, context->inFd, EV_READ | EV_PERSIST, incomingFromParent, context); event_add(context->dataFromParent, NULL); struct sockaddr_storage addr; int addrLen = sizeof(struct sockaddr_storage); char* bindTo = "127.0.0.1:9999"; String* bindStr = Dict_getString(config, BSTR("bind")); if (bindStr) { fprintf(stderr, "Admin: Binding to %s\n", bindStr->bytes); if (evutil_parse_sockaddr_port(bindStr->bytes, (struct sockaddr*) &addr, &addrLen)) { fprintf(stderr, "Admin: admin.bind parse failed, calling back on %s\n", bindTo); bindStr = NULL; } } if (!bindStr) { fprintf(stderr, "Admin: Binding to %s\n", bindTo); evutil_parse_sockaddr_port(bindTo, (struct sockaddr*) &addr, &addrLen); } evutil_socket_t listener = socket(addr.ss_family, SOCK_STREAM, 0); evutil_make_socket_nonblocking(listener); evutil_make_listen_socket_reuseable(listener); if (bind(listener, (struct sockaddr*)&addr, sizeof(addr)) < 0) { perror("bind"); return; } if (listen(listener, 16)<0) { perror("listen"); return; } context->socketEvent = event_new(context->eventBase, listener, EV_READ | EV_PERSIST, acceptConn, context); event_add(context->socketEvent, NULL); if (!context->eventBase) { exit(-1); } event_base_dispatch(context->eventBase); }
void SocketServerLibEvent::addListener(std::string addr, int port, SocketEvents* sev) { sockin.sin_family = AF_INET; //sockin.sin_addr.s_addr = inet_addr(addr.c_str()); inet_pton(AF_INET, addr.c_str(), &(sockin.sin_addr)); sockin.sin_port = htons(port); listeners.push_back(std::unique_ptr<SocketListenerLibEvent>( new SocketListenerLibEvent() )); SocketListenerLibEvent* listener = listeners.back().get(); listener->addr = addr; listener->port = port; listener->sev = sev; listener->ssle = this; listener->listener = socket(AF_INET, SOCK_STREAM, 0); if (listener->listener < 0) { perror("socket"); throw std::runtime_error("socket del listener"); } if (evutil_make_socket_nonblocking(listener->listener) != 0) { throw std::runtime_error("evutil_make_socket_nonblocking del listener"); } if (evutil_make_listen_socket_reuseable(listener->listener) != 0) { throw std::runtime_error("evutil_make_listen_socket_reuseable del listener"); } if (bind(listener->listener, (struct sockaddr*) &sockin, sizeof(struct sockaddr_in)) < 0) { throw std::runtime_error("bind del listener"); } if (listen(listener->listener, 250) < 0) { throw std::runtime_error("listen del listener"); } listener_event = event_new( base, listener->listener, EV_READ | EV_PERSIST, ssle_do_accept, (void*) listener); event_add(listener_event, NULL); }
int main(int argc, char*argv[]) { int ret; ret = init_hash_table();//初始化hash表; if(ret) { printf("init_hash_table error!\n"); } evutil_socket_t listener;//定义套接字描述符变量; listener = socket(AF_INET, SOCK_STREAM, 0);//建立套接字; assert(listener > 0); evutil_make_listen_socket_reuseable(listener);// //定义地址族结构; struct sockaddr_in sin; sin.sin_family = AF_INET; sin.sin_addr.s_addr = INADDR_ANY; sin.sin_port = htons(LISTEN_PORT);//设定端口号; if(bind(listener,(struct sockaddr*)&sin, sizeof(sin))<0)//绑定; { perror("bind"); return 1; } if(listen(listener, LISTEN_BACKLOG) < 0)//监听; { perror("listen error\n"); return 1; } printf("Listening...\n"); evutil_make_socket_nonblocking(listener);//设置套接字为不阻塞; struct event_base *base = event_base_new();//创建event_base对象; assert(base != NULL); //创建并绑定event; struct event *listen_event; listen_event = event_new(base, listener, EV_READ|EV_PERSIST, do_accept, (void*)base); event_add(listen_event, NULL);//添加对象,NULL表示无超时设置; event_base_dispatch(base);//启用循环; printf("The End."); return 0; }
int Listener::open(const struct sockaddr *sa, int socklen, int backlog){ int family = sa ? sa->sa_family : AF_UNSPEC; if (backlog == 0) return -1; evutil_socket_t fd = socket(family, SOCK_STREAM, 0); if (fd == -1) return -1; if (evutil_make_socket_nonblocking(fd) < 0) { evutil_closesocket(fd); return -1; } if (flags & LEV_OPT_CLOSE_ON_EXEC) { if (evutil_make_socket_closeonexec(fd) < 0) { evutil_closesocket(fd); return -1; } } if (setKeepAlive(fd)) { evutil_closesocket(fd); return -1; } if (flags & LEV_OPT_REUSEABLE) { if (evutil_make_listen_socket_reuseable(fd) < 0) { evutil_closesocket(fd); return -1; } } if (sa) { if (bind(fd, sa, socklen)<0) { evutil_closesocket(fd); return -1; } } int ret = this->open(fd, backlog); if (ret <0){ evutil_closesocket(fd); return ret; } return 0; }
int TCPServerInit(){ evutil_socket_t listener; listener = socket(AF_INET, SOCK_STREAM, 0); assert(listener > 0); evutil_make_listen_socket_reuseable(listener); struct sockaddr_in sin; sin.sin_family = AF_INET; sin.sin_addr.s_addr = 0; sin.sin_port = htons(LISTEN_PORT); if (bind(listener, (struct sockaddr *)&sin, sizeof(sin)) < 0) { perror("bind"); return 1; } if (listen(listener, LISTEN_BACKLOG) < 0) { perror("listen"); return 1; } printf("Listening..."); evutil_make_socket_nonblocking(listener); struct event_base *base = event_base_new(); assert(base != NULL); struct event *listen_event; listen_event = event_new(base, listener, EV_READ|EV_PERSIST, do_accept, (void*)base); event_add(listen_event, NULL); pid_t pid; pid = fork(); if (pid == 0){ CLog::GetInstance()->start(); event_base_dispatch(base); Log("The End."); return 0; }else{ return 0; } }
int game_add_listen_event(uint16_t port, LISTEN_CALLBACKS *callback) { struct event *event_accept = &callback->event_accept; int fd = 0; struct sockaddr_in addr; if (!callback || !callback->cb_get_client_map) return (-1); fd = create_new_socket(1); if (fd < 0) { log4c_category_log(mycat, LOG4C_PRIORITY_ERROR, "%s: create new socket failed[%d]", __FUNCTION__, errno); return (-2); } evutil_make_listen_socket_reuseable(fd); memset(&addr, 0, sizeof(addr)); addr.sin_family = AF_INET; addr.sin_addr.s_addr = htonl(0); addr.sin_port = htons(port); if (bind(fd, (struct sockaddr *)&addr, sizeof(addr)) != 0) { log4c_category_log(mycat, LOG4C_PRIORITY_ERROR, "%s: bind failed[%d]", __FUNCTION__, errno); return (-10); } if (listen(fd, 128) != 0) { log4c_category_log(mycat, LOG4C_PRIORITY_ERROR, "%s: listen failed[%d]", __FUNCTION__, errno); return (-20); } if (0 != event_assign(event_accept, base, fd, EV_READ|EV_PERSIST, cb_listen, (void *)callback)) { log4c_category_log(mycat, LOG4C_PRIORITY_ERROR, "%s: event_new failed[%d]", __FUNCTION__, errno); goto fail; } event_add(event_accept, NULL); return (0); fail: if (fd > 0) { evutil_closesocket(fd); } if (event_accept) { event_del(event_accept); } return (-1); }
int main(int argc, char *argv[]) { int ret; evutil_socket_t listener; listener = socket(AF_INET, SOCK_STREAM, 0); assert(listener > 0); evutil_make_listen_socket_reuseable(listener); struct sockaddr_in sin; memset(&sin, 0, sizeof(sockaddr_in)); sin.sin_family = AF_INET; // sin.sin_addr.s_addr = 0; sin.sin_addr.s_addr = htonl(INADDR_ANY); sin.sin_port = htons(LISTEN_PORT); if (bind(listener, (struct sockaddr *)&sin, sizeof(sin)) < 0) { perror("bind error!\n"); return 1; } if (listen(listener, LISTEN_BACKLOG) < 0) { perror("listen error!\n"); return 1; } printf ("Listening...\n"); evutil_make_socket_nonblocking(listener); struct event_base *base = event_base_new(); assert(base != NULL); struct event *listen_event; listen_event = event_new(base, listener, EV_READ|EV_PERSIST, do_accept, (void*)base); event_add(listen_event, NULL); event_base_dispatch(base); printf("The End."); return 0; }
evutil_socket_t get_multi_sock() { evutil_socket_t sock; sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP); if(sock == -1 || evutil_make_listen_socket_reuseable(sock) || evutil_make_socket_nonblocking(sock)) { fprintf(stderr, "blad podczas tworzenia socketa multicast\n"); exit(-1); } multicast_addr.sin_family = AF_INET; multicast_addr.sin_addr.s_addr = inet_addr(MULTICAST_IP);//htonl(INADDR_ANY); multicast_addr.sin_port = htons(MULTICAST_PORT); if ((bind(sock, (struct sockaddr *) &multicast_addr, sizeof(multicast_addr))) < 0) { fprintf(stderr, "blad podczas wiazania socketa multicast\n"); exit(-1); } struct ip_mreq ipmreq; ipmreq.imr_multiaddr.s_addr = inet_addr(MULTICAST_IP); ipmreq.imr_interface.s_addr = INADDR_ANY; if ((setsockopt(sock , IPPROTO_IP, IP_ADD_MEMBERSHIP, (void*) &ipmreq, sizeof(ipmreq))) < 0) { fprintf(stderr, "blad podczas ustawiania grupy socketa multicast\n"); exit(-1); } int loop = 0; if (setsockopt(sock, IPPROTO_IP, IP_MULTICAST_LOOP, &loop, sizeof(loop)) < 0) { fprintf(stderr, "blad podczas wylaczania petli socketa multicast\n"); exit(-1); } return sock; }
int tcp_server_init(int port, int listen_num) { evutil_socket_t listener; listener = ::socket(AF_INET, SOCK_STREAM, 0); if(listener == -1) { return -1; } evutil_make_listen_socket_reuseable(listener); sockaddr_in sin; sin.sin_family = AF_INET; sin.sin_addr.s_addr = 0; sin.sin_port = htons(port); if(::bind(listener, (sockaddr*)&sin, sizeof(sin)) < 0 ) { printf("bind error"); //errno_save = errno; evutil_closesocket(listener); //errno = errno_save; return -1; } if(::listen(listener, listen_num) < 0) { printf("listen error"); evutil_closesocket(listener); return -1; } evutil_make_socket_nonblocking(listener); return listener; }
evutil_socket_t get_delay_sock() { evutil_socket_t sock; struct sockaddr_in server_address; sock = socket(AF_INET, SOCK_DGRAM, 0); if (sock < 0){ fprintf(stderr, "blad podcas tworzenia socketa opoznien\n"); exit(-1); } server_address.sin_family = AF_INET; server_address.sin_addr.s_addr = htonl(INADDR_ANY); server_address.sin_port = htons(delay_port); if (bind(sock, (struct sockaddr *) &server_address, (socklen_t) sizeof(server_address)) || evutil_make_listen_socket_reuseable(sock) || evutil_make_socket_nonblocking(sock)) { fprintf(stderr, "blad podcas wiazania socketa opoznien\n"); exit(-1); } return sock; }
int tcp_server_init(int port, int listen_num) { int errno_save; evutil_socket_t listener; listener = ::socket(AF_INET, SOCK_STREAM, 0); if( listener == -1 ) return -1; //允许多次绑定同一个地址。要用在socket和bind之间 evutil_make_listen_socket_reuseable(listener); struct sockaddr_in sin; sin.sin_family = AF_INET; sin.sin_addr.s_addr = 0; sin.sin_port = htons(port); if( ::bind(listener, (SA*)&sin, sizeof(sin)) < 0 ) goto error; if( ::listen(listener, listen_num) < 0) goto error; //跨平台统一接口,将套接字设置为非阻塞状态 evutil_make_socket_nonblocking(listener); return listener; error: errno_save = errno; evutil_closesocket(listener); errno = errno_save; return -1; }
bool cServerHandleImpl::Listen(UInt16 a_Port) { // Make sure the cNetwork internals are innitialized: cNetworkSingleton::Get(); // Set up the main socket: // It should listen on IPv6 with IPv4 fallback, when available; IPv4 when IPv6 is not available. bool NeedsTwoSockets = false; int err; evutil_socket_t MainSock = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP); if (!IsValidSocket(MainSock)) { // Failed to create IPv6 socket, create an IPv4 one instead: err = EVUTIL_SOCKET_ERROR(); LOGD("Failed to create IPv6 MainSock: %d (%s)", err, evutil_socket_error_to_string(err)); MainSock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); if (!IsValidSocket(MainSock)) { m_ErrorCode = EVUTIL_SOCKET_ERROR(); Printf(m_ErrorMsg, "Cannot create socket for port %d: %s", a_Port, evutil_socket_error_to_string(m_ErrorCode)); return false; } // Allow the port to be reused right after the socket closes: if (evutil_make_listen_socket_reuseable(MainSock) != 0) { m_ErrorCode = EVUTIL_SOCKET_ERROR(); Printf(m_ErrorMsg, "Port %d cannot be made reusable: %d (%s). Restarting the server might not work.", a_Port, m_ErrorCode, evutil_socket_error_to_string(m_ErrorCode) ); LOG("%s", m_ErrorMsg.c_str()); } // Bind to all interfaces: sockaddr_in name; memset(&name, 0, sizeof(name)); name.sin_family = AF_INET; name.sin_port = ntohs(a_Port); if (bind(MainSock, reinterpret_cast<const sockaddr *>(&name), sizeof(name)) != 0) { m_ErrorCode = EVUTIL_SOCKET_ERROR(); Printf(m_ErrorMsg, "Cannot bind IPv4 socket to port %d: %s", a_Port, evutil_socket_error_to_string(m_ErrorCode)); evutil_closesocket(MainSock); return false; } } else { // IPv6 socket created, switch it into "dualstack" mode: UInt32 Zero = 0; #ifdef _WIN32 // WinXP doesn't support this feature, so if the setting fails, create another socket later on: int res = setsockopt(MainSock, IPPROTO_IPV6, IPV6_V6ONLY, reinterpret_cast<const char *>(&Zero), sizeof(Zero)); err = EVUTIL_SOCKET_ERROR(); NeedsTwoSockets = ((res == SOCKET_ERROR) && (err == WSAENOPROTOOPT)); #else setsockopt(MainSock, IPPROTO_IPV6, IPV6_V6ONLY, reinterpret_cast<const char *>(&Zero), sizeof(Zero)); #endif // Allow the port to be reused right after the socket closes: if (evutil_make_listen_socket_reuseable(MainSock) != 0) { m_ErrorCode = EVUTIL_SOCKET_ERROR(); Printf(m_ErrorMsg, "Port %d cannot be made reusable: %d (%s). Restarting the server might not work.", a_Port, m_ErrorCode, evutil_socket_error_to_string(m_ErrorCode) ); LOG("%s", m_ErrorMsg.c_str()); } // Bind to all interfaces: sockaddr_in6 name; memset(&name, 0, sizeof(name)); name.sin6_family = AF_INET6; name.sin6_port = ntohs(a_Port); if (bind(MainSock, reinterpret_cast<const sockaddr *>(&name), sizeof(name)) != 0) { m_ErrorCode = EVUTIL_SOCKET_ERROR(); Printf(m_ErrorMsg, "Cannot bind IPv6 socket to port %d: %d (%s)", a_Port, m_ErrorCode, evutil_socket_error_to_string(m_ErrorCode)); evutil_closesocket(MainSock); return false; } } if (evutil_make_socket_nonblocking(MainSock) != 0) { m_ErrorCode = EVUTIL_SOCKET_ERROR(); Printf(m_ErrorMsg, "Cannot make socket on port %d non-blocking: %d (%s)", a_Port, m_ErrorCode, evutil_socket_error_to_string(m_ErrorCode)); evutil_closesocket(MainSock); return false; } if (listen(MainSock, 0) != 0) { m_ErrorCode = EVUTIL_SOCKET_ERROR(); Printf(m_ErrorMsg, "Cannot listen on port %d: %d (%s)", a_Port, m_ErrorCode, evutil_socket_error_to_string(m_ErrorCode)); evutil_closesocket(MainSock); return false; } m_ConnListener = evconnlistener_new(cNetworkSingleton::Get().GetEventBase(), Callback, this, LEV_OPT_CLOSE_ON_FREE | LEV_OPT_REUSEABLE, 0, MainSock); m_IsListening = true; if (!NeedsTwoSockets) { return true; } // If a secondary socket is required (WinXP dual-stack), create it here: LOGD("Creating a second socket for IPv4"); evutil_socket_t SecondSock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); if (!IsValidSocket(SecondSock)) { err = EVUTIL_SOCKET_ERROR(); LOGD("socket(AF_INET, ...) failed for secondary socket: %d, %s", err, evutil_socket_error_to_string(err)); return true; // Report as success, the primary socket is working } // Allow the port to be reused right after the socket closes: if (evutil_make_listen_socket_reuseable(SecondSock) != 0) { m_ErrorCode = EVUTIL_SOCKET_ERROR(); Printf(m_ErrorMsg, "Port %d cannot be made reusable (second socket): %d (%s). Restarting the server might not work.", a_Port, m_ErrorCode, evutil_socket_error_to_string(m_ErrorCode) ); LOG("%s", m_ErrorMsg.c_str()); } // Make the secondary socket nonblocking: if (evutil_make_socket_nonblocking(SecondSock) != 0) { err = EVUTIL_SOCKET_ERROR(); LOGD("evutil_make_socket_nonblocking() failed for secondary socket: %d, %s", err, evutil_socket_error_to_string(err)); evutil_closesocket(SecondSock); return true; // Report as success, the primary socket is working } // Bind to all IPv4 interfaces: sockaddr_in name; memset(&name, 0, sizeof(name)); name.sin_family = AF_INET; name.sin_port = ntohs(a_Port); if (bind(SecondSock, reinterpret_cast<const sockaddr *>(&name), sizeof(name)) != 0) { err = EVUTIL_SOCKET_ERROR(); LOGD("Cannot bind secondary socket to port %d: %d (%s)", a_Port, err, evutil_socket_error_to_string(err)); evutil_closesocket(SecondSock); return true; // Report as success, the primary socket is working } if (listen(SecondSock, 0) != 0) { err = EVUTIL_SOCKET_ERROR(); LOGD("Cannot listen on secondary socket on port %d: %d (%s)", a_Port, err, evutil_socket_error_to_string(err)); evutil_closesocket(SecondSock); return true; // Report as success, the primary socket is working } m_SecondaryConnListener = evconnlistener_new(cNetworkSingleton::Get().GetEventBase(), Callback, this, LEV_OPT_CLOSE_ON_FREE | LEV_OPT_REUSEABLE, 0, SecondSock); return true; }
// only in child static void child(struct sockaddr_storage* addr, int addrLen, char* user, struct ChildContext* context) { context->dataFromParent = event_new(context->eventBase, context->inFd, EV_READ | EV_PERSIST, incomingFromParent, context); event_add(context->dataFromParent, NULL); if (!addr->ss_family) { addr->ss_family = AF_INET; // Apple gets mad if the length is wrong. addrLen = sizeof(struct sockaddr_in); } evutil_socket_t listener = socket(addr->ss_family, SOCK_STREAM, 0); if (listener < 0) { perror("socket()"); } evutil_make_listen_socket_reuseable(listener); if (bind(listener, (struct sockaddr*) addr, addrLen) < 0) { perror("bind()"); return; } if (getsockname(listener, (struct sockaddr*) addr, (socklen_t*) &addrLen)) { perror("getsockname()"); } if (listen(listener, 16)<0) { perror("listen"); return; } evutil_make_socket_nonblocking(listener); context->socketEvent = event_new(context->eventBase, listener, EV_READ | EV_PERSIST, acceptConn, context); event_add(context->socketEvent, NULL); if (!context->eventBase) { exit(-1); } // Write back the sockaddr_storage struct so the other end knows our port. uint8_t buff[sizeof(struct sockaddr_storage) + sizeof(int) + 8]; Bits_memcpyConst(buff, "abcd", 4); Bits_memcpyConst(&buff[4], &addrLen, sizeof(int)); Bits_memcpyConst(&buff[4 + sizeof(int)], addr, sizeof(struct sockaddr_storage)); Bits_memcpyConst(&buff[4 + sizeof(int) + sizeof(struct sockaddr_storage)], "wxyz", 4); write(context->outFd, buff, sizeof(buff)); event_base_dispatch(context->eventBase); }
int http_server_start(unsigned short port, http_handler_t http_handlers[], int num_handlers, const char *static_root) { int rt; int num_cpus = get_num_cpus(); http_server_data_t server_data = {0}, *data_tmp = NULL; evutil_socket_t sock = socket(AF_INET, SOCK_STREAM, 0); if (sock < 0) { perror("could not create socket"); return 1; } rt = evutil_make_listen_socket_reuseable(sock); if (rt < 0) { perror("cannot make socket reuseable"); return 1; } struct sockaddr_in addr; memset(&addr, 0, sizeof(addr)); addr.sin_family = AF_INET; addr.sin_addr.s_addr = INADDR_ANY; addr.sin_port = htons(port); rt = bind(sock, (struct sockaddr*)&addr, sizeof(addr)); if (rt < 0) { perror("cannot bind socket"); return -1; } rt = listen(sock, 1024); if (rt < 0) { perror("cannot listen"); return -1; } rt = evutil_make_socket_nonblocking(sock); if (rt < 0) { perror("cannot make socket non blocking"); return -1; } server_data.handlers = http_handlers; server_data.num_handlers = num_handlers; server_data.sock = sock; server_data.static_root = static_root; int i; num_servers = num_cpus; server_base = apr_pcalloc(global_pool, (num_servers + 1) * sizeof(struct event_base *)); for(i= 0; i < num_servers; i++) { data_tmp = calloc(1, sizeof(http_server_data_t)); *data_tmp = server_data; data_tmp->server_index = i; apr_thread_pool_push(thread_pool, http_server, data_tmp, APR_THREAD_TASK_PRIORITY_HIGHEST, NULL); } return 0; }
int main (int argc, char **argv) { evutil_socket_t delay_sock, multicast_sock; struct event *udp_client_event, *multicast_listener_event, *signal_event, *discover_event, *telnet, *telnet_ref; opterr = 0; int opt; while ((opt = getopt (argc, argv, "u:U:t:T:v:s")) != -1) { switch (opt) { case 'u': delay_port = atoi(optarg); if(!delay_port) { fprintf(stderr, "bledny port opoznien\n"); return 1; } break; case 'U': ui_port = atoi(optarg); if(!ui_port) { fprintf(stderr, "bledny port telnetu\n"); return 1; } break; case 't': delay_ref = atof(optarg); if(delay_ref == 0.0) { fprintf(stderr, "bledny czas pomiedzy mierzeniem opoznien\n"); return 1; } break; case 'T': discovery_ref = atof(optarg); if(discovery_ref == 0.0) { fprintf(stderr, "bledny czas pomiedzy odkrywaniem komputerow\n"); return 1; } break; case 'v': ui_ref = atof(optarg); if(ui_ref == 0.0) { fprintf(stderr, "bledny czas pomiedzy odkrywaniem odswierzaniem ui\n" ); return 1; } case 's': ssh_tcp = 1; break; default: fprintf(stderr, "bledna opcja\n"); return 1; } } init_data(); init_ip(); init_mdns(ssh_tcp); main_loop = event_base_new(); delay_sock = get_delay_sock(); multicast_sock = get_multi_sock(); udp_client_event = event_new(main_loop, delay_sock, EV_READ|EV_PERSIST, udp_delays_ans_cb, NULL); if(!udp_client_event) { fprintf(stderr, "nie udalo sie utworzyc eventu serwera udp\n"); exit(-1); } if(event_add(udp_client_event, NULL) == -1) { fprintf(stderr, "nie udalo sie przylaczyc eventu serwera udp\n"); exit(-1); } multicast_listener_event = event_new(main_loop, multicast_sock, EV_READ|EV_PERSIST, multicast_rcv_cb, NULL); if(!multicast_listener_event) { fprintf(stderr, "nie udalo sie utworzyc eventu serwera multicast\n"); exit(-1); } if(event_add(multicast_listener_event, NULL) == -1) { fprintf(stderr, "nie udalo sie przylaczyc eventu serwera multicast\n"); exit(-1); } discover_event = event_new(main_loop, multicast_sock, EV_TIMEOUT|EV_PERSIST, multicast_discover_cb, NULL); if(!discover_event || event_add(discover_event, &disc_tv) < 0) { fprintf(stderr, "odkrywnie nie uruchomilo sie\n"); exit(-1); } signal_event = evsignal_new(main_loop, SIGINT, sigint_cb, (void *)main_loop); if (!signal_event || event_add(signal_event, NULL)<0) { fprintf(stderr, "Could not create/add a signal event!\n"); return 1; } evutil_socket_t uisock = socket(PF_INET, SOCK_STREAM, 0); struct sockaddr_in uiadrr; uiadrr.sin_family = AF_INET; uiadrr.sin_addr.s_addr = htonl(INADDR_ANY); uiadrr.sin_port = htons(ui_port); if(uisock == -1 || evutil_make_listen_socket_reuseable(uisock) || evutil_make_socket_nonblocking(uisock)) { return 1; } bind(uisock, (struct sockaddr*)&uiadrr, (socklen_t)sizeof(uiadrr)); listen(uisock, 5); telnet = event_new(main_loop, uisock, EV_READ|EV_PERSIST, telnet_cb, NULL); event_add(telnet, NULL); telnet_ref = event_new(main_loop, uisock, EV_TIMEOUT|EV_PERSIST, telnet_refresh_cb, NULL); event_add(telnet_ref, &ui_tv); if(event_base_dispatch(main_loop) == -1) { fprintf(stderr, "nie udalo sie uruchomic glownej petli\n"); exit(-1); } event_free(signal_event); event_free(multicast_listener_event); event_free(udp_client_event); event_base_free(main_loop); close(delay_sock); close(multicast_sock); return 0; }