/* $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
