// Read in the stats from one directory and add to the counters.
void
stats_read(const char *sfile, struct counters *counters)
{
char *data = read_text_file(sfile, 1024);
if (data) {
parse_stats(counters, data);
}
free(data);
}
/* Read in the stats from one directory and add to the counters. */
void
stats_read(const char *sfile, struct counters *counters)
{
char *data = read_text_file(sfile);
if (data) {
parse_stats(counters, data);
} else {
stats_default(counters);
}
free(data);
}
/* read in the stats from one dir and add to the counters */
static void stats_read_fd(int fd, unsigned counters[STATS_END])
{
char buf[1024];
int len;
len = read(fd, buf, sizeof(buf)-1);
if (len <= 0) {
stats_default(counters);
return;
}
buf[len] = 0;
parse_stats(counters, buf);
}
int wowhead_t::parse_gem( item_t& item,
const std::string& gem_id,
bool ptr,
cache::behavior_t caching )
{
if ( gem_id.empty() || gem_id == "0" )
return GEM_NONE;
xml_node_t* node = download_id( item.sim, gem_id, caching, ptr );
if ( ! node )
{
if ( caching != cache::ONLY )
item.sim -> errorf( "Player %s unable to download gem id %s from wowhead\n", item.player -> name(), gem_id.c_str() );
return GEM_NONE;
}
int gem_type = GEM_NONE;
std::string color_str;
if ( xml_t::get_value( color_str, node, "subclass/cdata" ) )
{
std::string::size_type pos = color_str.find( ' ' );
if ( pos != std::string::npos ) color_str.erase( pos );
armory_t::format( color_str );
gem_type = util_t::parse_gem_type( color_str );
if ( gem_type == GEM_META )
{
std::string name_str;
if ( xml_t::get_value( name_str, node, "name/cdata" ) )
{
std::string::size_type pos = name_str.find( " Diamond" );
if ( pos != std::string::npos ) name_str.erase( pos );
armory_t::format( name_str );
item.armory_gems_str += "_";
item.armory_gems_str += name_str;
}
}
else
{
std::string stats_str;
if ( xml_t::get_value( stats_str, node, "jsonEquip/cdata" ) )
{
parse_stats( item.armory_gems_str, stats_str );
}
}
}
return gem_type;
}
CharEntry LoginParser::parse_charentry(InPacket& recv)
{
int32_t cid = recv.read_int();
StatsEntry stats = parse_stats(recv);
LookEntry look = parse_look(recv);
recv.read_bool(); // 'rankinfo' bool
if (recv.read_bool())
{
int32_t currank = recv.read_int();
int32_t rankmv = recv.read_int();
int32_t curjobrank = recv.read_int();
int32_t jobrankmv = recv.read_int();
int8_t rankmc = (rankmv > 0) ? '+' : (rankmv < 0) ? '-' : '=';
int8_t jobrankmc = (jobrankmv > 0) ? '+' : (jobrankmv < 0) ? '-' : '=';
stats.rank = std::make_pair(currank, rankmc);
stats.jobrank = std::make_pair(curjobrank, jobrankmc);
}
return{ stats, look, cid };
}
int main(int argc, char *argv[])
{
int ch = 0;
struct timeval tv_last, tv;
unsigned i;
atexit(cleanup);
setup_connections(argc, argv);
init_ncurses(global.num_clamd, default_colors);
memset(&tv_last, 0, sizeof(tv_last));
do {
if (toupper(ch) == 'H') {
ch = show_help();
}
switch(ch) {
case KEY_RESIZE:
resize();
endwin();
refresh();
init_windows(global.num_clamd);
break;
case 'R':
case 'r':
for (i=0;i<global.num_clamd;i++)
global.all_stats[i].biggest_queue = 1;
biggest_mem = 0;
break;
case KEY_UP:
if (global.num_clamd > 1) {
if (detail_selected == -1)
detail_selected = global.num_clamd-1;
else
--detail_selected;
}
break;
case KEY_DOWN:
if (global.num_clamd > 1) {
if (detail_selected == -1)
detail_selected = 0;
else {
if((unsigned)++detail_selected >= global.num_clamd)
detail_selected = -1;
}
}
break;
}
gettimeofday(&tv, NULL);
header();
if(tv.tv_sec - tv_last.tv_sec >= MIN_INTERVAL) {
free_global_stats();
for(i=0;i<global.num_clamd;i++) {
unsigned biggest_q;
struct stats *stats = &global.all_stats[i];
if (global.conn[i].sd != -1)
send_string(&global.conn[i], "nSTATS\n");
biggest_q = stats->biggest_queue;
memset(stats, 0, sizeof(*stats));
stats->biggest_queue = biggest_q;
parse_stats(&global.conn[i], stats, i);
}
if (global.tasks)
qsort(global.tasks, global.n, sizeof(*global.tasks), tasks_compare);
tv_last = tv;
}
/* always show, so that screen resizes take effect instantly*/
output_all();
for(i=0;i<global.num_clamd;i++) {
if (global.conn[i].sd == -1)
reconnect(&global.conn[i]);
}
} while(toupper(ch = getch()) != 'Q');
free_global_stats();
normal_exit = 1;
return 0;
}
/* Parse an incoming message. Note that the protocol might have sent this
* directly over the network (ie. TIPC) or might have wrapped it around (ie.
* TCP). Here we only deal with the clean, stripped, non protocol-specific
* message. */
int parse_message(struct req_info *req,
const unsigned char *buf, size_t len)
{
uint32_t hdr, ver, id;
uint16_t cmd, flags;
const unsigned char *payload;
size_t psize;
/* The header is:
* 4 bytes Version + ID
* 2 bytes Command
* 2 bytes Flags
* Variable Payload
*/
hdr = * ((uint32_t *) buf);
hdr = htonl(hdr);
/* FIXME: little endian-only */
ver = (hdr & 0xF0000000) >> 28;
id = hdr & 0x0FFFFFFF;
req->id = id;
cmd = ntohs(* ((uint16_t *) buf + 2));
flags = ntohs(* ((uint16_t *) buf + 3));
if (ver != PROTO_VER) {
stats.net_version_mismatch++;
req->reply_err(req, ERR_VER);
return 0;
}
/* We define payload as the stuff after buf. But be careful because
* there might be none (if len == 1). Doing the pointer arithmetic
* isn't problematic, but accessing the payload should be done only if
* we know we have enough data. */
payload = buf + 8;
psize = len - 8;
/* Store the id encoded in network byte order, so that we don't have
* to calculate it at send time. */
req->id = htonl(id);
req->cmd = cmd;
req->flags = flags;
req->payload = payload;
req->psize = psize;
if (cmd == REQ_GET) {
parse_get(req);
} else if (cmd == REQ_SET) {
parse_set(req);
} else if (cmd == REQ_DEL) {
parse_del(req);
} else if (cmd == REQ_CAS) {
parse_cas(req);
} else if (cmd == REQ_INCR) {
parse_incr(req);
} else if (cmd == REQ_FIRSTKEY) {
parse_firstkey(req);
} else if (cmd == REQ_NEXTKEY) {
parse_nextkey(req);
} else if (cmd == REQ_STATS) {
parse_stats(req);
} else {
stats.net_unk_req++;
req->reply_err(req, ERR_UNKREQ);
}
return 1;
}
char *
netstatus_sysdeps_read_iface_statistics (const char *iface,
gulong *in_packets,
gulong *out_packets,
gulong *in_bytes,
gulong *out_bytes)
{
GError *error;
char *command_line;
char **argv;
char *error_message = NULL;
int pipe_out;
g_return_val_if_fail (iface != NULL, NULL);
g_return_val_if_fail (in_packets != NULL, NULL);
g_return_val_if_fail (out_packets != NULL, NULL);
g_return_val_if_fail (in_bytes != NULL, NULL);
g_return_val_if_fail (out_bytes != NULL, NULL);
*in_packets = -1;
*out_packets = -1;
*in_bytes = -1;
*out_bytes = -1;
error = NULL;
command_line = g_strdup_printf ("/usr/bin/netstat -n -I %s -b -f inet", iface);
if (!g_shell_parse_argv (command_line, NULL, &argv, &error))
{
error_message = g_strdup_printf (_("Could not parse command line '%s': %s"),
command_line,
error->message);
g_error_free (error);
g_free (command_line);
return error_message;
}
g_free (command_line);
error = NULL;
if (g_spawn_async_with_pipes (NULL,
argv,
NULL,
0,
NULL,
NULL,
NULL,
NULL,
&pipe_out,
NULL,
&error))
{
GIOChannel *channel;
char *buf;
int prx_idx, ptx_idx;
int brx_idx, btx_idx;
channel = g_io_channel_unix_new (pipe_out);
g_io_channel_read_line (channel, &buf, NULL, NULL, NULL);
parse_header (buf, &prx_idx, &ptx_idx, &brx_idx, &btx_idx);
g_free (buf);
if (prx_idx == -1 || ptx_idx == -1 ||
brx_idx == -1 || btx_idx == -1)
{
error_message = g_strdup (_("Could not parse 'netstat' output. Unknown format"));
goto error_shutdown;
}
g_io_channel_read_line (channel, &buf, NULL, NULL, NULL);
if (!parse_stats (buf,
prx_idx, ptx_idx, in_packets, out_packets,
brx_idx, btx_idx, in_bytes, out_bytes))
{
error_message = g_strdup_printf (_("Could not parse interface statistics from '%s'. "
"prx_idx = %d; ptx_idx = %d; brx_idx = %d; btx_idx = %d;"),
buf, prx_idx, ptx_idx, brx_idx, btx_idx);
}
else if (*in_packets == -1 || *out_packets == -1 || *in_bytes == -1 || *out_bytes == -1)
{
error_message = g_strdup_printf ("Could not obtain information on interface '%s' from netstat",
iface);
}
g_free (buf);
error_shutdown:
g_io_channel_unref (channel);
close (pipe_out);
}
else
{
error_message = g_strdup_printf ("Error running /usr/bin/netstat for '%s': %s",
iface, error->message);
g_error_free (error);
}
g_strfreev (argv);
return error_message;
}
char *
netstatus_sysdeps_read_iface_statistics (const char *iface,
gulong *in_packets,
gulong *out_packets,
gulong *in_bytes,
gulong *out_bytes)
{
FILE *fh;
char buf [512];
int prx_idx, ptx_idx;
int brx_idx, btx_idx;
char *error_message = NULL;
g_return_val_if_fail (iface != NULL, NULL);
g_return_val_if_fail (in_packets != NULL, NULL);
g_return_val_if_fail (out_packets != NULL, NULL);
g_return_val_if_fail (in_bytes != NULL, NULL);
g_return_val_if_fail (out_bytes != NULL, NULL);
*in_packets = -1;
*out_packets = -1;
*in_bytes = -1;
*out_bytes = -1;
fh = get_proc_net_dev_fh ();
if (!fh)
return g_strdup_printf (_("Cannot open /proc/net/dev: %s"),
g_strerror (errno));
if (fgets (buf, sizeof (buf), fh) == NULL ||
fgets (buf, sizeof (buf), fh) == NULL)
return g_strdup (_("Could not parse /proc/net/dev. No data."));
parse_stats_header (buf, &prx_idx, &ptx_idx, &brx_idx, &btx_idx);
if (prx_idx == -1 || ptx_idx == -1 ||
brx_idx == -1 || btx_idx == -1)
return g_strdup (_("Could not parse /proc/net/dev. Unknown format."));
while (fgets (buf, sizeof (buf), fh))
{
char *stats;
char *name;
name = buf;
while (g_ascii_isspace (name [0]))
name++;
stats = parse_iface_name (name);
if (!stats)
{
if (!error_message)
error_message = g_strdup_printf (_("Could not parse interface name from '%s'"), buf);
continue;
}
if (strcmp (name, iface) != 0)
continue;
if (!parse_stats (stats,
prx_idx, ptx_idx, in_packets, out_packets,
brx_idx, btx_idx, in_bytes, out_bytes))
{
if (error_message)
g_free (error_message);
error_message = g_strdup_printf (_("Could not parse interface statistics from '%s'. "
"prx_idx = %d; ptx_idx = %d; brx_idx = %d; btx_idx = %d;"),
buf, prx_idx, ptx_idx, brx_idx, btx_idx);
continue;
}
break;
}
if ((*in_packets == (gulong) -1 || *out_packets == (gulong) -1 || *in_bytes == (gulong) -1 || *out_bytes == (gulong) -1) && !error_message)
error_message = g_strdup_printf ("Could not find information on interface '%s' in /proc/net/dev", iface);
rewind (fh);
fflush (fh);
return error_message;
}