1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 
  22 /*
  23  * Copyright (c) 1992, 2010, Oracle and/or its affiliates. All rights reserved.
  24  */
  25 
  26 /*
  27  * Implementation of all external interfaces between ld.so.1 and libc.
  28  *
  29  * This file started as a set of routines that provided synchronization and
  30  * locking operations using calls to libthread.  libthread has merged with libc
  31  * under the Unified Process Model (UPM), and things have gotten a lot simpler.
  32  * This file continues to establish and redirect various events within ld.so.1
  33  * to interfaces within libc.
  34  *
  35  * Until libc is loaded and relocated, any external interfaces are captured
  36  * locally.  Each link-map list maintains its own set of external vectors, as
  37  * each link-map list typically provides its own libc.  Although this per-link-
  38  * map list vectoring provides a degree of flexibility, there is a protocol
  39  * expected when calling various libc interfaces.
  40  *
  41  * i.   Any new alternative link-map list should call CI_THRINIT, and then call
  42  *      CI_TLS_MODADD to register any TLS for each object of that link-map list
  43  *      (this item is labeled i. as auditors can be the first objects loaded,
  44  *      and they exist on their own lik-map list).
  45  *
  46  * ii.  For the primary link-map list, CI_TLS_STATMOD must be called first to
  47  *      register any static TLS.  This routine is called regardless of there
  48  *      being any TLS, as this routine also establishes the link-map list as the
  49  *      primary list and fixes the association of uberdata).  CI_THRINIT should
  50  *      then be called.
  51  *
  52  * iii. Any objects added to an existing link-map list (primary or alternative)
  53  *      should call CI_TLS_MODADD to register any additional TLS.
  54  *
  55  * These events are established by:
  56  *
  57  * i.   Typically, libc is loaded as part of the primary dependencies of any
  58  *      link-map list (since the Unified Process Model (UPM), libc can't be
  59  *      lazily loaded).  To minimize the possibility of loading and registering
  60  *      objects, and then tearing them down (because of a relocation error),
  61  *      external vectors are established as part of load_completion().  This
  62  *      routine is called on completion of any operation that can cause objects
  63  *      to be loaded.  This point of control insures the objects have been fully
  64  *      analyzed and relocated, and moved to their controlling link-map list.
  65  *      The external vectors are established prior to any .inits being fired.
  66  *
  67  * ii.  Calls to CI_THRINIT, and CI_TLS_MODADD also occur as part of
  68  *      load_completion().  CI_THRINIT is only called once for each link-map
  69  *      control list.
  70  *
  71  * iii. Calls to CI_TLS_STATMOD, and CI_THRINIT occur for the primary link-map
  72  *      list in the final stages of setup().
  73  *
  74  * The interfaces provide by libc can be divided into two families.  The first
  75  * family consists of those interfaces that should be called from the link-map
  76  * list.  It's possible that these interfaces convey state concerning the
  77  * link-map list they are part of:
  78  *
  79  *      CI_ATEXIT
  80  *      CI TLS_MODADD
  81  *      CI_TLS_MODREM
  82  *      CI_TLS_STATMOD
  83  *      CI_THRINIT
  84  *
  85  * The second family are global in nature, that is, the link-map list from
  86  * which they are called provides no state information.  In fact, for
  87  * CI_BIND_GUARD, the calling link-map isn't even known.  The link-map can only
  88  * be deduced after ld.so.1's global lock has been obtained.  Therefore, the
  89  * following interfaces are also maintained as global:
  90  *
  91  *      CI_LCMESSAGES
  92  *      CI_BIND_GUARD
  93  *      CI_BIND_CLEAR
  94  *      CI_THR_SELF
  95  *
  96  * Note, it is possible that these global interfaces are obtained from an
  97  * alternative link-map list that gets torn down because of a processing
  98  * failure (unlikely, because the link-map list components must be analyzed
  99  * and relocated prior to load_completion(), but perhaps the tear down is still
 100  * a possibility).  Thus the global interfaces may have to be replaced.  Once
 101  * the interfaces have been obtained from the primary link-map, they can
 102  * remain fixed, as the primary link-map isn't going to go anywhere.
 103  *
 104  * The last wrinkle in the puzzle is what happens if an alternative link-map
 105  * is loaded with no libc dependency?  In this case, the alternative objects
 106  * can not call CI_THRINIT, can not be allowed to use TLS, and will not receive
 107  * any atexit processing.
 108  *
 109  * The history of these external interfaces is defined by their version:
 110  *
 111  * TI_VERSION == 1
 112  *      Under this model libthread provided rw_rwlock/rw_unlock, through which
 113  *      all rt_mutex_lock/rt_mutex_unlock calls were vectored.
 114  *      Under libc/libthread these interfaces provided _sigon/_sigoff (unlike
 115  *      lwp/libthread that provided signal blocking via bind_guard/bind_clear).
 116  *
 117  * TI_VERSION == 2
 118  *      Under this model only libthreads bind_guard/bind_clear and thr_self
 119  *      interfaces were used.  Both libthreads blocked signals under the
 120  *      bind_guard/bind_clear interfaces.   Lower level locking is derived
 121  *      from internally bound _lwp_ interfaces.  This removes recursive
 122  *      problems encountered when obtaining locking interfaces from libthread.
 123  *      The use of mutexes over reader/writer locks also enables the use of
 124  *      condition variables for controlling thread concurrency (allows access
 125  *      to objects only after their .init has completed).
 126  *
 127  * NOTE, the TI_VERSION indicated the ti_interface version number, where the
 128  * ti_interface was a large vector of functions passed to both libc (to override
 129  * the thread stub interfaces) and ld.so.1.  ld.so.1 used only a small subset of
 130  * these interfaces.
 131  *
 132  * CI_VERSION == 1
 133  *      Introduced with CI_VERSION & CI_ATEXIT
 134  *
 135  * CI_VERSION == 2 (Solaris 8 update 2).
 136  *      Added support for CI_LCMESSAGES
 137  *
 138  * CI_VERSION == 3 (Solaris 9).
 139  *      Added the following versions to the CI table:
 140  *
 141  *              CI_BIND_GUARD, CI_BIND_CLEAR, CI_THR_SELF
 142  *              CI_TLS_MODADD, CI_TLS_MOD_REMOVE, CI_TLS_STATMOD
 143  *
 144  *      This version introduced the DT_SUNW_RTLDINFO structure as a mechanism
 145  *      to handshake with ld.so.1.
 146  *
 147  * CI_VERSION == 4 (Solaris 10).
 148  *      Added the CI_THRINIT handshake as part of the libc/libthread unified
 149  *      process model.  libc now initializes the current thread pointer from
 150  *      this interface (and no longer relies on the INITFIRST flag - which
 151  *      others have started to camp out on).
 152  *
 153  * CI_VERSION == 5 (Solaris 11).
 154  *      Use of "protected" references within libc, so that symbols are
 155  *      pre-bound, and don't require ld.so.1 binding.  This implementation
 156  *      protects libc's critical regions from being vectored to auditors.
 157  *
 158  * CI_VERSION == 6 (Solaris 11).
 159  *      Added the CI_CRITICAL handshake, to allow "mem*" family to be reexposed
 160  *      as "global", and thus be redirected to auxiliary filters.
 161  *
 162  * Release summary:
 163  *
 164  *      Solaris 8       CI_ATEXIT via _ld_libc()
 165  *                      TI_* via _ld_concurrency()
 166  *
 167  *      Solaris 9       CI_ATEXIT and CI_LCMESSAGES via _ld_libc()
 168  *                      CI_* via RTLDINFO and _ld_libc()  - new libthread
 169  *                      TI_* via _ld_concurrency()  - old libthread
 170  *
 171  *      Solaris 10      CI_ATEXIT and CI_LCMESSAGES via _ld_libc()
 172  *                      CI_* via RTLDINFO and _ld_libc()  - new libthread
 173  */
 174 
 175 #include <sys/debug.h>
 176 #include <synch.h>
 177 #include <signal.h>
 178 #include <thread.h>
 179 #include <synch.h>
 180 #include <strings.h>
 181 #include <stdio.h>
 182 #include <debug.h>
 183 #include <libc_int.h>
 184 #include "_elf.h"
 185 #include "_rtld.h"
 186 
 187 /*
 188  * This interface provides the unified process model communication between
 189  * ld.so.1 and libc.  This interface can be called a number of times:
 190  *
 191  *   -  Initially, this interface is called to process RTLDINFO.  This data
 192  *      structure is typically provided by libc, and contains the address of
 193  *      libc interfaces that must be called to initialize threads information.
 194  *
 195  *   -  _ld_libc(), this interface can also be called by libc at process
 196  *      initialization, after libc has been loaded and relocated, but before
 197  *      control has been passed to any user code (.init's or main()).  This
 198  *      call provides additional libc interface information that ld.so.1 must
 199  *      call during process execution.
 200  *
 201  *   -  _ld_libc() can also be called by libc during process execution to
 202  *      re-establish interfaces such as the locale.
 203  */
 204 static void
 205 get_lcinterface(Rt_map *lmp, Lc_interface *funcs)
 206 {
 207         int             threaded = 0, entry = 0, tag;
 208         Lm_list         *lml;
 209         Lc_desc         *lcp;
 210 
 211         if ((lmp == NULL) || (funcs == NULL))
 212                 return;
 213 
 214         /*
 215          * Once the process is active, ensure we grab a lock.
 216          */
 217         if (rtld_flags & RT_FL_APPLIC)
 218                 entry = enter(0);
 219 
 220         lml = LIST(lmp);
 221         lcp = &lml->lm_lcs[0];
 222 
 223         DBG_CALL(Dbg_util_nl(lml, DBG_NL_STD));
 224 
 225         for (tag = funcs->ci_tag; tag; tag = (++funcs)->ci_tag) {
 226                 char    *gptr;
 227                 char    *lptr = funcs->ci_un.ci_ptr;
 228 
 229                 DBG_CALL(Dbg_util_lcinterface(lmp, tag, lptr));
 230 
 231                 if (tag >= CI_MAX)
 232                         continue;
 233 
 234                 /*
 235                  * Maintain all interfaces on a per-link-map basis.  Note, for
 236                  * most interfaces, only the first interface is used for any
 237                  * link-map list.  This prevents accidents with developers who
 238                  * manage to load two different versions of libc.
 239                  */
 240                 if ((lcp[tag].lc_lmp) &&
 241                     (tag != CI_LCMESSAGES) && (tag != CI_VERSION)) {
 242                         DBG_CALL(Dbg_unused_lcinterface(lmp,
 243                             lcp[tag].lc_lmp, tag));
 244                         continue;
 245                 }
 246 
 247                 lcp[tag].lc_un.lc_ptr = lptr;
 248                 lcp[tag].lc_lmp = lmp;
 249 
 250                 gptr = glcs[tag].lc_un.lc_ptr;
 251 
 252                 /*
 253                  * Process any interfaces that must be maintained on a global
 254                  * basis.
 255                  */
 256                 switch (tag) {
 257                 case CI_ATEXIT:
 258                         break;
 259 
 260                 case CI_LCMESSAGES:
 261                         /*
 262                          * At startup, ld.so.1 can establish a locale from one
 263                          * of the locale family of environment variables (see
 264                          * ld_str_env() and readenv_user()).  During process
 265                          * execution the locale can also be changed by the user.
 266                          * This interface is called from libc should the locale
 267                          * be modified.  Presently, only one global locale is
 268                          * maintained for all link-map lists, and only objects
 269                          * on the primrary link-map may change this locale.
 270                          */
 271                         if ((lml->lm_flags & LML_FLG_BASELM) &&
 272                             ((gptr == NULL) || (strcmp(gptr, lptr) != 0))) {
 273                                 /*
 274                                  * If we've obtained a message locale (typically
 275                                  * supplied via libc's setlocale()), then
 276                                  * register the locale for use in dgettext() so
 277                                  * as to reestablish the locale for ld.so.1's
 278                                  * messages.
 279                                  */
 280                                 if (gptr) {
 281                                         free((void *)gptr);
 282                                         rtld_flags |= RT_FL_NEWLOCALE;
 283                                 }
 284                                 glcs[tag].lc_un.lc_ptr = strdup(lptr);
 285 
 286                                 /*
 287                                  * Clear any cached messages.
 288                                  */
 289                                 bzero(err_strs, sizeof (err_strs));
 290                                 nosym_str = NULL;
 291                         }
 292                         break;
 293 
 294                 case CI_BIND_GUARD:
 295                 case CI_BIND_CLEAR:
 296                 case CI_THR_SELF:
 297                 case CI_CRITICAL:
 298                         /*
 299                          * If the global vector is unset, or this is the primary
 300                          * link-map, set the global vector.
 301                          */
 302                         if ((gptr == NULL) || (lml->lm_flags & LML_FLG_BASELM))
 303                                 glcs[tag].lc_un.lc_ptr = lptr;
 304 
 305                         /* FALLTHROUGH */
 306 
 307                 case CI_TLS_MODADD:
 308                 case CI_TLS_MODREM:
 309                 case CI_TLS_STATMOD:
 310                 case CI_THRINIT:
 311                         threaded++;
 312                         break;
 313 
 314                 case CI_VERSION:
 315                         if ((rtld_flags2 & RT_FL2_RTLDSEEN) == 0) {
 316                                 Aliste  idx;
 317                                 Lm_list *lml2;
 318                                 int     version;
 319 
 320                                 rtld_flags2 |= RT_FL2_RTLDSEEN;
 321 
 322                                 version = funcs->ci_un.ci_val;
 323 #if defined(CI_V_FIVE)
 324                                 if (version >= CI_V_FIVE) {
 325                                         thr_flg_nolock = THR_FLG_NOLOCK;
 326                                         thr_flg_reenter = THR_FLG_REENTER;
 327                                 }
 328 #endif
 329                                 if (version < CI_V_FOUR)
 330                                         break;
 331 
 332                                 rtld_flags2 |= RT_FL2_UNIFPROC;
 333 
 334                                 /*
 335                                  * We might have seen an auditor which is not
 336                                  * dependent on libc.  Such an auditor's link
 337                                  * map list has LML_FLG_HOLDLOCK set.  This
 338                                  * lock needs to be dropped.  Refer to
 339                                  * audit_setup() in audit.c.
 340                                  */
 341                                 if ((rtld_flags2 & RT_FL2_HASAUDIT) == 0)
 342                                         break;
 343 
 344                                 /*
 345                                  * Yes, we did.  Take care of them.
 346                                  */
 347                                 for (APLIST_TRAVERSE(dynlm_list, idx, lml2)) {
 348                                         Rt_map *map = (Rt_map *)lml2->lm_head;
 349 
 350                                         if (FLAGS(map) & FLG_RT_AUDIT) {
 351                                                 lml2->lm_flags &=
 352                                                     ~LML_FLG_HOLDLOCK;
 353                                         }
 354                                 }
 355                         }
 356                         break;
 357 
 358                 default:
 359                         break;
 360                 }
 361         }
 362 
 363         if (threaded) {
 364                 /*
 365                  * If a version of libc gives us only a subset of the TLS
 366                  * interfaces, it's confused and we discard the whole lot.
 367                  */
 368                 if ((lcp[CI_TLS_MODADD].lc_un.lc_func &&
 369                     lcp[CI_TLS_MODREM].lc_un.lc_func &&
 370                     lcp[CI_TLS_STATMOD].lc_un.lc_func) == NULL) {
 371                         lcp[CI_TLS_MODADD].lc_un.lc_func = NULL;
 372                         lcp[CI_TLS_MODREM].lc_un.lc_func = NULL;
 373                         lcp[CI_TLS_STATMOD].lc_un.lc_func = NULL;
 374                 }
 375 
 376                 /*
 377                  * Indicate that we're now thread capable.
 378                  */
 379                 if ((lml->lm_flags & LML_FLG_RTLDLM) == 0)
 380                         rtld_flags |= RT_FL_THREADS;
 381         }
 382 
 383         if (entry)
 384                 leave(lml, 0);
 385 }
 386 
 387 /*
 388  * At this point we know we have a set of objects that have been fully analyzed
 389  * and relocated.  Prior to the next major step of running .init sections (ie.
 390  * running user code), retrieve any RTLDINFO interfaces.
 391  */
 392 int
 393 rt_get_extern(Lm_list *lml, Rt_map *lmp)
 394 {
 395         if (lml->lm_rti) {
 396                 Aliste          idx;
 397                 Rti_desc        *rti;
 398 
 399                 for (ALIST_TRAVERSE(lml->lm_rti, idx, rti))
 400                         get_lcinterface(rti->rti_lmp, rti->rti_info);
 401 
 402                 free(lml->lm_rti);
 403                 lml->lm_rti = 0;
 404         }
 405 
 406         /*
 407          * Perform some sanity checks.  If we have TLS requirements we better
 408          * have the associated external interfaces.
 409          */
 410         if (lml->lm_tls &&
 411             (lml->lm_lcs[CI_TLS_STATMOD].lc_un.lc_func == NULL)) {
 412                 eprintf(lml, ERR_FATAL, MSG_INTL(MSG_TLS_NOSUPPORT),
 413                     NAME(lmp));
 414                 return (0);
 415         }
 416         return (1);
 417 }
 418 
 419 /*
 420  * Provide an interface for libc to communicate additional interface
 421  * information.
 422  */
 423 void
 424 _ld_libc(void *ptr)
 425 {
 426         get_lcinterface(_caller(caller(), CL_EXECDEF), (Lc_interface *)ptr);
 427 }
 428 
 429 static int      bindmask = 0;
 430 
 431 int
 432 rt_bind_guard(int flags)
 433 {
 434         int     (*fptr)(int);
 435         int     bindflag;
 436 
 437         if ((fptr = glcs[CI_BIND_GUARD].lc_un.lc_func) != NULL) {
 438                 return ((*fptr)(flags));
 439         } else {
 440                 bindflag = (flags & THR_FLG_RTLD);
 441                 if ((bindflag & bindmask) == 0) {
 442                         bindmask |= bindflag;
 443                         return (1);
 444                 }
 445                 return (0);
 446         }
 447 }
 448 
 449 int
 450 rt_bind_clear(int flags)
 451 {
 452         int     (*fptr)(int);
 453         int     bindflag;
 454 
 455         if ((fptr = glcs[CI_BIND_CLEAR].lc_un.lc_func) != NULL) {
 456                 return ((*fptr)(flags));
 457         } else {
 458                 bindflag = (flags & THR_FLG_RTLD);
 459                 if (bindflag == 0)
 460                         return (bindmask);
 461                 else {
 462                         bindmask &= ~bindflag;
 463                         return (0);
 464                 }
 465         }
 466 }
 467 
 468 /*
 469  * Make sure threads have been initialized.  This interface is called once for
 470  * each link-map list.
 471  */
 472 void
 473 rt_thr_init(Lm_list *lml)
 474 {
 475         void    (*fptr)(void);
 476 
 477         if ((fptr =
 478             (void (*)())lml->lm_lcs[CI_THRINIT].lc_un.lc_func) != NULL) {
 479                 lml->lm_lcs[CI_THRINIT].lc_un.lc_func = NULL;
 480 
 481                 leave(lml, thr_flg_reenter);
 482                 (*fptr)();
 483                 (void) enter(thr_flg_reenter);
 484 
 485                 /*
 486                  * If this is an alternative link-map list, and this is the
 487                  * first call to initialize threads, don't let the destination
 488                  * libc be deleted.  It is possible that an auditors complete
 489                  * initialization fails, but there is presently no main link-map
 490                  * list.  As this libc has established the thread pointer, don't
 491                  * delete this libc, otherwise the initialization of libc on the
 492                  * main link-map can be compromised during its threads
 493                  * initialization.
 494                  */
 495                 if (((lml->lm_flags & LML_FLG_BASELM) == 0) &&
 496                     ((rtld_flags2 & RT_FL2_PLMSETUP) == 0))
 497                         MODE(lml->lm_lcs[CI_THRINIT].lc_lmp) |= RTLD_NODELETE;
 498         }
 499 }
 500 
 501 thread_t
 502 rt_thr_self()
 503 {
 504         thread_t        (*fptr)(void);
 505 
 506         if ((fptr = (thread_t (*)())glcs[CI_THR_SELF].lc_un.lc_func) != NULL)
 507                 return ((*fptr)());
 508 
 509         return (1);
 510 }
 511 
 512 int
 513 rt_mutex_lock(Rt_lock *mp)
 514 {
 515         return (_lwp_mutex_lock((lwp_mutex_t *)mp));
 516 }
 517 
 518 int
 519 rt_mutex_unlock(Rt_lock *mp)
 520 {
 521         return (_lwp_mutex_unlock((lwp_mutex_t *)mp));
 522 }
 523 
 524 /*
 525  * Test whether we're in a libc critical region.  Certain function references,
 526  * like the "mem*" family, might require binding.  Although these functions can
 527  * safely bind to auxiliary filtees, they should not be captured by auditors.
 528  */
 529 int
 530 rt_critical()
 531 {
 532         int     (*fptr)(void);
 533 
 534         if ((fptr = glcs[CI_CRITICAL].lc_un.lc_func) != NULL)
 535                 return ((*fptr)());
 536 
 537         return (0);
 538 }
 539 
 540 /*
 541  * Mutex interfaces to resolve references from any objects extracted from
 542  * libc_pic.a.  Note, as ld.so.1 is essentially single threaded these can be
 543  * noops.
 544  */
 545 #pragma weak lmutex_lock = mutex_lock
 546 /* ARGSUSED */
 547 int
 548 mutex_lock(mutex_t *mp)
 549 {
 550         return (0);
 551 }
 552 
 553 #pragma weak lmutex_unlock = mutex_unlock
 554 /* ARGSUSED */
 555 int
 556 mutex_unlock(mutex_t *mp)
 557 {
 558         return (0);
 559 }
 560 
 561 /* ARGSUSED */
 562 int
 563 mutex_init(mutex_t *mp, int type, void *arg)
 564 {
 565         return (0);
 566 }
 567 
 568 /* ARGSUSED */
 569 int
 570 mutex_destroy(mutex_t *mp)
 571 {
 572         return (0);
 573 }
 574 
 575 /*
 576  * This is needed to satisfy sysconf() (case _SC_THREAD_STACK_MIN)
 577  */
 578 size_t
 579 thr_min_stack()
 580 {
 581         return (sizeof (uintptr_t) * 1024);
 582 }
 583 
 584 /*
 585  * Local str[n]casecmp() interfaces for the dynamic linker,
 586  * to avoid problems when linking with libc_pic.a
 587  */
 588 int
 589 strcasecmp(const char *s1, const char *s2)
 590 {
 591         extern int ascii_strcasecmp(const char *, const char *);
 592 
 593         return (ascii_strcasecmp(s1, s2));
 594 }
 595 
 596 int
 597 strncasecmp(const char *s1, const char *s2, size_t n)
 598 {
 599         extern int ascii_strncasecmp(const char *, const char *, size_t);
 600 
 601         return (ascii_strncasecmp(s1, s2, n));
 602 }
 603 
 604 /*
 605  * The following functions are cancellation points in libc.
 606  * They are called from other functions in libc that we extract
 607  * and use directly.  We don't do cancellation while we are in
 608  * the dynamic linker, so we redefine these to call the primitive,
 609  * non-cancellation interfaces.
 610  */
 611 int
 612 close(int fildes)
 613 {
 614         extern int __close(int);
 615 
 616         return (__close(fildes));
 617 }
 618 
 619 int
 620 fcntl(int fildes, int cmd, ...)
 621 {
 622         extern int __fcntl(int, int, ...);
 623         intptr_t arg;
 624         va_list ap;
 625 
 626         va_start(ap, cmd);
 627         arg = va_arg(ap, intptr_t);
 628         va_end(ap);
 629         return (__fcntl(fildes, cmd, arg));
 630 }
 631 
 632 int
 633 open(const char *path, int oflag, ...)
 634 {
 635         extern int __open(const char *, int, mode_t);
 636         mode_t mode;
 637         va_list ap;
 638 
 639         va_start(ap, oflag);
 640         mode = va_arg(ap, mode_t);
 641         va_end(ap);
 642         return (__open(path, oflag, mode));
 643 }
 644 
 645 int
 646 openat(int fd, const char *path, int oflag, ...)
 647 {
 648         extern int __openat(int, const char *, int, mode_t);
 649         mode_t mode;
 650         va_list ap;
 651 
 652         va_start(ap, oflag);
 653         mode = va_arg(ap, mode_t);
 654         va_end(ap);
 655         return (__openat(fd, path, oflag, mode));
 656 }
 657 
 658 ssize_t
 659 read(int fd, void *buf, size_t size)
 660 {
 661         extern ssize_t __read(int, void *, size_t);
 662         return (__read(fd, buf, size));
 663 }
 664 
 665 ssize_t
 666 write(int fd, const void *buf, size_t size)
 667 {
 668         extern ssize_t __write(int, const void *, size_t);
 669         return (__write(fd, buf, size));
 670 }
 671 
 672 /*
 673  * ASCII versions of ctype character classification functions.  This avoids
 674  * pulling in the entire locale framework that is in libc.
 675  */
 676 
 677 int
 678 isdigit(int c)
 679 {
 680         return ((c >= '0' && c <= '9') ? 1 : 0);
 681 }
 682 
 683 int
 684 isupper(int c)
 685 {
 686         return ((c >= 'A' && c <= 'Z') ? 1 : 0);
 687 }
 688 
 689 int
 690 islower(int c)
 691 {
 692         return ((c >= 'a' && c <= 'z') ? 1 : 0);
 693 }
 694 
 695 int
 696 isspace(int c)
 697 {
 698         return (((c == ' ') || (c == '\t') || (c == '\r') || (c == '\n') ||
 699             (c == '\v') || (c == '\f')) ? 1 : 0);
 700 }
 701 
 702 int
 703 isxdigit(int c)
 704 {
 705         return ((isdigit(c) || (c >= 'A' && c <= 'F') ||
 706             (c >= 'a' && c <= 'f')) ? 1 : 0);
 707 }
 708 
 709 int
 710 isalpha(int c)
 711 {
 712         return ((isupper(c) || islower(c)) ? 1 : 0);
 713 }
 714 
 715 int
 716 isalnum(int c)
 717 {
 718         return ((isalpha(c) || isdigit(c)) ? 1 : 0);
 719 }