xnu-6153.41.3.tar.gz

[apple/xnu.git] / osfmk / device / subrs.c

/*
 * Copyright (c) 2000-2006 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
 *
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. The rights granted to you under the License
 * may not be used to create, or enable the creation or redistribution of,
 * unlawful or unlicensed copies of an Apple operating system, or to
 * circumvent, violate, or enable the circumvention or violation of, any
 * terms of an Apple operating system software license agreement.
 *
 * Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this file.
 *
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
 */
/*
 * @OSF_COPYRIGHT@
 */
/*
 *(C)UNIX System Laboratories, Inc. all or some portions of this file are
 * derived from material licensed to the University of California by
 * American Telephone and Telegraph Co. or UNIX System Laboratories,
 * Inc. and are reproduced herein with the permission of UNIX System
 * Laboratories, Inc.
 */

/*
 * Mach Operating System
 * Copyright (c) 1993,1991,1990,1989,1988 Carnegie Mellon University
 * All Rights Reserved.
 *
 * Permission to use, copy, modify and distribute this software and its
 * documentation is hereby granted, provided that both the copyright
 * notice and this permission notice appear in all copies of the
 * software, derivative works or modified versions, and any portions
 * thereof, and that both notices appear in supporting documentation.
 *
 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
 * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
 * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
 *
 * Carnegie Mellon requests users of this software to return to
 *
 *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
 *  School of Computer Science
 *  Carnegie Mellon University
 *  Pittsburgh PA 15213-3890
 *
 * any improvements or extensions that they make and grant Carnegie Mellon
 * the rights to redistribute these changes.
 */
/*
 */
/*
 * Copyright (c) 1988 Regents of the University of California.
 * 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. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *      This product includes software developed by the University of
 *      California, Berkeley and its contributors.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 REGENTS OR CONTRIBUTORS 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.
 */

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

/*
 * NOTICE: This file was modified by McAfee Research in 2004 to introduce
 * support for mandatory and extensible security protections.  This notice
 * is included in support of clause 2.2 (b) of the Apple Public License,
 * Version 2.0.
 */
/*
 * Random device subroutines and stubs.
 */

#include <vm/vm_kern.h>
#include <kern/misc_protos.h>
#include <libsa/stdlib.h>
#include <sys/malloc.h>

/* String routines, from CMU */
#ifdef  strcpy
#undef strcmp
#undef strncmp
#undef strcpy
#undef strlen
#endif

/* to prevent recursion in the _chk functions */
#undef strcat
#undef strncpy
#undef strncat
#undef memcpy
#undef memset
#undef memmove
#undef strlcpy
#undef strlcat
/*
 * Abstract:
 *      strcmp (s1, s2) compares the strings "s1" and "s2".
 *      It returns 0 if the strings are identical. It returns
 *      > 0 if the first character that differs in the two strings
 *      is larger in s1 than in s2 or if s1 is longer than s2 and
 *      the contents are identical up to the length of s2.
 *      It returns < 0 if the first differing character is smaller
 *      in s1 than in s2 or if s1 is shorter than s2 and the
 *      contents are identical upto the length of s1.
 * Deprecation Warning:
 *      strcmp() is being deprecated. Please use strncmp() instead.
 */

int
strcmp(
        const char *s1,
        const char *s2)
{
        unsigned int a, b;

        do {
                a = *s1++;
                b = *s2++;
                if (a != b) {
                        return a - b;     /* includes case when
                                           *  'a' is zero and 'b' is not zero
                                           *  or vice versa */
                }
        } while (a != '\0');

        return 0;       /* both are zero */
}

/*
 * Abstract:
 *      strncmp (s1, s2, n) compares the strings "s1" and "s2"
 *      in exactly the same way as strcmp does.  Except the
 *      comparison runs for at most "n" characters.
 */

#if !defined __arm__ && !defined __arm64__
// ARM implementation in ../arm/strncmp.s
// ARM64 implementation in ../arm64/strncmp.s
int
strncmp(
        const char *s1,
        const char *s2,
        size_t n)
{
        unsigned int a, b;

        while (n != 0) {
                a = *s1++;
                b = *s2++;
                if (a != b) {
                        return a - b;     /* includes case when
                                           *  'a' is zero and 'b' is not zero
                                           *  or vice versa */
                }
                if (a == '\0') {
                        return 0;       /* both are zero */
                }
                n--;
        }

        return 0;
}
#endif // #ifndef __arm__


//
// Lame implementation just for use by strcasecmp/strncasecmp
//
static int
tolower(unsigned char ch)
{
        if (ch >= 'A' && ch <= 'Z') {
                ch = 'a' + (ch - 'A');
        }

        return ch;
}

int
strcasecmp(const char *s1, const char *s2)
{
        const unsigned char *us1 = (const u_char *)s1,
            *us2 = (const u_char *)s2;

        while (tolower(*us1) == tolower(*us2++)) {
                if (*us1++ == '\0') {
                        return 0;
                }
        }
        return tolower(*us1) - tolower(*--us2);
}

int
strncasecmp(const char *s1, const char *s2, size_t n)
{
        if (n != 0) {
                const unsigned char *us1 = (const u_char *)s1,
                    *us2 = (const u_char *)s2;

                do {
                        if (tolower(*us1) != tolower(*us2++)) {
                                return tolower(*us1) - tolower(*--us2);
                        }
                        if (*us1++ == '\0') {
                                break;
                        }
                } while (--n != 0);
        }
        return 0;
}

char *
strchr(const char *s, int c)
{
        if (!s) {
                return NULL;
        }

        do {
                if (*s == c) {
                        return __CAST_AWAY_QUALIFIER(s, const, char *);
                }
        } while (*s++);

        return NULL;
}

char *
strrchr(const char *s, int c)
{
        const char *found = NULL;

        if (!s) {
                return NULL;
        }

        do {
                if (*s == c) {
                        found = s;
                }
        } while (*s++);

        return __CAST_AWAY_QUALIFIER(found, const, char *);
}

/*
 * Abstract:
 *      strcpy copies the contents of the string "from" including
 *      the null terminator to the string "to". A pointer to "to"
 *      is returned.
 * Deprecation Warning:
 *      strcpy() is being deprecated. Please use strlcpy() instead.
 */
#if !CONFIG_EMBEDDED
char *
strcpy(
        char *to,
        const char *from)
{
        char *ret = to;

        while ((*to++ = *from++) != '\0') {
                continue;
        }

        return ret;
}
#endif

/*
 * Abstract:
 *      strncpy copies "count" characters from the "from" string to
 *      the "to" string. If "from" contains less than "count" characters
 *      "to" will be padded with null characters until exactly "count"
 *      characters have been written. The return value is a pointer
 *      to the "to" string.
 */

#if !defined __arm__ && !defined __arm64__
// ARM and ARM64 implementation in ../arm/strncpy.c
#undef strncpy
char *
strncpy(
        char *s1,
        const char *s2,
        size_t n)
{
        char *os1 = s1;
        unsigned long i;

        for (i = 0; i < n;) {
                if ((*s1++ = *s2++) == '\0') {
                        for (i++; i < n; i++) {
                                *s1++ = '\0';
                        }
                } else {
                        i++;
                }
        }
        return os1;
}
#endif // #ifndef __arm__

/*
 * atoi:
 *
 *      This function converts an ascii string into an integer.
 *
 * input        : string
 * output       : a number
 */

int
atoi(const char *cp)
{
        int     number;

        for (number = 0; ('0' <= *cp) && (*cp <= '9'); cp++) {
                number = (number * 10) + (*cp - '0');
        }

        return number;
}

/*
 * convert an ASCII string (decimal radix) to an integer
 * inputs:
 *      p       string pointer.
 *      t       char **, return a pointer to the cahr which terminates the
 *              numeric string.
 * returns:
 *      integer value of the numeric string.
 * side effect:
 *      pointer to terminating char.
 */

int
atoi_term(
        char    *p,     /* IN */
        char    **t)    /* OUT */
{
        int n;
        int f;

        n = 0;
        f = 0;
        for (;; p++) {
                switch (*p) {
                case ' ':
                case '\t':
                        continue;
                case '-':
                        f++;
                case '+':
                        p++;
                }
                break;
        }
        while (*p >= '0' && *p <= '9') {
                n = n * 10 + *p++ - '0';
        }

        /* return pointer to terminating character */
        if (t) {
                *t = p;
        }

        return f? -n: n;
}

/*
 * Does the same thing as strlen, except only looks up
 * to max chars inside the buffer.
 * Taken from archive/kern-stuff/sbf_machine.c in
 * seatbelt.
 * inputs:
 *      s       string whose length is to be measured
 *      max     maximum length of string to search for null
 * outputs:
 *      length of s or max; whichever is smaller
 */

#if !defined __arm__ && !defined __arm64__
// ARM implementation in ../arm/strnlen.s
// ARM64 implementation in ../arm64/strnlen.s
#undef strnlen
size_t
strnlen(const char *s, size_t max)
{
        const char *es = s + max, *p = s;
        while (*p && p != es) {
                p++;
        }

        return p - s;
}
#endif // #ifndef __arm__

/*
 * convert an integer to an ASCII string.
 * inputs:
 *      num     integer to be converted
 *      str     string pointer.
 *
 * outputs:
 *      pointer to string start.
 */

char *
itoa(
        int     num,
        char    *str)
{
        char    digits[11];
        char *dp;
        char *cp = str;

        if (num == 0) {
                *cp++ = '0';
        } else {
                dp = digits;
                while (num) {
                        *dp++ = '0' + num % 10;
                        num /= 10;
                }
                while (dp != digits) {
                        *cp++ = *--dp;
                }
        }
        *cp++ = '\0';

        return str;
}

/*
 * Deprecation Warning:
 *      strcat() is being deprecated. Please use strlcat() instead.
 */
#if !CONFIG_EMBEDDED
char *
strcat(
        char *dest,
        const char *src)
{
        char *old = dest;

        while (*dest) {
                ++dest;
        }
        while ((*dest++ = *src++)) {
                ;
        }
        return old;
}
#endif

/*
 * 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.
 */
#undef strlcat
size_t
strlcat(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 */
}

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

#if !defined __arm__ && !defined __arm64__
// ARM and ARM64 implementation in ../arm/strlcpy.c
#undef strlcpy
size_t
strlcpy(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

/*
 * STRDUP
 *
 * Description: The STRDUP function allocates sufficient memory for a copy
 *              of the string "string", does the copy, and returns a pointer
 *              it. The pointer may subsequently be used as an argument to
 *              the macro FREE().
 *
 * Parameters:  string          String to be duplicated
 *              type            type of memory to be allocated (normally
 *                              M_TEMP)
 *
 * Returns:     char *          A pointer to the newly allocated string with
 *                              duplicated contents in it.
 *
 *              NULL            If MALLOC() fails.
 *
 * Note:        This function can *not* be called from interrupt context as
 *              it calls MALLOC with M_WAITOK.  In fact, you really
 *              shouldn't be doing string manipulation in interrupt context
 *              ever.
 *
 *              This function name violates the kernel style(9) guide
 *              by being all caps.  This was done on purpose to emphasize
 *              one should use FREE() with the allocated buffer.
 *
 */
char *
STRDUP(const char *string, int type)
{
        size_t len;
        char *copy;

        len = strlen(string) + 1;
        MALLOC(copy, char *, len, type, M_WAITOK);
        if (copy == NULL) {
                return NULL;
        }
        bcopy(string, copy, len);
        return copy;
}

/*
 * Return TRUE(1) if string 2 is a prefix of string 1.
 */
int
strprefix(const char *s1, const char *s2)
{
        int c;

        while ((c = *s2++) != '\0') {
                if (c != *s1++) {
                        return 0;
                }
        }
        return 1;
}

char *
strnstr(char *s, const char *find, size_t slen)
{
        char c, sc;
        size_t len;

        if ((c = *find++) != '\0') {
                len = strlen(find);
                do {
                        do {
                                if ((sc = *s++) == '\0' || slen-- < 1) {
                                        return NULL;
                                }
                        } while (sc != c);
                        if (len > slen) {
                                return NULL;
                        }
                } while (strncmp(s, find, len) != 0);
                s--;
        }
        return s;
}

void * __memcpy_chk(void *dst, void const *src, size_t s, size_t chk_size);
void * __memmove_chk(void *dst, void const *src, size_t s, size_t chk_size);
void * __memset_chk(void *dst, int c, size_t s, size_t chk_size);
size_t __strlcpy_chk(char *dst, char const *src, size_t s, size_t chk_size);
size_t __strlcat_chk(char *dst, char const *src, size_t s, size_t chk_size);
char * __strncpy_chk(char *restrict dst, char *restrict src, size_t len, size_t chk_size);
char * __strncat_chk(char *restrict dst, const char *restrict src, size_t len, size_t chk_size);
char * __strcpy_chk(char *restrict dst, const char *restrict src, size_t chk_size);
char * __strcat_chk(char *restrict dst, const char *restrict src, size_t chk_size);

void *
__memcpy_chk(void *dst, void const *src, size_t s, size_t chk_size)
{
        if (__improbable(chk_size < s)) {
                panic("__memcpy_chk object size check failed: dst %p, src %p, (%zu < %zu)", dst, src, chk_size, s);
        }
        return memcpy(dst, src, s);
}

void *
__memmove_chk(void *dst, void const *src, size_t s, size_t chk_size)
{
        if (__improbable(chk_size < s)) {
                panic("__memmove_chk object size check failed: dst %p, src %p, (%zu < %zu)", dst, src, chk_size, s);
        }
        return memmove(dst, src, s);
}

void *
__memset_chk(void *dst, int c, size_t s, size_t chk_size)
{
        if (__improbable(chk_size < s)) {
                panic("__memset_chk object size check failed: dst %p, c %c, (%zu < %zu)", dst, c, chk_size, s);
        }
        return memset(dst, c, s);
}

size_t
__strlcat_chk(char *dst, char const *src, size_t s, size_t chk_size)
{
        if (__improbable(chk_size < s)) {
                panic("__strlcat_chk object size check failed: dst %p, src %p, (%zu < %zu)", dst, src, chk_size, s);
        }
        return strlcat(dst, src, s);
}

size_t
__strlcpy_chk(char *dst, char const *src, size_t s, size_t chk_size)
{
        if (__improbable(chk_size < s)) {
                panic("__strlcpy_chk object size check failed: dst %p, src %p, (%zu < %zu)", dst, src, chk_size, s);
        }
        return strlcpy(dst, src, s);
}

char *
__strncpy_chk(char *restrict dst, char *restrict src,
    size_t len, size_t chk_size)
{
        if (__improbable(chk_size < len)) {
                panic("__strncpy_chk object size check failed: dst %p, src %p, (%zu < %zu)", dst, src, chk_size, len);
        }
        return strncpy(dst, src, len);
}

char *
__strncat_chk(char *restrict dst, const char *restrict src,
    size_t len, size_t chk_size)
{
        size_t len1 = strlen(dst);
        size_t len2 = strnlen(src, len);
        if (__improbable(chk_size < len1 + len2 + 1)) {
                panic("__strncat_chk object size check failed: dst %p, src %p, (%zu < %zu + %zu + 1)", dst, src, chk_size, len1, len2);
        }
        return strncat(dst, src, len);
}

char *
__strcpy_chk(char *restrict dst, const char *restrict src, size_t chk_size)
{
        size_t len = strlen(src);
        if (__improbable(chk_size < len + 1)) {
                panic("__strcpy_chk object size check failed: dst %p, src %p, (%zu < %zu + 1)", dst, src, chk_size, len);
        }
        memcpy(dst, src, len + 1);
        return dst;
}

char *
__strcat_chk(char *restrict dst, const char *restrict src, size_t chk_size)
{
        size_t len1 = strlen(dst);
        size_t len2 = strlen(src);
        size_t required_len = len1 + len2 + 1;
        if (__improbable(chk_size < required_len)) {
                panic("__strcat_chk object size check failed: dst %p, src %p, (%zu < %zu + %zu + 1)", dst, src, chk_size, len1, len2);
        }
        memcpy(dst + len1, src, len2 + 1);
        return dst;
}