void handle_request ( int sock )
{
if ( sock == listen_sock )
{
accept_sock ( sock );
}
else
{
struct process* process = find_process_by_sock ( sock );
if ( process != 0 )
{
switch ( process->status )
{
case STATUS_READ_REQUEST_HEADER:
read_request ( process );
break;
case STATUS_SEND_RESPONSE_HEADER:
send_response_header ( process );
break;
case STATUS_SEND_RESPONSE:
send_response ( process );
break;
default:
break;
}
}
}
}
int TCP_sock_rcv(in_port_t port){
int sock, sock_rcv;
int porta;
struct sockaddr_in Local, From;
char ipstr[15];
porta = ntohs(port);
sock = get_sock(SOCK_STREAM);
set_sock(sock);
name_sock(&Local, htonl(INADDR_ANY), port);
bind_sock(sock, &Local);
listen_sock(sock);
printf("Attendo una connessione TCP sulla porta %d\n\n", porta);
sock_rcv = accept_sock(sock, &From);
inet_ntop(AF_INET, &From.sin_addr, ipstr,(socklen_t)15); /* conversione a stringa dell'ip per stamparlo */
printf("Connessione TCP da %s : %d\n\n", ipstr, ntohs(From.sin_port));
return sock_rcv;
}
int main(void) {
struct sockaddr_in serv_addr;
int listen_sock = socket(AF_INET, SOCK_STREAM, 0);
linked_fd * fdlist = new_linked_fd();
memset(&serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family=AF_INET;
serv_addr.sin_addr.s_addr=htonl(INADDR_ANY);
serv_addr.sin_port=htons(5058);
int bind_result = bind(listen_sock,
(struct sockaddr*)&serv_addr, sizeof(serv_addr));
if(bind_result == -1) {
perror("Failed to bind.");
return EXIT_FAILURE;
}
listen(listen_sock, 100);
fd_set fdset;
highest_fd = listen_sock;
do {
FD_ZERO(&fdset);
// Add the listening socket to the fdset.
FD_SET(listen_sock, &fdset);
// Add stdin to the fileset.
FD_SET(STDIN_FILENO, &fdset);
// Add each fd in our fdlist to the set.
linked_fd_node *current = linked_fd_head(fdlist);
while(current) {
int fd = fd_at(current);
if(fd < 0) {
return EXIT_FAILURE;
}
FD_SET(fd, &fdset);
current = linked_fd_next(current);
}
// Select on every fd in the fdset.
int x = select(highest_fd + 1, &fdset, NULL, NULL, NULL);
if(x < 0) {
return EXIT_FAILURE;
}
// If we got something on stdin, close all sockets
// And exit.
if(FD_ISSET(STDIN_FILENO, &fdset)) {
printf("Closing all sockets.\n");
close(listen_sock);
close_all(fdlist);
}
// If the listen_sock is 'ready', accept a socket and
// add it to our fd list.
if(FD_ISSET(listen_sock, &fdset)) {
accept_sock(listen_sock, fdlist);
}
//Handle other fds.
current = linked_fd_head(fdlist);
while(current) {
int fd = fd_at(current);
// This should never happen. Just precautionary.
if(fd < 0) {
return EXIT_FAILURE;
}
if(FD_ISSET(fd, &fdset)) {
do_echo(fd, fdlist);
}
current = linked_fd_next(current);
}
} while(1);
}
static void accept_pcpd(int sock, int pubsock, int privsock, int flag)
{
int fd;
pid_t pid;
struct PCP *pcp;
if ((fd=accept_sock(sock)) < 0)
return;
if (fcntl(fd, F_SETFL, 0) < 0)
{
syslog(LOG_CRIT, "pcpd: fcntl() failed: %m");
close(fd);
return;
}
maildir_cache_purge();
pid=fork();
if (pid < 0)
{
syslog(LOG_CRIT, "pcpd: fork() failed: %m");
close(fd);
return;
}
if (pid)
{
close(fd);
return; /* Parent resumes listening */
}
/* child */
close(pubsock);
close(privsock);
close(0);
if (dup(fd) != 0)
exit(0);
close(1);
if (dup(fd) != 1)
exit(0);
close(fd);
userid=login(flag, &flag);
pcp=pcp_open_dir(".", userid);
if (pcp && flag && pcp_cleanup(pcp))
{
pcp_close(pcp);
syslog(LOG_CRIT, "pcpd: pcp_cleanup failed");
pcp=NULL;
}
if (!pcp)
{
syslog(LOG_CRIT, "pcpd: pcp_open_dir failed");
perror("pcp_open_dir");
exit(1);
}
mainloop(pcp);
exit(0);
}
object *socket::accept()
{
struct sockaddr_storage addr;
socklen_t len = sizeof(addr);
int ret;
char hostname[1024];
list *retval;
socket *sock;
if (socket_val < 0)
{
exceptions::SocketError *exc = exceptions::SocketError::Create(
1,
new string("Socket already closed.")
);
exc->throw_exception();
}
ret = accept_sock(socket_val, (struct sockaddr*)&addr, &len);
if (ret < 0)
{
exceptions::SocketError *exc = exceptions::SocketError::Create(
1,
new string("Error during socket accept.")
);
exc->throw_exception();
}
if (!KITE_PROPERTY_EXISTS(this, unix_socket) || !KITE_GET_BOOLEAN_PROPERTY(this, unix_socket))
{
getnameinfo((struct sockaddr*)&addr, sizeof(addr), hostname, 1024, NULL, 0, NI_NUMERICHOST);
}
else
{
hostname[0] = 0;
}
retval = list::Create(0);
sock = new socket();
sock->socket_val = ret;
retval->list_contents.push_back(retval);
retval->list_contents.push_back(
new string(hostname)
);
if (!KITE_PROPERTY_EXISTS(this, unix_socket) || !KITE_GET_BOOLEAN_PROPERTY(this, unix_socket))
{
int port = 0;
switch(addr.ss_family)
{
case AF_INET:
{
struct sockaddr_in *sin = (struct sockaddr_in*)&addr;
port = sin->sin_port;
break;
}
case AF_INET6:
{
struct sockaddr_in6 *sin = (struct sockaddr_in6*)&addr;
port = sin->sin6_port;
break;
}
default:
{
assert(0);
}
}
retval->list_contents.push_back(new integer(port));
}
else
{
retval->list_contents.push_back(new integer(0));
}
return retval;
}
