* keepalived-1.1.10 released.
* VRRP : While restoring interface, release iproutes
before ipaddresses. Routing daemons needs that order
for netlink reflection channel.
* VRRP : Bin Guo, <bguo@bluesocket.com> fixed a memory
leak while calling script_open.
* Kevin Lindsay, <kevinl@netnation.com> fixed some buffer
overruns, NULL pointer and dangling pointer references.
* Kevin Lindsay, <kevinl@netnation.com> redisigned signal
handling. When a signal occurs, a global signal_mask is
modified. In the main loop there is a checked to see if
the signal_mask has any pending signals. The appropriate
signal handler is then run at this time. This is to prevent
races when modifying linked lists.
* Kevin Lindsay, <kevinl@netnation.com> fixed shadowed
declarations.
* Christophe Varoqui, <Christophe.Varoqui@free.fr> and I
Extended libipvs-2.6 to support syncd zombies handling.
Since ip_vs_sync.c kernel code no longer handle waitpid()
we fork a child before any ipvs syncd operation in order
to workaround zombies generation.
* John Ferlito, <johnf@inodes.org> and I Fixed a scheduling
race condition while working with low timers.
* Updated check_http and check_ssl to use non-blocking
socket.
* Fixed some race conditions while reloading configuration.
Prevent against list gardening if list is empty !
* Fixed recursive configuration parsing function to be clean
with stack. Only one recursion level.
* Some cosmetics cleanup in Makefiles.
Chris Caputo, <ccaputo@alt.net> :
o Added dont_track_primary, nopreempt,
preempt_delay, and misc_dynamic.
+
+Kevin Lindsay, <kevinl@netnation.com> :
+ o Fixed shadowed declaration reported by -Wshadow.
+ o Redesigned signal handling.
+2005-02-15 Alexandre Cassen <acassen@linux-vs.org>
+ * keepalived-1.1.10 released.
+ * VRRP : While restoring interface, release iproutes
+ before ipaddresses. Routing daemons needs that order
+ for netlink reflection channel.
+ * VRRP : Bin Guo, <bguo@bluesocket.com> fixed a memory
+ leak while calling script_open.
+ * Kevin Lindsay, <kevinl@netnation.com> fixed some buffer
+ overruns, NULL pointer and dangling pointer references.
+ * Kevin Lindsay, <kevinl@netnation.com> redisigned signal
+ handling. When a signal occurs, a global signal_mask is
+ modified. In the main loop there is a checked to see if
+ the signal_mask has any pending signals. The appropriate
+ signal handler is then run at this time. This is to prevent
+ races when modifying linked lists.
+ * Kevin Lindsay, <kevinl@netnation.com> fixed shadowed
+ declarations.
+ * Christophe Varoqui, <Christophe.Varoqui@free.fr> and I
+ Extended libipvs-2.6 to support syncd zombies handling.
+ Since ip_vs_sync.c kernel code no longer handle waitpid()
+ we fork a child before any ipvs syncd operation in order
+ to workaround zombies generation.
+ * John Ferlito, <johnf@inodes.org> and I Fixed a scheduling
+ race condition while working with low timers.
+ * Updated check_http and check_ssl to use non-blocking
+ socket.
+ * Fixed some race conditions while reloading configuration.
+ Prevent against list gardening if list is empty !
+ * Fixed recursive configuration parsing function to be clean
+ with stack. Only one recursion level.
+ * Some cosmetics cleanup in Makefiles.
+
2005-02-07 Alexandre Cassen <acassen@linux-vs.org>
* keepalived-1.1.9 released.
* VRRP : Chris Caputo, <ccaputo@alt.net> updated keepalived manpage
+keepalived (1.1.10) unstable; urgency=low
+
+ * Cf ChangeLog
+
+ -- Alexandre Cassen <acassen@linux-vs.org> Tue, 14 Feb 2005 22:15:23 +0200
+
keepalived (1.1.9) unstable; urgency=low
* Cf ChangeLog
OBJS = main.o sock.o layer4.o http.o ssl.o
LIB_OBJS = ../lib/timer.o ../lib/scheduler.o \
../lib/memory.o ../lib/list.o ../lib/utils.o \
- ../lib/html.o
+ ../lib/html.o ../lib/signals.o
all: $(BIN)/$(EXEC)
strip $(BIN)/$(EXEC)
@echo "Make complete"
$(BIN)/$(EXEC): $(LIB_OBJS) $(OBJS)
- $(CC) $(LIB_OBJS) $(OBJS) -o $(BIN)/$(EXEC) $(LDFLAGS)
+ @set -e; \
+ echo "Building $(BIN)/$(EXEC)" && \
+ $(CC) -o $(BIN)/$(EXEC) $(LIB_OBJS) $(OBJS) $(LDFLAGS)
clean:
rm -f core *.o
/* free allocated pieces */
static void
-free_all(thread * thread)
+free_all(thread * thread_obj)
{
- SOCK *sock = THREAD_ARG(thread);
+ SOCK *sock_obj = THREAD_ARG(thread_obj);
DBG("Total read size read = %d Bytes, fd:%d\n",
- sock->total_size, sock->fd);
+ sock_obj->total_size, sock_obj->fd);
- if (sock->buffer)
- FREE(sock->buffer);
+ if (sock_obj->buffer)
+ FREE(sock_obj->buffer);
/*
* Decrement the current global get number.
* => free the reserved thread
*/
req->response_time = timer_tol(timer_now());
- thread_add_terminate_event(thread->master);
+ thread_add_terminate_event(thread_obj->master);
}
/* Simple epilog functions. */
int
-epilog(thread * thread)
+epilog(thread * thread_obj)
{
DBG("Timeout on URL : [%s]\n", req->url);
- free_all(thread);
+ free_all(thread_obj);
return 0;
}
/* Simple finalization function */
int
-finalize(thread * thread)
+finalize(thread * thread_obj)
{
- SOCK *sock = THREAD_ARG(thread);
+ SOCK *sock_obj = THREAD_ARG(thread_obj);
unsigned char digest[16];
int i;
/* Compute final MD5 digest */
- MD5_Final(digest, &sock->context);
+ MD5_Final(digest, &sock_obj->context);
if (req->verbose) {
printf("\n");
printf(HTML_MD5);
printf("\n\n");
DBG("Finalize : [%s]\n", req->url);
- free_all(thread);
+ free_all(thread_obj);
return 0;
}
/* Process incoming stream */
int
-http_process_stream(SOCK * sock, int r)
+http_process_stream(SOCK * sock_obj, int r)
{
- sock->size += r;
- sock->total_size += r;
+ sock_obj->size += r;
+ sock_obj->total_size += r;
- if (!sock->extracted) {
+ if (!sock_obj->extracted) {
if (req->verbose)
printf(HTTP_HEADER_HEXA);
- if ((sock->extracted = extract_html(sock->buffer, sock->size))) {
+ if ((sock_obj->extracted = extract_html(sock_obj->buffer, sock_obj->size))) {
if (req->verbose)
- http_dump_header(sock->buffer,
- sock->extracted - sock->buffer);
- r = sock->size - (sock->extracted - sock->buffer);
+ http_dump_header(sock_obj->buffer,
+ sock_obj->extracted - sock_obj->buffer);
+ r = sock_obj->size - (sock_obj->extracted - sock_obj->buffer);
if (r) {
if (req->verbose) {
printf(HTML_HEADER_HEXA);
- dump_buffer(sock->extracted, r);
+ dump_buffer(sock_obj->extracted, r);
}
- memmove(sock->buffer, sock->extracted, r);
- MD5_Update(&sock->context, sock->buffer, r);
+ memmove(sock_obj->buffer, sock_obj->extracted, r);
+ MD5_Update(&sock_obj->context, sock_obj->buffer, r);
r = 0;
}
- sock->size = r;
+ sock_obj->size = r;
} else {
if (req->verbose)
- http_dump_header(sock->buffer, sock->size);
+ http_dump_header(sock_obj->buffer, sock_obj->size);
/* minimize buffer using no 2*CR/LF found yet */
- if (sock->size > 4) {
- memmove(sock->buffer,
- sock->buffer + sock->size - 4, 4);
- sock->size = 4;
+ if (sock_obj->size > 4) {
+ memmove(sock_obj->buffer,
+ sock_obj->buffer + sock_obj->size - 4, 4);
+ sock_obj->size = 4;
}
}
- } else if (sock->size) {
+ } else if (sock_obj->size) {
if (req->verbose)
- dump_buffer(sock->buffer, r);
- MD5_Update(&sock->context, sock->buffer, sock->size);
- sock->size = 0;
+ dump_buffer(sock_obj->buffer, r);
+ MD5_Update(&sock_obj->context, sock_obj->buffer, sock_obj->size);
+ sock_obj->size = 0;
}
return 0;
/* Asynchronous HTTP stream reader */
int
-http_read_thread(thread * thread)
+http_read_thread(thread * thread_obj)
{
- SOCK *sock = THREAD_ARG(thread);
+ SOCK *sock_obj = THREAD_ARG(thread_obj);
int r = 0;
/* Handle read timeout */
- if (thread->type == THREAD_READ_TIMEOUT)
- return epilog(thread);
+ if (thread_obj->type == THREAD_READ_TIMEOUT)
+ return epilog(thread_obj);
/* read the HTTP stream */
- memset(sock->buffer, 0, MAX_BUFFER_LENGTH);
- r = read(thread->u.fd, sock->buffer + sock->size,
- MAX_BUFFER_LENGTH - sock->size);
+ memset(sock_obj->buffer, 0, MAX_BUFFER_LENGTH);
+ r = read(thread_obj->u.fd, sock_obj->buffer + sock_obj->size,
+ MAX_BUFFER_LENGTH - sock_obj->size);
- DBG(" [l:%d,fd:%d]\n", r, sock->fd);
+ DBG(" [l:%d,fd:%d]\n", r, sock_obj->fd);
if (r == -1 || r == 0) { /* -1:error , 0:EOF */
if (r == -1) {
DBG("Read error with server [%s:%d]: %s\n",
inet_ntop2(req->addr_ip), ntohs(req->addr_port),
strerror(errno));
- return epilog(thread);
+ return epilog(thread_obj);
}
/* All the HTTP stream has been parsed */
- finalize(thread);
+ finalize(thread_obj);
} else {
/* Handle the response stream */
- http_process_stream(sock, r);
+ http_process_stream(sock_obj, r);
/*
* Register next http stream reader.
* Register itself to not perturbe global I/O multiplexer.
*/
- thread_add_read(thread->master, http_read_thread, sock,
- thread->u.fd, HTTP_CNX_TIMEOUT);
+ thread_add_read(thread_obj->master, http_read_thread, sock_obj,
+ thread_obj->u.fd, HTTP_CNX_TIMEOUT);
}
return 0;
* Apply trigger check to this result.
*/
int
-http_response_thread(thread * thread)
+http_response_thread(thread * thread_obj)
{
- SOCK *sock = THREAD_ARG(thread);
+ SOCK *sock_obj = THREAD_ARG(thread_obj);
/* Handle read timeout */
- if (thread->type == THREAD_READ_TIMEOUT)
- return epilog(thread);
+ if (thread_obj->type == THREAD_READ_TIMEOUT)
+ return epilog(thread_obj);
/* Allocate & clean the get buffer */
- sock->buffer = (char *) MALLOC(MAX_BUFFER_LENGTH);
+ sock_obj->buffer = (char *) MALLOC(MAX_BUFFER_LENGTH);
/* Initalize the MD5 context */
- MD5_Init(&sock->context);
+ MD5_Init(&sock_obj->context);
/* Register asynchronous http/ssl read thread */
if (req->ssl)
- thread_add_read(thread->master, ssl_read_thread, sock,
- thread->u.fd, HTTP_CNX_TIMEOUT);
+ thread_add_read(thread_obj->master, ssl_read_thread, sock_obj,
+ thread_obj->u.fd, HTTP_CNX_TIMEOUT);
else
- thread_add_read(thread->master, http_read_thread, sock,
- thread->u.fd, HTTP_CNX_TIMEOUT);
+ thread_add_read(thread_obj->master, http_read_thread, sock_obj,
+ thread_obj->u.fd, HTTP_CNX_TIMEOUT);
return 0;
}
/* remote Web server is connected, send it the get url query. */
int
-http_request_thread(thread * thread)
+http_request_thread(thread * thread_obj)
{
- SOCK *sock = THREAD_ARG(thread);
+ SOCK *sock_obj = THREAD_ARG(thread_obj);
char *str_request;
int ret = 0;
/* Handle read timeout */
- if (thread->type == THREAD_WRITE_TIMEOUT)
- return epilog(thread);
+ if (thread_obj->type == THREAD_WRITE_TIMEOUT)
+ return epilog(thread_obj);
/* Allocate & clean the GET string */
str_request = (char *) MALLOC(GET_BUFFER_LENGTH);
, ntohs(req->addr_port));
/* Send the GET request to remote Web server */
- DBG("Sending GET request [%s] on fd:%d\n", req->url, sock->fd);
+ DBG("Sending GET request [%s] on fd:%d\n", req->url, sock_obj->fd);
if (req->ssl)
ret =
- ssl_send_request(sock->ssl, str_request,
+ ssl_send_request(sock_obj->ssl, str_request,
strlen(str_request));
else
ret =
- (send(sock->fd, str_request, strlen(str_request), 0) !=
+ (send(sock_obj->fd, str_request, strlen(str_request), 0) !=
-1) ? 1 : 0;
FREE(str_request);
fprintf(stderr, "Cannot send get request to [%s:%d].\n",
inet_ntop2(req->addr_ip)
, ntohs(req->addr_port));
- return epilog(thread);
+ return epilog(thread_obj);
}
/* Register read timeouted thread */
- thread_add_read(thread->master, http_response_thread, sock,
- sock->fd, HTTP_CNX_TIMEOUT);
+ thread_add_read(thread_obj->master, http_response_thread, sock_obj,
+ sock_obj->fd, HTTP_CNX_TIMEOUT);
return 1;
}
#define HTML_MD5_FINAL DELIM_BEGIN" HTML MD5 final resulting "DELIM_END
/* Define prototypes */
-extern int epilog(thread * thread);
-extern int finalize(thread * thread);
-extern int http_process_stream(SOCK * sock, int r);
-extern int http_request_thread(thread * thread);
+extern int epilog(thread * thread_obj);
+extern int finalize(thread * thread_obj);
+extern int http_process_stream(SOCK * sock_obj, int r);
+extern int http_request_thread(thread * thread_obj);
#endif
}
enum connect_result
-tcp_socket_state(int fd, thread * thread, uint32_t addr_ip, uint16_t addr_port,
+tcp_socket_state(int fd, thread * thread_obj, uint32_t addr_ip, uint16_t addr_port,
int (*func) (struct _thread *))
{
int status;
TIMEVAL timer_min;
/* Handle connection timeout */
- if (thread->type == THREAD_WRITE_TIMEOUT) {
+ if (thread_obj->type == THREAD_WRITE_TIMEOUT) {
DBG("TCP connection timeout to [%s:%d].\n",
inet_ntop2(addr_ip), ntohs(addr_port));
- close(thread->u.fd);
+ close(thread_obj->u.fd);
return connect_timeout;
}
/* Check file descriptor */
slen = sizeof (status);
if (getsockopt
- (thread->u.fd, SOL_SOCKET, SO_ERROR, (void *) &status, &slen) < 0)
+ (thread_obj->u.fd, SOL_SOCKET, SO_ERROR, (void *) &status, &slen) < 0)
ret = errno;
/* Connection failed !!! */
if (ret) {
DBG("TCP connection failed to [%s:%d].\n",
inet_ntop2(addr_ip), ntohs(addr_port));
- close(thread->u.fd);
+ close(thread_obj->u.fd);
return connect_error;
}
DBG("TCP connection to [%s:%d] still IN_PROGRESS.\n",
inet_ntop2(addr_ip), ntohs(addr_port));
- timer_min = timer_sub_now(thread->sands);
- thread_add_write(thread->master, func, THREAD_ARG(thread)
- , thread->u.fd, TIMER_LONG(timer_min));
+ timer_min = timer_sub_now(thread_obj->sands);
+ thread_add_write(thread_obj->master, func, THREAD_ARG(thread_obj)
+ , thread_obj->u.fd, TIMER_LONG(timer_min));
return connect_in_progress;
}
}
void
-tcp_connection_state(int fd, enum connect_result status, thread * thread,
+tcp_connection_state(int fd, enum connect_result status, thread * thread_obj,
int (*func) (struct _thread *)
, long timeout)
{
break;
case connect_success:
- thread_add_write(thread->master, func, THREAD_ARG(thread),
+ thread_add_write(thread_obj->master, func, THREAD_ARG(thread_obj),
fd, timeout);
break;
/* Checking non-blocking connect, we wait until socket is writable */
case connect_in_progress:
- thread_add_write(thread->master, func, THREAD_ARG(thread),
+ thread_add_write(thread_obj->master, func, THREAD_ARG(thread_obj),
fd, timeout);
break;
}
int
-tcp_check_thread(thread * thread)
+tcp_check_thread(thread * thread_obj)
{
- SOCK *sock = THREAD_ARG(thread);
+ SOCK *sock_obj = THREAD_ARG(thread_obj);
int ret = 1;
- sock->status =
- tcp_socket_state(thread->u.fd, thread, req->addr_ip, req->addr_port,
+ sock_obj->status =
+ tcp_socket_state(thread_obj->u.fd, thread_obj, req->addr_ip, req->addr_port,
tcp_check_thread);
- switch (sock->status) {
+ switch (sock_obj->status) {
case connect_error:
DBG("Error connecting server [%s:%d].\n",
inet_ntop2(req->addr_ip), ntohs(req->addr_port));
- thread_add_terminate_event(thread->master);
+ thread_add_terminate_event(thread_obj->master);
return -1;
break;
case connect_timeout:
DBG("Timeout connecting server [%s:%d].\n",
inet_ntop2(req->addr_ip), ntohs(req->addr_port));
- thread_add_terminate_event(thread->master);
+ thread_add_terminate_event(thread_obj->master);
return -1;
break;
case connect_success:{
if (req->ssl)
- ret = ssl_connect(thread);
+ ret = ssl_connect(thread_obj);
if (ret) {
/* Remote WEB server is connected.
* Unlock eventual locked socket.
*/
- sock->lock = 0;
- thread_add_event(thread->master,
- http_request_thread, sock, 0);
+ sock_obj->lock = 0;
+ thread_add_event(thread_obj->master,
+ http_request_thread, sock_obj, 0);
} else {
DBG("Connection trouble to: [%s:%d].\n",
inet_ntop2(req->addr_ip),
ntohs(req->addr_port));
if (req->ssl)
ssl_printerr(SSL_get_error
- (sock->ssl, ret));
- sock->status = connect_error;
+ (sock_obj->ssl, ret));
+ sock_obj->status = connect_error;
return -1;
}
}
}
int
-tcp_connect_thread(thread * thread)
+tcp_connect_thread(thread * thread_obj)
{
- SOCK *sock = THREAD_ARG(thread);
+ SOCK *sock_obj = THREAD_ARG(thread_obj);
- if ((sock->fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {
+ if ((sock_obj->fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {
DBG("WEB connection fail to create socket.\n");
return 0;
}
- sock->status = tcp_connect(sock->fd, req->addr_ip, req->addr_port);
+ sock->status = tcp_connect(sock_obj->fd, req->addr_ip, req->addr_port);
/* handle tcp connection status & register check worker thread */
- tcp_connection_state(sock->fd, sock->status, thread, tcp_check_thread,
+ tcp_connection_state(sock_obj->fd, sock_obj->status, thread_obj, tcp_check_thread,
HTTP_CNX_TIMEOUT);
return 0;
}
#include <sys/wait.h>
#include "main.h"
#include "utils.h"
-#include "sock.h"
+#include "signals.h"
/* global var */
REQ *req = NULL;
thread_add_terminate_event(master);
}
-/* signal wrapper */
-void *
-signal_set(int signo, void (*func) (int))
-{
- int ret;
- struct sigaction sig;
- struct sigaction osig;
-
- sig.sa_handler = func;
- sigemptyset(&sig.sa_mask);
- sig.sa_flags = 0;
-#ifdef SA_RESTART
- sig.sa_flags |= SA_RESTART;
-#endif /* SA_RESTART */
-
- ret = sigaction(signo, &sig, &osig);
-
- if (ret < 0)
- return (SIG_ERR);
- else
- return (osig.sa_handler);
-}
-
/* Initialize signal handler */
void
signal_init(void)
{
+ signal_handler_init();
signal_set(SIGHUP, sigend);
signal_set(SIGINT, sigend);
signal_set(SIGTERM, sigend);
- signal_set(SIGKILL, sigend);
+ signal_ignore(SIGPIPE);
}
/* Usage function */
/* Command line parser */
static int
-parse_cmdline(int argc, char **argv, REQ * req)
+parse_cmdline(int argc, char **argv, REQ * req_obj)
{
poptContext context;
char *optarg = NULL;
usage(argv[0]);
break;
case 'v':
- req->verbose = 1;
+ req_obj->verbose = 1;
break;
case 'S':
- req->ssl = 1;
+ req_obj->ssl = 1;
break;
case 's':
- inet_ston(optarg, &req->addr_ip);
+ inet_ston(optarg, &req_obj->addr_ip);
break;
case 'V':
- req->vhost = optarg;
+ req_obj->vhost = optarg;
break;
default:
usage(argv[0]);
while ((c = poptGetNextOpt(context)) >= 0) {
switch (c) {
case 'v':
- req->verbose = 1;
+ req_obj->verbose = 1;
break;
case 'S':
- req->ssl = 1;
+ req_obj->ssl = 1;
break;
case 's':
- inet_ston(optarg, &req->addr_ip);
+ inet_ston(optarg, &req_obj->addr_ip);
break;
case 'V':
- req->vhost = optarg;
+ req_obj->vhost = optarg;
break;
case 'p':
- req->addr_port = htons(atoi(optarg));
+ req_obj->addr_port = htons(atoi(optarg));
break;
case 'u':
- req->url = optarg;
+ req_obj->url = optarg;
break;
default:
usage(argv[0]);
int
main(int argc, char **argv)
{
- thread thread;
+ thread thread_obj;
/* Allocate the room */
req = (REQ *) MALLOC(sizeof (REQ));
* return and execute one ready thread.
* Run until error, used for debuging only.
*/
- while (thread_fetch(master, &thread))
- thread_call(&thread);
+ while (thread_fetch(master, &thread_obj))
+ thread_call(&thread_obj);
/* Finalize output informations */
if (req->verbose)
/* Close the descriptor */
static void
-close_sock(SOCK * sock)
+close_sock(SOCK * sock_obj)
{
- if (sock->ssl) {
- SSL_shutdown(sock->ssl);
- SSL_free(sock->ssl);
+ if (sock_obj->ssl) {
+ SSL_shutdown(sock_obj->ssl);
+ SSL_free(sock_obj->ssl);
}
- close(sock->fd);
+ close(sock_obj->fd);
}
/* Destroy the socket handler */
void
-free_sock(SOCK * sock)
+free_sock(SOCK * sock_obj)
{
- DBG("Freeing fd:%d\n", sock->fd);
+ DBG("Freeing fd:%d\n", sock_obj->fd);
- close_sock(sock);
- FREE(sock);
+ close_sock(sock_obj);
+ FREE(sock_obj);
}
/* Init socket handler */
extern SOCK *sock;
/* Prototypes */
-extern void free_sock(SOCK * sock);
+extern void free_sock(SOCK * sock_obj);
extern void init_sock(void);
#endif
}
int
-ssl_connect(thread * thread)
+ssl_connect(thread * thread_obj)
{
- SOCK *sock = THREAD_ARG(thread);
+ SOCK *sock_obj = THREAD_ARG(thread_obj);
int ret;
- sock->ssl = SSL_new(req->ctx);
- sock->bio = BIO_new_socket(sock->fd, BIO_NOCLOSE);
- BIO_set_nbio(sock->bio, 1); /* Set the Non-Blocking flag */
- SSL_set_bio(sock->ssl, sock->bio, sock->bio);
- ret = SSL_connect(sock->ssl);
+ sock_obj->ssl = SSL_new(req->ctx);
+ sock_obj->bio = BIO_new_socket(sock_obj->fd, BIO_NOCLOSE);
+ BIO_set_nbio(sock_obj->bio, 1); /* Set the Non-Blocking flag */
+ SSL_set_bio(sock_obj->ssl, sock_obj->bio, sock_obj->bio);
+ ret = SSL_connect(sock_obj->ssl);
- DBG(" SSL_connect return code = %d on fd:%d\n", ret, thread->u.fd);
- ssl_printerr(SSL_get_error(sock->ssl, ret));
+ DBG(" SSL_connect return code = %d on fd:%d\n", ret, thread_obj->u.fd);
+ ssl_printerr(SSL_get_error(sock_obj->ssl, ret));
return (ret > 0) ? 1 : 0;
}
/* Asynchronous SSL stream reader */
int
-ssl_read_thread(thread * thread)
+ssl_read_thread(thread * thread_obj)
{
- SOCK *sock = THREAD_ARG(thread);
+ SOCK *sock_obj = THREAD_ARG(thread_obj);
int r = 0;
int error;
/* Handle read timeout */
- if (thread->type == THREAD_READ_TIMEOUT)
- return epilog(thread);
+ if (thread_obj->type == THREAD_READ_TIMEOUT)
+ return epilog(thread_obj);
/*
* The design implemented here is a workaround for use
read_stream:
/* read the SSL stream */
- memset(sock->buffer, 0, MAX_BUFFER_LENGTH);
- r = SSL_read(sock->ssl, sock->buffer, MAX_BUFFER_LENGTH);
- error = SSL_get_error(sock->ssl, r);
+ memset(sock_obj->buffer, 0, MAX_BUFFER_LENGTH);
+ r = SSL_read(sock_obj->ssl, sock_obj->buffer, MAX_BUFFER_LENGTH);
+ error = SSL_get_error(sock_obj->ssl, r);
- DBG(" [l:%d,fd:%d]\n", r, sock->fd);
+ DBG(" [l:%d,fd:%d]\n", r, sock_obj->fd);
if (error) {
/* All the SSL streal has been parsed */
/* Handle response stream */
if (error != SSL_ERROR_NONE)
- return finalize(thread);
+ return finalize(thread_obj);
} else if (r > 0 && error == 0) {
/* Handle the response stream */
- http_process_stream(sock, r);
+ http_process_stream(sock_obj, r);
/*
* Register next ssl stream reader.
/* Prototypes */
extern void init_ssl(void);
-extern int ssl_connect(thread * thread);
+extern int ssl_connect(thread * thread_obj);
extern int ssl_printerr(int err);
extern int ssl_send_request(SSL * ssl, char *str_request, int request_len);
-extern int ssl_read_thread(thread * thread);
+extern int ssl_read_thread(thread * thread_obj);
#endif
rm -f $(DESTDIR)$(sbindir)/$(EXEC)
rm -rf $(DESTDIR)$(sysconfdir)/keepalived
rm -f $(DESTDIR)$(init_dir)/$(init_script)
- rm -f $(DESTDIR)$(prefix)@mandir@/man/man5/keepalived.conf.5
- rm -f $(DESTDIR)$(prefix)@mandir@/man/man8/keepalived.8
+ rm -f $(DESTDIR)@mandir@/man/man5/keepalived.conf.5
+ rm -f $(DESTDIR)@mandir@/man/man8/keepalived.8
install:
install -d $(DESTDIR)$(sbindir)
install -d $(DESTDIR)$(sysconfdir)/keepalived/samples
install -m 644 $(conf_file) $(DESTDIR)$(sysconfdir)/keepalived/
install -m 644 ../doc/samples/* $(DESTDIR)$(sysconfdir)/keepalived/samples/
- install -d $(DESTDIR)$(prefix)@mandir@/man/man5
- install -d $(DESTDIR)$(prefix)@mandir@/man/man8
- install -m 644 ../doc/man/man5/keepalived.conf.5 $(DESTDIR)$(prefix)@mandir@/man/man5
- install -m 644 ../doc/man/man8/keepalived.8 $(DESTDIR)$(prefix)@mandir@/man/man8
+ install -d $(DESTDIR)@mandir@/man/man5
+ install -d $(DESTDIR)@mandir@/man/man8
+ install -m 644 ../doc/man/man5/keepalived.conf.5 $(DESTDIR)@mandir@/man/man5
+ install -m 644 ../doc/man/man8/keepalived.8 $(DESTDIR)@mandir@/man/man8
../include/check_parser.h ../include/check_data.h ../include/check_api.h \
../include/global_data.h ../include/ipwrapper.h ../include/ipwrapper.h \
../include/pidfile.h ../include/daemon.h ../../lib/list.h ../../lib/memory.h \
- ../../lib/parser.h ../include/vrrp_netlink.h \
+ ../../lib/parser.h ../../lib/signals.h ../include/vrrp_netlink.h \
../include/vrrp_if.h
check_data.o: check_data.c ../include/check_data.h \
../include/check_api.h ../../lib/memory.h ../../lib/utils.h
*
* Part: Checkers registration.
*
- * Version: $Id: check_api.c,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: check_api.c,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
/* free checker data */
static void
-free_checker(void *data)
+free_checker(void *chk_data_obj)
{
- checker *checker = data;
- (*checker->free) (checker);
+ checker *checker_obj = chk_data_obj;
+ (*checker_obj->free_func) (checker_obj);
}
/* dump checker data */
static void
-dump_checker(void *data)
+dump_checker(void *data_obj)
{
- checker *checker = data;
- syslog(LOG_INFO, " %s:%d", inet_ntop2(CHECKER_RIP(checker))
- , ntohs(CHECKER_RPORT(checker)));
- (*checker->dump) (checker);
+ checker *checker_obj = data_obj;
+ syslog(LOG_INFO, " %s:%d", inet_ntop2(CHECKER_RIP(checker_obj))
+ , ntohs(CHECKER_RPORT(checker_obj)));
+ (*checker_obj->dump_func) (checker_obj);
}
/* Queue a checker into the checkers_queue */
void
-queue_checker(void (*free) (void *), void (*dump) (void *)
+queue_checker(void (*free_func) (void *), void (*dump_func) (void *)
, int (*launch) (struct _thread *)
- , void *data)
+ , void *data_obj)
{
virtual_server *vs = LIST_TAIL_DATA(check_data->vs);
real_server *rs = LIST_TAIL_DATA(vs->rs);
- checker *chk = (checker *) MALLOC(sizeof (checker));
-
- chk->free = free;
- chk->dump = dump;
- chk->launch = launch;
- chk->vs = vs;
- chk->rs = rs;
- chk->data = data;
- chk->id = ncheckers++;
- chk->enabled = (vs->vfwmark) ? 1 : 0;
+ checker *check_obj = (checker *) MALLOC(sizeof (checker));
+
+ check_obj->free_func = free_func;
+ check_obj->dump_func = dump_func;
+ check_obj->launch = launch;
+ check_obj->vs = vs;
+ check_obj->rs = rs;
+ check_obj->data = data_obj;
+ check_obj->id = ncheckers++;
+ check_obj->enabled = (vs->vfwmark) ? 1 : 0;
#ifdef _WITHOUT_VRRP_
- chk->enabled = 1;
+ check_obj->enabled = 1;
#endif
/* queue the checker */
- list_add(checkers_queue, chk);
+ list_add(checkers_queue, check_obj);
}
/* dump the checkers_queue */
free_checkers_queue(void)
{
free_list(checkers_queue);
+ checkers_queue = NULL;
ncheckers = 0;
}
void
register_checkers_thread(void)
{
- checker *checker;
+ checker *checker_obj;
element e;
for (e = LIST_HEAD(checkers_queue); e; ELEMENT_NEXT(e)) {
- checker = ELEMENT_DATA(e);
+ checker_obj = ELEMENT_DATA(e);
syslog(LOG_INFO,
"Activating healtchecker for service [%s:%d]",
- inet_ntop2(CHECKER_RIP(checker)),
- ntohs(CHECKER_RPORT(checker)));
- CHECKER_ENABLE(checker);
- if (checker->launch)
- thread_add_timer(master, checker->launch, checker,
+ inet_ntop2(CHECKER_RIP(checker_obj)),
+ ntohs(CHECKER_RPORT(checker_obj)));
+ CHECKER_ENABLE(checker_obj);
+ if (checker_obj->launch)
+ thread_add_timer(master, checker_obj->launch, checker_obj,
BOOTSTRAP_DELAY);
}
}
void
update_checker_activity(uint32_t address, int enable)
{
- checker *checker;
+ checker *checker_obj;
element e;
/* Display netlink operation */
/* Processing Healthcheckers queue */
if (!LIST_ISEMPTY(checkers_queue))
for (e = LIST_HEAD(checkers_queue); e; ELEMENT_NEXT(e)) {
- checker = ELEMENT_DATA(e);
- if (CHECKER_VIP(checker) == address && CHECKER_HA_SUSPEND(checker)) {
- if (!CHECKER_ENABLED(checker) && enable)
+ checker_obj = ELEMENT_DATA(e);
+ if (CHECKER_VIP(checker_obj) == address && CHECKER_HA_SUSPEND(checker_obj)) {
+ if (!CHECKER_ENABLED(checker_obj) && enable)
syslog(LOG_INFO,
"Activating healtchecker for service [%s:%d]",
- inet_ntop2(CHECKER_RIP(checker)),
- ntohs(CHECKER_RPORT(checker)));
- if (CHECKER_ENABLED(checker) && !enable)
+ inet_ntop2(CHECKER_RIP(checker_obj)),
+ ntohs(CHECKER_RPORT(checker_obj)));
+ if (CHECKER_ENABLED(checker_obj) && !enable)
syslog(LOG_INFO,
"Suspending healtchecker for service [%s:%d]",
- inet_ntop2(CHECKER_RIP(checker)),
- ntohs(CHECKER_RPORT(checker)));
- checker->enabled = enable;
+ inet_ntop2(CHECKER_RIP(checker_obj)),
+ ntohs(CHECKER_RPORT(checker_obj)));
+ checker_obj->enabled = enable;
}
}
}
*
* Part: Healthcheckrs child process handling.
*
- * Version: $Id: check_daemon.c,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: check_daemon.c,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
#include "ipvswrapper.h"
#include "pidfile.h"
#include "daemon.h"
+#include "signals.h"
#include "list.h"
#include "main.h"
#include "memory.h"
/* Reload handler */
int
-reload_check_thread(thread * thread)
+reload_check_thread(thread * thread_obj)
{
/* set the reloading flag */
SET_RELOAD;
master = thread_make_master();
free_global_data(data);
free_checkers_queue();
+#ifdef _WITH_VRRP_
+ free_interface_queue();
+#endif
free_ssl();
ipvs_stop();
void
check_signal_init(void)
{
+ signal_handler_init();
signal_set(SIGHUP, sighup_check);
signal_set(SIGINT, sigend_check);
signal_set(SIGTERM, sigend_check);
- signal_set(SIGKILL, sigend_check);
+ signal_ignore(SIGPIPE);
signal_noignore_sigchld();
}
/* CHECK Child respawning thread */
int
-check_respawn_thread(thread * thread)
+check_respawn_thread(thread * thread_obj)
{
pid_t pid;
/* Fetch thread args */
- pid = THREAD_CHILD_PID(thread);
+ pid = THREAD_CHILD_PID(thread_obj);
/* Restart respawning thread */
- if (thread->type == THREAD_CHILD_TIMEOUT) {
+ if (thread_obj->type == THREAD_CHILD_TIMEOUT) {
thread_add_child(master, check_respawn_thread, NULL,
pid, RESPAWN_TIMER);
return 0;
*
* Part: Healthcheckers dynamic data structure definition.
*
- * Version: $Id: check_data.c,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: check_data.c,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
}
void
-free_check_data(check_conf_data *check_data)
+free_check_data(check_conf_data *check_data_obj)
{
- free_list(check_data->vs);
- free_list(check_data->vs_group);
- FREE(check_data);
+ free_list(check_data_obj->vs);
+ free_list(check_data_obj->vs_group);
+ FREE(check_data_obj);
}
void
-dump_check_data(check_conf_data *check_data)
+dump_check_data(check_conf_data *check_data_obj)
{
- if (check_data->ssl) {
+ if (check_data_obj->ssl) {
syslog(LOG_INFO, "------< SSL definitions >------");
dump_ssl();
}
- if (!LIST_ISEMPTY(check_data->vs)) {
+ if (!LIST_ISEMPTY(check_data_obj->vs)) {
syslog(LOG_INFO, "------< LVS Topology >------");
syslog(LOG_INFO, " System is compiled with LVS v%d.%d.%d",
NVERSION(IP_VS_VERSION_CODE));
- if (!LIST_ISEMPTY(check_data->vs_group))
- dump_list(check_data->vs_group);
- dump_list(check_data->vs);
+ if (!LIST_ISEMPTY(check_data_obj->vs_group))
+ dump_list(check_data_obj->vs_group);
+ dump_list(check_data_obj->vs);
}
dump_checkers_queue();
}
*
* Part: WEB CHECK. Common HTTP/SSL checker primitives.
*
- * Version: $Id: check_http.c,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: check_http.c,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Authors: Alexandre Cassen, <acassen@linux-vs.org>
* Jan Holmberg, <jan@artech.net>
void
free_url(void *data)
{
- url *url = data;
- FREE(url->path);
- FREE(url->digest);
- FREE(url);
+ url *url_obj = data;
+ FREE(url_obj->path);
+ FREE(url_obj->digest);
+ FREE(url_obj);
}
void
dump_url(void *data)
{
- url *url = data;
- syslog(LOG_INFO, " Checked url = %s", url->path);
- if (url->digest)
+ url *url_obj = data;
+ syslog(LOG_INFO, " Checked url = %s", url_obj->path);
+ if (url_obj->digest)
syslog(LOG_INFO, " digest = %s",
- url->digest);
- if (url->status_code)
+ url_obj->digest);
+ if (url_obj->status_code)
syslog(LOG_INFO, " HTTP Status Code = %d",
- url->status_code);
+ url_obj->status_code);
}
void
path_handler(vector strvec)
{
http_get_checker *http_get_chk = CHECKER_GET();
- url *url = LIST_TAIL_DATA(http_get_chk->url);
+ url *url_obj = LIST_TAIL_DATA(http_get_chk->url);
- url->path = CHECKER_VALUE_STRING(strvec);
+ url_obj->path = CHECKER_VALUE_STRING(strvec);
}
void
digest_handler(vector strvec)
{
http_get_checker *http_get_chk = CHECKER_GET();
- url *url = LIST_TAIL_DATA(http_get_chk->url);
+ url *url_obj = LIST_TAIL_DATA(http_get_chk->url);
- url->digest = CHECKER_VALUE_STRING(strvec);
+ url_obj->digest = CHECKER_VALUE_STRING(strvec);
}
void
status_code_handler(vector strvec)
{
http_get_checker *http_get_chk = CHECKER_GET();
- url *url = LIST_TAIL_DATA(http_get_chk->url);
+ url *url_obj = LIST_TAIL_DATA(http_get_chk->url);
- url->status_code = CHECKER_VALUE_INT(strvec);
+ url_obj->status_code = CHECKER_VALUE_INT(strvec);
}
void
*/
uint16_t
-get_service_port(checker * checker)
+get_service_port(checker * checker_obj)
{
- http_get_checker *http_get_check = CHECKER_ARG(checker);
+ http_get_checker *http_get_check = CHECKER_ARG(checker_obj);
uint16_t addr_port;
/*
* then assume we want to use default ports for HTTP or HTTPS.
* Known as 'Layer3 stickyness'.
*/
- addr_port = CHECKER_RPORT(checker);
+ addr_port = CHECKER_RPORT(checker_obj);
if (!addr_port)
addr_port =
htons((http_get_check->proto == PROTO_SSL) ? 443 : 80);
* method == 2 => register a retry on url checker thread
*/
int
-epilog(thread * thread, int method, int t, int c)
+epilog(thread * thread_obj, int method, int t, int c)
{
- checker *checker = THREAD_ARG(thread);
- http_get_checker *http_get_check = CHECKER_ARG(checker);
- http_arg *http_arg = HTTP_ARG(http_get_check);
- REQ *req = HTTP_REQ(http_arg);
- uint16_t addr_port = get_service_port(checker);
+ checker *checker_obj = THREAD_ARG(thread_obj);
+ http_get_checker *http_get_check = CHECKER_ARG(checker_obj);
+ http_arg *http_arg_obj = HTTP_ARG(http_get_check);
+ REQ *req = HTTP_REQ(http_arg_obj);
+ uint16_t addr_port = get_service_port(checker_obj);
long delay = 0;
if (method) {
- http_arg->url_it += t ? t : -http_arg->url_it;
- http_arg->retry_it += c ? c : -http_arg->retry_it;
+ http_arg_obj->url_it += t ? t : -http_arg_obj->url_it;
+ http_arg_obj->retry_it += c ? c : -http_arg_obj->retry_it;
}
/*
* html buffer. This is sometime needed with some applications
* servers.
*/
- if (http_arg->retry_it > http_get_check->nb_get_retry-1) {
- if (svr_checker_up(checker->id, checker->rs)) {
+ if (http_arg_obj->retry_it > http_get_check->nb_get_retry-1) {
+ if (svr_checker_up(checker_obj->id, checker_obj->rs)) {
syslog(LOG_INFO, "Check on service [%s:%d] failed after %d retry."
- , inet_ntop2(CHECKER_RIP(checker))
- , ntohs(addr_port), http_arg->retry_it);
- smtp_alert(thread->master, checker->rs, NULL, NULL,
+ , inet_ntop2(CHECKER_RIP(checker_obj))
+ , ntohs(addr_port), http_arg_obj->retry_it);
+ smtp_alert(checker_obj->rs, NULL, NULL,
"DOWN",
"=> CHECK failed on service"
" : MD5 digest mismatch <=");
- update_svr_checker_state(DOWN, checker->id
- , checker->vs
- , checker->rs);
+ update_svr_checker_state(DOWN, checker_obj->id
+ , checker_obj->vs
+ , checker_obj->rs);
}
/* Reset it counters */
- http_arg->url_it = 0;
- http_arg->retry_it = 0;
+ http_arg_obj->url_it = 0;
+ http_arg_obj->retry_it = 0;
}
/* register next timer thread */
switch (method) {
case 1:
if (req)
- delay = checker->vs->delay_loop;
+ delay = checker_obj->vs->delay_loop;
else
delay =
http_get_check->delay_before_retry;
break;
case 2:
- if (http_arg->url_it == 0 && http_arg->retry_it == 0)
- delay = checker->vs->delay_loop;
+ if (http_arg_obj->url_it == 0 && http_arg_obj->retry_it == 0)
+ delay = checker_obj->vs->delay_loop;
else
delay = http_get_check->delay_before_retry;
break;
if (req->buffer)
FREE(req->buffer);
FREE(req);
- http_arg->req = NULL;
- close(thread->u.fd);
+ http_arg_obj->req = NULL;
+ close(thread_obj->u.fd);
}
/* Register next checker thread */
- thread_add_timer(thread->master, http_connect_thread, checker, delay);
+ thread_add_timer(thread_obj->master, http_connect_thread, checker_obj, delay);
return 0;
}
int
-timeout_epilog(thread * thread, char *smtp_msg, char *debug_msg)
+timeout_epilog(thread * thread_obj, char *smtp_msg, char *debug_msg)
{
- checker *checker = THREAD_ARG(thread);
- uint16_t addr_port = get_service_port(checker);
+ checker *checker_obj = THREAD_ARG(thread_obj);
+ uint16_t addr_port = get_service_port(checker_obj);
syslog(LOG_INFO, "Timeout %s server [%s:%d].",
debug_msg
- , inet_ntop2(CHECKER_RIP(checker))
+ , inet_ntop2(CHECKER_RIP(checker_obj))
, ntohs(addr_port));
/* check if server is currently alive */
- if (svr_checker_up(checker->id, checker->rs)) {
- smtp_alert(thread->master, checker->rs, NULL, NULL,
+ if (svr_checker_up(checker_obj->id, checker_obj->rs)) {
+ smtp_alert(checker_obj->rs, NULL, NULL,
"DOWN", smtp_msg);
- update_svr_checker_state(DOWN, checker->id
- , checker->vs
- , checker->rs);
+ update_svr_checker_state(DOWN, checker_obj->id
+ , checker_obj->vs
+ , checker_obj->rs);
}
- return epilog(thread, 1, 0, 0);
+ return epilog(thread_obj, 1, 0, 0);
}
/* return the url pointer of the current url iterator */
url *
fetch_next_url(http_get_checker * http_get_check)
{
- http_arg *http_arg = HTTP_ARG(http_get_check);
+ http_arg *http_arg_obj = HTTP_ARG(http_get_check);
- return list_element(http_get_check->url, http_arg->url_it);
+ return list_element(http_get_check->url, http_arg_obj->url_it);
}
/* Handle response */
int
-http_handle_response(thread * thread, unsigned char digest[16]
+http_handle_response(thread * thread_obj, unsigned char digest[16]
, int empty_buffer)
{
- checker *checker = THREAD_ARG(thread);
- http_get_checker *http_get_check = CHECKER_ARG(checker);
- http_arg *http_arg = HTTP_ARG(http_get_check);
- REQ *req = HTTP_REQ(http_arg);
- uint16_t addr_port = get_service_port(checker);
+ checker *checker_obj = THREAD_ARG(thread_obj);
+ http_get_checker *http_get_check = CHECKER_ARG(checker_obj);
+ http_arg *http_arg_obj = HTTP_ARG(http_get_check);
+ REQ *req = HTTP_REQ(http_arg_obj);
+ uint16_t addr_port = get_service_port(checker_obj);
int r, di = 0;
unsigned char *digest_tmp;
url *fetched_url = fetch_next_url(http_get_check);
/* First check if remote webserver returned data */
if (empty_buffer)
- return timeout_epilog(thread, "=> CHECK failed on service"
+ return timeout_epilog(thread_obj, "=> CHECK failed on service"
" : empty buffer received <=\n\n",
"Read, no data received from ");
if (fetched_url->status_code) {
if (req->status_code != fetched_url->status_code) {
/* check if server is currently alive */
- if (svr_checker_up(checker->id, checker->rs)) {
+ if (svr_checker_up(checker_obj->id, checker_obj->rs)) {
syslog(LOG_INFO,
"HTTP status code error to [%s:%d] url(%s)"
", status_code [%d].",
- inet_ntop2(CHECKER_RIP(checker)),
+ inet_ntop2(CHECKER_RIP(checker_obj)),
ntohs(addr_port), fetched_url->path,
req->status_code);
- smtp_alert(thread->master, checker->rs, NULL, NULL,
+ smtp_alert(checker_obj->rs, NULL, NULL,
"DOWN",
"=> CHECK failed on service"
" : HTTP status code mismatch <=");
- update_svr_checker_state(DOWN, checker->id
- , checker->vs
- , checker->rs);
+ update_svr_checker_state(DOWN, checker_obj->id
+ , checker_obj->vs
+ , checker_obj->rs);
} else {
DBG("HTTP Status_code to [%s:%d] url(%d) = [%d].",
- inet_ntop2(CHECKER_RIP(checker))
+ inet_ntop2(CHECKER_RIP(checker_obj))
, ntohs(addr_port)
- , http_arg->url_it + 1
+ , http_arg_obj->url_it + 1
, req->status_code);
/*
* We set retry iterator to max value to not retry
* when service is already know as die.
*/
- http_arg->retry_it = http_get_check->nb_get_retry;
+ http_arg_obj->retry_it = http_get_check->nb_get_retry;
}
- return epilog(thread, 2, 0, 1);
+ return epilog(thread_obj, 2, 0, 1);
} else {
- if (!svr_checker_up(checker->id, checker->rs))
+ if (!svr_checker_up(checker_obj->id, checker_obj->rs))
syslog(LOG_INFO,
"HTTP status code success to [%s:%d] url(%d).",
- inet_ntop2(CHECKER_RIP(checker))
+ inet_ntop2(CHECKER_RIP(checker_obj))
, ntohs(addr_port)
- , http_arg->url_it + 1);
- return epilog(thread, 1, 1, 0) + 1;
+ , http_arg_obj->url_it + 1);
+ return epilog(thread_obj, 1, 1, 0) + 1;
}
}
if (r) {
/* check if server is currently alive */
- if (svr_checker_up(checker->id, checker->rs)) {
+ if (svr_checker_up(checker_obj->id, checker_obj->rs)) {
syslog(LOG_INFO,
"MD5 digest error to [%s:%d] url[%s]"
", MD5SUM [%s].",
- inet_ntop2(CHECKER_RIP(checker)),
+ inet_ntop2(CHECKER_RIP(checker_obj)),
ntohs(addr_port), fetched_url->path,
digest_tmp);
} else {
DBG("MD5SUM to [%s:%d] url(%d) = [%s].",
- inet_ntop2(CHECKER_RIP(checker))
+ inet_ntop2(CHECKER_RIP(checker_obj))
, ntohs(addr_port)
- , http_arg->url_it + 1
+ , http_arg_obj->url_it + 1
, digest_tmp);
/*
* We set retry iterator to max value to not retry
* when service is already know as die.
*/
- http_arg->retry_it = http_get_check->nb_get_retry;
+ http_arg_obj->retry_it = http_get_check->nb_get_retry;
}
FREE(digest_tmp);
- return epilog(thread, 2, 0, 1);
+ return epilog(thread_obj, 2, 0, 1);
} else {
- if (!svr_checker_up(checker->id, checker->rs))
+ if (!svr_checker_up(checker_obj->id, checker_obj->rs))
syslog(LOG_INFO, "MD5 digest success to [%s:%d] url(%d).",
- inet_ntop2(CHECKER_RIP(checker))
+ inet_ntop2(CHECKER_RIP(checker_obj))
, ntohs(addr_port)
- , http_arg->url_it + 1);
+ , http_arg_obj->url_it + 1);
FREE(digest_tmp);
- return epilog(thread, 1, 1, 0) + 1;
+ return epilog(thread_obj, 1, 1, 0) + 1;
}
}
- return epilog(thread, 1, 0, 0) + 1;
+ return epilog(thread_obj, 1, 0, 0) + 1;
}
/* Handle response stream performing MD5 updates */
/* Asynchronous HTTP stream reader */
int
-http_read_thread(thread * thread)
+http_read_thread(thread * thread_obj)
{
- checker *checker = THREAD_ARG(thread);
- http_get_checker *http_get_check = CHECKER_ARG(checker);
- http_arg *http_arg = HTTP_ARG(http_get_check);
- REQ *req = HTTP_REQ(http_arg);
- uint16_t addr_port = get_service_port(checker);
+ checker *checker_obj = THREAD_ARG(thread_obj);
+ http_get_checker *http_get_check = CHECKER_ARG(checker_obj);
+ http_arg *http_arg_obj = HTTP_ARG(http_get_check);
+ REQ *req = HTTP_REQ(http_arg_obj);
+ uint16_t addr_port = get_service_port(checker_obj);
unsigned char digest[16];
int r = 0;
int val;
/* Handle read timeout */
- if (thread->type == THREAD_READ_TIMEOUT)
- return timeout_epilog(thread, "=> HTTP CHECK failed on service"
+ if (thread_obj->type == THREAD_READ_TIMEOUT)
+ return timeout_epilog(thread_obj, "=> HTTP CHECK failed on service"
" : recevice data <=\n\n", "HTTP read");
/* Set descriptor non blocking */
- val = fcntl(thread->u.fd, F_GETFL, 0);
- fcntl(thread->u.fd, F_SETFL, val | O_NONBLOCK);
+ val = fcntl(thread_obj->u.fd, F_GETFL, 0);
+ fcntl(thread_obj->u.fd, F_SETFL, val | O_NONBLOCK);
/* read the HTTP stream */
- r = read(thread->u.fd, req->buffer + req->len,
+ r = read(thread_obj->u.fd, req->buffer + req->len,
MAX_BUFFER_LENGTH - req->len);
/* restore descriptor flags */
- fcntl(thread->u.fd, F_SETFL, val);
+ fcntl(thread_obj->u.fd, F_SETFL, val);
/* Test if data are ready */
- if (r == -1 && errno == EAGAIN) {
+ if (r == -1 && (errno == EAGAIN || errno == EINTR)) {
syslog(LOG_INFO, "Read error with server [%s:%d]: %s",
- inet_ntop2(CHECKER_RIP(checker))
+ inet_ntop2(CHECKER_RIP(checker_obj))
, ntohs(addr_port)
, strerror(errno));
- thread_add_read(thread->master, http_read_thread, checker,
- thread->u.fd, http_get_check->connection_to);
+ thread_add_read(thread_obj->master, http_read_thread, checker_obj,
+ thread_obj->u.fd, http_get_check->connection_to);
return 0;
}
if (r == -1) {
/* We have encourred a real read error */
- if (svr_checker_up(checker->id, checker->rs)) {
+ if (svr_checker_up(checker_obj->id, checker_obj->rs)) {
syslog(LOG_INFO, "Read error with server [%s:%d]: %s",
- inet_ntop2(CHECKER_RIP(checker))
+ inet_ntop2(CHECKER_RIP(checker_obj))
, ntohs(addr_port)
, strerror(errno));
- smtp_alert(thread->master, checker->rs, NULL, NULL,
+ smtp_alert(checker_obj->rs, NULL, NULL,
"DOWN",
"=> HTTP CHECK failed on service"
" : cannot receive data <=");
- update_svr_checker_state(DOWN, checker->id
- , checker->vs
- , checker->rs);
+ update_svr_checker_state(DOWN, checker_obj->id
+ , checker_obj->vs
+ , checker_obj->rs);
}
- return epilog(thread, 1, 0, 0);
+ return epilog(thread_obj, 1, 0, 0);
}
/* Handle response stream */
- http_handle_response(thread, digest, (!req->extracted) ? 1 : 0);
+ http_handle_response(thread_obj, digest, (!req->extracted) ? 1 : 0);
} else {
* Register next http stream reader.
* Register itself to not perturbe global I/O multiplexer.
*/
- thread_add_read(thread->master, http_read_thread, checker,
- thread->u.fd, http_get_check->connection_to);
+ thread_add_read(thread_obj->master, http_read_thread, checker_obj,
+ thread_obj->u.fd, http_get_check->connection_to);
}
return 0;
* Apply trigger check to this result.
*/
int
-http_response_thread(thread * thread)
+http_response_thread(thread * thread_obj)
{
- checker *checker = THREAD_ARG(thread);
- http_get_checker *http_get_check = CHECKER_ARG(checker);
- http_arg *http_arg = HTTP_ARG(http_get_check);
- REQ *req = HTTP_REQ(http_arg);
+ checker *checker_obj = THREAD_ARG(thread_obj);
+ http_get_checker *http_get_check = CHECKER_ARG(checker_obj);
+ http_arg *http_arg_obj = HTTP_ARG(http_get_check);
+ REQ *req = HTTP_REQ(http_arg_obj);
/* Handle read timeout */
- if (thread->type == THREAD_READ_TIMEOUT)
- return timeout_epilog(thread, "=> CHECK failed on service"
+ if (thread_obj->type == THREAD_READ_TIMEOUT)
+ return timeout_epilog(thread_obj, "=> CHECK failed on service"
" : recevice data <=\n\n", "WEB read");
/* Allocate & clean the get buffer */
/* Register asynchronous http/ssl read thread */
if (http_get_check->proto == PROTO_SSL)
- thread_add_read(thread->master, ssl_read_thread, checker,
- thread->u.fd, http_get_check->connection_to);
+ thread_add_read(thread_obj->master, ssl_read_thread, checker_obj,
+ thread_obj->u.fd, http_get_check->connection_to);
else
- thread_add_read(thread->master, http_read_thread, checker,
- thread->u.fd, http_get_check->connection_to);
+ thread_add_read(thread_obj->master, http_read_thread, checker_obj,
+ thread_obj->u.fd, http_get_check->connection_to);
return 0;
}
/* remote Web server is connected, send it the get url query. */
int
-http_request_thread(thread * thread)
+http_request_thread(thread * thread_obj)
{
- checker *checker = THREAD_ARG(thread);
- http_get_checker *http_get_check = CHECKER_ARG(checker);
- http_arg *http_arg = HTTP_ARG(http_get_check);
- REQ *req = HTTP_REQ(http_arg);
- uint16_t addr_port = get_service_port(checker);
- char *vhost = CHECKER_VHOST(checker);
+ checker *checker_obj = THREAD_ARG(thread_obj);
+ http_get_checker *http_get_check = CHECKER_ARG(checker_obj);
+ http_arg *http_arg_obj = HTTP_ARG(http_get_check);
+ REQ *req = HTTP_REQ(http_arg_obj);
+ uint16_t addr_port = get_service_port(checker_obj);
+ char *vhost = CHECKER_VHOST(checker_obj);
char *str_request;
url *fetched_url;
int ret = 0;
+ int val;
/* Handle read timeout */
- if (thread->type == THREAD_WRITE_TIMEOUT)
- return timeout_epilog(thread, "=> CHECK failed on service"
+ if (thread_obj->type == THREAD_WRITE_TIMEOUT)
+ return timeout_epilog(thread_obj, "=> CHECK failed on service"
" : read timeout <=\n\n",
"Web read, timeout");
fetched_url = fetch_next_url(http_get_check);
snprintf(str_request, GET_BUFFER_LENGTH, REQUEST_TEMPLATE,
fetched_url->path,
- (vhost) ? vhost : inet_ntop2(CHECKER_RIP(checker))
+ (vhost) ? vhost : inet_ntop2(CHECKER_RIP(checker_obj))
, ntohs(addr_port));
DBG("Processing url(%d) of [%s:%d].",
- http_arg->url_it + 1
- , inet_ntop2(CHECKER_RIP(checker))
+ http_arg_obj->url_it + 1
+ , inet_ntop2(CHECKER_RIP(checker_obj))
, ntohs(addr_port));
+ /* Set descriptor non blocking */
+ val = fcntl(thread_obj->u.fd, F_GETFL, 0);
+ fcntl(thread_obj->u.fd, F_SETFL, val | O_NONBLOCK);
+
/* Send the GET request to remote Web server */
- if (http_get_check->proto == PROTO_SSL)
- ret =
- ssl_send_request(req->ssl, str_request,
- strlen(str_request));
- else
- ret =
- (send(thread->u.fd, str_request, strlen(str_request), 0) !=
- -1) ? 1 : 0;
+ if (http_get_check->proto == PROTO_SSL) {
+ ret = ssl_send_request(req->ssl, str_request,
+ strlen(str_request));
+ } else {
+ ret = (send(thread_obj->u.fd, str_request, strlen(str_request), 0) !=
+ -1) ? 1 : 0;
+ }
+
+ /* restore descriptor flags */
+ fcntl(thread_obj->u.fd, F_SETFL, val);
FREE(str_request);
if (!ret) {
syslog(LOG_INFO, "Cannot send get request to [%s:%d].",
- inet_ntop2(CHECKER_RIP(checker))
+ inet_ntop2(CHECKER_RIP(checker_obj))
, ntohs(addr_port));
/* check if server is currently alive */
- if (svr_checker_up(checker->id, checker->rs)) {
- smtp_alert(thread->master, checker->rs, NULL, NULL,
+ if (svr_checker_up(checker_obj->id, checker_obj->rs)) {
+ smtp_alert(checker_obj->rs, NULL, NULL,
"DOWN",
"=> CHECK failed on service"
" : cannot send data <=");
- update_svr_checker_state(DOWN, checker->id
- , checker->vs
- , checker->rs);
+ update_svr_checker_state(DOWN, checker_obj->id
+ , checker_obj->vs
+ , checker_obj->rs);
}
- return epilog(thread, 1, 0, 0);
+ return epilog(thread_obj, 1, 0, 0);
}
/* Register read timeouted thread */
- thread_add_read(thread->master, http_response_thread, checker,
- thread->u.fd, http_get_check->connection_to);
+ thread_add_read(thread_obj->master, http_response_thread, checker_obj,
+ thread_obj->u.fd, http_get_check->connection_to);
return 1;
}
/* WEB checkers threads */
int
-http_check_thread(thread * thread)
+http_check_thread(thread * thread_obj)
{
- checker *checker = THREAD_ARG(thread);
- http_get_checker *http_get_check = CHECKER_ARG(checker);
- uint16_t addr_port = get_service_port(checker);
- http_arg *http_arg = HTTP_ARG(http_get_check);
+ checker *checker_obj = THREAD_ARG(thread_obj);
+ http_get_checker *http_get_check = CHECKER_ARG(checker_obj);
+ uint16_t addr_port = get_service_port(checker_obj);
+ http_arg *http_arg_obj = HTTP_ARG(http_get_check);
#ifdef _DEBUG_
- REQ *req = HTTP_REQ(http_arg);
+ REQ *req = HTTP_REQ(http_arg_obj);
#endif
int ret = 1;
int status;
- status = tcp_socket_state(thread->u.fd, thread, CHECKER_RIP(checker)
+ status = tcp_socket_state(thread_obj->u.fd, thread_obj, CHECKER_RIP(checker_obj)
, addr_port, http_check_thread);
switch (status) {
case connect_error:
/* check if server is currently alive */
- if (svr_checker_up(checker->id, checker->rs)) {
+ if (svr_checker_up(checker_obj->id, checker_obj->rs)) {
syslog(LOG_INFO, "Error connecting server [%s:%d].",
- inet_ntop2(CHECKER_RIP(checker))
+ inet_ntop2(CHECKER_RIP(checker_obj))
, ntohs(addr_port));
- smtp_alert(thread->master, checker->rs, NULL, NULL,
+ smtp_alert(checker_obj->rs, NULL, NULL,
"DOWN",
"=> CHECK failed on service"
" : connection error <=");
- update_svr_checker_state(DOWN, checker->id
- , checker->vs
- , checker->rs);
+ update_svr_checker_state(DOWN, checker_obj->id
+ , checker_obj->vs
+ , checker_obj->rs);
}
- return epilog(thread, 1, 0, 0);
+ return epilog(thread_obj, 1, 0, 0);
break;
case connect_timeout:
- return timeout_epilog(thread, "==> CHECK failed on service"
+ return timeout_epilog(thread_obj, "==> CHECK failed on service"
" : connection timeout <=\n\n",
"connect, timeout");
break;
case connect_success:{
/* Allocate & clean request struct */
- http_arg->req = (REQ *) MALLOC(sizeof (REQ));
+ http_arg_obj->req = (REQ *) MALLOC(sizeof (REQ));
if (http_get_check->proto == PROTO_SSL)
- ret = ssl_connect(thread);
+ ret = ssl_connect(thread_obj);
if (ret) {
/* Remote WEB server is connected.
* Register the next step thread ssl_request_thread.
*/
DBG("Remote Web server [%s:%d] connected.",
- inet_ntop2(CHECKER_RIP(checker)),
+ inet_ntop2(CHECKER_RIP(checker_obj)),
ntohs(addr_port));
- thread_add_write(thread->master,
- http_request_thread, checker,
- thread->u.fd,
+ thread_add_write(thread_obj->master,
+ http_request_thread, checker_obj,
+ thread_obj->u.fd,
http_get_check->connection_to);
} else {
syslog(LOG_INFO, "Connection trouble to: [%s:%d].",
- inet_ntop2(CHECKER_RIP(checker))
+ inet_ntop2(CHECKER_RIP(checker_obj))
, ntohs(addr_port));
#ifdef _DEBUG_
if (http_get_check->proto == PROTO_SSL)
ssl_printerr(SSL_get_error
(req->ssl, ret));
#endif
- return epilog(thread, 1, 0, 0);
+ return epilog(thread_obj, 1, 0, 0);
}
}
break;
}
int
-http_connect_thread(thread * thread)
+http_connect_thread(thread * thread_obj)
{
- checker *checker = THREAD_ARG(thread);
- http_get_checker *http_get_check = CHECKER_ARG(checker);
- http_arg *http_arg = HTTP_ARG(http_get_check);
- uint16_t addr_port = get_service_port(checker);
+ checker *checker_obj = THREAD_ARG(thread_obj);
+ http_get_checker *http_get_check = CHECKER_ARG(checker_obj);
+ http_arg *http_arg_obj = HTTP_ARG(http_get_check);
+ uint16_t addr_port = get_service_port(checker_obj);
url *fetched_url;
enum connect_result status;
int fd;
* Register a new checker thread & return
* if checker is disabled
*/
- if (!CHECKER_ENABLED(checker)) {
- thread_add_timer(thread->master, http_connect_thread, checker,
- checker->vs->delay_loop);
+ if (!CHECKER_ENABLED(checker_obj)) {
+ thread_add_timer(thread_obj->master, http_connect_thread, checker_obj,
+ checker_obj->vs->delay_loop);
return 0;
}
* Check completed.
* check if server is currently alive.
*/
- if (!svr_checker_up(checker->id, checker->rs)) {
+ if (!svr_checker_up(checker_obj->id, checker_obj->rs)) {
syslog(LOG_INFO, "Remote Web server [%s:%d] succeed on service.",
- inet_ntop2(CHECKER_RIP(checker))
+ inet_ntop2(CHECKER_RIP(checker_obj))
, ntohs(addr_port));
- smtp_alert(thread->master, checker->rs, NULL, NULL, "UP",
+ smtp_alert(checker_obj->rs, NULL, NULL, "UP",
"=> CHECK succeed on service <=");
- update_svr_checker_state(UP, checker->id
- , checker->vs
- , checker->rs);
+ update_svr_checker_state(UP, checker_obj->id
+ , checker_obj->vs
+ , checker_obj->rs);
}
- http_arg->req = NULL;
- return epilog(thread, 1, 0, 0) + 1;
+ http_arg_obj->req = NULL;
+ return epilog(thread_obj, 1, 0, 0) + 1;
}
/* Create the socket */
return 0;
}
- status = tcp_bind_connect(fd, CHECKER_RIP(checker), addr_port
+ status = tcp_bind_connect(fd, CHECKER_RIP(checker_obj), addr_port
, http_get_check->bindto);
/* handle tcp connection status & register check worker thread */
- tcp_connection_state(fd, status, thread, http_check_thread,
+ tcp_connection_state(fd, status, thread_obj, http_check_thread,
http_get_check->connection_to);
return 0;
}
* Part: MISC CHECK. Perform a system call to run an extra
* system prog or script.
*
- * Version: $Id: check_misc.c,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: check_misc.c,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Authors: Alexandre Cassen, <acassen@linux-vs.org>
* Eric Jarman, <ehj38230@cmsu2.cmsu.edu>
}
int
-misc_check_thread(thread * thread)
+misc_check_thread(thread * thread_obj)
{
- checker *checker;
+ checker *checker_obj;
misc_checker *misc_chk;
int status;
pid_t pid;
- checker = THREAD_ARG(thread);
- misc_chk = CHECKER_ARG(checker);
+ checker_obj = THREAD_ARG(thread_obj);
+ misc_chk = CHECKER_ARG(checker_obj);
/*
* Register a new checker thread & return
* if checker is disabled
*/
- if (!CHECKER_ENABLED(checker)) {
+ if (!CHECKER_ENABLED(checker_obj)) {
/* Register next timer checker */
- thread_add_timer(thread->master, misc_check_thread, checker,
- checker->vs->delay_loop);
+ thread_add_timer(thread_obj->master, misc_check_thread, checker_obj,
+ checker_obj->vs->delay_loop);
return 0;
}
/* Register next timer checker */
- thread_add_timer(thread->master, misc_check_thread, checker,
- checker->vs->delay_loop);
+ thread_add_timer(thread_obj->master, misc_check_thread, checker_obj,
+ checker_obj->vs->delay_loop);
/* Daemonization to not degrade our scheduling timer */
pid = fork();
/* In case of this is parent process */
if (pid) {
long timeout;
- timeout = (misc_chk->timeout) ? misc_chk->timeout : checker->vs->delay_loop;
+ timeout = (misc_chk->timeout) ? misc_chk->timeout : checker_obj->vs->delay_loop;
- thread_add_child(thread->master, misc_check_child_thread,
- checker, pid, timeout);
+ thread_add_child(thread_obj->master, misc_check_child_thread,
+ checker_obj, pid, timeout);
return 0;
}
}
int
-misc_check_child_thread(thread * thread)
+misc_check_child_thread(thread * thread_obj)
{
int wait_status;
- checker *checker;
+ checker *checker_obj;
misc_checker *misc_chk;
- checker = THREAD_ARG(thread);
- misc_chk = CHECKER_ARG(checker);
+ checker_obj = THREAD_ARG(thread_obj);
+ misc_chk = CHECKER_ARG(checker_obj);
- if (thread->type == THREAD_CHILD_TIMEOUT) {
+ if (thread_obj->type == THREAD_CHILD_TIMEOUT) {
pid_t pid;
- pid = THREAD_CHILD_PID(thread);
+ pid = THREAD_CHILD_PID(thread_obj);
/* The child hasn't responded. Kill it off. */
- if (svr_checker_up(checker->id, checker->rs)) {
+ if (svr_checker_up(checker_obj->id, checker_obj->rs)) {
syslog(LOG_INFO, "Misc check to [%s] for [%s] timed out",
- inet_ntop2(CHECKER_RIP(checker)),
+ inet_ntop2(CHECKER_RIP(checker_obj)),
misc_chk->path);
- smtp_alert(thread->master, checker->rs, NULL, NULL,
+ smtp_alert(checker_obj->rs, NULL, NULL,
"DOWN",
"=> MISC CHECK script timeout on service <=");
- update_svr_checker_state(DOWN, checker->id
- , checker->vs
- , checker->rs);
+ update_svr_checker_state(DOWN, checker_obj->id
+ , checker_obj->vs
+ , checker_obj->rs);
}
kill(pid, SIGTERM);
- thread_add_child(thread->master, misc_check_child_timeout_thread,
- checker, pid, 2);
+ thread_add_child(thread_obj->master, misc_check_child_timeout_thread,
+ checker_obj, pid, 2);
return 0;
}
- wait_status = THREAD_CHILD_STATUS(thread);
+ wait_status = THREAD_CHILD_STATUS(thread_obj);
if (WIFEXITED(wait_status)) {
int status;
* Catch legacy case of status being 0 but misc_dynamic being set.
*/
if (misc_chk->dynamic == 1 && status != 0)
- update_svr_wgt(status - 2, checker->vs, checker->rs);
+ update_svr_wgt(status - 2, checker_obj->vs, checker_obj->rs);
/* everything is good */
- if (!svr_checker_up(checker->id, checker->rs)) {
+ if (!svr_checker_up(checker_obj->id, checker_obj->rs)) {
syslog(LOG_INFO, "Misc check to [%s] for [%s] success.",
- inet_ntop2(CHECKER_RIP(checker)),
+ inet_ntop2(CHECKER_RIP(checker_obj)),
misc_chk->path);
- smtp_alert(thread->master, checker->rs, NULL, NULL,
+ smtp_alert(checker_obj->rs, NULL, NULL,
"UP",
"=> MISC CHECK succeed on service <=");
- update_svr_checker_state(UP, checker->id
- , checker->vs
- , checker->rs);
+ update_svr_checker_state(UP, checker_obj->id
+ , checker_obj->vs
+ , checker_obj->rs);
}
} else {
- if (svr_checker_up(checker->id, checker->rs)) {
+ if (svr_checker_up(checker_obj->id, checker_obj->rs)) {
syslog(LOG_INFO, "Misc check to [%s] for [%s] failed.",
- inet_ntop2(CHECKER_RIP(checker)),
+ inet_ntop2(CHECKER_RIP(checker_obj)),
misc_chk->path);
- smtp_alert(thread->master, checker->rs, NULL, NULL,
+ smtp_alert(checker_obj->rs, NULL, NULL,
"DOWN",
"=> MISC CHECK failed on service <=");
- update_svr_checker_state(DOWN, checker->id
- , checker->vs
- , checker->rs);
+ update_svr_checker_state(DOWN, checker_obj->id
+ , checker_obj->vs
+ , checker_obj->rs);
}
}
}
}
int
-misc_check_child_timeout_thread(thread * thread)
+misc_check_child_timeout_thread(thread * thread_obj)
{
pid_t pid;
- if (thread->type != THREAD_CHILD_TIMEOUT)
+ if (thread_obj->type != THREAD_CHILD_TIMEOUT)
return 0;
/* OK, it still hasn't exited. Now really kill it off. */
- pid = THREAD_CHILD_PID(thread);
+ pid = THREAD_CHILD_PID(thread_obj);
if (kill(pid, SIGKILL) < 0) {
/* Its possible it finished while we're handing this */
if (errno != ESRCH)
* data structure representation the conf file representing
* the loadbalanced server pool.
*
- * Version: $Id: check_parser.c,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: check_parser.c,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
*
* Part: SMTP CHECK. Check an SMTP-server.
*
- * Version: $Id: check_smtp.c,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: check_smtp.c,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
- * Authors: Alexandre Cassen, <acassen@linux-vs.org>
- * Jeremy Rumpf, <jrumpf@heavyload.net>
+ * Authors: Jeremy Rumpf, <jrumpf@heavyload.net>
+ * Alexandre Cassen, <acassen@linux-vs.org>
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* service down in case of error.
*/
int
-smtp_final(thread *thread, int error, const char *format, ...)
+smtp_final(thread *thread_obj, int error, const char *format, ...)
{
- checker *chk = THREAD_ARG(thread);
+ checker *chk = THREAD_ARG(thread_obj);
smtp_checker *smtp_chk = CHECKER_ARG(chk);
char error_buff[512];
char smtp_buff[542];
va_list varg_list;
/* Error or no error we should always have to close the socket */
- close(thread->u.fd);
+ close(thread_obj->u.fd);
/* If we're here, an attempt HAS been made already for the current host */
smtp_chk->attempts++;
* configured backoff delay. Otherwise down the RS.
*/
if (smtp_chk->attempts < smtp_chk->retry) {
- thread_add_timer(thread->master, smtp_connect_thread, chk,
+ thread_add_timer(thread_obj->master, smtp_connect_thread, chk,
smtp_chk->db_retry);
return 0;
}
}
smtp_buff[542 - 1] = '\0';
- smtp_alert(thread->master, chk->rs, NULL, NULL, "DOWN", smtp_buff);
+ smtp_alert(chk->rs, NULL, NULL, "DOWN", smtp_buff);
}
update_svr_checker_state(DOWN, chk->id, chk->vs, chk->rs);
smtp_chk->host_ctr = 0;
/* Reschedule the main thread using the configured delay loop */;
- thread_add_timer(thread->master, smtp_connect_thread, chk, chk->vs->delay_loop);
+ thread_add_timer(thread_obj->master, smtp_connect_thread, chk, chk->vs->delay_loop);
return 0;
}
smtp_chk->attempts = 0;
smtp_chk->host_ctr++;
- thread_add_timer(thread->master, smtp_connect_thread, chk, 1);
+ thread_add_timer(thread_obj->master, smtp_connect_thread, chk, 1);
return 0;
}
* Zeros out the rx/tx buffer
*/
void
-smtp_clear_buff(thread *thread)
+smtp_clear_buff(thread *thread_obj)
{
- checker *chk = THREAD_ARG(thread);
+ checker *chk = THREAD_ARG(thread_obj);
smtp_checker *smtp_chk = CHECKER_ARG(chk);
memset(smtp_chk->buff, 0, SMTP_BUFF_MAX);
smtp_chk->buff_ctr = 0;
* SMTP response codes at the beginning anyway.
*/
int
-smtp_get_line_cb(thread *thread)
+smtp_get_line_cb(thread *thread_obj)
{
- checker *chk = THREAD_ARG(thread);
+ checker *chk = THREAD_ARG(thread_obj);
smtp_checker *smtp_chk = CHECKER_ARG(chk);
smtp_host *smtp_hst = smtp_chk->host_ptr;
int f, r, x;
/* Handle read timeout */
- if (thread->type == THREAD_READ_TIMEOUT) {
- smtp_final(thread, 1, "Read timeout from server [%s:%d]",
+ if (thread_obj->type == THREAD_READ_TIMEOUT) {
+ smtp_final(thread_obj, 1, "Read timeout from server [%s:%d]",
inet_ntop2(smtp_hst->ip), ntohs(smtp_hst->port));
return 0;
}
syslog(LOG_INFO, "SMTP_CHECK Buffer overflow reading from server [%s:%d]. "
"Increase SMTP_BUFF_MAX in smtp_check.h",
inet_ntop2(smtp_hst->ip), ntohs(smtp_hst->port));
- smtp_clear_buff(thread);
+ smtp_clear_buff(thread_obj);
}
/* Set descriptor non blocking */
- f = fcntl(thread->u.fd, F_GETFL, 0);
- fcntl(thread->u.fd, F_SETFL, f | O_NONBLOCK);
+ f = fcntl(thread_obj->u.fd, F_GETFL, 0);
+ fcntl(thread_obj->u.fd, F_SETFL, f | O_NONBLOCK);
/* read the data */
- r = read(thread->u.fd, smtp_chk->buff + smtp_chk->buff_ctr,
+ r = read(thread_obj->u.fd, smtp_chk->buff + smtp_chk->buff_ctr,
SMTP_BUFF_MAX - smtp_chk->buff_ctr);
- if (r > 0)
- smtp_chk->buff_ctr += r;
-
if (r == -1 && (errno == EAGAIN || errno == EINTR)) {
- thread_add_read(thread->master, smtp_get_line_cb, chk,
- thread->u.fd, smtp_chk->timeout);
- fcntl(thread->u.fd, F_SETFL, f);
+ thread_add_read(thread_obj->master, smtp_get_line_cb, chk,
+ thread_obj->u.fd, smtp_chk->timeout);
+ fcntl(thread_obj->u.fd, F_SETFL, f);
return 0;
- }
+ } else if (r > 0)
+ smtp_chk->buff_ctr += r;
/* restore descriptor flags */
- fcntl(thread->u.fd, F_SETFL, f);
+ fcntl(thread_obj->u.fd, F_SETFL, f);
/* check if we have a newline, if so, callback */
for (x = 0; x < SMTP_BUFF_MAX; x++) {
DBG("SMTP_CHECK [%s:%d] < %s", inet_ntop2(smtp_hst->ip),
ntohs(smtp_hst->port), smtp_chk->buff);
- (smtp_chk->buff_cb)(thread);
+ (smtp_chk->buff_cb)(thread_obj);
return 0;
}
* some sort of error, notify smtp_final()
*/
if (r <= 0) {
- smtp_final(thread, 1, "Read failure from server [%s:%d]",
+ smtp_final(thread_obj, 1, "Read failure from server [%s:%d]",
inet_ntop2(smtp_hst->ip), ntohs(smtp_hst->port));
return 0;
}
* to pull a newline. Schedule ourselves for
* another round.
*/
- thread_add_read(thread->master, smtp_get_line_cb, chk,
- thread->u.fd, smtp_chk->timeout);
+ thread_add_read(thread_obj->master, smtp_get_line_cb, chk,
+ thread_obj->u.fd, smtp_chk->timeout);
return 0;
}
* sceduler can only accept a single *thread argument.
*/
void
-smtp_get_line(thread *thread, int (*callback) (struct _thread *))
+smtp_get_line(thread *thread_obj, int (*callback) (struct _thread *))
{
- checker *chk = THREAD_ARG(thread);
+ checker *chk = THREAD_ARG(thread_obj);
smtp_checker *smtp_chk = CHECKER_ARG(chk);
/* clear the buffer */
- smtp_clear_buff(thread);
+ smtp_clear_buff(thread_obj);
/* set the callback */
smtp_chk->buff_cb = callback;
/* schedule the I/O with our helper function */
- thread_add_read(thread->master, smtp_get_line_cb, chk,
- thread->u.fd, smtp_chk->timeout);
+ thread_add_read(thread_obj->master, smtp_get_line_cb, chk,
+ thread_obj->u.fd, smtp_chk->timeout);
return;
}
* we'll return to the scheduler and try again later.
*/
int
-smtp_put_line_cb(thread *thread)
+smtp_put_line_cb(thread *thread_obj)
{
- checker *chk = THREAD_ARG(thread);
+ checker *chk = THREAD_ARG(thread_obj);
smtp_checker *smtp_chk = CHECKER_ARG(chk);
smtp_host *smtp_hst = smtp_chk->host_ptr;
int f, w;
/* Handle read timeout */
- if (thread->type == THREAD_WRITE_TIMEOUT) {
- smtp_final(thread, 1, "Write timeout to server [%s:%d]",
+ if (thread_obj->type == THREAD_WRITE_TIMEOUT) {
+ smtp_final(thread_obj, 1, "Write timeout to server [%s:%d]",
inet_ntop2(smtp_hst->ip), ntohs(smtp_hst->port));
return 0;
}
/* Set descriptor non blocking */
- f = fcntl(thread->u.fd, F_GETFL, 0);
- fcntl(thread->u.fd, F_SETFL, f | O_NONBLOCK);
+ f = fcntl(thread_obj->u.fd, F_GETFL, 0);
+ fcntl(thread_obj->u.fd, F_SETFL, f | O_NONBLOCK);
/* write the data */
- w = write(thread->u.fd, smtp_chk->buff, smtp_chk->buff_ctr);
+ w = write(thread_obj->u.fd, smtp_chk->buff, smtp_chk->buff_ctr);
if (w == -1 && (errno == EAGAIN || errno == EINTR)) {
- thread_add_write(thread->master, smtp_put_line_cb, chk,
- thread->u.fd, smtp_chk->timeout);
- fcntl(thread->u.fd, F_SETFL, f);
+ thread_add_write(thread_obj->master, smtp_put_line_cb, chk,
+ thread_obj->u.fd, smtp_chk->timeout);
+ fcntl(thread_obj->u.fd, F_SETFL, f);
return 0;
}
+ /* restore descriptor flags */
+ fcntl(thread_obj->u.fd, F_SETFL, f);
+
DBG("SMTP_CHECK [%s:%d] > %s", inet_ntop2(smtp_hst->ip),
ntohs(smtp_hst->port), smtp_chk->buff);
- /* restore descriptor flags */
- fcntl(thread->u.fd, F_SETFL, f);
-
/*
* If the connection was closed or there was
* some sort of error, notify smtp_final()
*/
if (w <= 0) {
- smtp_final(thread, 1, "Write failure to server [%s:%d]",
+ smtp_final(thread_obj, 1, "Write failure to server [%s:%d]",
inet_ntop2(smtp_hst->ip), ntohs(smtp_hst->port));
return 0;
}
/* Execute the callback */
- (smtp_chk->buff_cb)(thread);
+ (smtp_chk->buff_cb)(thread_obj);
return 0;
}
* line of data instead of receiving one.
*/
void
-smtp_put_line(thread *thread, int (*callback) (struct _thread *))
+smtp_put_line(thread *thread_obj, int (*callback) (struct _thread *))
{
- checker *chk = THREAD_ARG(thread);
+ checker *chk = THREAD_ARG(thread_obj);
smtp_checker *smtp_chk = CHECKER_ARG(chk);
smtp_chk->buff[SMTP_BUFF_MAX - 1] = '\0';
smtp_chk->buff_cb = callback;
/* schedule the I/O with our helper function */
- thread_add_write(thread->master, smtp_put_line_cb, chk,
- thread->u.fd, smtp_chk->timeout);
+ thread_add_write(thread_obj->master, smtp_put_line_cb, chk,
+ thread_obj->u.fd, smtp_chk->timeout);
return;
}
* return -1.
*/
int
-smtp_get_status(thread *thread)
+smtp_get_status(thread *thread_obj)
{
- checker *chk = THREAD_ARG(thread);
+ checker *chk = THREAD_ARG(thread_obj);
smtp_checker *smtp_chk = CHECKER_ARG(chk);
char *buff = smtp_chk->buff;
* should be set to SMTP_START.
*/
int
-smtp_engine_thread(thread *thread)
+smtp_engine_thread(thread *thread_obj)
{
- checker *chk = THREAD_ARG(thread);
+ checker *chk = THREAD_ARG(thread_obj);
smtp_checker *smtp_chk = CHECKER_ARG(chk);
smtp_host *smtp_hst = smtp_chk->host_ptr;
/* First step, schedule to receive the greeting banner */
case SMTP_START:
-
/*
* Ok, if smtp_get_line schedules us back, we will
* have data to analyze. Otherwise, smtp_get_line
* will defer directly to smtp_final.
*/
smtp_chk->state = SMTP_HAVE_BANNER;
- smtp_get_line(thread, smtp_engine_thread);
+ smtp_get_line(thread_obj, smtp_engine_thread);
return 0;
break;
/* Second step, analyze banner, send HELO */
case SMTP_HAVE_BANNER:
-
/* Check for "220 some.mailserver.com" in the greeting */
- if (smtp_get_status(thread) != 220) {
- smtp_final(thread, 1, "Bad greeting banner from server [%s:%d]",
+ if (smtp_get_status(thread_obj) != 220) {
+ smtp_final(thread_obj, 1, "Bad greeting banner from server [%s:%d]",
inet_ntop2(smtp_hst->ip), ntohs(smtp_hst->port));
return 0;
smtp_chk->state = SMTP_SENT_HELO;
snprintf(smtp_chk->buff, SMTP_BUFF_MAX, "HELO %s\r\n",
smtp_chk->helo_name);
- smtp_put_line(thread, smtp_engine_thread);
+ smtp_put_line(thread_obj, smtp_engine_thread);
return 0;
break;
/* Third step, schedule to read the HELO response */
case SMTP_SENT_HELO:
smtp_chk->state = SMTP_RECV_HELO;
- smtp_get_line(thread, smtp_engine_thread);
+ smtp_get_line(thread_obj, smtp_engine_thread);
return 0;
break;
/* Fourth step, analyze HELO return, send QUIT */
case SMTP_RECV_HELO:
/* Check for "250 Please to meet you..." */
- if (smtp_get_status(thread) != 250) {
- smtp_final(thread, 1, "Bad HELO response from server [%s:%d]",
+ if (smtp_get_status(thread_obj) != 250) {
+ smtp_final(thread_obj, 1, "Bad HELO response from server [%s:%d]",
inet_ntop2(smtp_hst->ip), ntohs(smtp_hst->port));
return 0;
smtp_chk->state = SMTP_SENT_QUIT;
snprintf(smtp_chk->buff, SMTP_BUFF_MAX, "QUIT\r\n");
- smtp_put_line(thread, smtp_engine_thread);
+ smtp_put_line(thread_obj, smtp_engine_thread);
return 0;
break;
/* Fifth step, schedule to receive QUIT confirmation */
case SMTP_SENT_QUIT:
-
smtp_chk->state = SMTP_RECV_QUIT;
- smtp_get_line(thread, smtp_engine_thread);
+ smtp_get_line(thread_obj, smtp_engine_thread);
return 0;
break;
/* Sixth step, wrap up success to smtp_final */
case SMTP_RECV_QUIT:
- smtp_final(thread, 0, NULL);
+ smtp_final(thread_obj, 0, NULL);
return 0;
break;
}
/* We shouldn't be here */
- smtp_final(thread, 1, "Unknown smtp engine state encountered");
+ smtp_final(thread_obj, 1, "Unknown smtp engine state encountered");
return 0;
}
* to the host we're checking was successful or not.
*/
int
-smtp_check_thread(thread *thread)
+smtp_check_thread(thread *thread_obj)
{
- checker *chk = THREAD_ARG(thread);
+ checker *chk = THREAD_ARG(thread_obj);
smtp_checker *smtp_chk = CHECKER_ARG(chk);
smtp_host *smtp_hst = smtp_chk->host_ptr;
int status;
- status = tcp_socket_state(thread->u.fd, thread, smtp_hst->ip,
+ status = tcp_socket_state(thread_obj->u.fd, thread_obj, smtp_hst->ip,
smtp_hst->port, smtp_check_thread);
switch (status) {
case connect_error:
- smtp_final(thread, 1, "Error connecting to server [%s:%d]",
+ smtp_final(thread_obj, 1, "Error connecting to server [%s:%d]",
inet_ntop2(smtp_hst->ip), ntohs(smtp_hst->port));
return 0;
break;
case connect_timeout:
- smtp_final(thread, 1, "Connection timeout to server [%s:%d]",
+ smtp_final(thread_obj, 1, "Connection timeout to server [%s:%d]",
inet_ntop2(smtp_hst->ip), ntohs(smtp_hst->port));
return 0;
break;
/* Enter the engine at SMTP_START */
smtp_chk->state = SMTP_START;
- smtp_engine_thread(thread);
+ smtp_engine_thread(thread_obj);
return 0;
break;
}
/* we shouldn't be here */
- smtp_final(thread, 1, "Unknown connection error to server [%s:%d]",
+ smtp_final(thread_obj, 1, "Unknown connection error to server [%s:%d]",
inet_ntop2(smtp_hst->ip), ntohs(smtp_hst->port));
return 0;
}
* but eventually has to happen.
*/
int
-smtp_connect_thread(thread *thread)
+smtp_connect_thread(thread *thread_obj)
{
- checker *chk = THREAD_ARG(thread);
+ checker *chk = THREAD_ARG(thread_obj);
smtp_checker *smtp_chk = CHECKER_ARG(chk);
smtp_host *smtp_hst;
enum connect_result status;
- int sock;
+ int sd;
/* Let's review our data structures.
*
* we don't fall of the face of the earth.
*/
if (!CHECKER_ENABLED(chk)) {
- thread_add_timer(thread->master, smtp_connect_thread, chk,
+ thread_add_timer(thread_obj->master, smtp_connect_thread, chk,
chk->vs->delay_loop);
return 0;
}
syslog(LOG_INFO, "Remote SMTP server [%s:%d] succeed on service.",
inet_ntop2(CHECKER_RIP(chk)), ntohs(CHECKER_RPORT(chk)));
- smtp_alert(thread->master, chk->rs, NULL, NULL, "UP",
+ smtp_alert(chk->rs, NULL, NULL, "UP",
"=> CHECK succeed on service <=");
update_svr_checker_state(UP, chk->id, chk->vs, chk->rs);
}
smtp_chk->host_ctr = 0;
smtp_chk->host_ptr = list_element(smtp_chk->host, 0);
- thread_add_timer(thread->master, smtp_connect_thread, chk, chk->vs->delay_loop);
+ thread_add_timer(thread_obj->master, smtp_connect_thread, chk, chk->vs->delay_loop);
return 0;
}
smtp_hst = smtp_chk->host_ptr;
/* Create the socket, failling here should be an oddity */
- if ((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {
+ if ((sd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {
DBG("SMTP_CHECK connection failed to create socket.");
- thread_add_timer(thread->master, smtp_connect_thread, chk,
+ thread_add_timer(thread_obj->master, smtp_connect_thread, chk,
chk->vs->delay_loop);
return 0;
}
- status = tcp_bind_connect(sock, smtp_hst->ip, smtp_hst->port, smtp_hst->bindto);
+ status = tcp_bind_connect(sd, smtp_hst->ip, smtp_hst->port, smtp_hst->bindto);
/* handle tcp connection status & register callback the next setp in the process */
- tcp_connection_state(sock, status, thread, smtp_check_thread, smtp_chk->timeout);
+ tcp_connection_state(sd, status, thread_obj, smtp_check_thread, smtp_chk->timeout);
return 0;
}
* url, compute a MD5 over this result and match it to the
* expected value.
*
- * Version: $Id: check_ssl.c,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: check_ssl.c,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Authors: Alexandre Cassen, <acassen@linux-vs.org>
* Jan Holmberg, <jan@artech.net>
}
int
-ssl_connect(thread * thread)
+ssl_connect(thread * thread_obj)
{
- checker *checker = THREAD_ARG(thread);
- http_get_checker *http_get_check = CHECKER_ARG(checker);
- http_arg *http_arg = HTTP_ARG(http_get_check);
- REQ *req = HTTP_REQ(http_arg);
+ checker *checker_obj = THREAD_ARG(thread_obj);
+ http_get_checker *http_get_check = CHECKER_ARG(checker_obj);
+ http_arg *http_arg_obj = HTTP_ARG(http_get_check);
+ REQ *req = HTTP_REQ(http_arg_obj);
req->ssl = SSL_new(check_data->ssl->ctx);
- req->bio = BIO_new_socket(thread->u.fd, BIO_NOCLOSE);
+ req->bio = BIO_new_socket(thread_obj->u.fd, BIO_NOCLOSE);
SSL_set_bio(req->ssl, req->bio, req->bio);
return (SSL_connect(req->ssl) > 0) ? 1 : 0;
/* Asynchronous SSL stream reader */
int
-ssl_read_thread(thread * thread)
+ssl_read_thread(thread * thread_obj)
{
- checker *checker = THREAD_ARG(thread);
- http_get_checker *http_get_check = CHECKER_ARG(checker);
- http_arg *http_arg = HTTP_ARG(http_get_check);
- REQ *req = HTTP_REQ(http_arg);
+ checker *checker_obj = THREAD_ARG(thread_obj);
+ http_get_checker *http_get_check = CHECKER_ARG(checker_obj);
+ http_arg *http_arg_obj = HTTP_ARG(http_get_check);
+ REQ *req = HTTP_REQ(http_arg_obj);
unsigned char digest[16];
int r = 0;
+ int val;
/* Handle read timeout */
- if (thread->type == THREAD_READ_TIMEOUT && !req->extracted)
- return timeout_epilog(thread, "=> SSL CHECK failed on service"
+ if (thread_obj->type == THREAD_READ_TIMEOUT && !req->extracted)
+ return timeout_epilog(thread_obj, "=> SSL CHECK failed on service"
" : recevice data <=\n\n", "SSL read");
+ /* Set descriptor non blocking */
+ val = fcntl(thread_obj->u.fd, F_GETFL, 0);
+ fcntl(thread_obj->u.fd, F_SETFL, val | O_NONBLOCK);
+
/* read the SSL stream */
r = SSL_read(req->ssl, req->buffer + req->len,
MAX_BUFFER_LENGTH - req->len);
+
+ /* restore descriptor flags */
+ fcntl(thread_obj->u.fd, F_SETFL, val);
+
req->error = SSL_get_error(req->ssl, r);
if (req->error) {
if (r && !req->extracted) {
/* check if server is currently alive */
- if (svr_checker_up(checker->id, checker->rs)) {
- smtp_alert(thread->master, checker->rs, NULL, NULL,
+ if (svr_checker_up(checker_obj->id, checker_obj->rs)) {
+ smtp_alert(checker_obj->rs, NULL, NULL,
"DOWN",
"=> SSL CHECK failed on service"
" : cannot receive data <=\n\n");
- update_svr_checker_state(DOWN, checker->id
- , checker->vs
- , checker->rs);
+ update_svr_checker_state(DOWN, checker_obj->id
+ , checker_obj->vs
+ , checker_obj->rs);
}
- return epilog(thread, 1, 0, 0);
+ return epilog(thread_obj, 1, 0, 0);
}
/* Handle response stream */
- http_handle_response(thread, digest, (!req->extracted) ? 1 : 0);
+ http_handle_response(thread_obj, digest, (!req->extracted) ? 1 : 0);
} else if (r > 0 && req->error == 0) {
* Register next ssl stream reader.
* Register itself to not perturbe global I/O multiplexer.
*/
- thread_add_read(thread->master, ssl_read_thread, checker,
- thread->u.fd, http_get_check->connection_to);
+ thread_add_read(thread_obj->master, ssl_read_thread, checker_obj,
+ thread_obj->u.fd, http_get_check->connection_to);
}
return 0;
*
* Part: TCP checker.
*
- * Version: $Id: check_tcp.c,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: check_tcp.c,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
}
int
-tcp_check_thread(thread * thread)
+tcp_check_thread(thread * thread_obj)
{
- checker *checker;
+ checker *checker_obj;
tcp_checker *tcp_check;
uint16_t addr_port;
int status;
- checker = THREAD_ARG(thread);
- tcp_check = CHECKER_ARG(checker);
+ checker_obj = THREAD_ARG(thread_obj);
+ tcp_check = CHECKER_ARG(checker_obj);
- addr_port = CHECKER_RPORT(checker);
+ addr_port = CHECKER_RPORT(checker_obj);
if (tcp_check->connection_port)
addr_port = tcp_check->connection_port;
- status = tcp_socket_state(thread->u.fd, thread, CHECKER_RIP(checker)
+ status = tcp_socket_state(thread_obj->u.fd, thread_obj, CHECKER_RIP(checker_obj)
, addr_port, tcp_check_thread);
/* If status = connect_success, TCP connection to remote host is established.
* Otherwise we have a real connection error or connection timeout.
*/
if (status == connect_success) {
- close(thread->u.fd);
+ close(thread_obj->u.fd);
- if (!svr_checker_up(checker->id, checker->rs)) {
+ if (!svr_checker_up(checker_obj->id, checker_obj->rs)) {
syslog(LOG_INFO, "TCP connection to [%s:%d] success.",
- inet_ntop2(CHECKER_RIP(checker))
+ inet_ntop2(CHECKER_RIP(checker_obj))
, ntohs(addr_port));
- smtp_alert(thread->master, checker->rs, NULL, NULL,
+ smtp_alert(checker_obj->rs, NULL, NULL,
"UP",
"=> TCP CHECK succeed on service <=");
- update_svr_checker_state(UP, checker->id
- , checker->vs
- , checker->rs);
+ update_svr_checker_state(UP, checker_obj->id
+ , checker_obj->vs
+ , checker_obj->rs);
}
} else {
- if (svr_checker_up(checker->id, checker->rs)) {
+ if (svr_checker_up(checker_obj->id, checker_obj->rs)) {
syslog(LOG_INFO, "TCP connection to [%s:%d] failed !!!",
- inet_ntop2(CHECKER_RIP(checker))
+ inet_ntop2(CHECKER_RIP(checker_obj))
, ntohs(addr_port));
- smtp_alert(thread->master, checker->rs, NULL, NULL,
+ smtp_alert(checker_obj->rs, NULL, NULL,
"DOWN",
"=> TCP CHECK failed on service <=");
- update_svr_checker_state(DOWN, checker->id
- , checker->vs
- , checker->rs);
+ update_svr_checker_state(DOWN, checker_obj->id
+ , checker_obj->vs
+ , checker_obj->rs);
}
}
/* Register next timer checker */
if (status != connect_in_progress)
- thread_add_timer(thread->master, tcp_connect_thread, checker,
- checker->vs->delay_loop);
+ thread_add_timer(thread_obj->master, tcp_connect_thread, checker_obj,
+ checker_obj->vs->delay_loop);
return 0;
}
int
-tcp_connect_thread(thread * thread)
+tcp_connect_thread(thread * thread_obj)
{
- checker *checker = THREAD_ARG(thread);
- tcp_checker *tcp_check = CHECKER_ARG(checker);
+ checker *checker_obj = THREAD_ARG(thread_obj);
+ tcp_checker *tcp_check = CHECKER_ARG(checker_obj);
int fd;
uint16_t addr_port;
int status;
* Register a new checker thread & return
* if checker is disabled
*/
- if (!CHECKER_ENABLED(checker)) {
- thread_add_timer(thread->master, tcp_connect_thread, checker,
- checker->vs->delay_loop);
+ if (!CHECKER_ENABLED(checker_obj)) {
+ thread_add_timer(thread_obj->master, tcp_connect_thread, checker_obj,
+ checker_obj->vs->delay_loop);
return 0;
}
return 0;
}
- addr_port = CHECKER_RPORT(checker);
+ addr_port = CHECKER_RPORT(checker_obj);
if (tcp_check->connection_port)
addr_port = tcp_check->connection_port;
- status = tcp_bind_connect(fd, CHECKER_RIP(checker), addr_port
+ status = tcp_bind_connect(fd, CHECKER_RIP(checker_obj), addr_port
, tcp_check->bindto);
/* handle tcp connection status & register check worker thread */
- tcp_connection_state(fd, status, thread, tcp_check_thread,
+ tcp_connection_state(fd, status, thread_obj, tcp_check_thread,
tcp_check->connection_to);
return 0;
}
* library to add/remove server MASQ rules to the kernel
* firewall framework.
*
- * Version: $Id: ipfwwrapper.c,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: ipfwwrapper.c,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
* Part: IPVS Kernel wrapper. Use setsockopt call to add/remove
* server to/from the loadbalanced server pool.
*
- * Version: $Id: ipvswrapper.c,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: ipvswrapper.c,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
*
* Part: Manipulation functions for IPVS & IPFW wrappers.
*
- * Version: $Id: ipwrapper.c,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: ipwrapper.c,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
virtual_server *vs;
virtual_server_group *vsg;
+ if (LIST_ISEMPTY(l))
+ return 0;
+
for (e = LIST_HEAD(l); e; ELEMENT_NEXT(e)) {
vs = ELEMENT_DATA(e);
if (VS_ISEQ(old_vs, vs)) {
element e;
real_server *rs;
+ if (LIST_ISEMPTY(l))
+ return 0;
+
for (e = LIST_HEAD(l); e; ELEMENT_NEXT(e)) {
rs = ELEMENT_DATA(e);
if (RS_ISEQ(rs, old_rs)) {
list l = check_data->vs;
virtual_server *vsvr;
+ if (LIST_ISEMPTY(l))
+ return NULL;
+
for (e = LIST_HEAD(l); e; ELEMENT_NEXT(e)) {
vsvr = ELEMENT_DATA(e);
if (VS_ISEQ(vs, vsvr))
real_server *rs;
char rsip[16], vsip[16];
+ /* If old vs didn't own rs then nothing return */
+ if (LIST_ISEMPTY(l))
+ return 1;
+
for (e = LIST_HEAD(l); e; ELEMENT_NEXT(e)) {
rs = ELEMENT_DATA(e);
if (!rs_exist(rs, new)) {
list l = old_check_data->vs;
virtual_server *vs;
+ /* If old config didn't own vs then nothing return */
+ if (LIST_ISEMPTY(l))
+ return 1;
+
/* Remove diff entries from previous IPVS rules */
for (e = LIST_HEAD(l); e; ELEMENT_NEXT(e)) {
vs = ELEMENT_DATA(e);
rm -f Makefile
-main.o: main.c ../include/main.h ../include/config.h
+main.o: main.c ../include/main.h ../include/config.h ../../lib/signals.h
daemon.o: daemon.c ../include/daemon.h ../../lib/utils.h
pidfile.o: pidfile.c ../include/pidfile.h
layer4.o: layer4.c ../include/layer4.h ../include/check_api.h ../../lib/utils.h
*
* Part: Main program structure.
*
- * Version: $Id: main.c,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: main.c,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
umask(0);
return 0;
}
-
-/*
- * SIGCHLD handler. Reap all zombie child.
- * WNOHANG prevent against parent process get
- * stuck waiting child termination.
- */
-void
-dummy_handler(int sig)
-{
- /* Dummy */
-}
-
-void
-signal_noignore_sigchld(void)
-{
- struct sigaction sa;
- sigset_t mask;
-
- /* Need to remove the NOCHLD flag */
- sigemptyset(&mask);
- sa.sa_handler = dummy_handler;
- sa.sa_mask = mask;
- sa.sa_flags = 0;
-
- sigaction(SIGCHLD, &sa, NULL);
-
- /* Block SIGCHLD so that we only receive it
- * when required (ie when its unblocked in the
- * select loop)
- */
- sigaddset(&mask, SIGCHLD);
- sigprocmask(SIG_BLOCK, &mask, NULL);
-}
-
-/* Signal wrapper */
-void *
-signal_set(int signo, void (*func) (int))
-{
- int ret;
- struct sigaction sig;
- struct sigaction osig;
-
- sig.sa_handler = func;
- sigemptyset(&sig.sa_mask);
- sig.sa_flags = 0;
-#ifdef SA_RESTART
- sig.sa_flags |= SA_RESTART;
-#endif /* SA_RESTART */
-
- ret = sigaction(signo, &sig, &osig);
-
- if (ret < 0)
- return (SIG_ERR);
- else
- return (osig.sa_handler);
-}
-
-/* Signal remove */
-void *
-signal_ignore(int signo)
-{
- return signal_set(signo, SIG_IGN);
-}
*
* Part: Dynamic data structure definition.
*
- * Version: $Id: global_data.c,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: global_data.c,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
/* Default settings */
static void
-set_default_router_id(conf_data * conf_data)
+set_default_router_id(conf_data * conf_data_obj)
{
char *new_id = NULL;
int len = 0;
return;
len = strlen(new_id);
- conf_data->router_id = MALLOC(len + 1);
- if (!conf_data->router_id)
+ conf_data_obj->router_id = MALLOC(len + 1);
+ if (!conf_data_obj->router_id)
return;
- memcpy(conf_data->router_id, new_id, len);
+ memcpy(conf_data_obj->router_id, new_id, len);
}
static void
-set_default_email_from(conf_data * conf_data)
+set_default_email_from(conf_data * conf_data_obj)
{
struct passwd *pwd = NULL;
char *hostname = NULL;
return;
len = strlen(hostname) + strlen(pwd->pw_name) + 2;
- conf_data->email_from = MALLOC(len);
- if (!conf_data->email_from)
+ conf_data_obj->email_from = MALLOC(len);
+ if (!conf_data_obj->email_from)
return;
- snprintf(conf_data->email_from, len, "%s@%s", pwd->pw_name, hostname);
+ snprintf(conf_data_obj->email_from, len, "%s@%s", pwd->pw_name, hostname);
}
static void
-set_default_smtp_server(conf_data * conf_data)
+set_default_smtp_server(conf_data * conf_data_obj)
{
- conf_data->smtp_server = htonl(DEFAULT_SMTP_SERVER);
+ conf_data_obj->smtp_server = htonl(DEFAULT_SMTP_SERVER);
}
static void
-set_default_smtp_connection_timeout(conf_data * conf_data)
+set_default_smtp_connection_timeout(conf_data * conf_data_obj)
{
- conf_data->smtp_connection_to = DEFAULT_SMTP_CONNECTION_TIMEOUT;
+ conf_data_obj->smtp_connection_to = DEFAULT_SMTP_CONNECTION_TIMEOUT;
}
static void
-set_default_values(conf_data * conf_data)
+set_default_values(conf_data * conf_data_obj)
{
/* No global data so don't default */
- if (!conf_data)
+ if (!conf_data_obj)
return;
- set_default_router_id(conf_data);
- set_default_smtp_server(conf_data);
- set_default_smtp_connection_timeout(conf_data);
- set_default_email_from(conf_data);
+ set_default_router_id(conf_data_obj);
+ set_default_smtp_server(conf_data_obj);
+ set_default_smtp_connection_timeout(conf_data_obj);
+ set_default_email_from(conf_data_obj);
}
/* email facility functions */
static void
-free_email(void *data)
+free_email(void *data_obj)
{
- FREE(data);
+ FREE(data_obj);
}
static void
-dump_email(void *data)
+dump_email(void *data_obj)
{
- char *addr = data;
+ char *addr = data_obj;
syslog(LOG_INFO, " Email notification = %s", addr);
}
}
void
-free_global_data(conf_data * data)
+free_global_data(conf_data * global_data)
{
free_list(data->email);
FREE_PTR(data->router_id);
}
void
-dump_global_data(conf_data * data)
+dump_global_data(conf_data * global_data)
{
if (!data)
return;
* data structure representation the conf file representing
* the loadbalanced server pool.
*
- * Version: $Id: global_parser.c,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: global_parser.c,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
static void
email_handler(vector strvec)
{
- vector email = read_value_block();
+ vector email_vec = read_value_block();
int i;
char *str;
- for (i = 0; i < VECTOR_SIZE(email); i++) {
- str = VECTOR_SLOT(email, i);
+ for (i = 0; i < VECTOR_SIZE(email_vec); i++) {
+ str = VECTOR_SLOT(email_vec, i);
alloc_email(str);
}
- free_strvec(email);
+ free_strvec(email_vec);
}
void
* Part: Layer4 checkers handling. Register worker threads &
* upper layer checkers.
*
- * Version: $Id: layer4.c,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: layer4.c,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
{
struct linger li = { 0 };
int long_inet;
- struct sockaddr_in sin;
+ struct sockaddr_in sa_in;
int ret;
int val;
/* Bind socket */
long_inet = sizeof (struct sockaddr_in);
- memset(&sin, 0, long_inet);
+ memset(&sa_in, 0, long_inet);
if (bind_ip) {
- sin.sin_family = AF_INET;
- sin.sin_addr.s_addr = bind_ip;
- if (bind(fd, (struct sockaddr *) &sin, sizeof (sin)) != 0)
+ sa_in.sin_family = AF_INET;
+ sa_in.sin_addr.s_addr = bind_ip;
+ if (bind(fd, (struct sockaddr *) &sa_in, sizeof (sa_in)) != 0)
return connect_error;
}
/* Set remote IP and connect */
- memset(&sin, 0, long_inet);
- sin.sin_family = AF_INET;
- sin.sin_port = addr_port;
- sin.sin_addr.s_addr = addr_ip;
+ memset(&sa_in, 0, long_inet);
+ sa_in.sin_family = AF_INET;
+ sa_in.sin_port = addr_port;
+ sa_in.sin_addr.s_addr = addr_ip;
- ret = connect(fd, (struct sockaddr *) &sin, long_inet);
+ ret = connect(fd, (struct sockaddr *) &sa_in, long_inet);
/* Immediate success */
if (ret == 0) {
}
enum connect_result
-tcp_socket_state(int fd, thread * thread, uint32_t addr_ip, uint16_t addr_port,
+tcp_socket_state(int fd, thread * thread_obj, uint32_t addr_ip, uint16_t addr_port,
int (*func) (struct _thread *))
{
int status;
TIMEVAL timer_min;
/* Handle connection timeout */
- if (thread->type == THREAD_WRITE_TIMEOUT) {
+ if (thread_obj->type == THREAD_WRITE_TIMEOUT) {
DBG("TCP connection timeout to [%s:%d].",
inet_ntop2(addr_ip), ntohs(addr_port));
- close(thread->u.fd);
+ close(thread_obj->u.fd);
return connect_timeout;
}
/* Check file descriptor */
slen = sizeof (status);
if (getsockopt
- (thread->u.fd, SOL_SOCKET, SO_ERROR, (void *) &status, &slen) < 0)
+ (thread_obj->u.fd, SOL_SOCKET, SO_ERROR, (void *) &status, &slen) < 0)
ret = errno;
/* Connection failed !!! */
if (ret) {
DBG("TCP connection failed to [%s:%d].",
inet_ntop2(addr_ip), ntohs(addr_port));
- close(thread->u.fd);
+ close(thread_obj->u.fd);
return connect_error;
}
DBG("TCP connection to [%s:%d] still IN_PROGRESS.",
inet_ntop2(addr_ip), ntohs(addr_port));
- timer_min = timer_sub_now(thread->sands);
- thread_add_write(thread->master, func, THREAD_ARG(thread)
- , thread->u.fd, TIMER_LONG(timer_min));
+ timer_min = timer_sub_now(thread_obj->sands);
+ thread_add_write(thread_obj->master, func, THREAD_ARG(thread_obj)
+ , thread_obj->u.fd, TIMER_LONG(timer_min));
return connect_in_progress;
} else if (status != 0) {
- close(thread->u.fd);
+ close(thread_obj->u.fd);
return connect_error;
}
}
void
-tcp_connection_state(int fd, enum connect_result status, thread * thread,
+tcp_connection_state(int fd, enum connect_result status, thread * thread_obj,
int (*func) (struct _thread *)
, long timeout)
{
- checker *checker;
+ checker *checker_obj;
- checker = THREAD_ARG(thread);
+ checker_obj = THREAD_ARG(thread_obj);
switch (status) {
case connect_error:
DBG("TCP connection ERROR to [%s:%d].",
- inet_ntop2(SVR_IP(checker->rs)),
- ntohs(SVR_PORT(checker->rs)));
+ inet_ntop2(SVR_IP(checker_obj->rs)),
+ ntohs(SVR_PORT(checker_obj->rs)));
close(fd);
break;
case connect_success:
DBG("TCP connection SUCCESS to [%s:%d].",
- inet_ntop2(SVR_IP(checker->rs)),
- ntohs(SVR_PORT(checker->rs)));
- thread_add_write(thread->master, func, checker, fd, timeout);
+ inet_ntop2(SVR_IP(checker_obj->rs)),
+ ntohs(SVR_PORT(checker_obj->rs)));
+ thread_add_write(thread_obj->master, func, checker_obj, fd, timeout);
break;
/* Checking non-blocking connect, we wait until socket is writable */
case connect_in_progress:
DBG("TCP connection to [%s:%d] now IN_PROGRESS.",
- inet_ntop2(SVR_IP(checker->rs)),
- ntohs(SVR_PORT(checker->rs)));
- thread_add_write(thread->master, func, checker, fd, timeout);
+ inet_ntop2(SVR_IP(checker_obj->rs)),
+ ntohs(SVR_PORT(checker_obj->rs)));
+ thread_add_write(thread_obj->master, func, checker_obj, fd, timeout);
break;
default:
*
* Part: Main program structure.
*
- * Version: $Id: main.c,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: main.c,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
#include "main.h"
#include "config.h"
+#include "signals.h"
/* global var */
char *conf_file = NULL; /* Configuration file */
sigend(int sig)
{
int status;
- sigset_t mask;
/* register the terminate thread */
syslog(LOG_INFO, "Terminating on signal");
thread_add_terminate_event(master);
- /*
- * Signal child process.
- * Disable and unblock the SIGCHLD handler
- * so that wait() works.
- */
- signal_ignore(SIGCHLD);
- sigemptyset(&mask);
- sigaddset(&mask, SIGCHLD);
- sigprocmask(SIG_UNBLOCK, &mask, NULL);
-
if (vrrp_child > 0) {
kill(vrrp_child, SIGTERM);
waitpid(vrrp_child, &status, WNOHANG);
void
signal_init(void)
{
+ signal_handler_init();
signal_set(SIGHUP, sighup);
signal_set(SIGINT, sigend);
signal_set(SIGTERM, sigend);
- signal_set(SIGKILL, sigend);
+ signal_ignore(SIGPIPE);
signal_noignore_sigchld();
}
parse_cmdline(int argc, char **argv)
{
poptContext context;
- char *optarg = NULL;
+ char *option_arg = NULL;
int c;
struct poptOption options_table[] = {
{"help", 'h', POPT_ARG_NONE, NULL, 'h'},
{"log-console", 'l', POPT_ARG_NONE, NULL, 'l'},
{"log-detail", 'D', POPT_ARG_NONE, NULL, 'D'},
- {"log-facility", 'S', POPT_ARG_STRING, &optarg, 'S'},
+ {"log-facility", 'S', POPT_ARG_STRING, &option_arg, 'S'},
{"dont-release-vrrp", 'V', POPT_ARG_NONE, NULL, 'V'},
{"dont-release-ipvs", 'I', POPT_ARG_NONE, NULL, 'I'},
{"dont-fork", 'n', POPT_ARG_NONE, NULL, 'n'},
{"dump-conf", 'd', POPT_ARG_NONE, NULL, 'd'},
- {"use-file", 'f', POPT_ARG_STRING, &optarg, 'f'},
+ {"use-file", 'f', POPT_ARG_STRING, &option_arg, 'f'},
{"vrrp", 'P', POPT_ARG_NONE, NULL, 'P'},
{"check", 'C', POPT_ARG_NONE, NULL, 'C'},
{NULL, 0, 0, NULL, 0}
debug |= 32;
break;
case 'S':
- log_facility = LOG_FACILITY[atoi(optarg)].facility;
+ log_facility = LOG_FACILITY[atoi(option_arg)].facility;
break;
case 'f':
- conf_file = optarg;
+ conf_file = option_arg;
break;
case 'P':
daemon_mode |= 1;
debug |= 32;
break;
case 'S':
- log_facility = LOG_FACILITY[atoi(optarg)].facility;
+ log_facility = LOG_FACILITY[atoi(option_arg)].facility;
break;
case 'f':
- conf_file = optarg;
+ conf_file = option_arg;
break;
case 'P':
daemon_mode |= 1;
}
/* check unexpected arguments */
- if ((optarg = (char *) poptGetArg(context))) {
- fprintf(stderr, "unexpected argument %s\n", optarg);
+ if ((option_arg = (char *) poptGetArg(context))) {
+ fprintf(stderr, "unexpected argument %s\n", option_arg);
return;
}
*
* Part: pidfile utility.
*
- * Version: $Id: pidfile.c,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: pidfile.c,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
* using the smtp protocol according to the RFC 821. A non blocking
* timeouted connection is used to handle smtp protocol.
*
- * Version: $Id: smtp.c,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: smtp.c,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
/* layer4 connection handlers */
static int
-connection_error(thread * thread)
+connection_error(thread * thread_obj)
{
- smtp_thread_arg *smtp_arg = THREAD_ARG(thread);
+ smtp_thread_arg *smtp_arg = THREAD_ARG(thread_obj);
syslog(LOG_INFO, "SMTP connection ERROR to [%s:%d].",
inet_ntop2(data->smtp_server), SMTP_PORT);
return 0;
}
static int
-connection_timeout(thread * thread)
+connection_timeout(thread * thread_obj)
{
- smtp_thread_arg *smtp_arg = THREAD_ARG(thread);
+ smtp_thread_arg *smtp_arg = THREAD_ARG(thread_obj);
syslog(LOG_INFO, "Timeout connecting SMTP server [%s:%d].",
inet_ntop2(data->smtp_server), SMTP_PORT);
return 0;
}
static int
-connection_in_progress(thread * thread)
+connection_in_progress(thread * thread_obj)
{
int status;
* each element of the structure have the same value.
*/
status =
- tcp_socket_state(thread->u.fd, thread, data->smtp_server,
+ tcp_socket_state(thread_obj->u.fd, thread_obj, data->smtp_server,
htons(SMTP_PORT), connection_in_progress);
if (status != connect_in_progress)
- SMTP_FSM_SEND(status, thread);
+ SMTP_FSM_SEND(status, thread_obj);
return 0;
}
static int
-connection_success(thread * thread)
+connection_success(thread * thread_obj)
{
- smtp_thread_arg *smtp_arg = THREAD_ARG(thread);
+ smtp_thread_arg *smtp_arg = THREAD_ARG(thread_obj);
syslog(LOG_INFO, "Remote SMTP server [%s:%d] connected.",
inet_ntop2(data->smtp_server), SMTP_PORT);
smtp_arg->stage = connect_success;
- thread_add_read(thread->master, smtp_read_thread, smtp_arg,
+ thread_add_read(thread_obj->master, smtp_read_thread, smtp_arg,
smtp_arg->fd, data->smtp_connection_to);
return 0;
}
/* SMTP protocol handlers */
static int
-smtp_read_thread(thread * thread)
+smtp_read_thread(thread * thread_obj)
{
smtp_thread_arg *smtp_arg;
char *buffer;
int rcv_buffer_size = 0;
int status = -1;
- smtp_arg = THREAD_ARG(thread);
+ smtp_arg = THREAD_ARG(thread_obj);
- if (thread->type == THREAD_READ_TIMEOUT) {
+ if (thread_obj->type == THREAD_READ_TIMEOUT) {
syslog(LOG_INFO,
"Timeout reading data to remote SMTP server [%s:%d].",
inet_ntop2(data->smtp_server), SMTP_PORT);
- SMTP_FSM_READ(QUIT, thread, 0);
+ SMTP_FSM_READ(QUIT, thread_obj, 0);
return -1;
}
buffer = smtp_arg->buffer;
- rcv_buffer_size = read(thread->u.fd, buffer + smtp_arg->buflen,
+ rcv_buffer_size = read(thread_obj->u.fd, buffer + smtp_arg->buflen,
SMTP_BUFFER_LENGTH - smtp_arg->buflen);
if (rcv_buffer_size == -1) {
syslog(LOG_INFO,
"Error reading data from remote SMTP server [%s:%d].",
inet_ntop2(data->smtp_server), SMTP_PORT);
- SMTP_FSM_READ(QUIT, thread, 0);
+ SMTP_FSM_READ(QUIT, thread_obj, 0);
return 0;
}
"Received buffer from remote SMTP server [%s:%d]"
" overflow our get read buffer length.",
inet_ntop2(data->smtp_server), SMTP_PORT);
- SMTP_FSM_READ(QUIT, thread, 0);
+ SMTP_FSM_READ(QUIT, thread_obj, 0);
return 0;
} else {
smtp_arg->buflen += rcv_buffer_size;
smtp_arg->buflen -= (reply - buffer);
buffer[smtp_arg->buflen] = 0;
- thread_add_read(thread->master, smtp_read_thread,
- smtp_arg, thread->u.fd,
+ thread_add_read(thread_obj->master, smtp_read_thread,
+ smtp_arg, thread_obj->u.fd,
data->smtp_connection_to);
return 0;
}
buffer[smtp_arg->buflen] = 0;
if (status == -1) {
- thread_add_read(thread->master, smtp_read_thread, smtp_arg,
- thread->u.fd, data->smtp_connection_to);
+ thread_add_read(thread_obj->master, smtp_read_thread, smtp_arg,
+ thread_obj->u.fd, data->smtp_connection_to);
return 0;
}
- SMTP_FSM_READ(smtp_arg->stage, thread, status);
+ SMTP_FSM_READ(smtp_arg->stage, thread_obj, status);
/* Registering next smtp command processing thread */
if (smtp_arg->stage != ERROR) {
- thread_add_write(thread->master, smtp_send_thread, smtp_arg,
+ thread_add_write(thread_obj->master, smtp_send_thread, smtp_arg,
smtp_arg->fd, data->smtp_connection_to);
} else {
syslog(LOG_INFO,
"Can not read data from remote SMTP server [%s:%d].",
inet_ntop2(data->smtp_server), SMTP_PORT);
- SMTP_FSM_READ(QUIT, thread, 0);
+ SMTP_FSM_READ(QUIT, thread_obj, 0);
}
return 0;
}
static int
-smtp_send_thread(thread * thread)
+smtp_send_thread(thread * thread_obj)
{
- smtp_thread_arg *smtp_arg = THREAD_ARG(thread);
+ smtp_thread_arg *smtp_arg = THREAD_ARG(thread_obj);
- if (thread->type == THREAD_WRITE_TIMEOUT) {
+ if (thread_obj->type == THREAD_WRITE_TIMEOUT) {
syslog(LOG_INFO,
"Timeout sending data to remote SMTP server [%s:%d].",
inet_ntop2(data->smtp_server), SMTP_PORT);
- SMTP_FSM_READ(QUIT, thread, 0);
+ SMTP_FSM_READ(QUIT, thread_obj, 0);
return 0;
}
- SMTP_FSM_SEND(smtp_arg->stage, thread);
+ SMTP_FSM_SEND(smtp_arg->stage, thread_obj);
/* Handle END command */
if (smtp_arg->stage == END) {
- SMTP_FSM_READ(QUIT, thread, 0);
+ SMTP_FSM_READ(QUIT, thread_obj, 0);
return 0;
}
/* Registering next smtp command processing thread */
if (smtp_arg->stage != ERROR) {
- thread_add_read(thread->master, smtp_read_thread, smtp_arg,
- thread->u.fd, data->smtp_connection_to);
+ thread_add_read(thread_obj->master, smtp_read_thread, smtp_arg,
+ thread_obj->u.fd, data->smtp_connection_to);
} else {
syslog(LOG_INFO,
"Can not send data to remote SMTP server [%s:%d].",
inet_ntop2(data->smtp_server), SMTP_PORT);
- SMTP_FSM_READ(QUIT, thread, 0);
+ SMTP_FSM_READ(QUIT, thread_obj, 0);
}
return 0;
}
static int
-connection_code(thread * thread, int status)
+connection_code(thread * thread_obj, int status)
{
- smtp_thread_arg *smtp_arg = THREAD_ARG(thread);
+ smtp_thread_arg *smtp_arg = THREAD_ARG(thread_obj);
if (status == 220) {
smtp_arg->stage++;
/* HELO command processing */
static int
-helo_cmd(thread * thread)
+helo_cmd(thread * thread_obj)
{
- smtp_thread_arg *smtp_arg = THREAD_ARG(thread);
+ smtp_thread_arg *smtp_arg = THREAD_ARG(thread_obj);
char *buffer;
buffer = (char *) MALLOC(SMTP_BUFFER_MAX);
snprintf(buffer, SMTP_BUFFER_MAX, SMTP_HELO_CMD, get_local_name());
- if (send(thread->u.fd, buffer, strlen(buffer), 0) == -1)
+ if (send(thread_obj->u.fd, buffer, strlen(buffer), 0) == -1)
smtp_arg->stage = ERROR;
FREE(buffer);
return 0;
}
static int
-helo_code(thread * thread, int status)
+helo_code(thread * thread_obj, int status)
{
- smtp_thread_arg *smtp_arg = THREAD_ARG(thread);
+ smtp_thread_arg *smtp_arg = THREAD_ARG(thread_obj);
if (status == 250) {
smtp_arg->stage++;
/* MAIL command processing */
static int
-mail_cmd(thread * thread)
+mail_cmd(thread * thread_obj)
{
- smtp_thread_arg *smtp_arg = THREAD_ARG(thread);
+ smtp_thread_arg *smtp_arg = THREAD_ARG(thread_obj);
char *buffer;
buffer = (char *) MALLOC(SMTP_BUFFER_MAX);
snprintf(buffer, SMTP_BUFFER_MAX, SMTP_MAIL_CMD, data->email_from);
- if (send(thread->u.fd, buffer, strlen(buffer), 0) == -1)
+ if (send(thread_obj->u.fd, buffer, strlen(buffer), 0) == -1)
smtp_arg->stage = ERROR;
FREE(buffer);
return 0;
}
static int
-mail_code(thread * thread, int status)
+mail_code(thread * thread_obj, int status)
{
- smtp_thread_arg *smtp_arg = THREAD_ARG(thread);
+ smtp_thread_arg *smtp_arg = THREAD_ARG(thread_obj);
if (status == 250) {
smtp_arg->stage++;
/* RCPT command processing */
static int
-rcpt_cmd(thread * thread)
+rcpt_cmd(thread * thread_obj)
{
- smtp_thread_arg *smtp_arg = THREAD_ARG(thread);
+ smtp_thread_arg *smtp_arg = THREAD_ARG(thread_obj);
char *buffer;
char *fetched_email;
fetched_email = fetch_next_email(smtp_arg);
snprintf(buffer, SMTP_BUFFER_MAX, SMTP_RCPT_CMD, fetched_email);
- if (send(thread->u.fd, buffer, strlen(buffer), 0) == -1)
+ if (send(thread_obj->u.fd, buffer, strlen(buffer), 0) == -1)
smtp_arg->stage = ERROR;
FREE(buffer);
return 0;
}
static int
-rcpt_code(thread * thread, int status)
+rcpt_code(thread * thread_obj, int status)
{
- smtp_thread_arg *smtp_arg = THREAD_ARG(thread);
+ smtp_thread_arg *smtp_arg = THREAD_ARG(thread_obj);
char *fetched_email;
if (status == 250) {
/* DATA command processing */
static int
-data_cmd(thread * thread)
+data_cmd(thread * thread_obj)
{
- smtp_thread_arg *smtp_arg = THREAD_ARG(thread);
+ smtp_thread_arg *smtp_arg = THREAD_ARG(thread_obj);
- if (send(thread->u.fd, SMTP_DATA_CMD, strlen(SMTP_DATA_CMD), 0)
+ if (send(thread_obj->u.fd, SMTP_DATA_CMD, strlen(SMTP_DATA_CMD), 0)
== -1)
smtp_arg->stage = ERROR;
return 0;
}
static int
-data_code(thread * thread, int status)
+data_code(thread * thread_obj, int status)
{
- smtp_thread_arg *smtp_arg = THREAD_ARG(thread);
+ smtp_thread_arg *smtp_arg = THREAD_ARG(thread_obj);
if (status == 354) {
smtp_arg->stage++;
* handling ? Don t really think :)
*/
static int
-body_cmd(thread * thread)
+body_cmd(thread * thread_obj)
{
- smtp_thread_arg *smtp_arg = THREAD_ARG(thread);
+ smtp_thread_arg *smtp_arg = THREAD_ARG(thread_obj);
char *buffer;
char rfc822[80];
time_t tm;
rfc822, data->email_from, smtp_arg->subject);
/* send the subject field */
- if (send(thread->u.fd, buffer, strlen(buffer), 0) == -1)
+ if (send(thread_obj->u.fd, buffer, strlen(buffer), 0) == -1)
smtp_arg->stage = ERROR;
memset(buffer, 0, SMTP_BUFFER_MAX);
snprintf(buffer, SMTP_BUFFER_MAX, SMTP_BODY_CMD, smtp_arg->body);
/* send the the body field */
- if (send(thread->u.fd, buffer, strlen(buffer), 0) == -1)
+ if (send(thread_obj->u.fd, buffer, strlen(buffer), 0) == -1)
smtp_arg->stage = ERROR;
/* send the sending dot */
- if (send(thread->u.fd, SMTP_SEND_CMD, strlen(SMTP_SEND_CMD), 0)
+ if (send(thread_obj->u.fd, SMTP_SEND_CMD, strlen(SMTP_SEND_CMD), 0)
== -1)
smtp_arg->stage = ERROR;
return 0;
}
static int
-body_code(thread * thread, int status)
+body_code(thread * thread_obj, int status)
{
- smtp_thread_arg *smtp_arg = THREAD_ARG(thread);
+ smtp_thread_arg *smtp_arg = THREAD_ARG(thread_obj);
if (status == 250) {
syslog(LOG_INFO, "SMTP alert successfully sent.");
/* QUIT command processing */
static int
-quit_cmd(thread * thread)
+quit_cmd(thread * thread_obj)
{
- smtp_thread_arg *smtp_arg = THREAD_ARG(thread);
+ smtp_thread_arg *smtp_arg = THREAD_ARG(thread_obj);
- if (send(thread->u.fd, SMTP_QUIT_CMD, strlen(SMTP_QUIT_CMD), 0)
+ if (send(thread_obj->u.fd, SMTP_QUIT_CMD, strlen(SMTP_QUIT_CMD), 0)
== -1)
smtp_arg->stage = ERROR;
else
return 0;
}
static int
-quit_code(thread * thread, int status)
+quit_code(thread * thread_obj, int status)
{
- smtp_thread_arg *smtp_arg = THREAD_ARG(thread);
+ smtp_thread_arg *smtp_arg = THREAD_ARG(thread_obj);
/* final state, we are disconnected from the remote host */
free_smtp_all(smtp_arg);
- close(thread->u.fd);
+ close(thread_obj->u.fd);
return 0;
}
/* Main entry point */
void
-smtp_alert(thread_master * master, real_server * rs, vrrp_rt * vrrp,
+smtp_alert(real_server * rs, vrrp_rt * vrrp,
vrrp_sgroup * vgroup, const char *subject, const char *body)
{
smtp_thread_arg *smtp_arg;
*
* Part: Checkers arguments structures definitions.
*
- * Version: $Id: check_api.h,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: check_api.h,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
/* Checkers structure definition */
typedef struct _checker {
- void (*free) (void *);
- void (*dump) (void *);
+ void (*free_func) (void *);
+ void (*dump_func) (void *);
int (*launch) (struct _thread *);
int (*plugin_launch) (void *);
virtual_server *vs; /* pointer to the checker thread virtualserver */
/* Prototypes definition */
extern void init_checkers_queue(void);
-extern void queue_checker(void (*free) (void *), void (*dump) (void *)
+extern void queue_checker(void (*free_func) (void *), void (*dump_func) (void *)
, int (*launch) (struct _thread *)
, void *data);
extern void dump_checkers_queue(void);
*
* Part: check_daemon.c include file.
*
- * Version: $Id: check_daemon.h,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: check_daemon.h,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
*
* Part: Healthcheckers dynamic data structure definition.
*
- * Version: $Id: check_data.h,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: check_data.h,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
extern void alloc_rsgroup(char *ip, char *port);
extern void set_rsgroup(char *gname);
extern check_conf_data *alloc_check_data(void);
-extern void free_check_data(check_conf_data * data);
-extern void dump_check_data(check_conf_data * data);
+extern void free_check_data(check_conf_data * check_data_obj);
+extern void dump_check_data(check_conf_data * check_data_obj);
#endif
*
* Part: check_http.c include file.
*
- * Version: $Id: check_http.h,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: check_http.h,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Authors: Alexandre Cassen, <acassen@linux-vs.org>
* Jan Holmberg, <jan@artech.net>
/* Define prototypes */
extern void install_http_check_keyword(void);
-extern int epilog(thread * thread, int metod, int t, int c);
-extern int timeout_epilog(thread * thread, char *smtp_msg, char *debug_msg);
+extern int epilog(thread * thread_obj, int metod, int t, int c);
+extern int timeout_epilog(thread * thread_obj, char *smtp_msg, char *debug_msg);
extern url *fetch_next_url(http_get_checker * http_get_check);
extern int http_process_response(REQ * req, int r);
-extern int http_handle_response(thread * thread, unsigned char digest[16]
+extern int http_handle_response(thread * thread_obj, unsigned char digest[16]
, int empty_buffer);
#endif
*
* Part: check_misc.c include file.
*
- * Version: $Id: check_misc.h,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: check_misc.h,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
* Eric Jarman, <ehj38230@cmsu2.cmsu.edu>
*
* Part: check_parser.c include file.
*
- * Version: $Id: check_parser.h,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: check_parser.h,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
*
* Part: check_smtp.c include file.
*
- * Version: $Id: check_smtp.h,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: check_smtp.h,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
* Jeremy Rumpf, <jrumpf@heavyload.net>
*
* Part: check_http.c include file.
*
- * Version: $Id: check_http.h,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: check_http.h,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Authors: Alexandre Cassen, <acassen@linux-vs.org>
* Jan Holmberg, <jan@artech.net>
extern void install_ssl_check_keyword(void);
extern int init_ssl_ctx(void);
extern void clear_ssl(SSL_DATA * ssl);
-extern int ssl_connect(thread * thread);
+extern int ssl_connect(thread * thread_obj);
extern int ssl_printerr(int err);
extern int ssl_send_request(SSL * ssl, char *str_request, int request_len);
-extern int ssl_read_thread(thread * thread);
+extern int ssl_read_thread(thread * thread_obj);
#endif
*
* Part: check_tcp.c include file.
*
- * Version: $Id: check_tcp.h,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: check_tcp.h,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
*
* Part: Configuration include file.
*
- * Version: $Id: config.h.in,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: config.h.in,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Jacob Rief, <jacob.rief@tiscover.com>
*
*
* Part: Daemon process handling.
*
- * Version: $Id: daemon.h,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: daemon.h,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
#include <unistd.h>
#include <errno.h>
#include <fcntl.h>
-#include <signal.h>
/* prototype */
extern pid_t xdaemon(int, int, int);
-extern void *signal_set(int signo, void (*func) (int));
-extern void *signal_ignore(int signo);
-extern void signal_noignore_sigchld(void);
#endif
*
* Part: Dynamic data structure definition.
*
- * Version: $Id: global_data.h,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: global_data.h,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
/* Prototypes */
extern void alloc_email(char *addr);
extern conf_data *alloc_global_data(void);
-extern void free_global_data(conf_data *data);
-extern void dump_global_data(conf_data *data);
+extern void free_global_data(conf_data *global_data);
+extern void dump_global_data(conf_data *global_data);
#endif
*
* Part: vrrp_parser.c include file.
*
- * Version: $Id: global_parser.h,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: global_parser.h,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
*
* Part: ipfwwrapper.c include file.
*
- * Version: $Id: ipfwwrapper.h,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: ipfwwrapper.h,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
*
* Part: ipvswrapper.c include file.
*
- * Version: $Id: ipvswrapper.h,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: ipvswrapper.h,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
*
* Part: ipwrapper.c include file.
*
- * Version: $Id: ipwrapper.h,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: ipwrapper.h,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
*
* Part: layer4.c include file.
*
- * Version: $Id: layer4.h,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: layer4.h,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
*
* Part: Main program include file.
*
- * Version: $Id: main.h,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: main.h,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
*
* Part: pidfile.c include file.
*
- * Version: $Id: pidfile.h,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: pidfile.h,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
*
* Part: smtp.c include file.
*
- * Version: $Id: smtp.h,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: smtp.h,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
#define SMTP_QUIT_CMD "QUIT\r\n"
/* Prototypes defs */
-extern void smtp_alert(thread_master *,
- real_server *, vrrp_rt *, vrrp_sgroup *,
+extern void smtp_alert(real_server *, vrrp_rt *, vrrp_sgroup *,
const char *, const char *);
#endif
*
* Part: vrrp.c program include file.
*
- * Version: $Id: vrrp.h,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: vrrp.h,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
typedef struct _vrrp_sgroup {
char *gname; /* Group name */
vector iname; /* Set of VRRP instances in this group */
- list index; /* List of VRRP instances */
+ list index_list; /* List of VRRP instances */
int state; /* current stable state */
/* State transition notification */
((!LIST_ISEMPTY((V)->track_ifp)) ? TRACK_ISUP((V)->track_ifp) : 1))
/* prototypes */
-extern int open_vrrp_send_socket(const int proto, const int index);
-extern int open_vrrp_socket(const int proto, const int index);
+extern int open_vrrp_send_socket(const int proto, const int idx);
+extern int open_vrrp_socket(const int proto, const int idx);
extern int new_vrrp_socket(vrrp_rt * vrrp);
extern void close_vrrp_socket(vrrp_rt * vrrp);
extern void vrrp_send_gratuitous_arp(vrrp_rt * vrrp);
*
* Part: vrrp_arp.c include file.
*
- * Version: $Id: vrrp_arp.h,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: vrrp_arp.h,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
*
* Part: vrrp_daemon.c include file.
*
- * Version: $Id: vrrp_daemon.h,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: vrrp_daemon.h,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
*
* Part: Dynamic data structure definition.
*
- * Version: $Id: vrrp_data.h,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: vrrp_data.h,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
extern void alloc_vrrp_buffer(void);
extern void free_vrrp_buffer(void);
extern vrrp_conf_data *alloc_vrrp_data(void);
-extern void free_vrrp_data(vrrp_conf_data * data);
-extern void dump_vrrp_data(vrrp_conf_data * data);
+extern void free_vrrp_data(vrrp_conf_data * vrrp_data_obj);
+extern void dump_vrrp_data(vrrp_conf_data * vrrp_data_obj);
#endif
*
* Part: vrrp_if.c include file.
*
- * Version: $Id: vrrp_if.h,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: vrrp_if.h,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
extern int if_mii_probe(const char *ifname);
extern int if_ethtool_probe(const char *ifname);
extern void if_add_queue(interface * ifp);
-extern int if_monitor_thread(thread * thread);
+extern int if_monitor_thread(thread * thread_obj);
extern void init_interface_queue(void);
extern void free_interface_queue(void);
-extern void dump_if(void *data);
+extern void dump_if(void *if_data_obj);
extern int if_join_vrrp_group(int sd, interface * ifp, int proto);
extern void if_leave_vrrp_group(int sd, interface * ifp);
extern int if_setsockopt_bindtodevice(int sd, interface * ifp);
*
* Part: vrrp_index.c include file.
*
- * Version: $Id: vrrp_index.h,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: vrrp_index.h,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
*
* Part: vrrp_ipaddress.c include file.
*
- * Version: $Id: vrrp_ipaddress.h,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: vrrp_ipaddress.h,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
/* prototypes */
extern int netlink_address_ipv4(ip_address * ipaddr, int cmd);
extern void netlink_iplist_ipv4(list ip_list, int cmd);
-extern void free_ipaddress(void *data);
-extern void dump_ipaddress(void *data);
+extern void free_ipaddress(void *ip_data_obj);
+extern void dump_ipaddress(void *ip_data_obj);
extern void alloc_ipaddress(list ip_list, vector strvec, interface * ifp);
extern void clear_diff_address(list l, list n);
extern void clear_diff_saddresses(void);
*
* Part: vrrp_iproute.c include file.
*
- * Version: $Id: vrrp_iproute.h,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: vrrp_iproute.h,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
/* prototypes */
extern int netlink_route_ipv4(ip_route *iproute, int cmd);
extern void netlink_rtlist_ipv4(list rt_list, int cmd);
-extern void free_iproute(void *data);
-extern void dump_iproute(void *data);
+extern void free_iproute(void *rt_data_obj);
+extern void dump_iproute(void *rt_data_obj);
extern void alloc_route(list rt_list, vector strvec);
extern void clear_diff_routes(list l, list n);
extern void clear_diff_sroutes(void);
*
* Part: vrrp_ipsecah.c include file.
*
- * Version: $Id: vrrp_ipsecah.h,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: vrrp_ipsecah.h,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
*
* Part: vrrp_netlink.c include file.
*
- * Version: $Id: vrrp_netlink.h,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: vrrp_netlink.h,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
extern struct nl_handle nl_cmd; /* Command channel */
/* prototypes */
-extern int addattr32(struct nlmsghdr *n, int maxlen, int type, uint32_t data);
-extern int addattr_l(struct nlmsghdr *n, int maxlen, int type, void *data,
+extern int addattr32(struct nlmsghdr *n, int maxlen, int type, uint32_t data_obj);
+extern int addattr_l(struct nlmsghdr *n, int maxlen, int type, void *data_obj,
int alen);
extern char *netlink_scope_n2a(int scope);
extern int netlink_scope_a2n(char *scope);
extern int netlink_interface_lookup(void);
extern int netlink_interface_refresh(void);
extern void kernel_netlink_init(void);
+extern void kernel_netlink_close(void);
#endif
*
* Part: vrrp_notify.c include file.
*
- * Version: $Id: vrrp_notify.h,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: vrrp_notify.h,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
*
* Part: vrrp_parser.c include file.
*
- * Version: $Id: vrrp_parser.h,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: vrrp_parser.h,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
*
* Part: vrrp_scheduler.c include file.
*
- * Version: $Id: vrrp_scheduler.h,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: vrrp_scheduler.h,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
} while (0)
/* extern prototypes */
-extern void vrrp_dispatcher_release(vrrp_conf_data * data);
-extern int vrrp_dispatcher_init(thread * thread);
-extern int vrrp_read_dispatcher_thread(thread * thread);
+extern void vrrp_dispatcher_release(vrrp_conf_data * conf_data_obj);
+extern int vrrp_dispatcher_init(thread * thread_obj);
+extern int vrrp_read_dispatcher_thread(thread * thread_obj);
#endif
*
* Part: vrrp_sync.c include file.
*
- * Version: $Id: vrrp_sync.h,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: vrrp_sync.h,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
*
* Part: vrrp_track.c include file.
*
- * Version: $Id: vrrp_track.h,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: vrrp_track.h,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
#define TRACK_ISUP(L) (vrrp_tracked_up((L)))
/* prototypes */
-extern void dump_track(void *data);
+extern void dump_track(void *track_data_obj);
extern void alloc_track(list track_list, vector strvec);
extern int vrrp_tracked_up(list l);
extern void vrrp_log_tracked_down(list l);
}
-int ipvs_start_daemon(ipvs_daemon_t *dm)
+static int _ipvs_start_daemon(void *dm)
{
ipvs_func = ipvs_start_daemon;
- return setsockopt(sockfd, IPPROTO_IP, IP_VS_SO_SET_STARTDAEMON,
- (char *)dm, sizeof(*dm));
+ setsockopt(sockfd, IPPROTO_IP, IP_VS_SO_SET_STARTDAEMON,
+ (char *)dm, sizeof(struct ip_vs_daemon_user));
+ exit(0);
}
-extern int ipvs_stop_daemon(ipvs_daemon_t *dm)
+static int _ipvs_stop_daemon(void *dm)
{
ipvs_func = ipvs_stop_daemon;
- return setsockopt(sockfd, IPPROTO_IP, IP_VS_SO_SET_STOPDAEMON,
- (char *)dm, sizeof(*dm));
+ setsockopt(sockfd, IPPROTO_IP, IP_VS_SO_SET_STOPDAEMON,
+ (char *)dm, sizeof(struct ip_vs_daemon_user));
+ exit(0);
+}
+
+int ipvs_start_daemon(ipvs_daemon_t *dm)
+{
+ pid_t pid;
+
+ pid = fork();
+ if (pid == 0) {
+ _ipvs_start_daemon(dm);
+ exit(0);
+ } else if (pid > 0)
+ return 0;
+ return 1;
+}
+
+int ipvs_stop_daemon(ipvs_daemon_t *dm)
+{
+ pid_t pid;
+
+ pid = fork();
+ if (pid == 0) {
+ _ipvs_stop_daemon(dm);
+ exit(0);
+ } else if (pid > 0)
+ return 0;
+ return 1;
}
struct ip_vs_get_services *ipvs_get_services(void)
../include/vrrp_if.h ../include/vrrp_arp.h ../include/vrrp_netlink.h ../include/vrrp_iproute.h \
../include/vrrp_iproute.h ../include/vrrp_parser.h ../include/vrrp_data.h \
../include/vrrp.h ../include/global_data.h ../include/pidfile.h ../include/daemon.h \
- ../include/ipvswrapper.h ../../lib/list.h ../../lib/memory.h ../../lib/parser.h
+ ../include/ipvswrapper.h ../../lib/list.h ../../lib/memory.h ../../lib/parser.h \
+ ../../lib/signals.h
vrrp_data.o: vrrp_data.c ../include/vrrp_data.h \
../include/vrrp_sync.h ../include/vrrp_index.h ../include/vrrp.h ../../lib/memory.h \
../../lib/utils.h
* master fails, a backup server takes over.
* The original implementation has been made by jerome etienne.
*
- * Version: $Id: vrrp.c,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: vrrp.c,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
void
vrrp_restore_interface(vrrp_rt * vrrp, int advF)
{
+ /* remove virtual routes */
+ if (!LIST_ISEMPTY(vrrp->vroutes))
+ vrrp_handle_iproutes(vrrp, IPROUTE_DEL);
+
/*
* Remove the ip addresses.
*
vrrp->vipset = 0;
}
- /* remove virtual routes */
- if (!LIST_ISEMPTY(vrrp->vroutes))
- vrrp_handle_iproutes(vrrp, IPROUTE_DEL);
/* if we stop vrrp, warn the other routers to speed up the recovery */
if (advF)
/* open a VRRP sending socket */
int
-open_vrrp_send_socket(const int proto, const int index)
+open_vrrp_send_socket(const int proto, const int idx)
{
interface *ifp;
int fd = -1;
/* Retreive interface */
- ifp = if_get_by_ifindex(index);
+ ifp = if_get_by_ifindex(idx);
/* Create and init socket descriptor */
fd = socket(AF_INET, SOCK_RAW, proto);
/* open a VRRP socket and join the multicast group. */
int
-open_vrrp_socket(const int proto, const int index)
+open_vrrp_socket(const int proto, const int idx)
{
interface *ifp;
int fd = -1;
/* Retreive interface */
- ifp = if_get_by_ifindex(index);
+ ifp = if_get_by_ifindex(idx);
/* open the socket */
fd = socket(AF_INET, SOCK_RAW, proto);
list l = vrrp_data->vrrp;
vrrp_rt *vrrp;
+ if (LIST_ISEMPTY(l))
+ return NULL;
+
for (e = LIST_HEAD(l); e; ELEMENT_NEXT(e)) {
vrrp = ELEMENT_DATA(e);
if (!strcmp(vrrp->iname, old_vrrp->iname))
list l = old_vrrp_data->vrrp;
vrrp_rt *vrrp;
+ if (LIST_ISEMPTY(l))
+ return;
+
for (e = LIST_HEAD(l); e; ELEMENT_NEXT(e)) {
vrrp = ELEMENT_DATA(e);
*
* Part: ARP primitives.
*
- * Version: $Id: vrrp_arp.c,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: vrrp_arp.c,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
*
* Part: VRRP child process handling.
*
- * Version: $Id: vrrp_daemon.c,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: vrrp_daemon.c,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
#include "global_data.h"
#include "pidfile.h"
#include "daemon.h"
+#include "signals.h"
#ifdef _WITH_LVS_
#include "ipvswrapper.h"
#endif
thread_destroy_master(master);
/* Clear static entries */
- netlink_iplist_ipv4(vrrp_data->static_addresses, IPADDRESS_DEL);
netlink_rtlist_ipv4(vrrp_data->static_routes, IPROUTE_DEL);
+ netlink_iplist_ipv4(vrrp_data->static_addresses, IPADDRESS_DEL);
if (!(debug & 8))
shutdown_vrrp_instances();
/* Reload handler */
int
-reload_vrrp_thread(thread * thread)
+reload_vrrp_thread(thread * thread_obj)
{
/* set the reloading flag */
SET_RELOAD;
void
vrrp_signal_init(void)
{
+ signal_handler_init();
signal_set(SIGHUP, sighup_vrrp);
signal_set(SIGINT, sigend_vrrp);
signal_set(SIGTERM, sigend_vrrp);
- signal_set(SIGKILL, sigend_vrrp);
+ signal_ignore(SIGPIPE);
signal_noignore_sigchld();
}
/* VRRP Child respawning thread */
int
-vrrp_respawn_thread(thread * thread)
+vrrp_respawn_thread(thread * thread_obj)
{
pid_t pid;
/* Fetch thread args */
- pid = THREAD_CHILD_PID(thread);
+ pid = THREAD_CHILD_PID(thread_obj);
/* Restart respawning thread */
- if (thread->type == THREAD_CHILD_TIMEOUT) {
+ if (thread_obj->type == THREAD_CHILD_TIMEOUT) {
thread_add_child(master, vrrp_respawn_thread, NULL,
pid, RESPAWN_TIMER);
return 0;
*
* Part: Dynamic data structure definition.
*
- * Version: $Id: vrrp_data.c,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: vrrp_data.c,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
FREE(vgroup->gname);
free_strvec(vgroup->iname);
- free_list(vgroup->index);
+ free_list(vgroup->index_list);
FREE_PTR(vgroup->script_backup);
FREE_PTR(vgroup->script_master);
FREE_PTR(vgroup->script_fault);
}
/* Socket pool functions */
-void
-free_sock(void *data)
+static void
+free_sock(void *sock_data_obj)
{
- sock *sock = data;
- interface *ifp = if_get_by_ifindex(sock->ifindex);
- if_leave_vrrp_group(sock->fd_in, ifp);
- close(sock->fd_out);
- FREE(data);
+ sock *sock_obj = sock_data_obj;
+ interface *ifp = if_get_by_ifindex(sock_obj->ifindex);
+ if_leave_vrrp_group(sock_obj->fd_in, ifp);
+ close(sock_obj->fd_out);
+ FREE(sock_data_obj);
}
-void
-dump_sock(void *data)
+static void
+dump_sock(void *sock_data_obj)
{
- sock *sock = data;
+ sock *sock_obj = sock_data_obj;
syslog(LOG_INFO, "VRRP sockpool: [ifindex(%d), proto(%d), fd(%d,%d)]",
- sock->ifindex
- , sock->proto
- , sock->fd_in
- , sock->fd_out);
+ sock_obj->ifindex
+ , sock_obj->proto
+ , sock_obj->fd_in
+ , sock_obj->fd_out);
}
static void
}
void
-free_vrrp_data(vrrp_conf_data * vrrp_data)
+free_vrrp_data(vrrp_conf_data * vrrp_data_obj)
{
- free_list(vrrp_data->static_addresses);
- free_list(vrrp_data->static_routes);
- free_mlist(vrrp_data->vrrp_index, 255);
- free_mlist(vrrp_data->vrrp_index_fd, 1024+1);
- free_list(vrrp_data->vrrp);
- free_list(vrrp_data->vrrp_sync_group);
- free_list(vrrp_data->vrrp_socket_pool);
- FREE(vrrp_data);
+ free_list(vrrp_data_obj->static_addresses);
+ free_list(vrrp_data_obj->static_routes);
+ free_mlist(vrrp_data_obj->vrrp_index, 255);
+ free_mlist(vrrp_data_obj->vrrp_index_fd, 1024+1);
+ free_list(vrrp_data_obj->vrrp);
+ free_list(vrrp_data_obj->vrrp_sync_group);
+ free_list(vrrp_data_obj->vrrp_socket_pool);
+ FREE(vrrp_data_obj);
}
void
-dump_vrrp_data(vrrp_conf_data * vrrp_data)
+dump_vrrp_data(vrrp_conf_data * vrrp_data_obj)
{
- if (!LIST_ISEMPTY(vrrp_data->static_addresses)) {
+ if (!LIST_ISEMPTY(vrrp_data_obj->static_addresses)) {
syslog(LOG_INFO, "------< Static Addresses >------");
- dump_list(vrrp_data->static_addresses);
+ dump_list(vrrp_data_obj->static_addresses);
}
- if (!LIST_ISEMPTY(vrrp_data->static_routes)) {
+ if (!LIST_ISEMPTY(vrrp_data_obj->static_routes)) {
syslog(LOG_INFO, "------< Static Routes >------");
- dump_list(vrrp_data->static_routes);
+ dump_list(vrrp_data_obj->static_routes);
}
- if (!LIST_ISEMPTY(vrrp_data->vrrp)) {
+ if (!LIST_ISEMPTY(vrrp_data_obj->vrrp)) {
syslog(LOG_INFO, "------< VRRP Topology >------");
- dump_list(vrrp_data->vrrp);
+ dump_list(vrrp_data_obj->vrrp);
}
- if (!LIST_ISEMPTY(vrrp_data->vrrp_sync_group)) {
+ if (!LIST_ISEMPTY(vrrp_data_obj->vrrp_sync_group)) {
syslog(LOG_INFO, "------< VRRP Sync groups >------");
- dump_list(vrrp_data->vrrp_sync_group);
+ dump_list(vrrp_data_obj->vrrp_sync_group);
}
}
*
* Part: Interfaces manipulation.
*
- * Version: $Id: vrrp_if.c,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: vrrp_if.c,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
}
void
-dump_if(void *data)
+dump_if(void *if_data_obj)
{
- interface *ifp = data;
+ interface *ifp = if_data_obj;
syslog(LOG_INFO, "------< NIC >------");
syslog(LOG_INFO, " Name = %s", ifp->ifname);
#ifndef _WITH_LINKWATCH_
static int
-if_linkbeat_refresh_thread(thread * thread)
+if_linkbeat_refresh_thread(thread * thread_obj)
{
- interface *ifp = THREAD_ARG(thread);
+ interface *ifp = THREAD_ARG(thread_obj);
if (IF_MII_SUPPORTED(ifp))
ifp->linkbeat = (if_mii_probe(ifp->ifname)) ? 1 : 0;
{
if (!LIST_ISEMPTY(if_queue))
free_list(if_queue);
- netlink_close(&nl_kernel);
- netlink_close(&nl_cmd);
+ if_queue = NULL;
+ kernel_netlink_close();
}
void
*
* Part: VRRP instance index table.
*
- * Version: $Id: vrrp_index.c,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: vrrp_index.c,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
*
* Part: NETLINK IPv4 address manipulation.
*
- * Version: $Id: vrrp_ipaddress.c,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: vrrp_ipaddress.c,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
/* IP address dump/allocation */
void
-free_ipaddress(void *data)
+free_ipaddress(void *if_data_obj)
{
- FREE(data);
+ FREE(if_data_obj);
}
void
-dump_ipaddress(void *data)
+dump_ipaddress(void *if_data_obj)
{
- ip_address *ip_addr = data;
+ ip_address *ip_addr = if_data_obj;
syslog(LOG_INFO, " %s/%d brd %s dev %s scope %s"
, inet_ntop2(ip_addr->addr)
, ip_addr->mask
*
* Part: NETLINK IPv4 routes manipulation.
*
- * Version: $Id: vrrp_iproute.c,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: vrrp_iproute.c,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
/* Route dump/allocation */
void
-free_iproute(void *data)
+free_iproute(void *rt_data_obj)
{
- FREE(data);
+ FREE(rt_data_obj);
}
void
-dump_iproute(void *data)
+dump_iproute(void *rt_data_obj)
{
- ip_route *route = data;
+ ip_route *route = rt_data_obj;
char *log_msg = MALLOC(100);
char *tmp = MALLOC(30);
* authentication data encryption using HMAC MD5 according to
* RFCs 2085 & 2104.
*
- * Version: $Id: vrrp_ipsecah.c,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: vrrp_ipsecah.c,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
*
* Part: NETLINK kernel command channel.
*
- * Version: $Id: vrrp_netlink.c,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: vrrp_netlink.c,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
/* iproute2 utility function */
int
-addattr32(struct nlmsghdr *n, int maxlen, int type, uint32_t data)
+addattr32(struct nlmsghdr *n, int maxlen, int type, uint32_t data_obj)
{
int len = RTA_LENGTH(4);
struct rtattr *rta;
rta = (struct rtattr*)(((char*)n) + NLMSG_ALIGN(n->nlmsg_len));
rta->rta_type = type;
rta->rta_len = len;
- memcpy(RTA_DATA(rta), &data, 4);
+ memcpy(RTA_DATA(rta), &data_obj, 4);
n->nlmsg_len = NLMSG_ALIGN(n->nlmsg_len) + len;
return 0;
}
int
-addattr_l(struct nlmsghdr *n, int maxlen, int type, void *data, int alen)
+addattr_l(struct nlmsghdr *n, int maxlen, int type, void *data_obj, int alen)
{
int len = RTA_LENGTH(alen);
struct rtattr *rta;
rta = (struct rtattr *) (((char *) n) + NLMSG_ALIGN(n->nlmsg_len));
rta->rta_type = type;
rta->rta_len = len;
- memcpy(RTA_DATA(rta), data, alen);
+ memcpy(RTA_DATA(rta), data_obj, alen);
n->nlmsg_len = NLMSG_ALIGN(n->nlmsg_len) + len;
return 0;
}
int
-kernel_netlink(thread * thread)
+kernel_netlink(thread * thread_obj)
{
int status = 0;
- if (thread->type != THREAD_READ_TIMEOUT)
+ if (thread_obj->type != THREAD_READ_TIMEOUT)
status = netlink_parse_info(netlink_broadcast_filter, &nl_kernel);
thread_add_read(master, kernel_netlink, NULL, nl_kernel.fd,
NETLINK_TIMER);
else
syslog(LOG_INFO, "Error while registering Kernel netlink cmd channel");
}
+
+void
+kernel_netlink_close(void)
+{
+ netlink_close(&nl_kernel);
+ netlink_close(&nl_cmd);
+}
*
* Part: VRRP state transition notification scripts handling.
*
- * Version: $Id: vrrp_notify.c,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: vrrp_notify.c,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
{
char *cp = cmdline;
char *script;
- int strlen;
+ int str_len;
if (!cmdline)
return NULL;
while (!isspace((int) *cp) && *cp != '\0')
cp++;
- strlen = cp - cmdline;
- script = MALLOC(strlen + 1);
- memcpy(script, cmdline, strlen);
- *(script + strlen) = '\0';
+ str_len = cp - cmdline;
+ script = MALLOC(str_len + 1);
+ memcpy(script, cmdline, str_len);
+ *(script + str_len) = '\0';
return script;
}
static int
script_open(char *script)
{
- return script_open_litteral(notify_script_name(script));
+ char *name = notify_script_name(script);
+ int ret = name ? script_open_litteral(name) : 0;
+ if (name)
+ FREE(name);
+ return ret;
}
static int
* data structure representation the conf file representing
* the loadbalanced server pool.
*
- * Version: $Id: vrrp_parser.c,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: vrrp_parser.c,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
*
* Part: Sheduling framework for vrrp code.
*
- * Version: $Id: vrrp_scheduler.c,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: vrrp_scheduler.c,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
{
if (vrrp->smtp_alert) {
if (vrrp->state == VRRP_STATE_MAST)
- smtp_alert(master, NULL, vrrp, NULL,
+ smtp_alert(NULL, vrrp, NULL,
"Entering MASTER state",
"=> VRRP Instance is now owning VRRP VIPs <=");
if (vrrp->state == VRRP_STATE_BACK)
- smtp_alert(master, NULL, vrrp, NULL,
+ smtp_alert(NULL, vrrp, NULL,
"Entering BACKUP state",
"=> VRRP Instance is nolonger owning VRRP VIPs <=");
}
static void
vrrp_register_workers(list l)
{
- sock *sock;
+ sock *sock_obj;
TIMEVAL timer;
long vrrp_timer = 0;
element e;
/* Register VRRP workers threads */
for (e = LIST_HEAD(l); e; ELEMENT_NEXT(e)) {
- sock = ELEMENT_DATA(e);
+ sock_obj = ELEMENT_DATA(e);
/* jump to asynchronous handling */
- vrrp_timer = vrrp_timer_fd(sock->fd_in);
+ vrrp_timer = vrrp_timer_fd(sock_obj->fd_in);
/* Register a timer thread if interface is shut */
- if (sock->fd_in == -1)
+ if (sock_obj->fd_in == -1)
thread_add_timer(master, vrrp_read_dispatcher_thread,
(int *)THREAD_TIMER, vrrp_timer);
else
thread_add_read(master, vrrp_read_dispatcher_thread,
- NULL, sock->fd_in, vrrp_timer);
+ NULL, sock_obj->fd_in, vrrp_timer);
}
}
static int
already_exist_sock(list l, int ifindex, int proto)
{
- sock *sock;
+ sock *sock_obj;
element e;
for (e = LIST_HEAD(l); e; ELEMENT_NEXT(e)) {
- sock = ELEMENT_DATA(e);
- if ((sock->ifindex == ifindex) && (sock->proto == proto))
+ sock_obj = ELEMENT_DATA(e);
+ if ((sock_obj->ifindex == ifindex) && (sock_obj->proto == proto))
return 1;
}
return 0;
static void
vrrp_open_sockpool(list l)
{
- sock *sock;
+ sock *sock_obj;
element e;
for (e = LIST_HEAD(l); e; ELEMENT_NEXT(e)) {
- sock = ELEMENT_DATA(e);
- sock->fd_in = open_vrrp_socket(sock->proto, sock->ifindex);
- if (sock->fd_in == -1)
- sock->fd_out = -1;
+ sock_obj = ELEMENT_DATA(e);
+ sock_obj->fd_in = open_vrrp_socket(sock_obj->proto, sock_obj->ifindex);
+ if (sock_obj->fd_in == -1)
+ sock_obj->fd_out = -1;
else
- sock->fd_out = open_vrrp_send_socket(sock->proto,
- sock->ifindex);
+ sock_obj->fd_out = open_vrrp_send_socket(sock_obj->proto,
+ sock_obj->ifindex);
}
}
static void
vrrp_set_fds(list l)
{
- sock *sock;
+ sock *sock_obj;
vrrp_rt *vrrp;
list p = vrrp_data->vrrp;
element e_sock;
int proto;
for (e_sock = LIST_HEAD(l); e_sock; ELEMENT_NEXT(e_sock)) {
- sock = ELEMENT_DATA(e_sock);
+ sock_obj = ELEMENT_DATA(e_sock);
for (e_vrrp = LIST_HEAD(p); e_vrrp; ELEMENT_NEXT(e_vrrp)) {
vrrp = ELEMENT_DATA(e_vrrp);
if (vrrp->auth_type == VRRP_AUTH_AH)
else
proto = IPPROTO_VRRP;
- if ((sock->ifindex == IF_INDEX(vrrp->ifp)) &&
- (sock->proto == proto)) {
- vrrp->fd_in = sock->fd_in;
- vrrp->fd_out = sock->fd_out;
+ if ((sock_obj->ifindex == IF_INDEX(vrrp->ifp)) &&
+ (sock_obj->proto == proto)) {
+ vrrp->fd_in = sock_obj->fd_in;
+ vrrp->fd_out = sock_obj->fd_out;
/* append to hash index */
alloc_vrrp_fd_bucket(vrrp);
* multiplexing points.
*/
int
-vrrp_dispatcher_init(thread * thread)
+vrrp_dispatcher_init(thread * thread_obj)
{
/* create the VRRP socket pool list */
vrrp_create_sockpool(vrrp_data->vrrp_socket_pool);
}
void
-vrrp_dispatcher_release(vrrp_conf_data *data)
+vrrp_dispatcher_release(vrrp_conf_data *conf_data_obj)
{
- free_list(data->vrrp_socket_pool);
+ free_list(conf_data_obj->vrrp_socket_pool);
}
static void
-vrrp_backup(vrrp_rt * vrrp, char *vrrp_buffer, int len)
+vrrp_backup(vrrp_rt * vrrp, char *buffer, int len)
{
- struct iphdr *iph = (struct iphdr *) vrrp_buffer;
+ struct iphdr *iph = (struct iphdr *) buffer;
ipsec_ah *ah;
if (iph->protocol == IPPROTO_IPSEC_AH) {
- ah = (ipsec_ah *) (vrrp_buffer + sizeof (struct iphdr));
+ ah = (ipsec_ah *) (buffer + sizeof (struct iphdr));
if (ntohl(ah->seq_number) >= vrrp->ipsecah_counter->seq_number)
vrrp->ipsecah_counter->cycle = 0;
}
- vrrp_state_backup(vrrp, vrrp_buffer, len);
+ vrrp_state_backup(vrrp, buffer, len);
}
static void
-vrrp_become_master(vrrp_rt * vrrp, char *vrrp_buffer, int len)
+vrrp_become_master(vrrp_rt * vrrp, char *buffer, int len)
{
- struct iphdr *iph = (struct iphdr *) vrrp_buffer;
+ struct iphdr *iph = (struct iphdr *) buffer;
ipsec_ah *ah;
/*
if (iph->protocol == IPPROTO_IPSEC_AH) {
syslog(LOG_INFO, "VRRP_Instance(%s) IPSEC-AH : seq_num sync",
vrrp->iname);
- ah = (ipsec_ah *) (vrrp_buffer + sizeof (struct iphdr));
+ ah = (ipsec_ah *) (buffer + sizeof (struct iphdr));
vrrp->ipsecah_counter->seq_number = ntohl(ah->seq_number) + 1;
vrrp->ipsecah_counter->cycle = 0;
}
}
static void
-vrrp_leave_master(vrrp_rt * vrrp, char *vrrp_buffer, int len)
+vrrp_leave_master(vrrp_rt * vrrp, char *buffer, int len)
{
if (!VRRP_ISUP(vrrp)) {
vrrp_log_int_down(vrrp);
vrrp->wantstate = VRRP_STATE_GOTO_FAULT;
vrrp_state_leave_master(vrrp);
- } else if (vrrp_state_master_rx(vrrp, vrrp_buffer, len)) {
+ } else if (vrrp_state_master_rx(vrrp, buffer, len)) {
vrrp_state_leave_master(vrrp);
vrrp_smtp_notifier(vrrp);
}
}
static void
-vrrp_leave_fault(vrrp_rt * vrrp, char *vrrp_buffer, int len)
+vrrp_leave_fault(vrrp_rt * vrrp, char *buffer, int len)
{
if (!VRRP_ISUP(vrrp))
return;
- if (vrrp_state_fault_rx(vrrp, vrrp_buffer, len)) {
+ if (vrrp_state_fault_rx(vrrp, buffer, len)) {
if (vrrp->sync) {
if (vrrp_sync_leave_fault(vrrp)) {
syslog(LOG_INFO,
"VRRP_Instance(%s) prio is higher than received advert",
vrrp->iname);
- vrrp_become_master(vrrp, vrrp_buffer, len);
+ vrrp_become_master(vrrp, buffer, len);
}
} else {
syslog(LOG_INFO,
"VRRP_Instance(%s) prio is higher than received advert",
vrrp->iname);
- vrrp_become_master(vrrp, vrrp_buffer, len);
+ vrrp_become_master(vrrp, buffer, len);
}
} else {
if (vrrp->sync) {
/* Delayed gratuitous ARP thread */
int
-vrrp_gratuitous_arp_thread(thread * thread)
+vrrp_gratuitous_arp_thread(thread * thread_obj)
{
- vrrp_rt *vrrp = THREAD_ARG(thread);
+ vrrp_rt *vrrp = THREAD_ARG(thread_obj);
/* Simply broadcast the gratuitous ARP */
vrrp_send_gratuitous_arp(vrrp);
/* Our read packet dispatcher */
int
-vrrp_read_dispatcher_thread(thread * thread)
+vrrp_read_dispatcher_thread(thread * thread_obj)
{
long vrrp_timer = 0;
int fd;
/* Dispatcher state handler */
- if (thread->type == THREAD_READ_TIMEOUT)
- fd = vrrp_dispatcher_read_to(thread->u.fd);
- else if (thread->arg) {
+ if (thread_obj->type == THREAD_READ_TIMEOUT)
+ fd = vrrp_dispatcher_read_to(thread_obj->u.fd);
+ else if (thread_obj->arg) {
fd = vrrp_dispatcher_read_to(-1);
} else
- fd = vrrp_dispatcher_read(thread->u.fd);
+ fd = vrrp_dispatcher_read(thread_obj->u.fd);
/* register next dispatcher thread */
vrrp_timer = vrrp_timer_fd(fd);
if (fd == -1)
- thread_add_timer(thread->master, vrrp_read_dispatcher_thread,
+ thread_add_timer(thread_obj->master, vrrp_read_dispatcher_thread,
(int *)THREAD_TIMER, vrrp_timer);
else
- thread_add_read(thread->master, vrrp_read_dispatcher_thread,
+ thread_add_read(thread_obj->master, vrrp_read_dispatcher_thread,
NULL, fd, vrrp_timer);
return 0;
*
* Part: VRRP synchronization framework.
*
- * Version: $Id: vrrp_sync.c,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: vrrp_sync.c,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
str = VECTOR_SLOT(vgroup->iname, i);
vrrp = vrrp_get_instance(str);
if (vrrp) {
- if (LIST_ISEMPTY(vgroup->index))
- vgroup->index = alloc_list(NULL, NULL);
- list_add(vgroup->index, vrrp);
+ if (LIST_ISEMPTY(vgroup->index_list))
+ vgroup->index_list = alloc_list(NULL, NULL);
+ list_add(vgroup->index_list, vrrp);
vrrp->sync = vgroup;
}
}
{
vrrp_rt *vrrp;
element e;
- list l = vgroup->index;
+ list l = vgroup->index_list;
int is_up = 0;
for (e = LIST_HEAD(l); e; ELEMENT_NEXT(e)) {
is_up++;
}
- if (is_up == LIST_SIZE(vgroup->index)) {
+ if (is_up == LIST_SIZE(vgroup->index_list)) {
syslog(LOG_INFO, "Kernel is reporting: Group(%s) UP"
, GROUP_NAME(vgroup));
return 1;
{
if (vgroup->smtp_alert) {
if (GROUP_STATE(vgroup) == VRRP_STATE_MAST)
- smtp_alert(master, NULL, NULL, vgroup,
+ smtp_alert(NULL, NULL, vgroup,
"Entering MASTER state",
"=> All VRRP group instances are now in MASTER state <=");
if (GROUP_STATE(vgroup) == VRRP_STATE_BACK)
- smtp_alert(master, NULL, NULL, vgroup,
+ smtp_alert(NULL, NULL, vgroup,
"Entering BACKUP state",
"=> All VRRP group instances are now in BACKUP state <=");
}
{
vrrp_rt *isync;
vrrp_sgroup *vgroup = vrrp->sync;
- list l = vgroup->index;
+ list l = vgroup->index_list;
element e;
if (vrrp->wantstate != VRRP_STATE_GOTO_MASTER)
{
vrrp_rt *isync;
vrrp_sgroup *vgroup = vrrp->sync;
- list l = vgroup->index;
+ list l = vgroup->index_list;
element e;
if (GROUP_STATE(vgroup) == VRRP_STATE_BACK)
{
vrrp_rt *isync;
vrrp_sgroup *vgroup = vrrp->sync;
- list l = vgroup->index;
+ list l = vgroup->index_list;
element e;
if (GROUP_STATE(vgroup) == VRRP_STATE_MAST)
{
vrrp_rt *isync;
vrrp_sgroup *vgroup = vrrp->sync;
- list l = vgroup->index;
+ list l = vgroup->index_list;
element e;
if (GROUP_STATE(vgroup) == VRRP_STATE_FAULT)
*
* Part: Interface tracking framework.
*
- * Version: $Id: vrrp_track.c,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: vrrp_track.c,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
/* Track interface dump */
void
-dump_track(void *data)
+dump_track(void *track_data_obj)
{
- interface *ifp = data;
+ interface *ifp = track_data_obj;
syslog(LOG_INFO, " %s", IF_NAME(ifp));
}
void
COMPILE = $(CC) $(CFLAGS) $(DEFS)
OBJS = memory.o utils.o notify.o timer.o scheduler.o \
- vector.o list.o html.o parser.o
+ vector.o list.o html.o parser.o signals.o
HEADERS = $(OBJS:.o=.h)
.c.o:
list.o: list.c list.h memory.h
html.o: html.c html.h memory.h
parser.o: parser.c parser.h memory.h
+signals.o: signals.c signals.h
*
* Part: HTML stream parser utility functions.
*
- * Version: $Id: html.c,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: html.c,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Authors: Alexandre Cassen, <acassen@linux-vs.org>
*
*
* Part: parser.c include file.
*
- * Version: $Id: html.h,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: html.h,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Authors: Alexandre Cassen, <acassen@linux-vs.org>
*
*
* Part: List structure manipulation.
*
- * Version: $Id: list.c,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: list.c,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
*
* Part: list.c include file.
*
- * Version: $Id: list.h,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: list.h,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
* Part: Memory management framework. This framework is used to
* find any memory leak.
*
- * Version: $Id: memory.c,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: memory.c,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Authors: Alexandre Cassen, <acassen@linux-vs.org>
* Jan Holmberg, <jan@artech.net>
*
* Part: memory.c include file.
*
- * Version: $Id: memory.h,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: memory.h,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Authors: Alexandre Cassen, <acassen@linux-vs.org>
* Jan Holmberg, <jan@artech.net>
*
* Part: Forked system call to launch an extra script.
*
- * Version: $Id: notify.c,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: notify.c,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
*
* Part: notify.c include file.
*
- * Version: $Id: notify.h,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: notify.h,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
* data structure representation the conf file representing
* the loadbalanced server pool.
*
- * Version: $Id: parser.c,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: parser.c,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
static int sublevel = 0;
void
-keyword_alloc(vector keywords, char *string, void (*handler) (vector))
+keyword_alloc(vector keywords_vec, char *string, void (*handler) (vector))
{
struct keyword *keyword;
- vector_alloc_slot(keywords);
+ vector_alloc_slot(keywords_vec);
keyword = (struct keyword *) MALLOC(sizeof (struct keyword));
keyword->string = string;
keyword->handler = handler;
- vector_set_slot(keywords, keyword);
+ vector_set_slot(keywords_vec, keyword);
}
void
-keyword_alloc_sub(vector keywords, char *string, void (*handler) (vector))
+keyword_alloc_sub(vector keywords_vec, char *string, void (*handler) (vector))
{
int i = 0;
struct keyword *keyword;
/* fetch last keyword */
- keyword = VECTOR_SLOT(keywords, VECTOR_SIZE(keywords) - 1);
+ keyword = VECTOR_SLOT(keywords_vec, VECTOR_SIZE(keywords_vec) - 1);
/* position to last sub level */
for (i = 0; i < sublevel; i++)
dump_keywords(vector keydump, int level)
{
int i, j;
- struct keyword *keyword;
+ struct keyword *keyword_vec;
for (i = 0; i < VECTOR_SIZE(keydump); i++) {
- keyword = VECTOR_SLOT(keydump, i);
+ keyword_vec = VECTOR_SLOT(keydump, i);
for (j = 0; j < level; j++)
printf(" ");
- printf("Keyword : %s\n", keyword->string);
- if (keyword->sub)
- dump_keywords(keyword->sub, level + 1);
+ printf("Keyword : %s\n", keyword_vec->string);
+ if (keyword_vec->sub)
+ dump_keywords(keyword_vec->sub, level + 1);
}
}
void
-free_keywords(vector keywords)
+free_keywords(vector keywords_vec)
{
- struct keyword *keyword;
+ struct keyword *keyword_vec;
int i;
- for (i = 0; i < VECTOR_SIZE(keywords); i++) {
- keyword = VECTOR_SLOT(keywords, i);
- if (keyword->sub)
- free_keywords(keyword->sub);
- FREE(keyword);
+ for (i = 0; i < VECTOR_SIZE(keywords_vec); i++) {
+ keyword_vec = VECTOR_SLOT(keywords_vec, i);
+ if (keyword_vec->sub)
+ free_keywords(keyword_vec->sub);
+ FREE(keyword_vec);
}
- vector_free(keywords);
+ vector_free(keywords_vec);
}
vector
alloc_strvec(char *string)
{
char *cp, *start, *token;
- int strlen;
+ int str_len;
vector strvec;
if (!string)
} else {
while (!isspace((int) *cp) && *cp != '\0' && *cp != '"')
cp++;
- strlen = cp - start;
- token = MALLOC(strlen + 1);
- memcpy(token, start, strlen);
- *(token + strlen) = '\0';
+ str_len = cp - start;
+ token = MALLOC(str_len + 1);
+ memcpy(token, start, str_len);
+ *(token + str_len) = '\0';
}
/* Alloc & set the slot */
/* recursive configuration stream handler */
static int kw_level = 0;
void
-process_stream(vector keywords)
+process_stream(vector keywords_vec)
{
int i;
- struct keyword *keyword;
+ struct keyword *keyword_vec;
char *str;
char *buf;
vector strvec;
- buf = MALLOC(MAXBUF);
- if (!read_line(buf, MAXBUF)) {
- FREE(buf);
- return;
- }
-
- strvec = alloc_strvec(buf);
- FREE(buf);
+ buf = zalloc(MAXBUF);
+ while (read_line(buf, MAXBUF)) {
+ strvec = alloc_strvec(buf);
+ memset(buf,0, MAXBUF);
- if (!strvec) {
- process_stream(keywords);
- return;
- }
+ if (!strvec)
+ continue;
- str = VECTOR_SLOT(strvec, 0);
+ str = VECTOR_SLOT(strvec, 0);
- if (!strcmp(str, EOB) && kw_level > 0) {
- free_strvec(strvec);
- return;
- }
+ if (!strcmp(str, EOB) && kw_level > 0) {
+ free_strvec(strvec);
+ break;
+ }
- for (i = 0; i < VECTOR_SIZE(keywords); i++) {
- keyword = VECTOR_SLOT(keywords, i);
+ for (i = 0; i < VECTOR_SIZE(keywords_vec); i++) {
+ keyword_vec = VECTOR_SLOT(keywords_vec, i);
- if (!strcmp(keyword->string, str)) {
- if (keyword->handler)
- (*keyword->handler) (strvec);
+ if (!strcmp(keyword_vec->string, str)) {
+ if (keyword_vec->handler)
+ (*keyword_vec->handler) (strvec);
- if (keyword->sub) {
- kw_level++;
- process_stream(keyword->sub);
- kw_level--;
+ if (keyword_vec->sub) {
+ kw_level++;
+ process_stream(keyword_vec->sub);
+ kw_level--;
+ }
+ break;
}
- break;
}
+
+ free_strvec(strvec);
}
- free_strvec(strvec);
- process_stream(keywords);
+ free(buf);
+ return;
}
/* Data initialization */
*
* Part: cfreader.c include file.
*
- * Version: $Id: parser.h,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: parser.h,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
extern int reload;
/* Prototypes */
-extern void keyword_alloc(vector keywords, char *string, void (*handler) (vector));
-extern void keyword_alloc_sub(vector keywords, char *string, void (*handler) (vector));
+extern void keyword_alloc(vector keywords_vec, char *string, void (*handler) (vector));
+extern void keyword_alloc_sub(vector keywords_vec, char *string, void (*handler) (vector));
extern void install_keyword_root(char *string, void (*handler) (vector));
extern void install_sublevel(void);
extern void install_sublevel_end(void);
extern void install_keyword(char *string, void (*handler) (vector));
extern void dump_keywords(vector keydump, int level);
-extern void free_keywords(vector keywords);
+extern void free_keywords(vector keywords_vec);
extern vector alloc_strvec(char *string);
extern int read_line(char *buf, int size);
extern vector read_value_block(void);
extern void alloc_value_block(vector strvec, void (*alloc_func) (vector));
extern void *set_value(vector strvec);
-extern void process_stream(vector keywords);
+extern void process_stream(vector keywords_vec);
extern void init_data(char *conf_file, vector (*init_keywords) (void));
#endif
* the thread management routine (thread.c) present in the
* very nice zebra project (http://www.zebra.org).
*
- * Version: $Id: scheduler.c,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: scheduler.c,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
#include "scheduler.h"
#include "memory.h"
#include "utils.h"
+#include "signals.h"
/* global vars */
thread_master *master = NULL;
/* Add a new thread to the list. */
static void
-thread_list_add(thread_list * list, thread * thread)
+thread_list_add(thread_list * list, thread * thread_obj)
{
- thread->next = NULL;
- thread->prev = list->tail;
+ thread_obj->next = NULL;
+ thread_obj->prev = list->tail;
if (list->tail)
- list->tail->next = thread;
+ list->tail->next = thread_obj;
else
- list->head = thread;
- list->tail = thread;
+ list->head = thread_obj;
+ list->tail = thread_obj;
list->count++;
}
/* Add a new thread to the list. */
void
-thread_list_add_before(thread_list * list, thread * point, thread * thread)
+thread_list_add_before(thread_list * list, thread * point, thread * thread_obj)
{
- thread->next = point;
- thread->prev = point->prev;
+ thread_obj->next = point;
+ thread_obj->prev = point->prev;
if (point->prev)
- point->prev->next = thread;
+ point->prev->next = thread_obj;
else
- list->head = thread;
- point->prev = thread;
+ list->head = thread_obj;
+ point->prev = thread_obj;
list->count++;
}
/* Add a thread in the list sorted by timeval */
void
-thread_list_add_timeval(thread_list * list, thread * thread)
+thread_list_add_timeval(thread_list * list, thread * thread_obj)
{
struct _thread *tt;
for (tt = list->head; tt; tt = tt->next) {
- if (timer_cmp(thread->sands, tt->sands) <= 0)
+ if (timer_cmp(thread_obj->sands, tt->sands) <= 0)
break;
}
if (tt)
- thread_list_add_before(list, tt, thread);
+ thread_list_add_before(list, tt, thread_obj);
else
- thread_list_add(list, thread);
+ thread_list_add(list, thread_obj);
}
/* Delete a thread from the list. */
thread *
-thread_list_delete(thread_list * list, thread * thread)
+thread_list_delete(thread_list * list, thread * thread_obj)
{
- if (thread->next)
- thread->next->prev = thread->prev;
+ if (thread_obj->next)
+ thread_obj->next->prev = thread_obj->prev;
else
- list->tail = thread->prev;
- if (thread->prev)
- thread->prev->next = thread->next;
+ list->tail = thread_obj->prev;
+ if (thread_obj->prev)
+ thread_obj->prev->next = thread_obj->next;
else
- list->head = thread->next;
- thread->next = thread->prev = NULL;
+ list->head = thread_obj->next;
+ thread_obj->next = thread_obj->prev = NULL;
list->count--;
- return thread;
+ return thread_obj;
}
/* Free all unused thread. */
static void
thread_clean_unuse(thread_master * m)
{
- thread *thread;
+ thread *thread_obj;
- thread = m->unuse.head;
- while (thread) {
+ thread_obj = m->unuse.head;
+ while (thread_obj) {
struct _thread *t;
- t = thread;
- thread = t->next;
+ t = thread_obj;
+ thread_obj = t->next;
thread_list_delete(&m->unuse, t);
/* Move thread to unuse list. */
static void
-thread_add_unuse(thread_master * m, thread * thread)
+thread_add_unuse(thread_master * m, thread * thread_obj)
{
assert(m != NULL);
- assert(thread->next == NULL);
- assert(thread->prev == NULL);
- assert(thread->type == THREAD_UNUSED);
- thread_list_add(&m->unuse, thread);
+ assert(thread_obj->next == NULL);
+ assert(thread_obj->prev == NULL);
+ assert(thread_obj->type == THREAD_UNUSED);
+ thread_list_add(&m->unuse, thread_obj);
}
/* Move list element to unuse queue */
static void
-thread_destroy_list(thread_master * m, thread_list thread_list)
+thread_destroy_list(thread_master * m, thread_list thread_list_obj)
{
- thread *thread;
+ thread *thread_obj;
- thread = thread_list.head;
+ thread_obj = thread_list_obj.head;
- while (thread) {
+ while (thread_obj) {
struct _thread *t;
- t = thread;
- thread = t->next;
+ t = thread_obj;
+ thread_obj = t->next;
- thread_list_delete(&thread_list, t);
+ thread_list_delete(&thread_list_obj, t);
t->type = THREAD_UNUSED;
thread_add_unuse(m, t);
}
thread_add_read(thread_master * m, int (*func) (thread *)
, void *arg, int fd, long timer)
{
- thread *thread;
+ thread *thread_obj;
assert(m != NULL);
return NULL;
}
- thread = thread_new(m);
- thread->type = THREAD_READ;
- thread->id = 0;
- thread->master = m;
- thread->func = func;
- thread->arg = arg;
+ thread_obj = thread_new(m);
+ thread_obj->type = THREAD_READ;
+ thread_obj->id = 0;
+ thread_obj->master = m;
+ thread_obj->func = func;
+ thread_obj->arg = arg;
FD_SET(fd, &m->readfd);
- thread->u.fd = fd;
+ thread_obj->u.fd = fd;
/* Compute read timeout value */
set_time_now();
- thread->sands = timer_add_long(time_now, timer);
+ thread_obj->sands = timer_add_long(time_now, timer);
/* Sort the thread. */
- thread_list_add_timeval(&m->read, thread);
+ thread_list_add_timeval(&m->read, thread_obj);
- return thread;
+ return thread_obj;
}
/* Add new write thread. */
thread_add_write(thread_master * m, int (*func) (thread *)
, void *arg, int fd, long timer)
{
- thread *thread;
+ thread *thread_obj;
assert(m != NULL);
return NULL;
}
- thread = thread_new(m);
- thread->type = THREAD_WRITE;
- thread->id = 0;
- thread->master = m;
- thread->func = func;
- thread->arg = arg;
+ thread_obj = thread_new(m);
+ thread_obj->type = THREAD_WRITE;
+ thread_obj->id = 0;
+ thread_obj->master = m;
+ thread_obj->func = func;
+ thread_obj->arg = arg;
FD_SET(fd, &m->writefd);
- thread->u.fd = fd;
+ thread_obj->u.fd = fd;
/* Compute write timeout value */
set_time_now();
- thread->sands = timer_add_long(time_now, timer);
+ thread_obj->sands = timer_add_long(time_now, timer);
/* Sort the thread. */
- thread_list_add_timeval(&m->write, thread);
+ thread_list_add_timeval(&m->write, thread_obj);
- return thread;
+ return thread_obj;
}
/* Add timer event thread. */
thread_add_timer(thread_master * m, int (*func) (thread *)
, void *arg, long timer)
{
- thread *thread;
+ thread *thread_obj;
assert(m != NULL);
- thread = thread_new(m);
- thread->type = THREAD_TIMER;
- thread->id = 0;
- thread->master = m;
- thread->func = func;
- thread->arg = arg;
+ thread_obj = thread_new(m);
+ thread_obj->type = THREAD_TIMER;
+ thread_obj->id = 0;
+ thread_obj->master = m;
+ thread_obj->func = func;
+ thread_obj->arg = arg;
/* Do we need jitter here? */
set_time_now();
- thread->sands = timer_add_long(time_now, timer);
+ thread_obj->sands = timer_add_long(time_now, timer);
/* Sort by timeval. */
- thread_list_add_timeval(&m->timer, thread);
+ thread_list_add_timeval(&m->timer, thread_obj);
- return thread;
+ return thread_obj;
}
/* Add a child thread. */
thread_add_child(thread_master * m, int (*func) (thread *)
, void * arg, pid_t pid, long timer)
{
- thread *thread;
+ thread *thread_obj;
assert(m != NULL);
- thread = thread_new(m);
- thread->type = THREAD_CHILD;
- thread->id = 0;
- thread->master = m;
- thread->func = func;
- thread->arg = arg;
- thread->u.c.pid = pid;
- thread->u.c.status = 0;
+ thread_obj = thread_new(m);
+ thread_obj->type = THREAD_CHILD;
+ thread_obj->id = 0;
+ thread_obj->master = m;
+ thread_obj->func = func;
+ thread_obj->arg = arg;
+ thread_obj->u.c.pid = pid;
+ thread_obj->u.c.status = 0;
/* Compute write timeout value */
set_time_now();
- thread->sands = timer_add_long(time_now, timer);
+ thread_obj->sands = timer_add_long(time_now, timer);
/* Sort by timeval. */
- thread_list_add_timeval(&m->child, thread);
+ thread_list_add_timeval(&m->child, thread_obj);
- return thread;
+ return thread_obj;
}
/* Add simple event thread. */
thread_add_event(thread_master * m, int (*func) (thread *)
, void *arg, int val)
{
- thread *thread;
+ thread *thread_obj;
assert(m != NULL);
- thread = thread_new(m);
- thread->type = THREAD_EVENT;
- thread->id = 0;
- thread->master = m;
- thread->func = func;
- thread->arg = arg;
- thread->u.val = val;
- thread_list_add(&m->event, thread);
+ thread_obj = thread_new(m);
+ thread_obj->type = THREAD_EVENT;
+ thread_obj->id = 0;
+ thread_obj->master = m;
+ thread_obj->func = func;
+ thread_obj->arg = arg;
+ thread_obj->u.val = val;
+ thread_list_add(&m->event, thread_obj);
- return thread;
+ return thread_obj;
}
/* Add simple event thread. */
thread *
thread_add_terminate_event(thread_master * m)
{
- thread *thread;
+ thread *thread_obj;
assert(m != NULL);
- thread = thread_new(m);
- thread->type = THREAD_TERMINATE;
- thread->id = 0;
- thread->master = m;
- thread->func = NULL;
- thread->arg = NULL;
- thread->u.val = 0;
- thread_list_add(&m->event, thread);
+ thread_obj = thread_new(m);
+ thread_obj->type = THREAD_TERMINATE;
+ thread_obj->id = 0;
+ thread_obj->master = m;
+ thread_obj->func = NULL;
+ thread_obj->arg = NULL;
+ thread_obj->u.val = 0;
+ thread_list_add(&m->event, thread_obj);
- return thread;
+ return thread_obj;
}
/* Cancel thread from scheduler. */
void
-thread_cancel(thread * thread)
+thread_cancel(thread * thread_obj)
{
- switch (thread->type) {
+ switch (thread_obj->type) {
case THREAD_READ:
- assert(FD_ISSET(thread->u.fd, &thread->master->readfd));
- FD_CLR(thread->u.fd, &thread->master->readfd);
- thread_list_delete(&thread->master->read, thread);
+ assert(FD_ISSET(thread_obj->u.fd, &thread_obj->master->readfd));
+ FD_CLR(thread_obj->u.fd, &thread_obj->master->readfd);
+ thread_list_delete(&thread_obj->master->read, thread_obj);
break;
case THREAD_WRITE:
- assert(FD_ISSET(thread->u.fd, &thread->master->writefd));
- FD_CLR(thread->u.fd, &thread->master->writefd);
- thread_list_delete(&thread->master->write, thread);
+ assert(FD_ISSET(thread_obj->u.fd, &thread_obj->master->writefd));
+ FD_CLR(thread_obj->u.fd, &thread_obj->master->writefd);
+ thread_list_delete(&thread_obj->master->write, thread_obj);
break;
case THREAD_TIMER:
- thread_list_delete(&thread->master->timer, thread);
+ thread_list_delete(&thread_obj->master->timer, thread_obj);
break;
case THREAD_CHILD:
/* Does this need to kill the child, or is that the
* caller's job?
* This function is currently unused, so leave it for now.
*/
- thread_list_delete(&thread->master->child, thread);
+ thread_list_delete(&thread_obj->master->child, thread_obj);
break;
case THREAD_EVENT:
- thread_list_delete(&thread->master->event, thread);
+ thread_list_delete(&thread_obj->master->event, thread_obj);
break;
case THREAD_READY:
- thread_list_delete(&thread->master->ready, thread);
+ thread_list_delete(&thread_obj->master->ready, thread_obj);
break;
default:
break;
}
- thread->type = THREAD_UNUSED;
- thread_add_unuse(thread->master, thread);
+ thread_obj->type = THREAD_UNUSED;
+ thread_add_unuse(thread_obj->master, thread_obj);
}
/* Delete all events which has argument value arg. */
void
thread_cancel_event(thread_master * m, void *arg)
{
- thread *thread;
+ thread *thread_obj;
- thread = m->event.head;
- while (thread) {
+ thread_obj = m->event.head;
+ while (thread_obj) {
struct _thread *t;
- t = thread;
- thread = t->next;
+ t = thread_obj;
+ thread_obj = t->next;
if (t->arg == arg) {
thread_list_delete(&m->event, t);
if (!TIMER_ISNULL(timer_min)) {
timer_min = timer_sub(timer_min, time_now);
- if (timer_min.tv_sec < 0) {
+ if (timer_min.tv_sec < 0 || TIMER_ISNULL(timer_min)) {
timer_min.tv_sec = 0;
timer_min.tv_usec = 10;
}
thread_fetch(thread_master * m, thread * fetch)
{
int ret;
- thread *thread;
+ thread *thread_obj;
fd_set readfd;
fd_set writefd;
fd_set exceptfd;
retry: /* When thread can't fetch try to find next thread again. */
/* If there is event process it first. */
- while ((thread = thread_trim_head(&m->event))) {
- *fetch = *thread;
+ while ((thread_obj = thread_trim_head(&m->event))) {
+ *fetch = *thread_obj;
/* If daemon hanging event is received return NULL pointer */
- if (thread->type == THREAD_TERMINATE) {
- thread->type = THREAD_UNUSED;
- thread_add_unuse(m, thread);
+ if (thread_obj->type == THREAD_TERMINATE) {
+ thread_obj->type = THREAD_UNUSED;
+ thread_add_unuse(m, thread_obj);
return NULL;
}
- thread->type = THREAD_UNUSED;
- thread_add_unuse(m, thread);
+ thread_obj->type = THREAD_UNUSED;
+ thread_add_unuse(m, thread_obj);
return fetch;
}
/* If there is ready threads process them */
- while ((thread = thread_trim_head(&m->ready))) {
- *fetch = *thread;
- thread->type = THREAD_UNUSED;
- thread_add_unuse(m, thread);
+ while ((thread_obj = thread_trim_head(&m->ready))) {
+ *fetch = *thread_obj;
+ thread_obj->type = THREAD_UNUSED;
+ thread_add_unuse(m, thread_obj);
return fetch;
}
sigprocmask(SIG_SETMASK, &saveset, NULL);
}
+ /*
+ * When we receive a signal, we only add it to the signal_mask. This
+ * is so that we can run our handler functions in a safe place and
+ * not in, for example, the middle of a list modification.
+ */
+ if (signal_pending())
+ signal_run_callback();
+
/* Update current time */
set_time_now();
DBG("waitpid error: %s", strerror(errno));
assert(0);
} else {
- thread = m->child.head;
- while (thread) {
+ thread_obj = m->child.head;
+ while (thread_obj) {
struct _thread *t;
- t = thread;
- thread = t->next;
+ t = thread_obj;
+ thread_obj = t->next;
if (pid == t->u.c.pid) {
thread_list_delete(&m->child, t);
thread_list_add(&m->ready, t);
}
/* Timeout children */
- thread = m->child.head;
- while (thread) {
+ thread_obj = m->child.head;
+ while (thread_obj) {
struct _thread *t;
- t = thread;
- thread = t->next;
+ t = thread_obj;
+ thread_obj = t->next;
if (timer_cmp(time_now, t->sands) >= 0) {
thread_list_delete(&m->child, t);
}
/* Read thead. */
- thread = m->read.head;
- while (thread) {
+ thread_obj = m->read.head;
+ while (thread_obj) {
struct _thread *t;
- t = thread;
- thread = t->next;
+ t = thread_obj;
+ thread_obj = t->next;
if (FD_ISSET(t->u.fd, &readfd)) {
assert(FD_ISSET(t->u.fd, &m->readfd));
}
/* Write thead. */
- thread = m->write.head;
- while (thread) {
+ thread_obj = m->write.head;
+ while (thread_obj) {
struct _thread *t;
- t = thread;
- thread = t->next;
+ t = thread_obj;
+ thread_obj = t->next;
if (FD_ISSET(t->u.fd, &writefd)) {
assert(FD_ISSET(t->u.fd, &writefd));
/*... */
/* Timer update. */
- thread = m->timer.head;
- while (thread) {
+ thread_obj = m->timer.head;
+ while (thread_obj) {
struct _thread *t;
- t = thread;
- thread = t->next;
+ t = thread_obj;
+ thread_obj = t->next;
if (timer_cmp(time_now, t->sands) >= 0) {
thread_list_delete(&m->timer, t);
}
/* Return one event. */
- thread = thread_trim_head(&m->ready);
+ thread_obj = thread_trim_head(&m->ready);
/* There is no ready thread. */
- if (!thread)
+ if (!thread_obj)
goto retry;
- *fetch = *thread;
- thread->type = THREAD_UNUSED;
- thread_add_unuse(m, thread);
+ *fetch = *thread_obj;
+ thread_obj->type = THREAD_UNUSED;
+ thread_add_unuse(m, thread_obj);
return fetch;
}
/* Call thread ! */
void
-thread_call(thread * thread)
+thread_call(thread * thread_obj)
{
- thread->id = thread_get_id();
- (*thread->func) (thread);
+ thread_obj->id = thread_get_id();
+ (*thread_obj->func) (thread_obj);
}
/* Our infinite scheduling loop */
void
launch_scheduler(void)
{
- thread thread;
+ thread thread_obj;
/*
* Processing the master thread queues,
* return and execute one ready thread.
*/
- while (thread_fetch(master, &thread)) {
+ while (thread_fetch(master, &thread_obj)) {
/* Run until error, used for debuging only */
#ifdef _DEBUG_
if ((debug & 520) == 520) {
thread_add_terminate_event(master);
}
#endif
- thread_call(&thread);
+ thread_call(&thread_obj);
}
}
*
* Part: scheduler.c include file.
*
- * Version: $Id: scheduler.h,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: scheduler.h,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
, void *arg, pid_t pid, long timeout);
extern thread *thread_add_event(thread_master * m, int (*func) (thread *)
, void *arg, int val);
-extern void thread_cancel(thread * thread);
+extern void thread_cancel(thread * thread_obj);
extern void thread_cancel_event(thread_master * m, void *arg);
extern thread *thread_fetch(thread_master * m, thread * fetch);
-extern void thread_call(thread * thread);
+extern void thread_call(thread * thread_obj);
extern void launch_scheduler(void);
#endif
--- /dev/null
+/*
+ * Soft: Keepalived is a failover program for the LVS project
+ * <www.linuxvirtualserver.org>. It monitor & manipulate
+ * a loadbalanced server pool using multi-layer checks.
+ *
+ * Part: Signals framework.
+ *
+ * Version: $Id: signals.c,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
+ *
+ * Author: Kevin Lindsay, <kevinl@netnation.com>
+ * Alexandre Cassen, <acassen@linux-vs.org>
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ * Copyright (C) 2001-2005 Alexandre Cassen, <acassen@linux-vs.org>
+ */
+
+#include <signal.h>
+#include <string.h>
+
+#include "signals.h"
+
+/* Local Vars */
+static int signal_mask;
+void (*signal_SIGHUP_handler) (int sig);
+void (*signal_SIGINT_handler) (int sig);
+void (*signal_SIGTERM_handler) (int sig);
+void (*signal_SIGCHLD_handler) (int sig);
+
+/* Local signal test */
+int
+signal_pending(void)
+{
+ return (signal_mask) ? 1 : 0;
+}
+
+/* Signal flag */
+void
+signal_handler(int sig)
+{
+ switch(sig) {
+ case SIGHUP:
+ signal_mask |= SIGNAL_SIGHUP;
+ break;
+ case SIGINT:
+ signal_mask |= SIGNAL_SIGINT;
+ break;
+ case SIGTERM:
+ signal_mask |= SIGNAL_SIGTERM;
+ break;
+ case SIGCHLD:
+ signal_mask |= SIGNAL_SIGCHLD;
+ break;
+ }
+}
+
+/* Signal wrapper */
+void *
+signal_set(int signo, void (*func) (int))
+{
+ int ret;
+ struct sigaction sig;
+ struct sigaction osig;
+
+ sig.sa_handler = signal_handler;
+ sigemptyset(&sig.sa_mask);
+ sig.sa_flags = 0;
+#ifdef SA_RESTART
+ sig.sa_flags |= SA_RESTART;
+#endif /* SA_RESTART */
+
+ ret = sigaction(signo, &sig, &osig);
+
+ switch(signo) {
+ case SIGHUP:
+ signal_SIGHUP_handler = func;
+ break;
+ case SIGINT:
+ signal_SIGINT_handler = func;
+ break;
+ case SIGTERM:
+ signal_SIGTERM_handler = func;
+ break;
+ case SIGCHLD:
+ signal_SIGCHLD_handler = func;
+ break;
+ }
+
+ if (ret < 0)
+ return (SIG_ERR);
+ else
+ return (osig.sa_handler);
+}
+
+/* Signal Ignore */
+void *
+signal_ignore(int signo)
+{
+ return signal_set(signo, SIG_IGN);
+}
+
+/*
+ * SIGCHLD handler. Reap all zombie child.
+ * WNOHANG prevent against parent process get
+ * stuck waiting child termination.
+ */
+void
+dummy_handler(int sig)
+{
+ /* Dummy */
+}
+
+void
+signal_noignore_sigchld(void)
+{
+ struct sigaction sa;
+ sigset_t mask;
+
+ /* Need to remove the NOCHLD flag */
+ sigemptyset(&mask);
+ sa.sa_handler = dummy_handler;
+ sa.sa_mask = mask;
+ sa.sa_flags = 0;
+
+ sigaction(SIGCHLD, &sa, NULL);
+
+ /* Block SIGCHLD so that we only receive it
+ * when required (ie when its unblocked in the
+ * select loop)
+ */
+ sigaddset(&mask, SIGCHLD);
+ sigprocmask(SIG_BLOCK, &mask, NULL);
+}
+
+/* Handlers intialization */
+void
+signal_handler_init(void)
+{
+ signal_mask = 0;
+ signal_SIGHUP_handler = NULL;
+ signal_SIGINT_handler = NULL;
+ signal_SIGTERM_handler = NULL;
+ signal_SIGCHLD_handler = NULL;
+}
+
+/* Handlers callback according to global signal mask */
+void
+signal_run_callback(void)
+{
+ if (SIGNAL_SIGHUP & signal_mask) {
+ if (signal_SIGHUP_handler)
+ signal_SIGHUP_handler(SIGHUP);
+ signal_mask &= SIGNAL_SIGHUP;
+ }
+
+ if (SIGNAL_SIGINT & signal_mask) {
+ if (signal_SIGINT_handler)
+ signal_SIGINT_handler(SIGINT);
+ signal_mask &= SIGNAL_SIGINT;
+ }
+
+ if (SIGNAL_SIGTERM & signal_mask) {
+ if (signal_SIGTERM_handler)
+ signal_SIGTERM_handler(SIGTERM);
+ signal_mask &= SIGNAL_SIGTERM;
+ }
+
+ if (SIGNAL_SIGCHLD & signal_mask) {
+ if (signal_SIGCHLD_handler)
+ signal_SIGCHLD_handler(SIGCHLD);
+ signal_mask &= SIGNAL_SIGCHLD;
+ }
+}
--- /dev/null
+/*
+ * Soft: Keepalived is a failover program for the LVS project
+ * <www.linuxvirtualserver.org>. It monitor & manipulate
+ * a loadbalanced server pool using multi-layer checks.
+ *
+ * Part: signals.c include file.
+ *
+ * Version: $Id: signals.h,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
+ *
+ * Author: Kevin Lindsay, <kevinl@netnation.com>
+ * Alexandre Cassen, <acassen@linux-vs.org>
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ * Copyright (C) 2001-2005 Alexandre Cassen, <acassen@linux-vs.org>
+ */
+
+#ifndef _SIGNALS_H
+#define _SIGNALS_H
+
+/* signals definition */
+#define SIGNAL_SIGHUP 0x02
+#define SIGNAL_SIGINT 0x04
+#define SIGNAL_SIGTERM 0x08
+#define SIGNAL_SIGCHLD 0x10
+
+/* Prototypes */
+extern int signal_pending(void);
+extern void *signal_set(int signo, void (*func) (int));
+extern void *signal_ignore(int signo);
+extern void signal_noignore_sigchld(void);
+extern void signal_handler_init(void);
+extern void signal_run_callback(void);
+
+#endif
*
* Part: Timer manipulations.
*
- * Version: $Id: timer.c,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: timer.c,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
TIMEVAL
timer_now(void)
{
- TIMEVAL timer_now;
+ TIMEVAL curr_time;
/* init timer */
- TIMER_RESET(timer_now);
- gettimeofday(&timer_now, NULL);
+ TIMER_RESET(curr_time);
+ gettimeofday(&curr_time, NULL);
- return timer_now;
+ return curr_time;
}
/* sets and returns current time from system time */
*
* Part: timer.c include file.
*
- * Version: $Id: timer.h,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: timer.h,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
*
* Part: General program utils.
*
- * Version: $Id: utils.c,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: utils.c,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
*
* Part: utils.h include file.
*
- * Version: $Id: utils.h,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: utils.h,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
*
* Part: Vector structure manipulation.
*
- * Version: $Id: vector.c,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: vector.c,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
*
* Part: vector.c include file.
*
- * Version: $Id: vector.h,v 1.1.9 2005/02/07 03:18:31 acassen Exp $
+ * Version: $Id: vector.h,v 1.1.10 2005/02/15 01:15:22 acassen Exp $
*
* Author: Alexandre Cassen, <acassen@linux-vs.org>
*
projects / people / alex / keepalived.git / commitdiff