subr.c revision 1.12
1 /* $NetBSD: subr.c,v 1.12 2011/06/28 16:19:16 manu Exp $ */ 2 3 /*- 4 * Copyright (c) 2010-2011 Emmanuel Dreyfus. All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 16 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 17 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 18 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 19 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 20 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 21 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 22 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 23 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 24 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 25 * POSSIBILITY OF SUCH DAMAGE. 26 */ 27 28 #include <stdio.h> 29 #include <stdlib.h> 30 #include <err.h> 31 #include <errno.h> 32 #include <sysexits.h> 33 #include <syslog.h> 34 #include <puffs.h> 35 #include <paths.h> 36 #include <sys/extattr.h> 37 38 #include "perfuse_priv.h" 39 40 struct perfuse_ns_map { 41 const char *pnm_ns; 42 const size_t pnm_nslen; 43 const int pnm_native_ns; 44 }; 45 46 #define PERFUSE_NS_MAP(ns, native_ns) \ 47 { ns ".", sizeof(ns), native_ns } 48 49 static size_t node_path(puffs_cookie_t, char *, size_t); 50 51 struct puffs_node * 52 perfuse_new_pn(pu, name, parent) 53 struct puffs_usermount *pu; 54 const char *name; 55 struct puffs_node *parent; 56 { 57 struct puffs_node *pn; 58 struct perfuse_node_data *pnd; 59 60 if ((pnd = malloc(sizeof(*pnd))) == NULL) 61 DERR(EX_OSERR, "malloc failed"); 62 63 if ((pn = puffs_pn_new(pu, pnd)) == NULL) 64 DERR(EX_SOFTWARE, "puffs_pn_new failed"); 65 66 (void)memset(pnd, 0, sizeof(*pnd)); 67 pnd->pnd_rfh = FUSE_UNKNOWN_FH; 68 pnd->pnd_wfh = FUSE_UNKNOWN_FH; 69 pnd->pnd_ino = PERFUSE_UNKNOWN_INO; 70 pnd->pnd_nlookup = 1; 71 pnd->pnd_parent = parent; 72 pnd->pnd_pn = (puffs_cookie_t)pn; 73 (void)strlcpy(pnd->pnd_name, name, MAXPATHLEN); 74 TAILQ_INIT(&pnd->pnd_pcq); 75 TAILQ_INIT(&pnd->pnd_children); 76 77 if (parent != NULL) { 78 struct perfuse_node_data *parent_pnd; 79 80 parent_pnd = PERFUSE_NODE_DATA(parent); 81 TAILQ_INSERT_TAIL(&parent_pnd->pnd_children, pnd, pnd_next); 82 83 parent_pnd->pnd_childcount++; 84 } 85 86 return pn; 87 } 88 89 void 90 perfuse_destroy_pn(pn) 91 struct puffs_node *pn; 92 { 93 struct perfuse_node_data *pnd; 94 95 pnd = PERFUSE_NODE_DATA(pn); 96 97 if (pnd->pnd_parent != NULL) { 98 struct perfuse_node_data *parent_pnd; 99 100 parent_pnd = PERFUSE_NODE_DATA(pnd->pnd_parent); 101 TAILQ_REMOVE(&parent_pnd->pnd_children, pnd, pnd_next); 102 } 103 104 if ((pnd = puffs_pn_getpriv(pn)) != NULL) { 105 if (pnd->pnd_parent != NULL) 106 PERFUSE_NODE_DATA(pnd->pnd_parent)->pnd_childcount--; 107 108 if (pnd->pnd_dirent != NULL) 109 free(pnd->pnd_dirent); 110 111 if (pnd->pnd_all_fd != NULL) 112 free(pnd->pnd_all_fd); 113 #ifdef PERFUSE_DEBUG 114 if (pnd->pnd_flags & PND_OPEN) 115 DERRX(EX_SOFTWARE, "%s: file open", __func__); 116 117 if (!TAILQ_EMPTY(&pnd->pnd_pcq)) 118 DERRX(EX_SOFTWARE, "%s: non empty pnd_pcq", __func__); 119 #endif /* PERFUSE_DEBUG */ 120 121 free(pnd); 122 } 123 124 puffs_pn_put(pn); 125 126 return; 127 } 128 129 130 void 131 perfuse_new_fh(opc, fh, mode) 132 puffs_cookie_t opc; 133 uint64_t fh; 134 int mode; 135 { 136 struct perfuse_node_data *pnd; 137 138 pnd = PERFUSE_NODE_DATA(opc); 139 140 if (mode & FWRITE) { 141 if (pnd->pnd_flags & PND_WFH) 142 DERRX(EX_SOFTWARE, "%s: opc = %p, write fh already set", 143 __func__, (void *)opc); 144 pnd->pnd_wfh = fh; 145 pnd->pnd_flags |= PND_WFH; 146 } 147 148 if (mode & FREAD) { 149 if (pnd->pnd_flags & PND_RFH) 150 DERRX(EX_SOFTWARE, "%s: opc = %p, read fh already set", 151 __func__, (void *)opc); 152 pnd->pnd_rfh = fh; 153 pnd->pnd_flags |= PND_RFH; 154 } 155 156 return; 157 } 158 159 void 160 perfuse_destroy_fh(opc, fh) 161 puffs_cookie_t opc; 162 uint64_t fh; 163 { 164 struct perfuse_node_data *pnd; 165 166 pnd = PERFUSE_NODE_DATA(opc); 167 168 if (fh == pnd->pnd_rfh) { 169 if (!(pnd->pnd_flags & PND_RFH) && (fh != FUSE_UNKNOWN_FH)) 170 DERRX(EX_SOFTWARE, 171 "%s: opc = %p, unset rfh = %"PRIx64"", 172 __func__, (void *)opc, fh); 173 pnd->pnd_rfh = FUSE_UNKNOWN_FH; 174 pnd->pnd_flags &= ~PND_RFH; 175 } 176 177 if (fh == pnd->pnd_wfh) { 178 if (!(pnd->pnd_flags & PND_WFH) && (fh != FUSE_UNKNOWN_FH)) 179 DERRX(EX_SOFTWARE, 180 "%s: opc = %p, unset wfh = %"PRIx64"", 181 __func__, (void *)opc, fh); 182 pnd->pnd_wfh = FUSE_UNKNOWN_FH; 183 pnd->pnd_flags &= ~PND_WFH; 184 } 185 186 return; 187 } 188 189 uint64_t 190 perfuse_get_fh(opc, mode) 191 puffs_cookie_t opc; 192 int mode; 193 { 194 struct perfuse_node_data *pnd; 195 196 pnd = PERFUSE_NODE_DATA(opc); 197 198 if (mode & FWRITE) { 199 if (pnd->pnd_flags & PND_WFH) 200 return pnd->pnd_wfh; 201 } 202 203 if (mode & FREAD) { 204 if (pnd->pnd_flags & PND_RFH) 205 return pnd->pnd_rfh; 206 207 if (pnd->pnd_flags & PND_WFH) 208 return pnd->pnd_wfh; 209 210 } 211 212 return FUSE_UNKNOWN_FH; 213 } 214 215 static size_t 216 node_path(opc, buf, buflen) 217 puffs_cookie_t opc; 218 char *buf; 219 size_t buflen; 220 { 221 struct perfuse_node_data *pnd; 222 size_t written; 223 224 pnd = PERFUSE_NODE_DATA(opc); 225 if (pnd->pnd_parent == opc) 226 return 0; 227 228 written = node_path(pnd->pnd_parent, buf, buflen); 229 buf += written; 230 buflen -= written; 231 232 return written + snprintf(buf, buflen, "/%s", pnd->pnd_name); 233 } 234 235 char * 236 perfuse_node_path(opc) 237 puffs_cookie_t opc; 238 { 239 static char buf[MAXPATHLEN + 1]; 240 241 if (node_path(opc, buf, sizeof(buf)) == 0) 242 sprintf(buf, "/"); 243 244 return buf; 245 } 246 247 const char * 248 perfuse_native_ns(attrnamespace, attrname, fuse_attrname) 249 const int attrnamespace; 250 const char *attrname; 251 char *fuse_attrname; 252 { 253 const struct perfuse_ns_map *pnm; 254 const struct perfuse_ns_map perfuse_ns_map[] = { 255 PERFUSE_NS_MAP("trusted", EXTATTR_NAMESPACE_SYSTEM), 256 PERFUSE_NS_MAP("security", EXTATTR_NAMESPACE_SYSTEM), 257 PERFUSE_NS_MAP("system", EXTATTR_NAMESPACE_SYSTEM), 258 PERFUSE_NS_MAP("user", EXTATTR_NAMESPACE_USER), 259 { NULL, 0, EXTATTR_NAMESPACE_USER }, 260 }; 261 262 /* 263 * If attribute has a reserved Linux namespace (e.g.: trusted.foo) 264 * and that namespace matches the requested native namespace 265 * we have nothing to do. 266 * Otherwise we have either: 267 * (system|trusted|security).* with user namespace: prepend user. 268 * anything else with system napespace: prepend system. 269 */ 270 for (pnm = perfuse_ns_map; pnm->pnm_ns; pnm++) { 271 if (strncmp(attrname, pnm->pnm_ns, pnm->pnm_nslen) != 0) 272 continue; 273 274 if (attrnamespace == pnm->pnm_native_ns) 275 return attrname; 276 277 /* (system|trusted|security).* with user namespace */ 278 if (attrnamespace == EXTATTR_NAMESPACE_USER) { 279 (void)snprintf(fuse_attrname, LINUX_XATTR_NAME_MAX, 280 "user.%s", attrname); 281 return (const char *)fuse_attrname; 282 } 283 } 284 285 /* anything else with system napespace */ 286 if (attrnamespace == EXTATTR_NAMESPACE_SYSTEM) { 287 (void)snprintf(fuse_attrname, LINUX_XATTR_NAME_MAX, 288 "system.%s", attrname); 289 return (const char *)fuse_attrname; 290 } 291 292 return (const char *)attrname; 293 } 294
Indexes created Tue Sep 23 07:09:52 GMT 2025