path: root/mbbsd/osdep.c

/* $Id$ */
#include "bbs.h"

#ifdef NEED_STRLCAT

#include <sys/types.h>
#include <string.h>

/*   size_t
 *   strlcat(char *dst, const char *src, size_t size);
 */
/*
 * Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
 * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/*
 * Appends src to string dst of size siz (unlike strncat, siz is the
 * full size of dst, not space left).  At most siz-1 characters
 * will be copied.  Always NUL terminates (unless siz <= strlen(dst)).
 * Returns strlen(src) + MIN(siz, strlen(initial dst)).
 * If retval >= siz, truncation occurred.
 */
size_t
strlcat(dst, src, siz)
    char *dst;
    const char *src;
    size_t siz;
{
    char *d = dst;
    const char *s = src;
    size_t n = siz;
    size_t dlen;

    /* Find the end of dst and adjust bytes left but don't go past end */
    while (n-- != 0 && *d != '\0')
    d++;
    dlen = d - dst;
    n = siz - dlen;

    if (n == 0)
    return(dlen + strlen(s));
    while (*s != '\0') {
    if (n != 1) {
        *d++ = *s;
        n--;
    }
    s++;
    }
    *d = '\0';

    return(dlen + (s - src));   /* count does not include NUL */
}

#endif

#ifdef NEED_STRLCPY

/* ------------------------------------------------------------------------ */

/*   size_t
 *   strlcpy(char *dst, const char *src, size_t size);
 */

/*
 * Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
 * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/*
 * Copy src to string dst of size siz.  At most siz-1 characters
 * will be copied.  Always NUL terminates (unless siz == 0).
 * Returns strlen(src); if retval >= siz, truncation occurred.
 */
size_t strlcpy(dst, src, siz)
    char *dst;
    const char *src;
    size_t siz;
{
    char *d = dst;
    const char *s = src;
    size_t n = siz;

    /* Copy as many bytes as will fit */
    if (n != 0 && --n != 0) {
    do {
        if ((*d++ = *s++) == 0)
        break;
    } while (--n != 0);
    }

    /* Not enough room in dst, add NUL and traverse rest of src */
    if (n == 0) {
    if (siz != 0)
        *d = '\0';      /* NUL-terminate dst */
    while (*s++)
        ;
    }

    return(s - src - 1);    /* count does not include NUL */
}

#endif

#ifdef NEED_STRCASESTR

char           *
strcasestr(const char *big, const char *little)
{
    char           *ans = (char *)big;
    int             len = strlen(little);
    char           *endptr = (char *)big + strlen(big) - len;

    while (ans <= endptr)
    if (!strncasecmp(ans, little, len))
        return ans;
    else
        ans++;
    return 0;
}

#endif

#ifdef NEED_SCANDIR

/*
 * Scan the directory dirname calling select to make a list of selected
 * directory entries then sort using qsort and compare routine dcomp.
 * Returns the number of entries and a pointer to a list of pointers to
 * struct dirent (through namelist). Returns -1 if there were any errors.
 */

<<<<<<< .working
=======
#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#include <stdlib.h>
#include <string.h>

/*
 * The DIRSIZ macro is the minimum record length which will hold the directory
 * entry. This requires the amount of space in struct dirent without the
 * d_name field, plus enough space for the name and a terminating nul byte
 * (dp->d_namlen + 1), rounded up to a 4 byte boundary.
 */
#undef DIRSIZ
#define DIRSIZ(dp) \
    ((sizeof(struct dirent) - sizeof(dp)->d_name) + \
     ((strlen((dp)->d_name) + 1 + 3) &~ 3))
#if 0
((sizeof(struct dirent) - sizeof(dp)->d_name) + \
 (((dp)->d_namlen + 1 + 3) &~ 3))
#endif

int
scandir(dirname, namelist, select, dcomp)
    const char *dirname;
    struct dirent ***namelist;
    int (*select) (struct dirent *);
    int (*dcomp) (const void *, const void *);
{
    register struct dirent *d, *p, **names;
    register size_t nitems;
    struct stat stb;
    long arraysz;
    DIR *dirp;

    if ((dirp = opendir(dirname)) == NULL)
    return(-1);
    if (fstat(dirp->dd_fd, &stb) < 0)
    return(-1);

    /*
     * estimate the array size by taking the size of thedirectory file
     * and dividing it by a multiple of the minimum sizeentry.
     */
    arraysz = (stb.st_size / 24);
    names = (struct dirent **)malloc(arraysz * sizeof(struct dirent *));
    if (names == NULL)
    return(-1);

    nitems = 0;
    while ((d = readdir(dirp)) != NULL) {
    if (select != NULL && !(*select)(d))
        continue; /* just selected names */
    /*
     * Make a minimum size copy of the data
     */
    p = (struct dirent *)malloc(DIRSIZ(d));
    if (p == NULL)
        return(-1);
    p->d_ino = d->d_ino;
    p->d_off = d->d_off;
    p->d_reclen = d->d_reclen;
    memcpy(p->d_name, d->d_name, strlen(d->d_name) +1);
#if 0
    p->d_fileno = d->d_fileno;
    p->d_type = d->d_type;
    p->d_reclen = d->d_reclen;
    p->d_namlen = d->d_namlen;
    bcopy(d->d_name, p->d_name, p->d_namlen + 1);
#endif
    /*
     * Check to make sure the array has space left and
     * realloc the maximum size.
     */
    if (++nitems >= arraysz) {
        if (fstat(dirp->dd_fd, &stb) < 0)
        return(-1); /* just might have grown */
        arraysz = stb.st_size / 12;
        names = (struct dirent **)realloc((char*)names,
            arraysz * sizeof(struct dirent*));
        if (names == NULL)
        return(-1);
    }
    names[nitems-1] = p;
    }
    closedir(dirp);
    if (nitems && dcomp != NULL)
    qsort(names, nitems, sizeof(struct dirent *),dcomp);
    *namelist = names;
    return(nitems);
}

/*
 * Alphabetic order comparison routine for those who want it.
 */
int
alphasort(d1, d2)
    const void *d1;
    const void *d2;
{
    return(strcmp((*(struct dirent **)d1)->d_name,
        (*(struct dirent **)d2)->d_name));
} 

#endif

#ifdef NEED_FLOCK

int
flock (int fd, int f)
{
    if( f == LOCK_EX )
    return lockf(fd, F_LOCK, 0L);

    if( f == LOCK_UN )
    return lockf(fd, F_ULOCK, 0L);

    return -1;
}

#endif

#ifdef NEED_UNSETENV

void
unsetenv(name)
    char *name;
{
    extern char **environ;
    register char **pp;
    int len = strlen(name);

    for (pp = environ; *pp != NULL; pp++)
    {
    if (strncmp(name, *pp, len) == 0 &&
        ((*pp)[len] == '=' || (*pp)[len] == '\0'))
        break;
    }

    for (; *pp != NULL; pp++)
    *pp = pp[1];
}

#endif

#ifdef NEED_INET_PTON

#include <arpa/nameser.h>

/*
 * Copyright (c) 1996 by Internet Software Consortium.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS
 * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
 * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
 * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 * SOFTWARE.
 */

int
inet_pton(int af, const char *src, void *dst)
{
    static const char digits[] = "0123456789";
    int saw_digit, octets, ch;
    u_char tmp[INADDRSZ], *tp;

    saw_digit = 0;
    octets = 0;
    *(tp = tmp) = 0;
    while ((ch = *src++) != '\0') {
    const char *pch;

    if ((pch = strchr(digits, ch)) != NULL) {
        u_int new = *tp * 10 + (pch - digits);

        if (new > 255)
        return (0);
        *tp = new;
        if (! saw_digit) {
        if (++octets > 4)
            return (0);
        saw_digit = 1;
        }
    } else if (ch == '.' && saw_digit) {
        if (octets == 4)
        return (0);
        *++tp = 0;
        saw_digit = 0;
    } else
        return (0);
    }
    if (octets < 4)
    return (0);

    memcpy(dst, tmp, INADDRSZ);

    return (1);
}
#endif

#ifdef NEED_BSD_SIGNAL

void (*bsd_signal(int sig, void (*func)(int)))(int)
{
    struct sigaction act, oact;

    act.sa_handler = func;
    act.sa_flags = SA_RESTART;
    sigemptyset(&act.sa_mask);
    sigaddset(&act.sa_mask, sig);
    if (sigaction(sig, &act, &oact) == -1)
    return(SIG_ERR);
    return(oact.sa_handler);
}


#endif


#ifdef Solaris

#include <sys/stat.h>
#include <sys/swap.h>


double swapused(int *total, int *used)
{
    double          percent = -1;
    register int cnt, i;
    register int free;
    struct swaptable *swt;
    struct swapent *ste;
    static char path[256];
    cnt = swapctl(SC_GETNSWP, 0);
    swt = (struct swaptable *)malloc(sizeof(int) +
        cnt * sizeof(struct swapent));
    if (swt == NULL)
    {
    return 0;
    }
    swt->swt_n = cnt;

    /* fill in ste_path pointers: we don't care about the paths, so we point
       them all to the same buffer */
    ste = &(swt->swt_ent[0]);
    i = cnt;
    while (--i >= 0)
    {
    ste++->ste_path = path;
    }
    /* grab all swap info */
    swapctl(SC_LIST, swt);

    /* walk thru the structs and sum up the fields */
    *total = free = 0;
    ste = &(swt->swt_ent[0]);
    i = cnt;
    while (--i >= 0)
    {
    /* dont count slots being deleted */
    if (!(ste->ste_flags & ST_INDEL) &&
        !(ste->ste_flags & ST_DOINGDEL))
    {
        *total += ste->ste_pages;
        free += ste->ste_free;
    }
    ste++;
    }

    *used = *total - free;
    if( total != 0)
    percent = (double)*used / (double)*total;
    else
    percent = 0;

    return percent;
}

double
swapused(int *total, int *used)
{
    double          percent = -1;
    kvm_t          *kd;
    struct kvm_swap swapinfo;
    int             pagesize;

    kd = kvm_open(NULL, NULL, NULL, O_RDONLY, NULL);
    if (kd) {
    if (kvm_getswapinfo(kd, &swapinfo, 1, 0) == 0) {
        pagesize = getpagesize();
        *total = swapinfo.ksw_total * pagesize;
        *used = swapinfo.ksw_used * pagesize;
        if (*total != 0)
        percent = (double)*used / (double)*total;
    }
    kvm_close(kd);
    }
    return percent;
}

#endif

#if __FreeBSD__

int
cpuload(char *str)
{
    double          l[3] = {-1, -1, -1};
    if (getloadavg(l, 3) != 3)
    l[0] = -1;

    if (str) {
    if (l[0] != -1)
        sprintf(str, " %.2f %.2f %.2f", l[0], l[1], l[2]);
    else
        strcpy(str, " (unknown) ");
    }
    return (int)l[0];
}
#endif


#ifdef Solaris

#include <kstat.h>
#include <sys/param.h>

#define loaddouble(la) ((double)(la) / FSCALE)

int
cpuload(char *str)
{
    kstat_ctl_t *kc;
    kstat_t *ks;
    kstat_named_t *kn;
    double l[3] = {-1, -1, -1};

    kc = kstat_open();

    if( !kc ){
    strcpy(str, "(unknown) ");
    return -1;
    }

    ks = kstat_lookup( kc, "unix", 0, "system_misc");

    if( kstat_read( kc, ks, 0) == -1){
    strcpy( str, "( unknown ");
    return -1;
    }

    kn = kstat_data_lookup( ks, "avenrun_1min" );

    if( kn ) {
    l[0] = loaddouble(kn->value.ui32);
    }

    kn = kstat_data_lookup( ks, "avenrun_5min" );

    if( kn ) {
    l[1] = loaddouble(kn->value.ui32);
    }

    kn = kstat_data_lookup( ks, "avenrun_15min" );

    if( kn ) {
    l[2] = loaddouble(kn->value.ui32);
    }

    if (str) {

    if (l[0] != -1)
        sprintf(str, " %.2f %.2f %.2f", l[0], l[1], l[2]);
    else
        strcpy(str, " (unknown) ");
    }

    kstat_close(kc);
    return (int)l[0];
}

#endif

#ifdef __linux__
int
cpuload(char *str)
{
    double          l[3] = {-1, -1, -1};
    FILE           *fp;

    if ((fp = fopen("/proc/loadavg", "r"))) {
    if (fscanf(fp, "%lf %lf %lf", &l[0], &l[1], &l[2]) != 3)
        l[0] = -1;
    fclose(fp);
    }
    if (str) {
    if (l[0] != -1)
        snprintf(str, sizeof(str), " %.2f %.2f %.2f", l[0], l[1], l[2]);
    else
        strcpy(str, " (unknown) ");
    }
    return (int)l[0];
}

double
swapused(int *total, int *used)
{
    double          percent = -1;
    char            buf[101];
    FILE           *fp;

    if ((fp = fopen("/proc/meminfo", "r"))) {
    while (fgets(buf, 100, fp) && strstr(buf, "SwapTotal:") == NULL);
    sscanf(buf, "%*s %d", total);
    fgets(buf, 100, fp);
    sscanf(buf, "%*s %d", used);
    *used = *total - *used;
    if (*total != 0)
        percent = (double)*used / (double)*total;
    fclose(fp);
    }
    return percent;
}

#endif