int process_wccp_router_id_component(int fd, struct wccp_service_group *this_wccp_service_group, struct wccp_router_id_info *wccp2_router_id_component){
struct wccp_server *this_wccp_server = NULL;
struct wccp_router_view_info *wccp2_router_view_component = NULL;
char message[LOGSZ] = {0};
logger2(LOGGING_DEBUG, DEBUG_WCCP,"[WCCP] Entering process_wccp_router_id_component().\n");
this_wccp_server = find_wccp_server(this_wccp_service_group, wccp2_router_id_component->router_ip);
if(this_wccp_server != NULL){
this_wccp_server->router_id = ntohl(wccp2_router_id_component->router_id);
//binary_dump("[WCCP] Router ID", wccp2_router_id_component, ntohs(wccp2_router_id_component->length) + 4);
//sprintf(message,"[WCCP] Component type: %u in process_wccp_router_id_component().\n", ntohs(wccp2_router_id_component->type));
//logger2(LOGGING_DEBUG, DEBUG_WCCP, message);
//sprintf(message,"[WCCP] Router IP %u in process_wccp_router_id_component().\n", ntohl(wccp2_router_id_component->router_ip));
//logger2(LOGGING_DEBUG, DEBUG_WCCP, message);
//sprintf(message,"[WCCP] Router ID %u in process_wccp_router_id_component().\n", ntohl(wccp2_router_id_component->router_id));
//logger2(LOGGING_DEBUG, DEBUG_WCCP, message);
wccp2_router_view_component = (char*)wccp2_router_id_component + ntohs(wccp2_router_id_component->length) + 4;
process_wccp_router_view_component(fd, this_wccp_service_group, wccp2_router_view_component);
}
logger2(LOGGING_DEBUG, DEBUG_WCCP,"[WCCP] Exiting process_wccp_router_id_component().\n");
return 0;
}
int process_wccp_security_component(int fd, struct wccp_security_info *wccp2_security_component){
struct wccp_service_info *wccp2_service_component;
char message[LOGSZ] = {0};
logger2(LOGGING_DEBUG, DEBUG_WCCP,"[WCCP] Entering process_wccp_security_component().\n");
wccp2_service_component = (char *)wccp2_security_component + ntohs(wccp2_security_component->length) + 4;
sprintf(message,"[WCCP] Security option %i in process_wccp_i_see_you().\n", ntohl(wccp2_security_component->security_option));
logger2(LOGGING_DEBUG, DEBUG_WCCP, message);
process_wccp_service_component(fd, wccp2_service_component);
logger2(LOGGING_DEBUG, DEBUG_WCCP,"[WCCP] Exiting process_wccp_security_component().\n");
return 0;
}
int wccp_add_webcache_view_component(struct wccp_service_group *this_wccp_service_group, struct wccp2_message_header *wccp2_msg_header){
struct wccp_webcache_view_info *wccp2_webcache_view_component;
struct wccp_server *this_wccp_server = NULL;
struct wccp_webcache *this_wccp_webcache = NULL;
struct wccp_router_id_element *router_id = NULL;
__u32 *num_routers = NULL;
__u32 *num_webcaches = NULL;
__u32 *webcacheip = NULL;
char message[LOGSZ] = {0};
wccp2_webcache_view_component = (char *)wccp2_msg_header + get_wccp_message_length(wccp2_msg_header);
wccp2_webcache_view_component->type = htons(WCCP2_WC_VIEW_INFO);
wccp2_webcache_view_component->length = htons(4);
wccp2_webcache_view_component->change_number = htonl(this_wccp_service_group->change_number);
num_routers = (char*)wccp2_webcache_view_component + 8;
sprintf(message,"[WCCP] Number of Routers: %u.\n", this_wccp_service_group->servers.count);
logger2(LOGGING_DEBUG, DEBUG_WCCP, message);
*num_routers = htonl(this_wccp_service_group->servers.count);
wccp2_webcache_view_component->length = htons(ntohs(wccp2_webcache_view_component->length) + 4);
this_wccp_server = this_wccp_service_group->servers.next;
router_id = (char*)num_routers + 4;
while(this_wccp_server != NULL){
router_id->router_id = this_wccp_server->ipaddress;
router_id->receive_id = htonl(this_wccp_server->router_id);
wccp2_webcache_view_component->length = htons(ntohs(wccp2_webcache_view_component->length) + sizeof(struct wccp_router_id_element));
router_id = router_id + 1;
this_wccp_server = this_wccp_server->servers.next;
}
if(this_wccp_service_group->servers.count > 0){
num_webcaches = (char*)num_routers + 4 + (this_wccp_service_group->servers.count * sizeof(struct wccp_router_id_element));
}else{
num_webcaches = (char*)num_routers + 4;
}
*num_webcaches = htonl(this_wccp_service_group->webcaches.count);
wccp2_webcache_view_component->length = htons(ntohs(wccp2_webcache_view_component->length) + 4);
this_wccp_webcache = this_wccp_service_group->webcaches.next;
webcacheip = (char*)num_webcaches + 4;
while(this_wccp_webcache != NULL){
*webcacheip = this_wccp_webcache->ipaddress;
wccp2_webcache_view_component->length = htons(ntohs(wccp2_webcache_view_component->length) + 4);
webcacheip = webcacheip + 1;
this_wccp_webcache = this_wccp_webcache->webcaches.next;
}
update_wccp_message_length(wccp2_msg_header, wccp2_webcache_view_component->length);
return 0;
}
int process_wccp_service_component(int fd, struct wccp_service_info *wccp2_service_component){
struct wccp_router_id_info *wccp2_router_id_component;
struct wccp_service_group *this_wccp_service_group = NULL;
char message[LOGSZ] = {0};
logger2(LOGGING_DEBUG, DEBUG_WCCP,"[WCCP] Entering process_wccp_service_component().\n");
this_wccp_service_group = find_wccp_service_group(ntohs(wccp2_service_component->service_id));
if(this_wccp_service_group != NULL){
wccp2_router_id_component = (char *)wccp2_service_component + ntohs(wccp2_service_component->length) + 4;
process_wccp_router_id_component(fd, this_wccp_service_group, wccp2_router_id_component);
}
logger2(LOGGING_DEBUG, DEBUG_WCCP,"[WCCP] Exiting process_wccp_service_component().\n");
return 0;
}
void *wccp_thread(void *dummyPtr) {
int error = 0;
struct epoller wccp_epoller = { 0 };
char message[LOGSZ];
logger2(LOGGING_DEBUG, DEBUG_WCCP, "Starting WCCP Thread.\n");
error = new_ip_epoll_server(&wccp_epoller, NULL, wccp_handler, 0, wccp_epoller_timeout, (HERE_I_AM_T - 1000));
epoll_handler(&wccp_epoller);
logger2(LOGGING_DEBUG, DEBUG_WCCP, "Exiting WCCP Thread.\n");
shutdown_epoll_server(&wccp_epoller);
return EXIT_SUCCESS;
}
/** @brief Processes a WCCP server of a group.
*
* Check connection to server. Open a new one or close if dead.
* Send WCCP hello messages and login to WCCP group.
*
* @param this_epoller [in] wccp server being processed.
*/
int wccp_process_server(struct epoller *wccp_epoller, struct wccp_service_group *this_wccp_service_group, struct wccp_server *this_wccp_server){
char message[LOGSZ] = {0};
int client = -1;
if(this_wccp_server->sock == 0){ //Need to open a socket to this server.
client = new_udp_client(this_wccp_server->ipaddress, WCCP_PORT);
if(client >= 0){
this_wccp_server->sock = client;
register_socket(client, wccp_epoller->epoll_fd, &wccp_epoller->event);
logger2(LOGGING_DEBUG, DEBUG_WCCP,"[WCCP] Connected to server.\n");
}
}else{
logger2(LOGGING_DEBUG, DEBUG_WCCP,"[WCCP] Sending WCCP Hello to server.\n");
wccp_send_message(this_wccp_service_group, this_wccp_server, WCCP2_HERE_I_AM);
wccp_send_message(this_wccp_service_group, this_wccp_server, WCCP2_REDIRECT_ASSIGN);
}
return 0;
}
/** @brief Processes WCCP messages sent by WCCP servers.
*
* Processes WCCP messages sent by WCCP servers to this client.
*
* @param this_epoller [in] poller structure receiving the messages.
* @param fd [in] socket that the message was received on.
* @param buf [in] the message.
* @return int 0 = sucessful 1 = failed
*/
int wccp_handler(struct epoller *this_epoller, int fd, void *buf) {
struct wccp2_message_header *wccp2_msg_header;
char message[LOGSZ] = {0};
wccp2_msg_header = (struct wccp2_message_header *)buf;
struct wccp_security_info *wccp2_security_component;
logger2(LOGGING_DEBUG, DEBUG_WCCP,"[WCCP] Entering wccp_handler().\n");
wccp2_security_component = (char *)wccp2_msg_header + sizeof(struct wccp2_message_header);
//binary_dump("[WCCP]", buf, 4);
switch(ntohl(wccp2_msg_header->type)){
case WCCP2_HERE_I_AM:
break;
case WCCP2_I_SEE_YOU:
logger2(LOGGING_DEBUG, DEBUG_WCCP, "[WCCP] WCCP2_I_SEE_YOU Received.");
process_wccp_security_component(fd, wccp2_security_component);
break;
case WCCP2_REDIRECT_ASSIGN:
logger2(LOGGING_DEBUG, DEBUG_WCCP, "[WCCP] WCCP2_REDIRECT_ASSIGN Received.");
break;
case WCCP2_REMOVAL_QUERY:
logger2(LOGGING_DEBUG, DEBUG_WCCP, "[WCCP] WCCP2_REMOVAL_QUERY Received.");
break;
default:
sprintf(message,"[WCCP] Unknown message type %i in wccp_handler().\n", ntohl(wccp2_msg_header->type));
logger2(LOGGING_DEBUG, DEBUG_WCCP, message);
break;
}
logger2(LOGGING_DEBUG, DEBUG_WCCP,"[WCCP] Exiting wccp_handler().\n");
return 0;
}
int wccp_epoller_timeout(struct epoller *wccp_epoller){
time_t currenttime;
char message[LOGSZ] = {0};
struct wccp_service_group *current_wccp_service_group = (struct wccp_service_group *)wccp_service_groups.next;
struct wccp_server *current_wccp_server = NULL;
logger2(LOGGING_DEBUG, DEBUG_WCCP,"[WCCP] Entering wccp_epoller_timeout().\n");
time(¤ttime);
/*
* Send a WCCP_HELLO message to each server of each service group.
*/
// Loop through each service group.
while(current_wccp_service_group != NULL){
current_wccp_server = current_wccp_service_group->servers.next;
// Send WCCP_HELLO to each server in the group.
while(current_wccp_server != NULL){
if((difftime(currenttime, current_wccp_server->hellotimer) >= 9)){
logger2(LOGGING_DEBUG, DEBUG_WCCP,"[WCCP] Processing a server.\n");
time(¤t_wccp_server->hellotimer);
wccp_process_server(wccp_epoller, current_wccp_service_group, current_wccp_server);
}
current_wccp_server = current_wccp_server->servers.next;
}
current_wccp_service_group = current_wccp_service_group->groups.next;
}
logger2(LOGGING_DEBUG, DEBUG_WCCP,"[WCCP] Exiting wccp_epoller_timeout().\n");
return 0;
}
void tst_QMailLog::test_loggers()
{
FileLogger<LvlTimeLogPrefix> logger1(stdout);
QVERIFY(logger1.isReady());
QCOMPARE(logger1.getMinLogLvl(), LlInfo);
logger1.setMinLogLvl(LlDbg);
QCOMPARE(logger1.getMinLogLvl(), LlDbg);
// give invalid filename - so logger will not be ready
FileLogger<LvlTimeLogPrefix> logger2("/");
QVERIFY(!logger2.isReady());
TestBaseLoggerFoundation logger3;
QCOMPARE(logger3.getMinLogLvl(), LlInfo);
logger3.set_ready(true);
QVERIFY(logger3.isReady());
logger3.set_ready(false);
QVERIFY(!logger3.isReady());
}
/**
* @brief Simple example program
*/
int main ()
{
// Configure the default severity Level of new Channel objects
#ifndef NDEBUG
Log::Manager::setDefaultLevel(Log::Log::eDebug);
#else
Log::Manager::setDefaultLevel(Log::Log::eNotice);
#endif
// Configure the Output objects
Log::Config::Vector configList;
Log::Config::addOutput(configList, "OutputConsole");
Log::Config::addOutput(configList, "OutputFile");
Log::Config::setOption(configList, "filename", "log.txt");
Log::Config::setOption(configList, "filename_old", "log.old.txt");
Log::Config::setOption(configList, "max_startup_size", "0");
Log::Config::setOption(configList, "max_size", "10000");
#ifdef WIN32
Log::Config::addOutput(configList, "OutputDebug");
#endif
// Create a Logger object, using a "Main.Example" Channel
Log::Logger logger("Main.Example");
logger.warning() << "NO logs before configure()";
try
{
// Configure the Log Manager (create the Output objects)
Log::Manager::configure(configList);
}
catch (std::exception& e)
{
std::cerr << e.what();
}
// Test outputs of various kind of variables, and some common stream manipulations.
std::string str("string");
unsigned int ui = 123;
double dbl = -0.023f;
logger.debug() << "Variables ; '" << str << "', '" << ui << "', '" << dbl << "'";
logger.debug() << "Hexa = " << std::hex << 0x75af0 << " test";
logger.debug() << "Deci = " << std::right << std::setfill('0') << std::setw(8) << 76035 << " test";
logger.debug() << "sizeof(logger)=" << sizeof(logger);
// Test outputs of various severity Level
logger.debug() << "Debug.";
logger.info() << "Info.";
logger.notice() << "Notice.";
logger.warning()<< "Warning.";
logger.error() << "Error.";
logger.critic() << "Critic.";
// Modify the output Level of the underlying Channel, and test various severity Level again
logger.setLevel(Log::Log::eWarning);
logger.debug() << "NO Debug."; // NO more debug logs
logger.info() << "NO Info."; // NO more info logs
logger.notice() << "NO Notice."; // NO more notice logs
logger.warning()<< "Warning.";
logger.error() << "Error.";
logger.critic() << "Critic.";
// Reset Level of the "Main.example" channel by its name
Log::Manager::get("Main.Example")->setLevel(Log::Log::eDebug);
// Create other loggers, sharing the "Main.Example" Channel, and creating a new one
Log::Logger logger2("Main.Example");
Log::Logger logger3("Main.Other");
logger.debug() << "First logger to the Channel";
logger2.debug() << "Second logger to the Channel";
logger3.debug() << "Third logger, other Channel";
// Modify the Level of the "Main.example" channel by its name
Log::Manager::get("Main.Example")->setLevel(Log::Log::eInfo);
logger.debug() << "first logger inhibited"; // NO more debug logs for this logger
logger2.debug() << "second logger also disabled"; // NO more debug logs (sharing the same underlying channel)
logger3.debug() << "third logger still active";
// Reset the Level of the "Main.example" channel by its name
Log::Manager::get("Main.Example")->setLevel(Log::Log::eDebug);
logger.debug() << "first logger re-activated";
logger2.debug() << "second logger also re-activated";
logger3.debug() << "third logger always active";
// Create an object using a Logger as member variable
Tester tester;
tester.constTest();
// Show how to get the current Channel configuration (to save it to a file, for instance)
Log::Manager::get("Main.OtherChannel")->setLevel(Log::Log::eNotice);
Log::Config::Ptr ChannelConfigPtr = Log::Manager::getChannelConfig();
// Show how to set the current Channel configuration (restored from a file, for instance)
Log::Manager::setChannelConfig(ChannelConfigPtr);
// Terminate the Log Manager (destroy the Output objects)
Log::Manager::terminate();
logger.warning() << "NO more logs after terminate()";
return 0;
}
int process_wccp_router_view_component(int fd, struct wccp_service_group *this_wccp_service_group, struct wccp_router_view_info *wccp2_router_view_component){
char message[LOGSZ] = {0};
__u32 *num_routers = NULL;
__u32 *num_webcaches = NULL;
struct wccp_webcache_id_element *webcache = NULL;
struct wccp_webcache *this_wccp_webcache = NULL;
int i = 0;
int webcachefound = 0;
logger2(LOGGING_DEBUG, DEBUG_WCCP,"[WCCP] Entering process_wccp_router_view_component().\n");
if(ntohl(wccp2_router_view_component->change_number) != this_wccp_service_group->change_number){
this_wccp_service_group->change_number = ntohl(wccp2_router_view_component->change_number);
logger2(LOGGING_DEBUG, DEBUG_WCCP,"[WCCP] Change number updated.\n");
num_routers = (char *)wccp2_router_view_component + sizeof(struct wccp_router_view_info);
/**
* @todo:
* After a change should wait 1.5 HERE_I_AM_T before generating the message.
* Move this to timer based on main epoll loop.
* For now lets just send an assignment for each change.
*/
sprintf(message,"[WCCP] There are %u routers.\n", ntohl(*num_routers));
logger2(LOGGING_DEBUG, DEBUG_WCCP, message);
num_webcaches = (__u32 *)num_routers + ntohl(*num_routers) + 1;
sprintf(message,"[WCCP] There are %u web-caches.\n", ntohl(*num_webcaches));
logger2(LOGGING_DEBUG, DEBUG_WCCP, message);
/*
* First we make sure each web-cache in this message exists in the service view.
*/
if(ntohl(*num_webcaches) > 0){
webcache = (char *)num_webcaches + 4;
for(i=0;i<ntohl(*num_webcaches);i++){
if(find_wccp_webcache(this_wccp_service_group, webcache->cache_ip) == NULL){
logger2(LOGGING_DEBUG, DEBUG_WCCP,"[WCCP] No web-cache found!\n");
this_wccp_webcache = allocate_wccp_webcache(webcache->cache_ip);
insert_list_item(&this_wccp_service_group->webcaches, this_wccp_webcache);
}
}
webcache+=1;
}
/**
* @todo:
* Next we need to remove any web-cache this is not in this view.
* or at least mark them as missing?
* Buckets should only be assigned to web-caches that are visible to all routers.
* Not sure how to handle this right now.
*/
this_wccp_webcache = this_wccp_service_group->webcaches.next;
if(ntohl(*num_webcaches) > 0){
webcache = (char *)num_webcaches + 4;
while(this_wccp_webcache != NULL){
webcachefound = 0;
for(i=0;i<ntohl(*num_webcaches);i++){
if(webcache[i].cache_ip == this_wccp_webcache->ipaddress){
/*
* If we find the web-cache lets set a flag as true so it wont get removed.
*/
webcachefound = 1;
logger2(LOGGING_DEBUG, DEBUG_WCCP,"[WCCP] Web-cache was in list.\n");
}
}
/**
* @todo
* If its not found we need to remove it from the webcaches list and free the memory.
*/
if(webcachefound == 0){
logger2(LOGGING_DEBUG, DEBUG_WCCP,"[WCCP] Web-cache was not in list.\n");
}
this_wccp_webcache = this_wccp_webcache->webcaches.next;
}
}
}
//sprintf(message,"[WCCP] Change number: %u in process_wccp_router_view_component().\n", ntohl(wccp2_router_view_component->change_number));
//logger2(LOGGING_DEBUG, DEBUG_WCCP, message);
logger2(LOGGING_DEBUG, DEBUG_WCCP,"[WCCP] Exiting process_wccp_router_view_component().\n");
return 0;
}
int wccp_send_message(struct wccp_service_group *this_wccp_service_group, struct wccp_server *this_wccp_server, WCCP2_MSG_TYPE messagetype){
char buf[1024] = {0};
struct wccp2_message_header *wccp2_msg_header;
wccp2_msg_header = (struct wccp2_message_header *)&buf;
switch(messagetype) {
case WCCP2_HERE_I_AM:
/*
* 5.1 'Here I Am' Message
* +--------------------------------------+
* | WCCP Message Header |
* +--------------------------------------+
* | Security Info Component |
* +--------------------------------------+
* | Service Info Component |
* +--------------------------------------+
* | Web-Cache Identity Info Component |
* +--------------------------------------+
* | Web-Cache View Info Component |
* +--------------------------------------+
*/
wccp_add_here_i_am_header(wccp2_msg_header);
wccp_add_security_component(wccp2_msg_header);
wccp_add_service_component(this_wccp_service_group, wccp2_msg_header);
wccp_add_webcache_id_component(wccp2_msg_header);
wccp_add_webcache_view_component(this_wccp_service_group, wccp2_msg_header);
wccp_add_capability_info(wccp2_msg_header);
send(this_wccp_server->sock, wccp2_msg_header, ntohs(wccp2_msg_header->length) + 8, MSG_NOSIGNAL);
break;
case WCCP2_REDIRECT_ASSIGN:
/*
* 5.3 'Redirect Assign' Message
* +--------------------------------------+
* | WCCP Message Header |
* +--------------------------------------+
* | Security Info Component |
* +--------------------------------------+
* | Service Info Component |
* +--------------------------------------+
* | Assignment Info Component |
* | OR |
* | Alternate Assignment Component |
* +--------------------------------------+
*/
wccp_add_redirect_assign_header(wccp2_msg_header);
wccp_add_security_component(wccp2_msg_header);
wccp_add_service_component(this_wccp_service_group, wccp2_msg_header);
wccp_add_assignment_info_component(this_wccp_service_group, wccp2_msg_header);
send(this_wccp_server->sock, wccp2_msg_header, ntohs(wccp2_msg_header->length) + 8, MSG_NOSIGNAL);
break;
default:
logger2(LOGGING_DEBUG,DEBUG_WCCP,"[WCCP] Cannot send unknown type!\n");
}
return 0;
}
