pkgbuilds/wiifuse/src/wiifuse-0.2.0/fs_client.c

   1 /*
   2  *  Copyright (C) 2008 dhewg, #wiidev efnet
   3  *
   4  *  this file is part of wiifuse
   5  *  http://wiibrew.org/index.php?title=Wiifuse
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, write to the Free Software
  19  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 #include <sys/types.h>
  23 #include <sys/stat.h>
  24 #include <unistd.h>
  25 #include <stdlib.h>
  26 #include <stdio.h>
  27 #include <string.h>
  28 #include <ctype.h>
  29 #include <errno.h>
  30
  31 #include "global.h"
  32 #include "client.h"
  33 #include "fs_client.h"
  34
  35 int fs_client_get_native_error (const enum remote_result result) {
  36         switch (result) {
  37         case RES_ENOENT:
  38                 return -ENOENT;
  39         case RES_ENOTDIR:
  40                 return -ENOTDIR;
  41         case RES_EISDIR:
  42                 return -EISDIR;
  43         case RES_EACCES:
  44                 return -EACCES;
  45         case RES_ENAMETOOLONG:
  46                 return -ENAMETOOLONG;
  47         default:
  48                 return -EFAULT;
  49         }
  50 }
  51
  52 void get_remote_attr (struct remote_attr *attributes, const u8 *data) {
  53         attributes->is_dir = data[0];
  54         attributes->nlink = get_be16 (&data[1]);
  55         attributes->size = get_be32 (&data[3]);
  56         attributes->owner = get_be32 (&data[7]);
  57         attributes->group = get_be32 (&data[11]);
  58         attributes->perms = get_be16 (&data[15]);
  59 }
  60
  61 void put_remote_attr (u8 *data, const struct remote_attr *attributes) {
  62         data[0] = attributes->is_dir;
  63         put_be16 (&data[1], attributes->nlink);
  64         put_be32 (&data[3], attributes->size);
  65         put_be32 (&data[7], attributes->owner);
  66         put_be32 (&data[11], attributes->group);
  67         put_be16 (&data[15], attributes->perms);
  68 }
  69
  70 void get_remote_perms (mode_t *mode, const u16 perms) {
  71         *mode = 0;
  72         if (perms & MODE_IRUSR)
  73                 *mode |= S_IRUSR;
  74         if (perms & MODE_IWUSR)
  75                 *mode |= S_IWUSR;
  76         if (perms & MODE_IXUSR)
  77                 *mode |= S_IXUSR;
  78
  79         if (perms & MODE_IRGRP)
  80                 *mode |= S_IRGRP;
  81         if (perms & MODE_IWGRP)
  82                 *mode |= S_IWGRP;
  83         if (perms & MODE_IXGRP)
  84                 *mode |= S_IXGRP;
  85
  86         if (perms & MODE_IROTH)
  87                 *mode |= S_IROTH;
  88         if (perms & MODE_IWOTH)
  89                 *mode |= S_IWOTH;
  90         if (perms & MODE_IXOTH)
  91                 *mode |= S_IXOTH;
  92 }
  93
  94 void put_remote_perms (u16 *perms, const mode_t mode) {
  95         *perms = 0;
  96         if (mode & S_IRUSR)
  97                 *perms |= MODE_IRUSR;
  98         if (mode & S_IWUSR)
  99                 *perms |= MODE_IWUSR;
 100         if (mode & S_IXUSR)
 101                 *perms |= MODE_IXUSR;
 102
 103         if (mode & S_IRGRP)
 104                 *perms |= MODE_IRGRP;
 105         if (mode & S_IWGRP)
 106                 *perms |= MODE_IWGRP;
 107         if (mode & S_IXGRP)
 108                 *perms |= MODE_IXGRP;
 109
 110         if (mode & S_IROTH)
 111                 *perms |= MODE_IROTH;
 112         if (mode & S_IWOTH)
 113                 *perms |= MODE_IWOTH;
 114         if (mode & S_IXOTH)
 115                 *perms |= MODE_IXOTH;
 116 }
 117
 118 int fs_client_access (const char *path, int mode) {
 119         struct server_response *r;
 120         int res;
 121         u8 data;
 122
 123         data = 0;
 124         if (mode & R_OK)
 125                 data |= ACCESS_R_OK;
 126         if (mode & W_OK)
 127                 data |= ACCESS_W_OK;
 128         if (mode & X_OK)
 129                 data |= ACCESS_X_OK;
 130
 131         r = client_request (CMD_FS_ACCESS, path, &data, 1);
 132         if (!r)
 133                 return -EFAULT;
 134
 135         if (r->result != RES_OK) {
 136                 res = fs_client_get_native_error (r->result);
 137                 client_free_response (r);
 138                 return res;
 139         }
 140
 141         client_free_response (r);
 142         return 0;
 143 }
 144
 145 int fs_client_getattr (const char *path, struct stat *stbuf) {
 146         struct server_response *r;
 147         int res;
 148         struct remote_attr attributes;
 149
 150         memset (stbuf, 0, sizeof (struct stat));
 151
 152         r = client_request (CMD_FS_GETATTR, path, NULL, 0);
 153
 154         if (!r)
 155                 return -EFAULT;
 156
 157         if (!r->data || r->data_size != 17) {
 158                 client_free_response (r);
 159                 return -ENOENT;
 160         }
 161
 162         if (r->result != RES_OK) {
 163                 res = fs_client_get_native_error (r->result);
 164                 client_free_response (r);
 165                 return res;
 166         }
 167
 168         get_remote_attr (&attributes, r->data);
 169         get_remote_perms (&(stbuf->st_mode), attributes.perms);
 170
 171         if (attributes.is_dir)
 172                 stbuf->st_mode |= S_IFDIR;
 173         else
 174                 stbuf->st_mode |= S_IFREG;
 175
 176         stbuf->st_nlink = attributes.nlink;
 177         stbuf->st_size = attributes.size;
 178         stbuf->st_blocks = attributes.size / 512;
 179         stbuf->st_uid = attributes.owner;
 180         stbuf->st_gid = attributes.group;
 181
 182         client_free_response (r);
 183         return 0;
 184 }
 185
 186 int fs_client_open (const char *path, struct fuse_file_info *fi) {
 187         struct server_response *r;
 188         int res;
 189
 190         (void) fi;
 191
 192         r = client_request (CMD_FS_OPEN, path, NULL, 0);
 193
 194         if (!r)
 195                 return -EFAULT;
 196
 197         if (r->result != RES_OK) {
 198                 res = fs_client_get_native_error (r->result);
 199                 client_free_response (r);
 200                 return res;
 201         }
 202
 203         client_free_response (r);
 204         return 0;
 205 }
 206
 207 int fs_client_read (const char *path, char *buf, size_t size,
 208                     off_t offset, struct fuse_file_info *fi) {
 209         struct server_response *r;
 210         u8 data[10];
 211         int bytes_read;
 212         int res;
 213
 214         (void) fi;
 215
 216         if (size > 0xffff)
 217                 return -EFAULT;
 218
 219         put_be16 (data, size);
 220         put_be64 (&data[2], offset);
 221
 222         r = client_request (CMD_FS_READ, path, data, 10);
 223
 224         if (!r)
 225                 return -EIO;
 226
 227         if (r->result != RES_OK) {
 228                 res = fs_client_get_native_error (r->result);
 229                 client_free_response (r);
 230                 return res;
 231         }
 232
 233         bytes_read = r->data_size;
 234
 235         if (bytes_read > 0)
 236                 memcpy (buf, r->data, bytes_read);
 237
 238         client_free_response (r);
 239         return bytes_read;
 240 }
 241
 242 int fs_client_opendir (const char *path, struct fuse_file_info *fi) {
 243         struct server_response *r;
 244         int res;
 245
 246         (void) fi;
 247
 248         r = client_request (CMD_FS_OPENDIR, path, NULL, 0);
 249
 250         if (!r)
 251                 return -EFAULT;
 252
 253         if (r->result != RES_OK) {
 254                 res = fs_client_get_native_error (r->result);
 255                 client_free_response (r);
 256                 return res;
 257         }
 258
 259         client_free_response (r);
 260         return 0;
 261 }
 262
 263 int fs_client_readdir (const char *path, void *buf, fuse_fill_dir_t filler,
 264                        off_t offset, struct fuse_file_info *fi) {
 265         struct server_response *r;
 266         char *p;
 267         size_t s;
 268         int res;
 269
 270         (void) offset;
 271         (void) fi;
 272
 273         r = client_request (CMD_FS_READDIR, path, NULL, 0);
 274
 275         if (!r)
 276                 return -EFAULT;
 277
 278         if (r->result != RES_OK) {
 279                 res = fs_client_get_native_error (r->result);
 280                 client_free_response (r);
 281                 return res;
 282         }
 283
 284         filler (buf, ".", NULL, 0);
 285         filler (buf, "..", NULL, 0);
 286
 287         if (r->data) {
 288                 p = (char *) r->data;
 289                 while (*p) {
 290                         s = strlen (p);
 291                         filler (buf, p, NULL, 0);
 292                         p += s + 1;
 293                 }
 294         }
 295
 296         client_free_response (r);
 297         return 0;
 298 }
 299
 300 int fs_client_mkdir (const char *path, mode_t mode) {
 301         struct server_response *r;
 302         int res;
 303         u16 perms;
 304         u8 data[2];
 305
 306         put_remote_perms (&perms, mode);
 307
 308         put_be16 (data, perms);
 309
 310         r = client_request (CMD_FS_MKDIR, path, data, 2);
 311
 312         if (!r)
 313                 return -EFAULT;
 314
 315         if (r->result != RES_OK) {
 316                 res = fs_client_get_native_error (r->result);
 317                 client_free_response (r);
 318                 return res;
 319         }
 320
 321         client_free_response (r);
 322         return 0;
 323 }
 324
 325 int fs_client_rmdir (const char *path) {
 326         struct server_response *r;
 327         int res;
 328
 329         r = client_request (CMD_FS_RMDIR, path, NULL, 0);
 330
 331         if (!r)
 332                 return -EFAULT;
 333
 334         if (r->result != RES_OK) {
 335                 res = fs_client_get_native_error (r->result);
 336                 client_free_response (r);
 337                 return res;
 338         }
 339
 340         client_free_response (r);
 341         return 0;
 342 }
 343
 344 int fs_client_create (const char *path, mode_t mode,
 345                       struct fuse_file_info *fi) {
 346         struct server_response *r;
 347         int res;
 348         u16 perms;
 349         u8 data[2];
 350
 351         (void) fi;
 352
 353         put_remote_perms (&perms, mode);
 354
 355         put_be16 (data, perms);
 356
 357         r = client_request (CMD_FS_CREATE, path, data, 2);
 358
 359         if (!r)
 360                 return -EFAULT;
 361
 362         if (r->result != RES_OK) {
 363                 res = fs_client_get_native_error (r->result);
 364                 client_free_response (r);
 365                 return res;
 366         }
 367
 368         client_free_response (r);
 369         return 0;
 370 }
 371
 372 int fs_client_write (const char *path, const char *buf, size_t size,
 373                      off_t offset, struct fuse_file_info *fi) {
 374         struct server_response *r;
 375         u8 *data;
 376         int bytes_written;
 377         int res;
 378
 379         (void) fi;
 380
 381         if (size > 0xffff)
 382                 return -EFAULT;
 383
 384         data = malloc (size + 10);
 385
 386         put_be16 (data, size);
 387         put_be64 (&data[2], offset);
 388         memcpy (&data[10], buf, size);
 389
 390         r = client_request (CMD_FS_WRITE, path, data, size + 10);
 391
 392         free (data);
 393
 394         if (!r)
 395                 return -EIO;
 396
 397         if (r->result != RES_OK) {
 398                 res = fs_client_get_native_error (r->result);
 399                 client_free_response (r);
 400                 return res;
 401         }
 402
 403         if (r->data_size != 8) {
 404                 client_free_response (r);
 405                 return -EIO;
 406         }
 407
 408         bytes_written = get_be64 (r->data);
 409
 410         client_free_response (r);
 411         return bytes_written;
 412 }
 413
 414 int fs_client_chown (const char *filename, uid_t uid, gid_t gid) {
 415         struct server_response *r;
 416         int res;
 417         u32 owner;
 418         u32 group;
 419         u8 data[8];
 420
 421         owner = uid;
 422         group = gid;
 423
 424         put_be32 (data, owner);
 425         put_be32 (&data[4], group);
 426
 427         r = client_request (CMD_FS_CHOWN, filename, data, 8);
 428
 429         if (!r)
 430                 return -EFAULT;
 431
 432         if (r->result != RES_OK) {
 433                 res = fs_client_get_native_error (r->result);
 434                 client_free_response (r);
 435                 return res;
 436         }
 437
 438         client_free_response (r);
 439         return 0;
 440 }
 441
 442 int fs_client_chmod (const char *filename, mode_t mode) {
 443         struct server_response *r;
 444         int res;
 445         u16 perms;
 446         u8 data[2];
 447
 448         put_remote_perms (&perms, mode);
 449         put_be16 (data, perms);
 450
 451         r = client_request (CMD_FS_CHMOD, filename, &data, 2);
 452
 453         if (!r)
 454                 return -EFAULT;
 455
 456         if (r->result != RES_OK) {
 457                 res = fs_client_get_native_error (r->result);
 458                 client_free_response (r);
 459                 return res;
 460         }
 461
 462         client_free_response (r);
 463         return 0;
 464 }
 465
 466 int fs_client_rename (const char *src, const char *dst) {
 467         struct server_response *r;
 468         int res;
 469
 470         r = client_request (CMD_FS_RENAME, src, dst, strlen (dst));
 471
 472         if (!r)
 473                 return -EFAULT;
 474
 475         if (r->result != RES_OK) {
 476                 res = fs_client_get_native_error (r->result);
 477                 client_free_response (r);
 478                 return res;
 479         }
 480
 481         client_free_response (r);
 482         return 0;
 483 }
 484
 485 int fs_client_unlink (const char *path) {
 486         struct server_response *r;
 487         int res;
 488
 489         r = client_request (CMD_FS_UNLINK, path, NULL, 0);
 490
 491         if (!r)
 492                 return -EFAULT;
 493
 494         if (r->result != RES_OK) {
 495                 res = fs_client_get_native_error (r->result);
 496                 client_free_response (r);
 497                 return res;
 498         }
 499
 500         client_free_response (r);
 501         return 0;
 502 }
 503
 504 int fs_client_statfs (const char *path, struct statvfs *svfs) {
 505         struct server_response *r;
 506         int res;
 507
 508         memset (svfs, 0, sizeof (struct statvfs));
 509
 510         r = client_request (CMD_FS_STATFS, path, NULL, 0);
 511
 512         if (!r)
 513                 return -EFAULT;
 514
 515         if (r->result != RES_OK) {
 516                 res = fs_client_get_native_error (r->result);
 517                 client_free_response (r);
 518                 return res;
 519         }
 520
 521         if (r->data_size != 5 * 8) {
 522                 client_free_response (r);
 523                 return -EIO;
 524         }
 525
 526         svfs->f_bsize = get_be64 (r->data);
 527         svfs->f_blocks = get_be64 (&(r->data[8]));
 528         svfs->f_bfree = get_be64 (&(r->data[16]));
 529         svfs->f_files = get_be64 (&(r->data[24]));
 530         svfs->f_ffree = get_be64 (&(r->data[32]));
 531
 532         client_free_response (r);
 533         return 0;
 534 }
 535
 536 void fs_client_destroy () {
 537         struct server_response *r;
 538
 539         r = client_request (CMD_UMOUNT, NULL, NULL, 0);
 540
 541         if (!r) {
 542                 LOG_ERR ("server did not ack the umount");
 543                 return;
 544         }
 545
 546         if (r->result != RES_OK)
 547                 LOG_ERR ("server did not umount (%d)", r->result);
 548
 549         client_free_response (r);
 550 }
 551
 552 void fs_client_get_ops (struct fuse_operations *fs_ops) {
 553         memset (fs_ops, 0, sizeof (struct fuse_operations));
 554
 555         fs_ops->access = fs_client_access;
 556         fs_ops->getattr = fs_client_getattr;
 557         fs_ops->open = fs_client_open;
 558         fs_ops->read = fs_client_read;
 559         fs_ops->opendir = fs_client_opendir;
 560         fs_ops->readdir = fs_client_readdir;
 561
 562         fs_ops->mkdir = fs_client_mkdir;
 563         fs_ops->unlink = fs_client_unlink;
 564         fs_ops->rmdir = fs_client_rmdir;
 565         fs_ops->chown = fs_client_chown;
 566         fs_ops->chmod = fs_client_chmod;
 567         fs_ops->rename = fs_client_rename;
 568         fs_ops->write = fs_client_write;
 569         fs_ops->create = fs_client_create;
 570
 571         fs_ops->statfs = fs_client_statfs;
 572
 573         fs_ops->destroy = fs_client_destroy;
 574 }
 575