subr.c revision 1.14.2.2
1 /* $NetBSD: subr.c,v 1.14.2.2 2012/05/23 10:07:32 yamt 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(struct puffs_usermount *pu, const char *name, 53 struct puffs_node *parent) 54 { 55 struct puffs_node *pn; 56 struct perfuse_node_data *pnd; 57 58 if ((pnd = malloc(sizeof(*pnd))) == NULL) 59 DERR(EX_OSERR, "%s: malloc failed", __func__); 60 61 if ((pn = puffs_pn_new(pu, pnd)) == NULL) 62 DERR(EX_SOFTWARE, "%s: puffs_pn_new failed", __func__); 63 64 (void)memset(pnd, 0, sizeof(*pnd)); 65 pnd->pnd_rfh = FUSE_UNKNOWN_FH; 66 pnd->pnd_wfh = FUSE_UNKNOWN_FH; 67 pnd->pnd_nodeid = PERFUSE_UNKNOWN_NODEID; 68 pnd->pnd_fuse_nlookup = 1; 69 pnd->pnd_puffs_nlookup = 1; 70 pnd->pnd_parent = parent; 71 pnd->pnd_pn = (puffs_cookie_t)pn; 72 (void)strlcpy(pnd->pnd_name, name, MAXPATHLEN); 73 TAILQ_INIT(&pnd->pnd_pcq); 74 TAILQ_INIT(&pnd->pnd_children); 75 76 if (parent != NULL) { 77 struct perfuse_node_data *parent_pnd; 78 79 parent_pnd = PERFUSE_NODE_DATA(parent); 80 TAILQ_INSERT_TAIL(&parent_pnd->pnd_children, pnd, pnd_next); 81 82 parent_pnd->pnd_childcount++; 83 } 84 85 return pn; 86 } 87 88 void 89 perfuse_destroy_pn(struct puffs_node *pn) 90 { 91 struct perfuse_node_data *pnd; 92 93 if ((pnd = puffs_pn_getpriv(pn)) != NULL) { 94 if (pnd->pnd_parent != NULL) { 95 struct perfuse_node_data *parent_pnd; 96 97 parent_pnd = PERFUSE_NODE_DATA(pnd->pnd_parent); 98 TAILQ_REMOVE(&parent_pnd->pnd_children, pnd, pnd_next); 99 100 PERFUSE_NODE_DATA(pnd->pnd_parent)->pnd_childcount--; 101 } 102 103 if (pnd->pnd_dirent != NULL) 104 free(pnd->pnd_dirent); 105 106 if (pnd->pnd_all_fd != NULL) 107 free(pnd->pnd_all_fd); 108 #ifdef PERFUSE_DEBUG 109 if (pnd->pnd_flags & PND_OPEN) 110 DERRX(EX_SOFTWARE, "%s: file open", __func__); 111 112 if (!TAILQ_EMPTY(&pnd->pnd_pcq)) 113 DERRX(EX_SOFTWARE, "%s: non empty pnd_pcq", __func__); 114 #endif /* PERFUSE_DEBUG */ 115 116 free(pnd); 117 } 118 119 puffs_pn_put(pn); 120 121 return; 122 } 123 124 125 void 126 perfuse_new_fh(puffs_cookie_t opc, uint64_t fh, int mode) 127 { 128 struct perfuse_node_data *pnd; 129 130 pnd = PERFUSE_NODE_DATA(opc); 131 132 if (mode & FWRITE) { 133 if (pnd->pnd_flags & PND_WFH) 134 DERRX(EX_SOFTWARE, "%s: opc = %p, write fh already set", 135 __func__, (void *)opc); 136 pnd->pnd_wfh = fh; 137 pnd->pnd_flags |= PND_WFH; 138 } 139 140 if (mode & FREAD) { 141 if (pnd->pnd_flags & PND_RFH) 142 DERRX(EX_SOFTWARE, "%s: opc = %p, read fh already set", 143 __func__, (void *)opc); 144 pnd->pnd_rfh = fh; 145 pnd->pnd_flags |= PND_RFH; 146 } 147 148 return; 149 } 150 151 void 152 perfuse_destroy_fh(puffs_cookie_t opc, uint64_t fh) 153 { 154 struct perfuse_node_data *pnd; 155 156 pnd = PERFUSE_NODE_DATA(opc); 157 158 if (fh == pnd->pnd_rfh) { 159 if (!(pnd->pnd_flags & PND_RFH) && (fh != FUSE_UNKNOWN_FH)) 160 DERRX(EX_SOFTWARE, 161 "%s: opc = %p, unset rfh = %"PRIx64"", 162 __func__, (void *)opc, fh); 163 pnd->pnd_rfh = FUSE_UNKNOWN_FH; 164 pnd->pnd_flags &= ~PND_RFH; 165 } 166 167 if (fh == pnd->pnd_wfh) { 168 if (!(pnd->pnd_flags & PND_WFH) && (fh != FUSE_UNKNOWN_FH)) 169 DERRX(EX_SOFTWARE, 170 "%s: opc = %p, unset wfh = %"PRIx64"", 171 __func__, (void *)opc, fh); 172 pnd->pnd_wfh = FUSE_UNKNOWN_FH; 173 pnd->pnd_flags &= ~PND_WFH; 174 } 175 176 return; 177 } 178 179 uint64_t 180 perfuse_get_fh(puffs_cookie_t opc, int mode) 181 { 182 struct perfuse_node_data *pnd; 183 184 pnd = PERFUSE_NODE_DATA(opc); 185 186 if (mode & FWRITE) { 187 if (pnd->pnd_flags & PND_WFH) 188 return pnd->pnd_wfh; 189 } 190 191 if (mode & FREAD) { 192 if (pnd->pnd_flags & PND_RFH) 193 return pnd->pnd_rfh; 194 195 if (pnd->pnd_flags & PND_WFH) 196 return pnd->pnd_wfh; 197 198 } 199 200 return FUSE_UNKNOWN_FH; 201 } 202 203 static size_t 204 node_path(puffs_cookie_t opc, char *buf, size_t buflen) 205 { 206 struct perfuse_node_data *pnd; 207 size_t written; 208 209 pnd = PERFUSE_NODE_DATA(opc); 210 if (pnd->pnd_parent == opc) 211 return 0; 212 213 written = node_path(pnd->pnd_parent, buf, buflen); 214 buf += written; 215 buflen -= written; 216 217 return written + snprintf(buf, buflen, "/%s", pnd->pnd_name); 218 } 219 220 char * 221 perfuse_node_path(puffs_cookie_t opc) 222 { 223 static char buf[MAXPATHLEN + 1]; 224 225 if (node_path(opc, buf, sizeof(buf)) == 0) 226 sprintf(buf, "/"); 227 228 return buf; 229 } 230 231 const char * 232 perfuse_native_ns(const int attrnamespace, const char *attrname, 233 char *fuse_attrname) 234 { 235 const struct perfuse_ns_map *pnm; 236 const struct perfuse_ns_map perfuse_ns_map[] = { 237 PERFUSE_NS_MAP("trusted", EXTATTR_NAMESPACE_SYSTEM), 238 PERFUSE_NS_MAP("security", EXTATTR_NAMESPACE_SYSTEM), 239 PERFUSE_NS_MAP("system", EXTATTR_NAMESPACE_SYSTEM), 240 PERFUSE_NS_MAP("user", EXTATTR_NAMESPACE_USER), 241 { NULL, 0, EXTATTR_NAMESPACE_USER }, 242 }; 243 244 /* 245 * If attribute has a reserved Linux namespace (e.g.: trusted.foo) 246 * and that namespace matches the requested native namespace 247 * we have nothing to do. 248 * Otherwise we have either: 249 * (system|trusted|security).* with user namespace: prepend user. 250 * anything else with system napespace: prepend system. 251 */ 252 for (pnm = perfuse_ns_map; pnm->pnm_ns; pnm++) { 253 if (strncmp(attrname, pnm->pnm_ns, pnm->pnm_nslen) != 0) 254 continue; 255 256 if (attrnamespace == pnm->pnm_native_ns) 257 return attrname; 258 259 /* (system|trusted|security).* with user namespace */ 260 if (attrnamespace == EXTATTR_NAMESPACE_USER) { 261 (void)snprintf(fuse_attrname, LINUX_XATTR_NAME_MAX, 262 "user.%s", attrname); 263 return (const char *)fuse_attrname; 264 } 265 } 266 267 /* anything else with system napespace */ 268 if (attrnamespace == EXTATTR_NAMESPACE_SYSTEM) { 269 (void)snprintf(fuse_attrname, LINUX_XATTR_NAME_MAX, 270 "system.%s", attrname); 271 return (const char *)fuse_attrname; 272 } 273 274 return (const char *)attrname; 275 } 276
Indexes created Thu Oct 02 14:10:14 GMT 2025