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; }