sys/vfs/fuse/fuse_util.c

   1 /*-
   2  * Copyright (c) 2019 Tomohiro Kusumi <tkusumi@netbsd.org>
   3  * Copyright (c) 2019 The DragonFly Project
   4  * 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 AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  */
  27
  28 #include "fuse.h"
  29
  30 void
  31 fuse_hexdump(const char *p, size_t len)
  32 {
  33         int i;
  34
  35         if (!fuse_debug)
  36                 return;
  37
  38         for (i = 0; i < (int)len; i++) {
  39                 kprintf("%02X ", p[i] & 0xff);
  40                 if ((i + 1) % 32 == 0)
  41                         kprintf("\n");
  42         }
  43         kprintf("\n");
  44 }
  45
  46 void
  47 fuse_fill_in_header(struct fuse_in_header *ihd,
  48     uint32_t len, uint32_t opcode, uint64_t unique, uint64_t nodeid,
  49     uint32_t uid, uint32_t gid, uint32_t pid)
  50 {
  51         ihd->len = len;
  52         ihd->opcode = opcode;
  53         ihd->unique = unique;
  54         ihd->nodeid = nodeid;
  55         ihd->uid = uid;
  56         ihd->gid = gid;
  57         ihd->pid = pid;
  58 }
  59
  60 int
  61 fuse_forget_node(struct fuse_mount *fmp, uint64_t ino, uint64_t nlookup,
  62     struct ucred *cred)
  63 {
  64         struct fuse_ipc *fip;
  65         struct fuse_forget_in *ffi;
  66         int error;
  67
  68         KKASSERT(nlookup > 0);
  69
  70         fip = fuse_ipc_get(fmp, sizeof(*ffi));
  71         ffi = fuse_ipc_fill(fip, FUSE_FORGET, ino, cred);
  72         ffi->nlookup = nlookup;
  73
  74         error = fuse_ipc_tx_noreply(fip);
  75         if (error)
  76                 return error;
  77         fuse_ipc_put(fip);
  78
  79         return 0;
  80 }
  81
  82 /*
  83  * Ignore FUSE_COMPAT_XXX which seem to exist for backward compatibility
  84  * for ancient versions of FUSE protocol.
  85  */
  86 int
  87 fuse_audit_length(struct fuse_in_header *ihd, struct fuse_out_header *ohd)
  88 {
  89         size_t len = ohd->len - sizeof(struct fuse_out_header);
  90         bool res;
  91
  92         switch (ihd->opcode) {
  93         case FUSE_LOOKUP:
  94                 res = (len == sizeof(struct fuse_entry_out));
  95                 break;
  96         case FUSE_FORGET:
  97                 res = true;
  98                 break;
  99         case FUSE_GETATTR:
 100                 res = (len == sizeof(struct fuse_attr_out));
 101                 break;
 102         case FUSE_SETATTR:
 103                 res = (len == sizeof(struct fuse_attr_out));
 104                 break;
 105         case FUSE_READLINK:
 106                 res = (len <= PAGE_SIZE);
 107                 break;
 108         case FUSE_SYMLINK:
 109                 res = (len == sizeof(struct fuse_entry_out));
 110                 break;
 111         case FUSE_MKNOD:
 112                 res = (len == sizeof(struct fuse_entry_out));
 113                 break;
 114         case FUSE_MKDIR:
 115                 res = (len == sizeof(struct fuse_entry_out));
 116                 break;
 117         case FUSE_UNLINK:
 118                 res = (len == 0);
 119                 break;
 120         case FUSE_RMDIR:
 121                 res = (len == 0);
 122                 break;
 123         case FUSE_RENAME:
 124                 res = (len == 0);
 125                 break;
 126         case FUSE_LINK:
 127                 res = (len == sizeof(struct fuse_entry_out));
 128                 break;
 129         case FUSE_OPEN:
 130                 res = (len == sizeof(struct fuse_open_out));
 131                 break;
 132         case FUSE_READ:
 133                 res = (len <= ((struct fuse_read_in*)(ihd + 1))->size);
 134                 break;
 135         case FUSE_WRITE:
 136                 res = (len == sizeof(struct fuse_write_out));
 137                 break;
 138         case FUSE_STATFS:
 139                 res = (len == sizeof(struct fuse_statfs_out));
 140                 break;
 141         case FUSE_RELEASE:
 142                 res = (len == 0);
 143                 break;
 144         case FUSE_FSYNC:
 145                 res = (len == 0);
 146                 break;
 147         case FUSE_SETXATTR:
 148                 res = (len == 0);
 149                 break;
 150         case FUSE_GETXATTR:
 151                 res = true;
 152                 break;
 153         case FUSE_LISTXATTR:
 154                 res = true;
 155                 break;
 156         case FUSE_REMOVEXATTR:
 157                 res = (len == 0);
 158                 break;
 159         case FUSE_FLUSH:
 160                 res = (len == 0);
 161                 break;
 162         case FUSE_INIT:
 163                 res = (len == sizeof(struct fuse_init_out));
 164                 break;
 165         case FUSE_OPENDIR:
 166                 res = (len == sizeof(struct fuse_open_out));
 167                 break;
 168         case FUSE_READDIR:
 169                 res = (len <= ((struct fuse_read_in*)(ihd + 1))->size);
 170                 break;
 171         case FUSE_RELEASEDIR:
 172                 res = (len == 0);
 173                 break;
 174         case FUSE_FSYNCDIR:
 175                 res = (len == 0);
 176                 break;
 177         case FUSE_GETLK:
 178                 res = false;
 179                 break;
 180         case FUSE_SETLK:
 181                 res = false;
 182                 break;
 183         case FUSE_SETLKW:
 184                 res = false;
 185                 break;
 186         case FUSE_ACCESS:
 187                 res = (len == 0);
 188                 break;
 189         case FUSE_CREATE:
 190                 res = (len == sizeof(struct fuse_entry_out) +
 191                     sizeof(struct fuse_open_out));
 192                 break;
 193         case FUSE_INTERRUPT:
 194                 res = false;
 195                 break;
 196         case FUSE_BMAP:
 197                 res = false;
 198                 break;
 199         case FUSE_DESTROY:
 200                 res = (len == 0);
 201                 break;
 202         case FUSE_IOCTL:
 203                 res = false;
 204                 break;
 205         case FUSE_POLL:
 206                 res = false;
 207                 break;
 208         case FUSE_NOTIFY_REPLY:
 209                 res = false;
 210                 break;
 211         case FUSE_BATCH_FORGET:
 212                 res = false;
 213                 break;
 214         case FUSE_FALLOCATE:
 215                 res = false;
 216                 break;
 217         case FUSE_READDIRPLUS:
 218                 res = false;
 219                 break;
 220         case FUSE_RENAME2:
 221                 res = false;
 222                 break;
 223         case FUSE_LSEEK:
 224                 res = false;
 225                 break;
 226         case FUSE_COPY_FILE_RANGE:
 227                 res = false;
 228                 break;
 229         default:
 230                 fuse_panic("Invalid opcode %d", ihd->opcode);
 231                 break;
 232         }
 233
 234         if (!res)
 235                 return -1;
 236         return 0;
 237 }
 238
 239 const char*
 240 fuse_get_ops(int op)
 241 {
 242         switch (op) {
 243         case FUSE_LOOKUP:
 244                 return "FUSE_LOOKUP";
 245         case FUSE_FORGET:
 246                 return "FUSE_FORGET";
 247         case FUSE_GETATTR:
 248                 return "FUSE_GETATTR";
 249         case FUSE_SETATTR:
 250                 return "FUSE_SETATTR";
 251         case FUSE_READLINK:
 252                 return "FUSE_READLINK";
 253         case FUSE_SYMLINK:
 254                 return "FUSE_SYMLINK";
 255         case FUSE_MKNOD:
 256                 return "FUSE_MKNOD";
 257         case FUSE_MKDIR:
 258                 return "FUSE_MKDIR";
 259         case FUSE_UNLINK:
 260                 return "FUSE_UNLINK";
 261         case FUSE_RMDIR:
 262                 return "FUSE_RMDIR";
 263         case FUSE_RENAME:
 264                 return "FUSE_RENAME";
 265         case FUSE_LINK:
 266                 return "FUSE_LINK";
 267         case FUSE_OPEN:
 268                 return "FUSE_OPEN";
 269         case FUSE_READ:
 270                 return "FUSE_READ";
 271         case FUSE_WRITE:
 272                 return "FUSE_WRITE";
 273         case FUSE_STATFS:
 274                 return "FUSE_STATFS";
 275         case FUSE_RELEASE:
 276                 return "FUSE_RELEASE";
 277         case FUSE_FSYNC:
 278                 return "FUSE_FSYNC";
 279         case FUSE_SETXATTR:
 280                 return "FUSE_SETXATTR";
 281         case FUSE_GETXATTR:
 282                 return "FUSE_GETXATTR";
 283         case FUSE_LISTXATTR:
 284                 return "FUSE_LISTXATTR";
 285         case FUSE_REMOVEXATTR:
 286                 return "FUSE_REMOVEXATTR";
 287         case FUSE_FLUSH:
 288                 return "FUSE_FLUSH";
 289         case FUSE_INIT:
 290                 return "FUSE_INIT";
 291         case FUSE_OPENDIR:
 292                 return "FUSE_OPENDIR";
 293         case FUSE_READDIR:
 294                 return "FUSE_READDIR";
 295         case FUSE_RELEASEDIR:
 296                 return "FUSE_RELEASEDIR";
 297         case FUSE_FSYNCDIR:
 298                 return "FUSE_FSYNCDIR";
 299         case FUSE_GETLK:
 300                 return "FUSE_GETLK";
 301         case FUSE_SETLK:
 302                 return "FUSE_SETLK";
 303         case FUSE_SETLKW:
 304                 return "FUSE_SETLKW";
 305         case FUSE_ACCESS:
 306                 return "FUSE_ACCESS";
 307         case FUSE_CREATE:
 308                 return "FUSE_CREATE";
 309         case FUSE_INTERRUPT:
 310                 return "FUSE_INTERRUPT";
 311         case FUSE_BMAP:
 312                 return "FUSE_BMAP";
 313         case FUSE_DESTROY:
 314                 return "FUSE_DESTROY";
 315         case FUSE_IOCTL:
 316                 return "FUSE_IOCTL";
 317         case FUSE_POLL:
 318                 return "FUSE_POLL";
 319         case FUSE_NOTIFY_REPLY:
 320                 return "FUSE_NOTIFY_REPLY";
 321         case FUSE_BATCH_FORGET:
 322                 return "FUSE_BATCH_FORGET";
 323         case FUSE_FALLOCATE:
 324                 return "FUSE_FALLOCATE";
 325         case FUSE_READDIRPLUS:
 326                 return "FUSE_READDIRPLUS";
 327         case FUSE_RENAME2:
 328                 return "FUSE_RENAME2";
 329         case FUSE_LSEEK:
 330                 return "FUSE_LSEEK";
 331         case FUSE_COPY_FILE_RANGE:
 332                 return "FUSE_COPY_FILE_RANGE";
 333         default:
 334                 fuse_panic("Invalid opcode %d", op);
 335                 break;
 336         }
 337
 338         return NULL;
 339 }