void
handle_signal(int signum)
{
if (signum) {
fprintf(stderr,
"WARNING: stopping proxy service [signal %i: %s]\n",
signum, strsignal(signum));
}
/* Attempt to disconnect from everything */
if (session_data.conn >= 0) {
destroy_socket(session_data.conn);
}
if (session_data.ssock >= 0) {
destroy_socket(session_data.ssock);
}
if (session_data.csock >= 0) {
destroy_socket(session_data.csock);
}
/* Clear the internal buffer */
memset(session_data.buffer, '\0', MAX_COMMAND_LENGTH);
/* Re-raise the proper termination signals */
if (sigismember(&session_data.termination_signals, signum)) {
sigemptyset(&session_data.signal_action.sa_mask);
session_data.signal_action.sa_handler = SIG_DFL;
sigaction(signum, &session_data.signal_action, NULL);
raise(signum);
}
}
void
handle_signal(int signum)
{
int i;
putchar('\n');
if (signum) {
fprintf(stderr,
"WARNING: signal caught [code %i: %s]\n",
signum, strsignal(signum));
}
/* Perform a graceful shutdown of the system */
session_data.caught_signal = signum;
/* Send SIGTERM to every worker */
for (i = 0; i < MAX_CONNECTIONS; ++i) {
if (session_data.thread_data[i].id != (pthread_t)(BANKING_FAILURE)) {
#ifndef NDEBUG
fprintf(stderr, "INFO: sending kill signal to worker thread\n");
#endif
pthread_kill(session_data.thread_data[i].id, SIGUSR1);
}
}
/* Now collect them */
for (i = 0; i < MAX_CONNECTIONS; ++i) {
if (session_data.thread_data[i].id != (pthread_t)(BANKING_FAILURE)) {
if (pthread_join(session_data.thread_data[i].id, NULL)) {
session_data.thread_data[i].id = (pthread_t)(BANKING_FAILURE);
fprintf(stderr, "ERROR: failed to collect worker thread\n");
} else {
session_data.thread_data[i].id = (pthread_t)(BANKING_SUCCESS);
#ifndef NDEBUG
fprintf(stderr, "INFO: collected worker thread\n");
#endif
}
}
}
/* Do remaining housekeeping */
gcry_pthread_mutex_destroy((void **)(&session_data.accept_mutex));
gcry_pthread_mutex_destroy((void **)(&session_data.keystore_mutex));
destroy_socket(session_data.sock);
/* TODO remove shared memory code */
shutdown_crypto(old_shmid(&i));
if (shmctl(i, IPC_RMID, NULL)) {
fprintf(stderr, "WARNING: unable to remove shared memory segment\n");
}
destroy_db(BANKING_DB_FILE, session_data.db_conn);
/* Re-raise proper signals */
if (signum == SIGINT || signum == SIGTERM) {
sigemptyset(&session_data.signal_action.sa_mask);
session_data.signal_action.sa_handler = SIG_DFL;
sigaction(signum, &session_data.signal_action, NULL);
raise(signum);
}
}
void shutdown_socket(int unused __attribute__((__unused__))) {
sock_deallocated = 1;
if (sock) {
printf("Closing connection gracefully...\n");
close_connection(sock);
sleep(3);
destroy_socket(sock);
exit(0);
}
}
void us_mfa::shutdown() {
for (ifid_socket_map::iterator i = m_ifid_socket.begin(); i != m_ifid_socket.end(); i++) {
raw_socket *sock = i->second;
m_ifid_socket.erase(i);
destroy_socket(sock);
delete sock;
}
g_mrd->register_source_discovery("data-plane", 0);
}
int main(int argc, char *argv[])
{
SOCKET sock = create_socket();
if (sock != INVALID_SOCKET)
{
if (connect_socket(&sock, IP_ADDR, PORT_NO, 10))
{
char buffer[256] = {0};
int n;
keyboard_read("Please enter the message: ", buffer, 255);
n = send_socket(&sock, buffer, strlen(buffer));
if (n >= 0)
{
memset((void*) buffer, 0, 256);
n = recv_socket(&sock, buffer, 256);
if (n >= 0)
{
printf("%s\n", buffer);
}
else
{
puts("ERROR reading from socket");
}
}
else
{
puts("ERROR writing to socket");
}
}
else
{
puts("ERROR connecting");
}
disconnect_socket(&sock);
}
else
{
puts("ERROR opening socket");
}
destroy_socket(&sock);
return 0;
}
void zmq::socket_base_t::check_destroy ()
{
// If the object was already marked as destroyed, finish the deallocation.
if (destroyed) {
// Remove the socket from the reaper's poller.
poller->rm_fd (handle);
// Remove the socket from the context.
destroy_socket (this);
// Notify the reaper about the fact.
send_reaped ();
// Deallocate.
own_t::process_destroy ();
}
}
int main(int argc, char *argv[])
{
SOCKET sockfd = create_socket();
if (sockfd != INVALID_SOCKET)
{
if (bind_socket(&sockfd, PORT_NO, 10))
{
SOCKET sockets[MAX_SOCKETS] = {INVALID_SOCKET};
int opened_sockets = 0;
while (1)
{
int idx, max;
if (opened_sockets < MAX_SOCKETS)
{
SOCKET new_sockfd = wait_connection(&sockfd);
if (new_sockfd != INVALID_SOCKET)
{
sockets[opened_sockets++] = new_sockfd;
}
else if (WSAGetLastError() != WSAETIMEDOUT)
{
//printf("ERROR waiting\n");
}
}
for (idx = 0, max = opened_sockets; idx < max; idx++)
{
if (sockets[idx] != INVALID_SOCKET)
{
if (do_processing(&sockets[idx]) < 0)
{
printf("Disconnecting...\n");
disconnect_socket(&sockets[idx]);
sockets[idx] = sockets[opened_sockets-1];
sockets[opened_sockets-1] = INVALID_SOCKET;
opened_sockets--;
}
}
}
}
}
else
{
perror("ERROR binding");
}
disconnect_socket(&sockfd);
}
else
{
perror("ERROR opening socket");
}
destroy_socket(&sockfd);
return 0;
}
void *
handle_client(void * arg)
{
struct thread_data_t * datum = (struct thread_data_t *)(arg);
/* Fetch the ID from the argument */
#ifndef NDEBUG
fprintf(stderr, "[thread %lu] INFO: worker started\n", datum->id);
#endif
/* Worker thread signal handling is unique */
sigaction(SIGUSR1, datum->signal_action, NULL);
sigaction(SIGUSR2, datum->signal_action, NULL);
/* As long as possible, grab up whatever connection is available */
while (!session_data.caught_signal && !datum->caught_signal) {
/* Ensure only one worker accepts the next client */
gcry_pthread_mutex_lock((void **)(&session_data.accept_mutex));
datum->sock = accept(session_data.sock,
(struct sockaddr *)(&datum->remote_addr),
&datum->remote_addr_len);
gcry_pthread_mutex_unlock((void **)(&session_data.accept_mutex));
if (datum->sock >= 0) {
#ifndef NDEBUG
fprintf(stderr,
"[thread %lu] INFO: worker connected to client\n",
datum->id);
#endif
/* Receive a "hello" message from the client */
recv_message(&datum->buffet, datum->sock);
/* Decrypt it with the default key */
decrypt_message(&datum->buffet, keystore.key);
/* Verify it is an authentication request */
if (strncmp(datum->buffet.tbuffer,
AUTH_CHECK_MSG, sizeof(AUTH_CHECK_MSG))) {
/* Respond with nonce (misdirection) */
gcry_create_nonce(datum->buffet.pbuffer, MAX_COMMAND_LENGTH);
encrypt_message(&datum->buffet, keystore.key);
send_message(&datum->buffet, datum->sock);
} else {
/* Request a session key */
gcry_pthread_mutex_lock((void **)(&session_data.keystore_mutex));
#ifndef NDEBUG
print_keystore(stderr, "before request");
#endif
request_key(&datum->credentials.key);
#ifndef NDEBUG
print_keystore(stderr, "after request");
#endif
gcry_pthread_mutex_unlock((void **)(&session_data.keystore_mutex));
/* Encrypted it using the default key */
salt_and_pepper((char *)(datum->credentials.key), NULL,
&datum->buffet);
encrypt_message(&datum->buffet, keystore.key);
send_message(&datum->buffet, datum->sock);
clear_buffet(&datum->buffet);
/* Repeatedly poll for message streams */
while (handle_stream(datum) == BANKING_SUCCESS);
/* Revoke the session key */
gcry_pthread_mutex_lock((void **)(&session_data.keystore_mutex));
#ifndef NDEBUG
print_keystore(stderr, "before revoke");
#endif
revoke_key(&datum->credentials.key);
#ifndef NDEBUG
print_keystore(stderr, "after revoke");
#endif
gcry_pthread_mutex_unlock((void **)(&session_data.keystore_mutex));
}
/* Cleanup (disconnect) */
#ifndef NDEBUG
fprintf(stderr,
"[thread %lu] INFO: worker disconnected from client\n",
datum->id);
#endif
clear_buffet(&datum->buffet);
destroy_socket(datum->sock);
datum->sock = BANKING_FAILURE;
} else {
fprintf(stderr,
"[thread %lu] ERROR: worker unable to connect\n",
datum->id);
}
}
/* Teardown */
handle_interruption(0);
return NULL;
}
static int destory_outstream_handle_http(struct cdx_stream_info *stm_info)
{
destroy_socket(stm_info->fd_desc.fd);
return 0;
}
int
main(int argc, char ** argv)
{
ssize_t received, sent, bytes;
struct sigaction old_signal_action;
/* Input sanitation */
if (argc != 3) {
fprintf(stderr, "USAGE: %s listen_port bank_port\n", argv[0]);
return EXIT_FAILURE;
}
/* Capture SIGINT and SIGTERM */
memset(&session_data.signal_action, '\0', sizeof(struct sigaction));
sigfillset(&session_data.signal_action.sa_mask);
session_data.signal_action.sa_handler = &handle_signal;
sigemptyset(&session_data.termination_signals);
sigaction(SIGINT, NULL, &old_signal_action);
if (old_signal_action.sa_handler != SIG_IGN) {
sigaction(SIGINT, &session_data.signal_action, NULL);
sigaddset(&session_data.termination_signals, SIGINT);
}
sigaction(SIGTERM, NULL, &old_signal_action);
if (old_signal_action.sa_handler != SIG_IGN) {
sigaction(SIGTERM, &session_data.signal_action, NULL);
sigaddset(&session_data.termination_signals, SIGTERM);
}
/* Socket initialization */
if ((session_data.csock = init_client_socket(argv[2])) < 0) {
fprintf(stderr, "ERROR: unable to connect to server\n");
return EXIT_FAILURE;
}
if ((session_data.ssock = init_server_socket(argv[1])) < 0) {
fprintf(stderr, "ERROR: unable to start server\n");
destroy_socket(session_data.csock);
return EXIT_FAILURE;
}
/* Provide a dumb echo tunnel service TODO send/recv threads */
while (!handle_connection(session_data.ssock, &session_data.conn)) {
session_data.mode = A2B;
session_data.count = 0;
while (!handle_relay(&received, &sent)) {
/* Report leaky transmissions */
if (sent != received) {
bytes = sent - received;
if (bytes < 0) {
bytes = -bytes;
}
fprintf(stderr, "ERROR: %li byte(s) lost\n", (long)(bytes));
}
/* NOTE: modality is swapped after relay */
if (session_data.mode == A2B) {
fprintf(stderr,
"INFO: server sent message [id: %08i]\n",
session_data.count);
}
if (session_data.mode == B2A) {
fprintf(stderr,
"INFO: client sent message [id: %08i]\n",
session_data.count);
}
#ifndef NDEBUG
/* Report entire transmission */
hexdump(stderr, session_data.buffer, MAX_COMMAND_LENGTH);
#endif
}
time(&session_data.terminated);
fprintf(stderr, "INFO: tunnel closed [%i msg / %li sec]\n",
session_data.count,
(long)(session_data.terminated - session_data.established));
/* Disconnect from defunct clients */
destroy_socket(session_data.conn);
/* Re-establish with the server TODO should this be necessary? */
destroy_socket(session_data.csock);
session_data.csock = init_client_socket(argv[2]);
}
/* Teardown */
handle_signal(0);
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
WSADATA wsaData;
// Initialize Winsock
int iResult = WSAStartup(MAKEWORD(2,2), &wsaData);
if (iResult != 0) {
printf("WSAStartup failed with error: %d\n", iResult);
return 1;
}
SOCKET sockfd = create_socket();
if (sockfd != INVALID_SOCKET)
{
if (bind_socket(&sockfd, PORT_NO, 10))
{
SOCKET sockets[MAX_SOCKETS] = {INVALID_SOCKET};
int opened_sockets = 0;
while (1)
{
int idx, max;
if (opened_sockets < MAX_SOCKETS)
{
SOCKET new_sockfd = wait_connection(&sockfd);
if (new_sockfd != INVALID_SOCKET)
{
sockets[opened_sockets++] = new_sockfd;
}
//else if (errno != WSAETIMEDOUT)
{
//puts("ERROR waiting");
}
}
for (idx = 0, max = opened_sockets; idx < max; idx++)
{
if (sockets[idx] != INVALID_SOCKET)
{
if (do_processing(&sockets[idx])==-1)
{
if (errno != WSAETIMEDOUT)
{
printf("Disconnecting...\n");
disconnect_socket(&sockets[idx]);
sockets[idx] = sockets[opened_sockets-1];
sockets[opened_sockets-1] = INVALID_SOCKET;
opened_sockets--;
}
}
}
}
}
}
else
{
printf("ERROR binding\n");
}
disconnect_socket(&sockfd);
}
else
{
printf("ERROR opening socket\n");
}
destroy_socket(&sockfd);
return 0;
}
int main(int argc, char *argv[])
{
SOCKET sock = create_socket(), sockets[MAX_CLIENT] = {INVALID_SOCKET};
int num_clients = 0;
//cria e conecta o socket
if(sock != INVALID_SOCKET)
{
if(bind_socket(&sock, PORT_NO) == SOCKET_ERROR)
{
printf("ERROR binding\n");
exit(1);
}
else
{
listen(sock, MAX_CLIENT);
printf("Servidor iniciado.\n");
}
}
else
{
printf("ERROR opening socket");
exit(1);
}
//aceita conexões
puts("Esperando por conexoes...");
while (1)
{
int i, max;
if (num_clients < MAX_CLIENT)
{
SOCKET new_sockfd = wait_connection(&sock);
if(new_sockfd != INVALID_SOCKET)
{
sockets[num_clients++] = new_sockfd;
}
else if (WSAGetLastError() != WSAETIMEDOUT)
{
printf("ERROR waiting\n");
}
}
for (i = 0, max = num_clients; i < max; i++)
{
if (sockets[i] != INVALID_SOCKET)
{
if (!do_processing(&sockets[i]))
{
if (WSAGetLastError() != WSAETIMEDOUT)
{
printf("Disconnecting...\n");
disconnect_socket(&sockets[i]);
sockets[i] = sockets[num_clients-1];
sockets[num_clients-1] = INVALID_SOCKET;
num_clients--;
}
}
}
}
}
disconnect_socket(&sock);
destroy_socket(&sock);
return 0;
}
