void
accept_connection(int fd)
{
struct sockaddr_in from;
st_netfd_t st_fd,fd2;
int fromlen = sizeof(from);
if((st_fd = st_netfd_open_socket(fd)) == NULL)
{perror("st_netfd_open_socket") ; exit(1);}
while(1) {
fd2 = st_accept(st_fd,(struct sockaddr *)&from, &fromlen, -1);
if(fd2 == NULL) {
if(errno == EINTR) {
continue;
} else {
perror("accept");
st_sleep(0);
continue;
}
}
if(st_thread_create(handle_connection, (void *)fd2,0,0) == NULL){
perror("st_thread_create");
exit(1);
}
}
}
int main(int argc, char *argv[]) {
g_assert(st_set_eventsys(ST_EVENTSYS_ALT) == 0);
st_init();
int status = ares_library_init(ARES_LIB_INIT_ALL);
if (status != ARES_SUCCESS)
{
fprintf(stderr, "ares_library_init: %s\n", ares_strerror(status));
return 1;
}
int sock;
int n;
struct sockaddr_in serv_addr;
if ((sock = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
perror("socket");
}
n = 1;
if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char *)&n, sizeof(n)) < 0) {
perror("setsockopt SO_REUSEADDR");
}
memset(&serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(8080);
serv_addr.sin_addr.s_addr = inet_addr("0.0.0.0");
if (bind(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
perror("bind");
}
if (listen(sock, 10) < 0) {
perror("listen");
}
st_netfd_t server_nfd = st_netfd_open_socket(sock);
st_netfd_t client_nfd;
struct sockaddr_in from;
int fromlen = sizeof(from);
for (;;) {
client_nfd = st_accept(server_nfd,
(struct sockaddr *)&from, &fromlen, ST_UTIME_NO_TIMEOUT);
printf("accepted\n");
if (st_thread_create(handle_connection,
(void *)client_nfd, 0, 1024 * 1024) == NULL)
{
fprintf(stderr, "st_thread_create error\n");
}
}
ares_library_cleanup();
return EXIT_SUCCESS;
}
/**
* 接收 rpc 连接
* 进程的主线程在这里回环
*/
void accept_client(void) {
st_netfd_t client;
struct sockaddr from;
int fromlen = sizeof(from);
while ((client = st_accept(rpc_fd, &from, &fromlen, ST_UTIME_NO_TIMEOUT)) != NULL) {
st_netfd_setspecific(client, get_in_addr(&from), NULL);
if (st_thread_create(handle_clientconn, &client, 0, 0) == NULL)
fprintf(stderr, "[%d] failed to create the client thread: %s\n", my_index, strerror(errno));
}
st_netfd_close(rpc_fd);
}
void create_listener_and_accept(void) {
st_set_eventsys(ST_EVENTSYS_ALT);
st_init();
int listener_fd;
struct addrinfo hints, *ai, *p;
memset(&hints, 0, sizeof(hints));
hints.ai_family = PF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
hints.ai_flags = AI_PASSIVE;
getaddrinfo("0.0.0.0", "9595", &hints, &ai);
for (p = ai; p != NULL; p = p->ai_next) {
listener_fd = socket(p->ai_family, p->ai_socktype, p->ai_protocol);
if (listener_fd < 0) continue;
if (bind(listener_fd, p->ai_addr, p->ai_addrlen) < 0) {
close(listener_fd);
continue;
}
break;
}
if (p == NULL) return;
listen(listener_fd, 10);
context = (struct peer_context*)calloc(5, sizeof(struct peer_context));
context[0].rpc_fd = st_netfd_open_socket(listener_fd);
st_netfd_t client;
struct sockaddr from;
int len = sizeof(from);
while ((client = st_accept(context[0].rpc_fd, &from, &len, ST_UTIME_NO_TIMEOUT)) != NULL) {
st_thread_create(handle_conn, client, 0, 0);
}
}
int SrsListener::cycle()
{
int ret = ERROR_SUCCESS;
st_netfd_t client_stfd = st_accept(stfd, NULL, NULL, ST_UTIME_NO_TIMEOUT);
if(client_stfd == NULL){
// ignore error.
srs_warn("ignore accept thread stoppped for accept client error");
return ret;
}
srs_verbose("get a client. fd=%d", st_netfd_fileno(client_stfd));
if ((ret = server->accept_client(type, client_stfd)) != ERROR_SUCCESS) {
srs_warn("accept client error. ret=%d", ret);
return ret;
}
return ret;
}
static void *handle_connections(void *arg)
{
st_netfd_t srv_nfd, cli_nfd;
struct sockaddr_in from;
int fromlen;
long i = (long) arg;
srv_nfd = srv_socket[i].nfd;
fromlen = sizeof(from);
while (WAIT_THREADS(i) <= max_wait_threads) {
cli_nfd = st_accept(srv_nfd, (struct sockaddr *)&from, &fromlen,
ST_UTIME_NO_TIMEOUT);
if (cli_nfd == NULL) {
err_sys_report(errfd, "ERROR: can't accept connection: st_accept");
continue;
}
/* Save peer address, so we can retrieve it later */
st_netfd_setspecific(cli_nfd, &from.sin_addr, NULL);
WAIT_THREADS(i)--;
BUSY_THREADS(i)++;
if (WAIT_THREADS(i) < min_wait_threads && TOTAL_THREADS(i) < max_threads) {
/* Create another spare thread */
if (st_thread_create(handle_connections, (void *)i, 0, 0) != NULL)
WAIT_THREADS(i)++;
else
err_sys_report(errfd, "ERROR: process %d (pid %d): can't create"
" thread", my_index, my_pid);
}
handle_session(i, cli_nfd);
st_netfd_close(cli_nfd);
WAIT_THREADS(i)++;
BUSY_THREADS(i)--;
}
WAIT_THREADS(i)--;
return NULL;
}
void _peer_accept(void) {
st_netfd_t client;
struct sockaddr from;
int fromlen = sizeof(from);
struct peer_info *peer_info;
peer_info = &peer_list[self_index];
// 每个 Peer 的主回环
while ((client = st_accept(peer_info->rpc_fd, &from, &fromlen, ST_UTIME_NO_TIMEOUT)) != NULL) {
LOG("[%d] 收到一个 RPC 互联请求\n", self_index);
st_netfd_setspecific(client, get_in_addr(&from), NULL);
if (st_thread_create(_handle_peer_interconnect, client, 0, 0) == NULL)
ERR("[%d] failed to create the client thread: %s\n", self_index, strerror(errno));
}
LOG("[%d] 完成了当前 Peer 的主循环: %s\n", self_index, strerror(errno));
st_netfd_close(peer_info->rpc_fd);
}
/*
* This program acts as a generic gateway. It listens for connections
* to a local address ('-l' option). Upon accepting a client connection,
* it connects to the specified remote address ('-r' option) and then
* just pumps the data through without any modification.
*/
int main(int argc, char *argv[])
{
extern char *optarg;
int opt, sock, n;
int laddr, raddr, num_procs;
int serialize_accept = 0;
struct sockaddr_in lcl_addr, cli_addr;
st_netfd_t cli_nfd, srv_nfd;
prog = argv[0];
num_procs = laddr = raddr = 0;
/* Parse arguments */
while((opt = getopt(argc, argv, "l:r:p:Sh")) != EOF) {
switch (opt) {
case 'l':
read_address(optarg, &lcl_addr);
laddr = 1;
break;
case 'r':
read_address(optarg, &rmt_addr);
if (rmt_addr.sin_addr.s_addr == INADDR_ANY) {
fprintf(stderr, "%s: invalid remote address: %s\n", prog, optarg);
exit(1);
}
raddr = 1;
break;
case 'p':
num_procs = atoi(optarg);
if (num_procs < 1) {
fprintf(stderr, "%s: invalid number of processes: %s\n", prog, optarg);
exit(1);
}
break;
case 'S':
/*
* Serialization decision is tricky on some platforms. For example,
* Solaris 2.6 and above has kernel sockets implementation, so supposedly
* there is no need for serialization. The ST library may be compiled
* on one OS version, but used on another, so the need for serialization
* should be determined at run time by the application. Since it's just
* an example, the serialization decision is left up to user.
* Only on platforms where the serialization is never needed on any OS
* version st_netfd_serialize_accept() is a no-op.
*/
serialize_accept = 1;
break;
case 'h':
case '?':
fprintf(stderr, "Usage: %s -l <[host]:port> -r <host:port> "
"[-p <num_processes>] [-S]\n", prog);
exit(1);
}
}
if (!laddr) {
fprintf(stderr, "%s: local address required\n", prog);
exit(1);
}
if (!raddr) {
fprintf(stderr, "%s: remote address required\n", prog);
exit(1);
}
if (num_procs == 0)
num_procs = cpu_count();
fprintf(stderr, "%s: starting proxy daemon on %s:%d\n", prog,
inet_ntoa(lcl_addr.sin_addr), ntohs(lcl_addr.sin_port));
/* Start the daemon */
start_daemon();
/* Initialize the ST library */
if (st_init() < 0) {
print_sys_error("st_init");
exit(1);
}
/* Create and bind listening socket */
if ((sock = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
print_sys_error("socket");
exit(1);
}
n = 1;
if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char *)&n, sizeof(n)) < 0) {
print_sys_error("setsockopt");
exit(1);
}
if (bind(sock, (struct sockaddr *)&lcl_addr, sizeof(lcl_addr)) < 0) {
print_sys_error("bind");
exit(1);
}
listen(sock, 128);
if ((srv_nfd = st_netfd_open_socket(sock)) == NULL) {
print_sys_error("st_netfd_open");
exit(1);
}
/* See the comment regarding serialization decision above */
if (num_procs > 1 && serialize_accept && st_netfd_serialize_accept(srv_nfd)
< 0) {
print_sys_error("st_netfd_serialize_accept");
exit(1);
}
/* Start server processes */
set_concurrency(num_procs);
for ( ; ; ) {
n = sizeof(cli_addr);
cli_nfd = st_accept(srv_nfd, (struct sockaddr *)&cli_addr, &n, -1);
if (cli_nfd == NULL) {
print_sys_error("st_accept");
exit(1);
}
if (st_thread_create(handle_request, cli_nfd, 0, 0) == NULL) {
print_sys_error("st_thread_create");
exit(1);
}
}
/* NOTREACHED */
return 1;
}
