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;
}
