ServerSSL(boost::asio::io_service& io_service, int port)
: m_io_service(io_service)
, m_acceptor(io_service
, boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4()
, port))
, m_context(boost::asio::ssl::context::sslv23)
, m_room(new SessionManager())
{
std::cout << "Starting SSL Server" << std::endl;
m_context.set_options(
boost::asio::ssl::context::default_workarounds
| boost::asio::ssl::context::no_sslv2
| boost::asio::ssl::context::single_dh_use);
m_context.set_password_callback(boost::bind(&ServerSSL::get_password, this));
m_context.use_certificate_chain_file("KEYS/ca.pem");
//m_context.use_certificate_chain_file_path ...
m_context.use_private_key_file("KEYS/server.key", boost::asio::ssl::context::pem);
m_context.use_tmp_dh_file("KEYS/dh2048.pem");
// Setup the communicator to allow rest of program to talk with
// And send messages to other nodes.
TheCommunicator::instance()->setupServer(m_room);
std::cout << "SSL Server Ready." << std::endl;
wait_for_connection();
}
PhronesisAgent::PhronesisAgent(boost::asio::io_service& io_service,
const tcp::endpoint& endpoint) :
m_io_service(io_service), m_acceptor(io_service, endpoint) {
std::cout << "Creation d'un serveur " << std::endl;
wait_for_connection();
}
int mdg_demo_start(void)
{
int s;
if ((s = mdg_init(0)) != 0) {
fprintf(stderr, "mdg_init failed with %d\n", s);
return -1;
}
mdg_chat_init();
while (1) {
if (io_port == -1) {
if (read_from_sock(STDIN_FILENO) == 1) {
exit(0);
}
} else {
fprintf(stderr, "Listening for connection on port %d\n", io_port);
if (wait_for_connection(io_port, &io_socket) == 0) {
fprintf(stderr, "Reading input from socket...\n");
read_from_sock(io_socket);
}
fprintf(stderr, "Socket closed.\n");
close(io_socket);
}
}
}
int main(int argc, char** argv) {
// open system log and default to recording all logs (debug)
openlog("calc-server", LOG_PERROR | LOG_PID | LOG_NDELAY, LOG_USER);
setlogmask(LOG_UPTO(LOG_DEBUG));
int c;
char* port = NULL;
while (true) {
static struct option long_options[] = {
{"port", required_argument, 0, 'p'},
{0, 0, 0, 0}
};
int option_index = 0;
c = getopt_long(argc, argv, "p:", long_options, &option_index);
if (c == -1)
break;
switch (c) {
case 'p':
port = optarg;
if (port == NULL) {
syslog(LOG_ERR, "Port argument missing!");
exit(EXIT_FAILURE);
}
break;
case '?':
break;
}
}
// We want to listen on the specified port
struct addrinfo* results = get_server_sockaddr(port);
syslog(LOG_INFO, "Server listening on port %s", port);
// Create a listening socket
int sockfd = bind_socket(results);
// Start listening on the socket
if (listen(sockfd, BACKLOG) == -1) {
perror("Unable to listen on socket");
syslog(LOG_ERR, "Unable to listen on socket");
exit(EXIT_FAILURE);
}
while (true) {
// Wait for a connection and handle it
int connectionfd = wait_for_connection(sockfd);
handle_connection(connectionfd);
}
closelog();
exit(EXIT_SUCCESS);
}
int main(int argc,
char **argv)
{
errval_t err;
debug_printf("Xeon Phi Test started on the card.\n");
err = xeon_phi_client_init(disp_xeon_phi_id());
EXPECT_SUCCESS(err, "xeon_phi_client_init");
xeon_phi_client_set_callbacks(&callbacks);
alloc_local();
wait_for_connection();
char iface[30];
snprintf(iface, 30, "xphi_ump_bench.%u", XPHI_BENCH_CORE_HOST);
debug_printf("sending open to host domain..\n");
err = xeon_phi_client_chan_open(disp_xeon_phi_id(), domainid, 0, local_frame, 2);
EXPECT_SUCCESS(err, "xeon_phi_client_init");
#if XPHI_BENCH_INITIATOR_HOST
debug_printf("giving time for host to initialize...\n");
for (uint32_t i = 0; i < 10; ++i) {
delay_ms(4000);
thread_yield();
}
#endif
#if XPHI_BENCH_INITIATOR_HOST
debug_printf("---------------- normal run -----------------\n");
xphi_bench_start_echo(&xphi_uc);
debug_printf("---------------- reversed run -----------------\n");
xphi_bench_start_echo(&xphi_uc_rev);
#else
#ifndef XPHI_BENCH_THROUGHPUT
debug_printf("---------------- normal run -----------------\n");
xphi_bench_start_initator_rtt(&xphi_uc);
debug_printf("---------------- reversed run -----------------\n");
xphi_bench_start_initator_rtt(&xphi_uc_rev);
#else
#ifdef XPHI_BENCH_SEND_SYNC
debug_printf("---------------- normal run -----------------\n");
xphi_bench_start_initator_sync(&xphi_uc);
debug_printf("---------------- reversed run -----------------\n");
xphi_bench_start_initator_sync(&xphi_uc_rev);
#else
debug_printf("---------------- normal run -----------------\n");
xphi_bench_start_initator_async(&xphi_uc);
debug_printf("---------------- reversed run -----------------\n");
xphi_bench_start_initator_async(&xphi_uc_rev);
#endif
#endif
#endif
}
void listen_for_connection(int *listener) {
int connection, connect_result;
connect_result = -1;
do {
connect_result = wait_for_connection(*listener, &connection);
} while(connect_result < 0);
pthread_create(&listener_thread, NULL, (void *(*)(void *))
listen_for_connection, listener);
handle_rpc(connection);
}
int main(int argc, char** argv)
{
int c;
static int server_port_flag = 0;
char* server_port = NULL;
static struct option long_options[] =
{
/*set flags */
{"port", required_argument, 0, 'p'},
{0, 0, 0, 0}
};
while ((c = getopt_long(argc, argv, "p:",long_options,NULL)) != -1)
{
switch (c)
{
case 'p':
server_port_flag = 1;
server_port = optarg;
break;
case '?':
exit(EXIT_FAILURE);
break;
}
}
openlog("server", LOG_PERROR | LOG_PID | LOG_NDELAY, LOG_USER);
if (server_port_flag == 0)
{
syslog(LOG_WARNING, "No server port was specified");
exit(EXIT_FAILURE);
}
// We want to listen on port 5000
struct addrinfo* results = get_server_sockaddr(server_port);
// Create a listening socket
int sockfd = bind_socket(results);
// Start listening on the socket
if (listen(sockfd, BACKLOG) == -1)
{
perror("Unable to listen on socket");
exit(EXIT_FAILURE);
}
while (1)
{
// Wait for a connection and handle it
int connectionfd = wait_for_connection(sockfd);
handle_connection(connectionfd);
}
closelog(); /* close the syslog connection */
return EXIT_SUCCESS;
}
int main(int argc, char* argv[]) {
int client, server;
int master_sock;
int localport;
char* log_file_loc;
if (argc == 4) {
if (strcmp(argv[1], "-v") != 0) {
show_usage(argv[0]);
}
verbose = true;
localport = atoi(argv[2]);
log_file_loc = argv[3];
} else if (argc == 3) {
localport = atoi(argv[1]);
log_file_loc = argv[2];
} else {
show_usage(argv[0]);
}
if (strcmp(log_file_loc, "stdout") == 0) {
logfile = stdout;
verbose = false;
} else {
logfile = fopen(log_file_loc, "a");
}
if (logfile == NULL) {
fprintf(stderr, "log_file %s could not be opened\n", argv[2]);
exit(2);
}
assert(localport > 0);
signal(SIGINT, cleanup);
signal(SIGCHLD, sigreap);
master_sock = create_server_sock(localport);
for (;;) {
if ((client = wait_for_connection(master_sock)) < 0) {
continue;
}
if ((server = create_proxy(client)) < 0) {
continue;
}
if (!fork()) {
syslog(LOG_INFO, "connecting to %s:%d fd=%d\n", remoteaddr, remoteport, server);
service_client(client, server);
}
close(client);
close(server);
}
}
void PhronesisAgent::handle_accept(const boost::system::error_code& error,
connection_ptr new_connection) {
if (!error) {
std::string s =
new_connection.get()->socket().remote_endpoint().address().to_string();
std::cout << "Accepted connection from " << s << std::endl;
Treatment_ptr session = Treatment::create(new_connection);
//Shall we call wait_for_connection even if there is an error?
wait_for_connection();
} else {
std::cerr << "Connection refusee" << std::endl;
}
}
void listen_for_connection(host_port *info) {
pthread_t thread;
int connection, connect_result, listener;
connect_result = set_up_listener(info->port, &listener);
connect_result = -1;
while(1) {
do {
connect_result = wait_for_connection(listener, &connection);
} while(connect_result < 0);
connect_result = 0;
safe_recv(connection, &connect_result, sizeof(int));
if(connect_result) {
pthread_create(&thread, NULL, (void *(*)(void *))receive_int, (void *)&connection);
}
}
}
/**
* @brief On Connections, creates and spawns the SSL session.
* @param new_connection
* @param error
*/
void handle_accept(connection_ptr new_connection,
const boost::system::error_code& error)
{
if(!error)
{
std::cout << "SSL Connection Accepted" << std::endl;
session_ptr new_session = Session::create(m_io_service, new_connection, m_room);
m_room->join(new_session); // keep it alive!
// Loop back and handle next connection
wait_for_connection();
}
else
{
std::cout << "Error SSL Connection." << std::endl;
}
}
int main(int argc, char *argv[]) {
int thread_counter = 0;
int sockfd;
int newsockfd;
pthread_t workers[NUM_WORKERS];
my_router = malloc(sizeof(struct router));
// parse config
if (!parse_config(argc, argv)) {
return -1;
}
// set up this node
sockfd = create_node(port);
if (sockfd == -1) {
return -1;
}
dbg("Erstellt");
// init list of all connected neighbours
LIST_INIT(&neighbour_head);
// init blacklist
package_id_blacklist[0] = 1;// without this, packages with ID 0 are blacklisted from the beginning
while (1) {
newsockfd = wait_for_connection(sockfd);// wait for a new node to connect
pthread_create(&workers[thread_counter], NULL, worker_init, (void *)newsockfd);// create a new thread for handling this connection
thread_counter += 1;
if (thread_counter >= NUM_WORKERS) {
thread_counter = 0;
}
}
// clean up mutexes and conditions
pthread_mutex_destroy(&mutex_neighbours);
pthread_cond_destroy(&cond_neighbours);
pthread_mutex_destroy(&mutex_router);
pthread_cond_destroy(&cond_router);
pthread_mutex_destroy(&mutex_blacklist);
pthread_cond_destroy(&cond_blacklist);
return 0;
}
int main(int ac, char **av)
{
int fd;
int ret;
if (ac > 3 || ac == 2)
return (msg_error(EUSAGE, 0));
if (ac == 3)
fd = connect_to_server(av[1], atoi(av[2]));
else
fd = wait_for_connection();
if (fd <= 0)
return (EXIT_FAILURE);
ret = launch_client(fd);
if (close(fd) == -1)
return (msg_error(ECLOSE, 1));
return (ret);
}
int
handle_connections(int portnum)
{
int listenfd;
int acceptfd;
pid_t childpid;
listenfd = create_listener(portnum);
if (listenfd < 0) {
fprintf(stderr, "Warning: Exiting main network event loop\n");
return -1;
}
while (1) {
fprintf(stderr, "Notice: Waiting for a connection...\n");
acceptfd = wait_for_connection(listenfd);
if (acceptfd < 0) {
fprintf(stderr, "Warning: Exiting main network event loop\n");
return -1;
}
childpid = fork();
if (childpid > 0) {
close(acceptfd);
fprintf(stderr, "Notice: Child process id=%d forked to handle incoming connection\n", childpid);
}
else if (childpid == 0) {
close(listenfd);
fprintf(stderr, "Notice: Processing request in child process\n");
read_incoming_data(acceptfd);
exit(0);
}
else {
perror("fork");
fprintf(stderr, "Error: Unable to create child process to handle new connection\n");
}
}
} /* handle_connections() */
void udp_server(const char* name, int port, int mtu)
{
int sock, ret;
struct sockaddr_in cli_addr;
socklen_t cli_addr_size;
char buffer[MAX_BUFFER];
priv_data_st priv;
gnutls_session_t session;
gnutls_datum_t cookie_key;
gnutls_dtls_prestate_st prestate;
unsigned char sequence[8];
ret = gnutls_key_generate(&cookie_key, GNUTLS_COOKIE_KEY_SIZE);
if (ret < 0)
{
fprintf(stderr, "Cannot generate key\n");
exit(1);
}
ret = listen_socket (name, port, SOCK_DGRAM);
if (ret < 0)
{
fprintf(stderr, "Cannot listen\n");
exit (1);
}
for (;;)
{
printf("Waiting for connection...\n");
sock = wait_for_connection();
if (sock < 0)
continue;
cli_addr_size = sizeof(cli_addr);
ret = recvfrom(sock, buffer, sizeof(buffer), MSG_PEEK, (struct sockaddr*)&cli_addr, &cli_addr_size);
if (ret > 0)
{
memset(&prestate, 0, sizeof(prestate));
ret = gnutls_dtls_cookie_verify(&cookie_key, &cli_addr, sizeof(cli_addr), buffer, ret, &prestate);
if (ret < 0) /* cookie not valid */
{
priv_data_st s;
memset(&s,0,sizeof(s));
s.fd = sock;
s.cli_addr = (void*)&cli_addr;
s.cli_addr_size = sizeof(cli_addr);
printf("Sending hello verify request to %s\n", human_addr ((struct sockaddr *)
&cli_addr, sizeof(cli_addr), buffer, sizeof(buffer)));
gnutls_dtls_cookie_send(&cookie_key, &cli_addr, sizeof(cli_addr), &prestate, (gnutls_transport_ptr_t)&s, push_func);
/* discard peeked data*/
recvfrom(sock, buffer, sizeof(buffer), 0, (struct sockaddr*)&cli_addr, &cli_addr_size);
continue;
}
printf ("Accepted connection from %s\n",
human_addr ((struct sockaddr *)
&cli_addr, sizeof(cli_addr), buffer,
sizeof (buffer)));
}
else
continue;
session = initialize_session(1);
gnutls_dtls_prestate_set(session, &prestate);
if (mtu) gnutls_dtls_set_mtu(session, mtu);
priv.session = session;
priv.fd = sock;
priv.cli_addr = (struct sockaddr *)&cli_addr;
priv.cli_addr_size = sizeof(cli_addr);
gnutls_transport_set_ptr (session, &priv);
gnutls_transport_set_push_function (session, push_func);
gnutls_transport_set_pull_function (session, pull_func);
gnutls_transport_set_pull_timeout_function (session, pull_timeout_func);
do
{
ret = gnutls_handshake(session);
}
while(ret == GNUTLS_E_AGAIN || ret == GNUTLS_E_INTERRUPTED);
if (ret < 0)
{
fprintf(stderr, "Error in handshake(): %s\n", gnutls_strerror(ret));
gnutls_deinit(session);
continue;
}
for(;;)
{
do {
ret = gnutls_record_recv_seq(session, buffer, MAX_BUFFER, sequence);
} while(ret == GNUTLS_E_AGAIN || ret == GNUTLS_E_INTERRUPTED);
if (ret == GNUTLS_E_REHANDSHAKE)
{
fprintf (stderr, "*** Received hello message\n");
do
{
ret = gnutls_handshake (session);
}
while (ret == GNUTLS_E_INTERRUPTED ||
ret == GNUTLS_E_AGAIN);
if (ret == 0) continue;
}
if (ret < 0)
{
fprintf(stderr, "Error in recv(): %s\n", gnutls_strerror(ret));
break;
}
if (ret == 0)
{
printf("EOF\n\n");
break;
}
buffer[ret] = 0;
printf("received[%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x]: %s\n", sequence[0], sequence[1], sequence[2],
sequence[3], sequence[4], sequence[5], sequence[6], sequence[7], buffer);
if (check_command(session, buffer) == 0)
{
/* reply back */
ret = gnutls_record_send(session, buffer, ret);
if (ret < 0)
{
fprintf(stderr, "Error in send(): %s\n", gnutls_strerror(ret));
break;
}
}
}
}
gnutls_deinit(session);
}
int
main(int argc, char *argv[], char *env[])
{
struct sockaddr_storage from;
int on = 1;
socklen_t fromlen;
register int ch;
int i;
#if defined(HAS_IPPROTO_IP) && defined(IP_TOS)
int tos = -1;
#endif
initsetproctitle(argc, argv, env);
pfrontp = pbackp = ptyobuf;
netip = netibuf;
#ifdef USE_SSL
/* we need to know the fullpath to the location of the
* certificate that we will be running with as we cannot
* be sure of the cwd when we are launched
*/
sprintf(cert_filepath,"%s/%s",X509_get_default_cert_dir(),
"telnetd.pem");
ssl_cert_file=cert_filepath;
ssl_key_file=NULL;
#endif /* USE_SSL */
while ((ch = getopt(argc, argv, "d:a:e:lhnNr:I:D:B:sS:a:X:L:z:")) != EOF) {
switch(ch) {
#ifdef USE_SSL
case 'z':
{
char *origopt;
origopt=strdup(optarg);
optarg=strtok(origopt,",");
while(optarg!=NULL) {
if (strcmp(optarg, "debug") == 0 ) {
ssl_debug_flag=1;
} else if (strcmp(optarg, "ssl") == 0 ) {
ssl_only_flag=1;
} else if (strcmp(optarg, "certsok") == 0 ) {
ssl_certsok_flag=1;
} else if ( (strcmp(optarg, "!ssl") == 0) ||
(strcmp(optarg, "nossl") == 0) ) {
/* we may want to switch SSL negotiation off
* for testing or other reasons
*/
ssl_disabled_flag=1;
} else if (strcmp(optarg, "certrequired") == 0 ) {
ssl_cert_required=1;
} else if (strcmp(optarg, "secure") == 0 ) {
ssl_secure_flag=1;
} else if (strncmp(optarg, "verify=",
strlen("verify=")) == 0 ) {
ssl_verify_flag=atoi(optarg+strlen("verify="));
} else if (strncmp(optarg, "cert=",
strlen("cert=")) == 0 ) {
ssl_cert_file=optarg+strlen("cert=");
} else if (strncmp(optarg, "key=",
strlen("key=")) == 0 ) {
ssl_key_file=optarg+strlen("key=");
} else if (strncmp(optarg,"cipher=",
strlen("cipher="))==0) {
ssl_cipher_list=optarg+strlen("cipher=");
} else {
/* report when we are given rubbish so that
* if the user makes a mistake they have to
* correct it!
*/
fprintf(stderr,"Unknown SSL option %s\n",optarg);
fflush(stderr);
exit(1);
}
/* get the next one ... */
optarg=strtok(NULL,",");
}
/*
if (origopt!=NULL)
free(origopt);
*/
}
break;
#endif /* USE_SSL */
#ifdef AUTHENTICATE
case 'a':
/*
* Check for required authentication level
*/
if (strcmp(optarg, "debug") == 0) {
extern int auth_debug_mode;
auth_debug_mode = 1;
} else if (strcasecmp(optarg, "none") == 0) {
auth_level = 0;
} else if (strcasecmp(optarg, "other") == 0) {
auth_level = AUTH_OTHER;
} else if (strcasecmp(optarg, "user") == 0) {
auth_level = AUTH_USER;
} else if (strcasecmp(optarg, "valid") == 0) {
auth_level = AUTH_VALID;
} else if (strcasecmp(optarg, "off") == 0) {
/*
* This hack turns off authentication
*/
auth_level = -1;
} else {
fprintf(stderr,
"telnetd: unknown authorization level for -a\n");
}
break;
#endif /* AUTHENTICATE */
#ifdef BFTPDAEMON
case 'B':
bftpd++;
break;
#endif /* BFTPDAEMON */
case 'd':
if (strcmp(optarg, "ebug") == 0) {
debug++;
break;
}
usage();
/* NOTREACHED */
break;
#ifdef DIAGNOSTICS
case 'D':
/*
* Check for desired diagnostics capabilities.
*/
if (!strcmp(optarg, "report")) {
diagnostic |= TD_REPORT|TD_OPTIONS;
} else if (!strcmp(optarg, "exercise")) {
diagnostic |= TD_EXERCISE;
} else if (!strcmp(optarg, "netdata")) {
diagnostic |= TD_NETDATA;
} else if (!strcmp(optarg, "ptydata")) {
diagnostic |= TD_PTYDATA;
} else if (!strcmp(optarg, "options")) {
diagnostic |= TD_OPTIONS;
} else {
usage();
/* NOT REACHED */
}
break;
#endif /* DIAGNOSTICS */
#ifdef AUTHENTICATE
case 'e':
if (strcmp(optarg, "debug") == 0) {
extern int auth_debug_mode;
auth_debug_mode = 1;
break;
}
usage();
/* NOTREACHED */
break;
#endif /* AUTHENTICATE */
case 'h':
hostinfo = 0;
break;
#ifdef LINEMODE
case 'l':
alwayslinemode = 1;
break;
#endif /* LINEMODE */
case 'L':
loginprg = strdup(optarg);
/* XXX what if strdup fails? */
break;
case 'n':
keepalive = 0;
break;
case 'N':
numeric_hosts = 1;
break;
#ifdef SecurID
case 's':
/* SecurID required */
require_SecurID = 1;
break;
#endif /* SecurID */
case 'S':
#ifdef HAS_GETTOS
if ((tos = parsetos(optarg, "tcp")) < 0)
fprintf(stderr, "%s%s%s\n",
"telnetd: Bad TOS argument '", optarg,
"'; will try to use default TOS");
#else
fprintf(stderr, "%s%s\n", "TOS option unavailable; ",
"-S flag not supported\n");
#endif
break;
#ifdef AUTHENTICATE
case 'X':
/*
* Check for invalid authentication types
*/
auth_disable_name(optarg);
break;
#endif /* AUTHENTICATE */
default:
fprintf(stderr, "telnetd: %c: unknown option\n", ch);
/* FALLTHROUGH */
case '?':
usage();
/* NOTREACHED */
}
}
#ifdef USE_SSL
if (ssl_secure_flag || ssl_cert_required || ssl_certsok_flag) {
/* in secure mode we *must* switch on the base level
* verify checking otherwise we cannot abort connections
* at the right place!
*/
if (ssl_verify_flag==0)
ssl_verify_flag=1;
}
/* if we are not running in debug then any error
* stuff from SSL debug *must* not go down
* the socket (which 0,1,2 are all pointing to by
* default)
*/
if (ssl_debug_flag)
ssl_log_file="/telnetd.log";
if (!do_ssleay_init(1)) {
if (bio_err!=NULL) {
BIO_printf(bio_err,"do_ssleay_init() failed\n");
ERR_print_errors(bio_err);
} else {
fflush(stderr);
fprintf(stderr,"do_ssleay_init() failed\n");
ERR_print_errors_fp(stderr);
}
exit(1);
}
if (ssl_debug_flag) {
BIO_printf(bio_err,"secure %d certrequired %d verify %d\n",
ssl_secure_flag,ssl_cert_required,ssl_verify_flag);
for(i=0;i<argc;i++)
BIO_printf(bio_err,"argv[%d]=\"%s\"\n",i,argv[i]);
}
#endif /* USE_SSL */
argc -= optind;
argv += optind;
if (debug) {
if (argc > 1) {
usage();
/* NOTREACHED */
}
wait_for_connection((argc == 1) ? *argv : "telnet");
}
openlog("telnetd", LOG_PID | LOG_ODELAY, LOG_DAEMON);
fromlen = sizeof (from);
if (getpeername(0, (struct sockaddr *)&from, &fromlen) < 0) {
fatalperror(2, "getpeername");
}
if (keepalive &&
setsockopt(0, SOL_SOCKET, SO_KEEPALIVE, &on, sizeof (on)) < 0) {
syslog(LOG_WARNING, "setsockopt (SO_KEEPALIVE): %m");
}
#if defined(HAS_IPPROTO_IP) && defined(IP_TOS)
{
# if defined(HAS_GETTOS)
struct tosent *tp;
if (tos < 0 && (tp = gettosbyname("telnet", "tcp")))
tos = tp->t_tos;
# endif
if (tos < 0)
tos = 020; /* Low Delay bit */
if (tos
&& (setsockopt(0, IPPROTO_IP, IP_TOS, &tos, sizeof(tos)) < 0)
&& (errno != ENOPROTOOPT) )
syslog(LOG_WARNING, "setsockopt (IP_TOS): %m");
}
#endif /* defined(HAS_IPPROTO_IP) && defined(IP_TOS) */
#ifdef USE_SSL
/* do the SSL stuff now ... before we play with pty's */
SSL_set_fd(ssl_con,0);
if (ssl_only_flag) {
/* hmm ... only when running talking to things like
* https servers should we hit this code and then
* we really don't care *who* we talk to :-)
*/
SSL_set_verify(ssl_con,ssl_verify_flag,NULL);
if (SSL_accept(ssl_con) <= 0) {
static char errbuf[1024];
sprintf(errbuf,"SSL_accept error %s\n",
ERR_error_string(ERR_get_error(),NULL));
syslog(LOG_WARNING, "%s", errbuf);
BIO_printf(bio_err,"%s",errbuf);
/* go to sleep to make sure we are noticed */
sleep(10);
SSL_free(ssl_con);
_exit(1);
} else {
ssl_active_flag=1;
}
}
#endif /* USE_SSL */
net = 0;
netopen();
doit((struct sockaddr *)&from, fromlen);
/* NOTREACHED */
return 0;
} /* end of main */
int main(int argc, char *argv[])
{
int source_port;
char *destination_address;
int destination_port;
int server_sockfd = -1, client_sockfd = -1, target_sockfd = -1, admin_sockfd = -1, admin_client_sockfd = -1;
char *lock_filename;
/* Check parameters */
if(argc != 5)
{
print_usage();
_exit(1);
}
/* Get parameter values */
source_port = atoi(argv[1]);
destination_address = strdup(argv[2]);
destination_port = atoi(argv[3]);
lock_filename = strdup(argv[4]);
/* Create signal handlers */
signal(SIGINT, cleanup); /* Event handler for interruption */
signal(SIGCHLD, sigreap); /* Event handler when a child terminates */
/* Create server socket */
server_sockfd = create_server_socket(source_port);
set_nonblock(server_sockfd);
/* Create admin socket */
admin_sockfd = create_admin_socket("/tmp/disnix-tcp-proxy.sock");
set_nonblock(admin_sockfd);
/* Main loop */
while(TRUE)
{
int status;
/* Create admin client socket if there is an incoming connection */
if((admin_client_sockfd = wait_for_connection(admin_sockfd)) >= 0)
{
char msg[BUFFER_SIZE];
printf("Admin connection from client\n");
sprintf(msg, "%d", num_of_connections);
if(send(admin_client_sockfd, msg, strlen(msg), 0) < 0)
fprintf(stderr, "Error sending message to admin client: %s\n", strerror(errno));
close(admin_client_sockfd);
admin_client_sockfd = -1;
}
/* If we want to block do not accept any incoming client connections */
if(is_blocking(lock_filename))
continue;
/* Create client if there is an incoming connection */
if((client_sockfd = wait_for_connection(server_sockfd)) < 0)
continue;
/* Connect to the remote host */
if((target_sockfd = open_remote_host(destination_address, destination_port)) < 0)
{
close(client_sockfd);
client_sockfd = -1;
continue;
}
/* Fork a new process for each incoming client */
status = fork();
if(status == 0)
{
printf("Connection from client\n");
close(server_sockfd);
close(admin_sockfd);
do_proxy(client_sockfd, target_sockfd);
abort();
}
else if(status == -1)
fprintf(stderr, "Error in forking process\n");
else
num_of_connections++;
/* Close the connections to the remote host and client */
close(client_sockfd);
client_sockfd = -1;
close(target_sockfd);
target_sockfd = -1;
}
return 0;
}
int
main (void)
{
int listen_sd;
int sock, ret;
struct sockaddr_in sa_serv;
struct sockaddr_in cli_addr;
socklen_t cli_addr_size;
gnutls_session_t session;
char buffer[MAX_BUFFER];
priv_data_st priv;
gnutls_datum_t cookie_key;
gnutls_dtls_prestate_st prestate;
int mtu = 1400;
unsigned char sequence[8];
/* this must be called once in the program
*/
gnutls_global_init ();
gnutls_certificate_allocate_credentials (&x509_cred);
gnutls_certificate_set_x509_trust_file (x509_cred, CAFILE,
GNUTLS_X509_FMT_PEM);
gnutls_certificate_set_x509_crl_file (x509_cred, CRLFILE,
GNUTLS_X509_FMT_PEM);
ret = gnutls_certificate_set_x509_key_file (x509_cred, CERTFILE, KEYFILE,
GNUTLS_X509_FMT_PEM);
if (ret < 0)
{
printf("No certificate or key were found\n");
exit(1);
}
generate_dh_params ();
gnutls_certificate_set_dh_params (x509_cred, dh_params);
gnutls_priority_init (&priority_cache,
"PERFORMANCE:-VERS-TLS-ALL:+VERS-DTLS1.0:%SERVER_PRECEDENCE",
NULL);
gnutls_key_generate (&cookie_key, GNUTLS_COOKIE_KEY_SIZE);
/* Socket operations
*/
listen_sd = socket (AF_INET, SOCK_DGRAM, 0);
memset (&sa_serv, '\0', sizeof (sa_serv));
sa_serv.sin_family = AF_INET;
sa_serv.sin_addr.s_addr = INADDR_ANY;
sa_serv.sin_port = htons (PORT);
{ /* DTLS requires the IP don't fragment (DF) bit to be set */
#if defined(IP_DONTFRAG)
int optval = 1;
setsockopt (listen_sd, IPPROTO_IP, IP_DONTFRAG,
(const void *) &optval, sizeof (optval));
#elif defined(IP_MTU_DISCOVER)
int optval = IP_PMTUDISC_DO;
setsockopt(listen_sd, IPPROTO_IP, IP_MTU_DISCOVER,
(const void*) &optval, sizeof (optval));
#endif
}
bind (listen_sd, (struct sockaddr *) &sa_serv, sizeof (sa_serv));
printf ("UDP server ready. Listening to port '%d'.\n\n", PORT);
for (;;)
{
printf ("Waiting for connection...\n");
sock = wait_for_connection (listen_sd);
if (sock < 0)
continue;
cli_addr_size = sizeof (cli_addr);
ret = recvfrom (sock, buffer, sizeof (buffer), MSG_PEEK,
(struct sockaddr *) &cli_addr, &cli_addr_size);
if (ret > 0)
{
memset (&prestate, 0, sizeof (prestate));
ret = gnutls_dtls_cookie_verify (&cookie_key, &cli_addr,
sizeof (cli_addr), buffer, ret,
&prestate);
if (ret < 0) /* cookie not valid */
{
priv_data_st s;
memset (&s, 0, sizeof (s));
s.fd = sock;
s.cli_addr = (void *) &cli_addr;
s.cli_addr_size = sizeof (cli_addr);
printf ("Sending hello verify request to %s\n",
human_addr ((struct sockaddr *) &cli_addr,
sizeof (cli_addr), buffer,
sizeof (buffer)));
gnutls_dtls_cookie_send (&cookie_key, &cli_addr,
sizeof (cli_addr), &prestate,
(gnutls_transport_ptr_t) & s,
push_func);
/* discard peeked data */
recvfrom (sock, buffer, sizeof (buffer), 0,
(struct sockaddr *) &cli_addr, &cli_addr_size);
usleep (100);
continue;
}
printf ("Accepted connection from %s\n",
human_addr ((struct sockaddr *)
&cli_addr, sizeof (cli_addr), buffer,
sizeof (buffer)));
}
else
continue;
session = initialize_tls_session ();
gnutls_dtls_prestate_set (session, &prestate);
gnutls_dtls_set_mtu (session, mtu);
priv.session = session;
priv.fd = sock;
priv.cli_addr = (struct sockaddr *) &cli_addr;
priv.cli_addr_size = sizeof (cli_addr);
gnutls_transport_set_ptr (session, &priv);
gnutls_transport_set_push_function (session, push_func);
gnutls_transport_set_pull_function (session, pull_func);
gnutls_transport_set_pull_timeout_function (session, pull_timeout_func);
do
{
ret = gnutls_handshake (session);
}
while (ret < 0 && gnutls_error_is_fatal (ret) == 0);
if (ret < 0)
{
fprintf (stderr, "Error in handshake(): %s\n",
gnutls_strerror (ret));
gnutls_deinit (session);
continue;
}
printf ("- Handshake was completed\n");
for (;;)
{
do
{
ret = gnutls_record_recv_seq (session, buffer, MAX_BUFFER,
sequence);
}
while (ret == GNUTLS_E_AGAIN || ret == GNUTLS_E_INTERRUPTED);
if (ret < 0)
{
fprintf (stderr, "Error in recv(): %s\n",
gnutls_strerror (ret));
break;
}
if (ret == 0)
{
printf ("EOF\n\n");
break;
}
buffer[ret] = 0;
printf ("received[%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x]: %s\n",
sequence[0], sequence[1], sequence[2], sequence[3],
sequence[4], sequence[5], sequence[6], sequence[7], buffer);
/* reply back */
ret = gnutls_record_send (session, buffer, ret);
if (ret < 0)
{
fprintf (stderr, "Error in send(): %s\n",
gnutls_strerror (ret));
break;
}
}
gnutls_bye (session, GNUTLS_SHUT_WR);
gnutls_deinit (session);
}
close (listen_sd);
gnutls_certificate_free_credentials (x509_cred);
gnutls_priority_deinit (priority_cache);
gnutls_global_deinit ();
return 0;
}
/*
* Never returns.
*/
void main_loop(int sockfd) {
while (1)
{
int clientfd = wait_for_connection(sockfd);
INFO("main_loop(): New client. clientfd: %d\n", clientfd);
if (clientfd == -1)
{
ERROR("main_loop(): error occurred in wait_for_connection");
continue;
}
int cont = 1;
while (cont)
{
INFO("main_loop(): Waiting for message...\n");
controller_msg_hdr_t hdr;
if (recv_msg_hdr(clientfd, &hdr) == -1)
{
ERROR("main_loop(): Error occurred in recv_msg_hdr()\n");
cont = 0;
break;
}
INFO("main_loop(): Servicing message of type %s\n", msg_type_to_string(hdr.type));
switch (hdr.type)
{
case CTRL_MSG_JSON:
{
if (hdr.len > MAX_JSON_MSG_LEN)
{
WARN("main_loop(): JSON message may be excessively large.\n");
}
char * json_msg = ALLOC(char, hdr.len);
if (recv_msg_string(clientfd, json_msg, hdr.len) == -1)
{
ERROR("main_loop(): Error occurred in recv_msg_string()\n");
free(json_msg);
cont = 0;
break;
}
json_msg[hdr.len - 1] = '\0';
INFO("main_loop(): JSON Message received. Contents:\n%s\n", json_msg);
char * return_msg = handle_msg(json_msg);
INFO("main_loop(): Replying to client with message: \n%s\n", return_msg);
if (send_msg_hdr(clientfd, CTRL_MSG_JSON, strlen(return_msg) + 1) != -1)
{
if (send_msg_string(clientfd, return_msg) != -1)
{
}
else
{
ERROR("send_msg_string() failed, terminating communication with client...\n");
cont = 0;
}
}
else
{
ERROR("send_msg_hdr() failed, terminating communication with client...\n");
cont = 0;
}
free(return_msg);
free(json_msg);
break;
}
case CTRL_MSG_REPLY:
{
WARN("main_loop(): Received CTRL_MSG_REPLY... ignoring message\n");
break;
}
case CTRL_MSG_EXIT:
{
INFO("main_loop(): Received CTRL_MSG_EXIT\n");
cont = 0;
break;
}
case CTRL_MSG_ERROR:
{
ERROR("main_loop(): Received CTRL_MSG_ERROR\n");
cont = 0;
break;
}
default:
{
ERROR("main_loop(): Message of unknown type was received. Terminating communication..\n");
cont = 0;
break;
}
}
}
INFO("main_loop(): Breaking connection with client...\n");
close_socket(clientfd);
}
}
int main(int argc, char *argv[], char *dummy[])
{
ushort tcp_port = 4711;
struct srv_info sinfo;
uint cmd;
uint max_msglen;
struct sockaddr_in srv_addr;
int lstn_sd, peer_sd;
int srv_id = 0, srv_cnt = 0;;
own_node_addr = own_node();
memset(&sinfo, 0, sizeof(sinfo));
if (signal(SIGALRM, sig_alarm) == SIG_ERR)
die("Server master: can't catch alarm signals\n");
printf("****** TIPC Benchmark Server Started ******\n");
/* Create socket for communication with master: */
reset:
master_sd = socket(AF_TIPC, SOCK_RDM, 0);
if (master_sd < 0)
die("Server: Can't create socket to master\n");
if (bind(master_sd, (struct sockaddr *)&srv_ctrl_addr,
sizeof(srv_ctrl_addr)))
die("Server: Failed to bind to master socket\n");
/* Wait for command from master: */
srv_from_master(&cmd, &max_msglen, 0, 0);
buf = malloc(max_msglen);
if (!buf)
die("Failed to create buffer of size %u\n", ntohl(max_msglen));
/* Create TIPC or TCP listening socket: */
if (cmd == TIPC_CONN) {
lstn_sd = socket (AF_TIPC, SOCK_STREAM,0);
if (lstn_sd < 0)
die("Server master: can't create listening socket\n");
if (bind(lstn_sd, (struct sockaddr *)&srv_lstn_addr,
sizeof(srv_lstn_addr)) < 0)
die("TIPC Server master: failed to bind port name\n");
printf("****** TIPC Listener Socket Created ******\n");
srv_to_master(SRV_INFO, 0);
close(master_sd);
} else if (cmd == TCP_CONN) {
if ((lstn_sd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
die("TCP Server: failed to create listener socket");
/* Construct listener address structure */
memset(&srv_addr, 0, sizeof(srv_addr));
srv_addr.sin_family = AF_INET;
srv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
srv_addr.sin_port = htons(tcp_port);
/* Bind socket to address */
while (0 > bind(lstn_sd, (struct sockaddr *) &srv_addr,
sizeof(srv_addr)))
srv_addr.sin_port = htons(++tcp_port);
/* Inform master about own IP addresses and listener port number */
get_ip_list(&sinfo, NULL);
sinfo.tcp_port = htons(tcp_port);
printf("****** TCP Listener Socket Created ******\n");
srv_to_master(SRV_INFO, &sinfo);
close(master_sd);
} else {
close(master_sd);
goto reset;
}
/* Listen for incoming connections */
if (listen(lstn_sd, 32) < 0)
die("Server: listen() failed");
while (1) {
if (waitpid(-1, NULL, WNOHANG) > 0) {
if (--srv_cnt)
continue;
close(lstn_sd);
printf("****** Listener Socket Deleted ******\n");
goto reset;
}
peer_sd = wait_for_connection(lstn_sd);
if (!peer_sd)
continue;
srv_id++;
srv_cnt++;
if (fork()) {
close(peer_sd);
continue;
}
/* Continue in child process */
close(lstn_sd);
dprintf("calling echo: peer_sd: %u, srv_cnt = %u\n",peer_sd, srv_cnt);
master_sd = socket(AF_TIPC, SOCK_RDM, 0);
if (master_sd < 0)
die("Server: Can't create socket to master\n");
if (bind(master_sd, (struct sockaddr *)&srv_ctrl_addr,
sizeof(srv_ctrl_addr)))
die("Server: Failed to bind to master socket\n");
echo_messages(peer_sd, master_sd, srv_id);
}
close(lstn_sd);
printf("****** TIPC Benchmark Server Finished ******\n");
exit(0);
return 0;
}
void
start_server(krb5_context context, const char *port_str)
{
int e;
struct kadm_port *p;
krb5_socket_t *socks = NULL, *tmp;
unsigned int num_socks = 0;
int i;
if (port_str == NULL)
port_str = "+";
parse_ports(context, port_str);
for(p = kadm_ports; p; p = p->next) {
struct addrinfo hints, *ai, *ap;
char portstr[32];
memset (&hints, 0, sizeof(hints));
hints.ai_flags = AI_PASSIVE;
hints.ai_socktype = SOCK_STREAM;
e = getaddrinfo(NULL, p->port, &hints, &ai);
if(e) {
snprintf(portstr, sizeof(portstr), "%u", p->def_port);
e = getaddrinfo(NULL, portstr, &hints, &ai);
}
if(e) {
krb5_warn(context, krb5_eai_to_heim_errno(e, errno),
"%s", portstr);
continue;
}
i = 0;
for(ap = ai; ap; ap = ap->ai_next)
i++;
tmp = realloc(socks, (num_socks + i) * sizeof(*socks));
if(tmp == NULL) {
krb5_warnx(context, "failed to reallocate %lu bytes",
(unsigned long)(num_socks + i) * sizeof(*socks));
continue;
}
socks = tmp;
for(ap = ai; ap; ap = ap->ai_next) {
krb5_socket_t s = socket(ap->ai_family, ap->ai_socktype, ap->ai_protocol);
if(rk_IS_BAD_SOCKET(s)) {
krb5_warn(context, rk_SOCK_ERRNO, "socket");
continue;
}
socket_set_reuseaddr(s, 1);
socket_set_ipv6only(s, 1);
if (rk_IS_SOCKET_ERROR(bind (s, ap->ai_addr, ap->ai_addrlen))) {
krb5_warn(context, rk_SOCK_ERRNO, "bind");
rk_closesocket(s);
continue;
}
if (rk_IS_SOCKET_ERROR(listen (s, SOMAXCONN))) {
krb5_warn(context, rk_SOCK_ERRNO, "listen");
rk_closesocket(s);
continue;
}
socks[num_socks++] = s;
}
freeaddrinfo (ai);
}
if(num_socks == 0)
krb5_errx(context, 1, "no sockets to listen to - exiting");
wait_for_connection(context, socks, num_socks);
}
/*********************************************************************************************
* appMain()
*
*
*
*********************************************************************************************/
void
appMain()
{
uint8 err, i,count;
#ifdef FIRST_TIME_RUN //this is temporary arrangement.
Ist_run_config(); //FIRST_TIME_CONNECTION_SETTING_PROFILES
#endif
wait_for_connection();
err= open_txPort_Mgr();
if(err)
{
//fatal error , failed to open socket with mgr.
// restart .
fatal();
}
err= open_rxPort_Mgr();
if(err)
{
//fatal error , failed to open socket with mgr.
// restart .
fatal();
}
err= setsockopt_rcv_timeout( 10000 );
if(err){
fatal();
}
for( i=15; i>0;i--)
{
if(i>10)
count = 20;
else
count = 1*i;
toggleLed(SYSLED1);
while(count--)
__delay_cycles( 400000);
//turnLedOn(SYSLED1);
//__delay_cycles( 30000000);
}
turnLedOn(SYSLED1);
__delay_cycles(62000000);
test_send_data_to(2);
// register_Me();
//TODO: this need to be substituted with registration related functions, which will be probably triggered on button press.
//Infinite loop.
while(1) {
turnLedOff(SYSLED1);
#ifdef TEST_SOCKET_RECEIVE
test_rcv_data();
#else
Execute_Mgr_Cmd();
#endif
turnLedOn(SYSLED1);
__delay_cycles(22000000);
}
// return;
}
