[apple/libc.git] / libdarwin / string.c

/*
 * Copyright (c) 2018 Apple Inc. All rights reserved.
 *
 * @APPLE_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. 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_LICENSE_HEADER_END@
 */
#include "internal.h"

#pragma mark Definitions
#define __ENEG_ONE (-1)
#define __ENONE 0
#define __EBOGUS (ELAST + 1)

#pragma mark Types
OS_ENUM(errno_flags, uint32_t,
	EDF_INIT = 0,
	EDF_NONPOSIX = (1 << 0),
	EDF_SYSEXIT = (1 << 1),
);

typedef struct _errno_desc {
	int ed_error;
	int ed_sysexit;
	errno_flags_t ed_flags;
	const char *ed_sym;
	const char *ed_str;
} errno_desc_t;

#pragma mark Initializers
#define errno_init(__err, __sysexit, __str) \
	[__err] = { \
		.ed_error = (__err), \
		.ed_sysexit = (__sysexit), \
		.ed_flags = 0, \
		.ed_sym = #__err, \
		.ed_str = (__str), \
	}

#define errno_init_np(__err, __sysexit, __str) \
	[__err - EBASE_NP] = { \
		.ed_error = (__err), \
		.ed_sysexit = (__sysexit), \
		.ed_flags = EDF_NONPOSIX, \
		.ed_sym = #__err, \
		.ed_str = (__str), \
	}

#define sysexit_init(__code, __str) \
	[__code - EX__BASE] = { \
		.ed_error = (__code), \
		.ed_sysexit = (__code), \
		.ed_flags = EDF_SYSEXIT, \
		.ed_sym = #__code, \
		.ed_str = (__str), \
	}

#pragma mark Top-Level Statics
static const errno_desc_t _zero = {
	.ed_error = 0,
	.ed_sysexit = 0,
	.ed_flags = 0,
	.ed_sym = "0",
	.ed_str = "successful termination",
};

static const errno_desc_t _negative_one = {
	.ed_error = __ENEG_ONE,
	.ed_sysexit = EXIT_FAILURE,
	.ed_flags = 0,
	.ed_sym = "-1",
	.ed_str = "[return code instead of error]",
};

static const errno_desc_t _badreceipt = {
	.ed_error = EX_BADRECEIPT_NP,
	.ed_sysexit = EX_BADRECEIPT_NP,
	.ed_flags = EDF_SYSEXIT,
	.ed_sym = "EX_BADRECEIPT_NP",
	.ed_str = "bad purchase receipt",
};

static const errno_desc_t _posix_errors[] = {
	errno_init(__ENONE, EX_OK, "[no error]"),
	errno_init(EPERM, EX_NOPERM, "Operation not permitted"),
	errno_init(ENOENT, EX_NOINPUT, "No such file or directory"),
	errno_init(ESRCH, EX_IOERR, "No such process"),
	errno_init(EINTR, EX_OSERR, "Interrupted system call"),
	errno_init(EIO, EX_IOERR, "Input/output error"),
	errno_init(ENXIO, EX_NOINPUT, "Device not configured"),
	errno_init(E2BIG, EX_IOERR, "Argument list too long"),
	errno_init(ENOEXEC, EX_DATAERR, "Exec format error"),
	errno_init(EBADF, EX_OSERR, "Bad file descriptor"),
	errno_init(ECHILD, EX_IOERR, "No child processes"),
	errno_init(EDEADLK, EX_UNAVAILABLE, "Resource deadlock avoided"),
	errno_init(ENOMEM, EX_TEMPFAIL, "Cannot allocate memory"),
	errno_init(EACCES, EX_NOINPUT, "Permission denied"),
	errno_init(EFAULT, EX_OSERR, "Bad address"),
#if defined(ENOTBLK)
	errno_init(ENOTBLK, EX_IOERR, "Block device required"),
#endif
	errno_init(EBUSY, EX_TEMPFAIL, "Device / Resource busy"),
	errno_init(EEXIST, EX_CANTCREAT, "File exists"),
	errno_init(EXDEV, EX_UNAVAILABLE, "Cross-device link"),
	errno_init(ENODEV, EX_IOERR, "Operation not supported by device"),
	errno_init(ENOTDIR, EX_DATAERR, "Not a directory"),
	errno_init(EISDIR, EX_DATAERR, "Is a directory"),
	errno_init(EINVAL, EX_NOINPUT, "Invalid argument"),
	errno_init(ENFILE, EX_OSERR, "Too many open files in system"),
	errno_init(EMFILE, EX_OSERR, "Too many open files"),
	errno_init(ENOTTY, EX_PROTOCOL, "Inappropriate ioctl for device"),
	errno_init(ETXTBSY, EX_TEMPFAIL, "Text file busy"),
	errno_init(EFBIG, EX_NOINPUT, "File too large"),
	errno_init(ENOSPC, EX_CANTCREAT, "No space left on device"),
	errno_init(ESPIPE, EX_IOERR, "Illegal seek"),
	errno_init(EROFS, EX_NOPERM, "Read-only file system"),
	errno_init(EMLINK, EX_OSERR, "Too many links"),
	errno_init(EPIPE, EX_IOERR, "Broken pipe"),
	errno_init(EDOM, EX_DATAERR, "Numerical argument out of domain"),
	errno_init(ERANGE, EX_DATAERR, "Result too large"),
	errno_init(EAGAIN, EX_TEMPFAIL, "Resource temporarily unavailable"),
	errno_init(EINPROGRESS, EX_TEMPFAIL, "Operation now in progress"),
	errno_init(EALREADY, EX_TEMPFAIL, "Operation already in progress"),
	errno_init(ENOTSOCK, EX_PROTOCOL, "Socket operation on non-socket"),
	errno_init(EDESTADDRREQ, EX_PROTOCOL, "Destination address required"),
	errno_init(EMSGSIZE, EX_PROTOCOL, "Message too long"),
	errno_init(EPROTOTYPE, EX_PROTOCOL, "Protocol wrong type for socket"),
	errno_init(ENOPROTOOPT, EX_PROTOCOL, "Protocol not available"),
	errno_init(EPROTONOSUPPORT, EX_PROTOCOL, "Protocol not supported"),
#if defined(ESOCKTNOSUPPORT)
	errno_init(ESOCKTNOSUPPORT, EX_PROTOCOL, "Socket type not supported"),
#endif
	errno_init(ENOTSUP, EX_UNAVAILABLE, "Operation not supported"),
#if defined(EPFNOSUPPORT)
	errno_init(EPFNOSUPPORT, EX_PROTOCOL, "Protocol family not supported"),
#endif
	errno_init(EAFNOSUPPORT, EX_PROTOCOL,
		"Address family not supported by protocol family"
	),
	errno_init(EADDRINUSE, EX_PROTOCOL, "Address already in use"),
	errno_init(EADDRNOTAVAIL, EX_OSERR, "Can't assign requested address"),
	errno_init(ENETDOWN, EX_NOHOST, "Network is down"),
	errno_init(ENETUNREACH, EX_NOHOST, "Network is unreachable"),
	errno_init(ENETRESET, EX_NOHOST, "Network dropped connection on reset"),
	errno_init(ECONNABORTED, EX_OSERR, "Software caused connection abort"),
	errno_init(ECONNRESET, EX_PROTOCOL, "Connection reset by peer"),
	errno_init(ENOBUFS, EX_TEMPFAIL, "No buffer space available"),
	errno_init(EISCONN, EX_PROTOCOL, "Socket is already connected"),
	errno_init(ENOTCONN, EX_PROTOCOL, "Socket is not connected"),
#if defined(ESHUTDOWN)
	errno_init(ESHUTDOWN, EX_PROTOCOL, "Can't send after socket shutdown"),
	errno_init(ETOOMANYREFS, EX_PROTOCOL, "Too many references: can't splice"),
#endif
	errno_init(ETIMEDOUT, EX_TEMPFAIL, "Operation timed out"),
	errno_init(ECONNREFUSED, EX_PROTOCOL, "Connection refused"),
	errno_init(ELOOP, EX_DATAERR, "Too many levels of symbolic links"),
	errno_init(ENAMETOOLONG, EX_DATAERR, "File name too long"),
#if defined(EHOSTDOWN)
	errno_init(EHOSTDOWN, EX_NOHOST, "Host is down"),
#endif
	errno_init(EHOSTUNREACH, EX_NOHOST, "No route to host"),
	errno_init(ENOTEMPTY, EX_DATAERR, "Directory not empty"),
#if defined(EPROCLIM)
	errno_init(EPROCLIM, EX_TEMPFAIL, "Too many processes"),
	errno_init(EUSERS, EX_NOUSER, "Too many users"),
#endif
	errno_init(EDQUOT, EX_CANTCREAT, "Disc quota exceeded"),
	errno_init(ESTALE, EX_NOINPUT, "Stale NFS file handle"),
#if defined(EREMOTE)
	errno_init(EREMOTE, EX_DATAERR, "Too many levels of remote in path"),
	errno_init(EBADRPC, EX_PROTOCOL, "RPC struct is bad"),
	errno_init(ERPCMISMATCH, EX_PROTOCOL, "RPC version wrong"),
	errno_init(EPROGUNAVAIL, EX_PROTOCOL, "RPC prog. not avail"),
	errno_init(EPROGMISMATCH, EX_PROTOCOL, "Program version wrong"),
	errno_init(EPROCUNAVAIL, EX_PROTOCOL, "Bad procedure for program"),
#endif
	errno_init(ENOLCK, EX_OSERR, "No locks available"),
	errno_init(ENOSYS, EX_UNAVAILABLE, "Function not implemented"),
#if defined(EFTYPE)
	errno_init(EFTYPE, EX_DATAERR, "Inappropriate file type or format"),
	errno_init(EAUTH, EX_NOPERM, "Authentication error"),
	errno_init(ENEEDAUTH, EX_NOPERM, "Need authenticator"),
	errno_init(EPWROFF, EX_UNAVAILABLE, "Device power is off"),
	errno_init(EDEVERR, EX_UNAVAILABLE, "Device error, e.g. paper out"),
#endif
	errno_init(EOVERFLOW, EX_DATAERR,
		"Value too large to be stored in data type"
	),
#if defined(EBADEXEC)
	errno_init(EBADEXEC, EX_DATAERR, "Bad executable"),
	errno_init(EBADARCH, EX_DATAERR, "Bad CPU type in executable"),
	errno_init(ESHLIBVERS, EX_DATAERR, "Shared library version mismatch"),
	errno_init(EBADMACHO, EX_DATAERR, "Malformed Macho file"),
#endif
	errno_init(ECANCELED, EX_UNAVAILABLE, "Operation canceled"),
	errno_init(EIDRM, EX_UNAVAILABLE, "Identifier removed"),
	errno_init(ENOMSG, EX_UNAVAILABLE, "No message of desired type"),
	errno_init(EILSEQ, EX_DATAERR, "Illegal byte sequence"),
#if defined(ENOATTR)
	errno_init(ENOATTR, EX_UNAVAILABLE, "Attribute not found"),
#endif
	errno_init(EBADMSG, EX_PROTOCOL, "Bad message"),
	errno_init(EMULTIHOP, EX_UNAVAILABLE, "Reserved"),
	errno_init(ENODATA, EX_NOINPUT, "No message available on STREAM"),
	errno_init(ENOLINK, EX_UNAVAILABLE, "Reserved"),
	errno_init(ENOSR, EX_TEMPFAIL, "No STREAM resources"),
	errno_init(ENOSTR, EX_PROTOCOL, "Not a STREAM"),
	errno_init(EPROTO, EX_PROTOCOL, "Protocol error"),
	errno_init(ETIME, EX_TEMPFAIL, "STREAM ioctl timeout"),
#if defined(EOPNOTSUPP)
	errno_init(EOPNOTSUPP, EX_PROTOCOL, "Operation not supported on socket"),
#endif
	errno_init(ENOPOLICY, EX_UNAVAILABLE, "No such policy registered"),
#if defined(ENOTRECOVERABLE)
	errno_init(ENOTRECOVERABLE, EX_CONFIG, "State not recoverable"),
	errno_init(EOWNERDEAD, EX_NOHOST, "Previous owner died"),
#endif
#if defined(EQFULL)
	errno_init(EQFULL, EX_CANTCREAT, "Interface output queue is full"),
#endif
	errno_init(__EBOGUS, EX_UNAVAILABLE, "[invalid]"),
};

static const errno_desc_t _darwin_errors[] = {
	errno_init_np(ENOTENTITLED_NP, EX_NOPERM, "Requestor not entitled"),
	errno_init_np(ENOTPLATFORM_NP, EX_NOPERM, "Requestor not platform binary"),
	errno_init_np(EROOTLESS_NP, EX_NOPERM,
		"Operation disallowed by System Integrity Protection"
	),
	errno_init_np(ETAINTED_NP, EX_NOPERM,
		"Requestor is tainted and untrusthworthy"
	),
	errno_init_np(EQUARANTINE_NP, EX_NOPERM,
		"Operation not permitted on quarantined file"
	),
	errno_init_np(EBADUSER_NP, EX_NOINPUT, "Invalid username or identifier"),
	errno_init_np(EBADGROUP_NP, EX_NOINPUT, "Invalid group name or identifier"),
	errno_init_np(EOWNERSHIP_NP, EX_NOINPUT,
		"Ownership and/or permissions insufficiently restrictive"
	),
	errno_init_np(ENOOOO_NP, EX_PROTOCOL, "Out-of-order operation rejected"),
	errno_init_np(ENOTBUNDLE_NP, EX_NOINPUT, "Entity not a bundle"),
	errno_init_np(EBADBUNDLE_NP, EX_DATAERR, "Malformed bundle"),
	errno_init_np(EBADPATH_NP, EX_DATAERR, "Malformed path"),
	errno_init_np(EBADPLIST_NP, EX_DATAERR, "Malformed property list"),
	errno_init_np(EBADKEY_NP, EX_DATAERR, "Unrecognized key"),
	errno_init_np(EBADVAL_NP, EX_DATAERR, "Invalid or missing value for key"),
	errno_init_np(EBADSUBSYS_NP, EX_DATAERR,
		"Routine referenced an invalid subsystem"
	),
	errno_init_np(E2BIMPL_NP, EX_UNAVAILABLE, "Routine not yet implemented"),
	errno_init_np(EDEPRECATED_NP, EX_UNAVAILABLE, "Routine deprecated"),
	errno_init_np(EREMOVED_NP, EX_UNAVAILABLE, "Routine removed"),
	errno_init_np(EDROPPED_NP, EX_PROTOCOL, "Routine invocation dropped"),
	errno_init_np(EDEFERRED_NP, EX_TEMPFAIL, "Routine invocation deferred"),
	errno_init_np(EUSAGE_NP, EX_USAGE, "Bad command line usage"),
	errno_init_np(EUNKNOWN_NP, EX_UNAVAILABLE,
		"Unknown error from another subsystem"
	),
};

static const errno_desc_t _sysexits[] = {
	sysexit_init(EX_USAGE, "command line usage error"),
	sysexit_init(EX_DATAERR, "data format error"),
	sysexit_init(EX_NOINPUT, "cannot open input"),
	sysexit_init(EX_NOUSER, "addressee unknown"),
	sysexit_init(EX_NOHOST, "host name unknown"),
	sysexit_init(EX_UNAVAILABLE, "service unavailable"),
	sysexit_init(EX_SOFTWARE, "internal software error"),
	sysexit_init(EX_OSERR, "system error (e.g., can't fork)"),
	sysexit_init(EX_OSFILE, "critical OS file missing"),
	sysexit_init(EX_CANTCREAT, "can't create (user) output file"),
	sysexit_init(EX_IOERR, "input/output error"),
	sysexit_init(EX_TEMPFAIL, "temp failure"),
	sysexit_init(EX_PROTOCOL, "remote error in protocol"),
	sysexit_init(EX_NOPERM, "permission denied"),
	sysexit_init(EX_CONFIG, "configuration error"),
};

#pragma mark Utilities
static const errno_desc_t *
_find_error(int code)
{
	if (code < 0) {
		return &_negative_one;
	}

	if (code >= EBASE_NP && code <= __ELAST_NP) {
		return &_darwin_errors[code - EBASE_NP];
	}

	if (code >= 0 && code <= ELAST) {
		return &_posix_errors[code];
	}

	return &_posix_errors[__EBOGUS];
}

static const errno_desc_t *
_find_sysexit(int code)
{
	if (code == 0) {
		return &_zero;
	}

	if (code == EX_BADRECEIPT_NP) {
		return &_badreceipt;
	}

	if (code < EX__BASE || code > EX__MAX) {
		return &_sysexits[EX_UNAVAILABLE - EX__BASE];
	}

	return &_sysexits[code - EX__BASE];
}

static void
_writeflag(const char *humanflag, const char *sep, char *buff, size_t len,
		char **track_buff, size_t *track_sz)
{
	size_t offs = 0;

	if (*track_buff != buff) {
		offs = zsnprintf_np(*track_buff, *track_sz, "%s", sep);
		*track_buff += offs;
		*track_sz -= offs;
	}

	offs = zsnprintf_np(*track_buff, *track_sz, "%s", humanflag);
	*track_buff += offs;
	*track_sz -= offs;
}

#pragma mark API
int
sysexit_np(int code)
{
	const errno_desc_t *de = _find_error(code);
	return de->ed_sysexit;
}

const char *
strerror_np(int code)
{
	if (code >= 0 && code <= ELAST) {
		return strerror(code);
	}

	return _find_error(code)->ed_str;
}

const char *
strexit_np(int code)
{
	const errno_desc_t *de = _find_sysexit(code);
	return de->ed_str;
}

const char *
symerror_np(int code)
{
	const errno_desc_t *de = _find_error(code);
	return de->ed_sym;
}

const char *
symexit_np(int code)
{
	const errno_desc_t *de = _find_sysexit(code);
	return de->ed_sym;
}

char *
os_flagset_copy_string(const os_flagset_t flagset, uint64_t flags)
{
	size_t i = 0;
	const os_flag_t *fi = NULL;
	char buff[1024] = "[none]";
	char *cursor = buff;
	size_t left = sizeof(buff);

	while (i < OS_FLAGSET_COUNT && (fi = &flagset[i]) && fi->ohf_flag) {
		if (flags & fi->ohf_flag) {
			_writeflag(fi->ohf_human_flag, "|", buff, sizeof(buff),
					&cursor, &left);
		}
		i++;
	}

	return os_strdup(buff);
}
Commit	Line	Data
70ad1dc8 A	1	/*
	2	* Copyright (c) 2018 Apple Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
	6	* This file contains Original Code and/or Modifications of Original Code
	7	* as defined in and that are subject to the Apple Public Source License
	8	* Version 2.0 (the 'License'). You may not use this file except in
	9	* compliance with the License. Please obtain a copy of the License at
	10	* http://www.opensource.apple.com/apsl/ and read it before using this
	11	* file.
	12	*
	13	* The Original Code and all software distributed under the License are
	14	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	15	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	16	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	17	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	18	* Please see the License for the specific language governing rights and
	19	* limitations under the License.
	20	*
	21	* @APPLE_LICENSE_HEADER_END@
	22	*/
	23	#include "internal.h"
	24
	25	#pragma mark Definitions
	26	#define __ENEG_ONE (-1)
	27	#define __ENONE 0
	28	#define __EBOGUS (ELAST + 1)
	29
	30	#pragma mark Types
	31	OS_ENUM(errno_flags, uint32_t,
	32	EDF_INIT = 0,
	33	EDF_NONPOSIX = (1 << 0),
	34	EDF_SYSEXIT = (1 << 1),
	35	);
	36
	37	typedef struct _errno_desc {
	38	int ed_error;
	39	int ed_sysexit;
	40	errno_flags_t ed_flags;
	41	const char *ed_sym;
	42	const char *ed_str;
	43	} errno_desc_t;
	44
	45	#pragma mark Initializers
	46	#define errno_init(__err, __sysexit, __str) \
	47	[__err] = { \
	48	.ed_error = (__err), \
	49	.ed_sysexit = (__sysexit), \
	50	.ed_flags = 0, \
	51	.ed_sym = #__err, \
	52	.ed_str = (__str), \
	53	}
	54
	55	#define errno_init_np(__err, __sysexit, __str) \
	56	[__err - EBASE_NP] = { \
	57	.ed_error = (__err), \
	58	.ed_sysexit = (__sysexit), \
	59	.ed_flags = EDF_NONPOSIX, \
	60	.ed_sym = #__err, \
	61	.ed_str = (__str), \
	62	}
	63
	64	#define sysexit_init(__code, __str) \
65	[__code - EX__BASE] = { \
66	.ed_error = (__code), \
67	.ed_sysexit = (__code), \
68	.ed_flags = EDF_SYSEXIT, \
69	.ed_sym = #__code, \
70	.ed_str = (__str), \
71	}
72
73	#pragma mark Top-Level Statics
e1ee4b85 A	74	static const errno_desc_t _zero = {
	75	.ed_error = 0,
	76	.ed_sysexit = 0,
	77	.ed_flags = 0,
	78	.ed_sym = "0",
	79	.ed_str = "successful termination",
	80	};
	81
70ad1dc8 A	82	static const errno_desc_t _negative_one = {
	83	.ed_error = __ENEG_ONE,
	84	.ed_sysexit = EXIT_FAILURE,
	85	.ed_flags = 0,
	86	.ed_sym = "-1",
	87	.ed_str = "[return code instead of error]",
	88	};
	89
	90	static const errno_desc_t _badreceipt = {
	91	.ed_error = EX_BADRECEIPT_NP,
	92	.ed_sysexit = EX_BADRECEIPT_NP,
	93	.ed_flags = EDF_SYSEXIT,
	94	.ed_sym = "EX_BADRECEIPT_NP",
	95	.ed_str = "bad purchase receipt",
	96	};
	97
	98	static const errno_desc_t _posix_errors[] = {
	99	errno_init(__ENONE, EX_OK, "[no error]"),
	100	errno_init(EPERM, EX_NOPERM, "Operation not permitted"),
	101	errno_init(ENOENT, EX_NOINPUT, "No such file or directory"),
	102	errno_init(ESRCH, EX_IOERR, "No such process"),
	103	errno_init(EINTR, EX_OSERR, "Interrupted system call"),
	104	errno_init(EIO, EX_IOERR, "Input/output error"),
	105	errno_init(ENXIO, EX_NOINPUT, "Device not configured"),
	106	errno_init(E2BIG, EX_IOERR, "Argument list too long"),
	107	errno_init(ENOEXEC, EX_DATAERR, "Exec format error"),
	108	errno_init(EBADF, EX_OSERR, "Bad file descriptor"),
	109	errno_init(ECHILD, EX_IOERR, "No child processes"),
	110	errno_init(EDEADLK, EX_UNAVAILABLE, "Resource deadlock avoided"),
	111	errno_init(ENOMEM, EX_TEMPFAIL, "Cannot allocate memory"),
	112	errno_init(EACCES, EX_NOINPUT, "Permission denied"),
	113	errno_init(EFAULT, EX_OSERR, "Bad address"),
	114	#if defined(ENOTBLK)
	115	errno_init(ENOTBLK, EX_IOERR, "Block device required"),
	116	#endif
	117	errno_init(EBUSY, EX_TEMPFAIL, "Device / Resource busy"),
	118	errno_init(EEXIST, EX_CANTCREAT, "File exists"),
	119	errno_init(EXDEV, EX_UNAVAILABLE, "Cross-device link"),
	120	errno_init(ENODEV, EX_IOERR, "Operation not supported by device"),
	121	errno_init(ENOTDIR, EX_DATAERR, "Not a directory"),
	122	errno_init(EISDIR, EX_DATAERR, "Is a directory"),
	123	errno_init(EINVAL, EX_NOINPUT, "Invalid argument"),
	124	errno_init(ENFILE, EX_OSERR, "Too many open files in system"),
	125	errno_init(EMFILE, EX_OSERR, "Too many open files"),
	126	errno_init(ENOTTY, EX_PROTOCOL, "Inappropriate ioctl for device"),
	127	errno_init(ETXTBSY, EX_TEMPFAIL, "Text file busy"),
	128	errno_init(EFBIG, EX_NOINPUT, "File too large"),
	129	errno_init(ENOSPC, EX_CANTCREAT, "No space left on device"),
	130	errno_init(ESPIPE, EX_IOERR, "Illegal seek"),
	131	errno_init(EROFS, EX_NOPERM, "Read-only file system"),
	132	errno_init(EMLINK, EX_OSERR, "Too many links"),
	133	errno_init(EPIPE, EX_IOERR, "Broken pipe"),
	134	errno_init(EDOM, EX_DATAERR, "Numerical argument out of domain"),
	135	errno_init(ERANGE, EX_DATAERR, "Result too large"),
	136	errno_init(EAGAIN, EX_TEMPFAIL, "Resource temporarily unavailable"),
	137	errno_init(EINPROGRESS, EX_TEMPFAIL, "Operation now in progress"),
	138	errno_init(EALREADY, EX_TEMPFAIL, "Operation already in progress"),
	139	errno_init(ENOTSOCK, EX_PROTOCOL, "Socket operation on non-socket"),
	140	errno_init(EDESTADDRREQ, EX_PROTOCOL, "Destination address required"),
	141	errno_init(EMSGSIZE, EX_PROTOCOL, "Message too long"),
	142	errno_init(EPROTOTYPE, EX_PROTOCOL, "Protocol wrong type for socket"),
	143	errno_init(ENOPROTOOPT, EX_PROTOCOL, "Protocol not available"),
	144	errno_init(EPROTONOSUPPORT, EX_PROTOCOL, "Protocol not supported"),
	145	#if defined(ESOCKTNOSUPPORT)
146	errno_init(ESOCKTNOSUPPORT, EX_PROTOCOL, "Socket type not supported"),
147	#endif
148	errno_init(ENOTSUP, EX_UNAVAILABLE, "Operation not supported"),
149	#if defined(EPFNOSUPPORT)
150	errno_init(EPFNOSUPPORT, EX_PROTOCOL, "Protocol family not supported"),
151	#endif
152	errno_init(EAFNOSUPPORT, EX_PROTOCOL,
153	"Address family not supported by protocol family"
154	),
155	errno_init(EADDRINUSE, EX_PROTOCOL, "Address already in use"),
156	errno_init(EADDRNOTAVAIL, EX_OSERR, "Can't assign requested address"),
157	errno_init(ENETDOWN, EX_NOHOST, "Network is down"),
158	errno_init(ENETUNREACH, EX_NOHOST, "Network is unreachable"),
159	errno_init(ENETRESET, EX_NOHOST, "Network dropped connection on reset"),
160	errno_init(ECONNABORTED, EX_OSERR, "Software caused connection abort"),
161	errno_init(ECONNRESET, EX_PROTOCOL, "Connection reset by peer"),
162	errno_init(ENOBUFS, EX_TEMPFAIL, "No buffer space available"),
163	errno_init(EISCONN, EX_PROTOCOL, "Socket is already connected"),
164	errno_init(ENOTCONN, EX_PROTOCOL, "Socket is not connected"),
165	#if defined(ESHUTDOWN)
166	errno_init(ESHUTDOWN, EX_PROTOCOL, "Can't send after socket shutdown"),
167	errno_init(ETOOMANYREFS, EX_PROTOCOL, "Too many references: can't splice"),
168	#endif
169	errno_init(ETIMEDOUT, EX_TEMPFAIL, "Operation timed out"),
170	errno_init(ECONNREFUSED, EX_PROTOCOL, "Connection refused"),
171	errno_init(ELOOP, EX_DATAERR, "Too many levels of symbolic links"),
172	errno_init(ENAMETOOLONG, EX_DATAERR, "File name too long"),
173	#if defined(EHOSTDOWN)
174	errno_init(EHOSTDOWN, EX_NOHOST, "Host is down"),
175	#endif
176	errno_init(EHOSTUNREACH, EX_NOHOST, "No route to host"),
177	errno_init(ENOTEMPTY, EX_DATAERR, "Directory not empty"),
178	#if defined(EPROCLIM)
179	errno_init(EPROCLIM, EX_TEMPFAIL, "Too many processes"),
180	errno_init(EUSERS, EX_NOUSER, "Too many users"),
181	#endif
182	errno_init(EDQUOT, EX_CANTCREAT, "Disc quota exceeded"),
183	errno_init(ESTALE, EX_NOINPUT, "Stale NFS file handle"),
184	#if defined(EREMOTE)
185	errno_init(EREMOTE, EX_DATAERR, "Too many levels of remote in path"),
186	errno_init(EBADRPC, EX_PROTOCOL, "RPC struct is bad"),
187	errno_init(ERPCMISMATCH, EX_PROTOCOL, "RPC version wrong"),
188	errno_init(EPROGUNAVAIL, EX_PROTOCOL, "RPC prog. not avail"),
189	errno_init(EPROGMISMATCH, EX_PROTOCOL, "Program version wrong"),
190	errno_init(EPROCUNAVAIL, EX_PROTOCOL, "Bad procedure for program"),
191	#endif
192	errno_init(ENOLCK, EX_OSERR, "No locks available"),
193	errno_init(ENOSYS, EX_UNAVAILABLE, "Function not implemented"),
194	#if defined(EFTYPE)
195	errno_init(EFTYPE, EX_DATAERR, "Inappropriate file type or format"),
196	errno_init(EAUTH, EX_NOPERM, "Authentication error"),
197	errno_init(ENEEDAUTH, EX_NOPERM, "Need authenticator"),
198	errno_init(EPWROFF, EX_UNAVAILABLE, "Device power is off"),
199	errno_init(EDEVERR, EX_UNAVAILABLE, "Device error, e.g. paper out"),
200	#endif
201	errno_init(EOVERFLOW, EX_DATAERR,
202	"Value too large to be stored in data type"
203	),
204	#if defined(EBADEXEC)
205	errno_init(EBADEXEC, EX_DATAERR, "Bad executable"),
206	errno_init(EBADARCH, EX_DATAERR, "Bad CPU type in executable"),
207	errno_init(ESHLIBVERS, EX_DATAERR, "Shared library version mismatch"),
208	errno_init(EBADMACHO, EX_DATAERR, "Malformed Macho file"),
209	#endif
210	errno_init(ECANCELED, EX_UNAVAILABLE, "Operation canceled"),
211	errno_init(EIDRM, EX_UNAVAILABLE, "Identifier removed"),
212	errno_init(ENOMSG, EX_UNAVAILABLE, "No message of desired type"),
213	errno_init(EILSEQ, EX_DATAERR, "Illegal byte sequence"),
214	#if defined(ENOATTR)
215	errno_init(ENOATTR, EX_UNAVAILABLE, "Attribute not found"),
216	#endif
217	errno_init(EBADMSG, EX_PROTOCOL, "Bad message"),
218	errno_init(EMULTIHOP, EX_UNAVAILABLE, "Reserved"),
219	errno_init(ENODATA, EX_NOINPUT, "No message available on STREAM"),
220	errno_init(ENOLINK, EX_UNAVAILABLE, "Reserved"),
221	errno_init(ENOSR, EX_TEMPFAIL, "No STREAM resources"),
222	errno_init(ENOSTR, EX_PROTOCOL, "Not a STREAM"),
223	errno_init(EPROTO, EX_PROTOCOL, "Protocol error"),
224	errno_init(ETIME, EX_TEMPFAIL, "STREAM ioctl timeout"),
225	#if defined(EOPNOTSUPP)
226	errno_init(EOPNOTSUPP, EX_PROTOCOL, "Operation not supported on socket"),
227	#endif
228	errno_init(ENOPOLICY, EX_UNAVAILABLE, "No such policy registered"),
229	#if defined(ENOTRECOVERABLE)
230	errno_init(ENOTRECOVERABLE, EX_CONFIG, "State not recoverable"),
231	errno_init(EOWNERDEAD, EX_NOHOST, "Previous owner died"),
232	#endif
233	#if defined(EQFULL)
234	errno_init(EQFULL, EX_CANTCREAT, "Interface output queue is full"),
235	#endif
236	errno_init(__EBOGUS, EX_UNAVAILABLE, "[invalid]"),
237	};
238
239	static const errno_desc_t _darwin_errors[] = {
240	errno_init_np(ENOTENTITLED_NP, EX_NOPERM, "Requestor not entitled"),
241	errno_init_np(ENOTPLATFORM_NP, EX_NOPERM, "Requestor not platform binary"),
242	errno_init_np(EROOTLESS_NP, EX_NOPERM,
243	"Operation disallowed by System Integrity Protection"
244	),
245	errno_init_np(ETAINTED_NP, EX_NOPERM,
246	"Requestor is tainted and untrusthworthy"
247	),
248	errno_init_np(EQUARANTINE_NP, EX_NOPERM,
249	"Operation not permitted on quarantined file"
250	),
251	errno_init_np(EBADUSER_NP, EX_NOINPUT, "Invalid username or identifier"),
252	errno_init_np(EBADGROUP_NP, EX_NOINPUT, "Invalid group name or identifier"),
253	errno_init_np(EOWNERSHIP_NP, EX_NOINPUT,
254	"Ownership and/or permissions insufficiently restrictive"
255	),
256	errno_init_np(ENOOOO_NP, EX_PROTOCOL, "Out-of-order operation rejected"),
257	errno_init_np(ENOTBUNDLE_NP, EX_NOINPUT, "Entity not a bundle"),
258	errno_init_np(EBADBUNDLE_NP, EX_DATAERR, "Malformed bundle"),
259	errno_init_np(EBADPATH_NP, EX_DATAERR, "Malformed path"),
260	errno_init_np(EBADPLIST_NP, EX_DATAERR, "Malformed property list"),
261	errno_init_np(EBADKEY_NP, EX_DATAERR, "Unrecognized key"),
262	errno_init_np(EBADVAL_NP, EX_DATAERR, "Invalid or missing value for key"),
263	errno_init_np(EBADSUBSYS_NP, EX_DATAERR,
264	"Routine referenced an invalid subsystem"
265	),
266	errno_init_np(E2BIMPL_NP, EX_UNAVAILABLE, "Routine not yet implemented"),
267	errno_init_np(EDEPRECATED_NP, EX_UNAVAILABLE, "Routine deprecated"),
268	errno_init_np(EREMOVED_NP, EX_UNAVAILABLE, "Routine removed"),
269	errno_init_np(EDROPPED_NP, EX_PROTOCOL, "Routine invocation dropped"),
270	errno_init_np(EDEFERRED_NP, EX_TEMPFAIL, "Routine invocation deferred"),
271	errno_init_np(EUSAGE_NP, EX_USAGE, "Bad command line usage"),
272	errno_init_np(EUNKNOWN_NP, EX_UNAVAILABLE,
273	"Unknown error from another subsystem"
274	),
275	};
276
277	static const errno_desc_t _sysexits[] = {
278	sysexit_init(EX_USAGE, "command line usage error"),
279	sysexit_init(EX_DATAERR, "data format error"),
280	sysexit_init(EX_NOINPUT, "cannot open input"),
281	sysexit_init(EX_NOUSER, "addressee unknown"),
282	sysexit_init(EX_NOHOST, "host name unknown"),
283	sysexit_init(EX_UNAVAILABLE, "service unavailable"),
284	sysexit_init(EX_SOFTWARE, "internal software error"),
285	sysexit_init(EX_OSERR, "system error (e.g., can't fork)"),
286	sysexit_init(EX_OSFILE, "critical OS file missing"),
287	sysexit_init(EX_CANTCREAT, "can't create (user) output file"),
288	sysexit_init(EX_IOERR, "input/output error"),
289	sysexit_init(EX_TEMPFAIL, "temp failure"),
290	sysexit_init(EX_PROTOCOL, "remote error in protocol"),
291	sysexit_init(EX_NOPERM, "permission denied"),
292	sysexit_init(EX_CONFIG, "configuration error"),
293	};
294
295	#pragma mark Utilities
296	static const errno_desc_t *
297	_find_error(int code)
298	{
299	if (code < 0) {
300	return &_negative_one;
301	}
302
303	if (code >= EBASE_NP && code <= __ELAST_NP) {
304	return &_darwin_errors[code - EBASE_NP];
305	}
306
307	if (code >= 0 && code <= ELAST) {
308	return &_posix_errors[code];
309	}
310
311	return &_posix_errors[__EBOGUS];
312	}
313
314	static const errno_desc_t *
315	_find_sysexit(int code)
316	{
e1ee4b85 A	317	if (code == 0) {
	318	return &_zero;
	319	}
	320
70ad1dc8 A	321	if (code == EX_BADRECEIPT_NP) {
	322	return &_badreceipt;
	323	}
	324
	325	if (code < EX__BASE \|\| code > EX__MAX) {
	326	return &_sysexits[EX_UNAVAILABLE - EX__BASE];
	327	}
	328
	329	return &_sysexits[code - EX__BASE];
	330	}
	331
	332	static void
	333	_writeflag(const char humanflag, const char sep, char *buff, size_t len,
	334	char *track_buff, size_t track_sz)
	335	{
	336	size_t offs = 0;
	337
	338	if (*track_buff != buff) {
	339	offs = zsnprintf_np(track_buff, track_sz, "%s", sep);
	340	*track_buff += offs;
	341	*track_sz -= offs;
	342	}
	343
	344	offs = zsnprintf_np(track_buff, track_sz, "%s", humanflag);
	345	*track_buff += offs;
	346	*track_sz -= offs;
	347	}
	348
	349	#pragma mark API
	350	int
	351	sysexit_np(int code)
	352	{
	353	const errno_desc_t *de = _find_error(code);
	354	return de->ed_sysexit;
	355	}
	356
	357	const char *
	358	strerror_np(int code)
	359	{
	360	if (code >= 0 && code <= ELAST) {
	361	return strerror(code);
	362	}
	363
	364	return _find_error(code)->ed_str;
	365	}
	366
e1ee4b85 A	367	const char *
	368	strexit_np(int code)
	369	{
	370	const errno_desc_t *de = _find_sysexit(code);
	371	return de->ed_str;
	372	}
	373
70ad1dc8 A	374	const char *
	375	symerror_np(int code)
	376	{
e1ee4b85	377	const errno_desc_t *de = _find_error(code);
70ad1dc8 A	378	return de->ed_sym;
	379	}
	380
	381	const char *
	382	symexit_np(int code)
	383	{
	384	const errno_desc_t *de = _find_sysexit(code);
	385	return de->ed_sym;
	386	}
	387
	388	char *
	389	os_flagset_copy_string(const os_flagset_t flagset, uint64_t flags)
	390	{
	391	size_t i = 0;
	392	const os_flag_t *fi = NULL;
	393	char buff[1024] = "[none]";
	394	char *cursor = buff;
	395	size_t left = sizeof(buff);
	396
	397	while (i < OS_FLAGSET_COUNT && (fi = &flagset[i]) && fi->ohf_flag) {
	398	if (flags & fi->ohf_flag) {
	399	_writeflag(fi->ohf_human_flag, "\|", buff, sizeof(buff),
	400	&cursor, &left);
	401	}
	402	i++;
	403	}
	404
	405	return os_strdup(buff);
	406	}
	407