/* free allocated pieces */
static void
-free_all(thread * thread_obj)
+free_all(thread_t * thread)
{
- SOCK *sock_obj = THREAD_ARG(thread_obj);
+ SOCK *sock_obj = THREAD_ARG(thread);
DBG("Total read size read = %d Bytes, fd:%d\n",
sock_obj->total_size, sock_obj->fd);
* => free the reserved thread
*/
req->response_time = timer_tol(timer_now());
- thread_add_terminate_event(thread_obj->master);
+ thread_add_terminate_event(thread->master);
}
/* Simple epilog functions. */
int
-epilog(thread * thread_obj)
+epilog(thread_t * thread)
{
DBG("Timeout on URL : [%s]\n", req->url);
- free_all(thread_obj);
+ free_all(thread);
return 0;
}
/* Simple finalization function */
int
-finalize(thread * thread_obj)
+finalize(thread_t * thread)
{
- SOCK *sock_obj = THREAD_ARG(thread_obj);
+ SOCK *sock_obj = THREAD_ARG(thread);
unsigned char digest[16];
int i;
printf("\n\n");
DBG("Finalize : [%s]\n", req->url);
- free_all(thread_obj);
+ free_all(thread);
return 0;
}
/* Asynchronous HTTP stream reader */
int
-http_read_thread(thread * thread_obj)
+http_read_thread(thread_t * thread)
{
- SOCK *sock_obj = THREAD_ARG(thread_obj);
+ SOCK *sock_obj = THREAD_ARG(thread);
int r = 0;
/* Handle read timeout */
- if (thread_obj->type == THREAD_READ_TIMEOUT)
- return epilog(thread_obj);
+ if (thread->type == THREAD_READ_TIMEOUT)
+ return epilog(thread);
/* read the HTTP stream */
memset(sock_obj->buffer, 0, MAX_BUFFER_LENGTH);
- r = read(thread_obj->u.fd, sock_obj->buffer + sock_obj->size,
+ r = read(thread->u.fd, sock_obj->buffer + sock_obj->size,
MAX_BUFFER_LENGTH - sock_obj->size);
DBG(" [l:%d,fd:%d]\n", r, sock_obj->fd);
DBG("Read error with server [%s:%d]: %s\n",
inet_ntop2(req->addr_ip), ntohs(req->addr_port),
strerror(errno));
- return epilog(thread_obj);
+ return epilog(thread);
}
/* All the HTTP stream has been parsed */
- finalize(thread_obj);
+ finalize(thread);
} else {
/* Handle the response stream */
http_process_stream(sock_obj, r);
* Register next http stream reader.
* Register itself to not perturbe global I/O multiplexer.
*/
- thread_add_read(thread_obj->master, http_read_thread, sock_obj,
- thread_obj->u.fd, HTTP_CNX_TIMEOUT);
+ thread_add_read(thread->master, http_read_thread, sock_obj,
+ thread->u.fd, HTTP_CNX_TIMEOUT);
}
return 0;
* Apply trigger check to this result.
*/
int
-http_response_thread(thread * thread_obj)
+http_response_thread(thread_t * thread)
{
- SOCK *sock_obj = THREAD_ARG(thread_obj);
+ SOCK *sock_obj = THREAD_ARG(thread);
/* Handle read timeout */
- if (thread_obj->type == THREAD_READ_TIMEOUT)
- return epilog(thread_obj);
+ if (thread->type == THREAD_READ_TIMEOUT)
+ return epilog(thread);
/* Allocate & clean the get buffer */
sock_obj->buffer = (char *) MALLOC(MAX_BUFFER_LENGTH);
/* Register asynchronous http/ssl read thread */
if (req->ssl)
- thread_add_read(thread_obj->master, ssl_read_thread, sock_obj,
- thread_obj->u.fd, HTTP_CNX_TIMEOUT);
+ thread_add_read(thread->master, ssl_read_thread, sock_obj,
+ thread->u.fd, HTTP_CNX_TIMEOUT);
else
- thread_add_read(thread_obj->master, http_read_thread, sock_obj,
- thread_obj->u.fd, HTTP_CNX_TIMEOUT);
+ thread_add_read(thread->master, http_read_thread, sock_obj,
+ thread->u.fd, HTTP_CNX_TIMEOUT);
return 0;
}
/* remote Web server is connected, send it the get url query. */
int
-http_request_thread(thread * thread_obj)
+http_request_thread(thread_t * thread)
{
- SOCK *sock_obj = THREAD_ARG(thread_obj);
+ SOCK *sock_obj = THREAD_ARG(thread);
char *str_request;
int ret = 0;
/* Handle read timeout */
- if (thread_obj->type == THREAD_WRITE_TIMEOUT)
- return epilog(thread_obj);
+ if (thread->type == THREAD_WRITE_TIMEOUT)
+ return epilog(thread);
/* Allocate & clean the GET string */
str_request = (char *) MALLOC(GET_BUFFER_LENGTH);
fprintf(stderr, "Cannot send get request to [%s:%d].\n",
inet_ntop2(req->addr_ip)
, ntohs(req->addr_port));
- return epilog(thread_obj);
+ return epilog(thread);
}
/* Register read timeouted thread */
- thread_add_read(thread_obj->master, http_response_thread, sock_obj,
+ thread_add_read(thread->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_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);
+extern int epilog(thread_t *);
+extern int finalize(thread_t *);
+extern int http_process_stream(SOCK *, int);
+extern int http_request_thread(thread_t *);
#endif
}
enum connect_result
-tcp_socket_state(int fd, thread * thread_obj, uint32_t addr_ip, uint16_t addr_port,
- int (*func) (struct _thread *))
+tcp_socket_state(int fd, thread_t * thread, uint32_t addr_ip, uint16_t addr_port,
+ int (*func) (thread_t *))
{
int status;
socklen_t slen;
TIMEVAL timer_min;
/* Handle connection timeout */
- if (thread_obj->type == THREAD_WRITE_TIMEOUT) {
+ if (thread->type == THREAD_WRITE_TIMEOUT) {
DBG("TCP connection timeout to [%s:%d].\n",
inet_ntop2(addr_ip), ntohs(addr_port));
- close(thread_obj->u.fd);
+ close(thread->u.fd);
return connect_timeout;
}
/* Check file descriptor */
slen = sizeof (status);
if (getsockopt
- (thread_obj->u.fd, SOL_SOCKET, SO_ERROR, (void *) &status, &slen) < 0)
+ (thread->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_obj->u.fd);
+ close(thread->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_obj->sands);
- thread_add_write(thread_obj->master, func, THREAD_ARG(thread_obj)
- , thread_obj->u.fd, TIMER_LONG(timer_min));
+ timer_min = timer_sub_now(thread->sands);
+ thread_add_write(thread->master, func, THREAD_ARG(thread)
+ , thread->u.fd, TIMER_LONG(timer_min));
return connect_in_progress;
}
}
void
-tcp_connection_state(int fd, enum connect_result status, thread * thread_obj,
- int (*func) (struct _thread *)
+tcp_connection_state(int fd, enum connect_result status, thread_t * thread,
+ int (*func) (thread_t *)
, long timeout)
{
switch (status) {
break;
case connect_success:
- thread_add_write(thread_obj->master, func, THREAD_ARG(thread_obj),
+ thread_add_write(thread->master, func, THREAD_ARG(thread),
fd, timeout);
break;
/* Checking non-blocking connect, we wait until socket is writable */
case connect_in_progress:
- thread_add_write(thread_obj->master, func, THREAD_ARG(thread_obj),
+ thread_add_write(thread->master, func, THREAD_ARG(thread),
fd, timeout);
break;
}
int
-tcp_check_thread(thread * thread_obj)
+tcp_check_thread(thread_t * thread)
{
- SOCK *sock_obj = THREAD_ARG(thread_obj);
+ SOCK *sock_obj = THREAD_ARG(thread);
int ret = 1;
sock_obj->status =
- tcp_socket_state(thread_obj->u.fd, thread_obj, req->addr_ip, req->addr_port,
+ tcp_socket_state(thread->u.fd, thread, req->addr_ip, req->addr_port,
tcp_check_thread);
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_obj->master);
+ thread_add_terminate_event(thread->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_obj->master);
+ thread_add_terminate_event(thread->master);
return -1;
break;
case connect_success:{
if (req->ssl)
- ret = ssl_connect(thread_obj);
+ ret = ssl_connect(thread);
if (ret) {
/* Remote WEB server is connected.
* Unlock eventual locked socket.
*/
sock_obj->lock = 0;
- thread_add_event(thread_obj->master,
+ thread_add_event(thread->master,
http_request_thread, sock_obj, 0);
} else {
DBG("Connection trouble to: [%s:%d].\n",
}
int
-tcp_connect_thread(thread * thread_obj)
+tcp_connect_thread(thread_t * thread)
{
- SOCK *sock_obj = THREAD_ARG(thread_obj);
+ SOCK *sock_obj = THREAD_ARG(thread);
if ((sock_obj->fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {
DBG("WEB connection fail to create socket.\n");
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_obj->fd, sock_obj->status, thread_obj, tcp_check_thread,
+ tcp_connection_state(sock_obj->fd, sock_obj->status, thread, tcp_check_thread,
HTTP_CNX_TIMEOUT);
return 0;
}
tcp_connect(int fd, uint32_t, uint16_t);
extern enum connect_result
- tcp_socket_state(int, thread *, uint32_t, uint16_t,
- int (*func) (struct _thread *));
+ tcp_socket_state(int, thread_t *, uint32_t, uint16_t,
+ int (*func) (thread_t *));
extern void
tcp_connection_state(int, enum connect_result
- , thread *, int (*func) (struct _thread *)
+ , thread_t *, int (*func) (thread_t *)
, long);
-extern int
- tcp_connect_thread(thread *);
+extern int tcp_connect_thread(thread_t *);
#endif
int
main(int argc, char **argv)
{
- thread thread_obj;
+ thread_t thread;
/* Allocate the room */
req = (REQ *) MALLOC(sizeof (REQ));
* not activate SIGCHLD handling, however, this
* is no issue here.
*/
- while (thread_fetch(master, &thread_obj))
- thread_call(&thread_obj);
+ while (thread_fetch(master, &thread))
+ thread_call(&thread);
/* Finalize output informations */
if (req->verbose)
} REQ;
/* Global variables */
-extern thread_master *master;
+extern thread_master_t *master;
extern REQ *req; /* Cmd line arguments */
/* Data buffer length description */
extern SOCK *sock;
/* Prototypes */
-extern void free_sock(SOCK * sock_obj);
+extern void free_sock(SOCK *);
extern void init_sock(void);
#endif
}
int
-ssl_connect(thread * thread_obj)
+ssl_connect(thread_t * thread)
{
- SOCK *sock_obj = THREAD_ARG(thread_obj);
+ SOCK *sock_obj = THREAD_ARG(thread);
int ret;
sock_obj->ssl = SSL_new(req->ctx);
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_obj->u.fd);
+ DBG(" SSL_connect return code = %d on fd:%d\n", ret, thread->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_obj)
+ssl_read_thread(thread_t * thread)
{
- SOCK *sock_obj = THREAD_ARG(thread_obj);
+ SOCK *sock_obj = THREAD_ARG(thread);
int r = 0;
int error;
/* Handle read timeout */
- if (thread_obj->type == THREAD_READ_TIMEOUT)
- return epilog(thread_obj);
+ if (thread->type == THREAD_READ_TIMEOUT)
+ return epilog(thread);
/*
* The design implemented here is a workaround for use
/* All the SSL streal has been parsed */
/* Handle response stream */
if (error != SSL_ERROR_NONE)
- return finalize(thread_obj);
+ return finalize(thread);
} else if (r > 0 && error == 0) {
/* Handle the response stream */
/* Prototypes */
extern void init_ssl(void);
-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_obj);
+extern int ssl_connect(thread_t *);
+extern int ssl_printerr(int);
+extern int ssl_send_request(SSL *, char *, int);
+extern int ssl_read_thread(thread_t *);
#endif
}
/* Reload handler */
-int reload_check_thread(thread * thread_obj);
+int reload_check_thread(thread_t *);
void
sighup_check(void *v, int sig)
{
/* Reload thread */
int
-reload_check_thread(thread * thread_obj)
+reload_check_thread(thread_t * thread)
{
/* set the reloading flag */
SET_RELOAD;
/* CHECK Child respawning thread */
int
-check_respawn_thread(thread * thread_obj)
+check_respawn_thread(thread_t * thread)
{
pid_t pid;
/* Fetch thread args */
- pid = THREAD_CHILD_PID(thread_obj);
+ pid = THREAD_CHILD_PID(thread);
/* Restart respawning thread */
- if (thread_obj->type == THREAD_CHILD_TIMEOUT) {
+ if (thread->type == THREAD_CHILD_TIMEOUT) {
thread_add_child(master, check_respawn_thread, NULL,
pid, RESPAWN_TIMER);
return 0;
#include "utils.h"
#include "html.h"
-int http_connect_thread(thread *);
+int http_connect_thread(thread_t *);
/* Configuration stream handling */
void
* method == 2 => register a retry on url checker thread
*/
int
-epilog(thread * thread_obj, int method, int t, int c)
+epilog(thread_t * thread, int method, int t, int c)
{
- checker *checker_obj = THREAD_ARG(thread_obj);
+ checker *checker_obj = THREAD_ARG(thread);
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);
FREE(req->buffer);
FREE(req);
http_arg_obj->req = NULL;
- close(thread_obj->u.fd);
+ close(thread->u.fd);
}
/* Register next checker thread */
- thread_add_timer(thread_obj->master, http_connect_thread, checker_obj, delay);
+ thread_add_timer(thread->master, http_connect_thread, checker_obj, delay);
return 0;
}
int
-timeout_epilog(thread * thread_obj, char *smtp_msg, char *debug_msg)
+timeout_epilog(thread_t * thread, char *smtp_msg, char *debug_msg)
{
- checker *checker_obj = THREAD_ARG(thread_obj);
+ checker *checker_obj = THREAD_ARG(thread);
http_get_checker *http_get_check = CHECKER_ARG(checker_obj);
log_message(LOG_INFO, "Timeout %s server [%s]:%d."
, checker_obj->rs);
}
- return epilog(thread_obj, 1, 0, 0);
+ return epilog(thread, 1, 0, 0);
}
/* return the url pointer of the current url iterator */
/* Handle response */
int
-http_handle_response(thread * thread_obj, unsigned char digest[16]
+http_handle_response(thread_t * thread, unsigned char digest[16]
, int empty_buffer)
{
- checker *checker_obj = THREAD_ARG(thread_obj);
+ checker *checker_obj = THREAD_ARG(thread);
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);
/* First check if remote webserver returned data */
if (empty_buffer)
- return timeout_epilog(thread_obj, "=> CHECK failed on service"
+ return timeout_epilog(thread, "=> CHECK failed on service"
" : empty buffer received <=\n\n",
"Read, no data received from ");
*/
http_arg_obj->retry_it = http_get_check->nb_get_retry;
}
- return epilog(thread_obj, 2, 0, 1);
+ return epilog(thread, 2, 0, 1);
} else {
if (!svr_checker_up(checker_obj->id, checker_obj->rs))
log_message(LOG_INFO,
, inet_sockaddrtos(&http_get_check->dst)
, ntohs(inet_sockaddrport(&http_get_check->dst))
, http_arg_obj->url_it + 1);
- return epilog(thread_obj, 1, 1, 0) + 1;
+ return epilog(thread, 1, 1, 0) + 1;
}
}
http_arg_obj->retry_it = http_get_check->nb_get_retry;
}
FREE(digest_tmp);
- return epilog(thread_obj, 2, 0, 1);
+ return epilog(thread, 2, 0, 1);
} else {
if (!svr_checker_up(checker_obj->id, checker_obj->rs))
log_message(LOG_INFO, "MD5 digest success to [%s]:%d url(%d)."
, ntohs(inet_sockaddrport(&http_get_check->dst))
, http_arg_obj->url_it + 1);
FREE(digest_tmp);
- return epilog(thread_obj, 1, 1, 0) + 1;
+ return epilog(thread, 1, 1, 0) + 1;
}
}
- return epilog(thread_obj, 1, 0, 0) + 1;
+ return epilog(thread, 1, 0, 0) + 1;
}
/* Handle response stream performing MD5 updates */
/* Asynchronous HTTP stream reader */
int
-http_read_thread(thread * thread_obj)
+http_read_thread(thread_t * thread)
{
- checker *checker_obj = THREAD_ARG(thread_obj);
+ checker *checker_obj = THREAD_ARG(thread);
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);
int val;
/* Handle read timeout */
- if (thread_obj->type == THREAD_READ_TIMEOUT)
- return timeout_epilog(thread_obj, "=> HTTP CHECK failed on service"
+ if (thread->type == THREAD_READ_TIMEOUT)
+ return timeout_epilog(thread, "=> HTTP CHECK failed on service"
" : recevice data <=\n\n", "HTTP read");
/* Set descriptor non blocking */
- val = fcntl(thread_obj->u.fd, F_GETFL, 0);
- fcntl(thread_obj->u.fd, F_SETFL, val | O_NONBLOCK);
+ val = fcntl(thread->u.fd, F_GETFL, 0);
+ fcntl(thread->u.fd, F_SETFL, val | O_NONBLOCK);
/* read the HTTP stream */
- r = read(thread_obj->u.fd, req->buffer + req->len,
+ r = read(thread->u.fd, req->buffer + req->len,
MAX_BUFFER_LENGTH - req->len);
/* restore descriptor flags */
- fcntl(thread_obj->u.fd, F_SETFL, val);
+ fcntl(thread->u.fd, F_SETFL, val);
/* Test if data are ready */
if (r == -1 && (errno == EAGAIN || errno == EINTR)) {
, inet_sockaddrtos(&http_get_check->dst)
, ntohs(inet_sockaddrport(&http_get_check->dst))
, strerror(errno));
- thread_add_read(thread_obj->master, http_read_thread, checker_obj,
- thread_obj->u.fd, http_get_check->connection_to);
+ thread_add_read(thread->master, http_read_thread, checker_obj,
+ thread->u.fd, http_get_check->connection_to);
return 0;
}
, checker_obj->vs
, checker_obj->rs);
}
- return epilog(thread_obj, 1, 0, 0);
+ return epilog(thread, 1, 0, 0);
}
/* Handle response stream */
- http_handle_response(thread_obj, digest, (!req->extracted) ? 1 : 0);
+ http_handle_response(thread, digest, (!req->extracted) ? 1 : 0);
} else {
* Register next http stream reader.
* Register itself to not perturbe global I/O multiplexer.
*/
- thread_add_read(thread_obj->master, http_read_thread, checker_obj,
- thread_obj->u.fd, http_get_check->connection_to);
+ thread_add_read(thread->master, http_read_thread, checker_obj,
+ thread->u.fd, http_get_check->connection_to);
}
return 0;
* Apply trigger check to this result.
*/
int
-http_response_thread(thread * thread_obj)
+http_response_thread(thread_t * thread)
{
- checker *checker_obj = THREAD_ARG(thread_obj);
+ checker *checker_obj = THREAD_ARG(thread);
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_obj->type == THREAD_READ_TIMEOUT)
- return timeout_epilog(thread_obj, "=> CHECK failed on service"
+ if (thread->type == THREAD_READ_TIMEOUT)
+ return timeout_epilog(thread, "=> 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_obj->master, ssl_read_thread, checker_obj,
- thread_obj->u.fd, http_get_check->connection_to);
+ thread_add_read(thread->master, ssl_read_thread, checker_obj,
+ thread->u.fd, http_get_check->connection_to);
else
- thread_add_read(thread_obj->master, http_read_thread, checker_obj,
- thread_obj->u.fd, http_get_check->connection_to);
+ thread_add_read(thread->master, http_read_thread, checker_obj,
+ thread->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_obj)
+http_request_thread(thread_t * thread)
{
- checker *checker_obj = THREAD_ARG(thread_obj);
+ checker *checker_obj = THREAD_ARG(thread);
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);
int val;
/* Handle read timeout */
- if (thread_obj->type == THREAD_WRITE_TIMEOUT)
- return timeout_epilog(thread_obj, "=> CHECK failed on service"
+ if (thread->type == THREAD_WRITE_TIMEOUT)
+ return timeout_epilog(thread, "=> CHECK failed on service"
" : read timeout <=\n\n",
"Web read, timeout");
, ntohs(inet_sockaddrport(&http_get_check->dst)));
/* Set descriptor non blocking */
- val = fcntl(thread_obj->u.fd, F_GETFL, 0);
- fcntl(thread_obj->u.fd, F_SETFL, val | O_NONBLOCK);
+ val = fcntl(thread->u.fd, F_GETFL, 0);
+ fcntl(thread->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_obj->u.fd, str_request, strlen(str_request), 0) !=
+ ret = (send(thread->u.fd, str_request, strlen(str_request), 0) !=
-1) ? 1 : 0;
}
/* restore descriptor flags */
- fcntl(thread_obj->u.fd, F_SETFL, val);
+ fcntl(thread->u.fd, F_SETFL, val);
FREE(str_request);
, checker_obj->vs
, checker_obj->rs);
}
- return epilog(thread_obj, 1, 0, 0);
+ return epilog(thread, 1, 0, 0);
}
/* Register read timeouted thread */
- thread_add_read(thread_obj->master, http_response_thread, checker_obj,
- thread_obj->u.fd, http_get_check->connection_to);
+ thread_add_read(thread->master, http_response_thread, checker_obj,
+ thread->u.fd, http_get_check->connection_to);
return 1;
}
/* WEB checkers threads */
int
-http_check_thread(thread * thread_obj)
+http_check_thread(thread_t * thread)
{
- checker *checker_obj = THREAD_ARG(thread_obj);
+ checker *checker_obj = THREAD_ARG(thread);
http_get_checker *http_get_check = CHECKER_ARG(checker_obj);
http_arg *http_arg_obj = HTTP_ARG(http_get_check);
#ifdef _DEBUG_
int ssl_err = 0;
int new_req = 0;
- status = tcp_socket_state(thread_obj->u.fd, thread_obj, http_check_thread);
+ status = tcp_socket_state(thread->u.fd, thread, http_check_thread);
switch (status) {
case connect_error:
/* check if server is currently alive */
, checker_obj->vs
, checker_obj->rs);
}
- return epilog(thread_obj, 1, 0, 0);
+ return epilog(thread, 1, 0, 0);
break;
case connect_timeout:
- return timeout_epilog(thread_obj, "==> CHECK failed on service"
+ return timeout_epilog(thread, "==> CHECK failed on service"
" : connection timeout <=\n\n",
"connect, timeout");
break;
new_req = 0;
if (http_get_check->proto == PROTO_SSL) {
- timeout = TIMER_LONG(thread_obj->sands)-TIMER_LONG(time_now);
- if (thread_obj->type != THREAD_WRITE_TIMEOUT &&
- thread_obj->type != THREAD_READ_TIMEOUT)
- ret = ssl_connect(thread_obj, new_req);
+ timeout = TIMER_LONG(thread->sands)-TIMER_LONG(time_now);
+ if (thread->type != THREAD_WRITE_TIMEOUT &&
+ thread->type != THREAD_READ_TIMEOUT)
+ ret = ssl_connect(thread, new_req);
else {
- return timeout_epilog(thread_obj, "==> CHECK failed on service"
+ return timeout_epilog(thread, "==> CHECK failed on service"
" : connection timeout <=\n\n",
"connect, timeout");
}
switch ((ssl_err = SSL_get_error(http_arg_obj->req->ssl,
ret))) {
case SSL_ERROR_WANT_READ:
- thread_add_read(thread_obj->master,
+ thread_add_read(thread->master,
http_check_thread,
- THREAD_ARG(thread_obj),
- thread_obj->u.fd, timeout);
+ THREAD_ARG(thread),
+ thread->u.fd, timeout);
break;
case SSL_ERROR_WANT_WRITE:
- thread_add_write(thread_obj->master,
+ thread_add_write(thread->master,
http_check_thread,
- THREAD_ARG(thread_obj),
- thread_obj->u.fd, timeout);
+ THREAD_ARG(thread),
+ thread->u.fd, timeout);
break;
default:
ret = 0;
DBG("Remote Web server [%s]:%d connected."
, inet_sockaddrtos(&http_get_check->dst)
, ntohs(inet_sockaddrport(&http_get_check->dst)));
- thread_add_write(thread_obj->master,
+ thread_add_write(thread->master,
http_request_thread, checker_obj,
- thread_obj->u.fd,
+ thread->u.fd,
http_get_check->connection_to);
} else {
DBG(LOG_INFO, "Connection trouble to: [%s]:%d."
, checker_obj->rs);
}
- return epilog(thread_obj, 1, 0, 0);
+ return epilog(thread, 1, 0, 0);
}
}
break;
}
int
-http_connect_thread(thread * thread_obj)
+http_connect_thread(thread_t * thread)
{
- checker *checker_obj = THREAD_ARG(thread_obj);
+ checker *checker_obj = THREAD_ARG(thread);
http_get_checker *http_get_check = CHECKER_ARG(checker_obj);
http_arg *http_arg_obj = HTTP_ARG(http_get_check);
url *fetched_url;
* if checker is disabled
*/
if (!CHECKER_ENABLED(checker_obj)) {
- thread_add_timer(thread_obj->master, http_connect_thread, checker_obj,
+ thread_add_timer(thread->master, http_connect_thread, checker_obj,
checker_obj->vs->delay_loop);
return 0;
}
, checker_obj->rs);
}
http_arg_obj->req = NULL;
- return epilog(thread_obj, 1, 0, 0) + 1;
+ return epilog(thread, 1, 0, 0) + 1;
}
/* Create the socket */
status = tcp_bind_connect(fd, &http_get_check->dst, &http_get_check->bindto);
if (status == connect_error) {
- thread_add_timer(thread_obj->master, http_connect_thread, checker_obj,
+ thread_add_timer(thread->master, http_connect_thread, checker_obj,
checker_obj->vs->delay_loop);
return 0;
}
/* handle tcp connection status & register check worker thread */
- tcp_connection_state(fd, status, thread_obj, http_check_thread,
+ tcp_connection_state(fd, status, thread, http_check_thread,
http_get_check->connection_to);
return 0;
}
#include "daemon.h"
#include "signals.h"
-int misc_check_thread(thread *);
-int misc_check_child_thread(thread *);
-int misc_check_child_timeout_thread(thread *);
+int misc_check_thread(thread_t *);
+int misc_check_child_thread(thread_t *);
+int misc_check_child_timeout_thread(thread_t *);
/* Configuration stream handling */
void
}
int
-misc_check_thread(thread * thread_obj)
+misc_check_thread(thread_t * thread)
{
checker *checker_obj;
misc_checker *misc_chk;
int status, ret;
pid_t pid;
- checker_obj = THREAD_ARG(thread_obj);
+ checker_obj = THREAD_ARG(thread);
misc_chk = CHECKER_ARG(checker_obj);
/*
*/
if (!CHECKER_ENABLED(checker_obj)) {
/* Register next timer checker */
- thread_add_timer(thread_obj->master, misc_check_thread, checker_obj,
+ thread_add_timer(thread->master, misc_check_thread, checker_obj,
checker_obj->vs->delay_loop);
return 0;
}
/* Register next timer checker */
- thread_add_timer(thread_obj->master, misc_check_thread, checker_obj,
+ thread_add_timer(thread->master, misc_check_thread, checker_obj,
checker_obj->vs->delay_loop);
/* Daemonization to not degrade our scheduling timer */
long timeout;
timeout = (misc_chk->timeout) ? misc_chk->timeout : checker_obj->vs->delay_loop;
- thread_add_child(thread_obj->master, misc_check_child_thread,
+ thread_add_child(thread->master, misc_check_child_thread,
checker_obj, pid, timeout);
return 0;
}
}
int
-misc_check_child_thread(thread * thread_obj)
+misc_check_child_thread(thread_t * thread)
{
int wait_status;
checker *checker_obj;
misc_checker *misc_chk;
- checker_obj = THREAD_ARG(thread_obj);
+ checker_obj = THREAD_ARG(thread);
misc_chk = CHECKER_ARG(checker_obj);
- if (thread_obj->type == THREAD_CHILD_TIMEOUT) {
+ if (thread->type == THREAD_CHILD_TIMEOUT) {
pid_t pid;
- pid = THREAD_CHILD_PID(thread_obj);
+ pid = THREAD_CHILD_PID(thread);
/* The child hasn't responded. Kill it off. */
if (svr_checker_up(checker_obj->id, checker_obj->rs)) {
}
kill(pid, SIGTERM);
- thread_add_child(thread_obj->master, misc_check_child_timeout_thread,
+ thread_add_child(thread->master, misc_check_child_timeout_thread,
checker_obj, pid, 2);
return 0;
}
- wait_status = THREAD_CHILD_STATUS(thread_obj);
+ wait_status = THREAD_CHILD_STATUS(thread);
if (WIFEXITED(wait_status)) {
int status;
}
int
-misc_check_child_timeout_thread(thread * thread_obj)
+misc_check_child_timeout_thread(thread_t * thread)
{
pid_t pid;
- if (thread_obj->type != THREAD_CHILD_TIMEOUT)
+ if (thread->type != THREAD_CHILD_TIMEOUT)
return 0;
/* OK, it still hasn't exited. Now really kill it off. */
- pid = THREAD_CHILD_PID(thread_obj);
+ pid = THREAD_CHILD_PID(thread);
if (kill(pid, SIGKILL) < 0) {
/* Its possible it finished while we're handing this */
if (errno != ESRCH)
#include "parser.h"
#include "daemon.h"
-int smtp_connect_thread(thread *);
+int smtp_connect_thread(thread_t *);
/* module variables */
static smtp_host *default_host = NULL;
* list.
*
* queue_checker(void (*free) (void *), void (*dump) (void *),
- * int (*launch) (struct _thread *),
+ * int (*launch) (thread_t *),
* void *data)
*/
queue_checker(free_smtp_check, dump_smtp_check, smtp_connect_thread,
* service down in case of error.
*/
int
-smtp_final(thread *thread_obj, int error, const char *format, ...)
+smtp_final(thread_t *thread, int error, const char *format, ...)
{
- checker *chk = THREAD_ARG(thread_obj);
+ checker *chk = THREAD_ARG(thread);
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_obj->u.fd);
+ close(thread->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_obj->master, smtp_connect_thread, chk,
+ thread_add_timer(thread->master, smtp_connect_thread, chk,
smtp_chk->db_retry);
return 0;
}
smtp_chk->host_ctr = 0;
/* Reschedule the main thread using the configured delay loop */;
- thread_add_timer(thread_obj->master, smtp_connect_thread, chk, chk->vs->delay_loop);
+ thread_add_timer(thread->master, smtp_connect_thread, chk, chk->vs->delay_loop);
return 0;
}
smtp_chk->attempts = 0;
smtp_chk->host_ctr++;
- thread_add_timer(thread_obj->master, smtp_connect_thread, chk, 1);
+ thread_add_timer(thread->master, smtp_connect_thread, chk, 1);
return 0;
}
* Zeros out the rx/tx buffer
*/
void
-smtp_clear_buff(thread *thread_obj)
+smtp_clear_buff(thread_t *thread)
{
- checker *chk = THREAD_ARG(thread_obj);
+ checker *chk = THREAD_ARG(thread);
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_obj)
+smtp_get_line_cb(thread_t *thread)
{
- checker *chk = THREAD_ARG(thread_obj);
+ checker *chk = THREAD_ARG(thread);
smtp_checker *smtp_chk = CHECKER_ARG(chk);
smtp_host *smtp_hst = smtp_chk->host_ptr;
int f, r, x;
/* Handle read timeout */
- if (thread_obj->type == THREAD_READ_TIMEOUT) {
- smtp_final(thread_obj, 1, "Read timeout from server [%s:%d]"
+ if (thread->type == THREAD_READ_TIMEOUT) {
+ smtp_final(thread, 1, "Read timeout from server [%s:%d]"
, inet_sockaddrtos(&smtp_hst->dst)
, ntohs(inet_sockaddrport(&smtp_hst->dst)));
return 0;
"Increase SMTP_BUFF_MAX in smtp_check.h"
, inet_sockaddrtos(&smtp_hst->dst)
, ntohs(inet_sockaddrport(&smtp_hst->dst)));
- smtp_clear_buff(thread_obj);
+ smtp_clear_buff(thread);
}
/* Set descriptor non blocking */
- f = fcntl(thread_obj->u.fd, F_GETFL, 0);
- fcntl(thread_obj->u.fd, F_SETFL, f | O_NONBLOCK);
+ f = fcntl(thread->u.fd, F_GETFL, 0);
+ fcntl(thread->u.fd, F_SETFL, f | O_NONBLOCK);
/* read the data */
- r = read(thread_obj->u.fd, smtp_chk->buff + smtp_chk->buff_ctr,
+ r = read(thread->u.fd, smtp_chk->buff + smtp_chk->buff_ctr,
SMTP_BUFF_MAX - smtp_chk->buff_ctr);
if (r == -1 && (errno == EAGAIN || errno == EINTR)) {
- 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);
+ thread_add_read(thread->master, smtp_get_line_cb, chk,
+ thread->u.fd, smtp_chk->timeout);
+ fcntl(thread->u.fd, F_SETFL, f);
return 0;
} else if (r > 0)
smtp_chk->buff_ctr += r;
/* restore descriptor flags */
- fcntl(thread_obj->u.fd, F_SETFL, f);
+ fcntl(thread->u.fd, F_SETFL, f);
/* check if we have a newline, if so, callback */
for (x = 0; x < SMTP_BUFF_MAX; x++) {
, ntohs(inet_sockaddrport(&smtp_hst->dst))
, smtp_chk->buff);
- (smtp_chk->buff_cb)(thread_obj);
+ (smtp_chk->buff_cb)(thread);
return 0;
}
* some sort of error, notify smtp_final()
*/
if (r <= 0) {
- smtp_final(thread_obj, 1, "Read failure from server [%s:%d]"
+ smtp_final(thread, 1, "Read failure from server [%s:%d]"
, inet_sockaddrtos(&smtp_hst->dst)
, ntohs(inet_sockaddrport(&smtp_hst->dst)));
return 0;
* to pull a newline. Schedule ourselves for
* another round.
*/
- thread_add_read(thread_obj->master, smtp_get_line_cb, chk,
- thread_obj->u.fd, smtp_chk->timeout);
+ thread_add_read(thread->master, smtp_get_line_cb, chk,
+ thread->u.fd, smtp_chk->timeout);
return 0;
}
* sceduler can only accept a single *thread argument.
*/
void
-smtp_get_line(thread *thread_obj, int (*callback) (struct _thread *))
+smtp_get_line(thread_t *thread, int (*callback) (thread_t *))
{
- checker *chk = THREAD_ARG(thread_obj);
+ checker *chk = THREAD_ARG(thread);
smtp_checker *smtp_chk = CHECKER_ARG(chk);
/* clear the buffer */
- smtp_clear_buff(thread_obj);
+ smtp_clear_buff(thread);
/* set the callback */
smtp_chk->buff_cb = callback;
/* schedule the I/O with our helper function */
- thread_add_read(thread_obj->master, smtp_get_line_cb, chk,
- thread_obj->u.fd, smtp_chk->timeout);
+ thread_add_read(thread->master, smtp_get_line_cb, chk,
+ thread->u.fd, smtp_chk->timeout);
return;
}
* we'll return to the scheduler and try again later.
*/
int
-smtp_put_line_cb(thread *thread_obj)
+smtp_put_line_cb(thread_t *thread)
{
- checker *chk = THREAD_ARG(thread_obj);
+ checker *chk = THREAD_ARG(thread);
smtp_checker *smtp_chk = CHECKER_ARG(chk);
smtp_host *smtp_hst = smtp_chk->host_ptr;
int f, w;
/* Handle read timeout */
- if (thread_obj->type == THREAD_WRITE_TIMEOUT) {
- smtp_final(thread_obj, 1, "Write timeout to server [%s:%d]"
+ if (thread->type == THREAD_WRITE_TIMEOUT) {
+ smtp_final(thread, 1, "Write timeout to server [%s:%d]"
, inet_sockaddrtos(&smtp_hst->dst)
, ntohs(inet_sockaddrport(&smtp_hst->dst)));
return 0;
}
/* Set descriptor non blocking */
- f = fcntl(thread_obj->u.fd, F_GETFL, 0);
- fcntl(thread_obj->u.fd, F_SETFL, f | O_NONBLOCK);
+ f = fcntl(thread->u.fd, F_GETFL, 0);
+ fcntl(thread->u.fd, F_SETFL, f | O_NONBLOCK);
/* write the data */
- w = write(thread_obj->u.fd, smtp_chk->buff, smtp_chk->buff_ctr);
+ w = write(thread->u.fd, smtp_chk->buff, smtp_chk->buff_ctr);
if (w == -1 && (errno == EAGAIN || errno == EINTR)) {
- 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);
+ thread_add_write(thread->master, smtp_put_line_cb, chk,
+ thread->u.fd, smtp_chk->timeout);
+ fcntl(thread->u.fd, F_SETFL, f);
return 0;
}
/* restore descriptor flags */
- fcntl(thread_obj->u.fd, F_SETFL, f);
+ fcntl(thread->u.fd, F_SETFL, f);
DBG("SMTP_CHECK [%s:%d] > %s"
, inet_sockaddrtos(&smtp_hst->dst)
* some sort of error, notify smtp_final()
*/
if (w <= 0) {
- smtp_final(thread_obj, 1, "Write failure to server [%s:%d]"
+ smtp_final(thread, 1, "Write failure to server [%s:%d]"
, inet_sockaddrtos(&smtp_hst->dst)
, ntohs(inet_sockaddrport(&smtp_hst->dst)));
return 0;
}
/* Execute the callback */
- (smtp_chk->buff_cb)(thread_obj);
+ (smtp_chk->buff_cb)(thread);
return 0;
}
* line of data instead of receiving one.
*/
void
-smtp_put_line(thread *thread_obj, int (*callback) (struct _thread *))
+smtp_put_line(thread_t *thread, int (*callback) (thread_t *))
{
- checker *chk = THREAD_ARG(thread_obj);
+ checker *chk = THREAD_ARG(thread);
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_obj->master, smtp_put_line_cb, chk,
- thread_obj->u.fd, smtp_chk->timeout);
+ thread_add_write(thread->master, smtp_put_line_cb, chk,
+ thread->u.fd, smtp_chk->timeout);
return;
}
* return -1.
*/
int
-smtp_get_status(thread *thread_obj)
+smtp_get_status(thread_t *thread)
{
- checker *chk = THREAD_ARG(thread_obj);
+ checker *chk = THREAD_ARG(thread);
smtp_checker *smtp_chk = CHECKER_ARG(chk);
char *buff = smtp_chk->buff;
* should be set to SMTP_START.
*/
int
-smtp_engine_thread(thread *thread_obj)
+smtp_engine_thread(thread_t *thread)
{
- checker *chk = THREAD_ARG(thread_obj);
+ checker *chk = THREAD_ARG(thread);
smtp_checker *smtp_chk = CHECKER_ARG(chk);
smtp_host *smtp_hst = smtp_chk->host_ptr;
* will defer directly to smtp_final.
*/
smtp_chk->state = SMTP_HAVE_BANNER;
- smtp_get_line(thread_obj, smtp_engine_thread);
+ smtp_get_line(thread, 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_obj) != 220) {
- smtp_final(thread_obj, 1, "Bad greeting banner from server [%s:%d]"
+ if (smtp_get_status(thread) != 220) {
+ smtp_final(thread, 1, "Bad greeting banner from server [%s:%d]"
, inet_sockaddrtos(&smtp_hst->dst)
, ntohs(inet_sockaddrport(&smtp_hst->dst)));
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_obj, smtp_engine_thread);
+ smtp_put_line(thread, 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_obj, smtp_engine_thread);
+ smtp_get_line(thread, 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_obj) != 250) {
- smtp_final(thread_obj, 1, "Bad HELO response from server [%s:%d]"
+ if (smtp_get_status(thread) != 250) {
+ smtp_final(thread, 1, "Bad HELO response from server [%s:%d]"
, inet_sockaddrtos(&smtp_hst->dst)
, ntohs(inet_sockaddrport(&smtp_hst->dst)));
smtp_chk->state = SMTP_SENT_QUIT;
snprintf(smtp_chk->buff, SMTP_BUFF_MAX, "QUIT\r\n");
- smtp_put_line(thread_obj, smtp_engine_thread);
+ smtp_put_line(thread, 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_obj, smtp_engine_thread);
+ smtp_get_line(thread, smtp_engine_thread);
return 0;
break;
/* Sixth step, wrap up success to smtp_final */
case SMTP_RECV_QUIT:
- smtp_final(thread_obj, 0, NULL);
+ smtp_final(thread, 0, NULL);
return 0;
break;
}
/* We shouldn't be here */
- smtp_final(thread_obj, 1, "Unknown smtp engine state encountered");
+ smtp_final(thread, 1, "Unknown smtp engine state encountered");
return 0;
}
* to the host we're checking was successful or not.
*/
int
-smtp_check_thread(thread *thread_obj)
+smtp_check_thread(thread_t *thread)
{
- checker *chk = THREAD_ARG(thread_obj);
+ checker *chk = THREAD_ARG(thread);
smtp_checker *smtp_chk = CHECKER_ARG(chk);
smtp_host *smtp_hst = smtp_chk->host_ptr;
int status;
- status = tcp_socket_state(thread_obj->u.fd, thread_obj, smtp_check_thread);
+ status = tcp_socket_state(thread->u.fd, thread, smtp_check_thread);
switch (status) {
case connect_error:
- smtp_final(thread_obj, 1, "Error connecting to server [%s:%d]"
+ smtp_final(thread, 1, "Error connecting to server [%s:%d]"
, inet_sockaddrtos(&smtp_hst->dst)
, ntohs(inet_sockaddrport(&smtp_hst->dst)));
return 0;
break;
case connect_timeout:
- smtp_final(thread_obj, 1, "Connection timeout to server [%s:%d]"
+ smtp_final(thread, 1, "Connection timeout to server [%s:%d]"
, inet_sockaddrtos(&smtp_hst->dst)
, ntohs(inet_sockaddrport(&smtp_hst->dst)));
return 0;
/* Enter the engine at SMTP_START */
smtp_chk->state = SMTP_START;
- smtp_engine_thread(thread_obj);
+ smtp_engine_thread(thread);
return 0;
break;
}
/* we shouldn't be here */
- smtp_final(thread_obj, 1, "Unknown connection error to server [%s:%d]"
+ smtp_final(thread, 1, "Unknown connection error to server [%s:%d]"
, inet_sockaddrtos(&smtp_hst->dst)
, ntohs(inet_sockaddrport(&smtp_hst->dst)));
return 0;
* but eventually has to happen.
*/
int
-smtp_connect_thread(thread *thread_obj)
+smtp_connect_thread(thread_t *thread)
{
- checker *chk = THREAD_ARG(thread_obj);
+ checker *chk = THREAD_ARG(thread);
smtp_checker *smtp_chk = CHECKER_ARG(chk);
smtp_host *smtp_hst;
enum connect_result status;
* we don't fall of the face of the earth.
*/
if (!CHECKER_ENABLED(chk)) {
- thread_add_timer(thread_obj->master, smtp_connect_thread, chk,
+ thread_add_timer(thread->master, smtp_connect_thread, chk,
chk->vs->delay_loop);
return 0;
}
smtp_chk->host_ctr = 0;
smtp_chk->host_ptr = list_element(smtp_chk->host, 0);
- thread_add_timer(thread_obj->master, smtp_connect_thread, chk, chk->vs->delay_loop);
+ thread_add_timer(thread->master, smtp_connect_thread, chk, chk->vs->delay_loop);
return 0;
}
/* Create the socket, failling here should be an oddity */
if ((sd = socket(smtp_hst->dst.ss_family, SOCK_STREAM, IPPROTO_TCP)) == -1) {
DBG("SMTP_CHECK connection failed to create socket.");
- thread_add_timer(thread_obj->master, smtp_connect_thread, chk,
+ thread_add_timer(thread->master, smtp_connect_thread, chk,
chk->vs->delay_loop);
return 0;
}
status = tcp_bind_connect(sd, &smtp_hst->dst, &smtp_hst->bindto);
if (status == connect_error) {
- thread_add_timer(thread_obj->master, smtp_connect_thread, chk,
+ thread_add_timer(thread->master, smtp_connect_thread, chk,
chk->vs->delay_loop);
return 0;
}
/* handle tcp connection status & register callback the next setp in the process */
- tcp_connection_state(sd, status, thread_obj, smtp_check_thread, smtp_chk->timeout);
+ tcp_connection_state(sd, status, thread, smtp_check_thread, smtp_chk->timeout);
return 0;
}
}
int
-ssl_connect(thread * thread_obj, int new_req)
+ssl_connect(thread_t * thread, int new_req)
{
- checker *checker_obj = THREAD_ARG(thread_obj);
+ checker *checker_obj = THREAD_ARG(thread);
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);
/* First round, create SSL context */
if (new_req) {
req->ssl = SSL_new(check_data->ssl->ctx);
- req->bio = BIO_new_socket(thread_obj->u.fd, BIO_NOCLOSE);
+ req->bio = BIO_new_socket(thread->u.fd, BIO_NOCLOSE);
SSL_set_bio(req->ssl, req->bio, req->bio);
}
/* Set descriptor non blocking */
- val = fcntl(thread_obj->u.fd, F_GETFL, 0);
- fcntl(thread_obj->u.fd, F_SETFL, val | O_NONBLOCK);
+ val = fcntl(thread->u.fd, F_GETFL, 0);
+ fcntl(thread->u.fd, F_SETFL, val | O_NONBLOCK);
ret = SSL_connect(req->ssl);
/* restore descriptor flags */
- fcntl(thread_obj->u.fd, F_SETFL, val);
+ fcntl(thread->u.fd, F_SETFL, val);
return ret;
}
/* Asynchronous SSL stream reader */
int
-ssl_read_thread(thread * thread_obj)
+ssl_read_thread(thread_t * thread)
{
- checker *checker_obj = THREAD_ARG(thread_obj);
+ checker *checker_obj = THREAD_ARG(thread);
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);
int val;
/* Handle read timeout */
- if (thread_obj->type == THREAD_READ_TIMEOUT && !req->extracted)
- return timeout_epilog(thread_obj, "=> SSL CHECK failed on service"
+ if (thread->type == THREAD_READ_TIMEOUT && !req->extracted)
+ return timeout_epilog(thread, "=> 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);
+ val = fcntl(thread->u.fd, F_GETFL, 0);
+ fcntl(thread->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);
+ fcntl(thread->u.fd, F_SETFL, val);
req->error = SSL_get_error(req->ssl, r);
if (req->error == SSL_ERROR_WANT_READ) {
/* async read unfinished */
- thread_add_read(thread_obj->master, ssl_read_thread, checker_obj,
- thread_obj->u.fd, http_get_check->connection_to);
+ thread_add_read(thread->master, ssl_read_thread, checker_obj,
+ thread->u.fd, http_get_check->connection_to);
} else if (r > 0 && req->error == 0) {
/* Handle response stream */
http_process_response(req, r);
* Register next ssl stream reader.
* Register itself to not perturbe global I/O multiplexer.
*/
- thread_add_read(thread_obj->master, ssl_read_thread, checker_obj,
- thread_obj->u.fd, http_get_check->connection_to);
+ thread_add_read(thread->master, ssl_read_thread, checker_obj,
+ thread->u.fd, http_get_check->connection_to);
} else if (req->error) {
/* All the SSL streal has been parsed */
, checker_obj->vs
, checker_obj->rs);
}
- return epilog(thread_obj, 1, 0, 0);
+ return epilog(thread, 1, 0, 0);
}
/* Handle response stream */
- http_handle_response(thread_obj, digest, (!req->extracted) ? 1 : 0);
+ http_handle_response(thread, digest, (!req->extracted) ? 1 : 0);
}
#include "utils.h"
#include "parser.h"
-int tcp_connect_thread(thread *);
+int tcp_connect_thread(thread_t *);
/* Configuration stream handling */
void
}
int
-tcp_check_thread(thread * thread_obj)
+tcp_check_thread(thread_t * thread)
{
checker *checker_obj;
tcp_checker *tcp_check;
int status;
- checker_obj = THREAD_ARG(thread_obj);
+ checker_obj = THREAD_ARG(thread);
tcp_check = CHECKER_ARG(checker_obj);
- status = tcp_socket_state(thread_obj->u.fd, thread_obj, tcp_check_thread);
+ status = tcp_socket_state(thread->u.fd, thread, 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_obj->u.fd);
+ close(thread->u.fd);
if (!svr_checker_up(checker_obj->id, checker_obj->rs)) {
log_message(LOG_INFO, "TCP connection to [%s]:%d success."
/* Register next timer checker */
if (status != connect_in_progress)
- thread_add_timer(thread_obj->master, tcp_connect_thread, checker_obj,
+ thread_add_timer(thread->master, tcp_connect_thread, checker_obj,
checker_obj->vs->delay_loop);
return 0;
}
int
-tcp_connect_thread(thread * thread_obj)
+tcp_connect_thread(thread_t * thread)
{
- checker *checker_obj = THREAD_ARG(thread_obj);
+ checker *checker_obj = THREAD_ARG(thread);
tcp_checker *tcp_check = CHECKER_ARG(checker_obj);
int fd;
int status;
* if checker is disabled
*/
if (!CHECKER_ENABLED(checker_obj)) {
- thread_add_timer(thread_obj->master, tcp_connect_thread, checker_obj,
+ thread_add_timer(thread->master, tcp_connect_thread, checker_obj,
checker_obj->vs->delay_loop);
return 0;
}
status = tcp_bind_connect(fd, &tcp_check->dst, &tcp_check->bindto);
if (status == connect_error) {
- thread_add_timer(thread_obj->master, tcp_connect_thread, checker_obj,
+ thread_add_timer(thread->master, tcp_connect_thread, checker_obj,
checker_obj->vs->delay_loop);
return 0;
}
/* handle tcp connection status & register check worker thread */
- tcp_connection_state(fd, status, thread_obj, tcp_check_thread,
+ tcp_connection_state(fd, status, thread, tcp_check_thread,
tcp_check->connection_to);
return 0;
}
}
enum connect_result
-tcp_socket_state(int fd, thread * thread_obj, int (*func) (struct _thread *))
+tcp_socket_state(int fd, thread_t * thread, int (*func) (thread_t *))
{
int status;
socklen_t addrlen;
TIMEVAL timer_min;
/* Handle connection timeout */
- if (thread_obj->type == THREAD_WRITE_TIMEOUT) {
- close(thread_obj->u.fd);
+ if (thread->type == THREAD_WRITE_TIMEOUT) {
+ close(thread->u.fd);
return connect_timeout;
}
/* Check file descriptor */
addrlen = sizeof(status);
- if (getsockopt(thread_obj->u.fd, SOL_SOCKET, SO_ERROR, (void *) &status, &addrlen) < 0)
+ if (getsockopt(thread->u.fd, SOL_SOCKET, SO_ERROR, (void *) &status, &addrlen) < 0)
ret = errno;
/* Connection failed !!! */
if (ret) {
- close(thread_obj->u.fd);
+ close(thread->u.fd);
return connect_error;
}
* Recompute the write timeout (or pending connection).
*/
if (status == EINPROGRESS) {
- 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));
+ timer_min = timer_sub_now(thread->sands);
+ thread_add_write(thread->master, func, THREAD_ARG(thread),
+ thread->u.fd, TIMER_LONG(timer_min));
return connect_in_progress;
} else if (status != 0) {
- close(thread_obj->u.fd);
+ close(thread->u.fd);
return connect_error;
}
}
void
-tcp_connection_state(int fd, enum connect_result status, thread * thread_obj,
- int (*func) (struct _thread *), long timeout)
+tcp_connection_state(int fd, enum connect_result status, thread_t * thread,
+ int (*func) (thread_t *), long timeout)
{
checker *checker_obj;
- checker_obj = THREAD_ARG(thread_obj);
+ checker_obj = THREAD_ARG(thread);
switch (status) {
case connect_error:
break;
case connect_success:
- thread_add_write(thread_obj->master, func, checker_obj, fd, timeout);
+ thread_add_write(thread->master, func, checker_obj, fd, timeout);
break;
/* Checking non-blocking connect, we wait until socket is writable */
case connect_in_progress:
- thread_add_write(thread_obj->master, func, checker_obj, fd, timeout);
+ thread_add_write(thread->master, func, checker_obj, fd, timeout);
break;
default:
#include "utils.h"
/* SMTP FSM definition */
-static int connection_error(thread *);
-static int connection_in_progress(thread *);
-static int connection_timeout(thread *);
-static int connection_success(thread *);
-static int helo_cmd(thread *);
-static int mail_cmd(thread *);
-static int rcpt_cmd(thread *);
-static int data_cmd(thread *);
-static int body_cmd(thread *);
-static int quit_cmd(thread *);
-
-static int connection_code(thread *, int);
-static int helo_code(thread *, int);
-static int mail_code(thread *, int);
-static int rcpt_code(thread *, int);
-static int data_code(thread *, int);
-static int body_code(thread *, int);
-static int quit_code(thread *, int);
-
-static int smtp_read_thread(thread *);
-static int smtp_send_thread(thread *);
+static int connection_error(thread_t *);
+static int connection_in_progress(thread_t *);
+static int connection_timeout(thread_t *);
+static int connection_success(thread_t *);
+static int helo_cmd(thread_t *);
+static int mail_cmd(thread_t *);
+static int rcpt_cmd(thread_t *);
+static int data_cmd(thread_t *);
+static int body_cmd(thread_t *);
+static int quit_cmd(thread_t *);
+
+static int connection_code(thread_t *, int);
+static int helo_code(thread_t *, int);
+static int mail_code(thread_t *, int);
+static int rcpt_code(thread_t *, int);
+static int data_code(thread_t *, int);
+static int body_code(thread_t *, int);
+static int quit_code(thread_t *, int);
+
+static int smtp_read_thread(thread_t *);
+static int smtp_send_thread(thread_t *);
struct {
- int (*send) (thread *);
- int (*read) (thread *, int);
+ int (*send) (thread_t *);
+ int (*read) (thread_t *, int);
} SMTP_FSM[SMTP_MAX_FSM_STATE] = {
/* Stream Write Handlers | Stream Read handlers *
*-------------------------------+--------------------------*/
/* layer4 connection handlers */
static int
-connection_error(thread * thread_obj)
+connection_error(thread_t * thread)
{
- smtp_thread_arg *smtp_arg = THREAD_ARG(thread_obj);
+ smtp_thread_arg *smtp_arg = THREAD_ARG(thread);
log_message(LOG_INFO, "SMTP connection ERROR to [%s:%d]."
, inet_sockaddrtos(&data->smtp_server), SMTP_PORT);
return 0;
}
static int
-connection_timeout(thread * thread_obj)
+connection_timeout(thread_t * thread)
{
- smtp_thread_arg *smtp_arg = THREAD_ARG(thread_obj);
+ smtp_thread_arg *smtp_arg = THREAD_ARG(thread);
log_message(LOG_INFO, "Timeout connecting SMTP server [%s:%d]."
, inet_sockaddrtos(&data->smtp_server), SMTP_PORT);
return 0;
}
static int
-connection_in_progress(thread * thread_obj)
+connection_in_progress(thread_t * thread)
{
int status;
* Here we use the propriety of a union structure,
* each element of the structure have the same value.
*/
- status = tcp_socket_state(thread_obj->u.fd, thread_obj, connection_in_progress);
+ status = tcp_socket_state(thread->u.fd, thread, connection_in_progress);
if (status != connect_in_progress)
- SMTP_FSM_SEND(status, thread_obj);
+ SMTP_FSM_SEND(status, thread);
return 0;
}
static int
-connection_success(thread * thread_obj)
+connection_success(thread_t * thread)
{
- smtp_thread_arg *smtp_arg = THREAD_ARG(thread_obj);
+ smtp_thread_arg *smtp_arg = THREAD_ARG(thread);
log_message(LOG_INFO, "Remote SMTP server [%s:%d] connected."
, inet_sockaddrtos(&data->smtp_server), SMTP_PORT);
smtp_arg->stage = connect_success;
- thread_add_read(thread_obj->master, smtp_read_thread, smtp_arg,
+ thread_add_read(thread->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_obj)
+smtp_read_thread(thread_t * thread)
{
smtp_thread_arg *smtp_arg;
char *buffer;
int rcv_buffer_size = 0;
int status = -1;
- smtp_arg = THREAD_ARG(thread_obj);
+ smtp_arg = THREAD_ARG(thread);
- if (thread_obj->type == THREAD_READ_TIMEOUT) {
+ if (thread->type == THREAD_READ_TIMEOUT) {
log_message(LOG_INFO, "Timeout reading data to remote SMTP server [%s:%d]."
, inet_sockaddrtos(&data->smtp_server), SMTP_PORT);
- SMTP_FSM_READ(QUIT, thread_obj, 0);
+ SMTP_FSM_READ(QUIT, thread, 0);
return -1;
}
buffer = smtp_arg->buffer;
- rcv_buffer_size = read(thread_obj->u.fd, buffer + smtp_arg->buflen,
+ rcv_buffer_size = read(thread->u.fd, buffer + smtp_arg->buflen,
SMTP_BUFFER_LENGTH - smtp_arg->buflen);
if (rcv_buffer_size == -1) {
goto end;
log_message(LOG_INFO, "Error reading data from remote SMTP server [%s:%d]."
, inet_sockaddrtos(&data->smtp_server), SMTP_PORT);
- SMTP_FSM_READ(QUIT, thread_obj, 0);
+ SMTP_FSM_READ(QUIT, thread, 0);
return 0;
}
log_message(LOG_INFO, "Received buffer from remote SMTP server [%s:%d]"
" overflow our get read buffer length."
, inet_sockaddrtos(&data->smtp_server), SMTP_PORT);
- SMTP_FSM_READ(QUIT, thread_obj, 0);
+ SMTP_FSM_READ(QUIT, thread, 0);
return 0;
} else {
smtp_arg->buflen += rcv_buffer_size;
smtp_arg->buflen -= (reply - buffer);
buffer[smtp_arg->buflen] = 0;
- thread_add_read(thread_obj->master, smtp_read_thread,
- smtp_arg, thread_obj->u.fd,
+ thread_add_read(thread->master, smtp_read_thread,
+ smtp_arg, thread->u.fd,
data->smtp_connection_to);
return 0;
}
buffer[smtp_arg->buflen] = 0;
if (status == -1) {
- thread_add_read(thread_obj->master, smtp_read_thread, smtp_arg,
- thread_obj->u.fd, data->smtp_connection_to);
+ thread_add_read(thread->master, smtp_read_thread, smtp_arg,
+ thread->u.fd, data->smtp_connection_to);
return 0;
}
- SMTP_FSM_READ(smtp_arg->stage, thread_obj, status);
+ SMTP_FSM_READ(smtp_arg->stage, thread, status);
/* Registering next smtp command processing thread */
if (smtp_arg->stage != ERROR) {
- thread_add_write(thread_obj->master, smtp_send_thread, smtp_arg,
+ thread_add_write(thread->master, smtp_send_thread, smtp_arg,
smtp_arg->fd, data->smtp_connection_to);
} else {
log_message(LOG_INFO, "Can not read data from remote SMTP server [%s:%d]."
, inet_sockaddrtos(&data->smtp_server), SMTP_PORT);
- SMTP_FSM_READ(QUIT, thread_obj, 0);
+ SMTP_FSM_READ(QUIT, thread, 0);
}
return 0;
}
static int
-smtp_send_thread(thread * thread_obj)
+smtp_send_thread(thread_t * thread)
{
- smtp_thread_arg *smtp_arg = THREAD_ARG(thread_obj);
+ smtp_thread_arg *smtp_arg = THREAD_ARG(thread);
- if (thread_obj->type == THREAD_WRITE_TIMEOUT) {
+ if (thread->type == THREAD_WRITE_TIMEOUT) {
log_message(LOG_INFO, "Timeout sending data to remote SMTP server [%s:%d]."
, inet_sockaddrtos(&data->smtp_server), SMTP_PORT);
- SMTP_FSM_READ(QUIT, thread_obj, 0);
+ SMTP_FSM_READ(QUIT, thread, 0);
return 0;
}
- SMTP_FSM_SEND(smtp_arg->stage, thread_obj);
+ SMTP_FSM_SEND(smtp_arg->stage, thread);
/* Handle END command */
if (smtp_arg->stage == END) {
- SMTP_FSM_READ(QUIT, thread_obj, 0);
+ SMTP_FSM_READ(QUIT, thread, 0);
return 0;
}
/* Registering next smtp command processing thread */
if (smtp_arg->stage != ERROR) {
- thread_add_read(thread_obj->master, smtp_read_thread, smtp_arg,
- thread_obj->u.fd, data->smtp_connection_to);
+ thread_add_read(thread->master, smtp_read_thread, smtp_arg,
+ thread->u.fd, data->smtp_connection_to);
} else {
log_message(LOG_INFO,
"Can not send data to remote SMTP server [%s:%d].",
inet_sockaddrtos(&data->smtp_server), SMTP_PORT);
- SMTP_FSM_READ(QUIT, thread_obj, 0);
+ SMTP_FSM_READ(QUIT, thread, 0);
}
return 0;
}
static int
-connection_code(thread * thread_obj, int status)
+connection_code(thread_t * thread, int status)
{
- smtp_thread_arg *smtp_arg = THREAD_ARG(thread_obj);
+ smtp_thread_arg *smtp_arg = THREAD_ARG(thread);
if (status == 220) {
smtp_arg->stage++;
/* HELO command processing */
static int
-helo_cmd(thread * thread_obj)
+helo_cmd(thread_t * thread)
{
- smtp_thread_arg *smtp_arg = THREAD_ARG(thread_obj);
+ smtp_thread_arg *smtp_arg = THREAD_ARG(thread);
char *buffer;
buffer = (char *) MALLOC(SMTP_BUFFER_MAX);
snprintf(buffer, SMTP_BUFFER_MAX, SMTP_HELO_CMD, get_local_name());
- if (send(thread_obj->u.fd, buffer, strlen(buffer), 0) == -1)
+ if (send(thread->u.fd, buffer, strlen(buffer), 0) == -1)
smtp_arg->stage = ERROR;
FREE(buffer);
return 0;
}
static int
-helo_code(thread * thread_obj, int status)
+helo_code(thread_t * thread, int status)
{
- smtp_thread_arg *smtp_arg = THREAD_ARG(thread_obj);
+ smtp_thread_arg *smtp_arg = THREAD_ARG(thread);
if (status == 250) {
smtp_arg->stage++;
/* MAIL command processing */
static int
-mail_cmd(thread * thread_obj)
+mail_cmd(thread_t * thread)
{
- smtp_thread_arg *smtp_arg = THREAD_ARG(thread_obj);
+ smtp_thread_arg *smtp_arg = THREAD_ARG(thread);
char *buffer;
buffer = (char *) MALLOC(SMTP_BUFFER_MAX);
snprintf(buffer, SMTP_BUFFER_MAX, SMTP_MAIL_CMD, data->email_from);
- if (send(thread_obj->u.fd, buffer, strlen(buffer), 0) == -1)
+ if (send(thread->u.fd, buffer, strlen(buffer), 0) == -1)
smtp_arg->stage = ERROR;
FREE(buffer);
return 0;
}
static int
-mail_code(thread * thread_obj, int status)
+mail_code(thread_t * thread, int status)
{
- smtp_thread_arg *smtp_arg = THREAD_ARG(thread_obj);
+ smtp_thread_arg *smtp_arg = THREAD_ARG(thread);
if (status == 250) {
smtp_arg->stage++;
/* RCPT command processing */
static int
-rcpt_cmd(thread * thread_obj)
+rcpt_cmd(thread_t * thread)
{
- smtp_thread_arg *smtp_arg = THREAD_ARG(thread_obj);
+ smtp_thread_arg *smtp_arg = THREAD_ARG(thread);
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_obj->u.fd, buffer, strlen(buffer), 0) == -1)
+ if (send(thread->u.fd, buffer, strlen(buffer), 0) == -1)
smtp_arg->stage = ERROR;
FREE(buffer);
return 0;
}
static int
-rcpt_code(thread * thread_obj, int status)
+rcpt_code(thread_t * thread, int status)
{
- smtp_thread_arg *smtp_arg = THREAD_ARG(thread_obj);
+ smtp_thread_arg *smtp_arg = THREAD_ARG(thread);
char *fetched_email;
if (status == 250) {
/* DATA command processing */
static int
-data_cmd(thread * thread_obj)
+data_cmd(thread_t * thread)
{
- smtp_thread_arg *smtp_arg = THREAD_ARG(thread_obj);
+ smtp_thread_arg *smtp_arg = THREAD_ARG(thread);
- if (send(thread_obj->u.fd, SMTP_DATA_CMD, strlen(SMTP_DATA_CMD), 0) == -1)
+ if (send(thread->u.fd, SMTP_DATA_CMD, strlen(SMTP_DATA_CMD), 0) == -1)
smtp_arg->stage = ERROR;
return 0;
}
static int
-data_code(thread * thread_obj, int status)
+data_code(thread_t * thread, int status)
{
- smtp_thread_arg *smtp_arg = THREAD_ARG(thread_obj);
+ smtp_thread_arg *smtp_arg = THREAD_ARG(thread);
if (status == 354) {
smtp_arg->stage++;
* handling ? Don t really think :)
*/
static int
-body_cmd(thread * thread_obj)
+body_cmd(thread_t * thread)
{
- smtp_thread_arg *smtp_arg = THREAD_ARG(thread_obj);
+ smtp_thread_arg *smtp_arg = THREAD_ARG(thread);
char *buffer;
char rfc822[80];
time_t tm;
rfc822, data->email_from, smtp_arg->subject);
/* send the subject field */
- if (send(thread_obj->u.fd, buffer, strlen(buffer), 0) == -1)
+ if (send(thread->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_obj->u.fd, buffer, strlen(buffer), 0) == -1)
+ if (send(thread->u.fd, buffer, strlen(buffer), 0) == -1)
smtp_arg->stage = ERROR;
/* send the sending dot */
- if (send(thread_obj->u.fd, SMTP_SEND_CMD, strlen(SMTP_SEND_CMD), 0)
+ if (send(thread->u.fd, SMTP_SEND_CMD, strlen(SMTP_SEND_CMD), 0)
== -1)
smtp_arg->stage = ERROR;
return 0;
}
static int
-body_code(thread * thread_obj, int status)
+body_code(thread_t * thread, int status)
{
- smtp_thread_arg *smtp_arg = THREAD_ARG(thread_obj);
+ smtp_thread_arg *smtp_arg = THREAD_ARG(thread);
if (status == 250) {
log_message(LOG_INFO, "SMTP alert successfully sent.");
/* QUIT command processing */
static int
-quit_cmd(thread * thread_obj)
+quit_cmd(thread_t * thread)
{
- smtp_thread_arg *smtp_arg = THREAD_ARG(thread_obj);
+ smtp_thread_arg *smtp_arg = THREAD_ARG(thread);
- if (send(thread_obj->u.fd, SMTP_QUIT_CMD, strlen(SMTP_QUIT_CMD), 0) == -1)
+ if (send(thread->u.fd, SMTP_QUIT_CMD, strlen(SMTP_QUIT_CMD), 0) == -1)
smtp_arg->stage = ERROR;
else
smtp_arg->stage++;
return 0;
}
static int
-quit_code(thread * thread_obj, int status)
+quit_code(thread_t * thread, int status)
{
- smtp_thread_arg *smtp_arg = THREAD_ARG(thread_obj);
+ smtp_thread_arg *smtp_arg = THREAD_ARG(thread);
/* final state, we are disconnected from the remote host */
free_smtp_all(smtp_arg);
- close(thread_obj->u.fd);
+ close(thread->u.fd);
return 0;
}
/* prototypes */
extern SSL_DATA *alloc_ssl(void);
extern void free_ssl(void);
-extern void alloc_vsg(char *gname);
-extern void alloc_vsg_entry(vector strvec);
-extern void alloc_vs(char *ip, char *port);
-extern void alloc_rs(char *ip, char *port);
-extern void alloc_ssvr(char *ip, char *port);
-extern void alloc_group(char *name);
-extern void alloc_rsgroup(char *ip, char *port);
-extern void set_rsgroup(char *gname);
+extern void alloc_vsg(char *);
+extern void alloc_vsg_entry(vector);
+extern void alloc_vs(char *, char *);
+extern void alloc_rs(char *, char *);
+extern void alloc_ssvr(char *, char *);
+extern void alloc_group(char *);
+extern void alloc_rsgroup(char *, char *);
+extern void set_rsgroup(char *);
extern check_conf_data *alloc_check_data(void);
-extern void free_check_data(check_conf_data * check_data_obj);
-extern void dump_check_data(check_conf_data * check_data_obj);
+extern void free_check_data(check_conf_data *);
+extern void dump_check_data(check_conf_data *);
#endif
/* Define prototypes */
extern void install_http_check_keyword(void);
-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_obj, unsigned char digest[16]
- , int empty_buffer);
+extern int epilog(thread_t *, int, int, int);
+extern int timeout_epilog(thread_t *, char *, char *);
+extern url *fetch_next_url(http_get_checker *);
+extern int http_process_response(REQ *, int);
+extern int http_handle_response(thread_t *, unsigned char digest[16]
+ , int);
#endif
/* Prototypes */
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_obj, int new_req);
-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_obj);
+extern void clear_ssl(SSL_DATA *);
+extern int ssl_connect(thread_t *, int);
+extern int ssl_printerr(int);
+extern int ssl_send_request(SSL *, char *, int);
+extern int ssl_read_thread(thread_t *);
#endif
extern conf_data *data; /* Global configuration data */
/* Prototypes */
-extern void alloc_email(char *addr);
+extern void alloc_email(char *);
extern conf_data *alloc_global_data(void);
-extern void free_global_data(conf_data *global_data);
-extern void dump_global_data(conf_data *global_data);
+extern void free_global_data(conf_data *);
+extern void dump_global_data(conf_data *);
#endif
/* prototypes */
extern int ipvs_start(void);
extern void ipvs_stop(void);
-extern virtual_server_group *ipvs_get_group_by_name(char *gname, list l);
-extern int ipvs_group_remove_entry(virtual_server * vs,
- virtual_server_group_entry * vsge);
-extern int ipvs_cmd(int cmd, list vs_group, virtual_server * vserver,
- real_server * rserver);
-extern int ipvs_syncd_cmd(int cmd, char *ifname, int state, int syncid);
-extern void ipvs_syncd_master(char *ifname, int syncid);
-extern void ipvs_syncd_backup(char *ifname, int syncid);
+extern virtual_server_group *ipvs_get_group_by_name(char *, list);
+extern int ipvs_group_remove_entry(virtual_server *, virtual_server_group_entry *);
+extern int ipvs_cmd(int, list, virtual_server *, real_server *);
+extern int ipvs_syncd_cmd(int, char *, int, int);
+extern void ipvs_syncd_master(char *, int);
+extern void ipvs_syncd_backup(char *, int);
#endif
#define LVS_CMD_EDIT_DEST IP_VS_SO_SET_EDITDEST
/* prototypes */
-extern void perform_svr_state(int alive, virtual_server * vs, real_server * rs);
-extern void update_svr_wgt(int weight, virtual_server * vs, real_server * rs);
-extern int svr_checker_up(checker_id_t cid, real_server * rs);
-extern void update_svr_checker_state(int alive, checker_id_t cid,
- virtual_server * vs, real_server * rs);
+extern void perform_svr_state(int, virtual_server *, real_server *);
+extern void update_svr_wgt(int, virtual_server *, real_server *);
+extern int svr_checker_up(checker_id_t, real_server *);
+extern void update_svr_checker_state(int, checker_id_t, virtual_server *, real_server *);
extern int init_services(void);
extern int clear_services(void);
extern int clear_diff_services(void);
tcp_connect(int, struct sockaddr_storage *);
extern enum connect_result
- tcp_socket_state(int, thread *, int (*func) (struct _thread *));
+ tcp_socket_state(int, thread_t *, int (*func) (thread_t *));
extern void
tcp_connection_state(int, enum connect_result
- , thread *, int (*func) (struct _thread *)
+ , thread_t *, int (*func) (thread_t *)
, long);
#endif
#define CHECKERS_PID_FILE "/var/run/checkers.pid"
/* Prototypes */
-extern int pidfile_write(char *pid_file, int pid);
-extern void pidfile_rm(char *pid_file);
-extern int keepalived_running(int mode);
+extern int pidfile_write(char *, int);
+extern void pidfile_rm(char *);
+extern int keepalived_running(int);
#endif
extern char *vrrp_buffer;
/* prototypes */
-extern void alloc_saddress(vector strvec);
-extern void alloc_sroute(vector strvec);
-extern void alloc_vrrp_sync_group(char *gname);
-extern void alloc_vrrp(char *iname);
-extern void alloc_vrrp_track(vector strvec);
-extern void alloc_vrrp_script(char *sname);
-extern void alloc_vrrp_track_script(vector strvec);
-extern void alloc_vrrp_vip(vector strvec);
-extern void alloc_vrrp_evip(vector strvec);
-extern void alloc_vrrp_vroute(vector strvec);
+extern void alloc_saddress(vector);
+extern void alloc_sroute(vector);
+extern void alloc_vrrp_sync_group(char *);
+extern void alloc_vrrp(char *);
+extern void alloc_vrrp_track(vector);
+extern void alloc_vrrp_script(char *);
+extern void alloc_vrrp_track_script(vector);
+extern void alloc_vrrp_vip(vector);
+extern void alloc_vrrp_evip(vector);
+extern void alloc_vrrp_vroute(vector);
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 * vrrp_data_obj);
-extern void dump_vrrp_data(vrrp_conf_data * vrrp_data_obj);
-extern void free_vrrp_sockpool(vrrp_conf_data * vrrp_data_obj);
+extern void free_vrrp_data(vrrp_conf_data *);
+extern void dump_vrrp_data(vrrp_conf_data *);
+extern void free_vrrp_sockpool(vrrp_conf_data *);
#endif
extern int if_mii_probe(const char *);
extern int if_ethtool_probe(const char *);
extern void if_add_queue(interface *);
-extern int if_monitor_thread(thread *);
+extern int if_monitor_thread(thread_t *);
extern void init_interface_queue(void);
extern void init_interface_linkbeat(void);
extern void free_interface_queue(void);
/* Macro definition */
/* prototypes */
-extern void alloc_vrrp_bucket(vrrp_rt *vrrp);
-extern void alloc_vrrp_fd_bucket(vrrp_rt *vrrp);
-extern void remove_vrrp_fd_bucket(vrrp_rt *vrrp);
-extern void set_vrrp_fd_bucket(int old_fd, vrrp_rt *vrrp);
-extern vrrp_rt *vrrp_index_lookup(const int vrid, const int fd);
+extern void alloc_vrrp_bucket(vrrp_rt *);
+extern void alloc_vrrp_fd_bucket(vrrp_rt *);
+extern void remove_vrrp_fd_bucket(vrrp_rt *);
+extern void set_vrrp_fd_bucket(int, vrrp_rt *);
+extern vrrp_rt *vrrp_index_lookup(const int, const int);
#endif
/* prototypes */
-extern void netlink_iplist(list ip_list, int cmd);
-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 netlink_iplist(list, int);
+extern void free_ipaddress(void *);
+extern void dump_ipaddress(void *);
+extern void alloc_ipaddress(list, vector, interface *);
+extern void clear_diff_address(list, list);
extern void clear_diff_saddresses(void);
#endif
(X)->index == (Y)->index)
/* 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 *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 int netlink_route_ipv4(ip_route *, int);
+extern void netlink_rtlist_ipv4(list, int);
+extern void free_iproute(void *);
+extern void dump_iproute(void *);
+extern void alloc_route(list, vector);
+extern void clear_diff_routes(list, list);
extern void clear_diff_sroutes(void);
#endif
uint32_t seq_number;
} seq_counter;
-extern void hmac_md5(unsigned char *buffer, int buffer_len,
- unsigned char *key, int key_len, unsigned char *digest);
+extern void hmac_md5(unsigned char *, int, unsigned char *, int, unsigned char *);
#endif
extern struct nl_handle nl_cmd; /* Command channel */
/* prototypes */
-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 int rta_addattr_l(struct rtattr *rta, int maxlen, int type,
- const void *data, int alen);
-extern char *netlink_scope_n2a(int scope);
-extern int netlink_scope_a2n(char *scope);
-extern int netlink_socket(struct nl_handle *nl, unsigned long groups);
-extern int netlink_close(struct nl_handle *nl);
-extern int netlink_talk(struct nl_handle *nl, struct nlmsghdr *n);
+extern int addattr32(struct nlmsghdr *, int, int, uint32_t);
+extern int addattr_l(struct nlmsghdr *, int, int, void *, int);
+extern int rta_addattr_l(struct rtattr *, int, int, const void *, int);
+extern char *netlink_scope_n2a(int);
+extern int netlink_scope_a2n(char *);
+extern int netlink_socket(struct nl_handle *, unsigned long);
+extern int netlink_close(struct nl_handle *);
+extern int netlink_talk(struct nl_handle *, struct nlmsghdr *);
extern int netlink_interface_lookup(void);
extern int netlink_interface_refresh(void);
extern void kernel_netlink_init(void);
/* local include */
#include "vrrp.h"
-extern int notify_instance_exec(vrrp_rt * vrrp, int state);
-extern int notify_group_exec(vrrp_sgroup * vgroup, int state);
+extern int notify_instance_exec(vrrp_rt *, int);
+extern int notify_group_exec(vrrp_sgroup *, int);
#endif
} while (0)
/* extern prototypes */
-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);
+extern void vrrp_dispatcher_release(vrrp_conf_data *);
+extern int vrrp_dispatcher_init(thread_t *);
+extern int vrrp_read_dispatcher_thread(thread_t *);
#endif
} tracked_sc;
/* prototypes */
-extern void dump_track(void *track_data_obj);
-extern void alloc_track(list track_list, vector strvec);
-extern void dump_track_script(void *track_data_obj);
-extern void alloc_track_script(list track_list, vector strvec);
-extern int vrrp_tracked_up(list l);
-extern void vrrp_log_tracked_down(list l);
-extern int vrrp_tracked_weight(list l);
-extern int vrrp_script_up(list l);
-extern int vrrp_script_weight(list l);
-extern vrrp_script* find_script_by_name(char *name);
+extern void dump_track(void *);
+extern void alloc_track(list, vector);
+extern void dump_track_script(void *);
+extern void alloc_track_script(list, vector);
+extern int vrrp_tracked_up(list);
+extern void vrrp_log_tracked_down(list);
+extern int vrrp_tracked_weight(list);
+extern int vrrp_script_up(list);
+extern int vrrp_script_weight(list);
+extern vrrp_script* find_script_by_name(char *);
#endif
}
/* Reload handler */
-int reload_vrrp_thread(thread * thread_obj);
+int reload_vrrp_thread(thread_t * thread);
void
sighup_vrrp(void *v, int sig)
{
/* Reload thread */
int
-reload_vrrp_thread(thread * thread_obj)
+reload_vrrp_thread(thread_t * thread)
{
/* set the reloading flag */
SET_RELOAD;
/* VRRP Child respawning thread */
int
-vrrp_respawn_thread(thread * thread_obj)
+vrrp_respawn_thread(thread_t * thread)
{
pid_t pid;
/* Fetch thread args */
- pid = THREAD_CHILD_PID(thread_obj);
+ pid = THREAD_CHILD_PID(thread);
/* Restart respawning thread */
- if (thread_obj->type == THREAD_CHILD_TIMEOUT) {
+ if (thread->type == THREAD_CHILD_TIMEOUT) {
thread_add_child(master, vrrp_respawn_thread, NULL,
pid, RESPAWN_TIMER);
return 0;
}
static int
-if_linkbeat_refresh_thread(thread * thread_obj)
+if_linkbeat_refresh_thread(thread_t * thread)
{
- interface *ifp = THREAD_ARG(thread_obj);
+ interface *ifp = THREAD_ARG(thread);
if (IF_MII_SUPPORTED(ifp))
ifp->linkbeat = (if_mii_probe(ifp->ifname)) ? 1 : 0;
}
int
-kernel_netlink(thread * thread_obj)
+kernel_netlink(thread_t * thread)
{
int status = 0;
- if (thread_obj->type != THREAD_READ_TIMEOUT)
+ if (thread->type != THREAD_READ_TIMEOUT)
status = netlink_parse_info(netlink_broadcast_filter, &nl_kernel, NULL);
thread_add_read(master, kernel_netlink, NULL, nl_kernel.fd,
NETLINK_TIMER);
static void vrrp_master(vrrp_rt *);
static void vrrp_fault(vrrp_rt *);
-static int vrrp_update_priority(thread * thread_obj);
-static int vrrp_script_child_timeout_thread(thread * thread_obj);
-static int vrrp_script_child_thread(thread * thread_obj);
-static int vrrp_script_thread(thread * thread_obj);
+static int vrrp_update_priority(thread_t * thread);
+static int vrrp_script_child_timeout_thread(thread_t * thread);
+static int vrrp_script_child_thread(thread_t * thread);
+static int vrrp_script_thread(thread_t * thread);
struct {
void (*read) (vrrp_rt *, char *, int);
* multiplexing points.
*/
int
-vrrp_dispatcher_init(thread * thread_obj)
+vrrp_dispatcher_init(thread_t * thread)
{
/* create the VRRP socket pool list */
vrrp_create_sockpool(vrrp_data->vrrp_socket_pool);
/* Delayed gratuitous ARP thread */
int
-vrrp_gratuitous_arp_thread(thread * thread_obj)
+vrrp_gratuitous_arp_thread(thread_t * thread)
{
- vrrp_rt *vrrp = THREAD_ARG(thread_obj);
+ vrrp_rt *vrrp = THREAD_ARG(thread);
/* Simply broadcast the gratuitous ARP */
vrrp_send_link_update(vrrp);
* This is a thread which is executed every adver_int.
*/
static int
-vrrp_update_priority(thread * thread_obj)
+vrrp_update_priority(thread_t * thread)
{
- vrrp_rt *vrrp = THREAD_ARG(thread_obj);
+ vrrp_rt *vrrp = THREAD_ARG(thread);
int prio_offset, new_prio;
/* compute prio_offset right here */
/* Our read packet dispatcher */
int
-vrrp_read_dispatcher_thread(thread * thread_obj)
+vrrp_read_dispatcher_thread(thread_t * thread)
{
long vrrp_timer = 0;
sock *sock_obj;
int fd;
/* Fetch thread arg */
- sock_obj = THREAD_ARG(thread_obj);
+ sock_obj = THREAD_ARG(thread);
/* Dispatcher state handler */
- if (thread_obj->type == THREAD_READ_TIMEOUT || sock_obj->fd_in == -1)
+ if (thread->type == THREAD_READ_TIMEOUT || sock_obj->fd_in == -1)
fd = vrrp_dispatcher_read_to(sock_obj->fd_in);
else
fd = vrrp_dispatcher_read(sock_obj);
/* register next dispatcher thread */
vrrp_timer = vrrp_timer_fd(fd);
if (fd == -1)
- thread_add_timer(thread_obj->master, vrrp_read_dispatcher_thread,
+ thread_add_timer(thread->master, vrrp_read_dispatcher_thread,
sock_obj, vrrp_timer);
else
- thread_add_read(thread_obj->master, vrrp_read_dispatcher_thread,
+ thread_add_read(thread->master, vrrp_read_dispatcher_thread,
sock_obj, fd, vrrp_timer);
return 0;
/* Script tracking threads */
static int
-vrrp_script_thread(thread * thread_obj)
+vrrp_script_thread(thread_t * thread)
{
- vrrp_script *vscript = THREAD_ARG(thread_obj);
+ vrrp_script *vscript = THREAD_ARG(thread);
int status, ret;
pid_t pid;
/* Register next timer tracker */
- thread_add_timer(thread_obj->master, vrrp_script_thread, vscript,
+ thread_add_timer(thread->master, vrrp_script_thread, vscript,
vscript->interval);
/* Daemonization to not degrade our scheduling timer */
if (pid) {
long timeout;
timeout = vscript->interval;
- thread_add_child(thread_obj->master, vrrp_script_child_thread,
+ thread_add_child(thread->master, vrrp_script_child_thread,
vscript, pid, timeout);
return 0;
}
}
static int
-vrrp_script_child_thread(thread * thread_obj)
+vrrp_script_child_thread(thread_t * thread)
{
int wait_status;
- vrrp_script *vscript = THREAD_ARG(thread_obj);
+ vrrp_script *vscript = THREAD_ARG(thread);
- if (thread_obj->type == THREAD_CHILD_TIMEOUT) {
+ if (thread->type == THREAD_CHILD_TIMEOUT) {
pid_t pid;
- pid = THREAD_CHILD_PID(thread_obj);
+ pid = THREAD_CHILD_PID(thread);
/* The child hasn't responded. Kill it off. */
if (vscript->result > vscript->rise) {
vscript->result = 0;
}
kill(pid, SIGTERM);
- thread_add_child(thread_obj->master, vrrp_script_child_timeout_thread,
+ thread_add_child(thread->master, vrrp_script_child_timeout_thread,
vscript, pid, 2);
return 0;
}
- wait_status = THREAD_CHILD_STATUS(thread_obj);
+ wait_status = THREAD_CHILD_STATUS(thread);
if (WIFEXITED(wait_status)) {
int status;
}
static int
-vrrp_script_child_timeout_thread(thread * thread_obj)
+vrrp_script_child_timeout_thread(thread_t * thread)
{
pid_t pid;
- if (thread_obj->type != THREAD_CHILD_TIMEOUT)
+ if (thread->type != THREAD_CHILD_TIMEOUT)
return 0;
/* OK, it still hasn't exited. Now really kill it off. */
- pid = THREAD_CHILD_PID(thread_obj);
+ pid = THREAD_CHILD_PID(thread);
if (kill(pid, SIGKILL) < 0) {
/* Its possible it finished while we're handing this */
if (errno != ESRCH)
#include "logger.h"
/* global vars */
-thread_master *master = NULL;
+thread_master_t *master = NULL;
/* Make thread master. */
-thread_master *
+thread_master_t *
thread_make_master(void)
{
- thread_master *new;
+ thread_master_t *new;
- new = (thread_master *) MALLOC(sizeof (thread_master));
+ new = (thread_master_t *) MALLOC(sizeof (thread_master_t));
return new;
}
/* Add a new thread to the list. */
static void
-thread_list_add(thread_list * list, thread * thread_obj)
+thread_list_add(thread_list_t * list, thread_t * thread)
{
- thread_obj->next = NULL;
- thread_obj->prev = list->tail;
+ thread->next = NULL;
+ thread->prev = list->tail;
if (list->tail)
- list->tail->next = thread_obj;
+ list->tail->next = thread;
else
- list->head = thread_obj;
- list->tail = thread_obj;
+ list->head = thread;
+ list->tail = thread;
list->count++;
}
/* Add a new thread to the list. */
void
-thread_list_add_before(thread_list * list, thread * point, thread * thread_obj)
+thread_list_add_before(thread_list_t * list, thread_t * point, thread_t * thread)
{
- thread_obj->next = point;
- thread_obj->prev = point->prev;
+ thread->next = point;
+ thread->prev = point->prev;
if (point->prev)
- point->prev->next = thread_obj;
+ point->prev->next = thread;
else
- list->head = thread_obj;
- point->prev = thread_obj;
+ list->head = thread;
+ point->prev = thread;
list->count++;
}
/* Add a thread in the list sorted by timeval */
void
-thread_list_add_timeval(thread_list * list, thread * thread_obj)
+thread_list_add_timeval(thread_list_t * list, thread_t * thread)
{
- struct _thread *tt;
+ thread_t *tt;
for (tt = list->head; tt; tt = tt->next) {
- if (timer_cmp(thread_obj->sands, tt->sands) <= 0)
+ if (timer_cmp(thread->sands, tt->sands) <= 0)
break;
}
if (tt)
- thread_list_add_before(list, tt, thread_obj);
+ thread_list_add_before(list, tt, thread);
else
- thread_list_add(list, thread_obj);
+ thread_list_add(list, thread);
}
/* Delete a thread from the list. */
-thread *
-thread_list_delete(thread_list * list, thread * thread_obj)
+thread_t *
+thread_list_delete(thread_list_t * list, thread_t * thread)
{
- if (thread_obj->next)
- thread_obj->next->prev = thread_obj->prev;
+ if (thread->next)
+ thread->next->prev = thread->prev;
else
- list->tail = thread_obj->prev;
- if (thread_obj->prev)
- thread_obj->prev->next = thread_obj->next;
+ list->tail = thread->prev;
+ if (thread->prev)
+ thread->prev->next = thread->next;
else
- list->head = thread_obj->next;
- thread_obj->next = thread_obj->prev = NULL;
+ list->head = thread->next;
+ thread->next = thread->prev = NULL;
list->count--;
- return thread_obj;
+ return thread;
}
/* Free all unused thread. */
static void
-thread_clean_unuse(thread_master * m)
+thread_clean_unuse(thread_master_t * m)
{
- thread *thread_obj;
+ thread_t *thread;
- thread_obj = m->unuse.head;
- while (thread_obj) {
- struct _thread *t;
+ thread = m->unuse.head;
+ while (thread) {
+ thread_t *t;
- t = thread_obj;
- thread_obj = t->next;
+ t = thread;
+ thread = t->next;
thread_list_delete(&m->unuse, t);
/* Move thread to unuse list. */
static void
-thread_add_unuse(thread_master * m, thread * thread_obj)
+thread_add_unuse(thread_master_t * m, thread_t * thread)
{
assert(m != NULL);
- assert(thread_obj->next == NULL);
- assert(thread_obj->prev == NULL);
- assert(thread_obj->type == THREAD_UNUSED);
- thread_list_add(&m->unuse, thread_obj);
+ assert(thread->next == NULL);
+ assert(thread->prev == NULL);
+ assert(thread->type == THREAD_UNUSED);
+ thread_list_add(&m->unuse, thread);
}
/* Move list element to unuse queue */
static void
-thread_destroy_list(thread_master * m, thread_list thread_list_obj)
+thread_destroy_list(thread_master_t * m, thread_list_t thread_list)
{
- thread *thread_obj;
+ thread_t *thread;
- thread_obj = thread_list_obj.head;
+ thread = thread_list.head;
- while (thread_obj) {
- struct _thread *t;
+ while (thread) {
+ thread_t *t;
- t = thread_obj;
- thread_obj = t->next;
+ t = thread;
+ thread = t->next;
if (t->type == THREAD_READY_FD ||
t->type == THREAD_READ ||
t->type == THREAD_WRITE_TIMEOUT)
close (t->u.fd);
- thread_list_delete(&thread_list_obj, t);
+ thread_list_delete(&thread_list, t);
t->type = THREAD_UNUSED;
thread_add_unuse(m, t);
}
/* Cleanup master */
static void
-thread_cleanup_master(thread_master * m)
+thread_cleanup_master(thread_master_t * m)
{
/* Unuse current thread lists */
thread_destroy_list(m, m->read);
/* Stop thread scheduler. */
void
-thread_destroy_master(thread_master * m)
+thread_destroy_master(thread_master_t * m)
{
thread_cleanup_master(m);
FREE(m);
}
/* Delete top of the list and return it. */
-thread *
-thread_trim_head(thread_list * list)
+thread_t *
+thread_trim_head(thread_list_t * list)
{
if (list->head)
return thread_list_delete(list, list->head);
}
/* Make new thread. */
-thread *
-thread_new(thread_master * m)
+thread_t *
+thread_new(thread_master_t * m)
{
- thread *new;
+ thread_t *new;
/* If one thread is already allocated return it */
if (m->unuse.head) {
new = thread_trim_head(&m->unuse);
- memset(new, 0, sizeof (thread));
+ memset(new, 0, sizeof (thread_t));
return new;
}
- new = (thread *) MALLOC(sizeof (thread));
+ new = (thread_t *) MALLOC(sizeof (thread_t));
m->alloc++;
return new;
}
/* Add new read thread. */
-thread *
-thread_add_read(thread_master * m, int (*func) (thread *)
+thread_t *
+thread_add_read(thread_master_t * m, int (*func) (thread_t *)
, void *arg, int fd, long timer)
{
- thread *thread_obj;
+ thread_t *thread;
assert(m != NULL);
return NULL;
}
- 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;
+ thread = thread_new(m);
+ thread->type = THREAD_READ;
+ thread->id = 0;
+ thread->master = m;
+ thread->func = func;
+ thread->arg = arg;
FD_SET(fd, &m->readfd);
- thread_obj->u.fd = fd;
+ thread->u.fd = fd;
/* Compute read timeout value */
set_time_now();
- thread_obj->sands = timer_add_long(time_now, timer);
+ thread->sands = timer_add_long(time_now, timer);
/* Sort the thread. */
- thread_list_add_timeval(&m->read, thread_obj);
+ thread_list_add_timeval(&m->read, thread);
- return thread_obj;
+ return thread;
}
/* Add new write thread. */
-thread *
-thread_add_write(thread_master * m, int (*func) (thread *)
+thread_t *
+thread_add_write(thread_master_t * m, int (*func) (thread_t *)
, void *arg, int fd, long timer)
{
- thread *thread_obj;
+ thread_t *thread;
assert(m != NULL);
return NULL;
}
- 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;
+ thread = thread_new(m);
+ thread->type = THREAD_WRITE;
+ thread->id = 0;
+ thread->master = m;
+ thread->func = func;
+ thread->arg = arg;
FD_SET(fd, &m->writefd);
- thread_obj->u.fd = fd;
+ thread->u.fd = fd;
/* Compute write timeout value */
set_time_now();
- thread_obj->sands = timer_add_long(time_now, timer);
+ thread->sands = timer_add_long(time_now, timer);
/* Sort the thread. */
- thread_list_add_timeval(&m->write, thread_obj);
+ thread_list_add_timeval(&m->write, thread);
- return thread_obj;
+ return thread;
}
/* Add timer event thread. */
-thread *
-thread_add_timer(thread_master * m, int (*func) (thread *)
+thread_t *
+thread_add_timer(thread_master_t * m, int (*func) (thread_t *)
, void *arg, long timer)
{
- thread *thread_obj;
+ thread_t *thread;
assert(m != NULL);
- 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;
+ thread = thread_new(m);
+ thread->type = THREAD_TIMER;
+ thread->id = 0;
+ thread->master = m;
+ thread->func = func;
+ thread->arg = arg;
/* Do we need jitter here? */
set_time_now();
- thread_obj->sands = timer_add_long(time_now, timer);
+ thread->sands = timer_add_long(time_now, timer);
/* Sort by timeval. */
- thread_list_add_timeval(&m->timer, thread_obj);
+ thread_list_add_timeval(&m->timer, thread);
- return thread_obj;
+ return thread;
}
/* Add a child thread. */
-thread *
-thread_add_child(thread_master * m, int (*func) (thread *)
+thread_t *
+thread_add_child(thread_master_t * m, int (*func) (thread_t *)
, void * arg, pid_t pid, long timer)
{
- thread *thread_obj;
+ thread_t *thread;
assert(m != NULL);
- 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;
+ 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;
/* Compute write timeout value */
set_time_now();
- thread_obj->sands = timer_add_long(time_now, timer);
+ thread->sands = timer_add_long(time_now, timer);
/* Sort by timeval. */
- thread_list_add_timeval(&m->child, thread_obj);
+ thread_list_add_timeval(&m->child, thread);
- return thread_obj;
+ return thread;
}
/* Add simple event thread. */
-thread *
-thread_add_event(thread_master * m, int (*func) (thread *)
+thread_t *
+thread_add_event(thread_master_t * m, int (*func) (thread_t *)
, void *arg, int val)
{
- thread *thread_obj;
+ thread_t *thread;
assert(m != NULL);
- 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);
+ 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);
- return thread_obj;
+ return thread;
}
/* Add simple event thread. */
-thread *
-thread_add_terminate_event(thread_master * m)
+thread_t *
+thread_add_terminate_event(thread_master_t * m)
{
- thread *thread_obj;
+ thread_t *thread;
assert(m != NULL);
- 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);
+ 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);
- return thread_obj;
+ return thread;
}
/* Cancel thread from scheduler. */
void
-thread_cancel(thread * thread_obj)
+thread_cancel(thread_t * thread)
{
- switch (thread_obj->type) {
+ switch (thread->type) {
case THREAD_READ:
- 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);
+ assert(FD_ISSET(thread->u.fd, &thread->master->readfd));
+ FD_CLR(thread->u.fd, &thread->master->readfd);
+ thread_list_delete(&thread->master->read, thread);
break;
case THREAD_WRITE:
- 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);
+ assert(FD_ISSET(thread->u.fd, &thread->master->writefd));
+ FD_CLR(thread->u.fd, &thread->master->writefd);
+ thread_list_delete(&thread->master->write, thread);
break;
case THREAD_TIMER:
- thread_list_delete(&thread_obj->master->timer, thread_obj);
+ thread_list_delete(&thread->master->timer, thread);
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_obj->master->child, thread_obj);
+ thread_list_delete(&thread->master->child, thread);
break;
case THREAD_EVENT:
- thread_list_delete(&thread_obj->master->event, thread_obj);
+ thread_list_delete(&thread->master->event, thread);
break;
case THREAD_READY:
case THREAD_READY_FD:
- thread_list_delete(&thread_obj->master->ready, thread_obj);
+ thread_list_delete(&thread->master->ready, thread);
break;
default:
break;
}
- thread_obj->type = THREAD_UNUSED;
- thread_add_unuse(thread_obj->master, thread_obj);
+ thread->type = THREAD_UNUSED;
+ thread_add_unuse(thread->master, thread);
}
/* Delete all events which has argument value arg. */
void
-thread_cancel_event(thread_master * m, void *arg)
+thread_cancel_event(thread_master_t * m, void *arg)
{
- thread *thread_obj;
+ thread_t *thread;
- thread_obj = m->event.head;
- while (thread_obj) {
- struct _thread *t;
+ thread = m->event.head;
+ while (thread) {
+ thread_t *t;
- t = thread_obj;
- thread_obj = t->next;
+ t = thread;
+ thread = t->next;
if (t->arg == arg) {
thread_list_delete(&m->event, t);
/* Update timer value */
static void
-thread_update_timer(thread_list *list, TIMEVAL *timer_min)
+thread_update_timer(thread_list_t *list, TIMEVAL *timer_min)
{
if (list->head) {
if (!TIMER_ISNULL(*timer_min)) {
/* Compute the wait timer. Take care of timeouted fd */
static void
-thread_compute_timer(thread_master * m, TIMEVAL * timer_wait)
+thread_compute_timer(thread_master_t * m, TIMEVAL * timer_wait)
{
TIMEVAL timer_min;
}
/* Fetch next ready thread. */
-thread *
-thread_fetch(thread_master * m, thread * fetch)
+thread_t *
+thread_fetch(thread_master_t * m, thread_t * fetch)
{
int ret, old_errno;
- thread *thread_obj;
+ thread_t *thread;
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_obj = thread_trim_head(&m->event))) {
- *fetch = *thread_obj;
+ while ((thread = thread_trim_head(&m->event))) {
+ *fetch = *thread;
/* If daemon hanging event is received return NULL pointer */
- if (thread_obj->type == THREAD_TERMINATE) {
- thread_obj->type = THREAD_UNUSED;
- thread_add_unuse(m, thread_obj);
+ if (thread->type == THREAD_TERMINATE) {
+ thread->type = THREAD_UNUSED;
+ thread_add_unuse(m, thread);
return NULL;
}
- thread_obj->type = THREAD_UNUSED;
- thread_add_unuse(m, thread_obj);
+ thread->type = THREAD_UNUSED;
+ thread_add_unuse(m, thread);
return fetch;
}
/* If there is ready threads process them */
- while ((thread_obj = thread_trim_head(&m->ready))) {
- *fetch = *thread_obj;
- thread_obj->type = THREAD_UNUSED;
- thread_add_unuse(m, thread_obj);
+ while ((thread = thread_trim_head(&m->ready))) {
+ *fetch = *thread;
+ thread->type = THREAD_UNUSED;
+ thread_add_unuse(m, thread);
return fetch;
}
}
/* Timeout children */
- thread_obj = m->child.head;
- while (thread_obj) {
- struct _thread *t;
+ thread = m->child.head;
+ while (thread) {
+ thread_t *t;
- t = thread_obj;
- thread_obj = t->next;
+ t = thread;
+ thread = t->next;
if (timer_cmp(time_now, t->sands) >= 0) {
thread_list_delete(&m->child, t);
}
/* Read thead. */
- thread_obj = m->read.head;
- while (thread_obj) {
- struct _thread *t;
+ thread = m->read.head;
+ while (thread) {
+ thread_t *t;
- t = thread_obj;
- thread_obj = t->next;
+ t = thread;
+ thread = t->next;
if (FD_ISSET(t->u.fd, &readfd)) {
assert(FD_ISSET(t->u.fd, &m->readfd));
}
/* Write thead. */
- thread_obj = m->write.head;
- while (thread_obj) {
- struct _thread *t;
+ thread = m->write.head;
+ while (thread) {
+ thread_t *t;
- t = thread_obj;
- thread_obj = t->next;
+ t = thread;
+ thread = t->next;
if (FD_ISSET(t->u.fd, &writefd)) {
assert(FD_ISSET(t->u.fd, &writefd));
/*... */
/* Timer update. */
- thread_obj = m->timer.head;
- while (thread_obj) {
- struct _thread *t;
+ thread = m->timer.head;
+ while (thread) {
+ thread_t *t;
- t = thread_obj;
- thread_obj = t->next;
+ t = thread;
+ thread = t->next;
if (timer_cmp(time_now, t->sands) >= 0) {
thread_list_delete(&m->timer, t);
}
/* Return one event. */
- thread_obj = thread_trim_head(&m->ready);
+ thread = thread_trim_head(&m->ready);
/* There is no ready thread. */
- if (!thread_obj)
+ if (!thread)
goto retry;
- *fetch = *thread_obj;
- thread_obj->type = THREAD_UNUSED;
- thread_add_unuse(m, thread_obj);
+ *fetch = *thread;
+ thread->type = THREAD_UNUSED;
+ thread_add_unuse(m, thread);
return fetch;
}
/* Synchronous signal handler to reap child processes */
void
-thread_child_handler(void * v, int sig) {
- thread_master * m = v;
+thread_child_handler(void * v, int sig)
+{
+ thread_master_t * m = v;
+
/*
* This is O(n^2), but there will only be a few entries on
* this list.
*/
- thread *thread_obj;
+ thread_t *thread;
pid_t pid;
int status = 77;
while ((pid = waitpid(-1, &status, WNOHANG))) {
DBG("waitpid error: %s", strerror(errno));
assert(0);
} else {
- thread_obj = m->child.head;
- while (thread_obj) {
- struct _thread *t;
- t = thread_obj;
- thread_obj = t->next;
+ thread = m->child.head;
+ while (thread) {
+ thread_t *t;
+ t = thread;
+ thread = t->next;
if (pid == t->u.c.pid) {
thread_list_delete(&m->child, t);
thread_list_add(&m->ready, t);
/* Call thread ! */
void
-thread_call(thread * thread_obj)
+thread_call(thread_t * thread)
{
- thread_obj->id = thread_get_id();
- (*thread_obj->func) (thread_obj);
+ thread->id = thread_get_id();
+ (*thread->func) (thread);
}
/* Our infinite scheduling loop */
void
launch_scheduler(void)
{
- thread thread_obj;
+ thread_t thread;
signal_set(SIGCHLD, thread_child_handler, master);
* Processing the master thread queues,
* return and execute one ready thread.
*/
- while (thread_fetch(master, &thread_obj)) {
+ while (thread_fetch(master, &thread)) {
/* Run until error, used for debuging only */
#ifdef _DEBUG_
if ((debug & 520) == 520) {
thread_add_terminate_event(master);
}
#endif
- thread_call(&thread_obj);
+ thread_call(&thread);
}
}
int status; /* return status of the process */
} c;
} u;
-} thread;
+} thread_t;
/* Linked list of thread. */
typedef struct _thread_list {
- thread *head;
- thread *tail;
+ thread_t *head;
+ thread_t *tail;
int count;
-} thread_list;
+} thread_list_t;
/* Master of the theads. */
typedef struct _thread_master {
- thread_list read;
- thread_list write;
- thread_list timer;
- thread_list child;
- thread_list event;
- thread_list ready;
- thread_list unuse;
+ thread_list_t read;
+ thread_list_t write;
+ thread_list_t timer;
+ thread_list_t child;
+ thread_list_t event;
+ thread_list_t ready;
+ thread_list_t unuse;
fd_set readfd;
fd_set writefd;
fd_set exceptfd;
unsigned long alloc;
-} thread_master;
+} thread_master_t;
/* Thread types. */
#define THREAD_READ 0
#define THREAD_CHILD_STATUS(X) ((X)->u.c.status)
/* global vars exported */
-extern thread_master *master;
+extern thread_master_t *master;
/* Prototypes. */
-extern thread_master *thread_make_master(void);
-extern thread *thread_add_terminate_event(thread_master * m);
-extern void thread_destroy_master(thread_master * m);
-extern thread *thread_add_read(thread_master * m, int (*func) (thread *)
- , void *arg, int fd, long timeout);
-extern thread *thread_add_write(thread_master * m, int (*func) (thread *)
- , void *arg, int fd, long timeout);
-extern thread *thread_add_timer(thread_master * m, int (*func) (thread *)
- , void *arg, long timer);
-extern thread *thread_add_child(thread_master * m, int (*func) (thread *)
- , 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_obj);
-extern void thread_cancel_event(thread_master * m, void *arg);
-extern thread *thread_fetch(thread_master * m, thread * fetch);
-extern void thread_child_handler(void * v, int sig);
-extern void thread_call(thread * thread_obj);
+extern thread_master_t *thread_make_master(void);
+extern thread_t *thread_add_terminate_event(thread_master_t *);
+extern void thread_destroy_master(thread_master_t *);
+extern thread_t *thread_add_read(thread_master_t *, int (*func) (thread_t *), void *, int, long);
+extern thread_t *thread_add_write(thread_master_t *, int (*func) (thread_t *), void *, int, long);
+extern thread_t *thread_add_timer(thread_master_t *, int (*func) (thread_t *), void *, long);
+extern thread_t *thread_add_child(thread_master_t *, int (*func) (thread_t *), void *, pid_t, long);
+extern thread_t *thread_add_event(thread_master_t *, int (*func) (thread_t *), void *, int);
+extern void thread_cancel(thread_t *);
+extern void thread_cancel_event(thread_master_t *, void *);
+extern thread_t *thread_fetch(thread_master_t *, thread_t *);
+extern void thread_child_handler(void *, int);
+extern void thread_call(thread_t *);
extern void launch_scheduler(void);
#endif
projects / people / alex / keepalived.git / commitdiff