int df(lua_State *L)
{
unsigned long blocks_used;
unsigned blocks_percent_used;
FILE *mount_table;
struct mntent *mount_entry = 0;
struct statfs s;
/* default display is kilobytes */
const char *disp_units_hdr = "1k-blocks";
int cnt = 0;
printf("Filesystem %-15sUsed Available Use%% Mounted on\n",
disp_units_hdr);
mount_table = NULL;
mount_table = setmntent("/etc/mtab", "r");
lua_newtable(L);
while (1) {
const char *device;
const char *mount_point;
if (mount_table) {
mount_entry = getmntent(mount_table);
if (!mount_entry) {
endmntent(mount_table);
break;
}
}
device = mount_entry->mnt_fsname;
mount_point = mount_entry->mnt_dir;
if (statfs(mount_point, &s) != 0) {
perror(mount_point);
continue;
}
if ((s.f_blocks > 0) || !mount_table)
{
blocks_used = s.f_blocks - s.f_bfree;
blocks_percent_used = 0;
if (blocks_used + s.f_bavail)
{
blocks_percent_used = (blocks_used * 100ULL + (blocks_used + s.f_bavail) / 2 )
/ (blocks_used + s.f_bavail);
}
lua_pushinteger(L, ++cnt);
lua_newtable(L);
add_table_entry_int(L, "blocks", kscale(s.f_blocks, s.f_bsize));
add_table_entry_int(L, "used", kscale(s.f_blocks-s.f_bfree, s.f_bsize));
add_table_entry_int(L, "avail", kscale(s.f_bavail, s.f_bsize));
add_table_entry_int(L, "percent", blocks_percent_used);
add_table_entry(L, "device", device);
add_table_entry(L, "mountpoint", mount_point);
add_table_entry_int(L, "blocksize", s.f_bsize);
lua_settable(L, -3);
/*printf("\n%-20s" + 1, device)
printf(" %9lu %9lu %9lu %3u%% %s\n",
kscale(s.f_blocks, s.f_bsize),
kscale(s.f_blocks-s.f_bfree, s.f_bsize),
kscale(s.f_bavail, s.f_bsize),
blocks_percent_used, mount_point);*/
}
}
return 1;
}
void add_region(World *w, Region *r)
{
add_table_entry(w->regions, r);
}
void add_vertex(World *w, Vertex *v)
{
add_table_entry(w->vertices, v);
}
void add_wall(World *w, Wall *wall)
{
add_table_entry(w->walls, wall);
}
void add_texture(World *w, Texture *tex)
{
add_table_entry(w->textures, &tex);
}
/*
* Process a newly received IGMP packet that is sitting in the input
* packet buffer.
*/
void accept_igmp(size_t recvlen)
{
register u_int32 src, dst, group;
struct ip *ip;
struct igmp *igmp;
int ipdatalen, iphdrlen, igmpdatalen;
if (recvlen < sizeof(struct ip)) {
logit(LOG_WARNING, 0,
"received packet too short (%u bytes) for IP header", recvlen);
return;
}
ip = (struct ip *)recv_buf;
src = ip->ip_src.s_addr;
dst = ip->ip_dst.s_addr;
/*
* this is most likely a message from the kernel indicating that
* a new src grp pair message has arrived and so, it would be
* necessary to install a route into the kernel for this.
*/
if (ip->ip_p == 0) {
if (src == 0 || dst == 0)
logit(LOG_WARNING, 0, "kernel request not accurate");
else
add_table_entry(src, dst);
return;
}
iphdrlen = ip->ip_hl << 2;
ipdatalen = ntohs(ip->ip_len) - iphdrlen;
if ((size_t)(iphdrlen + ipdatalen) != recvlen) {
logit(LOG_WARNING, 0,
"received packet from %s shorter (%u bytes) than hdr+data length (%u+%u)",
inet_fmt(src, s1, sizeof(s1)), recvlen, iphdrlen, ipdatalen);
return;
}
igmp = (struct igmp *)(recv_buf + iphdrlen);
group = igmp->igmp_group.s_addr;
igmpdatalen = ipdatalen - IGMP_MINLEN;
if (igmpdatalen < 0) {
logit(LOG_WARNING, 0,
"received IP data field too short (%u bytes) for IGMP, from %s",
ipdatalen, inet_fmt(src, s1, sizeof(s1)));
return;
}
IF_DEBUG(DEBUG_PKT|igmp_debug_kind(igmp->igmp_type, igmp->igmp_code))
logit(LOG_DEBUG, 0, "RECV %s from %-15s to %s",
igmp_packet_kind(igmp->igmp_type, igmp->igmp_code),
inet_fmt(src, s1, sizeof(s1)), inet_fmt(dst, s2, sizeof(s2)));
switch (igmp->igmp_type) {
case IGMP_MEMBERSHIP_QUERY:
accept_membership_query(src, dst, group, igmp->igmp_code);
return;
case IGMP_V1_MEMBERSHIP_REPORT:
case IGMP_V2_MEMBERSHIP_REPORT:
accept_group_report(src, dst, group, igmp->igmp_type);
return;
case IGMP_V2_LEAVE_GROUP:
accept_leave_message(src, dst, group);
return;
case IGMP_DVMRP:
group = ntohl(group);
switch (igmp->igmp_code) {
case DVMRP_PROBE:
accept_probe(src, dst, (char *)(igmp+1), igmpdatalen, group);
return;
case DVMRP_REPORT:
accept_report(src, dst, (char *)(igmp+1), igmpdatalen, group);
return;
case DVMRP_ASK_NEIGHBORS:
accept_neighbor_request(src, dst);
return;
case DVMRP_ASK_NEIGHBORS2:
accept_neighbor_request2(src, dst);
return;
case DVMRP_NEIGHBORS:
accept_neighbors(src, dst, (u_char *)(igmp+1), igmpdatalen, group);
return;
case DVMRP_NEIGHBORS2:
accept_neighbors2(src, dst, (u_char *)(igmp+1), igmpdatalen, group);
return;
case DVMRP_PRUNE:
accept_prune(src, dst, (char *)(igmp+1), igmpdatalen);
return;
case DVMRP_GRAFT:
accept_graft(src, dst, (char *)(igmp+1), igmpdatalen);
return;
case DVMRP_GRAFT_ACK:
accept_g_ack(src, dst, (char *)(igmp+1), igmpdatalen);
return;
case DVMRP_INFO_REQUEST:
accept_info_request(src, dst, (u_char *)(igmp+1), igmpdatalen);
return;
case DVMRP_INFO_REPLY:
accept_info_reply(src, dst, (u_char *)(igmp+1), igmpdatalen);
return;
default:
logit(LOG_INFO, 0,
"ignoring unknown DVMRP message code %u from %s to %s",
igmp->igmp_code, inet_fmt(src, s1, sizeof(s1)),
inet_fmt(dst, s2, sizeof(s2)));
return;
}
case IGMP_PIM:
return;
case IGMP_MTRACE_RESP:
return;
case IGMP_MTRACE:
accept_mtrace(src, dst, group, (char *)(igmp+1),
igmp->igmp_code, igmpdatalen);
return;
default:
logit(LOG_INFO, 0,
"ignoring unknown IGMP message type %x from %s to %s",
igmp->igmp_type, inet_fmt(src, s1, sizeof(s1)),
inet_fmt(dst, s2, sizeof(s2)));
return;
}
}
