int main(int argc, char *argv[])
{
#if defined(__NR_accept4) || defined(__NR_socketcall)
struct sockaddr_in conn_addr;
int lfd;
int port_num;
setup();
port_num = (argc > 1) ? atoi(argv[1]) : PORT_NUM;
memset(&conn_addr, 0, sizeof(struct sockaddr_in));
conn_addr.sin_family = AF_INET;
conn_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
conn_addr.sin_port = htons(port_num);
lfd = create_listening_socket(port_num);
do_test(lfd, &conn_addr, 0, 0);
do_test(lfd, &conn_addr, SOCK_CLOEXEC, 0);
do_test(lfd, &conn_addr, 0, SOCK_NONBLOCK);
do_test(lfd, &conn_addr, SOCK_CLOEXEC, SOCK_NONBLOCK);
close(lfd);
#else
tst_resm(TCONF, "syscall __NR_accept4 not supported on your arch");
#endif
cleanup();
tst_exit();
}
int main()
{
fd_set read_fds;
create_listening_socket();
printf("<?xml version='1.0' encoding='UTF-8'?>\n" );
printf( "<log>\n\n" );
/* Logging loop */
while( 1 )
{
FD_ZERO(&read_fds);
FD_SET(listening_socket, &read_fds);
FD_SET(0, &read_fds);
select(listening_socket+1, &read_fds, NULL, NULL, NULL);
if (FD_ISSET(listening_socket, &read_fds))
receive_and_log_packet();
else
break;
}
printf( "</log>\n" );
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
struct sockaddr_in conn_addr;
int lfd;
int port_num;
setup();
port_num = (argc > 1) ? atoi(argv[1]) : PORT_NUM;
memset(&conn_addr, 0, sizeof(struct sockaddr_in));
conn_addr.sin_family = AF_INET;
conn_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
conn_addr.sin_port = htons(port_num);
lfd = create_listening_socket(port_num);
do_test(lfd, &conn_addr, 0, 0);
do_test(lfd, &conn_addr, SOCK_CLOEXEC, 0);
do_test(lfd, &conn_addr, 0, SOCK_NONBLOCK);
do_test(lfd, &conn_addr, SOCK_CLOEXEC, SOCK_NONBLOCK);
close(lfd);
cleanup();
tst_exit();
}
static void init(void)
{
init_winsock();
create_io_completion_port();
create_listening_socket();
bind_listening_socket();
start_listening();
load_accept_ex();
start_accepting();
}
bool server_start(server_t server) {
debug("starting the server\n");
server->free_chain = NULL;
server->used_chain = NULL;
server->listener = create_listening_socket(server->host, server->port);
if (server->listener == -1) {
return false;
}
return server_add_socket(server, server->listener, NULL);
}
int setup_transport(EV_P_ transport *xprt) {
int accept_fd = create_listening_socket(xprt->port);
accept_watcher_data *awd = calloc(1, sizeof(accept_watcher_data));
awd->accept_fd = accept_fd;
awd->xprt = xprt;
awd->uniq_id = 0;
ev_io *new_connection_watcher = malloc(sizeof(ev_io));
new_connection_watcher->data = awd;
ev_io_init(new_connection_watcher, conn_accept_cb, accept_fd, EV_READ);
xprt->xprt_initialize(xprt);
ev_io_start(EV_DEFAULT_ new_connection_watcher);
}
static int create_sockets_tcp(fd_pair *client_fds, fd_pair *server_fds) {
int listen_fd = -1;
int client_fd = -1;
int server_fd = -1;
struct sockaddr_in port;
struct sockaddr *sa_port = (struct sockaddr *)&port;
port.sin_family = AF_INET;
port.sin_port = 0;
port.sin_addr.s_addr = INADDR_ANY;
listen_fd = create_listening_socket(sa_port, sizeof(port));
if (listen_fd == -1) {
gpr_log(GPR_ERROR, "Listen failed");
goto error;
}
client_fd = connect_client(sa_port, sizeof(port));
if (client_fd == -1) {
gpr_log(GPR_ERROR, "Connect failed");
goto error;
}
server_fd = accept_server(listen_fd);
if (server_fd == -1) {
gpr_log(GPR_ERROR, "Accept failed");
goto error;
}
client_fds->read_fd = client_fd;
client_fds->write_fd = client_fd;
server_fds->read_fd = server_fd;
server_fds->write_fd = server_fd;
close(listen_fd);
return 0;
error:
if (listen_fd != -1) {
close(listen_fd);
}
if (client_fd != -1) {
close(client_fd);
}
if (server_fd != -1) {
close(server_fd);
}
return -1;
}
int ip_init()
{
set_my_ipaddr();
set_real_ip_addresses();
create_sending_socket();
create_listening_socket();
check_packet_logging();
packet_loss = get_percentage_env("PACKET_LOSS");
packet_corruption = get_percentage_env("PACKET_CORRUPTION");
if (my_ipaddr)
return 1;
return 0;
}
bool server_start(server_t server) {
debug("starting the server\n");
server->streamsnum = 0;
server->listener = create_listening_socket(server->host, server->port);
if (server->listener == -1) {
return false;
}
FD_ZERO(&server->all);
FD_SET(server->listener, &server->all);
server->maxfd = server->listener;
return true;
}
int main(int argc, char* argv[])
{
int one=1;
int cmd=0;
if(!IOFlashStorage_kernel_patch())
return -1;
CFMutableDictionaryRef dict = FSDGetInfo(1);
if(dict == NULL)
{
fprintf(stderr, "FAILed to get NAND infos");
return -1;
}
check_special_pages();
int sl = create_listening_socket(LISTEN_PORT);
if(sl == -1)
{
fprintf(stderr, "Error calling create_listening_socket\n");
return -1;
}
fprintf(stderr, "NAND dumper listening on port %d\n", LISTEN_PORT);
while(1)
{
int s = accept(sl, NULL, NULL);
setsockopt(s, SOL_SOCKET, SO_NOSIGPIPE, (void *)&one, sizeof(int));
int r = read(s, (void*) &cmd, sizeof(int));
if(r == sizeof(int))
{
if(cmd == CMD_DUMP)
{
nand_dump(s);
}
else if(cmd == CMD_PROXY)
{
nand_proxy(s);
}
}
shutdown(s, SHUT_RDWR);
close(s);
}
return 0;
}
int main(int argc, char ** argv) {
server_state_t * s;
// All of these setup routines may exit with an error.
s = parse_args(argc, argv);
create_listening_socket(s);
open_backing_store(s);
if (s->daemonize) {
if (daemon(false, false) == -1)
perror("daemon() failed");
}
do_server(s);
return 0;
}
int
main(int argc, char *argv[])
{
int server_sock;
int client_sock;
if (argc < 2) {
errx(1, "Please enter socket parameter!");
}
signal(SIGPIPE, SIG_IGN);
setlinebuf(stdout);
server_sock = create_listening_socket(argv[1]);
do {
client_sock = accept_conn(server_sock);
} while (read_write_loop(client_sock, stdout) != -1);
return (0);
}
static bool start_server(void)
{
int i;
server.listener = -1;
server.raftsock = -1;
FD_ZERO(&server.all);
server.maxfd = 0;
server.clientnum = 0;
server.listener = create_listening_socket(server.host, server.port);
if (server.listener == -1)
{
return false;
}
for (i = 0; i < MAX_CLIENTS; i++)
{
server.clients[i].sock = -1;
}
return add_socket(server.listener);
}
int
main(int argc, char **argv)
{
int o;
int port = 7667;
gettimeofday(&prog_start, NULL);
bzero(&PS, sizeof(PS));
PS.max_packets_on_the_wire = 1000000;
PS.program_version = 2014052300;
while ( (o = getopt(argc, argv, "hp:q")) != -1) {
switch (o) {
case 'h':
usage(NULL);
break;
case 'p':
port = strtol(optarg, NULL, 10);
break;
case 'q':
opt_quiet = 1;
break;
default:
usage("");
}
}
argc -= optind;
argv += optind;
if (argc != 0)
usage("extraneous arguments");
create_snmp_socket();
create_listening_socket(port);
event_loop();
return 0;
}
/*
* Main program.
*/
int main(int argc, char *argv[])
{
#ifdef __linux__
// signal handling
if (init_signal() < 0)
exit(EXIT_FAILURE);
// command line options checking
if (check_args(argc, argv) < 0)
exit(EXIT_FAILURE);
// creating listening TCP socket
listenfd = create_listening_socket();
if (listenfd < 0)
exit(EXIT_FAILURE);
// creating RAW socket
rawfd = create_raw_socket();
if (rawfd < 0)
exit(EXIT_FAILURE);
// setting fds to select
fd_set readfds;
int select_ret;
// infinite loop where select chooses one of listening or raw socket to serve
while (keep_going) {
FD_ZERO(&readfds);
FD_SET(rawfd, &readfds);
FD_SET(listenfd, &readfds);
select_ret = select(MAX(rawfd, listenfd) + 1, &readfds, NULL, NULL, NULL);
if (select_ret == -1) {
// just cleaning up and finishing with error
clean_up();
exit(EXIT_FAILURE);
} else {
// FD was choosen
if (FD_ISSET(listenfd, &readfds)) {
// incoming client
if (add_client() < 0) {
clean_up();
exit(EXIT_FAILURE);
}
}
if (FD_ISSET(rawfd, &readfds)) {
// reading from raw socket
if (read_raw_socket() < 0) {
clean_up();
exit(EXIT_FAILURE);
}
}
} // if (select_ret > 0)
} // while(keep_doing)
// closing sockets
if (clean_up() < 0)
exit(EXIT_FAILURE);
#endif
exit(EXIT_SUCCESS);
}
int main(int argc, char **argv)
{
int ret, size;
int fd = -1, fdv = -1, ls;
struct input_event ev;
struct pollfd fds[3];
int num_fds = 0;
struct sigaction sa_int;
/*
* initialize our state
*/
daemonize(argv[0]);
#ifdef DEBUG_PRINT
console = fopen("/dev/console", "w");
if(console == NULL)
exit(1);
#endif
if (sound_connect())
goto fail_sound;
running = 0;
if (backlight_connect() == 0)
backlight = 1;
fd = open_input_device("LF1000 Keyboard");
if (fd < 0) {
dbprintf("can't open input device\n");
goto fail_kb;
}
fds[LFD_KEY_PRESS].fd = fd;
fds[LFD_KEY_PRESS].events = POLLIN;
num_fds++;
/* volume fd open */
fdv = open_input_device("OpenLF Didj volume interface");
if (fdv < 0) {
dbprintf("can't open volume input device\n");
goto fail_kb;
}
fds[LFD_VOLUME].fd = fdv;
fds[LFD_VOLUME].events = POLLIN;
num_fds++;
ls = create_listening_socket(LFD_SOCKET_PATH);
if (ls < 0) {
dbprintf("can't create listening socket\n");
goto fail_sock;
}
fcntl(ls, F_SETFL, O_NONBLOCK);
fds[LFD_CONTROL_SOCKET].fd = ls;
fds[LFD_CONTROL_SOCKET].events = POLLIN;
num_fds++;
mv = battery_get_mv();
/*
* trap SIGTERM so that we clean up before exiting
*/
running = 1;
sigemptyset(&sa_int.sa_mask);
sa_int.sa_handler = handle_signal;
sa_int.sa_flags = 0;
if (sigaction(SIGTERM, &sa_int, NULL) == -1) {
dbprintf("can't trap SIGTERM\n");
goto fail_sig;
}
if (sigaction(SIGINT, &sa_int, NULL) == -1) {
dbprintf("can't trap SIGINT\n");
goto fail_sig;
}
/*
* monitor
*/
while (running) {
ret = poll(fds, num_fds, 1000);
if (ret == 0) { /* timeout */
mv = battery_get_mv();
} else if (ret > 0) {
if (fds[LFD_KEY_PRESS].revents & POLLIN) {
size = read(fd, &ev, sizeof(ev));
if (ev.type == EV_KEY && ev.value == 1)
handle_key(ev.code);
}
if(fds[LFD_VOLUME].revents & POLLIN) {
size = read(fdv, &ev, sizeof(ev));
if (ev.type == EV_ABS)
handle_volume(ev.value);
}
if (fds[LFD_CONTROL_SOCKET].revents & POLLIN)
handle_control_socket(ls);
}
}
dbprintf("exiting...\n");
close(ls);
close(fd);
sound_disconnect();
#ifdef DEBUG_PRINT
fclose(console);
#endif
exit(0);
fail_sig:
close(ls);
fail_sock:
fail_sound:
close(fd);
close(fdv);
fail_kb:
sound_disconnect();
#ifdef DEBUG_PRINT
fclose(console);
#endif
exit(1);
}
int socket_server_run()
{
int listen_fd, connect_fd;
struct sockaddr_in client_addr;
socklen_t client_len;
if((listen_fd = create_listening_socket()) == -1)
{
fprintf(stderr, "can't create listening socket\n");
return -1;
}
FILE* log_file;
log_file = open_log_file();
bool main_server_has_error = false;
#ifdef __DEBUG__
fprintf(stdout, "start listening\n");
#endif
if(signal(SIGCHLD, sig_chld) == SIG_ERR)
{
fprintf(stderr, "can't bind signal handler\n");
main_server_has_error = true;
}
while(main_server_has_error == false)
{
client_len = sizeof(client_addr);
if((connect_fd = Accept(listen_fd, (SA*)&client_addr, &client_len)) == -1)
{
fprintf(stderr, "accept error\n");
main_server_has_error = true;
break;
}
if(fork() == 0) // child process
{
int child_server_status = 0;
FILE* read_file;
FILE* write_file;
if(close(listen_fd) == -1)
{
fprintf(stderr, "server child close listening socket error\n");
child_server_status = -1;
}
if((read_file = fdopen(connect_fd, "r+")) == NULL)
{
fprintf(stderr, "convertion from connected socket fd to FILE struct has error\n");
close(connect_fd);
child_server_status = -1;
}
else
{
write_file = read_file; // socket is duplex
#ifdef __DEBUG__
fprintf(stdout, "establish client server socket connection\n");
#endif
if(run_server_core(read_file, write_file, open_log_file()) == -1)
{
fprintf(stderr, "server core has error\n");
child_server_status = -1;
}
//disconnect client socket is duplex, so read_file and write_file is the same file
if(fclose(read_file) == EOF)
{
fprintf(stderr, "close the read file occurs an error\n");
child_server_status = -1;
}
if(log_file != NULL)
{
fclose(log_file);
}
}
return child_server_status;
}
if(close(connect_fd) == -1)
{
fprintf(stderr, "server close connected socket error\n");
return -1;
}
}
// you go here means you have something wrong
if(close(listen_fd) == -1)
{
fprintf(stderr, "server child close listening socket error\n");
}
if(log_file != NULL)
{
fclose(log_file);
}
return -1;
}
int
main(int argc, char *argv[])
{
int ch, forkres, dontfork = 0, cpf;
char conffile[PATH_MAX + 1];
strlcpy(conffile, CONFFILE, sizeof(conffile));
while((ch = getopt(argc, argv, "c:dDfhp:W")) != -1)
switch(ch) {
case 'c':
strlcpy(conffile, optarg, sizeof(conffile));
break;
case 'D':
debug_f = 1;
break;
case 'd':
dont_catch = 1;
break;
case 'f':
dontfork = 1;
break;
case 'p':
if ((command_port = atoi(optarg)) < 1) {
print_usage(argv[0]);
return EXIT_FAILURE;
}
break;
case 'W':
warn_f = 1;
break;
case 'h':
default:
print_usage(argv[0]);
return EXIT_FAILURE;
break;
}
cpf = conf_parsefile(conffile);
if (cpf < 0 && strcmp(conffile, CONFFILE)) {
fatalp("Cannot parse config file: %s\n", conffile);
return EXIT_FAILURE;
} else if (cpf > 0) {
fatalp("Cannot parse line %d in config file\n", cpf);
return EXIT_FAILURE;
}
if (set_my_ldp_id()) {
fatalp("Cannot set LDP ID\n");
return EXIT_FAILURE;
}
if (conf_ldp_id.s_addr != 0)
strlcpy(my_ldp_id, inet_ntoa(conf_ldp_id), INET_ADDRSTRLEN);
if (mplssockaddr.sa_len == 0) {
fatalp("FATAL: Create an mpls interface using ifconfig\n"
"e.g. ifconfig mpls0 create up\n");
return EXIT_FAILURE;
}
if (mpls_start_ldp() == -1)
return EXIT_FAILURE;
if (!strcmp(LDP_ID, "0.0.0.0")) {
fatalp("Cannot set my LDP ID.\nAre you sure you've "
"got a non-loopback INET interface UP ?\n");
return EXIT_FAILURE;
}
init_command_sockets();
if ((command_socket = create_command_socket(command_port)) < 1) {
fatalp("Cannot create command socket\n");
return EXIT_FAILURE;
}
if (create_hello_sockets() != 0) {
fatalp("Cannot create hello socket\n");
return EXIT_FAILURE;
}
ls = create_listening_socket();
if (ls < 0) {
fatalp("Cannot create listening socket\n");
return EXIT_FAILURE;
}
if (dontfork == 1)
return the_big_loop();
forkres = fork();
if (forkres == 0) {
syslog_f = 1;
return the_big_loop();
}
if (forkres < 0)
perror("fork");
return EXIT_SUCCESS;
}
int main(int argc, char ** argv)
{
fd_set readset;
server_state_t * s;
s = (server_state_t *)calloc(1, sizeof(server_state_t));
s->live_count = 0;
s->total_count = 0;
parse_args(argc, argv, s);
/* open shared memory file */
if ((s->shm_fd = shm_open(s->shmobj, O_CREAT|O_RDWR, S_IRWXU)) < 0)
{
fprintf(stderr, "ivshmem server: could not open shared file\n");
exit(-1);
}
if (ftruncate(s->shm_fd, s->shm_size) != 0)
{
fprintf(stderr, "ivshmem server: could not truncate memory region\n");
exit(-1);
}
s->conn_socket = create_listening_socket(s->path);
s->maxfd = s->conn_socket;
for(;;) {
int ret, handle, i;
char buf[1024];
print_vec(s, "vm_sockets");
FD_ZERO(&readset);
/* conn socket is in Live_vms at posn 0 */
FD_SET(s->conn_socket, &readset);
for (i = 0; i < s->total_count; i++) {
if (s->live_vms[i].alive != 0) {
FD_SET(s->live_vms[i].sockfd, &readset);
}
}
printf("\nWaiting (maxfd = %d)\n", s->maxfd);
ret = select(s->maxfd + 1, &readset, NULL, NULL, NULL);
if (ret == -1) {
perror("select()");
}
handle = find_set(&readset, s->maxfd + 1);
if (handle == -1) continue;
if (handle == s->conn_socket) {
printf("[NC] new connection\n");
FD_CLR(s->conn_socket, &readset);
/* The Total_count is equal to the new guests VM ID */
add_new_guest(s);
/* update our the maximum file descriptor number */
s->maxfd = s->live_vms[s->total_count - 1].sockfd > s->maxfd ?
s->live_vms[s->total_count - 1].sockfd : s->maxfd;
s->live_count++;
printf("Live_count is %ld\n", s->live_count);
} else {
/* then we have received a disconnection */
int recv_ret;
long i, j;
long deadposn = -1;
recv_ret = recv(handle, buf, 1, 0);
printf("[DC] recv returned %d\n", recv_ret);
/* find the dead VM in our list and move it do the dead list. */
for (i = 0; i < s->total_count; i++) {
if (s->live_vms[i].sockfd == handle) {
deadposn = i;
s->live_vms[i].alive = 0;
close(s->live_vms[i].sockfd);
for (j = 0; j < s->msi_vectors; j++) {
close(s->live_vms[i].efd[j]);
}
free(s->live_vms[i].efd);
s->live_vms[i].sockfd = -1;
break;
}
}
for (j = 0; j < s->total_count; j++) {
/* update remaining clients that one client has left/died */
if (s->live_vms[j].alive) {
printf("[UD] sending kill of fd[%ld] to %ld\n",
deadposn, j);
sendKill(s->live_vms[j].sockfd, deadposn, sizeof(deadposn));
}
}
s->live_count--;
/* close the socket for the departed VM */
close(handle);
}
}
return 0;
}
