libdarwin/string.c

   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
  74 static const errno_desc_t _negative_one = {
  75         .ed_error = __ENEG_ONE,
  76         .ed_sysexit = EXIT_FAILURE,
  77         .ed_flags = 0,
  78         .ed_sym = "-1",
  79         .ed_str = "[return code instead of error]",
  80 };
  81
  82 static const errno_desc_t _badreceipt = {
  83         .ed_error = EX_BADRECEIPT_NP,
  84         .ed_sysexit = EX_BADRECEIPT_NP,
  85         .ed_flags = EDF_SYSEXIT,
  86         .ed_sym = "EX_BADRECEIPT_NP",
  87         .ed_str = "bad purchase receipt",
  88 };
  89
  90 static const errno_desc_t _posix_errors[] = {
  91         errno_init(__ENONE, EX_OK, "[no error]"),
  92         errno_init(EPERM, EX_NOPERM, "Operation not permitted"),
  93         errno_init(ENOENT, EX_NOINPUT, "No such file or directory"),
  94         errno_init(ESRCH, EX_IOERR, "No such process"),
  95         errno_init(EINTR, EX_OSERR, "Interrupted system call"),
  96         errno_init(EIO, EX_IOERR, "Input/output error"),
  97         errno_init(ENXIO, EX_NOINPUT, "Device not configured"),
  98         errno_init(E2BIG, EX_IOERR, "Argument list too long"),
  99         errno_init(ENOEXEC, EX_DATAERR, "Exec format error"),
 100         errno_init(EBADF, EX_OSERR, "Bad file descriptor"),
 101         errno_init(ECHILD, EX_IOERR, "No child processes"),
 102         errno_init(EDEADLK, EX_UNAVAILABLE, "Resource deadlock avoided"),
 103         errno_init(ENOMEM, EX_TEMPFAIL, "Cannot allocate memory"),
 104         errno_init(EACCES, EX_NOINPUT, "Permission denied"),
 105         errno_init(EFAULT, EX_OSERR, "Bad address"),
 106 #if defined(ENOTBLK)
 107         errno_init(ENOTBLK, EX_IOERR, "Block device required"),
 108 #endif
 109         errno_init(EBUSY, EX_TEMPFAIL, "Device / Resource busy"),
 110         errno_init(EEXIST, EX_CANTCREAT, "File exists"),
 111         errno_init(EXDEV, EX_UNAVAILABLE, "Cross-device link"),
 112         errno_init(ENODEV, EX_IOERR, "Operation not supported by device"),
 113         errno_init(ENOTDIR, EX_DATAERR, "Not a directory"),
 114         errno_init(EISDIR, EX_DATAERR, "Is a directory"),
 115         errno_init(EINVAL, EX_NOINPUT, "Invalid argument"),
 116         errno_init(ENFILE, EX_OSERR, "Too many open files in system"),
 117         errno_init(EMFILE, EX_OSERR, "Too many open files"),
 118         errno_init(ENOTTY, EX_PROTOCOL, "Inappropriate ioctl for device"),
 119         errno_init(ETXTBSY, EX_TEMPFAIL, "Text file busy"),
 120         errno_init(EFBIG, EX_NOINPUT, "File too large"),
 121         errno_init(ENOSPC, EX_CANTCREAT, "No space left on device"),
 122         errno_init(ESPIPE, EX_IOERR, "Illegal seek"),
 123         errno_init(EROFS, EX_NOPERM, "Read-only file system"),
 124         errno_init(EMLINK, EX_OSERR, "Too many links"),
 125         errno_init(EPIPE, EX_IOERR, "Broken pipe"),
 126         errno_init(EDOM, EX_DATAERR, "Numerical argument out of domain"),
 127         errno_init(ERANGE, EX_DATAERR, "Result too large"),
 128         errno_init(EAGAIN, EX_TEMPFAIL, "Resource temporarily unavailable"),
 129         errno_init(EINPROGRESS, EX_TEMPFAIL, "Operation now in progress"),
 130         errno_init(EALREADY, EX_TEMPFAIL, "Operation already in progress"),
 131         errno_init(ENOTSOCK, EX_PROTOCOL, "Socket operation on non-socket"),
 132         errno_init(EDESTADDRREQ, EX_PROTOCOL, "Destination address required"),
 133         errno_init(EMSGSIZE, EX_PROTOCOL, "Message too long"),
 134         errno_init(EPROTOTYPE, EX_PROTOCOL, "Protocol wrong type for socket"),
 135         errno_init(ENOPROTOOPT, EX_PROTOCOL, "Protocol not available"),
 136         errno_init(EPROTONOSUPPORT, EX_PROTOCOL, "Protocol not supported"),
 137 #if defined(ESOCKTNOSUPPORT)
 138         errno_init(ESOCKTNOSUPPORT, EX_PROTOCOL, "Socket type not supported"),
 139 #endif
 140         errno_init(ENOTSUP, EX_UNAVAILABLE, "Operation not supported"),
 141 #if defined(EPFNOSUPPORT)
 142         errno_init(EPFNOSUPPORT, EX_PROTOCOL, "Protocol family not supported"),
 143 #endif
 144         errno_init(EAFNOSUPPORT, EX_PROTOCOL,
 145                 "Address family not supported by protocol family"
 146         ),
 147         errno_init(EADDRINUSE, EX_PROTOCOL, "Address already in use"),
 148         errno_init(EADDRNOTAVAIL, EX_OSERR, "Can't assign requested address"),
 149         errno_init(ENETDOWN, EX_NOHOST, "Network is down"),
 150         errno_init(ENETUNREACH, EX_NOHOST, "Network is unreachable"),
 151         errno_init(ENETRESET, EX_NOHOST, "Network dropped connection on reset"),
 152         errno_init(ECONNABORTED, EX_OSERR, "Software caused connection abort"),
 153         errno_init(ECONNRESET, EX_PROTOCOL, "Connection reset by peer"),
 154         errno_init(ENOBUFS, EX_TEMPFAIL, "No buffer space available"),
 155         errno_init(EISCONN, EX_PROTOCOL, "Socket is already connected"),
 156         errno_init(ENOTCONN, EX_PROTOCOL, "Socket is not connected"),
 157 #if defined(ESHUTDOWN)
 158         errno_init(ESHUTDOWN, EX_PROTOCOL, "Can't send after socket shutdown"),
 159         errno_init(ETOOMANYREFS, EX_PROTOCOL, "Too many references: can't splice"),
 160 #endif
 161         errno_init(ETIMEDOUT, EX_TEMPFAIL, "Operation timed out"),
 162         errno_init(ECONNREFUSED, EX_PROTOCOL, "Connection refused"),
 163         errno_init(ELOOP, EX_DATAERR, "Too many levels of symbolic links"),
 164         errno_init(ENAMETOOLONG, EX_DATAERR, "File name too long"),
 165 #if defined(EHOSTDOWN)
 166         errno_init(EHOSTDOWN, EX_NOHOST, "Host is down"),
 167 #endif
 168         errno_init(EHOSTUNREACH, EX_NOHOST, "No route to host"),
 169         errno_init(ENOTEMPTY, EX_DATAERR, "Directory not empty"),
 170 #if defined(EPROCLIM)
 171         errno_init(EPROCLIM, EX_TEMPFAIL, "Too many processes"),
 172         errno_init(EUSERS, EX_NOUSER, "Too many users"),
 173 #endif
 174         errno_init(EDQUOT, EX_CANTCREAT, "Disc quota exceeded"),
 175         errno_init(ESTALE, EX_NOINPUT, "Stale NFS file handle"),
 176 #if defined(EREMOTE)
 177         errno_init(EREMOTE, EX_DATAERR, "Too many levels of remote in path"),
 178         errno_init(EBADRPC, EX_PROTOCOL, "RPC struct is bad"),
 179         errno_init(ERPCMISMATCH, EX_PROTOCOL, "RPC version wrong"),
 180         errno_init(EPROGUNAVAIL, EX_PROTOCOL, "RPC prog. not avail"),
 181         errno_init(EPROGMISMATCH, EX_PROTOCOL, "Program version wrong"),
 182         errno_init(EPROCUNAVAIL, EX_PROTOCOL, "Bad procedure for program"),
 183 #endif
 184         errno_init(ENOLCK, EX_OSERR, "No locks available"),
 185         errno_init(ENOSYS, EX_UNAVAILABLE, "Function not implemented"),
 186 #if defined(EFTYPE)
 187         errno_init(EFTYPE, EX_DATAERR, "Inappropriate file type or format"),
 188         errno_init(EAUTH, EX_NOPERM, "Authentication error"),
 189         errno_init(ENEEDAUTH, EX_NOPERM, "Need authenticator"),
 190         errno_init(EPWROFF, EX_UNAVAILABLE, "Device power is off"),
 191         errno_init(EDEVERR, EX_UNAVAILABLE, "Device error, e.g. paper out"),
 192 #endif
 193         errno_init(EOVERFLOW, EX_DATAERR,
 194                 "Value too large to be stored in data type"
 195         ),
 196 #if defined(EBADEXEC)
 197         errno_init(EBADEXEC, EX_DATAERR, "Bad executable"),
 198         errno_init(EBADARCH, EX_DATAERR, "Bad CPU type in executable"),
 199         errno_init(ESHLIBVERS, EX_DATAERR, "Shared library version mismatch"),
 200         errno_init(EBADMACHO, EX_DATAERR, "Malformed Macho file"),
 201 #endif
 202         errno_init(ECANCELED, EX_UNAVAILABLE, "Operation canceled"),
 203         errno_init(EIDRM, EX_UNAVAILABLE, "Identifier removed"),
 204         errno_init(ENOMSG, EX_UNAVAILABLE, "No message of desired type"),
 205         errno_init(EILSEQ, EX_DATAERR, "Illegal byte sequence"),
 206 #if defined(ENOATTR)
 207         errno_init(ENOATTR, EX_UNAVAILABLE, "Attribute not found"),
 208 #endif
 209         errno_init(EBADMSG, EX_PROTOCOL, "Bad message"),
 210         errno_init(EMULTIHOP, EX_UNAVAILABLE, "Reserved"),
 211         errno_init(ENODATA, EX_NOINPUT, "No message available on STREAM"),
 212         errno_init(ENOLINK, EX_UNAVAILABLE, "Reserved"),
 213         errno_init(ENOSR, EX_TEMPFAIL, "No STREAM resources"),
 214         errno_init(ENOSTR, EX_PROTOCOL, "Not a STREAM"),
 215         errno_init(EPROTO, EX_PROTOCOL, "Protocol error"),
 216         errno_init(ETIME, EX_TEMPFAIL, "STREAM ioctl timeout"),
 217 #if defined(EOPNOTSUPP)
 218         errno_init(EOPNOTSUPP, EX_PROTOCOL, "Operation not supported on socket"),
 219 #endif
 220         errno_init(ENOPOLICY, EX_UNAVAILABLE, "No such policy registered"),
 221 #if defined(ENOTRECOVERABLE)
 222         errno_init(ENOTRECOVERABLE, EX_CONFIG, "State not recoverable"),
 223         errno_init(EOWNERDEAD, EX_NOHOST, "Previous owner died"),
 224 #endif
 225 #if defined(EQFULL)
 226         errno_init(EQFULL, EX_CANTCREAT, "Interface output queue is full"),
 227 #endif
 228         errno_init(__EBOGUS, EX_UNAVAILABLE, "[invalid]"),
 229 };
 230
 231 static const errno_desc_t _darwin_errors[] = {
 232         errno_init_np(ENOTENTITLED_NP, EX_NOPERM, "Requestor not entitled"),
 233         errno_init_np(ENOTPLATFORM_NP, EX_NOPERM, "Requestor not platform binary"),
 234         errno_init_np(EROOTLESS_NP, EX_NOPERM,
 235                 "Operation disallowed by System Integrity Protection"
 236         ),
 237         errno_init_np(ETAINTED_NP, EX_NOPERM,
 238                 "Requestor is tainted and untrusthworthy"
 239         ),
 240         errno_init_np(EQUARANTINE_NP, EX_NOPERM,
 241                 "Operation not permitted on quarantined file"
 242         ),
 243         errno_init_np(EBADUSER_NP, EX_NOINPUT, "Invalid username or identifier"),
 244         errno_init_np(EBADGROUP_NP, EX_NOINPUT, "Invalid group name or identifier"),
 245         errno_init_np(EOWNERSHIP_NP, EX_NOINPUT,
 246                 "Ownership and/or permissions insufficiently restrictive"
 247         ),
 248         errno_init_np(ENOOOO_NP, EX_PROTOCOL, "Out-of-order operation rejected"),
 249         errno_init_np(ENOTBUNDLE_NP, EX_NOINPUT, "Entity not a bundle"),
 250         errno_init_np(EBADBUNDLE_NP, EX_DATAERR, "Malformed bundle"),
 251         errno_init_np(EBADPATH_NP, EX_DATAERR, "Malformed path"),
 252         errno_init_np(EBADPLIST_NP, EX_DATAERR, "Malformed property list"),
 253         errno_init_np(EBADKEY_NP, EX_DATAERR, "Unrecognized key"),
 254         errno_init_np(EBADVAL_NP, EX_DATAERR, "Invalid or missing value for key"),
 255         errno_init_np(EBADSUBSYS_NP, EX_DATAERR,
 256                 "Routine referenced an invalid subsystem"
 257         ),
 258         errno_init_np(E2BIMPL_NP, EX_UNAVAILABLE, "Routine not yet implemented"),
 259         errno_init_np(EDEPRECATED_NP, EX_UNAVAILABLE, "Routine deprecated"),
 260         errno_init_np(EREMOVED_NP, EX_UNAVAILABLE, "Routine removed"),
 261         errno_init_np(EDROPPED_NP, EX_PROTOCOL, "Routine invocation dropped"),
 262         errno_init_np(EDEFERRED_NP, EX_TEMPFAIL, "Routine invocation deferred"),
 263         errno_init_np(EUSAGE_NP, EX_USAGE, "Bad command line usage"),
 264         errno_init_np(EUNKNOWN_NP, EX_UNAVAILABLE,
 265                 "Unknown error from another subsystem"
 266         ),
 267 };
 268
 269 static const errno_desc_t _sysexits[] = {
 270         sysexit_init(EX_USAGE, "command line usage error"),
 271         sysexit_init(EX_DATAERR, "data format error"),
 272         sysexit_init(EX_NOINPUT, "cannot open input"),
 273         sysexit_init(EX_NOUSER, "addressee unknown"),
 274         sysexit_init(EX_NOHOST, "host name unknown"),
 275         sysexit_init(EX_UNAVAILABLE, "service unavailable"),
 276         sysexit_init(EX_SOFTWARE, "internal software error"),
 277         sysexit_init(EX_OSERR, "system error (e.g., can't fork)"),
 278         sysexit_init(EX_OSFILE, "critical OS file missing"),
 279         sysexit_init(EX_CANTCREAT, "can't create (user) output file"),
 280         sysexit_init(EX_IOERR, "input/output error"),
 281         sysexit_init(EX_TEMPFAIL, "temp failure"),
 282         sysexit_init(EX_PROTOCOL, "remote error in protocol"),
 283         sysexit_init(EX_NOPERM, "permission denied"),
 284         sysexit_init(EX_CONFIG, "configuration error"),
 285 };
 286
 287 #pragma mark Utilities
 288 static const errno_desc_t *
 289 _find_error(int code)
 290 {
 291         if (code < 0) {
 292                 return &_negative_one;
 293         }
 294
 295         if (code >= EBASE_NP && code <= __ELAST_NP) {
 296                 return &_darwin_errors[code - EBASE_NP];
 297         }
 298
 299         if (code >= 0 && code <= ELAST) {
 300                 return &_posix_errors[code];
 301         }
 302
 303         return &_posix_errors[__EBOGUS];
 304 }
 305
 306 static const errno_desc_t *
 307 _find_sysexit(int code)
 308 {
 309         if (code == EX_BADRECEIPT_NP) {
 310                 return &_badreceipt;
 311         }
 312
 313         if (code < EX__BASE || code > EX__MAX) {
 314                 return &_sysexits[EX_UNAVAILABLE - EX__BASE];
 315         }
 316
 317         return &_sysexits[code - EX__BASE];
 318 }
 319
 320 static void
 321 _writeflag(const char *humanflag, const char *sep, char *buff, size_t len,
 322                 char **track_buff, size_t *track_sz)
 323 {
 324         size_t offs = 0;
 325
 326         if (*track_buff != buff) {
 327                 offs = zsnprintf_np(*track_buff, *track_sz, "%s", sep);
 328                 *track_buff += offs;
 329                 *track_sz -= offs;
 330         }
 331
 332         offs = zsnprintf_np(*track_buff, *track_sz, "%s", humanflag);
 333         *track_buff += offs;
 334         *track_sz -= offs;
 335 }
 336
 337 #pragma mark API
 338 int
 339 sysexit_np(int code)
 340 {
 341         const errno_desc_t *de = _find_error(code);
 342         return de->ed_sysexit;
 343 }
 344
 345 const char *
 346 strerror_np(int code)
 347 {
 348         if (code >= 0 && code <= ELAST) {
 349                 return strerror(code);
 350         }
 351
 352         return _find_error(code)->ed_str;
 353 }
 354
 355 const char *
 356 symerror_np(int code)
 357 {
 358         const errno_desc_t *de = _find_error(code);;
 359         return de->ed_sym;
 360 }
 361
 362 const char *
 363 symexit_np(int code)
 364 {
 365         const errno_desc_t *de = _find_sysexit(code);
 366         return de->ed_sym;
 367 }
 368
 369 char *
 370 os_flagset_copy_string(const os_flagset_t flagset, uint64_t flags)
 371 {
 372         size_t i = 0;
 373         const os_flag_t *fi = NULL;
 374         char buff[1024] = "[none]";
 375         char *cursor = buff;
 376         size_t left = sizeof(buff);
 377
 378         while (i < OS_FLAGSET_COUNT && (fi = &flagset[i]) && fi->ohf_flag) {
 379                 if (flags & fi->ohf_flag) {
 380                         _writeflag(fi->ohf_human_flag, "|", buff, sizeof(buff),
 381                                         &cursor, &left);
 382                 }
 383                 i++;
 384         }
 385
 386         return os_strdup(buff);
 387 }
 388