(root)/
m4-1.4.19/
lib/
openat-proc.c
       1  /* Create /proc/self/fd-related names for subfiles of open directories.
       2  
       3     Copyright (C) 2006, 2009-2021 Free Software Foundation, Inc.
       4  
       5     This program is free software: you can redistribute it and/or modify
       6     it under the terms of the GNU General Public License as published by
       7     the Free Software Foundation; either version 3 of the License, or
       8     (at your option) any later version.
       9  
      10     This program is distributed in the hope that it will be useful,
      11     but WITHOUT ANY WARRANTY; without even the implied warranty of
      12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      13     GNU General Public License for more details.
      14  
      15     You should have received a copy of the GNU General Public License
      16     along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
      17  
      18  /* Written by Paul Eggert.  */
      19  
      20  #include <config.h>
      21  
      22  #include "openat-priv.h"
      23  
      24  #include <sys/types.h>
      25  #include <sys/stat.h>
      26  #include <fcntl.h>
      27  
      28  #include <stdio.h>
      29  #include <stdlib.h>
      30  #include <string.h>
      31  #include <unistd.h>
      32  
      33  #ifdef __KLIBC__
      34  # include <InnoTekLIBC/backend.h>
      35  #endif
      36  
      37  #include "intprops.h"
      38  
      39  /* Set BUF to the name of the subfile of the directory identified by
      40     FD, where the subfile is named FILE.  If successful, return BUF if
      41     the result fits in BUF, dynamically allocated memory otherwise.
      42     Return NULL (setting errno) on error.  */
      43  char *
      44  openat_proc_name (char buf[OPENAT_BUFFER_SIZE], int fd, char const *file)
      45  {
      46    char *result = buf;
      47    int dirlen;
      48  
      49    /* Make sure the caller gets ENOENT when appropriate.  */
      50    if (!*file)
      51      {
      52        buf[0] = '\0';
      53        return buf;
      54      }
      55  
      56  #ifndef __KLIBC__
      57  # define PROC_SELF_FD_FORMAT "/proc/self/fd/%d/"
      58    {
      59      enum {
      60        PROC_SELF_FD_DIR_SIZE_BOUND
      61          = (sizeof PROC_SELF_FD_FORMAT - (sizeof "%d" - 1)
      62             + INT_STRLEN_BOUND (int))
      63      };
      64  
      65      static int proc_status = 0;
      66      if (! proc_status)
      67        {
      68          /* Set PROC_STATUS to a positive value if /proc/self/fd is
      69             reliable, and a negative value otherwise.  Solaris 10
      70             /proc/self/fd mishandles "..", and any file name might expand
      71             to ".." after symbolic link expansion, so avoid /proc/self/fd
      72             if it mishandles "..".  Solaris 10 has openat, but this
      73             problem is exhibited on code that built on Solaris 8 and
      74             running on Solaris 10.  */
      75  
      76          int proc_self_fd =
      77            open ("/proc/self/fd",
      78                  O_SEARCH | O_DIRECTORY | O_NOCTTY | O_NONBLOCK | O_CLOEXEC);
      79          if (proc_self_fd < 0)
      80            proc_status = -1;
      81          else
      82            {
      83              /* Detect whether /proc/self/fd/%i/../fd exists, where %i is the
      84                 number of a file descriptor open on /proc/self/fd.  On Linux,
      85                 that name resolves to /proc/self/fd, which was opened above.
      86                 However, on Solaris, it may resolve to /proc/self/fd/fd, which
      87                 cannot exist, since all names in /proc/self/fd are numeric.  */
      88              char dotdot_buf[PROC_SELF_FD_DIR_SIZE_BOUND + sizeof "../fd" - 1];
      89              sprintf (dotdot_buf, PROC_SELF_FD_FORMAT "../fd", proc_self_fd);
      90              proc_status = access (dotdot_buf, F_OK) ? -1 : 1;
      91              close (proc_self_fd);
      92            }
      93        }
      94  
      95      if (proc_status < 0)
      96        return NULL;
      97      else
      98        {
      99          size_t bufsize = PROC_SELF_FD_DIR_SIZE_BOUND + strlen (file);
     100          if (OPENAT_BUFFER_SIZE < bufsize)
     101            {
     102              result = malloc (bufsize);
     103              if (! result)
     104                return NULL;
     105            }
     106  
     107          dirlen = sprintf (result, PROC_SELF_FD_FORMAT, fd);
     108        }
     109    }
     110  #else
     111    /* OS/2 kLIBC provides a function to retrieve a path from a fd.  */
     112    {
     113      char dir[_MAX_PATH];
     114      size_t bufsize;
     115  
     116      if (__libc_Back_ioFHToPath (fd, dir, sizeof dir))
     117        return NULL;
     118  
     119      dirlen = strlen (dir);
     120      bufsize = dirlen + 1 + strlen (file) + 1; /* 1 for '/', 1 for null */
     121      if (OPENAT_BUFFER_SIZE < bufsize)
     122        {
     123          result = malloc (bufsize);
     124          if (! result)
     125            return NULL;
     126        }
     127  
     128      strcpy (result, dir);
     129      result[dirlen++] = '/';
     130    }
     131  #endif
     132  
     133    strcpy (result + dirlen, file);
     134    return result;
     135  }