zfs/lib/libspl/mkdirp.c

   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 2008 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 /*      Copyright (c) 1988 AT&T */
  28 /*        All Rights Reserved   */
  29
  30 #pragma ident   "%Z%%M% %I%     %E% SMI"
  31
  32 /*
  33  * Creates directory and it's parents if the parents do not
  34  * exist yet.
  35  *
  36  * Returns -1 if fails for reasons other than non-existing
  37  * parents.
  38  * Does NOT simplify pathnames with . or .. in them.
  39  */
  40
  41 #include <sys/types.h>
  42 #include <libgen.h>
  43 #include <stdlib.h>
  44 #include <unistd.h>
  45 #include <errno.h>
  46 #include <string.h>
  47 #include <sys/stat.h>
  48
  49 static char *simplify(const char *str);
  50
  51 int
  52 mkdirp(const char *d, mode_t mode)
  53 {
  54         char  *endptr, *ptr, *slash, *str;
  55
  56         str = simplify(d);
  57
  58         /* If space couldn't be allocated for the simplified names, return. */
  59
  60         if (str == NULL)
  61                 return (-1);
  62
  63                 /* Try to make the directory */
  64
  65         if (mkdir(str, mode) == 0) {
  66                 free(str);
  67                 return (0);
  68         }
  69         if (errno != ENOENT) {
  70                 free(str);
  71                 return (-1);
  72         }
  73         endptr = strrchr(str, '\0');
  74         slash = strrchr(str, '/');
  75
  76                 /* Search upward for the non-existing parent */
  77
  78         while (slash != NULL) {
  79
  80                 ptr = slash;
  81                 *ptr = '\0';
  82
  83                         /* If reached an existing parent, break */
  84
  85                 if (access(str, F_OK) == 0)
  86                         break;
  87
  88                         /* If non-existing parent */
  89
  90                 else {
  91                         slash = strrchr(str, '/');
  92
  93                                 /* If under / or current directory, make it. */
  94
  95                         if (slash == NULL || slash == str) {
  96                                 if (mkdir(str, mode) != 0 && errno != EEXIST) {
  97                                         free(str);
  98                                         return (-1);
  99                                 }
 100                                 break;
 101                         }
 102                 }
 103         }
 104
 105         /* Create directories starting from upmost non-existing parent */
 106
 107         while ((ptr = strchr(str, '\0')) != endptr) {
 108                 *ptr = '/';
 109                 if (mkdir(str, mode) != 0 && errno != EEXIST) {
 110                         /*
 111                          *  If the mkdir fails because str already
 112                          *  exists (EEXIST), then str has the form
 113                          *  "existing-dir/..", and this is really
 114                          *  ok. (Remember, this loop is creating the
 115                          *  portion of the path that didn't exist)
 116                          */
 117                         free(str);
 118                         return (-1);
 119                 }
 120         }
 121         free(str);
 122         return (0);
 123 }
 124
 125 /*
 126  *      simplify - given a pathname, simplify that path by removing
 127  *                 duplicate contiguous slashes.
 128  *
 129  *                 A simplified copy of the argument is returned to the
 130  *                 caller, or NULL is returned on error.
 131  *
 132  *                 The caller should handle error reporting based upon the
 133  *                 returned vlaue, and should free the returned value,
 134  *                 when appropriate.
 135  */
 136
 137 static char *
 138 simplify(const char *str)
 139 {
 140         int i;
 141         size_t mbPathlen;       /* length of multi-byte path */
 142         size_t wcPathlen;       /* length of wide-character path */
 143         wchar_t *wptr;          /* scratch pointer */
 144         wchar_t *wcPath;        /* wide-character version of the path */
 145         char *mbPath;           /* The copy fo the path to be returned */
 146
 147         /*
 148          *  bail out if there is nothing there.
 149          */
 150
 151         if (!str)
 152                 return (NULL);
 153
 154         /*
 155          *  Get a copy of the argument.
 156          */
 157
 158         if ((mbPath = strdup(str)) == NULL) {
 159                 return (NULL);
 160         }
 161
 162         /*
 163          *  convert the multi-byte version of the path to a
 164          *  wide-character rendering, for doing our figuring.
 165          */
 166
 167         mbPathlen = strlen(mbPath);
 168
 169         if ((wcPath = calloc(sizeof (wchar_t), mbPathlen+1)) == NULL) {
 170                 free(mbPath);
 171                 return (NULL);
 172         }
 173
 174         if ((wcPathlen = mbstowcs(wcPath, mbPath, mbPathlen)) == (size_t)-1) {
 175                 free(mbPath);
 176                 free(wcPath);
 177                 return (NULL);
 178         }
 179
 180         /*
 181          *  remove duplicate slashes first ("//../" -> "/")
 182          */
 183
 184         for (wptr = wcPath, i = 0; i < wcPathlen; i++) {
 185                 *wptr++ = wcPath[i];
 186
 187                 if (wcPath[i] == '/') {
 188                         i++;
 189
 190                         while (wcPath[i] == '/') {
 191                                 i++;
 192                         }
 193
 194                         i--;
 195                 }
 196         }
 197
 198         *wptr = '\0';
 199
 200         /*
 201          *  now convert back to the multi-byte format.
 202          */
 203
 204         if (wcstombs(mbPath, wcPath, mbPathlen) == (size_t)-1) {
 205                 free(mbPath);
 206                 free(wcPath);
 207                 return (NULL);
 208         }
 209
 210         free(wcPath);
 211         return (mbPath);
 212 }