funfs/funfsd.cc

   1 #include "funfsd.h"
   2 #include "funfscodecs.h"
   3 #include "wvfshelpers.h"
   4
   5 #include <wvfork.h>
   6 #include <wvistreamlist.h>
   7
   8 #include <sys/stat.h>
   9 #include <dirent.h>
  10 #include <utime.h>
  11 #include <stdio.h>
  12 #include <fcntl.h>
  13
  14 #define GETPATH()                       \
  15     WvString path = getline(-1);        \
  16     assert(!!path)
  17
  18
  19 FunFSd::FunFSd(int port, bool _forkok)
  20     : forkok(_forkok), listener(WvIPPortAddr("0.0.0.0", port)),
  21     log("FunFSd", WvLog::Info)
  22 {
  23     log("Listening on port %s.\n", port);
  24
  25     listener.setcallback(WvStreamCallback(this, &FunFSd::callback_incoming), 0);
  26
  27     append(&listener, false);
  28 }
  29
  30
  31 bool FunFSd::isok() const
  32 {
  33     if (!listener.isok())
  34     {
  35         log(WvLog::Error, "%s.", listener.errstr());
  36         return false;
  37     }
  38     return true;
  39 }
  40
  41
  42 void FunFSd::callback_incoming(WvStream &, void *)
  43 {
  44     WvFDStream *s = listener.accept();
  45
  46     int pid = forkok ? wvfork(s->getfd()) : 0;
  47
  48     if (pid > 0)
  49     {
  50         delete s;
  51     }
  52     else if (pid == 0)
  53     {
  54         WvIStreamList::globallist.append(new FunFSdCon(s, forkok), true);
  55     }
  56     else
  57     {
  58         log(WvLog::Error, "Fork failed!\n");
  59     }
  60 }
  61
  62
  63 FunFSdCon::FunFSdCon(WvStream *s, bool _quit_on_disconnect)
  64     : WvStreamClone(s), quit_on_disconnect(_quit_on_disconnect),
  65     log(WvString("Client<%s>", *s->src()), WvLog::Debug2)
  66 {
  67     log(WvLog::Info, "Incoming connection.\n");
  68     uses_continue_select = true;
  69
  70     s->write("FunFS Server 0.0 ready\n");
  71
  72     setcallback(WvStreamCallback(this, &FunFSdCon::line_mode_execute), NULL);
  73 }
  74
  75
  76 FunFSdCon::~FunFSdCon()
  77 {
  78     close();
  79
  80     log(WvLog::Info, "Connection terminated.\n");
  81
  82     terminate_continue_select();
  83
  84     if (quit_on_disconnect)
  85         _exit(0);
  86 }
  87
  88
  89 void FunFSdCon::line_mode_execute(WvStream &, void *)
  90 {
  91     WvStream *&mycloned = (WvStream*)cloned;
  92
  93     // Switch to data mode
  94     mycloned->delay_output(true);
  95     setcallback(WvStreamCallback(this, &FunFSdCon::data_mode_execute), NULL);
  96 }
  97
  98
  99 void FunFSdCon::data_mode_execute(WvStream &, void *)
 100 {
 101     uint16 jobid = 0;
 102     uint8 jobtype = 0;
 103
 104     READ(jobid);
 105     READ(jobtype);
 106
 107     log(WvLog::Debug4, "jobid = %s, jobtype = %s\n", (int)jobid, (int)jobtype);
 108
 109     if (!isok())
 110         return;
 111
 112     assert(jobid);
 113
 114     // FIXME: parallelize replys
 115     cloned->write(SWAP16(&jobid), sizeof(jobid));
 116
 117     switch (jobtype)
 118     {
 119         case JT_GETATTR:
 120             handle_getattr();
 121             break;
 122         case JT_GETDIR:
 123             handle_getdir();
 124             break;
 125         case JT_READLINK:
 126             handle_readlink();
 127             break;
 128         case JT_READ:
 129             handle_read();
 130             break;
 131         case JT_STATFS:
 132             handle_statfs();
 133             break;
 134         case JT_OPEN:
 135             handle_open();
 136             break;
 137         case JT_RELEASE:
 138             handle_release();
 139             break;
 140         /*
 141         case JT_UTIME:
 142             handle_utime();
 143             break;
 144         case JT_LINK:
 145             handle_link();
 146             break;
 147         */
 148         default:
 149             break;
 150     }
 151
 152     flush_queued();
 153 }
 154
 155
 156 void FunFSdCon::flush_queued()
 157 {
 158     if (int c = queue.count())
 159         log("<BOB> Flushing %s queued message(s).\n", c);
 160
 161     WvList<WvDynBuf>::Iter i(queue);
 162     uint16 jobid = 0;
 163     for (i.rewind(); i.next(); )
 164     {
 165         cloned->write(&jobid, sizeof(jobid));
 166         write(*i);
 167     }
 168     queue.zap();
 169 }
 170
 171
 172 size_t FunFSdCon::write(WvBuf &inbuf, size_t count)
 173 {
 174     //fprintf(stderr, "wrote count %d\n", inbuf.used());
 175     uint32 clength = inbuf.used();
 176
 177     cloned->write(SWAP32(&clength), sizeof(clength));
 178     size_t r = cloned->write(inbuf);
 179
 180     cloned->flush(0);
 181
 182     inbuf.zap();
 183
 184     return r;
 185 }
 186
 187 void FunFSdCon::handle_getdir()
 188 {
 189     GETPATH();
 190     log("<GetDir> Read path: %s\n", path);
 191
 192     struct dirent *de;
 193     struct stat stbuf;
 194
 195     DIR *dp = opendir(path);
 196
 197     if (!dp)
 198     {
 199             uint16 err = errno;
 200             xoutbuf.put(SWAP16(&err), sizeof(err));
 201     }
 202     else
 203     {
 204         cim_mark_uptodate(path, JT_GETDIR);
 205     }
 206
 207     while (dp && (de = readdir(dp)) != NULL)
 208     {
 209         if (strcmp(de->d_name, ".") && strcmp(de->d_name, ".."))
 210         {
 211             WvString fullpath("%s/%s", path, de->d_name);
 212
 213             // Make sure we fill in the type field if libc didn't
 214             if (de->d_type == DT_UNKNOWN)
 215             {
 216                 if (!lstat(fullpath, &stbuf))
 217                 {
 218                     de->d_type = IFTODT(stbuf.st_mode);
 219                 }
 220                 else
 221                     fprintf(stderr, "Error stat'ing '%s': %s.\n",
 222                         WvString("%s/%s", path, de->d_name).cstr(),
 223                         strerror(errno));
 224             }
 225
 226             // Presend the information the client might be interested in
 227             switch (de->d_type)
 228             {
 229                 case DT_LNK:
 230                     enqueue(JT_READLINK, fullpath);
 231                 case DT_REG:
 232                     enqueue(JT_GETATTR, fullpath);
 233                     break;
 234                 case DT_UNKNOWN:
 235                     fprintf(stderr, "Still no type in getdir!\n");
 236                 default:
 237                     break;
 238             }
 239             encode_fuse_dirent(xoutbuf, de);
 240         }
 241     }
 242
 243     closedir(dp);
 244     write(xoutbuf);
 245 }
 246
 247 void FunFSdCon::enqueue(JobType type, WvStringParm path)
 248 {
 249     WvDynBuf *mybuf = new WvDynBuf();
 250
 251     mybuf->putch(type);
 252     mybuf->putstr(path);
 253     mybuf->putch('\0');
 254
 255     bool success = false;
 256
 257     switch (type)
 258     {
 259         case JT_READLINK:
 260             success = do_readlink(path, *mybuf);
 261             break;
 262         case JT_GETATTR:
 263             success = do_getattr(path, *mybuf);
 264             break;
 265         default:
 266             break;
 267     }
 268
 269     if (success)
 270     {
 271         queue.append(mybuf, true);
 272     }
 273     else
 274         delete mybuf;
 275 }
 276
 277 void FunFSdCon::handle_getattr()
 278 {
 279     GETPATH();
 280     log("<GetAttr> Read path: %s\n", path);
 281
 282     do_getattr(path, xoutbuf);
 283
 284     write(xoutbuf);
 285 }
 286
 287
 288 bool FunFSdCon::do_getattr(WvStringParm path, WvDynBuf &myoutbuf)
 289 {
 290     struct stat stbuf;
 291
 292     int res = lstat(path, &stbuf);
 293
 294     if (res < 0)
 295     {
 296         uint16 err = errno;
 297         myoutbuf.put(SWAP16(&err), sizeof(err));
 298     }
 299     else
 300     {
 301         fuse_attr attr;
 302         convert_stat(&stbuf, &attr);
 303         encode_fuse_attr(myoutbuf, &attr);
 304         cim_mark_uptodate(path, JT_GETATTR);
 305     }
 306
 307     return !res;
 308 }
 309
 310
 311 void FunFSdCon::handle_readlink()
 312 {
 313     GETPATH();
 314     log("<ReadLink> Read path: %s\n", path);
 315
 316     do_readlink(path, xoutbuf);
 317
 318     write(xoutbuf);
 319 }
 320
 321 bool FunFSdCon::do_readlink(WvStringParm path, WvDynBuf &myoutbuf)
 322 {
 323     char link[PATH_MAX];
 324
 325     int size = readlink(path, link, PATH_MAX);
 326
 327     uint16 err = (size >= 0 ? 0 : errno);
 328     myoutbuf.put(SWAP16(&err), sizeof(err));
 329
 330     if (size >= 0)
 331     {
 332         cim_mark_uptodate(path, JT_READLINK);
 333         myoutbuf.put(link, size);
 334         myoutbuf.putch('\0');
 335         return true;
 336     }
 337     return false;
 338 }
 339
 340 void FunFSdCon::handle_read()
 341 {
 342     int fd = 0;
 343     uint32 size = 0;
 344     uint32 offset = 0;
 345
 346     READ(fd);
 347     READ(size);
 348     READ(offset);
 349
 350     //fprintf(stderr, "fd = %d, size = %lu, offset = %lu\n", fd, size, offset);
 351
 352     int err = 0;
 353     int remaining = size;
 354
 355     int res = 0;
 356     char *tmpbuf = new char[size];
 357
 358     for (char *where = tmpbuf; remaining > 0; where += res,
 359             remaining -= res, offset += res)
 360     {
 361         res = ::pread(fd, where, remaining, offset);
 362
 363         if (res == -1)
 364             err = errno;
 365
 366         // Zero indicates end of file
 367         if (res <= 0)
 368             break;
 369     }
 370
 371     if (err)
 372         fprintf(stderr, "Error on read: %s\n", strerror(errno));
 373
 374     if (size - remaining)
 375         xoutbuf.put(tmpbuf, size - remaining);
 376
 377     //fprintf(stderr, "buf.used(): %d\n", buf.used());
 378
 379     delete[] tmpbuf;
 380
 381     write(xoutbuf);
 382 }
 383
 384 void FunFSdCon::handle_statfs()
 385 {
 386     struct statfs st;
 387
 388     // FIXME: this should use filesystem root
 389     int res = statfs("/",&st);
 390
 391     if (res < 0)
 392     {
 393         uint16 err = errno;
 394         xoutbuf.put(SWAP16(&err), sizeof(err));
 395     }
 396     else
 397     {
 398         fuse_kstatfs fst;
 399         convert_statfs(&st, &fst);
 400         encode_fuse_kstatfs(xoutbuf, &fst);
 401     }
 402
 403     write(xoutbuf);
 404 }
 405
 406 void FunFSdCon::handle_open()
 407 {
 408     GETPATH();
 409
 410     int flags;
 411     READ(flags);
 412
 413     int fd = ::open(path, flags);
 414
 415     if (fd >= 0)
 416     {
 417         cim_do_open(path, fd);
 418         xoutbuf.put(SWAP32(&fd), sizeof(fd));
 419     }
 420     else
 421     {
 422         uint16 err = errno;
 423         xoutbuf.put(SWAP16(&err), sizeof(err));
 424     }
 425
 426     write(xoutbuf);
 427 }
 428
 429 void FunFSdCon::handle_release()
 430 {
 431     int fd;
 432     READ(fd);
 433
 434     cim_do_close(fd);
 435
 436     ::close(fd);
 437     write(xoutbuf);
 438 }
 439
 440     /*
 441 void FunFSdCon::handle_link()
 442 {
 443     WvString from = getline(-1, '\0');
 444     assert(!!from);
 445     WvString to = getline(-1, '\0');
 446     assert(!!to);
 447
 448     int res = link(from, to);
 449
 450     PUTERRNO(res < 0);
 451
 452     write(xoutbuf);
 453 }
 454     */
 455
 456     /*
 457 void FunFSdCon::handle_utime()
 458 {
 459     WvString path = getline(-1, '\0');
 460
 461     if (!path)
 462         return;
 463
 464     log("<Utime>Read path: %s\n", path);
 465
 466     struct utimbuf utbuf;
 467
 468     int res = utime(path, &utbuf);
 469
 470     PUTERRNO(res < 0);
 471
 472     if (res == 0)
 473     {
 474         xoutbuf.put(SWAP32(&utbuf.actime), 32);
 475         xoutbuf.put(SWAP32(&utbuf.modtime), 32);
 476     }
 477
 478     write(xoutbuf);
 479 }
 480     */
 481
 482
 483 void FunFSdCon::file_changed(WvStringParm path)
 484 {
 485     log(WvLog::Debug4, "%s changed!\n");
 486 }
 487
 488
 489 void FunFSdCon::file_deleted(WvStringParm path)
 490 {
 491     log(WvLog::Debug4, "%s deleted!\n");
 492 }
 493
 494
 495 void FunFSdCon::file_created(WvStringParm path)
 496 {
 497     log(WvLog::Debug4, "%s created!\n");
 498 }
 499
 500