3687 fopen() O_CLOEXEC support via the "e" flag

          --- old/usr/src/lib/libc/port/stdio/_endopen.c
          +++ new/usr/src/lib/libc/port/stdio/_endopen.c

   1    1  /*
   2    2   * CDDL HEADER START
   3    3   *
   4    4   * The contents of this file are subject to the terms of the
   5    5   * Common Development and Distribution License (the "License").
   6    6   * You may not use this file except in compliance with the License.
   7    7   *
   8    8   * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9    9   * or http://www.opensolaris.org/os/licensing.
  10   10   * See the License for the specific language governing permissions
  11   11   * and limitations under the License.
  12   12   *
  13   13   * When distributing Covered Code, include this CDDL HEADER in each
  14   14   * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15   15   * If applicable, add the following below this CDDL HEADER, with the
  16   16   * fields enclosed by brackets "[]" replaced with your own identifying
  17   17   * information: Portions Copyright [yyyy] [name of copyright owner]
  18   18   *
  19   19   * CDDL HEADER END

  20   20   */
  21   21  
  22   22  /*
  23   23   * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
  24   24   * Use is subject to license terms.
  25   25   */
  26   26  
  27   27  /*      Copyright (c) 1988 AT&T */
  28   28  /*        All Rights Reserved   */
  29   29  
  30      -#pragma ident   "%Z%%M% %I%     %E% SMI"
       30 +/* Copyright (c) 2013 OmniTI Computer Consulting, Inc. All rights reserved. */
  31   31  
  32   32  /*
  33   33   *      This routine is a special case, in that it is aware of
  34   34   *      both small and large file interfaces. It must be built
  35   35   *      in the small compilation environment.
  36   36   */
  37   37  
  38   38  #include "lint.h"
  39   39  #include "file64.h"
  40   40  #include <mtlib.h>

  41   41  #include <sys/types.h>
  42   42  #include <stdio.h>
  43   43  #include <fcntl.h>
  44   44  #include <unistd.h>
  45   45  #include <limits.h>
  46   46  #include <thread.h>
  47   47  #include <synch.h>

  48   48  #include "stdiom.h"
  49   49  #include <errno.h>
  50   50  
  51   51  /*
  52   52   * open UNIX file name, associate with iop
  53   53   */
  54   54  
  55   55  FILE *
  56   56  _endopen(const char *name, const char *type, FILE *iop, int largefile)
  57   57  {
  58      -        int oflag, fd, fflag;
  59      -        char plus;
       58 +        int oflag, fd, fflag, eflag, plusflag;
       59 +        const char *echr;
  60   60  
  61   61          if (iop == NULL)
  62   62                  return (NULL);
  63   63          switch (type[0]) {
  64   64          default:
  65   65                  errno = EINVAL;
  66   66                  return (NULL);
  67   67          case 'r':
  68   68                  oflag = O_RDONLY;
  69   69                  fflag = _IOREAD;
  70   70                  break;
  71   71          case 'w':
  72   72                  oflag = O_WRONLY | O_TRUNC | O_CREAT;
  73   73                  fflag = _IOWRT;
  74   74                  break;
  75   75          case 'a':
  76   76                  oflag = O_WRONLY | O_APPEND | O_CREAT;
  77   77                  fflag = _IOWRT;
  78   78                  break;
  79   79          }
  80      -        /* UNIX ignores 'b' and treats text and binary the same */
  81      -        if ((plus = type[1]) == 'b')
  82      -                plus = type[2];
  83      -        if (plus == '+') {
       80 +
       81 +        plusflag = 0;
       82 +        eflag = 0;
       83 +        for (echr = type + 1; *echr != '\0'; echr++) {
       84 +                switch (*echr) {
       85 +                /* UNIX ignores 'b' and treats text and binary the same */
       86 +                default:
       87 +                        break;
       88 +                case '+':
       89 +                        plusflag = 1;
       90 +                        break;
       91 +                case 'e':
       92 +                        eflag = 1;
       93 +                        break;
       94 +                }
       95 +        }
       96 +        if (eflag) {
       97 +                /* Subsequent to a mode flag, 'e' indicates O_CLOEXEC */
       98 +                oflag = oflag | O_CLOEXEC;
       99 +        }
      100 +        if (plusflag) {
  84  101                  oflag = (oflag & ~(O_RDONLY | O_WRONLY)) | O_RDWR;
  85  102                  fflag = _IORW;
  86  103          }
  87  104  
  88  105          /* select small or large file open based on flag */
  89  106          if (largefile) {
  90  107                  fd = open64(name, oflag, 0666);
  91  108          } else {
  92  109                  fd = open(name, oflag, 0666);
  93  110          }

  94  111          if (fd < 0)
  95  112                  return (NULL);
  96  113  
  97  114          /* As long as we make sure _flag stays != 0, we don't need to lock */
  98  115  #ifdef  _LP64
  99  116          iop->_file = fd;
 100  117          iop->_flag = (iop->_flag & ~0377) | fflag;
 101  118  #else
 102  119          if (fd <= _FILE_FD_MAX) {
 103  120                  SET_FILE(iop, fd);
 104  121          } else if (_file_set(iop, fd, type) != 0) {
 105  122                  /* errno set in _file_set() */
 106  123                  (void) close(fd);
 107  124                  return (NULL);
 108  125          }
 109  126          iop->_flag = fflag;
 110  127  #endif  /*      _LP64   */
 111  128  
 112  129          if (oflag == (O_WRONLY | O_APPEND | O_CREAT)) { /* type == "a" */
 113  130                  if (lseek64(fd, (off64_t)0, SEEK_END) < (off64_t)0) {
 114  131                          (void) close(fd);
 115  132                          return (NULL);
 116  133                  }
 117  134          }
 118  135  
 119  136          return (iop);
 120  137  }

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX