9c81f2a0b8b0de5111c674e87bf3efd9f97a8f6b
[zfs.git] / 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 }