Annotation of embedaddon/libpdel/util/kernelglue.c, revision 1.1
1.1 ! misho 1:
! 2: /*
! 3: * Copyright (c) 1988, 1993
! 4: * The Regents of the University of California. All rights reserved.
! 5: *
! 6: * Redistribution and use in source and binary forms, with or without
! 7: * modification, are permitted provided that the following conditions
! 8: * are met:
! 9: * 1. Redistributions of source code must retain the above copyright
! 10: * notice, this list of conditions and the following disclaimer.
! 11: * 2. Redistributions in binary form must reproduce the above copyright
! 12: * notice, this list of conditions and the following disclaimer in the
! 13: * documentation and/or other materials provided with the distribution.
! 14: * 3. All advertising materials mentioning features or use of this software
! 15: * must display the following acknowledgement:
! 16: * This product includes software developed by the University of
! 17: * California, Berkeley and its contributors.
! 18: * 4. Neither the name of the University nor the names of its contributors
! 19: * may be used to endorse or promote products derived from this software
! 20: * without specific prior written permission.
! 21: *
! 22: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
! 23: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 24: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 25: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
! 26: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 27: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 28: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 29: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 30: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 31: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 32: * SUCH DAMAGE.
! 33: */
! 34:
! 35: #include <sys/types.h>
! 36: #include <sys/errno.h>
! 37: #include <sys/param.h>
! 38: #include <sys/libkern.h>
! 39: #include <sys/systm.h>
! 40: #include <sys/ctype.h>
! 41: #include <net/ethernet.h>
! 42: #include <netinet/in.h>
! 43: #include <netinet/in_systm.h>
! 44:
! 45: #include "kernelglue.h"
! 46:
! 47: /*
! 48: * Kernelglue kernel memory type
! 49: */
! 50: MALLOC_DEFINE(M_LIBPDEL, "LIBPDEL", "libpdel kernel memory");
! 51:
! 52: /* Errno */
! 53: int errno;
! 54:
! 55: char *
! 56: strdup(const char *str)
! 57: {
! 58: size_t len;
! 59: char *copy;
! 60:
! 61: len = strlen(str) + 1;
! 62: if ((copy = MALLOC(NULL, len)) == NULL)
! 63: return (NULL);
! 64: memcpy(copy, str, len);
! 65: return (copy);
! 66: }
! 67:
! 68: int
! 69: asprintf(char **ret, const char *format, ...)
! 70: {
! 71: va_list args;
! 72: int rtn;
! 73:
! 74: va_start(args, format);
! 75: rtn = vasprintf(ret, format, args);
! 76: va_end(args);
! 77: return (rtn);
! 78: }
! 79:
! 80: int
! 81: vasprintf(char **ret, const char *format, va_list ap)
! 82: {
! 83: size_t buflen = 256;
! 84: char *buf;
! 85: int slen;
! 86:
! 87: /* Initialize return value in case of failure */
! 88: *ret = NULL;
! 89:
! 90: try_again:
! 91: /* Allocate buffer */
! 92: if ((buf = malloc(buflen, M_LIBPDEL, M_NOWAIT)) == NULL) {
! 93: errno = ENOMEM;
! 94: return (-1);
! 95: }
! 96:
! 97: /* Format string */
! 98: slen = vsnprintf(buf, buflen, format, ap);
! 99:
! 100: /* If buffer was big enough, we're done */
! 101: if (slen < buflen) {
! 102: *ret = buf;
! 103: return (slen);
! 104: }
! 105:
! 106: /* Increase buffer size and try again */
! 107: free(buf, M_LIBPDEL);
! 108: buflen = slen + 1;
! 109: goto try_again;
! 110: }
! 111:
! 112: char *
! 113: strchr(const char *s, int c)
! 114: {
! 115: while (1) {
! 116: if (*s == (char)c)
! 117: return ((char *)s);
! 118: if (*s == '\0')
! 119: return (NULL);
! 120: s++;
! 121: }
! 122: }
! 123:
! 124: int
! 125: strcasecmp(const char *s1, const char *s2)
! 126: {
! 127: const u_char *s = s1;
! 128: const u_char *t = s2;
! 129:
! 130: while (*s != '\0' && *t != '\0' && tolower(*s) == tolower(*t)) {
! 131: s++;
! 132: t++;
! 133: }
! 134: return (*s - *t);
! 135: }
! 136:
! 137: size_t
! 138: strlcpy(char *dst, const char *src, size_t siz)
! 139: {
! 140: char *d = dst;
! 141: const char *s = src;
! 142: size_t n = siz;
! 143:
! 144: /* Copy as many bytes as will fit */
! 145: if (n != 0 && --n != 0) {
! 146: do {
! 147: if ((*d++ = *s++) == 0)
! 148: break;
! 149: } while (--n != 0);
! 150: }
! 151:
! 152: /* Not enough room in dst, add NUL and traverse rest of src */
! 153: if (n == 0) {
! 154: if (siz != 0)
! 155: *d = '\0'; /* NUL-terminate dst */
! 156: while (*s++)
! 157: ;
! 158: }
! 159:
! 160: return(s - src - 1); /* count does not include NUL */
! 161: }
! 162:
! 163: void *
! 164: memmove(void *dst, const void *src, size_t len)
! 165: {
! 166: ovbcopy(src, dst, len);
! 167: return (dst);
! 168: }
! 169:
! 170: time_t
! 171: time(time_t *newtime)
! 172: {
! 173: struct timeval valtime;
! 174:
! 175: getmicrotime(&valtime);
! 176: if (newtime)
! 177: *newtime = valtime.tv_sec;
! 178: return (valtime.tv_sec);
! 179: }
! 180:
! 181: char *
! 182: strerror(int errnum)
! 183: {
! 184: static char buf[32];
! 185: const char *s;
! 186:
! 187: switch (errnum) {
! 188: case EPERM: s = "Operation not permitted"; break;
! 189: case ENOENT: s = "No such file or directory"; break;
! 190: case ESRCH: s = "No such process"; break;
! 191: case EINTR: s = "Interrupted system call"; break;
! 192: case EIO: s = "Input/output error"; break;
! 193: case ENXIO: s = "Device not configured"; break;
! 194: case E2BIG: s = "Argument list too long"; break;
! 195: case ENOEXEC: s = "Exec format error"; break;
! 196: case EBADF: s = "Bad file descriptor"; break;
! 197: case ECHILD: s = "No child processes"; break;
! 198: case EDEADLK: s = "Resource deadlock avoided"; break;
! 199: case ENOMEM: s = "Cannot allocate memory"; break;
! 200: case EACCES: s = "Permission denied"; break;
! 201: case EFAULT: s = "Bad address"; break;
! 202: case ENOTBLK: s = "Block device required"; break;
! 203: case EBUSY: s = "Device busy"; break;
! 204: case EEXIST: s = "File exists"; break;
! 205: case EXDEV: s = "Cross-device link"; break;
! 206: case ENODEV: s = "Operation not supported by device"; break;
! 207: case ENOTDIR: s = "Not a directory"; break;
! 208: case EISDIR: s = "Is a directory"; break;
! 209: case EINVAL: s = "Invalid argument"; break;
! 210: case ENFILE: s = "Too many open files in system"; break;
! 211: case EMFILE: s = "Too many open files"; break;
! 212: case ENOTTY: s = "Inappropriate ioctl for device"; break;
! 213: case ETXTBSY: s = "Text file busy"; break;
! 214: case EFBIG: s = "File too large"; break;
! 215: case ENOSPC: s = "No space left on device"; break;
! 216: case ESPIPE: s = "Illegal seek"; break;
! 217: case EROFS: s = "Read-only file system"; break;
! 218: case EMLINK: s = "Too many links"; break;
! 219: case EPIPE: s = "Broken pipe"; break;
! 220: case EDOM: s = "Numerical argument out of domain"; break;
! 221: case ERANGE: s = "Result too large"; break;
! 222: case EAGAIN: s = "Resource temporarily unavailable"; break;
! 223: case EINPROGRESS: s = "Operation now in progress"; break;
! 224: case EALREADY: s = "Operation already in progress"; break;
! 225: case ENOTSOCK: s = "Socket operation on non-socket"; break;
! 226: case EDESTADDRREQ: s = "Destination address required"; break;
! 227: case EMSGSIZE: s = "Message too long"; break;
! 228: case EPROTOTYPE: s = "Protocol wrong type for socket"; break;
! 229: case ENOPROTOOPT: s = "Protocol not available"; break;
! 230: case EPROTONOSUPPORT: s = "Protocol not supported"; break;
! 231: case ESOCKTNOSUPPORT: s = "Socket type not supported"; break;
! 232: case EOPNOTSUPP: s = "Operation not supported"; break;
! 233: case EPFNOSUPPORT: s = "Protocol family not supported"; break;
! 234: case EAFNOSUPPORT:
! 235: s = "Address family not supported by protocol family"; break;
! 236: case EADDRINUSE: s = "Address already in use"; break;
! 237: case EADDRNOTAVAIL: s = "Can't assign requested address"; break;
! 238: case ENETDOWN: s = "Network is down"; break;
! 239: case ENETUNREACH: s = "Network is unreachable"; break;
! 240: case ENETRESET:
! 241: s = "Network dropped connection on reset"; break;
! 242: case ECONNABORTED: s = "Software caused connection abort"; break;
! 243: case ECONNRESET: s = "Connection reset by peer"; break;
! 244: case ENOBUFS: s = "No buffer space available"; break;
! 245: case EISCONN: s = "Socket is already connected"; break;
! 246: case ENOTCONN: s = "Socket is not connected"; break;
! 247: case ESHUTDOWN: s = "Can't send after socket shutdown"; break;
! 248: case ETOOMANYREFS: s = "Too many references: can't splice"; break;
! 249: case ETIMEDOUT: s = "Operation timed out"; break;
! 250: case ECONNREFUSED: s = "Connection refused"; break;
! 251: case ELOOP: s = "Too many levels of symbolic links"; break;
! 252: case ENAMETOOLONG: s = "File name too long"; break;
! 253: case EHOSTDOWN: s = "Host is down"; break;
! 254: case EHOSTUNREACH: s = "No route to host"; break;
! 255: case ENOTEMPTY: s = "Directory not empty"; break;
! 256: case EPROCLIM: s = "Too many processes"; break;
! 257: case EUSERS: s = "Too many users"; break;
! 258: case EDQUOT: s = "Disc quota exceeded"; break;
! 259: case ESTALE: s = "Stale NFS file handle"; break;
! 260: case EREMOTE: s = "Too many levels of remote in path"; break;
! 261: case EBADRPC: s = "RPC struct is bad"; break;
! 262: case ERPCMISMATCH: s = "RPC version wrong"; break;
! 263: case EPROGUNAVAIL: s = "RPC prog. not avail"; break;
! 264: case EPROGMISMATCH: s = "Program version wrong"; break;
! 265: case EPROCUNAVAIL: s = "Bad procedure for program"; break;
! 266: case ENOLCK: s = "No locks available"; break;
! 267: case ENOSYS: s = "Function not implemented"; break;
! 268: case EFTYPE: s = "Inappropriate file type or format"; break;
! 269: case EAUTH: s = "Authentication error"; break;
! 270: case ENEEDAUTH: s = "Need authenticator"; break;
! 271: case EIDRM: s = "Identifier removed"; break;
! 272: case ENOMSG: s = "No message of desired type"; break;
! 273: case EOVERFLOW: s =
! 274: "Value too large to be stored in data type"; break;
! 275: case ECANCELED: s = "Operation canceled"; break;
! 276: case EILSEQ: s = "Illegal byte sequence"; break;
! 277: default:
! 278: snprintf(buf, sizeof(buf), "Unknown error: %d", errnum);
! 279: errno = EINVAL;
! 280: return (buf);
! 281: }
! 282: strlcpy(buf, s, sizeof(buf));
! 283: return (buf);
! 284: }
! 285:
! 286: void *
! 287: kern_malloc(size_t size)
! 288: {
! 289: void *mem;
! 290:
! 291: if ((mem = malloc((u_long)size, M_LIBPDEL, M_NOWAIT)) == NULL)
! 292: errno = ENOMEM;
! 293: return (mem);
! 294: }
! 295:
! 296: void *
! 297: kern_realloc(void *mem, size_t size)
! 298: {
! 299: if ((mem = realloc(mem,
! 300: (u_long)size, M_LIBPDEL, M_NOWAIT)) == NULL)
! 301: errno = ENOMEM;
! 302: return (mem);
! 303: }
! 304:
! 305: void
! 306: kern_free(void *mem)
! 307: {
! 308: free(mem, M_LIBPDEL);
! 309: }
! 310:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to kernelglue.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libpdel / util