source: trunk/third/sysinfo/bsd-sysctl.c @ 12269

/*
 * Copyright (c) 1992-1998 Michael A. Cooper.
 * This software may be freely used and distributed provided it is not
 * sold for profit or used in part or in whole for commercial gain
 * without prior written agreement, and the author is credited
 * appropriately.
 */

#ifndef lint
static char *RCSid = "$Revision: 1.1.1.1 $";
#endif

/*
 * sysctl(3) functions common to BSD implimentations (BSD/OS, FreeBSD, etc.)
 */

#include "defs.h"
#include <sys/types.h>
#include <sys/sysctl.h>
#include <sys/time.h>
#include <sys/socket.h>         /* BSD/OS 3.1 */
#include <net/if.h>
#include <net/if_dl.h>
#include <net/route.h>
#if     defined(freebsd)
#include <net/ethernet.h>
#endif  /* freebsd */
#if     defined(VM_SWAPSTATS)
#include <vm/swap_pager.h>
#endif  /* VM_SWAPSTATS */

/*
 * Use sysctl() to get MODEL.
 */
extern char *GetModelSysCtl()
{
    int                         Query[2];
    static char                 Model[128];
    size_t                      Length = sizeof(Model);

    Query[0] = CTL_HW;
    Query[1] = HW_MODEL;
    if (sysctl(Query, 2, Model, &Length, NULL, 0) == -1) {
        SImsg(SIM_GERR, "sysctl CTL_HW.HW_MODEL failed: %s", SYSERR);
        return((char *) NULL);
    }

    return(Model);
}

/*
 * Use sysctl() to get Number of CPUs
 */
extern char *GetNcpuSysCtl()
{
    int                         Query[2];
    int                         NumCpu = 0;
    size_t                      Length = sizeof(NumCpu);

    Query[0] = CTL_HW;
    Query[1] = HW_NCPU;
    if (sysctl(Query, 2, &NumCpu, &Length, NULL, 0) == -1) {
        SImsg(SIM_GERR, "sysctl CTL_HW.HW_NCPU failed: %s", SYSERR);
        return((char *) NULL);
    }

    return(itoa(NumCpu));
}

/*
 * Use sysctl() to get the Kernel Version
 */
extern char *GetKernVerSysCtl()
{
    int                         Query[2];
    static char                 Version[256];
    size_t                      Length = sizeof(Version);

    Query[0] = CTL_KERN;
    Query[1] = KERN_VERSION;
    if (sysctl(Query, 2, Version, &Length, NULL, 0) == -1) {
        SImsg(SIM_GERR, "sysctl CTL_KERN.KERN_MODEL failed: %s", SYSERR);
        return((char *) NULL);
    }

    return(Version);
}

/*
 * Use sysctl() to get the OS Distribution
 */
extern char *GetOSDistSysCtl()
{
    int                         Query[2];
    int                         Dist = 0;
    size_t                      Length = sizeof(Dist);

    Query[0] = CTL_KERN;
    Query[1] = KERN_OSREV;
    if (sysctl(Query, 2, &Dist, &Length, NULL, 0) == -1) {
        SImsg(SIM_GERR, "sysctl CTL_KERN.KERN_OSREV failed: %s", SYSERR);
        return((char *) NULL);
    }

    return(itoa(Dist));
}

/*
 * Use sysctl() to get the Memory
 */
extern char *GetMemorySysCtl()
{
    int                         Query[2];
    int                         Memory = 0;
    Large_t                     Amount;
    size_t                      Length = sizeof(Memory);

    Query[0] = CTL_HW;
    Query[1] = HW_PHYSMEM;
    if (sysctl(Query, 2, &Memory, &Length, NULL, 0) == -1) {
        SImsg(SIM_GERR, "sysctl CTL_HW.HW_PHYSMEM failed: %s", SYSERR);
        return((char *) NULL);
    }

    Amount = DivRndUp(Memory, (Large_t)MBYTES);

    return(GetMemoryStr(Amount));
}

/*
 * Use sysctl() to get the Virtual Memory
 */
extern char *GetVirtMemSysCtl()
{
#if     defined(VM_SWAPSTATS)
    int                         Query[2];
    struct swapstats            Swap;
    size_t                      Length = sizeof(Swap);
    Large_t                     Amount;

    Query[0] = CTL_VM;
    Query[1] = VM_SWAPSTATS;
    if (sysctl(Query, 2, &Swap, &Length, NULL, 0) == -1) {
        SImsg(SIM_GERR, "sysctl CTL_Vm.VM_SWAPSTATS failed: %s", SYSERR);
        return((char *) NULL);
    }

    Amount = DivRndUp(Swap.swap_total * 512, (Large_t)MBYTES);

    return(GetMemoryStr(Amount));
#else
    return((char *) NULL);
#endif  /* VM_SWAPSTATS */
}

/*
 * Use sysctl() to get the Boot Time
 */
extern char *GetBootTimeSysCtl()
{
    int                         Query[2];
    struct timeval              TimeVal;
    time_t                      Time;
    size_t                      Length = sizeof(TimeVal);
    char                       *TimeStr;
    register char              *cp;

    Query[0] = CTL_KERN;
    Query[1] = KERN_BOOTTIME;
    if (sysctl(Query, 2, &TimeVal, &Length, NULL, 0) == -1) {
        SImsg(SIM_GERR, "sysctl CTL_KERN.KERN_BOOTTIME failed: %s", SYSERR);
        return((char *) NULL);
    }

    Time = (time_t) TimeVal.tv_sec;
    TimeStr = ctime(&Time);
    if (cp = strchr(TimeStr, '\n'))
        *cp = CNULL;

    return(TimeStr);
}

/*
 * Use sysctl(3) to retrieve the MAC Info for a network interface.
 * This is based on code from FreeBSD 2.2.6 ifconfig(8).
 * This is totally convoluted!  Yuck!
 */
extern void SetMacInfoSysCtl(DevInfo, NetIf)
     DevInfo_t                 *DevInfo;
     NetIF_t                   *NetIf;
{
    static char                 Ether[128];
    static char                 EtherName[128];
#if     defined(HAVE_ETHER_NTOHOST)
    struct ether_addr           EtherAddr;
#endif  /* HAVE_ETHER_NTOHOST */
    register char              *cp;
    register int                n;
    register int                Len;
    struct if_msghdr           *ifm, *nextifm;
    struct ifa_msghdr          *ifam;
    struct sockaddr_dl         *sdl;
    char                       *buf, *lim, *next;
    size_t                      needed;
    int                         mib[6];

    mib[0] = CTL_NET;
    mib[1] = PF_ROUTE;
    mib[2] = 0;
    mib[3] = AF_INET;   /* address family */
    mib[4] = NET_RT_IFLIST;
    mib[5] = 0;
    if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0) {
        SImsg(SIM_GERR, "%s: sysctl get iflist estimate failed: %s",
              DevInfo->Name, SYSERR);
        return;
    }
    buf = (char *) xmalloc(needed);
    if (sysctl(mib, 6, buf, &needed, NULL, 0) < 0) {
        SImsg(SIM_GERR, "%s: sysctl retrieve iflist table failed: %s",
              DevInfo->Name, SYSERR);
        return;
    }
    lim = buf + needed;
    
    next = buf;
    while (next < lim) {
        
        ifm = (struct if_msghdr *)next;
        
        if (ifm->ifm_type == RTM_IFINFO) {
            sdl = (struct sockaddr_dl *)(ifm + 1);
        } else {
            SImsg(SIM_GERR, 
            "%s: Cannot get MAC info: out of sync parsing NET_RT_IFLIST.", 
                  DevInfo->Name);
            return;
        }
        
        next += ifm->ifm_msglen;
        ifam = NULL;
        while (next < lim) {
            
            nextifm = (struct if_msghdr *)next;
            
            if (nextifm->ifm_type != RTM_NEWADDR)
                break;
            
            if (ifam == NULL)
                ifam = (struct ifa_msghdr *)nextifm;
            
            next += nextifm->ifm_msglen;
        }

        if (EQN(DevInfo->Name, sdl->sdl_data, sdl->sdl_nlen)) {
            /* Found it */
            cp = (char *)LLADDR(sdl);
            if ((n = sdl->sdl_alen) > 0) {
                Ether[0] = CNULL;
                while (--n >= 0) {
                    Len = strlen(Ether);
                    (void) snprintf(&Ether[Len], sizeof(Ether)-Len,
                                    "%02x%s", *cp++ & 0xff, n > 0 ? ":" : "");
                }

                NetIf->MACaddr = strdup(Ether);
#if     defined(HAVE_ETHER_NTOHOST)
                memcpy(&EtherAddr.octet, LLADDR(sdl), ETHER_ADDR_LEN);
                if (ether_ntohost(EtherName, &EtherAddr) == 0)
                    NetIf->MACname = strdup(EtherName);
#endif  /* HAVE_ETHER_NTOHOST */
            }
            break;
        }
    }
    (void) free(buf);
}