static gpointer
server_thread (gpointer user_data)
{
int listener = GPOINTER_TO_INT (user_data), client;
gnutls_certificate_credentials creds;
gnutls_session_t session;
struct sockaddr_in sin;
int len;
char buf[BUFSIZE];
int status;
gnutls_certificate_allocate_credentials (&creds);
if (gnutls_certificate_set_x509_key_file (creds,
ssl_cert_file, ssl_key_file,
GNUTLS_X509_FMT_PEM) != 0) {
g_error ("Failed to set SSL certificate and key files "
"(%s, %s).", ssl_cert_file, ssl_key_file);
}
gnutls_certificate_set_dh_params (creds, dh_params);
/* Create a new session */
gnutls_init (&session, GNUTLS_SERVER);
gnutls_set_default_priority (session);
gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, creds);
gnutls_dh_set_prime_bits (session, DH_BITS);
/* Wait for client thread to connect */
len = sizeof (sin);
client = accept (listener, (struct sockaddr *) &sin, (void *)&len);
gnutls_transport_set_ptr (session, GINT_TO_POINTER (client));
/* Initial handshake */
status = gnutls_handshake (session);
if (status < 0)
g_error ("initial handshake failed: %d", status);
/* Synchronous client test. */
server_read (session, buf, BUFSIZE);
server_write (session, buf, BUFSIZE);
/* Async client test. */
server_read (session, buf, BUFSIZE);
server_write (session, buf, BUFSIZE);
/* That's all, folks. */
gnutls_bye (session, GNUTLS_SHUT_WR);
gnutls_deinit (session);
close (client);
gnutls_certificate_free_credentials (creds);
return NULL;
}
void signal_user1(int sig) {
signal(SIGUSR1, signal_user1);
sig = sig;
context();
ioutput(OUTPUT_DEST_LOG | OUTPUT_DEST_NO | OUTPUT_TYPE_DEBUG, "changing servers");
server_write((char *) "QUIT :changing servers", SERVER_SEND_NOW);
FD_CLR(g.serversocket, &g.readset);
close(g.serversocket);
module_serverquit();
g.serverstatus = SERVER_STATUS_NOTCONNECTED;
return;
}
void server_ready(struct connection *self, uint32_t mask)
{
struct conn_info *info = self->info;
if (mask & E_ERROR) {
LOG(ERROR, "server error: %s:%d %d", info->addr.ip, info->addr.port, self->fd);
server_eof(self, rep_err);
return;
}
if (mask & E_WRITABLE) {
LOG(DEBUG, "server writable");
if (info->status == CONNECTING) info->status = CONNECTED;
if (info->status == CONNECTED) {
if (server_write(self) == CORVUS_ERR) {
server_eof(self, rep_err);
return;
}
} else {
LOG(ERROR, "server not connected");
server_eof(self, rep_err);
return;
}
}
if (mask & E_READABLE) {
LOG(DEBUG, "server readable");
if (!STAILQ_EMPTY(&info->waiting_queue)) {
switch (server_read(self)) {
case CORVUS_ERR:
case CORVUS_EOF:
server_eof(self, rep_err);
return;
}
} else {
LOG(WARN, "server is readable but waiting_queue is empty");
server_eof(self, rep_err);
return;
}
}
}
void server_puts (const char *str)
{
server_write ((const uint8_t *)str, strlen(str));
}
void server_putc (uint8_t b)
{
server_write (&b, 1);
}
